6.3 用於 SELECT 和 WHERE 子句的函數
一個 SQL 語句中的 select_expression 或 where_definition 可由任何使用了下面所描述函數的表達式組成。
包含 NULL 的表達式總是得出一個 NULL 值結果，除非表達式中的操作和函數在文檔中有另外的說明。
注意：在一個函數名和跟隨它的括號之間必須不存在空格。這有助於 MySQL 語法分析程序區分函數調用和對恰巧與函數同名表或列的引用。然而，參數左右兩邊的空格卻是允許的。
你可以強制 MySQL 接受函數名後存在空格的形式，這需要通過以 --ansi 選項啟動 mysqld，或在 mysql_connect() 中使用 CLIENT_IGNORE_SPACE，但是，在這種情況下，所有的函數名均將成為保留字。查看章節 1.8.2 以 ANSI 模式運行 MySQL.
為了簡潔，從 MySQL 程序輸出的例子以縮寫的形式顯示。因此：
MySQL> SELECT MOD(29,9);
1 rows in set (0.00 sec)
+-----------+
| mod(29,9) |
+-----------+
| 2 |
+-----------+
將被顯示為這樣：
MySQL> SELECT MOD(29,9);
-> 2
6.3.1 無類型的特殊運算符和函數
6.3.1.1 圓括號
( ... )
括號，使用它來強制一個表達式的計算順序。
MySQL> SELECT 1+2*3;
-> 7
MySQL> SELECT (1+2)*3;
-> 9
6.3.1.2 比較運算符
比較運算符的結果是 1 (TRUE)、0 (FALSE) 或 NULL。這些函數可工作於數字和字符串上。根據需要，字符串將會自動地被轉換到數字，以及數字被轉換成字符串(比如在 Perl 中)。
MySQL 使用下列規則進行比較：
* 如果一個或兩個參數是 NULL，比較的結果是 NULL，除了 <=> 運算符。
* 如果在一個比較操作中兩個參數均是字符串，他們將作為字符串被比較。
* 如果兩個參數均是整數，他們作為整數被比較。
* 十六進制值如果不與一個數字進行比較，那麼它將當作一個二進制字符串。
* 如果參數之一是一個 TIMESTAMP 或 DATETIME 列，而另一參數是一個常數，在比較執行之前，這個常數被轉換為一個時間戳。這樣做是為了對 ODBC 更友好。
* 在所有其它情況下，參數作為浮點(real)數字被比較。
缺省地，字符串使用當前字符集以忽略字母大小寫的方式進行比較(缺省的字符集為 ISO-8859-1 Latin1，它對英語處理得很出色)。
下面的例子演示了對於比較操作字符串到數字的轉換：
MySQL> SELECT 1 > '6x';
-> 0
MySQL> SELECT 7 > '6x';
-> 1
MySQL> SELECT 0 > 'x6';
-> 0
MySQL> SELECT 0 = 'x6';
-> 1
=
等於：
MySQL> SELECT 1 = 0;
-> 0
MySQL> SELECT '0' = 0;
-> 1
MySQL
$False$
> SELECT '0.0' = 0;
-> 1
MySQL> SELECT '0.01' = 0;
-> 0
MySQL> SELECT '.01' = 0.01;
-> 1
<>
!=
不等於：
MySQL> SELECT '.01' <> '0.01';
-> 1
MySQL> SELECT .01 <> '0.01';
-> 0
MySQL> SELECT 'zapp' <> 'zappp';
-> 1
<=
小於或等於：
MySQL> SELECT 0.1 <= 2;
-> 1
<
小於：
MySQL> SELECT 2 < 2;
-> 0
>=
大於或等於：
MySQL> SELECT 2 >= 2;
-> 1
>
大於：
MySQL> SELECT 2 > 2;
-> 0
<=>
NULL 值安全等於：
MySQL> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
-> 1 1 0
IS NULL
IS NOT NULL
測試一個值是或不是 NULL:
MySQL> SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL;
-> 0 0 1
MySQL> SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;
-> 1 1 0
為了能夠與其它程序更好的工作，在使用 IS NULL 是 MySQL 支持下列額外選擇性：
* 通過它，你可以找到最後插入的記錄行：
SELECT * FROM tbl_name WHERE auto_col IS NULL
這個操作可以通過設置 SQL_AUTO_IS_NULL=0 來禁止。查看章節 5.5.6 SET 句法.
* 對於 NOT NULL 的 DATE 和 DATETIME 列，可以通過使用下列語句找到特殊的值 0000-00-00：
SELECT * FROM tbl_name WHERE date_column IS NULL
您正在看的MySQL教程是:用於 SELECT 和 WHERE 子句的函數。> 這需要通過某些 ODBC 應用程序才能工作(因為 ODBC 不支持一個 0000-00-00 日期)
expr BETWEEN min AND max
如果 expr 大於或等於 min ，並且 expr 小於或等於 max，BETWEEN 返回 1，否則返回 0。它等價於表達式 (min <= expr AND expr <= max) ，只要所有的參數均是相同的類型。 否則類型會依照上面的規則發生轉換，但是應用於所有三個參數。注意，在 MySQL 4.0.5 之前，參數被轉換到 expr 的類型。
MySQL> SELECT 1 BETWEEN 2 AND 3;
-> 0
MySQL> SELECT 'b' BETWEEN 'a' AND 'c';
-> 1
MySQL> SELECT 2 BETWEEN 2 AND '3';
-> 1
MySQL> SELECT 2 BETWEEN 2 AND 'x-3';
-> 0
expr NOT BETWEEN min AND max
等同於 NOT (expr BETWEEN min AND max)。
expr IN (value,...)
如果 expr 是 IN 列表中的作一值，它將返回 1，否則返回 0。如果所有的值均是常數，那麼所有的值被依照 expr 的類型進行計算和排序。然後以一個二進制搜索方式完成項目的搜索。這就意味著，如果 IN 列表完全由常數組成，IN 將是非常快的。如果 expr 是一個字母大小寫敏感的字符串表達式，字符串比較將以大小寫敏感方式執行：
MySQL> SELECT 2 IN (0,3,5,'wefwf');
-> 0
MySQL> SELECT 'wefwf' IN (0,3,5,'wefwf');
-> 1
從 MySQL 4.1 開始(符合 SQL-99 標准)，如果左手邊的表達式是 NULL，或者在列表中沒有發現相匹配的值並且列表中的一個表達式是 NULL，IN 均返回 NULL。
expr NOT IN (value,...)
等同於 NOT (expr IN (value,...))。
ISNULL(expr)
如果 expr 是 NULL，ISNULL() 返回
1，否則返回 0：
MySQL> SELECT ISNULL(1+1);
-> 0
MySQL> SELECT ISNULL(1/0);
-> 1
注意，對 NULL 值使用 = 進行比較總是為 false ！
COALESCE(list)
返回列表中第一個非 NULL 的元素：
MySQL> SELECT COALESCE(NULL,1);
-> 1
MySQL> SELECT COALESCE(NULL,NULL,NULL);
-> NULL
INTERVAL(N,N1,N2,N3,...)
Returns 如果 N < N1 返回 0，如果 N < N2 返回 1，等等。所有的參數均被當作整數。為了函數能正確地工作，它要求 N1 < N2 < N3 < ... < Nn。這是因為它使用的是一個二進制的搜索(非常地快)：
MySQL> SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200);
-> 3
MySQL> SELECT INTERVAL(10, 1, 10, 100, 1000);
-> 2
MySQL> SELECT INTERVAL(22, 23, 30, 44, 200);
-> 0
如果以任何一個標准運算符(=, <>..., 但除了 LIKE)對一個忽略大小寫的字符串進行比較，尾部的空白空間(空格、TAB 和換行)均被忽略。
MySQL> SELECT "a" ="A \n";
-> 1
6.3.1.3 邏輯運算符
在 SQL 中，所有的邏輯運算符返回的值均為 TRUE、FALSE 或 NULL (未知)。在 MySQL 中，它們由 1 (TRUE)、0 (FALSE) 和 NULL 實現。這些大部分在不同的 SQL 數據庫間是相同的，然而某些可能會以一個非零值返回 TRUE。
NOT
!
邏輯非。如果操作數為 0，返回 1；如果操作數為非零，返回 0；如果操作數為 NOT NULL，返回 NULL。
MySQL> SELECT NOT 10;
-> 0
MySQL> SELECT NOT 0;
-> 1
MySQL> SELECT NOT NULL;
-> NULL
MySQL> SELECT ! (1+1);
-> 0
MySQL> SELECT ! 1+1;
-> 1
最後一個例子返回 1，因為表達式是與 (!1)+1 一樣被計算的。
AND
&&
邏輯與。如果所有的操作數都是非零或非 NULL 的，返回 1；如果有一個或多個操作數為 0 ，則返回 0，只要操作數中有 NULL 返回值就為 NULL。
MySQL> SELECT 1 && 1;
-> 1
MySQL> SELECT 1 && 0;
-> 0
MySQL> SELECT 1 && NULL;
-> NULL
MySQL> SELECT 0 && NULL;
-> 0
MySQL> SELECT NULL && 0;
-> 0
請注意，在 MySQL 4.0.5 以前版本中，當遇到一個 NULL 時就停止計算，而不是繼續進程檢查可能存在的0。這就意味著，在這些版本中，SELECT (NULL AND 0) 返回 NULL，而不是 0。在 4.0.5 中，代碼已被重新設計了，已便於在任何仍然使用優化情況下，返回值總是能如 ANSI 所規定的那樣。
OR
||
邏輯或。如果任何一個操作數是非零的，返回值為 1，如果任一操作數為 NULL，返回值為 NULL，否則返回 0。
MySQL> SELECT 1 || 1;
-> 1
MySQL> SELECT 1 || 0;
-> 1
MySQL> SELECT 0 || 0;
-> 0
MySQL> SELE您正在看的MySQL教程是:用於 SELECT 和 WHERE 子句的函數。CT 0 || NULL;
-> NULL
MySQL> SELECT 1 || NULL;
-> 1
XOR
邏輯異或。如果任一操作數為 NULL，返回值為 NULL。對於非 NULL 的操作數，如果有奇數個非零的操作數，結果返回為 1，否則返回 0。
MySQL> SELECT 1 XOR 1;
-> 0
MySQL> SELECT 1 XOR 0;
-> 1
MySQL> SELECT 1 XOR NULL;
-> NULL
MySQL> SELECT 1 XOR 1 XOR 1;
-> 1
a XOR b 算術相等於 (a AND (NOT b)) OR ((NOT a) and b)。 XOR 在 MySQL 4.0.2 中被添加。
6.3.1.4 控制流函數
IFNULL(expr1,expr2)
如果 expr1 為非 NULL 的，IFNULL() 返回 expr1，否則返回 expr2。IFNULL() 返回一個數字或字符串值，這取決於它被使用的語境：
MySQL> SELECT IFNULL(1,0);
-> 1
MySQL> SELECT IFNULL(NULL,10);
-> 10
MySQL> SELECT IFNULL(1/0,
10);
-> 10
MySQL> SELECT IFNULL(1/0,'yes');
-> 'yes'
在 MySQL 4.0.6 和更新版本中，IFNULL(expr1,expr2) 的默認返回值以 STRING、REAL 或 INTEGER 順序更加'general'了兩個表達式。當你基於一個表達式創建一個表或在一個臨時表中 MySQL 不得不存儲一個從 IFNULL() 返回的值時，這個與較早 MySQL 版本的不同將更加值得注意。
CREATE TABLE foo SELECT IFNULL(1,"test") as test;
在 MySQL 4.0.6 中，列 'test' 的類型為 CHAR(4)，然而在較早的版本中，你得到的卻是 BIGINT。
NULLIF(expr1,expr2)
如果 expr1 = expr2 為真，返回 NULL，否則返回 expr1。它等同於 CASE WHEN x = y THEN NULL ELSE x END：
MySQL> SELECT NULLIF(1,1);
-> NULL
MySQL> SELECT NULLIF(1,2);
-> 1
注意，如果參數不相等，在 MySQL 中，expr1 被求值兩次。
IF(expr1,expr2,expr3)
如果 expr1 為真(expr1 <> 0 以及 expr1 <> NULL)，那麼 IF() 返回 expr2，否則返回 expr3。IF() 返回一個數字或字符串，這取決於它被使用的語境：
MySQL> SELECT IF(1>2,2,3);
-> 3
MySQL> SELECT IF(1<2,'yes','no');
-> 'yes'
MySQL> SELECT IF(STRCMP('test','test1'),'no','yes');
-> 'no'
如果 expr2 或 expr3 明確地為 NULL，那麼函數 IF() 的返回值類型為非 NULL 列的類型。(這在選擇在 MySQL 4.0.3 中新加入)。 expr1 是作為一個整數值被計算的，這就意味著，如果測試的是一個浮點型或字符串值，就必須進行比較操作：
MySQL> SELECT IF(0.1,1,0);
-> 0
MySQL> SELECT IF(0.1<>0,1,0);
-> 1
在上面第一種情況下，IF(0.1) 返回 0，是因為 0.1 被轉換為一個整數值，返回 IF(0) 的測試結果。這可能不是你所期望的。在第二種情況下，比較測試原浮點數是否為一個非零值。比較的結果被作為整數使用。 缺省的 IF() 返回值類型 (當結果存儲在臨時表中時，這是非常重要的) 在 MySQL 3.23 中按下列方式確定：
表達式 返回值
表達式(expr2)或表達式(expr3)返回值為字符串 字符串
表達式(expr2)或表達式(expr3)返回值為浮點型值 浮點型
表達式(expr2)或表達式(expr3)返回值為整型 整型
如果表達式(expr2)和表達式(expr3)均是字符串，同時兩個字符串均是忽略字母大小寫的，那麼返回值也是忽略字母大小寫的(從 MySQL 3.23.51 開始)。
CASE value WHEN [compare-value] THEN result [WHEN [compare-value] THEN result ...] [ELSE result] END
CASE WHEN [condition] THEN result [WHEN [condition] THEN result ...] [ELSE result] END
第一個形式當 value=compare-value 時返回 result。第二個形式當第一個為真值的 condition 出現時，返回該條件的結果。如果沒有匹配的結果值，那麼 ELSE 後的結果將被返回。
如果沒有 ELSE 部分，那麼 NULL 被返回：
MySQL> SELECT CASE 1 WHEN 1 THEN "one"
WHEN 2 THEN "two" ELSE "more" END;
-> "one"
MySQL> SELECT CASE WHEN 1>0 THEN "true" ELSE "false" END;
-> "true"
MySQL> SELECT CASE BINARY "B" WHEN "a" THEN 1 WHEN "b" THEN 2 END;
-> NULL
返回值的類型 (INTEGER、DOUBLE 或 STRING) 與第一個返回值(第一個 THEN 後的表達式)的類型相同。
6.3.2 字符串函數
如果返回結果的長度超過服務器參數 max_allowed_packet 的大小，字符串值函數將返回 NULL。查看章節 5.5.2 調節服務器參數。
對於操作字符串位置的函數，第一個位置被標記為 1。
ASCII(str)
返回字符串 str 最左邊的那個字符的 ASCII 碼值。如果 str 是一個空字符串，那麼返回值為 0。如果 str 是一個 NULL，返回值也是 NULL：
MySQL> SELECT ASCII('2');
您正在看的MySQL教程是:用於 SELECT 和 WHERE 子句的函數。 -> 50
MySQL> SELECT ASCII(2);
-> 50
MySQL> SELECT ASCII('dx');
-> 100
也可參看 ORD() 函數。
ORD(str)
如果字符串 str 的最左邊的字符是一個多字節的字符，根據多字節字符的成分字符的 ASCII 碼值通過下面的公式計算返回那個的編碼：((first byte ASCII code)*256+(second byte ASCII code))[*256+third byte ASCII code...]。如果最左邊的字符不是一個多字節字符，返回值與 ASCII() 函數相同：
MySQL> SELECT ORD('2');
-> 50
CONV(N,from_base,to_base)
在不同的數字基數之間轉換數字。將數字 N 從 from_base 轉換到 to_base，並以字符串表示形式返回。如果任何一個參數為 NULL，那麼返回值也為 NULL。參數 N 被解釋為是一個整數，但是也可以被指定為一個整數或一個字符串。最小基為 2，最大基為 36。如果 to_base 是一個負值，N 將被看作為是一個有符號數字。否則，N 被視為是無符號的。CONV 以 64 位精度工作：
MySQL> SELECT CONV("a",16,2);
-> '1010'
MySQL> SELECT CONV("6E",18,8);
-> '172'
MySQL> SELECT CONV(-17,10,-18);
-> '-H'
MySQL> SELECT CONV(10+"10"+'10'+0xa,10,10);
-> '40'
BIN(N)
返回 N 的字符串表示的二進制值形式，在這裡，N 長長的(BIGINT)數字。這個函數等價於 CONV(N,10,2)。如果 N 是一個 NULL，返回值也是 NULL：
MySQL> SELECT BIN(12);
-> '1100'
OCT(N)
返回 N 的字符串表示的八進制值形式，在這裡，N 是一個長長的數字。這個函數等價於 CONV(N,10,8)。如果 N 是一個 NULL，返回值也是 NULL ：
MySQL> SELECT OCT(12);<
br /> -> '14'
HEX(N_or_S)
如果 N_OR_S 是一個數字，返回 N 的字符串表示的十六進制值形式，這裡 N 是一個長長的(BIGINT)數字。這個函數等價於 CONV(N,10,16)。 如果 N_OR_S 是一個字符串，N_OR_S 中的每個字符均被轉換為 2 位十六進制數字，並以十六進制的字符串形式返回。這是 0xff 形式的字符串反轉操作。
MySQL> SELECT HEX(255);
-> 'FF'
MySQL> SELECT HEX("abc");
-> 616263
MySQL> SELECT 0x616263;
-> "abc"
CHAR(N,...)
CHAR() 以整數類型解釋參數，返回這個整數所代表的 ASCII 碼值給出的字符組成的字符串。NULL 值將被忽略：
MySQL> SELECT CHAR(77,121,83,81,'76');
-> 'MySQL'
MySQL> SELECT CHAR(77,77.3,'77.3');
-> 'MMM'
CONCAT(str1,str2,...)
將參數連接成字符串返回。如果有任何一個參數為 NULL，返回值也為 NULL。可以有超過 2 個的參數。數字參數將被轉換為相等價的字符串形式：
MySQL> SELECT CONCAT('My', 'S', 'QL');
-> 'MySQL'
MySQL> SELECT CONCAT('My', NULL, 'QL');
-> NULL
MySQL> SELECT CONCAT(14.3);
-> '14.3'
CONCAT_WS(separator, str1, str2,...)
CONCAT_WS() 支持 CONCAT 加上一個分隔符，它是一個特殊形式的 CONCAT()。第一個參數剩余參數間的分隔符。分隔符可以是與剩余參數一樣的字符串。如果分隔符是 NULL，返回值也將為 NULL。這個函數會跳過分隔符參數後的任何 NULL 和空字符串。分隔符將被加到被連接的字符串之間：
MySQL> SELECT CONCAT_WS(",","First name","Second name","Last Name");
-> 'First name,Second name,Last Name'
MySQL> SELECT CONCAT_WS(",","First name",NULL,"Last Name");
-> 'First name,Last Name'
LENGTH(str)
OCTET_LENGTH(str)
CHAR_LENGTH(str)
CHARACTER_LENGTH(str)
返回字符串 str 的長度：
MySQL> SELECT LENGTH('text');
-> 4
MySQL> SELECT OCTET_LENGTH('text');
-> 4
注意，CHAR_LENGTH() 和 CHARACTER_LENGTH() 對於多字節字符只計數一次。
BIT_LENGTH(str)
返回字符串 str 的比特長度：
MySQL> SELECT BIT_LENGTH('text');
-> 32
LOCATE(substr,str)
POSITION(substr IN str)
返回子串 substr 在字符串 str 中第一次出現的位置。如果子串 substr 在 str 中不存在，
返回值為 0：
MySQL> SELECT LOCATE('bar', 'foobarbar');
-> 4
MySQL> SELECT LOCATE('xbar', 'foobar');
-> 0
這個函數是多字節安全的。在 MySQL 3.23 中，這個函數是字母大小寫敏感的，當在 MySQL 4.0 中時，如有任一參數是一個二進制字符串，它才是字母大小寫敏感的。
LOCATE(substr,str,pos)
返回子串 substr 在字符串 str
您正在看的MySQL教程是:用於 SELECT 和 WHERE 子句的函數。中的第 pos 位置後第一次出現的位置。如果 substr 不在 str 中返回 0 ：
MySQL> SELECT LOCATE('bar', 'foobarbar',5);
-> 7
這個函數是多字節安全的。在 MySQL 3.23 中，這個函數是字母大小寫敏感的，當在 MySQL 4.0 中時，如有任一參數是一個二進制字符串，它才是字母大小寫敏感的。
INSTR(str,substr)
返回子串 substr 在字符串 str 中第一次出現的位置。這與有兩個參數形式的 LOCATE() 相似，只是參數的位置被顛倒了：
MySQL> SELECT INSTR('foobarbar', 'bar');
-> 4
MySQL> SELECT INSTR('xbar', 'foobar');
-> 0
這個函數是多字節安全的。在 MySQL 3.23 中，這個函數是字母大小寫敏感的，當在 MySQL 4.0 中時，如有任一參數是一個二進制字符串，它才是字母大小寫敏感的。
LPAD(str,len,padstr)
用字符串 padstr 對 str 進行左邊填補直至它的長度達到 len 個字符長度，然後返回 str。如果 str 的長度長於 len'，那麼它將被截除到 len 個字符。
MySQL> SELECT LPAD('hi',4,'??');
-> '??hi'
RPAD(str,len,padstr)
用字符串 padstr 對 str 進行右邊填補直至它的長度達到 len 個字符長度，然後返回 str。如果 str 的長度長於 len'，那麼它將被截除到 len 個字符。
MySQL> SELECT RPAD('hi',5,'?');
-> 'hi???'
LEFT(str,len)
返回字符串 str 中最左邊的 len 個字符：
MySQL> SELECT LEFT('foobarbar', 5);
-> 'fooba'
這個函數是多字節安全的。
RIGHT(str,len)
返回字符串 str 中最右邊的 len 個字符：
MySQL> SELECT RIGHT('foobarbar', 4);
-> 'rbar'
這個函數是多字節安全的。
SUBSTRING(str,pos,len)
SUBSTRING(str FROM pos FOR len)
MID(str,pos,len)
從字符串 str 的 pos 位置起返回 len 個字符的子串。使用 FROM 的變體形式是 ANSI SQL92 的句法：
MySQL> SELECT SUBSTRING('Quadratically',5,6);
-> 'ratica'
這個函數是多字節安全的。
SUBSTRING(str,pos)
SUBSTRING(str FROM pos)
從字符串 str 的 pos 位置起返回子串：
MySQL> SELECT SUBSTRING('Quadratically',5);
-> 'ratically'
MySQL> SELECT SUBSTRING('foobarbar' FROM 4);
-> 'barbar'
這個函數是多字節安全的。
SUBSTRING_INDEX(str,delim,count)
返回字符串 str 中在第 count 個出現的分隔符 delim 之前的子串。如果 count 是一個正數，返回從最後的(從左邊開始計數)分隔符到左邊所有字符。如果 count 是負數，返回從最後的(從右邊開始計數)分隔符到右邊所有字符：
mysql> SELECT SUBSTRING_INDEX('www.MySQL.com', '.', 2);
-> 'www.MySQL'
mysql> SELECT SUBSTRING_INDEX('www.MySQL.com', '.', -2);
-> 'MySQL.com'
這個函數是多字節安全的。
LTRIM(str)
返回移除了領頭的空格字符後的 str：
MySQL> SELECT LTRIM(' barbar');
-> 'barbar'
RTRIM(str)
返回移除了尾部的空格字符後的 str：
MySQL> SELECT RTRIM('barbar ');
-> 'barbar'
這個函數是多字節安全的。
TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str)
移除字符串 str 中所有的 remstr 前綴或後綴，然後將其返回。如果沒有任何 BOTH、LEADING 或 TRAILING 修飾符被給出，BOTH 被假定。如果 remstr 沒有被指定，空格將被移除：
MySQL> SELECT TRIM(' bar ');
-> 'bar'
MySQL> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
-> 'barxxx'
MySQL> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
-> 'bar'
MySQL> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
-> 'barx'
這個函數是多字節安全的。
SOUNDEX(str)
返回 str 的近音字。兩個發音差不多的字符串應該有同樣的近音字。一個標准的近音字為 4 個字符長，但是函數 SOUNDEX() 卻返回一個任意長的字符串。你可以在結果上使用 SUBSTRING() 標准的近音字。提供的字符中所有的非數字字母的字符均被忽略。所有在 A-Z 范圍之外的國際 alpha 字符被視為元音：
MySQL> SELECT SOUNDEX('Hello');
-> 'H400'
MySQL> SELECT SOUNDEX('Quadratically');
-> 'Q36324'
SPACE(N)
返回有 N 空格字符組成的字符串：
MySQL> SELECT SPACE(6);
-> '
您正在看的MySQL教程是:用於 SELECT 和 WHERE 子句的函數。
'
REPLACE(str,from_str,to_str)
在字符串 str 中所有出現的字符串 from_str 均被 to_str替換，然後返回這個字符串：
mysql> SELECT REPLACE('www.MySQL.com', 'w', 'Ww');
-> 'WwWwWw.MySQL.com'
這個函數是多字節安全的。
REPEAT(str,count)
返回一個由重復了 count 次的字符串 str 組成的字符串。如果 count <= 0，返回一個空字符串。如果 str 或 count 是 NULL，返回值也為 NULL：
mysql> SELECT REPEAT('MySQL', 3);
-> 'MySQLMySQLMySQL'
REVERSE(str)
以顛倒的字符順序返回字符串 str：
MySQL> SELECT REVERSE('abc');
-> 'cba'
這個函數是多字節安全的。
INSERT(str,pos,len,newstr)
在字符串 str 中，將從 pos 位置開始，len 個字符長的子串替換為字符串 newstr ，然後將結果返回：
MySQL> SELECT INSERT('Quadratic', 3, 4, 'What');
-> 'QuWhattic'
這個函數是多字節安全的。
ELT(N,str1,str2,str3,...)
如果 N = 1，返回 str1，如果N = 2，返回 str2，等等。如果 N 小於 1 或大於參數的數量，返回 NULL。ELT() FIELD() 反運算：
MySQL> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');
-> 'ej'
MySQL> SELECT ELT(4, 'ej', 'Heja', 'hej', 'foo');
-> 'foo'
FIELD(str,str1,str2,str3,...)
返回 str 在列表 str1, str2, str3, ... 中的索引。如果 str 沒有發現，返回 0。FIELD() 是 ELT() 的反運算：
MySQL> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
-> 2
MySQL> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');
-> 0
FIND_IN_SET(str,strlist)
Returns a value 如果字符串 str 在由 N 個子串組成的列表 strlist 中，返回一個 1 到 N 的值。一個字符串列表是由通過字符 “,” 分隔的多個子串組成。如果第一個參數是一個常數字符串，並且第二個參數是一個 SET 列類型，FIND_IN_SET() 函數將被優化為使用位運算！如果 str 在不 strlist 中或者如果 strlist 是一個空串，返回值為 0。如果任何一個參數為 NULL，返回值也是 NULL。如果第一個參數包含一個 “,”，這個函數將完全不能工作：
MySQL> SELECT FIND_IN_SET('b','a,b,c,d');
-> 2
MAKE_SET(bits,str1,str2,...)
返回一個集合 (包含由字符 “,” 分隔的多個子串組成的一個字符串)，它由在 bits 集合中有相應的比特位的字符串組成。str1 對應於比特位 0，str2 對應比特位 1，等等。在 str1, str2, ... 中的 NULL 串不允許被添加到結果中：
MySQL> SELECT MAKE_SET(1,'a','b',
'c');
-> 'a'
MySQL> SELECT MAKE_SET(1 | 4,'hello','nice','world');
-> 'hello,world'
MySQL> SELECT MAKE_SET(0,'a','b','c');
-> ''
EXPORT_SET(bits,on,off,[separator,[number_of_bits]])
返回一個字符串，對於在 'bits' 中的每個比特字位，你將得到一個 'on' 字符，而如果比特字位是一個清零比特位(reset bit)你將得到一個 'off' 字符串。每個字符串均被“分隔符”(缺省為“,”)分隔，並且只有 'number_of_bits'(缺省為 64) 個 'bits' 被使用：
MySQL> SELECT EXPORT_SET(5,'Y','N',',',4)
-> Y,N,Y,N
示例(譯者注)：
MySQL> select EXPORT_SET(1,'1','0','',5);
-> 10000
# 最左邊第一位為 2 的 0 次冪
MySQL> select EXPORT_SET(2,'1','0','',5);
-> 01000
# 最左邊第一位為 2 的 0 次冪，第二位為 2 的 1 次冪
MySQL> select EXPORT_SET(4,'1','0','',5);
-> 00100
# 最左邊第一位為 2 的 0 次冪，第二位為 2 的 1 次冪，第三位為 2 的 2 次冪
MySQL> select EXPORT_SET(15,'1','0','',5);
-> 11110
# 最左邊第一位為 2 的 1 次冪，第四位為 2 的 3 次冪
MySQL> select EXPORT_SET(16,'1','0','',5);
-> 00001
# 最左邊第一位為 2 的 1 次冪，第五位為 2 的 4 次冪
# 以上結果在 MySQL 4.0.12 中測試通過
示例結束(譯者注)
LCASE(str)
LOWER(str)
依照當前字符集設置映射(缺省為 ISO-8859-1 Latin1)，將字符串 str 中的所有字符改變為小寫，然後返回該值：
MySQL> SELECT LCASE('QUADRATICALLY');
-> 'quadratically'
這個函數是多字節安全的。
UCASE(str)
UPPER(str)
依照當前字符集設置映射(缺省為 ISO-8859-1 Latin1)，將字符串 str
您正在看的MySQL教程是:用於 SELECT 和 WHERE 子句的函數。中的所有字符改變為大寫，然後返回該值：
MySQL> SELECT UCASE('Hej');
-> 'HEJ'
這個函數是多字節安全的。
LOAD_FILE(file_name)
讀入文件，並將文件內容作為一個字符串返回。這個文件必須在服務器上，必須指定文件完整的路徑名，並且你必須有 FILE 權限。文件必須完全可讀，並且小於 max_allowed_packet。 如果該文件不存在，或因為上面的任一原因而不能被讀出，函數返回 NULL：
MySQL> UPDATE tbl_name
SET blob_column=LOAD_FILE("/tmp/picture")
WHERE id=1;
如果你沒有使用 MySQL 3.23，你不得不在你的應用程序中讀取文件，以文件的信息創建一個 INSERT 語句，來更新數據庫。如果你使用 MySQL++ 庫，下面有一個示例，詳細請查看 http://www.mysql.com/documentation/mysql++/MySQL++-examples.Html。
QUOTE(str)
引用一個字符串，並返回一個結果，該結果可作為一個適當轉義過的數據值在一個 SQL 語句中使用。字符串被單引號包圍著返回，並且在該字符串中每個單引號(“'”)、反斜線符號(“\”)、ASCII NUL 和 Control-Z 出現的地方，在該字符之前均被加上了一個反斜線。如果參數是 NULL，那麼結果值是一個沒有單引號包圍的單詞 “NULL”。 QUOTE 函數在 MySQL 4.0.3 中被加入。
MySQL> SELECT QUOTE("Don't");
-> 'Don't!'
MySQL> SELECT QUOTE(NULL);
-> NULL
6.3.2.1 字符串比較函數
在必要的時候，MySQL 會自動地將數字轉換到字符串，反之亦然：
MySQL> SELECT 1+"1";
-> 2
MySQL> SELECT CONCAT(2,' test');
-> '2 test'
如果你希望明確地將一個數字轉換為字符串，將它參數傳遞到 CONCAT() 中。
如果將一個二進制字符串作為參數傳遞給一個字符串函數，結果返回也是一個二進制字符串。一個數字被轉換到字符串，該字符串被視為是一個二進制字符串。這僅僅會影響結果。
通常，只要字符串比較中的任何一個表達式是區分大小寫的，比較就會以字母大小寫敏感方式執行。
expr LIKE pat [ESCAPE 'escape-char']
使用 SQL 的簡單的正規表達式進行比較的模式匹配。返回 1 (TRUE) 或 0 (FALSE)。可以在模式中使用下面所示的兩個通配符字符與 LIKE 配合：
字符 含義
% 匹配任意多個字符，甚至是零個字符
_ 嚴格地匹配一個字符
MySQL> SELECT 'David!' LIKE 'David_';
-> 1
MySQL> SELECT 'David!' LIKE '%D%v%';
-> 1
為了測試一個含有通配符的文字實例，可以用轉義符加在能配符前。如果沒有明確指定 ESCAPE 字符，假定為 “\”：
字符串 含義
\% 匹配一個 % 字符
\_ 匹配一個 _ 字符
MySQL> SELECT 'David!' LIKE 'David\_';
-> 0
MySQL> SELECT 'David_' LIKE 'David\_';
-> 1
為了指定一個不同的轉義字符，可以使用 ESCAPE 子句：
MySQL> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
-> 1
下面兩個語句表明，字符串比較是忽略大小寫的，除非任一操作數是一個二進制字符串：
MySQL> SELECT 'abc' LIKE 'ABC';
-> 1
MySQL> SELECT 'abc' LIKE BINARY 'ABC';
-> 0
LIKE 允許用在一個數字表達式上。(這是 MySQL 對 ANSI SQL LIKE 的擴展。)
MySQL> SELECT 10 LIKE '1%';
->注意：因為 MySQL 在字符串中使用的是 C 的轉義句法(例如 “\n”)，所以在 LIKE 字符串中使用的任何一個 “\” 必須被雙寫。例如，為了查找 “\n”，必須以 “\\n” 形式指定它。為了查找 “\”，必須指定它為 “\\\\” (反斜線被語法分析器剝離一次，另一次在模式匹配時完成，留下一條單獨的反斜線被匹配)。
expr NOT LIKE pat [ESCAPE 'escape-char']
相同於 NOT (expr LIKE pat [ESCAPE 'escape-char'])。
expr SOUNDS LIKE expr
等同於 SOUNDEX(expr)=SOUNDEX(expr) (適用於 MySQL 4.1 或更新的版本)。
expr REGEXP pat
expr RLIKE pat
依照模式 pat 對字符串表達式 expr 執行一個模式比較。模式可以是一個擴展的正則表達式。查看章節 G MySQL 正則表達式。Returns 如果表達式 expr 匹配 pat，返回 1，否則返回 0。RLIKE 是 REGEXP 的同義詞，它提供了與 mSQL 的兼容。注意：MySQL 在字符串中使用的是 C 的轉義句法(例如 “\n”)，所以在 REGEXP 字符串中使用的任何一個 “\” 必須被雙寫。在 MySQL 3.23.4 中，REGEXP 對於正常的(不是二進制)字符串是忽略大小寫的：
MySQL> SELECT 'Monty!' REGEXP 'm%y%%';
-> 0
MySQL> SELECT 'Monty!' REGEXP '.*';
-> 1
MySQL> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
-> 1
MySQL> SELECT "a" REGEXP "A", "a" REGEXP BINARY "A";
-> 1 0
MySQL> SELECT "a" REGEXP "^[a-d]";
-> 1
當決定一個字符的類型時，REGEXP 和 RLIKE 使用當前使用的字符集(缺省為 ISO-8859-1 Latin1)。
expr NOT REGEXP pat
您正在看的MySQL教程是:用於 SELECT 和 WHERE 子句的函數。 expr NOT RLIKE pat
等同於 NOT (expr REGEXP pat)。
STRCMP(expr1,expr2)
如果字符串是相同，STRCMP() 返回 0，如果第一個參數根據當前排序次序小於第二個參數，返回 -1，否則返回 1：
MySQL> SELECT STRCMP('text', 'text2');
-> -1
MySQL> SELECT STRCMP('text2', 'text');
-> 1
MySQL> SELECT STRCMP('text', 'text');
-> 0
MATCH (col1,col2,...) AGAINST (expr)
MATCH (col1,col2,...) AGAINST (expr IN BOOLEAN MODE)
MATCH ... AGAINST() 用於全文搜索，返回在列 (col1,col2,...) 和查詢 expr 之間文本的相關相似的尺度。相關性是一個正的浮點型數字。零相關性意味著不相似。MATCH ... AGAINST() 可用於 MySQL 3.23.23 或更新的版本中。IN BOOLEAN MODE 擴展在 MySQL 4.0.1 中被新加入。詳細描述和使用范例，請查看 6.8 MySQL 全文搜索。
6.3.2.2 字母大小寫敏感性
BINARY
BINARY 操作符將跟在它後面的字符串強制作為一個二進制字符串。這可以很容易地強制一個列的比較以字母大小寫敏感方式進行，
即使該列沒有定義為 BINARY 或 BLOB?
MySQL> SELECT "a" = "A";
-> 1
MySQL> SELECT BINARY "a" = "A";
-> 0
BINARY string 是 CAST(string AS BINARY) 的縮寫。查看章節 6.3.5 Cast 函數。BINARY 在 MySQL 3.23.0 中被加入。 注意，當將一個索引列強制為 BINARY 時，在某些語境中，MySQL 將不能有效地使用索引。
如果希望對一個 blob 進行忽略字母大小的比較時，你通常可以在比較前將它轉換到大寫：
SELECT 'A' LIKE UPPER(blob_col) FROM table_name;
我們計劃不久推出在不同字符集間的轉化，以使字符串比較有更好的伸縮性。
6.3.3 數字函數
6.3.3.1 算術運算
常用的算術操作符均是可用的。注意，如果兩個參數均是整型，`-', `+' 和 `*' 以 BIGINT (64 位)精度運算並返回結果！如果一個參數是一個無符號的整數，另一個參數也是一個整數，結果也將是一個無符號整數。查看章節 6.3.5 Cast 函數。
+
加法：
MySQL> SELECT 3+5;
-> 8
-
減法：
MySQL> SELECT 3-5;
-> -2
*
乘法：
MySQL> SELECT 3*5;
-> 15
MySQL> SELECT 18014398509481984*18014398509481984.0;
-> 324518553658426726783156020576256.0
MySQL> SELECT 18014398509481984*18014398509481984;
-> 0
最後一個表達式的結果是錯誤的，這是因為乘法結果超過了 64 位 BIGINT 計算范圍。
/
除法：
MySQL> SELECT 3/5;
-> 0.60
被 0 除將返回一個 NULL 結果：
MySQL> SELECT 102/(1-1);
-> NULL
只有當在一個結果被轉換到一個整數的語境中執行時，除法將會以 BIGINT 進行算術計算。
6.3.3.2 數學函數
所有的數學函數在發生錯誤的情況下，均返回 NULL。
-
一元減。 改變參數的符號：
MySQL> SELECT - 2;
-> -2
注意，如果這個操作符被用於一個 BIGINT，返回值也是一個 BIGINT！這就意味著，應該避免在一個可能有值 -2^63 的整數上使用 - 操作符！
ABS(X)
返回 X 的絕對值：
MySQL> SELECT ABS(2);
-> 2
MySQL> SELECT ABS(-32);
-> 32
這個函數可安全地使用於 BIGINT 值。
SIGN(X)
以 -1、0 或 1 方式返回參數的符號，它取決於參數 X 是負數、0 或正數。MySQL> SELECT SIGN(-32);
-> -1
MySQL> SELECT SIGN(0);
-> 0
MySQL> SELECT SIGN(234);
-> 1
MOD(N,M)
%
取模 (就如 C 中的 % 操作符)。返回 N 被 M 除後的余數：
MySQL> SELECT MOD(234, 10);
-> 4
MySQL> SELECT 253 % 7;
-> 1
MySQL> SELECT MOD(29,9);
-> 2
MySQL> SELECT 29 MOD 9;
-> 2
這個函數可安全地使用於 BIGINT 值。最後一個示例可在 MySQL 4.1 中工作。
FLOOR(X)
返回不大於 X 的最大整數值：
MySQL> SELECT FLOOR(1.23);
-> 1
MySQL>SELECT FLOOR(-1.23);
-> -2
注意，返回值被轉換為一個 BIGINT！
CEILING(X)
返回不小於 X 的最小整數：
您正在看的MySQL教程是:用於 SELECT 和 WHERE 子句的函數。MySQL> SELECT CEILING(1.23);
-> 2
MySQL> SELECT CEILING(-1.23);
-> -1
注意，返回值被轉換為一個 BIGINT！
ROUND(X)
ROUND(X,D)
將參數 X 四捨五入到最近的整數，然後返回。兩個參數的形式是將一個數字四捨五入到 D 個小數後返回。
MySQL> SELECT ROUND(-1.23);
-> -1
MySQL> SELECT ROUND(-1.58);
-> -2
MySQL> SELECT ROUND(1.58);
-> 2
MySQL> SELECT ROUND(1.298, 1);
-> 1.3
MySQL> SELECT ROUND(1.298, 0);
-> 1
注意，當參數在兩個整數之間時， ROUND() 的行為取決於 C 庫的實現。某些取整到最近的偶數，總是向下取，總是向上取，也可能總是接近於零。如果你需要某種取整類型，應該使用一個明確定義的函數比如 TRUNCATE() 或 FLOOR() 代替。
DIV
整除。類似於 FLOOR()，但是它可安全地用於 BIGINT 值。
MySQL> SELECT 5 DIV 2
-> 2
DIV 在 MySQL 4.1.0 中新加入。
EXP(X)
返回值 e (自然對數的底) 的 X 次方：
MySQL> SELECT EXP(2);
-> 7.389056
MySQL> SELECT EXP(-2);
-> 0.135335
LN(X)
返回 X 的自然對數：
MySQL> SELECT LN(2);
-> 0.693147
/> MySQL> SELECT LN(-2);
-> NULL
這個函數在 MySQL 4.0.3 被新加入。在 MySQL 中，它是 LOG(X) 的同義詞。
LOG(X)
LOG(B,X)
如果以一個參數調用，它返回 X 的自然對數：
MySQL> SELECT LOG(2);
-> 0.693147
MySQL> SELECT LOG(-2);
-> NULL
如果以兩個參數調用，這個函數返回 X 任意底 B 的對數：
MySQL> SELECT LOG(2,65536);
-> 16.000000
MySQL> SELECT LOG(1,100);
-> NULL
任意底選項在 MySQL 4.0.3 中被加入。LOG(B,X) 等價於 LOG(X)/LOG(B)。
LOG2(X)
返回 X 的以 2 為底的對數：
MySQL> SELECT LOG2(65536);
-> 16.000000
MySQL> SELECT LOG2(-100);
-> NULL
LOG2() 通常可以用於計數出一個數字需要多少個比特位用於存儲它。這個函數在 MySQL 4.0.3 中被添加。在更早的版本中，可以使用 LOG(X)/LOG(2) 來代替它。
LOG10(X)
返回 X 以 10 為底的對數：
MySQL> SELECT LOG10(2);
-> 0.301030
MySQL> SELECT LOG10(100);
-> 2.000000
MySQL> SELECT LOG10(-100);
-> NULL
POW(X,Y)
POWER(X,Y)
返回 X 的 Y 冪：
MySQL> SELECT POW(2,2);
-> 4.000000
MySQL> SELECT POW(2,-2);
-> 0.250000
SQRT(X)
返回 X 的非否平方根：
MySQL> SELECT SQRT(4);
-> 2.000000
MySQL> SELECT SQRT(20);
-> 4.472136
PI()
返回 PI 值(圓周率)。缺少顯示 5 位小數，但是在 MySQL 內部，為 PI 使用全部的雙精度。
MySQL> SELECT PI();
-> 3.141593
MySQL> SELECT PI()+0.000000000000000000;
-> 3.141592653589793116
COS(X)
返回 X 的余弦，在這裡，X 以弧度給出：
MySQL> SELECT COS(PI());
-> -1.000000
SIN(X)
返回 X 的正弦，在這裡，X 以弧度給出：
MySQL> SELECT SIN(PI());
-> 0.000000
TAN(X)
返回 X 的正切，在這裡，
X 以弧度給出：
MySQL> SELECT TAN(PI()+1);
-> 1.557408
ACOS(X)
返回 X 的反余弦，更確切地說，返回余弦值為 X 的值。如果 X 不在 -1 到 1 之間的范圍內，返回 NULL：
MySQL> SELECT ACOS(1);
-> 0.000000
MySQL> SELECT ACOS(1.0001);
-> NULL
MySQL> SELECT ACOS(0);
-> 1.570796
ASIN(X)
返回 X 的反正弦，更確切地說，返回正弦值為 X 的值。如果 X 不在 -1 到 1 之間
您正在看的MySQL教程是:用於 SELECT 和 WHERE 子句的函數。的范圍內，返回 NULL：
MySQL> SELECT ASIN(0.2);
-> 0.201358
MySQL> SELECT ASIN('foo');
-> 0.000000
ATAN(X)
返回 X 的反正切， 更確切地說，返回正切值為 X 的值：
MySQL> SELECT ATAN(2);
-> 1.107149
MySQL> SELECT ATAN(-2);
-> -1.107149
ATAN(Y,X)
ATAN2(Y,X)
返回兩個變量 X 和 Y 的反正切。它類似於計算 Y / X 的反正切，除了兩個參數的符號用於決定結果的象限：
MySQL> SELECT ATAN(-2,2);
-> -0.785398
MySQL> SELECT ATAN2(PI(),0);
-> 1.570796
COT(X)
返回 X 的余切：
MySQL> SELECT COT(12);
-> -1.57267341
MySQL> SELECT COT(0);
-> NULL
RAND()
RAND(N)
返回一個范圍在 0 到 1.0 之間的隨機浮點值。如果一個整數參數 N 被指定，它被當做種子值使用(用於產生一個可重復的數值)：
MySQL> SELECT RAND();
-> 0.9233482386203
MySQL> SELECT RAND(20);
-> 0.15888261251047
MySQL> SELECT RAND(20);
->0.15888261251047
MySQL> SELECT RAND();
-> 0.63553050033332
MySQL> SELECT RAND();
-> 0.70100469486881
在一個 ORDER BY 子句中，不可以使用 RAND() 值使用一個列，因為 ORDER BY 將多次重復計算列。從 MySQL 3.23 開始，你可以使用：SELECT * FROM table_name ORDER BY RAND()，這有利於得到一個來自 SELECT * FROM table1,table2 WHERE a=b AND c
LEAST(X,Y,...)
有兩個或更多個參數，返回最小(最小值)的參數。參數使用下列規則進行比較：
* 如果返回值用於一個 INTEGER 語境，或所有的參數是整數值，它們作為整數比較。
* 如果返回值用於一個 REAL 語境，或所有的參數均是實數值，它們作為實數被比較。
* 如果任何一個參數是字母大小寫敏感的，參數作為大小寫敏感的字符串進行比較。
* 在其它情況下，參數做為忽略大小寫的字符中進行比較：
MySQL> SELECT LEAST(2,0);
-> 0
MySQL> SELECT LEAST(34.0,3.0,5.0,767.0);
-> 3.0
MySQL> SELECT LEAST("B","A","C");
-> "A"
在早於 MySQL 3.22.5 的版本中，你可以使用 MIN() 代替 LEAST。
GREATEST(X,Y,...)
返回最大(最大值)參數。參數使用與 LEAST 一致的規則進行比較：
MySQL> SELECT GREATEST(2,0);
-> 2
MySQL> SELECT GREATEST(34.0,3.0,5.0,767.0);
-> 767.0
MySQL> SELECT GREATEST("B","A","C");
-> "C"
在早於 MySQL 3.22.5 的版本中，可以使用 MAX() 代替 GREATEST。
DEGREES(X)
將參數 X 從弧度轉換為角度，然後返回：
MySQL> SELECT DEGREES(PI());
-> 180.000000
RADIANS(X)
將參數 X 從角度轉換為弧度，然後返回：
MySQL> SELECT RADIANS(90);
-> 1.570796
TRUNCATE(X,D)
將數值 X 截到 D 個小數，然後返回。如果 D 為 0，結果將不包含小數點和小數部分：
MySQL> SELECT TRUNCATE(1.223,1);
-> 1.2
MySQL> SELECT TRUNCATE(1.999,1);
-> 1.9
MySQL> SELECT TRUNCATE(1.999,0);
-> 1
MySQL> SELECT TRUNCATE(-1.999,1);
-> -1.9
從 MySQL 3.23.51 開始，所有數字被四捨五入到零。 如果 D 是負數，那麼數字的整個部分被對准零位輸出：
MySQL> SELECT TRUNCATE(122,-2);
-> 100
注意， 十進值小數在計算機中通常不以精確數字存儲，而是雙精度型的值，你可能會被下列結果所愚弄：
MySQL> SELECT TRUNCATE(10.28*100,0);
-> 1027
上面結果的發生是因為 10.28 實際上是以某些像 10.2799999999999999 的形式被存儲的。
6.3.4 日期和時間函數
對於每個類型的值范圍以及日期和時間值有效指定格式，請查看章節 6.2.2 Date 和 Time 類型。
這裡是一個使用日期函數的例子。下面的查詢選擇所有 date_col 值在最後 30 天內的記錄。
MySQL> SELECT
您正在看的MySQL教程是:用於 SELECT 和 WHERE 子句的函數。 something FROM tbl_name
WHERE TO_DAYS(NOW()) - TO_DAYS(date_col) <= 30;
DAYOFWEEK(date)
返回 date 的星期索引(1 = Sunday, 2 = Monday, ... 7 = Saturday)。索引值符合 ODBC 的標准。
MySQL> SELECT DAYOFWEEK('1998-02-03');
-> 3
WEEKDAY(date)
返回 date 的星期索引(0 = Monday, 1 = Tuesday, ... 6 = Sunday)：
MySQL> SELECT WEEKDAY('1998-02-03 22:23:00');
-> 1
MySQL> SELECT WEEKDAY('1997-11-05');
-> 2
DAYOFMONTH(date)
返回 date 是一月中的第幾天，范圍為 1 到 31：
MySQL> SELECT DAYOFMONTH('1998-02-03');
-> 3
DAYOFYEAR(date)
返回 date 是一年中的第幾天，范圍為 1 到 366：
MySQL> SELECT DAYOFYEAR('1998-02-03');
-> 34
MONTH(date)
返回 date 中的月份，范圍為 1 到 12：
MySQL> SELECT MONTH('1998-02-03');
-> 2
DAYNAME(date)
返回 date 的星期名：
MySQL> SELECT DAYNAME("1998-02-05");
-> 'Thursday'
MONTHNAME(date)
返回 date 的月份名：
MySQL> SELECT MONTHNAME("1998-02-05");
-> 'February'
QUARTER(date)
返回 date 在一年中的季度，范圍為 1 到 4：
MySQL> SELECT QUARTER('98-04-01');
-> 2
WEEK(date)
WEEK(date,first)
對於星期日是一周中的第一天的場合，如果函數只有一個參數調用，返回 date 為一年的第幾周，返回值范圍為 0 到 53 (是的，可能有第 53 周的開始)。兩個參數形式的 WEEK() 允許你指定一周是否以星期日或星期一開始，以及返回值為 0-53 還是 1-52。 這裡的一個表顯示第二個參數是如何工作的：
值 含義
0 一周以星期日開始，返回值范圍為 0-53
1 一周以星期一開始，返回值范圍為 0-53
2 一周以星期日開始，返回值范圍為 1-53
3 一周以星期一開始，返回值范圍為 1-53 (ISO 8601)
MySQL> SELECT WEEK('1998-02-20');
-> 7
MySQL> SELECT WEEK('1998-02-20',0);
-> 7
MySQL> SELECT WEEK('1998-02-20',
1);
-> 8
MySQL> SELECT WEEK('1998-12-31',1);
-> 53
注意，在版本 4.0 中，WEEK(#,0) 被更改為匹配 USA 歷法。 注意，如果一周是上一年的最後一周，當你沒有使用 2 或 3 做為可選參數時，MySQL 將返回 0：
MySQL> SELECT YEAR('2000-01-01'), WEEK('2000-01-01',0);
-> 2000, 0
MySQL> SELECT WEEK('2000-01-01',2);
-> 52
你可能會爭辯說，當給定的日期值實際上是 1999 年的第 52 周的一部分時，MySQL 對 WEEK() 函數應該返回 52。我們決定返回 0 ，是因為我們希望該函數返回“在指定年份中是第幾周”。當與其它的提取日期值中的月日值的函數結合使用時，這使得 WEEK() 函數的用法可靠。 如果你更希望能得到恰當的年-周值，那麼你應該使用參數 2 或 3 做為可選參數，或者使用函數 YEARWEEK() ：
MySQL> SELECT YEARWEEK('2000-01-01');
-> 199952
MySQL> SELECT MID(YEARWEEK('2000-01-01'),5,2);
-> 52
YEAR(date)
返回 date 的年份，范圍為 1000 到 9999：
MySQL> SELECT YEAR('98-02-03');
-> 1998
YEARWEEK(date)
YEARWEEK(date,first)
返回一個日期值是的哪一年的哪一周。第二個參數的形式與作用完全與 WEEK() 的第二個參數一致。注意，對於給定的日期參數是一年的第一周或最後一周的，返回的年份值可能與日期參數給出的年份不一致：
MySQL> SELECT YEARWEEK('1987-01-01');
-> 198653
注意，對於可選參數 0 或 1，周值的返回值不同於 WEEK() 函數所返回值(0)， WEEK() 根據給定的年語境返回周值。
HOUR(time)
返回 time 的小時值，范圍為 0 到 23：
MySQL> SELECT HOUR('10:05:03');
-> 10
MINUTE(time)
返回 time 的分鐘值，范圍為 0 到 59：
MySQL> SELECT MINUTE('98-02-03 10:05:03');
-> 5
SECOND(time)
返回 time 的秒值，范圍為 0 到 59：
MySQL> SELECT SECOND('10:05:03');
-> 3
PERIOD_ADD(P,N)
增加 N 個月到時期 P(格式為 YYMM 或 YYYYMM)中。以 YYYYMM 格式返回值。 注意，期間參數 P 不是 一個日期值：
