MySQL 4.1.0 中文參考手冊 --- 6.3 用於 SELECT 和 WHERE 子句的函式 (1) (轉)[@more@] 4.1.0 中文參考手冊"> words" content="MySQL,4.1.0,Shuixin13,MySQL 4.1.0,中文,中文參考手冊,犬犬(心帆)"> CSS rel=STYLESHEET>

MySQL Reference Manual for version 4.1.0-alpha.

---

6.3 用於 和 WHERE 子句的

一個 SQL 語句中的 select_expression 或 where_definition 可由任何使用了下面所描述函式的組成。

包含 NULL 的表示式總是得出一個 NULL 值結果，除非表示式中的操作和函式在文件中有另外的說明。

注意：在一個函式名和跟隨它的括號之間必須不存在空格。這有助於 MySQL 語法分析區分函式和對恰巧與函式同名表或列的引用。然而，引數左右兩邊的空格卻是允許的。

你可以強制 MySQL 接受函式名後存在空格的形式，這需要透過以 --ansi 選項啟動 mysqld，或在 mysql_connect() 中使用 CLIENT_IGNORE_SPACE，但是，在這種情況下，所有的函式名均將成為保留字。檢視章節 執行 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。這些函式可工作於數字和字串上。根據需要，字串將會自動地被轉換到數字，以及數字被轉換成字串(比如在 中)。

MySQL 使用下列規則進行比較：

• 如果一個或兩個引數是 NULL，比較的結果是 NULL，除了 <=> 運算子。
• 如果在一個比較操作中兩個引數均是字串，他們將作為字串被比較。
• 如果兩個引數均是整數，他們作為整數被比較。
• 十六進位制值如果不與一個數字進行比較，那麼它將當作一個二進位制字串。
• 如果引數之一是一個 TIMESTAMP 或 DATETIME 列，而另一引數是一個常數，在比較之前，這個常數被轉換為一個時間戳。這樣做是為了對 OC 更友好。
• 在所有其它情況下，引數作為浮點(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> 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 來禁止。檢視章節 .
• 對於 NOT NULL 的 DATE 和 DATETIME 列，可以透過使用下列語句找到特殊的值 0000-00-00：

  SELECT * FROM tbl_name WHERE date_column IS NULL

  這需要透過某些 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> SELECT 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。檢視章節 。

對於操作字串位置的函式，第一個位置被標記為 1。

ASCII(str)

返回字串 str 最左邊的那個字元的 ASCII 碼值。如果 str 是一個空字串，那麼返回值為 0。如果 str 是一個 NULL，返回值也是 NULL：

mysql> SELECT ASCII('2'); -> 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); -> '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 中的第 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 pFOR 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('', '.', 2); -> '' mysql> SELECT SUBSTRING_INDEX('', '.', -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); -> ' '

REPLACE(str,from_str,to_str)

在字串 str 中所有出現的字串 from_str 均被 to_str替換，然後返回這個字串：

mysql> SELECT REPLACE('', 'w', 'Ww'); -> 'WwW'

這個函式是多位元組安全的。

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 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:///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%'; -> 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 REGEpat

expr RLIKE pat

依照模式 pat 對字串表示式 expr 執行一個模式比較。模式可以是一個擴充套件的正規表示式。檢視章節 。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

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.3.2.2 字母大小寫敏感性

BINARY

BINARY 運算子將跟在它後面的字串強制作為一個二進位制字串。這可以很容易地強制一個列的比較以字母大小寫敏感方式進行，即使該列沒有定義為 BINARY 或 BLOB?

mysql> SELECT "a" = "A"; -> 1 mysql> SELECT BINARY "a" = "A"; -> 0

BINARY string 是 CAST(string AS BINARY) 的縮寫。檢視章節 。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 位)精度運算並返回結果！如果一個引數是一個無符號的整數，另一個引數也是一個整數，結果也將是一個無符號整數。檢視章節 。

+

加法：

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 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 之間的範圍內，返回 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 的集合中的隨機樣本。注意，在一個 WHERE 子句中的 RAND() 將在每次 WHERE 執行時被重新計算。 RAND() 並不是預期完美的隨機數發生器，但是可以代替做為產生特別的隨機數一個的方法，這樣便於在兩個不同平臺下的同一 MySQL 版本間移動。

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 的形式被儲存的。