用於 SELECT 和 WHERE 子句的函數，select子句
1 一個 SQL 語句中的 select_expression 或 where_definition 可由任何使用了下面所描述函數的表達式組成。
2
3 包含 NULL 的表達式總是得出一個 NULL 值結果，除非表達式中的操作和函數在文檔中有另外的說明。
4
5 注意：在一個函數名和跟隨它的括號之間必須不存在空格。這有助於 MySQL 語法分析程序區分函數調用和對恰巧與函數同名表或列的引用。然而，參數左右兩邊的空格卻是允許的。
6
7 你可以強制 MySQL 接受函數名後存在空格的形式，這需要通過以 --ansi 選項啟動 mysqld，或在 mysql_connect() 中使用 CLIENT_IGNORE_SPACE，但是，在這種情況下，所有的函數名均將成為保留字。查看章節 1.8.2 以 ANSI 模式運行 MySQL.
8
9 為了簡潔，從 mysql 程序輸出的例子以縮寫的形式顯示。因此：
10
11 mysql> SELECT MOD(29,9);
12 1 rows in set (0.00 sec)
13
14 +-----------+
15 | mod(29,9) |
16 +-----------+
17 | 2 |
18 +-----------+
19
20 將被顯示為這樣：
21
22 mysql> SELECT MOD(29,9);
23 -> 2
24
25 6.3.1 無類型的特殊運算符和函數
26 6.3.1.1 圓括號
27 ( ... )
28
29 括號，使用它來強制一個表達式的計算順序。
30
31 mysql> SELECT 1+2*3;
32 -> 7
33 mysql> SELECT (1+2)*3;
34 -> 9
35
36 6.3.1.2 比較運算符
37 比較運算符的結果是 1 (TRUE)、0 (FALSE) 或 NULL。這些函數可工作於數字和字符串上。根據需要，字符串將會自動地被轉換到數字，以及數字被轉換成字符串(比如在 Perl 中)。
38
39 MySQL 使用下列規則進行比較：
40
41 如果一個或兩個參數是 NULL，比較的結果是 NULL，除了 <=> 運算符。
42 如果在一個比較操作中兩個參數均是字符串，他們將作為字符串被比較。
43 如果兩個參數均是整數，他們作為整數被比較。
44 十六進制值如果不與一個數字進行比較，那麼它將當作一個二進制字符串。
45 如果參數之一是一個 TIMESTAMP 或 DATETIME 列，而另一參數是一個常數，在比較執行之前，這個常數被轉換為一個時間戳。這樣做是為了對 ODBC 更友好。
46 在所有其它情況下，參數作為浮點(real)數字被比較。
47 缺省地，字符串使用當前字符集以忽略字母大小寫的方式進行比較(缺省的字符集為 ISO-8859-1 Latin1，它對英語處理得很出色)。
48
49 下面的例子演示了對於比較操作字符串到數字的轉換：
50
51 mysql> SELECT 1 > '6x';
52 -> 0
53 mysql> SELECT 7 > '6x';
54 -> 1
55 mysql> SELECT 0 > 'x6';
56 -> 0
57 mysql> SELECT 0 = 'x6';
58 -> 1
59
60 =
61 等於：
62 mysql> SELECT 1 = 0;
63 -> 0
64 mysql> SELECT '0' = 0;
65 -> 1
66 mysql> SELECT '0.0' = 0;
67 -> 1
68 mysql> SELECT '0.01' = 0;
69 -> 0
70 mysql> SELECT '.01' = 0.01;
71 -> 1
72
73 <>
74 !=
75 不等於：
76 mysql> SELECT '.01' <> '0.01';
77 -> 1
78 mysql> SELECT .01 <> '0.01';
79 -> 0
80 mysql> SELECT 'zapp' <> 'zappp';
81 -> 1
82
83 <=
84 小於或等於：
85 mysql> SELECT 0.1 <= 2;
86 -> 1
87
88 <
89 小於：
90 mysql> SELECT 2 < 2;
91 -> 0
92
93 >=
94 大於或等於：
95 mysql> SELECT 2 >= 2;
96 -> 1
97
98 >
99 大於：
100 mysql> SELECT 2 > 2;
101 -> 0
102
103 <=>
104 NULL 值安全等於：
105 mysql> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
106 -> 1 1 0
107
108 IS NULL
109 IS NOT NULL
110 測試一個值是或不是 NULL:
111 mysql> SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL;
112 -> 0 0 1
113 mysql> SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;
114 -> 1 1 0
115
116 為了能夠與其它程序更好的工作，在使用 IS NULL 是 MySQL 支持下列額外選擇性：
117 通過它，你可以找到最後插入的記錄行：
118 SELECT * FROM tbl_name WHERE auto_col IS NULL
119
120 這個操作可以通過設置 SQL_AUTO_IS_NULL=0 來禁止。查看章節 5.5.6 SET 句法.
121 對於 NOT NULL 的 DATE 和 DATETIME 列，可以通過使用下列語句找到特殊的值 0000-00-00：
122 SELECT * FROM tbl_name WHERE date_column IS NULL
123
124 這需要通過某些 ODBC 應用程序才能工作(因為 ODBC 不支持一個 0000-00-00 日期)
125
126 expr BETWEEN min AND max
127 如果 expr 大於或等於 min ，並且 expr 小於或等於 max，BETWEEN 返回 1，否則返回 0。它等價於表達式 (min <= expr AND expr <= max) ，只要所有的參數均是相同的類型。 否則類型會依照上面的規則發生轉換，但是應用於所有三個參數。注意，在 MySQL 4.0.5 之前，參數被轉換到 expr 的類型。
128 mysql> SELECT 1 BETWEEN 2 AND 3;
129 -> 0
130 mysql> SELECT 'b' BETWEEN 'a' AND 'c';
131 -> 1
132 mysql> SELECT 2 BETWEEN 2 AND '3';
133 -> 1
134 mysql> SELECT 2 BETWEEN 2 AND 'x-3';
135 -> 0
136
137 expr NOT BETWEEN min AND max
138 等同於 NOT (expr BETWEEN min AND max)。
139
140 expr IN (value,...)
141 如果 expr 是 IN 列表中的作一值，它將返回 1，否則返回 0。如果所有的值均是常數，那麼所有的值被依照 expr 的類型進行計算和排序。然後以一個二進制搜索方式完成項目的搜索。這就意味著，如果 IN 列表完全由常數組成，IN 將是非常快的。如果 expr 是一個字母大小寫敏感的字符串表達式，字符串比較將以大小寫敏感方式執行：
142 mysql> SELECT 2 IN (0,3,5,'wefwf');
143 -> 0
144 mysql> SELECT 'wefwf' IN (0,3,5,'wefwf');
145 -> 1
146
147 從 MySQL 4.1 開始(符合 SQL-99 標准)，如果左手邊的表達式是 NULL，或者在列表中沒有發現相匹配的值並且列表中的一個表達式是 NULL，IN 均返回 NULL。
148
149 expr NOT IN (value,...)
150 等同於 NOT (expr IN (value,...))。
151
152 ISNULL(expr)
153 如果 expr 是 NULL，ISNULL() 返回 1，否則返回 0：
154 mysql> SELECT ISNULL(1+1);
155 -> 0
156 mysql> SELECT ISNULL(1/0);
157 -> 1
158
159 注意，對 NULL 值使用 = 進行比較總是為 false ！
160 COALESCE(list)
161 返回列表中第一個非 NULL 的元素：
162 mysql> SELECT COALESCE(NULL,1);
163 -> 1
164 mysql> SELECT COALESCE(NULL,NULL,NULL);
165 -> NULL
166
167 INTERVAL(N,N1,N2,N3,...)
168 Returns 如果 N < N1 返回 0，如果 N < N2 返回 1，等等。所有的參數均被當作整數。為了函數能正確地工作，它要求 N1 < N2 < N3 < ... < Nn。這是因為它使用的是一個二進制的搜索(非常地快)：
169 mysql> SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200);
170 -> 3
171 mysql> SELECT INTERVAL(10, 1, 10, 100, 1000);
172 -> 2
173 mysql> SELECT INTERVAL(22, 23, 30, 44, 200);
174 -> 0
175
176 如果以任何一個標准運算符(=, <>..., 但除了 LIKE)對一個忽略大小寫的字符串進行比較，尾部的空白空間(空格、TAB 和換行)均被忽略。
177
178 mysql> SELECT "a" ="A \n";
179 -> 1
180
181 6.3.1.3 邏輯運算符
182
183 在 SQL 中，所有的邏輯運算符返回的值均為 TRUE、FALSE 或 NULL (未知)。在 MySQL 中，它們由 1 (TRUE)、0 (FALSE) 和 NULL 實現。這些大部分在不同的 SQL 數據庫間是相同的，然而某些可能會以一個非零值返回 TRUE。
184
185 NOT
186 !
187 邏輯非。如果操作數為 0，返回 1；如果操作數為非零，返回 0；如果操作數為 NOT NULL，返回 NULL。
188 mysql> SELECT NOT 10;
189 -> 0
190 mysql> SELECT NOT 0;
191 -> 1
192 mysql> SELECT NOT NULL;
193 -> NULL
194 mysql> SELECT ! (1+1);
195 -> 0
196 mysql> SELECT ! 1+1;
197 -> 1
198
199 最後一個例子返回 1，因為表達式是與 (!1)+1 一樣被計算的。
200
201 AND
202 &&
203 邏輯與。如果所有的操作數都是非零或非 NULL 的，返回 1；如果有一個或多個操作數為 0 ，則返回 0，只要操作數中有 NULL 返回值就為 NULL。
204 mysql> SELECT 1 && 1;
205 -> 1
206 mysql> SELECT 1 && 0;
207 -> 0
208 mysql> SELECT 1 && NULL;
209 -> NULL
210 mysql> SELECT 0 && NULL;
211 -> 0
212 mysql> SELECT NULL && 0;
213 -> 0
214
215 請注意，在 MySQL 4.0.5 以前版本中，當遇到一個 NULL 時就停止計算，而不是繼續進程檢查可能存在的0。這就意味著，在這些版本中，SELECT (NULL AND 0) 返回 NULL，而不是 0。在 4.0.5 中，代碼已被重新設計了，已便於在任何仍然使用優化情況下，返回值總是能如 ANSI 所規定的那樣。
216 OR
217 ||
218 邏輯或。如果任何一個操作數是非零的，返回值為 1，如果任一操作數為 NULL，返回值為 NULL，否則返回 0。
219 mysql> SELECT 1 || 1;
220 -> 1
221 mysql> SELECT 1 || 0;
222 -> 1
223 mysql> SELECT 0 || 0;
224 -> 0
225 mysql> SELECT 0 || NULL;
226 -> NULL
227 mysql> SELECT 1 || NULL;
228 -> 1
229
230 XOR
231 邏輯異或。如果任一操作數為 NULL，返回值為 NULL。對於非 NULL 的操作數，如果有奇數個非零的操作數，結果返回為 1，否則返回 0。
232 mysql> SELECT 1 XOR 1;
233 -> 0
234 mysql> SELECT 1 XOR 0;
235 -> 1
236 mysql> SELECT 1 XOR NULL;
237 -> NULL
238 mysql> SELECT 1 XOR 1 XOR 1;
239 -> 1
240
241 a XOR b 算術相等於 (a AND (NOT b)) OR ((NOT a) and b)。 XOR 在 MySQL 4.0.2 中被添加。
242 6.3.1.4 控制流函數
243
244 IFNULL(expr1,expr2)
245 如果 expr1 為非 NULL 的，IFNULL() 返回 expr1，否則返回 expr2。IFNULL() 返回一個數字或字符串值，這取決於它被使用的語境：
246 mysql> SELECT IFNULL(1,0);
247 -> 1
248 mysql> SELECT IFNULL(NULL,10);
249 -> 10
250 mysql> SELECT IFNULL(1/0,10);
251 -> 10
252 mysql> SELECT IFNULL(1/0,'yes');
253 -> 'yes'
254
255 在 MySQL 4.0.6 和更新版本中，IFNULL(expr1,expr2) 的默認返回值以 STRING、REAL 或 INTEGER 順序更加'general'了兩個表達式。當你基於一個表達式創建一個表或在一個臨時表中 MySQL 不得不存儲一個從 IFNULL() 返回的值時，這個與較早 MySQL 版本的不同將更加值得注意。
256 CREATE TABLE foo SELECT IFNULL(1,"test") as test;
257
258 在 MySQL 4.0.6 中，列 'test' 的類型為 CHAR(4)，然而在較早的版本中，你得到的卻是 BIGINT。
259
260 NULLIF(expr1,expr2)
261 如果 expr1 = expr2 為真，返回 NULL，否則返回 expr1。它等同於 CASE WHEN x = y THEN NULL ELSE x END：
262 mysql> SELECT NULLIF(1,1);
263 -> NULL
264 mysql> SELECT NULLIF(1,2);
265 -> 1
266
267 注意，如果參數不相等，在 MySQL 中，expr1 被求值兩次。
268
269 IF(expr1,expr2,expr3)
270 如果 expr1 為真(expr1 <> 0 以及 expr1 <> NULL)，那麼 IF() 返回 expr2，否則返回 expr3。IF() 返回一個數字或字符串，這取決於它被使用的語境：
271 mysql> SELECT IF(1>2,2,3);
272 -> 3
273 mysql> SELECT IF(1<2,'yes','no');
274 -> 'yes'
275 mysql> SELECT IF(STRCMP('test','test1'),'no','yes');
276 -> 'no'
277
278 如果 expr2 或 expr3 明確地為 NULL，那麼函數 IF() 的返回值類型為非 NULL 列的類型。(這在選擇在 MySQL 4.0.3 中新加入)。 expr1 是作為一個整數值被計算的，這就意味著，如果測試的是一個浮點型或字符串值，就必須進行比較操作：
279 mysql> SELECT IF(0.1,1,0);
280 -> 0
281 mysql> SELECT IF(0.1<>0,1,0);
282 -> 1
283
284 在上面第一種情況下，IF(0.1) 返回 0，是因為 0.1 被轉換為一個整數值，返回 IF(0) 的測試結果。這可能不是你所期望的。在第二種情況下，比較測試原浮點數是否為一個非零值。比較的結果被作為整數使用。 缺省的 IF() 返回值類型 (當結果存儲在臨時表中時，這是非常重要的) 在 MySQL 3.23 中按下列方式確定： 表達式 返回值
285 表達式(expr2)或表達式(expr3)返回值為字符串 字符串
286 表達式(expr2)或表達式(expr3)返回值為浮點型值 浮點型
287 表達式(expr2)或表達式(expr3)返回值為整型 整型
288 如果表達式(expr2)和表達式(expr3)均是字符串，同時兩個字符串均是忽略字母大小寫的，那麼返回值也是忽略字母大小寫的(從 MySQL 3.23.51 開始)。
289
290 CASE value WHEN [compare-value] THEN result [WHEN [compare-value] THEN result ...] [ELSE result] END
291 CASE WHEN [condition] THEN result [WHEN [condition] THEN result ...] [ELSE result] END
292 第一個形式當 value=compare-value 時返回 result。第二個形式當第一個為真值的 condition 出現時，返回該條件的結果。如果沒有匹配的結果值，那麼 ELSE 後的結果將被返回。如果沒有 ELSE 部分，那麼 NULL 被返回：
293 mysql> SELECT CASE 1 WHEN 1 THEN "one"
294 WHEN 2 THEN "two" ELSE "more" END;
295 -> "one"
296 mysql> SELECT CASE WHEN 1>0 THEN "true" ELSE "false" END;
297 -> "true"
298 mysql> SELECT CASE BINARY "B" WHEN "a" THEN 1 WHEN "b" THEN 2 END;
299 -> NULL
300
301 返回值的類型 (INTEGER、DOUBLE 或 STRING) 與第一個返回值(第一個 THEN 後的表達式)的類型相同。
302
303 6.3.2 字符串函數
304
305 如果返回結果的長度超過服務器參數 max_allowed_packet 的大小，字符串值函數將返回 NULL。查看章節 5.5.2 調節服務器參數。
306
307 對於操作字符串位置的函數，第一個位置被標記為 1。
308
309 ASCII(str)
310 返回字符串 str 最左邊的那個字符的 ASCII 碼值。如果 str 是一個空字符串，那麼返回值為 0。如果 str 是一個 NULL，返回值也是 NULL：
311 mysql> SELECT ASCII('2');
312 -> 50
313 mysql> SELECT ASCII(2);
314 -> 50
315 mysql> SELECT ASCII('dx');
316 -> 100
317
318 也可參看 ORD() 函數。
319
320 ORD(str)
321 如果字符串 str 的最左邊的字符是一個多字節的字符，根據多字節字符的成分字符的 ASCII 碼值通過下面的公式計算返回那個的編碼：((first byte ASCII code)*256+(second byte ASCII code))[*256+third byte ASCII code...]。如果最左邊的字符不是一個多字節字符，返回值與 ASCII() 函數相同：
322 mysql> SELECT ORD('2');
323 -> 50
324
325 CONV(N,from_base,to_base)
326 在不同的數字基數之間轉換數字。將數字 N 從 from_base 轉換到 to_base，並以字符串表示形式返回。如果任何一個參數為 NULL，那麼返回值也為 NULL。參數 N 被解釋為是一個整數，但是也可以被指定為一個整數或一個字符串。最小基為 2，最大基為 36。如果 to_base 是一個負值，N 將被看作為是一個有符號數字。否則，N 被視為是無符號的。CONV 以 64 位精度工作：
327 mysql> SELECT CONV("a",16,2);
328 -> '1010'
329 mysql> SELECT CONV("6E",18,8);
330 -> '172'
331 mysql> SELECT CONV(-17,10,-18);
332 -> '-H'
333 mysql> SELECT CONV(10+"10"+'10'+0xa,10,10);
334 -> '40'
335
336 BIN(N)
337 返回 N 的字符串表示的二進制值形式，在這裡，N 長長的(BIGINT)數字。這個函數等價於 CONV(N,10,2)。如果 N 是一個 NULL，返回值也是 NULL：
338 mysql> SELECT BIN(12);
339 -> '1100'
340
341 OCT(N)
342 返回 N 的字符串表示的八進制值形式，在這裡，N 是一個長長的數字。這個函數等價於 CONV(N,10,8)。如果 N 是一個 NULL，返回值也是 NULL ：
343 mysql> SELECT OCT(12);
344 -> '14'
345
346 HEX(N_or_S)
347 如果 N_OR_S 是一個數字，返回 N 的字符串表示的十六進制值形式，這裡 N 是一個長長的(BIGINT)數字。這個函數等價於 CONV(N,10,16)。 如果 N_OR_S 是一個字符串，N_OR_S 中的每個字符均被轉換為 2 位十六進制數字，並以十六進制的字符串形式返回。這是 0xff 形式的字符串反轉操作。
348 mysql> SELECT HEX(255);
349 -> 'FF'
350 mysql> SELECT HEX("abc");
351 -> 616263
352 mysql> SELECT 0x616263;
353 -> "abc"
354
355 CHAR(N,...)
356 CHAR() 以整數類型解釋參數，返回這個整數所代表的 ASCII 碼值給出的字符組成的字符串。NULL 值將被忽略：
357 mysql> SELECT CHAR(77,121,83,81,'76');
358 -> 'MySQL'
359 mysql> SELECT CHAR(77,77.3,'77.3');
360 -> 'MMM'
361
362 CONCAT(str1,str2,...)
363 將參數連接成字符串返回。如果有任何一個參數為 NULL，返回值也為 NULL。可以有超過 2 個的參數。數字參數將被轉換為相等價的字符串形式：
364 mysql> SELECT CONCAT('My', 'S', 'QL');
365 -> 'MySQL'
366 mysql> SELECT CONCAT('My', NULL, 'QL');
367 -> NULL
368 mysql> SELECT CONCAT(14.3);
369 -> '14.3'
370
371 CONCAT_WS(separator, str1, str2,...)
372 CONCAT_WS() 支持 CONCAT 加上一個分隔符，它是一個特殊形式的 CONCAT()。第一個參數剩余參數間的分隔符。分隔符可以是與剩余參數一樣的字符串。如果分隔符是 NULL，返回值也將為 NULL。這個函數會跳過分隔符參數後的任何 NULL 和空字符串。分隔符將被加到被連接的字符串之間：
373 mysql> SELECT CONCAT_WS(",","First name","Second name","Last Name");
374 -> 'First name,Second name,Last Name'
375 mysql> SELECT CONCAT_WS(",","First name",NULL,"Last Name");
376 -> 'First name,Last Name'
377
378 LENGTH(str)
379 OCTET_LENGTH(str)
380 CHAR_LENGTH(str)
381 CHARACTER_LENGTH(str)
382 返回字符串 str 的長度：
383 mysql> SELECT LENGTH('text');
384 -> 4
385 mysql> SELECT OCTET_LENGTH('text');
386 -> 4
387
388 注意，CHAR_LENGTH() 和 CHARACTER_LENGTH() 對於多字節字符只計數一次。
389
390 BIT_LENGTH(str)
391 返回字符串 str 的比特長度：
392 mysql> SELECT BIT_LENGTH('text');
393 -> 32
394
395 LOCATE(substr,str)
396 POSITION(substr IN str)
397 返回子串 substr 在字符串 str 中第一次出現的位置。如果子串 substr 在 str 中不存在，返回值為 0：
398 mysql> SELECT LOCATE('bar', 'foobarbar');
399 -> 4
400 mysql> SELECT LOCATE('xbar', 'foobar');
401 -> 0
402
403 這個函數是多字節安全的。在 MySQL 3.23 中，這個函數是字母大小寫敏感的，當在 MySQL 4.0 中時，如有任一參數是一個二進制字符串，它才是字母大小寫敏感的。
404
405 LOCATE(substr,str,pos)
406 返回子串 substr 在字符串 str 中的第 pos 位置後第一次出現的位置。如果 substr 不在 str 中返回 0 ：
407 mysql> SELECT LOCATE('bar', 'foobarbar',5);
408 -> 7
409
410 這個函數是多字節安全的。在 MySQL 3.23 中，這個函數是字母大小寫敏感的，當在 MySQL 4.0 中時，如有任一參數是一個二進制字符串，它才是字母大小寫敏感的。
411
412 INSTR(str,substr)
413 返回子串 substr 在字符串 str 中第一次出現的位置。這與有兩個參數形式的 LOCATE() 相似，只是參數的位置被顛倒了：
414 mysql> SELECT INSTR('foobarbar', 'bar');
415 -> 4
416 mysql> SELECT INSTR('xbar', 'foobar');
417 -> 0
418
419 這個函數是多字節安全的。在 MySQL 3.23 中，這個函數是字母大小寫敏感的，當在 MySQL 4.0 中時，如有任一參數是一個二進制字符串，它才是字母大小寫敏感的。
420
421 LPAD(str,len,padstr)
422 用字符串 padstr 對 str 進行左邊填補直至它的長度達到 len 個字符長度，然後返回 str。如果 str 的長度長於 len'，那麼它將被截除到 len 個字符。
423 mysql> SELECT LPAD('hi',4,'??');
424 -> '??hi'
425
426 RPAD(str,len,padstr)
427 用字符串 padstr 對 str 進行右邊填補直至它的長度達到 len 個字符長度，然後返回 str。如果 str 的長度長於 len'，那麼它將被截除到 len 個字符。
428 mysql> SELECT RPAD('hi',5,'?');
429 -> 'hi???'
430
431 LEFT(str,len)
432 返回字符串 str 中最左邊的 len 個字符：
433 mysql> SELECT LEFT('foobarbar', 5);
434 -> 'fooba'
435
436 這個函數是多字節安全的。
437
438 RIGHT(str,len)
439 返回字符串 str 中最右邊的 len 個字符：
440 mysql> SELECT RIGHT('foobarbar', 4);
441 -> 'rbar'
442
443 這個函數是多字節安全的。
444
445 SUBSTRING(str,pos,len)
446 SUBSTRING(str FROM pos FOR len)
447 MID(str,pos,len)
448 從字符串 str 的 pos 位置起返回 len 個字符的子串。使用 FROM 的變體形式是 ANSI SQL92 的句法：
449 mysql> SELECT SUBSTRING('Quadratically',5,6);
450 -> 'ratica'
451
452 這個函數是多字節安全的。
453
454 SUBSTRING(str,pos)
455 SUBSTRING(str FROM pos)
456 從字符串 str 的 pos 位置起返回子串：
457 mysql> SELECT SUBSTRING('Quadratically',5);
458 -> 'ratically'
459 mysql> SELECT SUBSTRING('foobarbar' FROM 4);
460 -> 'barbar'
461
462 這個函數是多字節安全的。
463
464 SUBSTRING_INDEX(str,delim,count)
465 返回字符串 str 中在第 count 個出現的分隔符 delim 之前的子串。如果 count 是一個正數，返回從最後的(從左邊開始計數)分隔符到左邊所有字符。如果 count 是負數，返回從最後的(從右邊開始計數)分隔符到右邊所有字符：
466 mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
467 -> 'www.mysql'
468 mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2);
469 -> 'mysql.com'
470
471 這個函數是多字節安全的。
472
473 LTRIM(str)
474 返回移除了領頭的空格字符後的 str：
475 mysql> SELECT LTRIM(' barbar');
476 -> 'barbar'
477
478
479 RTRIM(str)
480 返回移除了尾部的空格字符後的 str：
481 mysql> SELECT RTRIM('barbar ');
482 -> 'barbar'
483
484 這個函數是多字節安全的。
485
486 TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str)
487 移除字符串 str 中所有的 remstr 前綴或後綴，然後將其返回。如果沒有任何 BOTH、LEADING 或 TRAILING 修飾符被給出，BOTH 被假定。如果 remstr 沒有被指定，空格將被移除：
488 mysql> SELECT TRIM(' bar ');
489 -> 'bar'
490 mysql> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
491 -> 'barxxx'
492 mysql> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
493 -> 'bar'
494 mysql> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
495 -> 'barx'
496
497 這個函數是多字節安全的。
498
499 SOUNDEX(str)
500 返回 str 的近音字。兩個發音差不多的字符串應該有同樣的近音字。一個標准的近音字為 4 個字符長，但是函數 SOUNDEX() 卻返回一個任意長的字符串。你可以在結果上使用 SUBSTRING() 標准的近音字。提供的字符中所有的非數字字母的字符均被忽略。所有在 A-Z 范圍之外的國際 alpha 字符被視為元音：
501 mysql> SELECT SOUNDEX('Hello');
502 -> 'H400'
503 mysql> SELECT SOUNDEX('Quadratically');
504 -> 'Q36324'
505
506
507 SPACE(N)
508 返回有 N 空格字符組成的字符串：
509 mysql> SELECT SPACE(6);
510 -> ' '
511
512
513 REPLACE(str,from_str,to_str)
514 在字符串 str 中所有出現的字符串 from_str 均被 to_str替換，然後返回這個字符串：
515 mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
516 -> 'WwWwWw.mysql.com'
517
518 這個函數是多字節安全的。
519
520 REPEAT(str,count)
521 返回一個由重復了 count 次的字符串 str 組成的字符串。如果 count <= 0，返回一個空字符串。如果 str 或 count 是 NULL，返回值也為 NULL：
522 mysql> SELECT REPEAT('MySQL', 3);
523 -> 'MySQLMySQLMySQL'
524
525
526 REVERSE(str)
527 以顛倒的字符順序返回字符串 str：
528 mysql> SELECT REVERSE('abc');
529 -> 'cba'
530
531 這個函數是多字節安全的。
532
533 INSERT(str,pos,len,newstr)
534 在字符串 str 中，將從 pos 位置開始，len 個字符長的子串替換為字符串 newstr ，然後將結果返回：
535 mysql> SELECT INSERT('Quadratic', 3, 4, 'What');
536 -> 'QuWhattic'
537
538 這個函數是多字節安全的。
539
540 ELT(N,str1,str2,str3,...)
541 如果 N = 1，返回 str1，如果N = 2，返回 str2，等等。如果 N 小於 1 或大於參數的數量，返回 NULL。ELT() FIELD() 反運算：
542 mysql> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');
543 -> 'ej'
544 mysql> SELECT ELT(4, 'ej', 'Heja', 'hej', 'foo');
545 -> 'foo'
546
547
548 FIELD(str,str1,str2,str3,...)
549 返回 str 在列表 str1, str2, str3, ... 中的索引。如果 str 沒有發現，返回 0。FIELD() 是 ELT() 的反運算：
550 mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
551 -> 2
552 mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');
553 -> 0
554
555
556 FIND_IN_SET(str,strlist)
557 Returns a value 如果字符串 str 在由 N 個子串組成的列表 strlist 中，返回一個 1 到 N 的值。一個字符串列表是由通過字符 “,” 分隔的多個子串組成。如果第一個參數是一個常數字符串，並且第二個參數是一個 SET 列類型，FIND_IN_SET() 函數將被優化為使用位運算！如果 str 在不 strlist 中或者如果 strlist 是一個空串，返回值為 0。如果任何一個參數為 NULL，返回值也是 NULL。如果第一個參數包含一個 “,”，這個函數將完全不能工作：
558 mysql> SELECT FIND_IN_SET('b','a,b,c,d');
559 -> 2
560
561
562 MAKE_SET(bits,str1,str2,...)
563 返回一個集合 (包含由字符 “,” 分隔的多個子串組成的一個字符串)，它由在 bits 集合中有相應的比特位的字符串組成。str1 對應於比特位 0，str2 對應比特位 1，等等。在 str1, str2, ... 中的 NULL 串不允許被添加到結果中：
564 mysql> SELECT MAKE_SET(1,'a','b','c');
565 -> 'a'
566 mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world');
567 -> 'hello,world'
568 mysql> SELECT MAKE_SET(0,'a','b','c');
569 -> ''
570
571
572 EXPORT_SET(bits,on,off,[separator,[number_of_bits]])
573 返回一個字符串，對於在 'bits' 中的每個比特字位，你將得到一個 'on' 字符，而如果比特字位是一個清零比特位(reset bit)你將得到一個 'off' 字符串。每個字符串均被“分隔符”(缺省為“,”)分隔，並且只有 'number_of_bits'(缺省為 64) 個 'bits' 被使用：
574 mysql> SELECT EXPORT_SET(5,'Y','N',',',4)
575 -> Y,N,Y,N
576
577 示例(譯者注)：
578 mysql> select EXPORT_SET(1,'1','0','',5);
579 -> 10000
580 # 最左邊第一位為 2 的 0 次冪
581
582 mysql> select EXPORT_SET(2,'1','0','',5);
583 -> 01000
584 # 最左邊第一位為 2 的 0 次冪，第二位為 2 的 1 次冪
585
586 mysql> select EXPORT_SET(4,'1','0','',5);
587 -> 00100
588 # 最左邊第一位為 2 的 0 次冪，第二位為 2 的 1 次冪，第三位為 2 的 2 次冪
589
590 mysql> select EXPORT_SET(15,'1','0','',5);
591 -> 11110
592 # 最左邊第一位為 2 的 1 次冪，第四位為 2 的 3 次冪
593
594 mysql> select EXPORT_SET(16,'1','0','',5);
595 -> 00001
596 # 最左邊第一位為 2 的 1 次冪，第五位為 2 的 4 次冪
597
598
599 # 以上結果在 MySQL 4.0.12 中測試通過
600
601 示例結束(譯者注)
602
603 LCASE(str)
604 LOWER(str)
605 依照當前字符集設置映射(缺省為 ISO-8859-1 Latin1)，將字符串 str 中的所有字符改變為小寫，然後返回該值：
606 mysql> SELECT LCASE('QUADRATICALLY');
607 -> 'quadratically'
608
609 這個函數是多字節安全的。
610
611 UCASE(str)
612 UPPER(str)
613 依照當前字符集設置映射(缺省為 ISO-8859-1 Latin1)，將字符串 str 中的所有字符改變為大寫，然後返回該值：
614 mysql> SELECT UCASE('Hej');
615 -> 'HEJ'
616
617 這個函數是多字節安全的。
618
619 LOAD_FILE(file_name)
620 讀入文件，並將文件內容作為一個字符串返回。這個文件必須在服務器上，必須指定文件完整的路徑名，並且你必須有 FILE 權限。文件必須完全可讀，並且小於 max_allowed_packet。 如果該文件不存在，或因為上面的任一原因而不能被讀出，函數返回 NULL：
621 mysql> UPDATE tbl_name
622 SET blob_column=LOAD_FILE("/tmp/picture")
623 WHERE id=1;
624
625 如果你沒有使用 MySQL 3.23，你不得不在你的應用程序中讀取文件，以文件的信息創建一個 INSERT 語句，來更新數據庫。如果你使用 MySQL++ 庫，下面有一個示例，詳細請查看 http://www.mysql.com/documentation/mysql++/mysql++-examples.html。
626
627 QUOTE(str)
628 引用一個字符串，並返回一個結果，該結果可作為一個適當轉義過的數據值在一個 SQL 語句中使用。字符串被單引號包圍著返回，並且在該字符串中每個單引號(“'”)、反斜線符號(“\”)、ASCII NUL 和 Control-Z 出現的地方，在該字符之前均被加上了一個反斜線。如果參數是 NULL，那麼結果值是一個沒有單引號包圍的單詞 “NULL”。 QUOTE 函數在 MySQL 4.0.3 中被加入。
629 mysql> SELECT QUOTE("Don't");
630 -> 'Don\'t!'
631 mysql> SELECT QUOTE(NULL);
632 -> NULL
633
634 6.3.2.1 字符串比較函數
635
636 在必要的時候，MySQL 會自動地將數字轉換到字符串，反之亦然：
637
638 mysql> SELECT 1+"1";
639 -> 2
640 mysql> SELECT CONCAT(2,' test');
641 -> '2 test'
642
643 如果你希望明確地將一個數字轉換為字符串，將它參數傳遞到 CONCAT() 中。
644
645 如果將一個二進制字符串作為參數傳遞給一個字符串函數，結果返回也是一個二進制字符串。一個數字被轉換到字符串，該字符串被視為是一個二進制字符串。這僅僅會影響結果。
646
647
648 通常，只要字符串比較中的任何一個表達式是區分大小寫的，比較就會以字母大小寫敏感方式執行。
649
650 expr LIKE pat [ESCAPE 'escape-char']
651 使用 SQL 的簡單的正規表達式進行比較的模式匹配。返回 1 (TRUE) 或 0 (FALSE)。可以在模式中使用下面所示的兩個通配符字符與 LIKE 配合： 字符 含義
652 % 匹配任意多個字符，甚至是零個字符
653 _ 嚴格地匹配一個字符
654
655 mysql> SELECT 'David!' LIKE 'David_';
656 -> 1
657 mysql> SELECT 'David!' LIKE '%D%v%';
658 -> 1
659
660 為了測試一個含有通配符的文字實例，可以用轉義符加在能配符前。如果沒有明確指定 ESCAPE 字符，假定為 “\”： 字符串 含義
661 \% 匹配一個 % 字符
662 \_ 匹配一個 _ 字符
663
664 mysql> SELECT 'David!' LIKE 'David\_';
665 -> 0
666 mysql> SELECT 'David_' LIKE 'David\_';
667 -> 1
668
669 為了指定一個不同的轉義字符，可以使用 ESCAPE 子句：
670 mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
671 -> 1
672
673 下面兩個語句表明，字符串比較是忽略大小寫的，除非任一操作數是一個二進制字符串：
674 mysql> SELECT 'abc' LIKE 'ABC';
675 -> 1
676 mysql> SELECT 'abc' LIKE BINARY 'ABC';
677 -> 0
678
679 LIKE 允許用在一個數字表達式上。(這是 MySQL 對 ANSI SQL LIKE 的擴展。)
680 mysql> SELECT 10 LIKE '1%';
681 -> 1
682
683 注意：因為 MySQL 在字符串中使用的是 C 的轉義句法(例如 “\n”)，所以在 LIKE 字符串中使用的任何一個 “\” 必須被雙寫。例如，為了查找 “\n”，必須以 “\\n” 形式指定它。為了查找 “\”，必須指定它為 “\\\\” (反斜線被語法分析器剝離一次，另一次在模式匹配時完成，留下一條單獨的反斜線被匹配)。
684
685 expr NOT LIKE pat [ESCAPE 'escape-char']
686 相同於 NOT (expr LIKE pat [ESCAPE 'escape-char'])。
687
688 expr SOUNDS LIKE expr
689 等同於 SOUNDEX(expr)=SOUNDEX(expr) (適用於 MySQL 4.1 或更新的版本)。
690
691 expr REGEXP pat
692 expr RLIKE pat
693 依照模式 pat 對字符串表達式 expr 執行一個模式比較。模式可以是一個擴展的正則表達式。查看章節 G MySQL 正則表達式。Returns 如果表達式 expr 匹配 pat，返回 1，否則返回 0。RLIKE 是 REGEXP 的同義詞，它提供了與 mSQL 的兼容。注意：MySQL 在字符串中使用的是 C 的轉義句法(例如 “\n”)，所以在 REGEXP 字符串中使用的任何一個 “\” 必須被雙寫。在 MySQL 3.23.4 中，REGEXP 對於正常的(不是二進制)字符串是忽略大小寫的：
694 mysql> SELECT 'Monty!' REGEXP 'm%y%%';
695 -> 0
696 mysql> SELECT 'Monty!' REGEXP '.*';
697 -> 1
698 mysql> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
699 -> 1
700 mysql> SELECT "a" REGEXP "A", "a" REGEXP BINARY "A";
701 -> 1 0
702 mysql> SELECT "a" REGEXP "^[a-d]";
703 -> 1
704
705 當決定一個字符的類型時，REGEXP 和 RLIKE 使用當前使用的字符集(缺省為 ISO-8859-1 Latin1)。
706
707 expr NOT REGEXP pat
708 expr NOT RLIKE pat
709 等同於 NOT (expr REGEXP pat)。
710
711 STRCMP(expr1,expr2)
712 如果字符串是相同，STRCMP() 返回 0，如果第一個參數根據當前排序次序小於第二個參數，返回 -1，否則返回 1：
713 mysql> SELECT STRCMP('text', 'text2');
714 -> -1
715 mysql> SELECT STRCMP('text2', 'text');
716 -> 1
717 mysql> SELECT STRCMP('text', 'text');
718 -> 0
719
720
721 MATCH (col1,col2,...) AGAINST (expr)
722 MATCH (col1,col2,...) AGAINST (expr IN BOOLEAN MODE)
723 MATCH ... AGAINST() 用於全文搜索，返回在列 (col1,col2,...) 和查詢 expr 之間文本的相關相似的尺度。相關性是一個正的浮點型數字。零相關性意味著不相似。MATCH ... AGAINST() 可用於 MySQL 3.23.23 或更新的版本中。IN BOOLEAN MODE 擴展在 MySQL 4.0.1 中被新加入。詳細描述和使用范例，請查看 6.8 MySQL 全文搜索。
724 6.3.2.2 字母大小寫敏感性
725
726
727 BINARY
728 BINARY 操作符將跟在它後面的字符串強制作為一個二進制字符串。這可以很容易地強制一個列的比較以字母大小寫敏感方式進行，即使該列沒有定義為 BINARY 或 BLOB?
729 mysql> SELECT "a" = "A";
730 -> 1
731 mysql> SELECT BINARY "a" = "A";
732 -> 0
733
734 BINARY string 是 CAST(string AS BINARY) 的縮寫。查看章節 6.3.5 Cast 函數。BINARY 在 MySQL 3.23.0 中被加入。 注意，當將一個索引列強制為 BINARY 時，在某些語境中，MySQL 將不能有效地使用索引。
735 如果希望對一個 blob 進行忽略字母大小的比較時，你通常可以在比較前將它轉換到大寫：
736
737 SELECT 'A' LIKE UPPER(blob_col) FROM table_name;
738
739 我們計劃不久推出在不同字符集間的轉化，以使字符串比較有更好的伸縮性。
740
741 6.3.3 數字函數
742 6.3.3.1 算術運算
743 常用的算術操作符均是可用的。注意，如果兩個參數均是整型，`-', `+' 和 `*' 以 BIGINT (64 位)精度運算並返回結果！如果一個參數是一個無符號的整數，另一個參數也是一個整數，結果也將是一個無符號整數。查看章節 6.3.5 Cast 函數。
744
745
746 +
747 加法：
748 mysql> SELECT 3+5;
749 -> 8
750
751 -
752 減法：
753 mysql> SELECT 3-5;
754 -> -2
755
756 *
757 乘法：
758 mysql> SELECT 3*5;
759 -> 15
760 mysql> SELECT 18014398509481984*18014398509481984.0;
761 -> 324518553658426726783156020576256.0
762 mysql> SELECT 18014398509481984*18014398509481984;
763 -> 0
764
765 最後一個表達式的結果是錯誤的，這是因為乘法結果超過了 64 位 BIGINT 計算范圍。
766 /
767 除法：
768 mysql> SELECT 3/5;
769 -> 0.60
770
771 被 0 除將返回一個 NULL 結果：
772 mysql> SELECT 102/(1-1);
773 -> NULL
774
775 只有當在一個結果被轉換到一個整數的語境中執行時，除法將會以 BIGINT 進行算術計算。
776 6.3.3.2 數學函數
777 所有的數學函數在發生錯誤的情況下，均返回 NULL。
778
779
780 -
781 一元減。 改變參數的符號：
782 mysql> SELECT - 2;
783 -> -2
784
785 注意，如果這個操作符被用於一個 BIGINT，返回值也是一個 BIGINT！這就意味著，應該避免在一個可能有值 -2^63 的整數上使用 - 操作符！
786
787 ABS(X)
788 返回 X 的絕對值：
789 mysql> SELECT ABS(2);
790 -> 2
791 mysql> SELECT ABS(-32);
792 -> 32
793
794 這個函數可安全地使用於 BIGINT 值。
795
796 SIGN(X)
797 以 -1、0 或 1 方式返回參數的符號，它取決於參數 X 是負數、0 或正數。
798 mysql> SELECT SIGN(-32);
799 -> -1
800 mysql> SELECT SIGN(0);
801 -> 0
802 mysql> SELECT SIGN(234);
803 -> 1
804
805 MOD(N,M)
806 %
807 取模 (就如 C 中的 % 操作符)。返回 N 被 M 除後的余數：
808 mysql> SELECT MOD(234, 10);
809 -> 4
810 mysql> SELECT 253 % 7;
811 -> 1
812 mysql> SELECT MOD(29,9);
813 -> 2
814 mysql> SELECT 29 MOD 9;
815 -> 2
816
817 這個函數可安全地使用於 BIGINT 值。最後一個示例可在 MySQL 4.1 中工作。
818
819 FLOOR(X)
820 返回不大於 X 的最大整數值：
821 mysql> SELECT FLOOR(1.23);
822 -> 1
823 mysql> SELECT FLOOR(-1.23);
824 -> -2
825
826 注意，返回值被轉換為一個 BIGINT！
827
828 CEILING(X)
829 返回不小於 X 的最小整數：
830 mysql> SELECT CEILING(1.23);
831 -> 2
832 mysql> SELECT CEILING(-1.23);
833 -> -1
834
835 注意，返回值被轉換為一個 BIGINT！
836
837 ROUND(X)
838 ROUND(X,D)
839 將參數 X 四捨五入到最近的整數，然後返回。兩個參數的形式是將一個數字四捨五入到 D 個小數後返回。
840 mysql> SELECT ROUND(-1.23);
841 -> -1
842 mysql> SELECT ROUND(-1.58);
843 -> -2
844 mysql> SELECT ROUND(1.58);
845 -> 2
846 mysql> SELECT ROUND(1.298, 1);
847 -> 1.3
848 mysql> SELECT ROUND(1.298, 0);
849 -> 1
850
851 注意，當參數在兩個整數之間時， ROUND() 的行為取決於 C 庫的實現。某些取整到最近的偶數，總是向下取，總是向上取，也可能總是接近於零。如果你需要某種取整類型，應該使用一個明確定義的函數比如 TRUNCATE() 或 FLOOR() 代替。
852
853 DIV
854 整除。類似於 FLOOR()，但是它可安全地用於 BIGINT 值。
855 mysql> SELECT 5 DIV 2
856 -> 2
857
858 DIV 在 MySQL 4.1.0 中新加入。
859
860 EXP(X)
861 返回值 e (自然對數的底) 的 X 次方：
862 mysql> SELECT EXP(2);
863 -> 7.389056
864 mysql> SELECT EXP(-2);
865 -> 0.135335
866
867 LN(X)
868 返回 X 的自然對數：
869 mysql> SELECT LN(2);
870 -> 0.693147
871 mysql> SELECT LN(-2);
872 -> NULL
873
874 這個函數在 MySQL 4.0.3 被新加入。在 MySQL 中，它是 LOG(X) 的同義詞。
875
876 LOG(X)
877 LOG(B,X)
878 如果以一個參數調用，它返回 X 的自然對數：
879 mysql> SELECT LOG(2);
880 -> 0.693147
881 mysql> SELECT LOG(-2);
882 -> NULL
883
884 如果以兩個參數調用，這個函數返回 X 任意底 B 的對數：
885 mysql> SELECT LOG(2,65536);
886 -> 16.000000
887 mysql> SELECT LOG(1,100);
888 -> NULL
889
890 任意底選項在 MySQL 4.0.3 中被加入。LOG(B,X) 等價於 LOG(X)/LOG(B)。
891
892 LOG2(X)
893 返回 X 的以 2 為底的對數：
894 mysql> SELECT LOG2(65536);
895 -> 16.000000
896 mysql> SELECT LOG2(-100);
897 -> NULL
898
899 LOG2() 通常可以用於計數出一個數字需要多少個比特位用於存儲它。這個函數在 MySQL 4.0.3 中被添加。在更早的版本中，可以使用 LOG(X)/LOG(2) 來代替它。
900
901 LOG10(X)
902 返回 X 以 10 為底的對數：
903 mysql> SELECT LOG10(2);
904 -> 0.301030
905 mysql> SELECT LOG10(100);
906 -> 2.000000
907 mysql> SELECT LOG10(-100);
908 -> NULL
909
910 POW(X,Y)
911 POWER(X,Y)
912 返回 X 的 Y 冪：
913 mysql> SELECT POW(2,2);
914 -> 4.000000
915 mysql> SELECT POW(2,-2);
916 -> 0.250000
917
918 SQRT(X)
919 返回 X 的非否平方根：
920 mysql> SELECT SQRT(4);
921 -> 2.000000
922 mysql> SELECT SQRT(20);
923 -> 4.472136
924
925 PI()
926 返回 PI 值(圓周率)。缺少顯示 5 位小數，但是在 MySQL 內部，為 PI 使用全部的雙精度。
927 mysql> SELECT PI();
928 -> 3.141593
929 mysql> SELECT PI()+0.000000000000000000;
930 -> 3.141592653589793116
931
932 COS(X)
933 返回 X 的余弦，在這裡，X 以弧度給出：
934 mysql> SELECT COS(PI());
935 -> -1.000000
936
937 SIN(X)
938 返回 X 的正弦，在這裡，X 以弧度給出：
939 mysql> SELECT SIN(PI());
940 -> 0.000000
941
942 TAN(X)
943 返回 X 的正切，在這裡，X 以弧度給出：
944 mysql> SELECT TAN(PI()+1);
945 -> 1.557408
946
947 ACOS(X)
948 返回 X 的反余弦，更確切地說，返回余弦值為 X 的值。如果 X 不在 -1 到 1 之間的范圍內，返回 NULL：
949 mysql> SELECT ACOS(1);
950 -> 0.000000
951 mysql> SELECT ACOS(1.0001);
952 -> NULL
953 mysql> SELECT ACOS(0);
954 -> 1.570796
955
956 ASIN(X)
957 返回 X 的反正弦，更確切地說，返回正弦值為 X 的值。如果 X 不在 -1 到 1 之間的范圍內，返回 NULL：
958 mysql> SELECT ASIN(0.2);
959 -> 0.201358
960 mysql> SELECT ASIN('foo');
961 -> 0.000000
962
963 ATAN(X)
964 返回 X 的反正切， 更確切地說，返回正切值為 X 的值：
965 mysql> SELECT ATAN(2);
966 -> 1.107149
967 mysql> SELECT ATAN(-2);
968 -> -1.107149
969
970 ATAN(Y,X)
971 ATAN2(Y,X)
972 返回兩個變量 X 和 Y 的反正切。它類似於計算 Y / X 的反正切，除了兩個參數的符號用於決定結果的象限：
973 mysql> SELECT ATAN(-2,2);
974 -> -0.785398
975 mysql> SELECT ATAN2(PI(),0);
976 -> 1.570796
977
978 COT(X)
979 返回 X 的余切：
980 mysql> SELECT COT(12);
981 -> -1.57267341
982 mysql> SELECT COT(0);
983 -> NULL
984
985 RAND()
986 RAND(N)
987 返回一個范圍在 0 到 1.0 之間的隨機浮點值。如果一個整數參數 N 被指定，它被當做種子值使用(用於產生一個可重復的數值)：
988 mysql> SELECT RAND();
989 -> 0.9233482386203
990 mysql> SELECT RAND(20);
991 -> 0.15888261251047
992 mysql> SELECT RAND(20);
993 -> 0.15888261251047
994 mysql> SELECT RAND();
995 -> 0.63553050033332
996 mysql> SELECT RAND();
997 -> 0.70100469486881
998
999 在一個 ORDER BY 子句中，不可以使用 RAND() 值使用一個列，因為 ORDER BY 將多次重復計算列。從 MySQL 3.23 開始，你可以使用：SELECT * FROM table_name ORDER BY RAND()，這有利於得到一個來自 SELECT * FROM table1,table2 WHERE a=b AND c<d ORDER BY RAND() LIMIT 1000 的集合中的隨機樣本。 注意，在一個 WHERE 子句中的 RAND() 將在每次 WHERE 執行時被重新計算。 RAND() 並不是預期完美的隨機數發生器，但是可以代替做為產生特別的隨機數一個快速的方法，這樣便於在兩個不同平台下的同一 MySQL 版本間移動。
1000
1001 LEAST(X,Y,...)
1002 有兩個或更多個參數，返回最小(最小值)的參數。參數使用下列規則進行比較：
1003 如果返回值用於一個 INTEGER 語境，或所有的參數是整數值，它們作為整數比較。
1004 如果返回值用於一個 REAL 語境，或所有的參數均是實數值，它們作為實數被比較。
1005 如果任何一個參數是字母大小寫敏感的，參數作為大小寫敏感的字符串進行比較。
1006 在其它情況下，參數做為忽略大小寫的字符中進行比較：
1007 mysql> SELECT LEAST(2,0);
1008 -> 0
1009 mysql> SELECT LEAST(34.0,3.0,5.0,767.0);
1010 -> 3.0
1011 mysql> SELECT LEAST("B","A","C");
1012 -> "A"
1013
1014 在早於 MySQL 3.22.5 的版本中，你可以使用 MIN() 代替 LEAST。
1015
1016 GREATEST(X,Y,...)
1017 返回最大(最大值)參數。參數使用與 LEAST 一致的規則進行比較：
1018 mysql> SELECT GREATEST(2,0);
1019 -> 2
1020 mysql> SELECT GREATEST(34.0,3.0,5.0,767.0);
1021 -> 767.0
1022 mysql> SELECT GREATEST("B","A","C");
1023 -> "C"
1024
1025 在早於 MySQL 3.22.5 的版本中，可以使用 MAX() 代替 GREATEST。
1026
1027 DEGREES(X)
1028 將參數 X 從弧度轉換為角度，然後返回：
1029 mysql> SELECT DEGREES(PI());
1030 -> 180.000000
1031
1032 RADIANS(X)
1033 將參數 X 從角度轉換為弧度，然後返回：
1034 mysql> SELECT RADIANS(90);
1035 -> 1.570796
1036
1037 TRUNCATE(X,D)
1038 將數值 X 截到 D 個小數，然後返回。如果 D 為 0，結果將不包含小數點和小數部分：
1039 mysql> SELECT TRUNCATE(1.223,1);
1040 -> 1.2
1041 mysql> SELECT TRUNCATE(1.999,1);
1042 -> 1.9
1043 mysql> SELECT TRUNCATE(1.999,0);
1044 -> 1
1045 mysql> SELECT TRUNCATE(-1.999,1);
1046 -> -1.9
1047
1048 從 MySQL 3.23.51 開始，所有數字被四捨五入到零。 如果 D 是負數，那麼數字的整個部分被對准零位輸出：
1049 mysql> SELECT TRUNCATE(122,-2);
1050 -> 100
1051
1052 注意， 十進值小數在計算機中通常不以精確數字存儲，而是雙精度型的值，你可能會被下列結果所愚弄：
1053 mysql> SELECT TRUNCATE(10.28*100,0);
1054 -> 1027
1055
1056 上面結果的發生是因為 10.28 實際上是以某些像 10.2799999999999999 的形式被存儲的。
1057 6.3.4 日期和時間函數
1058
1059 對於每個類型的值范圍以及日期和時間值有效指定格式，請查看章節 6.2.2 Date 和 Time 類型。
1060
1061 這裡是一個使用日期函數的例子。下面的查詢選擇所有 date_col 值在最後 30 天內的記錄。
1062
1063 mysql> SELECT something FROM tbl_name
1064 WHERE TO_DAYS(NOW()) - TO_DAYS(date_col) <= 30;
1065
1066 DAYOFWEEK(date)
1067 返回 date 的星期索引(1 = Sunday, 2 = Monday, ... 7 = Saturday)。索引值符合 ODBC 的標准。
1068 mysql> SELECT DAYOFWEEK('1998-02-03');
1069 -> 3
1070
1071 WEEKDAY(date)
1072 返回 date 的星期索引(0 = Monday, 1 = Tuesday, ... 6 = Sunday)：
1073 mysql> SELECT WEEKDAY('1998-02-03 22:23:00');
1074 -> 1
1075 mysql> SELECT WEEKDAY('1997-11-05');
1076 -> 2
1077
1078 DAYOFMONTH(date)
1079 返回 date 是一月中的第幾天，范圍為 1 到 31：
1080 mysql> SELECT DAYOFMONTH('1998-02-03');
1081 -> 3
1082
1083 DAYOFYEAR(date)
1084 返回 date 是一年中的第幾天，范圍為 1 到 366：
1085 mysql> SELECT DAYOFYEAR('1998-02-03');
1086 -> 34
1087
1088 MONTH(date)
1089 返回 date 中的月份，范圍為 1 到 12：
1090 mysql> SELECT MONTH('1998-02-03');
1091 -> 2
1092
1093 DAYNAME(date)
1094 返回 date 的星期名：
1095 mysql> SELECT DAYNAME("1998-02-05");
1096 -> 'Thursday'
1097
1098 MONTHNAME(date)
1099 返回 date 的月份名：
1100 mysql> SELECT MONTHNAME("1998-02-05");
1101 -> 'February'
1102
1103 QUARTER(date)
1104 返回 date 在一年中的季度，范圍為 1 到 4：
1105 mysql> SELECT QUARTER('98-04-01');
1106 -> 2
1107
1108 WEEK(date)
1109 WEEK(date,first)
1110 對於星期日是一周中的第一天的場合，如果函數只有一個參數調用，返回 date 為一年的第幾周，返回值范圍為 0 到 53 (是的，可能有第 53 周的開始)。兩個參數形式的 WEEK() 允許你指定一周是否以星期日或星期一開始，以及返回值為 0-53 還是 1-52。 這裡的一個表顯示第二個參數是如何工作的： 值 含義
1111 0 一周以星期日開始，返回值范圍為 0-53
1112 1 一周以星期一開始，返回值范圍為 0-53
1113 2 一周以星期日開始，返回值范圍為 1-53
1114 3 一周以星期一開始，返回值范圍為 1-53 (ISO 8601)
1115
1116 mysql> SELECT WEEK('1998-02-20');
1117 -> 7
1118 mysql> SELECT WEEK('1998-02-20',0);
1119 -> 7
1120 mysql> SELECT WEEK('1998-02-20',1);
1121 -> 8
1122 mysql> SELECT WEEK('1998-12-31',1);
1123 -> 53
1124
1125 注意，在版本 4.0 中，WEEK(#,0) 被更改為匹配 USA 歷法。 注意，如果一周是上一年的最後一周，當你沒有使用 2 或 3 做為可選參數時，MySQL 將返回 0：
1126 mysql> SELECT YEAR('2000-01-01'), WEEK('2000-01-01',0);
1127 -> 2000, 0
1128 mysql> SELECT WEEK('2000-01-01',2);
1129 -> 52
1130
1131 你可能會爭辯說，當給定的日期值實際上是 1999 年的第 52 周的一部分時，MySQL 對 WEEK() 函數應該返回 52。我們決定返回 0 ，是因為我們希望該函數返回“在指定年份中是第幾周”。當與其它的提取日期值中的月日值的函數結合使用時，這使得 WEEK() 函數的用法可靠。 如果你更希望能得到恰當的年-周值，那麼你應該使用參數 2 或 3 做為可選參數，或者使用函數 YEARWEEK() ：
1132 mysql> SELECT YEARWEEK('2000-01-01');
1133 -> 199952
1134 mysql> SELECT MID(YEARWEEK('2000-01-01'),5,2);
1135 -> 52
1136
1137 YEAR(date)
1138 返回 date 的年份，范圍為 1000 到 9999：
1139 mysql> SELECT YEAR('98-02-03');
1140 -> 1998
1141
1142 YEARWEEK(date)
1143 YEARWEEK(date,first)
1144 返回一個日期值是的哪一年的哪一周。第二個參數的形式與作用完全與 WEEK() 的第二個參數一致。注意，對於給定的日期參數是一年的第一周或最後一周的，返回的年份值可能與日期參數給出的年份不一致：
1145 mysql> SELECT YEARWEEK('1987-01-01');
1146 -> 198653
1147
1148 注意，對於可選參數 0 或 1，周值的返回值不同於 WEEK() 函數所返回值(0)， WEEK() 根據給定的年語境返回周值。
1149 HOUR(time)
1150 返回 time 的小時值，范圍為 0 到 23：
1151 mysql> SELECT HOUR('10:05:03');
1152 -> 10
1153
1154 MINUTE(time)
1155 返回 time 的分鐘值，范圍為 0 到 59：
1156 mysql> SELECT MINUTE('98-02-03 10:05:03');
1157 -> 5
1158
1159 SECOND(time)
1160 返回 time 的秒值，范圍為 0 到 59：
1161 mysql> SELECT SECOND('10:05:03');
1162 -> 3
1163
1164 PERIOD_ADD(P,N)
1165 增加 N 個月到時期 P(格式為 YYMM 或 YYYYMM)中。以 YYYYMM 格式返回值。 注意，期間參數 P 不是 一個日期值：
1166 mysql> SELECT PERIOD_ADD(9801,2);
1167 -> 199803
1168
1169 PERIOD_DIFF(P1,P2)
1170 返回時期 P1 和 P2 之間的月數。P1 和 P2 應該以 YYMM 或 YYYYMM 指定。 注意，時期參數 P1 和 P2 不是 日期值：
1171 mysql> SELECT PERIOD_DIFF(9802,199703);
1172 -> 11
1173
1174 DATE_ADD(date,INTERVAL expr type)
1175 DATE_SUB(date,INTERVAL expr type)
1176 ADDDATE(date,INTERVAL expr type)
1177 SUBDATE(date,INTERVAL expr type)
1178 這些函數執行日期的算術運算。ADDDATE() 和 SUBDATE() 分別是 DATE_ADD() 和 DATE_SUB() 的同義詞。 在 MySQL 3.23 中，如果表達式的右邊是一個日期值或一個日期時間型字段，你可以使用 + 和 - 代替 DATE_ADD() 和 DATE_SUB()(示例如下)。 參數 date 是一個 DATETIME 或 DATE 值，指定一個日期的開始。expr 是一個表達式，指定從開始日期上增加還是減去間隔值。expr 是一個字符串；它可以以一個 “-” 領頭表示一個負的間隔值。type 是一個關鍵詞，它標志著表達式以何格式被解釋。 下表顯示 type 和 expr 參數是如何關聯的： type 值 expr 期望的格式
1179 SECOND SECONDS
1180 MINUTE MINUTES
1181 HOUR HOURS
1182 DAY DAYS
1183 MONTH MONTHS
1184 YEAR YEARS
1185 MINUTE_SECOND "MINUTES:SECONDS"
1186 HOUR_MINUTE "HOURS:MINUTES"
1187 DAY_HOUR "DAYS HOURS"
1188 YEAR_MONTH "YEARS-MONTHS"
1189 HOUR_SECOND "HOURS:MINUTES:SECONDS"
1190 DAY_MINUTE "DAYS HOURS:MINUTES"
1191 DAY_SECOND "DAYS HOURS:MINUTES:SECONDS"
1192 在 expr 的格式中，MySQL 允許任何字符作為定界符。表中所顯示的是建議的定界字符。如果 date 參數是一個 DATE 值，並且計算的間隔僅僅有 YEAR、MONTH 和 DAY 部分(沒有時間部分)，那麼返回值也是一個 DATE 值。否則返回值是一個 DATETIME 值：
1193 mysql> SELECT "1997-12-31 23:59:59" + INTERVAL 1 SECOND;
1194 -> 1998-01-01 00:00:00
1195 mysql> SELECT INTERVAL 1 DAY + "1997-12-31";
1196 -> 1998-01-01
1197 mysql> SELECT "1998-01-01" - INTERVAL 1 SECOND;
1198 -> 1997-12-31 23:59:59
1199 mysql> SELECT DATE_ADD("1997-12-31 23:59:59",
1200 -> INTERVAL 1 SECOND);
1201 -> 1998-01-01 00:00:00
1202 mysql> SELECT DATE_ADD("1997-12-31 23:59:59",
1203 -> INTERVAL 1 DAY);
1204 -> 1998-01-01 23:59:59
1205 mysql> SELECT DATE_ADD("1997-12-31 23:59:59",
1206 -> INTERVAL "1:1" MINUTE_SECOND);
1207 -> 1998-01-01 00:01:00
1208 mysql> SELECT DATE_SUB("1998-01-01 00:00:00",
1209 -> INTERVAL "1 1:1:1" DAY_SECOND);
1210 -> 1997-12-30 22:58:59
1211 mysql> SELECT DATE_ADD("1998-01-01 00:00:00",
1212 -> INTERVAL "-1 10" DAY_HOUR);
1213 -> 1997-12-30 14:00:00
1214 mysql> SELECT DATE_SUB("1998-01-02", INTERVAL 31 DAY);
1215 -> 1997-12-02
1216
1217 如果你指定了一個太短的間隔值(沒有包括 type 關鍵詞所期望的所有間隔部分)，MySQL 假設你遺漏了間隔值的最左邊部分。例如，如果指定一個 type 為 DAY_SECOND，那麼 expr 值被期望包含天、小時、分鐘和秒部分。如果你象 "1:10" 樣指定一個值，MySQL 假設天和小時部分被遺漏了，指定的值代表分鐘和秒。換句話說，"1:10" DAY_SECOND 被解釋為等價於 "1:10" MINUTE_SECOND。這類似於 MySQL 解釋 TIME 值為經過的時間而不是一天的時刻。 注意，如果依著包含一個時間部分的間隔增加或減少一個日期值，該日期值將被自動地轉換到一個日期時間值：
1218 mysql> SELECT DATE_ADD("1999-01-01", INTERVAL 1 DAY);
1219 -> 1999-01-02
1220 mysql> SELECT DATE_ADD("1999-01-01", INTERVAL 1 HOUR);
1221 -> 1999-01-01 01:00:00
1222
1223 如果你使用了確定不正確的日期，返回結果將是 NULL。如果你增加 MONTH、YEAR_MONTH 或 YEAR，並且結果日期的天比新月份的最大天數還大，那麼它將被調整到新月份的最大天數：
1224 mysql> SELECT DATE_ADD('1998-01-30', INTERVAL 1 MONTH);
1225 -> 1998-02-28
1226
1227 注意，上面的例子中，單詞 INTERVAL 和關鍵詞 type 是不區分字母大小寫的。
1228
1229 EXTRACT(type FROM date)
1230 EXTRACT() 函數使用與 DATE_ADD() 或 DATE_SUB() 一致的間隔類型，但是它用於指定從日期中提取的部分，而不是進行日期算術運算。
1231 mysql> SELECT EXTRACT(YEAR FROM "1999-07-02");
1232 -> 1999
1233 mysql> SELECT EXTRACT(YEAR_MONTH FROM "1999-07-02 01:02:03");
1234 -> 199907
1235 mysql> SELECT EXTRACT(DAY_MINUTE FROM "1999-07-02 01:02:03");
1236 -> 20102
1237
1238 TO_DAYS(date)
1239 給出一個日期 date，返回一個天數(從 0 年開始的天數)：
1240 mysql> SELECT TO_DAYS(950501);
1241 -> 728779
1242 mysql> SELECT TO_DAYS('1997-10-07');
1243 -> 729669
1244
1245 TO_DAYS() 無意於使用先於格裡高裡歷法(即現行的陽歷)(1582)出現的值，因為它不考慮當歷法改變時所遺失的天數。
1246
1247 FROM_DAYS(N)
1248 給出一個天數 N，返回一個 DATE 值：
1249 mysql> SELECT FROM_DAYS(729669);
1250 -> '1997-10-07'
1251
1252 FROM_DAYS() 無意於使用先於格裡高裡歷法(1582)出現的值，因為它不考慮當歷法改變時所遺失的天數。
1253
1254 DATE_FORMAT(date,format)
1255 依照 format 字符串格式化 date 值。下面的修飾符可被用於 format 字符串中： 修飾符 含義
1256 %M 月的名字 (January..December)
1257 %W 星期的名字 (Sunday..Saturday)
1258 %D 有英文後綴的某月的第幾天 (0th, 1st, 2nd, 3rd, etc.)
1259 %Y 年份，數字的，4 位
1260 %y 年份，數字的，2 位
1261 %X 周值的年份，星期日是一個星期的第一天，數字的，4 位，與 '%V' 一同使用
1262 %x 周值的年份，星期一是一個星期的第一天，數字的，4 位，與 '%v' 一同使用
1263 %a 縮寫的星期名 (Sun..Sat)
1264 %d 月份中的天數，數字的 (00..31)
1265 %e 月份中的天數，數字的 (0..31)
1266 %m 月，數字的 (00..12)
1267 %c 月，數字的 (0..12)
1268 %b 縮寫的月份名 (Jan..Dec)
1269 %j 一年中的天數 (001..366)
1270 %H 小時 (00..23)
1271 %k 小時 (0..23)
1272 %h 小時 (01..12)
1273 %I 小時 (01..12)
1274 %l 小時 (1..12)
1275 %i 分鐘，數字的 (00..59)
1276 %r 時間，12 小時 (hh:mm:ss [AP]M)
1277 %T 時間，24 小時 (hh:mm:ss)
1278 %S 秒 (00..59)
1279 %s 秒 (00..59)
1280 %p AM 或 PM
1281 %w 一周中的天數 (0=Sunday..6=Saturday)
1282 %U 星期 (00..53)，星期日是一個星期的第一天
1283 %u 星期 (00..53)，星期一是一個星期的第一天
1284 %V 星期 (01..53)，星期日是一個星期的第一天。與 '%X' 一起使用
1285 %v 星期 (01..53)，星期一是一個星期的第一天。與 '%x' 一起使用
1286 %% 一個字母 “%”
1287 所有其它的字符不經過解釋，直接復制到結果中：
1288 mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
1289 -> 'Saturday October 1997'
1290 mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%H:%i:%s');
1291 -> '22:23:00'
1292 mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00',
1293 '%D %y %a %d %m %b %j');
1294 -> '4th 97 Sat 04 10 Oct 277'
1295 mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00',
1296 '%H %k %I %r %T %S %w');
1297 -> '22 22 10 10:23:00 PM 22:23:00 00 6'
1298 mysql> SELECT DATE_FORMAT('1999-01-01', '%X %V');
1299 -> '1998 52'
1300
1301 在 MySQL 3.23 中，在格式修飾符前需要字符 `%'。在更早的 MySQL 版本中，`%' 是可選的。 月份與天修飾符的范圍從零開始的原因是，在 MySQL 3.23 中，它允許存儲不完善的日期值(例如 '2004-00-00')。
1302
1303 TIME_FORMAT(time,format)
1304 它的使用方法與上面的 DATE_FORMAT() 函數相似，但是 format 字符串只包含處理小時、分和秒的那些格式修飾符。使用其它的修飾符會產生一個 NULL 值或 0。
1305
1306 CURDATE()
1307 CURRENT_DATE
1308 以 'YYYY-MM-DD' 或 YYYYMMDD 格式返回當前的日期值，返回的格式取決於該函數是用於字符串還是數字語境中：
1309 mysql> SELECT CURDATE();
1310 -> '1997-12-15'
1311 mysql> SELECT CURDATE() + 0;
1312 -> 19971215
1313
1314 CURTIME()
1315 CURRENT_TIME
1316 以 'HH:MM:SS' 或 HHMMSS 格式返回當前的時間值，返回的格式取決於該函數是用於字符串還是數字語境中：
1317 mysql> SELECT CURTIME();
1318 -> '23:50:26'
1319 mysql> SELECT CURTIME() + 0;
1320 -> 235026
1321
1322 NOW()
1323 SYSDATE()
1324 CURRENT_TIMESTAMP
1325 以 'YYYY-MM-DD HH:MM:SS' 或 YYYYMMDDHHMMSS 格式返回當前的日期時間值，返回的格式取決於該函數是用於字符串還是數字語境中：
1326 mysql> SELECT NOW();
1327 -> '1997-12-15 23:50:26'
1328 mysql> SELECT NOW() + 0;
1329 -> 19971215235026
1330
1331 注意，函數 NOW() 在每個查詢中只計算一次，也就是在查詢開始執行時。這就是說，如果在一個單獨的查詢中多次引用了 NOW()，它只會給出值都是一個相同的時間。
1332
1333 UNIX_TIMESTAMP()
1334 UNIX_TIMESTAMP(date)
1335 如果調用時沒有參數，以無符號的整數形式返回一個 Unix 時間戳(從 '1970-01-01 00:00:00' GMT 開始的秒數)。如果以一個參數 date 調用 UNIX_TIMESTAMP()，它將返回該參數值從 '1970-01-01 00:00:00' GMT 開始經過的秒數值。date 可以是一個 DATE 字符串，一個 DATETIME 字符串，一個 TIMESTAMP，或者以一個 YYMMDD 或 YYYYMMDD 顯示的本地時間：
1336 mysql> SELECT UNIX_TIMESTAMP();
1337 -> 882226357
1338 mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');
1339 -> 875996580
1340
1341 當 UNIX_TIMESTAMP 被用於一個 TIMESTAMP 列時，函數直接返回一個內部的時間戳值，而不進行一個隱含地 “string-to-unix-timestamp” 轉換。如果你傳遞一個超出范圍的日期參數給 UNIX_TIMESTAMP() ，它將返回 0，但是請注意，MySQL 對其僅僅進行基本的檢驗(年范圍 1970-2037，月份 01-12，日期 01-31)。 如果你希望減去 UNIX_TIMESTAMP() 列，你應該需要將結果強制轉換為一有符號整數。查看章節 6.3.5 Cast 函數。
1342
1343 FROM_UNIXTIME(unix_timestamp [,format])
1344 以 'YYYY-MM-DD HH:MM:SS' 或 YYYYMMDDHHMMSS 格式返回一個 unix_timestamp 參數值，返回值的形式取決於該函數使用於字符串還是數字語境。 如果 format 給出，返回值依 format 字符串被格式。format 可以包含與 DATE_FORMAT() 函數同樣的修飾符。
1345 mysql> SELECT FROM_UNIXTIME(875996580);
1346 -> '1997-10-04 22:23:00'
1347 mysql> SELECT FROM_UNIXTIME(875996580) + 0;
1348 -> 19971004222300
1349 mysql> SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(),
1350 '%Y %D %M %h:%i:%s %x');
1351 -> '1997 23rd December 03:43:30 1997'
1352
1353 SEC_TO_TIME(seconds)
1354 以 'HH:MM:SS' 或 HHMMSS 格式返回參數 seconds 被轉換到時分秒後的值，返回值的形式取決於該函數使用於字符串還是數字語境：
1355 mysql> SELECT SEC_TO_TIME(2378);
1356 -> '00:39:38'
1357 mysql> SELECT SEC_TO_TIME(2378) + 0;
1358 -> 3938
1359
1360 TIME_TO_SEC(time)
1361 將參數 time 轉換為秒數後返回：
1362 mysql> SELECT TIME_TO_SEC('22:23:00');
1363 -> 80580
1364 mysql> SELECT TIME_TO_SEC('00:39:38');
1365 -> 2378
1366
1367 6.3.5 Cast 函數
1368 CAST 函數的句法如下：
1369
1370
1371 CAST(expression AS type)
1372
1373 或
1374
1375 CONVERT(expression,type)
1376
1377 type 可以是下面的任一個：
1378
1379 BINARY
1380 CHAR (4.0.6 中新加入)
1381 DATE
1382 DATETIME
1383 SIGNED {INTEGER}
1384 TIME
1385 UNSIGNED {INTEGER}
1386 CAST() 是 ANSI SQL99 的句法，CONVERT() 是 ODBC 的句法。
1387
1388 CAST 函數主要用於以特殊的 CREATE ... SELECT 形式建立一個列時：
1389
1390 CREATE TABLE new_table SELECT CAST('2000-01-01' AS DATE);
1391
1392 CAST(string AS BINARY 與 BINARY string 是相同的。 CAST(expr AS CHAR 表示一個使用當前默認字符集的字符串。
1393
1394 為了將一個字符串轉換成一個數字值，通常不需要做任何事情；只要將字符串值當做一個數字即可：
1395
1396 mysql> SELECT 1+'1';
1397 -> 2
1398
1399 如果在一個字符串語境中使用一個數字，該數字會被自動地轉換為一個 BINARY 字符串。
1400
1401 mysql> SELECT CONCAT("hello you ",2);
1402 -> "hello you 2"
1403
1404 MySQL 支持兩方是有符號的和無符號的 64 位值的算術運算。如果你使用一個數字操作符(比如 +)，並且其中的一個操作數是 unsigned integer，那麼結果將是無符號的。為了不考慮這些問題，你可以使用 SIGNED 和 UNSIGNED CAST 操作符來，它會分別地強制運算到一個有符號的或一個無符號的 64 位整數。
1405
1406 mysql> SELECT CAST(1-2 AS UNSIGNED)
1407 -> 18446744073709551615
1408 mysql> SELECT CAST(CAST(1-2 AS UNSIGNED) AS SIGNED);
1409 -> -1
1410
1411 注意，如果任一個操作數是一個浮點值(在這種語境下，DECIMAL() 被當作是一個浮點數值)，結果也將是一個浮點數值，並且結果不受上面的規則影響。
1412
1413 mysql> SELECT CAST(1 AS UNSIGNED) -2.0
1414 -> -1.0
1415
1416 如果在一個算術運算中使用一個字符串，它將被轉換為一個浮點數字。
1417
1418 函數 CAST() 和 CONVERT() 在 MySQL 4.0.2 中被加入。
1419
1420 為了完全支持 BIGINT，在 MySQL 4.0 中對無符號值的處理發生了改變。如果希望你的代碼在 MySQL 4.0 和 3.23 中均能夠正常運行(在這種情況下，你或許不能夠使用 CAST 函數)，當進行兩個無符號整數列的減法時，你可以使用下面的技巧得到一個有符號的結果：
1421
1422 SELECT (unsigned_column_1+0.0)-(unsigned_column_2+0.0);
1423
1424 這個做法是在進行減法之前，先將無符號列轉換為一個浮點數。
1425
1426 如果你將舊的 MySQL 應用程序移植到 MySQL 4.0 時，在 UNSIGNED 列上出現了問題，你可以在啟動 mysqld 時使用 --sql-mode=NO_UNSIGNED_SUBTRACTION 選項。注意，只要你使用了這個選項，你將不能直接地使用 UNSIGNED BIGINT 列類型。
1427
1428 6.3.6 其它函數
1429 6.3.6.1 位函數
1430
1431 MySQL 使用 BIGINT (64 位) 算法進行位運算，因而這些操作符有一個 64 位的最大范圍。
1432
1433 |
1434 位或
1435 mysql> SELECT 29 | 15;
1436 -> 31
1437
1438 返回值是一個 64 位的無符號整數。
1439
1440 &
1441 位與
1442 mysql> SELECT 29 & 15;
1443 -> 13
1444
1445 返回值是一個 64 位的無符號整數。
1446
1447 ^
1448 位異或
1449 mysql> SELECT 1 ^ 1;
1450 -> 0
1451 mysql> SELECT 1 ^ 0;
1452 -> 1
1453 mysql> SELECT 11 ^ 3;
1454 -> 8
1455
1456 返回值是一個 64 位的無符號整數。 XOR 在 MySQL 4.0.2 中被加入。
1457
1458 <<
1459 左移一個長長的數字(BIGINT)：
1460 mysql> SELECT 1 << 2;
1461 -> 4
1462
1463 返回值是一個 64 位的無符號整數。
1464
1465 >>
1466 右移一個長長的數字(BIGINT)：
1467 mysql> SELECT 4 >> 2;
1468 -> 1
1469
1470 返回值是一個 64 位的無符號整數。
1471
1472 ~
1473 置反所有位：
1474 mysql> SELECT 5 & ~1;
1475 -> 4
1476
1477 返回值是一個 64 位的無符號整數。
1478
1479 BIT_COUNT(N)
1480 返回在參數 N 中嵌入的比特位數量：
1481 mysql> SELECT BIT_COUNT(29);
1482 -> 4
1483
1484 6.3.6.2 輔助功能函數
1485
1486 DATABASE()
1487 返回當前數據庫名：
1488 mysql> SELECT DATABASE();
1489 -> 'test'
1490
1491 如果沒有當前數據庫，DATABASE() 返回一個空字符串。
1492 USER()
1493 SYSTEM_USER()
1494 SESSION_USER()
1495 返回當前 MySQL 用戶名：
1496 mysql> SELECT USER();
1497 -> 'davida@localhost'
1498
1499 在 MySQL 3.22.11 或更新的版本中，返回值包含用戶名和客戶機的主機名。你可以象下面所示的僅取出用戶名部分(無論值是否包含一個主機名部分，它均能正常工作)：
1500 mysql> SELECT SUBSTRING_INDEX(USER(),"@",1);
1501 -> 'davida'
1502
1503 CURRENT_USER()
1504 返回當前會話被驗證匹配的用戶名：
1505 mysql> SELECT USER();
1506 -> 'davida@localhost'
1507 mysql> SELECT * FROM mysql.user;
1508 -> ERROR 1044: Access denied for user: '@localhost' to database 'mysql'
1509 mysql> SELECT CURRENT_USER();
1510 -> '@localhost'
1511
1512 PASSWORD(str)
1513 OLD_PASSWORD(str)
1514 從純文本口令 str 計算一個口令字符串。這個函數用於對存儲到授權表 user 的Password 列中的 MySQL 口令進行加密。
1515 mysql> SELECT PASSWORD('badpwd');
1516 -> '7f84554057dd964b'
1517
1518 PASSWORD() 加密是不可逆的。 PASSWORD() 不以與 Unix 口令加密相同的方式進行口令加密。參見 ENCRYPT()。 注意， PASSWORD() 函數是用於在 MySQL 服務中驗證系統的，你不應該 在你的應用程序中使用它。你可以使用 MD5() 或 SHA1() 代替使用它。同樣查看 RFC-2195 可獲得有關應用程序的口令處理與安全驗證的更多信息。
1519 ENCRYPT(str[,salt])
1520 Encrypt使用 Unix crypt() 系統調用加密 str 。參數 salt 應該是一個有兩個字符的字符串，(在 MySQL 3.22.16 中，salt 可以超過兩個字符。)：
1521 mysql> SELECT ENCRYPT("hello");
1522 -> 'VxuFAJXVARROc'
1523
1524 如果 crypt() 在你的系統上不可用，ENCRYPT() 總是返回 NULL。 ENCRYPT() 只保留 str 中前 8 個字符，而忽略其它所有的，至少在某些系統上是這樣的。這取決於底層 crypt() 系統調用的行為。
1525
1526 ENCODE(str,pass_str)
1527 使用 pass_str 做為密鑰加密 str。使用 DECODE() 解密結果。結果是一個與 string 一樣長的二進制字符。如果希望將它保存到一個列中，請使用 BLOB 列類型。
1528
1529 DECODE(crypt_str,pass_str)
1530 使用 pass_str 作為密鑰解密加密後的字符串 crypt_str。crypt_str 應該是一個由 ENCODE() 返回的字符串。
1531
1532 MD5(string)
1533 計算一個字符串的 MD5 128 位校驗和。值作為一個 32 位的十六進制數字返回，例如，被用於一個哈希(hash)鍵：
1534 mysql> SELECT MD5("testing");
1535 -> 'ae2b1fca515949e5d54fb22b8ed95575'
1536
1537 這是 "RSA 數據安全公司的 MD5 消息-摘要算法"。
1538
1539 SHA1(string)
1540 SHA(string)
1541 計算一個字符串的 SHA1 160 位校驗和（在 RFC 3174 (Secure Hash Algorithm) 中被描述)。返回值是一個 40 位的十六進制數字，或在輸入參數為 NULL 的情況下，返回值為 NULL。一個使用這個函數的可能就是用於一個哈希鍵。你也可以使用它作為存儲密碼時的密碼安全函數。
1542 mysql> SELECT SHA1("abc");
1543 -> 'a9993e364706816aba3e25717850c26c9cd0d89d'
1544
1545 SHA1() 在MySQL 4.0.2 中被加入，並可被當做比 MD5() 加密更安全的等價物。SHA() 是 SHA1() 的同義詞。
1546
1547 AES_ENCRYPT(string,key_string)
1548 AES_DECRYPT(string,key_string)
1549 這些函數允許使用官方的 AES(Advanced Encryption Standardadvanced 先進的密碼技術標准) 算法加密/解密數據。加密時使用 128 位長的密鑰，但是你可以通過修改源碼將其擴展到 256 位。我們選擇 128 位是因為它更快一點並且已足夠安全了。 輸入的參數可以是任意長度的。如果任何一個參數是 NULL，這個函數返回值也將是 NULL。 因為 AES 是一個塊級的算法，加密不同長度的字符串時會對其進行填充，因而結果字符串的長度也可以通過 16*(trunc(string_length/16)+1) 計算出。 如果 AES_DECRYPT() 發現數據無效或錯誤的填料，它將返回 NULL。可是，如果輸入的數據或密鑰是無效的，函數仍然可能返回一個非 NULL 值 (可能是無用的信息)。 通過修改你的 SQL 語句，你可以使用 AES 函數以一個加密的形式存儲數據：
1550 INSERT INTO t VALUES (1,AES_ENCRYPT("text","password"));
1551
1552 盡量避免在一個連接上的每個查詢中傳遞密鑰，這樣可以得到更高的安全性，上述方式可以通過連接時在服務器端存儲密鑰來完成：
1553 SELECT @password:="my password";
1554 INSERT INTO t VALUES (1,AES_ENCRYPT("text",@password));
1555
1556 AES_ENCRYPT() 和 AES_DECRYPT() 在 MySQL 4.0.2 中被加入，可以被考慮為當前 MySQL 中可用的加解密函數中最密碼安全的。
1557
1558 DES_ENCRYPT(string_to_encrypt [, (key_number | key_string) ] )
1559 使用 Triple-DES 算法以給定的密鑰對字符串加密。 注意，只有配置了 MySQL 對 SSL 的支持，這個函數才能正常工作。查看章節 4.3.9 使用安全地連接。 編碼密鑰以下列各項方法選擇： 參數 含義
1560 只有一個參數 des-key-file 中的第一個密鑰被使用。
1561 key number des-key-file 中給定的密鑰 (0-9) 被使用。
1562 string 給定的 key_string 將被用於加密 string_to_encrypt。
1563 返回字符串是一個二進制字符串，並且第一個字符是 CHAR(128 | key_number)。 128 被加入是為了更加容易地識別一個加密密鑰。如果你使用一個字符串密鑰，key_number 將是 127。 當發生錯誤時，這個函數返回 NULL。 返回字符串的長度將為：new_length= org_length + (8-(org_length % 8))+1。 des-key-file 的格式如下：
1564 key_number des_key_string
1565 key_number des_key_string
1566
1567 每個 key_number 必須是一個在 0 到 9 范圍之內的數字。文件中的行可以是任何次序的。des_key_string 是用於加密消息的字符串。在數字與密鑰之間至少要有一個空格。如果你沒在 DES_ENCRYPT() 指定任何密鑰參數，那麼文件中的第一個密鑰將被缺省使用。 以 FLUSH DES_KEY_FILE 命令，你可以告訴 MySQL 從密鑰文件中讀取新的密鑰值。這個操作需要你有 Reload_priv 權限。 有一套默認密鑰的一個好處就是，它給應用程序一個檢查存在的加密列值的方法，而不需要給最終用戶解密這些值的權限。
1568 mysql> SELECT customer_address FROM customer_table WHERE
1569 crypted_credit_card = DES_ENCRYPT("credit_card_number");
1570
1571 DES_DECRYPT(string_to_decrypt [, key_string])
1572 解密 DES_ENCRYPT() 加密後的字符串。 注意，只有配置了 MySQL 對 SSL 的支持，這個函數才能正常工作。查看章節 4.3.9 使用安全地連接。 如果 key_string 參數沒有給出，DES_DECRYPT() 檢查加密字符串的第一個字節，以確定用於加密原始字符串的 DES 密鑰數字，然後從 des-key-file 讀取密鑰用於解密消息。為了能這樣工作，該用戶必須有 SUPER 權限。 如果將一個 key_string 參數傳遞給該函數，這個字符串將被作為解密消息的密鑰。 如果 string_to_decrypt 看上去不像是一個加密字符串，MySQL 將返回給定的 string_to_decrypt。 當發生錯誤時，該函數返回 NULL。
1573
1574 LAST_INSERT_ID([expr])
1575 返回被插入到一個 AUTO_INCREMENT 列中的最後一個自動產生的值。查看章節 8.1.3.130 mysql_insert_id()。
1576 mysql> SELECT LAST_INSERT_ID();
1577 -> 195
1578
1579 最後產生的 ID 是以每個連接為基礎在服務器端被維護的。它不可能被其它的客戶端連接改變。如果你以一個非特殊值(即一個非 NULL 和非 0 的值)更新其它的 AUTO_INCREMENT，它甚至也不會改變。 如果你在同一時間內以一個插入語句插入了許多記錄行，LAST_INSERT_ID() 將返回第一個被插入行的值。這樣做的原因是因為，這可能列容易地在其它服務器上再現同一條 INSERT 語句。 如果 expr 被作為一個參數傳遞給 LAST_INSERT_ID()，那麼函數將返回這個參數的值，並且被設置為 LAST_INSERT_ID() 返回的下一個值。這可被用於模擬一個序列： 首先創建一個表：
1580 mysql> CREATE TABLE sequence (id INT NOT NULL);
1581 mysql> INSERT INTO sequence VALUES (0);
1582
1583 然後這個表可以被用來以下面的方式產生序列值：
1584 mysql> UPDATE sequence SET id=LAST_INSERT_ID(id+1);
1585
1586 你也可以不調用 LAST_INSERT_ID() 產生序列，但是以這種方式使用這個函數的作用就是，ID 值是在服務器端敘談最後的自動產生值被維護的(是多用戶安全的)。你可以檢索這的新的 ID 值，就好像讀取 MySQL 中任何正常的 AUTO_INCREMENT 值一樣。舉例來說，LAST_INSERT_ID()(無任何參數) 將返回一個新的 ID。C API 函數 mysql_insert_id() 也可以用來得到這個值。 注意，由於 mysql_insert_id() 僅僅只能用於在 INSERT 和 UPDATE 語句的更新之後，所以在執行了其它的 SQL 語句(比如 SELECT 或 SET)之後，你不能夠使用 C API 函數檢索到 LAST_INSERT_ID(expr) 的值。
1587
1588 FORMAT(X,D)
1589 將數字 X 格式化為一個 '#,###,###.##' 的形式，四捨五入到 D 位小數。如果 D 為 0，返回的結果將沒有小數點和小數部分：
1590 mysql> SELECT FORMAT(12332.123456, 4);
1591 -> '12,332.1235'
1592 mysql> SELECT FORMAT(12332.1,4);
1593 -> '12,332.1000'
1594 mysql> SELECT FORMAT(12332.2,0);
1595 -> '12,332'
1596
1597 VERSION()
1598 以一個字符串形式返回 MySQL 服務器的版本：
1599 mysql> SELECT VERSION();
1600 -> '3.23.13-log'
1601
1602 注意，如果你的版本以 -log 結果，那就意味著日志是被設為可用的。
1603
1604 CONNECTION_ID()
1605 返回當前連接的連接 ID(thread_id)。每個連接均有一個自己唯一的 id：
1606 mysql> SELECT CONNECTION_ID();
1607 -> 1
1608
1609 GET_LOCK(str,timeout)
1610 嘗試獲得一個由字符串 str 給定名字的鎖定與一個 timeout 秒的超時。如果鎖定被獲得成功，返回 1，如果嘗試超時，返回 0，或者一個錯誤發生(比如內存溢出或線程被 mysqladmin kill 殺死)，返回NULL。當你執行 RELEASE_LOCK()、執行一個新的 GET_LOCK()，或線程終止時，一個鎖定被釋放。這個函數可以被用於執行應用程序鎖定或模擬記錄鎖定。它會阻塞其它的客戶端用同樣的名字的鎖定請求；遵從一個給定鎖定字符串名的客戶端可以使用這個字符串來執行子協作建議的鎖定：
1611 mysql> SELECT GET_LOCK("lock1",10);
1612 -> 1
1613 mysql> SELECT IS_FREE_LOCK("lock2");
1614 -> 1
1615 mysql> SELECT GET_LOCK("lock2",10);
1616 -> 1
1617 mysql> SELECT RELEASE_LOCK("lock2");
1618 -> 1
1619 mysql> SELECT RELEASE_LOCK("lock1");
1620 -> NULL
1621
1622 注意，第二個 RELEASE_LOCK() 調用返回 NULL 是因為 "lock1" 鎖定被第二個 GET_LOCK() 調用自動地釋放了。
1623
1624 RELEASE_LOCK(str)
1625 釋放由字符串 str 命名的通過 GET_LOCK() 獲得的鎖定。如果鎖定被釋放，返回 1；如果鎖定並沒有被當前線程鎖定(在這種情況下，鎖定不會被釋放)，返回 0；如果命名的鎖定不存在，返回 NULL。如果鎖定從來就沒有通過調用一個 GET_LOCK() 獲得，或已被釋放了，那麼該鎖定將不存在。 DO 語句通常與 RELEASE_LOCK() 一起使用。查看章節 6.4.10 DO 句法。
1626
1627 IS_FREE_LOCK(str)
1628 檢查以 str 命名的鎖定是否可以自由使用(也就是說，還未鎖定)。如果鎖定被釋放了(沒有一個人使用這個鎖定)，返回 1；如果這個鎖定處於使用中，返回 0；如果發生一個錯(例如錯誤的參數)，返回 NULL。
1629
1630 BENCHMARK(count,expr)
1631 BENCHMARK() 函數用於將表達式 expr 重復運行 count 次。它可以被用於計時 MySQL 處理表達式有多快。結果通常為 0。在 mysql 客戶端有意使用它時，它將返回查詢執行所需的時間：
1632 mysql> SELECT BENCHMARK(1000000,ENCODE("hello","goodbye"));
1633 +----------------------------------------------+
1634 | BENCHMARK(1000000,ENCODE("hello","goodbye")) |
1635 +----------------------------------------------+
1636 | 0 |
1637 +----------------------------------------------+
1638 1 row in set (4.74 sec)
1639
1640 報告的時間是客戶端經過的時間，不是服務器端的 CPU 時間。執行 BENCHMARK() 多次可能是明智的，並注意服務器的負載來解釋結果。
1641
1642 INET_NTOA(expr)
1643 給定一個數字的網絡地址 (4 或 8 字節)，以一個字符串的形式返回點組表示的地址：
1644 mysql> SELECT INET_NTOA(3520061480);
1645 -> "209.207.224.40"
1646
1647 INET_ATON(expr)
1648 以字符串的形式給定一個點組表示的網絡地址，返回一個地址的數字值表示的整數。地址可以是 4 或 8 個字節的地址：
1649 mysql> SELECT INET_ATON("209.207.224.40");
1650 -> 3520061480
1651
1652 產生的數字通常是以網絡地址字節的順序；例如，上面的數字是以 209*256^3 + 207*256^2 + 224*256 +40 被計算出來的。
1653
1654 MASTER_POS_WAIT(log_name, log_pos)
1655 阻塞，只到從服務器到達(也就是說，已讀取並應用了所有更新，一直到)主服務器上的日志中指定的位置。如果主服務器上的信息沒有初始化，或如果參數錯誤，返回 NULL。如果從服務器沒有運行，將阻塞並造作，只到它啟動並到達或超過指定的位置。如果從服務器已超過指定的位置，立即返回。 如果 timeout (在 4.0.10 中新加入) 被指定，當等待 timeout 秒經過後，將放棄。timeout 必須大於 0；一個零或一個負值 timeout 意味著超時。返回值是到達日志指定位置所必須等待的日志事件的數量，或者在出錯的情況下為 NULL，或者超過超時時間返回 -1。 這個命令有益於控制主從服務器的同步，但是最初是為了復制測試的方便而寫的。
1656
1657 FOUND_ROWS()
1658 返回最後一個 SELECT SQL_CALC_FOUND_ROWS ... 命令如果沒有以 LIMIT 進行限制結果時將返回記錄行數。
1659 mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name
1660 WHERE id > 100 LIMIT 10;
1661 mysql> SELECT FOUND_ROWS();
1662
1663 第二個 SELECT 將返回一個數字，它指示前一個沒有被 LIMIT 子句限制的 SELECT 將返回多少行記錄。注意，如果你使用 SELECT SQL_CALC_FOUND_ROWS ...，MySQL 不得不計算所有的記錄行到結果集中。然而，這與你不使用 LIMIT 相比是更快一點的，因為結果集不需要發送到客戶端。 SQL_CALC_FOUND_ROWS 從 MySQL 4.0.0 開始可以被使用。
1664 6.3.7 用於 GROUP BY 子句的函數
1665
1666 如果在一個沒有包含 GROUP BY 子句的一個語句中使用聚合函數，它將等價於將所有的記錄行分為一組。
1667
1668 COUNT(expr)
1669 返回由一個 SELECT 語句檢索出來的記錄行中非 NULL 值的記錄總數目：
1670 mysql> SELECT student.student_name,COUNT(*)
1671 -> FROM student,course
1672 -> WHERE student.student_id=course.student_id
1673 -> GROUP BY student_name;
1674
1675
1676 COUNT(*) 在它返回檢索出的記錄行的數目上稍微有點不同，它不管記錄行中是否包括 NULL 值。 如果 SELECT 語句從一個表中進行檢索，沒有檢索其它的列，並且沒有 WHERE 子句，那麼 COUNT(*) 將被優化以便更快地返回值。示例如下：
1677 mysql> SELECT COUNT(*) FROM student;
1678
1679 COUNT(DISTINCT expr,[expr...])
1680 返回一個互不相同的非 NULL 的值的總數目：
1681 mysql> SELECT COUNT(DISTINCT results) FROM student;
1682
1683 在 MySQL 中，通過給出一個表達式列表，可以得到不包含 NULL 的不同的表達式組合的數目。在 ANSI SQL 中，你可能不得不在 COUNT(DISTINCT ...) 中拼接所有的表達式。
1684
1685 AVG(expr)
1686 返回 expr 的平均值：
1687 mysql> SELECT student_name, AVG(test_score)
1688 -> FROM student
1689 -> GROUP BY student_name;
1690
1691 MIN(expr)
1692 MAX(expr)
1693 返回 expr 的最小或最大值。MIN() 和 MAX() 可以接受一個字符串參數；在這種情況下，它們將返回最小或最大的字符串傳下。查看章節 5.4.3 MySQL 如何使用索引。
1694 mysql> SELECT student_name, MIN(test_score), MAX(test_score)
1695 -> FROM student
1696 -> GROUP BY student_name;
1697
1698 在 MIN()、MAX() 和其它的合計函數中，MySQL 通常列的字符串值比較 ENUM 和 SET 列，而不是字符串在集合中相對應的位置。這將會被修正。
1699 SUM(expr)
1700 返回 expr 的總和。注意，如果返回集中沒有從我任何記錄行，它將返回 NULL ！
1701
1702 GROUP_CONCAT(expr)
1703 完整句法如下：
1704 GROUP_CONCAT([DISTINCT] expr [,expr ...]
1705 [ORDER BY {unsigned_integer | col_name | formula} [ASC | DESC] [,col ...]]
1706 [SEPARATOR str_val])
1707
1708 這個函數在 MySQL 4.1 中被加入。函數返回一個字符串結果，該結果由分組中的值連接組合而成：
1709 mysql> SELECT student_name,
1710 -> GROUP_CONCAT(test_score)
1711 -> FROM student
1712 -> GROUP BY student_name;
1713 or
1714 mysql> SELECT student_name,
1715 -> GROUP_CONCAT(DISTINCT test_score
1716 -> ORDER BY test_score DESC SEPARATOR " ")
1717 -> FROM student
1718 -> GROUP BY student_name;
1719
1720 在 MySQL 中，你可以得到表達式結合體的連結值。通過使用 DISTINCT 可以排除重復值。如果希望對結果中的值進行排序，可以使用 ORDER BY 子句。為了以倒序排序，可以在 ORDER BY 子句中用於排序的列名後添加一個 DESC (遞減 descending) 關鍵詞。缺省為升序；這也可以通過使用 ASC 關鍵詞明確指定。 SEPARATOR 是一個字符串值，它被用於插入到結果值中。缺省為一個逗號 (",")。你可以通過指定 SEPARATOR "" 完全地移除這個分隔符。 在你的配置中，通過變量 group_concat_max_len 要以設置一個最大的長度。在運行時執行的句法如下：
1721 SET [SESSION | GLOBAL] group_concat_max_len = unsigned_integer;
1722
1723 如果最大長度被設置，結果值被剪切到這個最大長度。 GROUP_CONCAT() 函數是一個增強的 Sybase SQL Anywhere 支持的基本 LIST() 函數。如果只有一個列，並且沒有其它選項被指定，GROUP_CONCAT() 是向後兼容有極大限制的 LIST() 函數。 LIST() 有一個缺省的排序次序。
1724 示例(譯者注)：
1725
1726 mysql> CREATE TABLE `ta` (
1727 -> `id` smallint(5) unsigned NOT NULL default '0',
1728 -> `name` char(60) NOT NULL default '',
1729 -> KEY `id` (`id`)
1730 -> ) TYPE=MyISAM;
1731 Query OK, 0 rows affected (0.02 sec)
1732
1733 mysql> INSERT INTO `ta` VALUES("1", "a"),("1", "b"),
1734 -> ("1", "c"),("1", "d"),("2", "a"),
1735 -> ("2", "b"),("2", "c"),("3", "d");
1736 Query OK, 8 rows affected (0.03 sec)
1737 Records: 8 Duplicates: 0 Warnings: 0
1738
1739 mysql> SELECT * FROM `ta`;
1740 +----+------+
1741 | id | name |
1742 +----+------+
1743 | 1 | a |
1744 | 1 | b |
1745 | 1 | c |
1746 | 1 | d |
1747 | 2 | a |
1748 | 2 | b |
1749 | 2 | c |
1750 | 3 | d |
1751 +----+------+
1752 8 rows in set (0.00 sec)
1753
1754 mysql> SELECT `id`,
1755 -> GROUP_CONCAT(`name`)
1756 -> FROM `ta`
1757 -> GROUP BY `id`;
1758 +----+----------------------+
1759 | id | GROUP_CONCAT(`name`) |
1760 +----+----------------------+
1761 | 1 | a c b d |
1762 | 2 | a c b |
1763 | 3 | d |
1764 +----+----------------------+
1765 3 rows in set (0.03 sec)
1766
1767 # SEPARATOR 缺省是一個空格而不是一個逗號
1768
1769 mysql> SELECT `id`,
1770 -> GROUP_CONCAT(DISTINCT `name`
1771 -> ORDER BY `name` DESC SEPARATOR ",") AS Result
1772 -> FROM `ta`
1773 -> GROUP BY `id`;
1774 +----+---------+
1775 | id | Result |
1776 +----+---------+
1777 | 1 | d,c,b,a |
1778 | 2 | c,b,a |
1779 | 3 | d |
1780 +----+---------+
1781 3 rows in set (0.00 sec)
1782
1783 * 以上結果在 MySQL 4.1 中測試
1784
1785 示例結束(譯者注)
1786
1787 VARIANCE(expr)
1788 返回 expr 的標准方差(standard variance)。這是對 ANSI SQL 的擴展(只有在 4.1 或更新的版本中可用)。
1789
1790 STD(expr)
1791 STDDEV(expr)
1792 返回 expr 的標准偏差(standard deviation)。這是對 ANSI SQL 的擴展。這個函數的 STDDEV() 格式是為了 Oracle 兼容而提供的。
1793
1794 BIT_OR(expr)
1795 返回 expr 中所有比特位的位 OR。計算以 64 位 (BIGINT) 精度執行。
1796
1797 BIT_AND(expr)
1798 返回 expr 中所有比特位的位 AND。計算以 64 位 (BIGINT) 精度執行。
1799 示例(譯者注)：
1800
1801
1802 mysql> CREATE TABLE `ta` (
1803 -> `id` smallint(5) unsigned NOT NULL default '0',
1804 -> KEY `id` (`id`)
1805 -> ) TYPE=MyISAM;
1806 Query OK, 0 rows affected (0.01 sec)
1807
1808 mysql> INSERT INTO `ta` VALUES("1"),("2"),("3"),("4");
1809 Query OK, 8 rows affected (0.00 sec)
1810 Records: 4 Duplicates: 0 Warnings: 0
1811
1812 mysql> SELECT BIT_OR(id) from ta;
1813 +------------+
1814 | BIT_OR(id) |
1815 +------------+
1816 | 7 |
1817 +------------+
1818 1 row in set (0.00 sec)
1819
1820 # ..0001
1821 # ..0010
1822 # ..0011
1823 # ..0100
1824 # OR ..0000
1825 # ---------
1826 # ..0111
1827
1828 mysql> SELECT BIT_AND(id) from ta;
1829 +-------------+
1830 | BIT_AND(id) |
1831 +-------------+
1832 | 0 |
1833 +-------------+
1834 1 row in set (0.00 sec)
1835
1836 # ..0001
1837 # ..0010
1838 # ..0011
1839 # ..0100
1840 # AND ..1111
1841 # ----------
1842 # ..0000
1843
1844 * 以上結果在 MySQL 4.1 中測試
1845
1846 示例結束(譯者注)
1847
1848 MySQL 擴展了 GROUP BY 的用法。在 SELECT 表達式中，你可以使用或計算沒有出現在 GROUP BY 部分中的列。這代表 這個組的任何可能的值。你可以使用它避免在不必要的分類項目上進行排序和分組，這樣會得到更好的性能。舉例來說，在下面的例子中，你不必要以 customer.name 進行分組：
1849
1850 mysql> SELECT order.custid,customer.name,MAX(payments)
1851 -> FROM order,customer
1852 -> WHERE order.custid = customer.custid
1853 -> GROUP BY order.custid;
1854
1855 在 ANSI SQL 中，必須將customer.name 添加到 GROUP BY 子句。而在 MySQL 中，如果沒有以 ANSI 模式運行，該名是多余的。
1856
1857 如果你在 GROUP BY 部分省略的列在分組中不是唯一的，請不要使用這個特征！否則將得到不可預知的結果。
1858
1859 在某些情況下，可以使用 MIN() 和 MAX() 獲得一個特定的列值，即使它不是唯一的。下面的示例取出包含了 sort 列中最小值的記錄行中的 column 的值：
1860
1861 SUBSTR(MIN(CONCAT(RPAD(sort,6,' '),column)),7)
1862
1863 查看章節 3.5.4 擁有某個字段的組間最大值的記錄行。
1864
1865 注意，如果你所使用的是 MySQL 3.22 (或更早的版本)，或者你正試圖遵從 ANSI SQL，你不能在 GROUP BY 或 ORDER BY 子句中使用表達式。你可以使用表達式的別名來應付這個限制：
1866
1867 mysql> SELECT id,FLOOR(value/100) AS val FROM tbl_name
1868 -> GROUP BY id,val ORDER BY val;
1869
1870 在 MySQL 3.23 中，你可以這樣做：
1871
1872 mysql> SELECT id,FLOOR(value/100) FROM tbl_name ORDER BY RAND();
