MySQL中文參考手冊MySQL中文參考手冊譯者：晏子 (clyan@sohu.com） 主頁：http://linuxdb.yeah.net
譯者：晏子 (clyan@sohu.com）
GB 碼主頁：http://linuxdb.yeah.net
Big5 轉碼者：statue
(statue@bbs.yzu.edu.tw）
詞彙轉換：彭武興 (wilson@mailbox.com.tw)
Big5 碼主頁：
http://cnpa.yzu.edu.tw/~cfc/docs/mysqldoc_big5/manual_toc.html
Big5 碼分站：
http://php.wilson.gs/mysqldoc/big5/manual_toc.html
一個字符串是一個字符序列，由單引號(“'”)或雙引號(“"”)字符(後者只有你不在ANSI模式運行)包圍。例如：
'a string' "another string"
在字符串內，某個順序有特殊的意義。這些順序的每一個以一條反斜線(“\”)開始，稱為轉義字符。MySQL識別下列轉義字符：
\0 NUL)字符。 \n \t \r \b \' \" \\ \% \_ 注意，如果你在某些正文環境中使用“\%”或“\%_”，這些將返回字符串“\%”和“\_”而不是“%”和“_”。
有幾種方法在一個字符串內包括引號：
下面顯示的SELECT演示引號和轉義如何工作：
mysql> SELECT 'hello', '"hello"', '""hello""', 'hel''lo', '\'hello'; +-------+---------+-----------+--------+--------+ | hello | "hello" | ""hello"" | hel'lo | 'hello | +-------+---------+-----------+--------+--------+ mysql> SELECT "hello", "'hello'", "''hello''", "hel""lo", "\"hello"; +-------+---------+-----------+--------+--------+ | hello | 'hello' | ''hello'' | hel"lo | "hello | +-------+---------+-----------+--------+--------+ mysql> SELECT "This\nIs\nFour\nlines"; +--------------------+ | This Is Four lines | +--------------------+
如果你想要把二進制數據插入到一個BLOB列，下列字符必須由轉義序列表示：
NUL\ ' " 如果你寫C代碼，你可以使用C API函數mysql_escape_string()來為INSERT語句轉義字符。見20.3 C API 函數概述。在 Perl中，你可以使用DBI包中的quote方法變換特殊的字符到正確的轉義序列。見20.5.2 DBI介面。
你應該在任何可能包含上述任何特殊字符的字符串上使用轉義函數！
整數表示為一個數字順序。浮點數使用“.”作為一個十進制分隔符。這兩種類型的數字可以前置“-”表明一個負值。
有效整數的例子：
1221 0 -32
有效浮點數的例子：
294.42 -32032.6809e+10 148.00
一個整數可以在浮點上下文使用﹔它解釋為等值的浮點數。
MySQL支援十六進制值。在數字上下文，它們表現類似於一個整數(64位精度)。在字符串上下文，它們表現類似於一個二進制字符串，這裡每一對十六進制數字被變換為一個字符。
mysql> SELECT 0xa+0
-> 10
mysql> select 0x5061756c;
-> Paul
十六進制字符串經常被ODBC使用，給出BLOB列的值。
NULL值NULL值意味著“無數據”並且不同於例如數字類型的0為或字符串類型的空字符串。見18.15 NULL值問題。
當使用文本文件導入或導出格式(LOAD DATA INFILE, SELECT
... INTO OUTFILE)時，NULL可以用\N表示。見7.16 LOAD DATA INFILE句法。
資料庫、表、索引、列和別名的名字都遵守MySQL同樣的規則:
注意，從MySQL3.23.6開始規則改變了，此時我們引入了用'引用的標識符(資料庫、表和列命名)（如果你以ANSI模式運行，"也將用於引用標識符）。
| 標識符 | 最大長度 | 允許的字符 |
| 資料庫 | 64 | 在一個目錄名允許的任何字符，除了/. |
| 表 | 64 | 在文件名中允許的任何字符，除了/或. |
| 列 | 64 | 所有字符 |
| 別名 | 255 | 所有字符 |
注意，除了以上，你在一個標識符中不能有ASCII(0)或ASCII(255)。
注意，如果標識符是一個限制詞或包含特殊字符，當你使用它時，你必須總是用`引用它：
SELECT * from `select` where `select`.id > 100;
在 MySQL的先前版本，命名規則如下：
建議你不使用像1e這樣的名字，因為一個表達式如1e+1是二義性的。它可以解釋為表達式1e
+ 1或數字1e+1。
在MySQL中，你能使用下列表格的任何一種引用列：
| 列引用 | 含義 |
col_name |
來自於任意表的列col_name，用於包含該表的一個列的查詢中 |
tbl_name.col_name |
來自當前的資料庫的表tbl_name的列col_name |
db_name.tbl_name.col_name |
行列col_name從表格tbl_name資料庫db_name。這個形式在MySQL3.22或以後版本可用。
|
`column_name` |
是一個關鍵詞或包含特殊字符的列。 |
在一條語句的列引用中，你不必指定一個tbl_name或db_name.tbl_name前綴，除非引用會有二義性。例如，假定表t1和t2，每個均包含列c，並且你用一個使用t1和t2的SELECT語句檢索c。在這種情況下，c有二義性，因為它在使用表的語句中不是唯一的，因此你必須通過寫出t1.c或t2.c來指明你想要哪個表。同樣，如果你從資料庫db1中一個表t和在資料庫db2的一個表t檢索，你必須用db1.t.col_name和db2.t.col_name引用這些數據表的列。
句法.tbl_name意味著在當前的資料庫中的表tbl_name，該句法為了ODBC的兼容性被接受，因為一些ODBC程式用一個“.”字符作為資料庫表名的前綴。
在MySQL中，資料庫和表對應於在那些目錄下的目錄和文件，因而，內在的作業系統的敏感性決定資料庫和表命名的大小寫敏感性。這意味著資料庫和表名在Unix上是區分大小寫的，而在Win32上忽略大小寫。
注意：在Win32上，盡管資料庫和表名是忽略大小寫的，你不應該在同一個查詢中使用不同的大小寫來引用一個給定的資料庫和表。下列查詢將不工作，因為它作為my_table和作為MY_TABLE引用一個表：
mysql> SELECT * FROM my_table WHERE MY_TABLE.col=1;
列名在所有情況下都是忽略大小寫的。
表的別名是區分大小寫的。下列查詢將不工作，:
因為它用a和A引用別名：
mysql> SELECT col_name FROM tbl_name AS a
WHERE a.col_name = 1 OR A.col_name = 2;
列的別名是忽略大小寫的。
MySQL支援執行緒特定的變數，用@variablename句法。一個變數名可以由當前字符集的數字字母字符和“_”、“$”和“.”組成。預設字符集是ISO-8859-1
Latin1﹔這可以通過重新編譯MySQL改變。見9.1.1 用於數據和排序的字符集。
變數不必被初始化。預設地，他們包含NULL並能儲存整數、實數或一個字符串值。當執行緒退出時，對於一個執行緒的所有變數自動地被釋放。
你可以用SET句法設置一個變數：
SET @variable= { integer expression | real expression | string expression }
[,@variable= ...].
你也可以用@variable:=expr句法在一個表達式中設置一個變數：
select @t1:=(@t2:=1)+@t3:=4,@t1,@t2,@t3; +----------------------+------+------+------+ | @t1:=(@t2:=1)+@t3:=4 | @t1 | @t2 | @t3 | +----------------------+------+------+------+ | 5 | 5 | 1 | 4 | +----------------------+------+------+------+
（這裡，我們不得不使用:=句法，因為=是為比較保留的）
MySQL支援大量的列類型，它可以被分為3類：數字類型、日期和時間類型以及字符串(字符)類型。本節首先給出可用類型的一個概述，並且總結每個列類型的儲存需求，然後提供每個類中的類型性質的更詳細的描述。概述有意簡化，更詳細的說明應該考慮到有關特定列類型的附加資訊，例如你能為其指定值的允許格式。
由MySQL支援的列類型列在下面。下列代碼字母用於描述中：
M D M-2。
方括號(“[”和“]”)指出可選的類型修飾符的部分。
注意，如果你指定一個了為ZEROFILL，MySQL將為該列自動地增加UNSIGNED屬性。
TINYINT[(M)] [UNSIGNED] [ZEROFILL] -128到127，無符號的範圍是0到255。
SMALLINT[(M)] [UNSIGNED] [ZEROFILL] -32768到32767，無符號的範圍是0到65535。
MEDIUMINT[(M)] [UNSIGNED] [ZEROFILL] -8388608到8388607，無符號的範圍是0到16777215。
INT[(M)] [UNSIGNED] [ZEROFILL] -2147483648到2147483647，無符號的範圍是0到4294967295。
INTEGER[(M)] [UNSIGNED] [ZEROFILL] INT的一個同義詞。 BIGINT[(M)] [UNSIGNED] [ZEROFILL] -9223372036854775808到9223372036854775807，無符號的範圍是0到18446744073709551615。注意，所有算術運算用有符號的BIGINT或DOUBLE值完成，因此你不應該使用大於9223372036854775807（63位)的有符號大整數，除了位函數！注意，當兩個參數是INTEGER值時，-、+和*將使用BIGINT運算！這意味著如果你乘2個大整數(或來自於返回整數的函數)，如果結果大於9223372036854775807，你可以得到意外的結果。一個浮點數字，不能是無符號的，對一個單精度浮點數，其精度可以是<=24，對一個雙精度浮點數，是在25
和53之間，這些類型如FLOAT和DOUBLE類型馬上在下面描述。FLOAT(X)有對應的FLOAT和DOUBLE相同的範圍，但是顯示尺寸和小數位數是未定義的。在MySQL3.23中，這是一個真正的浮點值。在更早的MySQL版本中，FLOAT(precision)總是有2位小數。該句法為了ODBC兼容性而提供。
FLOAT[(M,D)] [ZEROFILL] -3.402823466E+38到-1.175494351E-38，0
和1.175494351E-38到3.402823466E+38。M是顯示寬度而D是小數的位數。沒有參數的FLOAT或有<24
的一個參數表示一個單精密浮點數字。
DOUBLE[(M,D)] [ZEROFILL] -1.7976931348623157E+308到-2.2250738585072014E-308、
0和2.2250738585072014E-308到1.7976931348623157E+308。M是顯示寬度而D是小數位數。沒有一個參數的DOUBLE或FLOAT(X)（25
< = X < = 53）代表一個雙精密浮點數字。 DOUBLE PRECISION[(M,D)] [ZEROFILL] REAL[(M,D)] [ZEROFILL] DOUBLE同義詞。 DECIMAL[(M[,D])] [ZEROFILL] CHAR列：“未壓縮”意味著數字作為一個字符串被儲存，值的每一位使用一個字符。小數點，並且對於負數，“-”符號不在M中計算。如果D是0，值將沒有小數點或小數部分。DECIMAL值的最大範圍與DOUBLE相同，但是對一個給定的DECIMAL列，實際的範圍可以通過M和D的選擇被限制。如果D被省略，它被設置為0。如果M被省掉，它被設置為10。注意，在MySQL3.22裡，M參數包括符號和小數點。
NUMERIC(M,D) [ZEROFILL] DECIMAL的一個同義詞。 DATE '1000-01-01'到'9999-12-31'。MySQL以'YYYY-MM-DD'格式來顯示DATE值，但是允許你使用字符串或數字把值賦給DATE列。
DATETIME '1000-01-01 00:00:00'到'9999-12-31
23:59:59'。MySQL以'YYYY-MM-DD HH:MM:SS'格式來顯示DATETIME值，但是允許你使用字符串或數字把值賦給DATETIME的列。
TIMESTAMP[(M)] '1970-01-01 00:00:00'到2037年的某時。MySQL以YYYYMMDDHHMMSS、YYMMDDHHMMSS、YYYYMMDD或YYMMDD格式來顯示TIMESTAMP值，取決於是否M是14（或省略)、12、8或6，但是允許你使用字符串或數字把值賦給TIMESTAMP列。一個TIMESTAMP列對於記錄一個INSERT或UPDATE操作的日期和時間是有用的，因為如果你不自己給它賦值，它自動地被設置為最近操作的日期和時間。你以可以通過賦給它一個NULL值設置它為當前的日期和時間。見7.3.6 日期和時間類型。 TIME '-838:59:59'到'838:59:59'。MySQL以'HH:MM:SS'格式來顯示TIME值，但是允許你使用字符串或數字把值賦給TIME列。
YEAR[(2|4)] 1901到2155，和0000（4位年格式），如果你使用2位，1970-2069(
70-69)。MySQL以YYYY格式來顯示YEAR值，但是允許你把使用字符串或數字值賦給YEAR列。（YEAR類型在MySQL3.22中是新類型。） CHAR(M) [BINARY] M的範圍是1
∼ 255個字符。當值被檢索時，空格尾部被刪除。CHAR值根據預設字符集以大小寫不區分的方式排序和比較，除非給出BINARY關鍵詞。NATIONAL
CHAR（短形式NCHAR)是ANSI SQL的方式來定義CHAR列應該使用預設字符集。這是MySQL的預設。CHAR是CHARACTER的一個縮寫。
[NATIONAL] VARCHAR(M) [BINARY] VARCHAR值根據預設字符集以大小寫不區分的方式排序和比較，除非給出BINARY關鍵詞值。見7.7.1 隱式列指定變化。 VARCHAR是CHARACTER
VARYING一個縮寫。 TINYBLOB TINYTEXT BLOB或TEXT列，最大長度為255(2^8-1)個字符。見7.7.1 隱式列指定變化。 BLOB TEXT BLOB或TEXT列，最大長度為65535(2^16-1)個字符。見7.7.1 隱式列指定變化。 MEDIUMBLOB MEDIUMTEXT BLOB或TEXT列，最大長度為16777215(2^24-1)個字符。見7.7.1 隱式列指定變化。 LONGBLOB LONGTEXT BLOB或TEXT列，最大長度為4294967295(2^32-1)個字符。見7.7.1 隱式列指定變化 ENUM('value1','value2',...) 'value1'、'value2',
...,或NULL。一個ENUM最多能有65535不同的值。
SET('value1','value2',...) 'value1',
'value2', ...選出。一個SET最多能有64個成員。
對於每個由MySQL支援的列類型的儲存需求在下面按類列出。
| 列類型 | 需要的儲存量 |
TINYINT |
1 字節 |
SMALLINT |
2 個字節 |
MEDIUMINT |
3 個字節 |
INT |
4 個字節 |
INTEGER |
4 個字節 |
BIGINT |
8 個字節 |
FLOAT(X) |
4 如果 X < = 24 或 8 如果 25 < = X < = 53 |
FLOAT |
4 個字節 |
DOUBLE |
8 個字節 |
DOUBLE PRECISION |
8 個字節 |
REAL |
8 個字節 |
DECIMAL(M,D) |
M字節(D+2 , 如果M < D) |
NUMERIC(M,D) |
M字節(D+2 , 如果M < D) |
| 列類型 | 需要的儲存量 |
DATE |
3 個字節 |
DATETIME |
8 個字節 |
TIMESTAMP |
4 個字節 |
TIME |
3 個字節 |
YEAR |
1 字節 |
| 列類型 | 需要的儲存量 |
CHAR(M) |
M字節，1 <= M <= 255 |
VARCHAR(M) |
L+1 字節, 在此L <= M和1 <= M <= 255
|
TINYBLOB, TINYTEXT |
L+1 字節, 在此L< 2 ^ 8 |
BLOB, TEXT |
L+2 字節, 在此L< 2 ^ 16 |
MEDIUMBLOB, MEDIUMTEXT |
L+3 字節, 在此L< 2 ^ 24 |
LONGBLOB, LONGTEXT |
L+4 字節, 在此L< 2 ^ 32 |
ENUM('value1','value2',...) |
1 或 2 個字節, 取決於枚舉值的數目(最大值65535） |
SET('value1','value2',...) |
1，2，3，4或8個字節, 取決於集合成員的數量(最多64個成員） |
VARCHAR和BLOB和TEXT類型是變長類型，對於其儲存需求取決於列值的實際長度(在前面的表格以 L表示)，而不是取決於類型的最大可能尺寸。例如，一個VARCHAR(10)列能保存最大長度為10個字符的一個字符串，實際的儲存需要是字符串的長度(L)，加上1個字節以記錄字符串的長度。對於字符串'abcd'，L是4而儲存要求是5個字節。
BLOB和TEXT類型需要1，2，3或4個字節來記錄列值的長度，這取決於類型的最大可能長度。
如果一個表包括任何變長的列類型，記錄格式將也是變長的。注意，當一個表被創建時，MySQL可能在某些條件下將一個列從一個變長類型改變為一個定長類型或相反。見7.7.1 隱式列指定變化。
一個ENUM對像的大小由不同枚舉值的數量決定。1字節被用於枚舉，最大到255個可能的值﹔2個字節用於枚舉，最大到65535
值。
一個SET對像的大小由不同的集合成員的數量決定。如果集合大小是N，對像占據(N+7)/8個字節，四捨五入為1，2，3，4或8
個字節。一個SET最多能有64個成員。
MySQL支援所有的ANSI/ISO SQL92的數字類型。這些類型包括準確數字的數據類型(NUMERIC,
DECIMAL, INTEGER,和SMALLINT)，也包括近似數字的數據類型(FLOAT,
REAL,和DOUBLE PRECISION)。關鍵詞INT是INTEGER的一個同義詞，而關鍵詞DEC是DECIMAL一個同義詞。
NUMERIC和DECIMAL類型被MySQL實現為同樣的類型，這在SQL92標準允許。他們被用於保存值，該值的準確精度是極其重要的值，例如與金錢有關的數據。當聲明一個類是這些類型之一時，精度和規模的能被(並且通常是)指定﹔例如：
salary DECIMAL(9,2)
在這個例子中，9(precision)代表將被用於儲存值的總的小數位數，而2(scale)代表將被用於儲存小數點後的位數。因此，在這種情況下，能被儲存在salary列中的值的範圍是從-9999999.99到9999999.99。在ANSI/ISO
SQL92中，句法DECIMAL(p)等價於DECIMAL(p,0)。同樣，句法DECIMAL等價於DECIMAL(p,0)，這裡實現被允許決定值p。MySQL當前不支援DECIMAL/NUMERIC數據類型的這些變種形式的任一種。這一般說來不是一個嚴重的問題，因為這些類型的主要益處得自於明顯地控制精度和規模的能力。
DECIMAL和NUMERIC值作為字符串儲存，而不是作為二進制浮點數，以便保存那些值的小數精度。一個字符用於值的每一位、小數點(如果scale>0)和“-”符號(對於負值)。如果scale是0，DECIMAL和NUMERIC值不包含小數點或小數部分。
DECIMAL和NUMERIC值得最大的範圍與DOUBLE一樣，但是對於一個給定的DECIMAL或NUMERIC列，實際的範圍可由制由給定列的precision或scale限制。當這樣的列賦給了小數點後面的位超過指定scale所允許的位的值，該值根據scale四捨五入。當一個DECIMAL或NUMERIC列被賦給了其大小超過指定(或預設的）precision和scale隱含的範圍的值，MySQL儲存表示那個範圍的相應的端點值。
作為對ANSI/ISO SQL92標準的擴展，MySQL也支援上表所列的整型類型TINYINT、MEDIUMINT和BIGINT。另一個擴展是MySQL支援可選地指定一個整型值顯示的寬度，用括號跟在基本關鍵詞之後(例如，INT(4))。這個可選的寬度指定被用於其寬度小於列指定寬度的值得左填補顯示，但是不限制能在列中被儲存的值的範圍，也不限制值將被顯示的位數，其寬度超過列指定的寬度。當與可選的擴展屬性ZEROFILL一起使用時，預設的空格填補用零代替。例如，對於聲明為INT(5)
ZEROFILL的列，一個為4的值作為00004被檢索。注意，如果你在一個整型列儲存超過顯示寬度的更大值，當MySQL對於某些複雜的聯結(join)產生臨時表時，你可能會遇到問題，因為在這些情況下，MySQL相信數據確實適合原來的列寬度。
所有的整型類型可以有一個可選(非標準的)屬性UNSIGNED。當你想要在列中僅允許正數並且你需要一個稍大一點的列範圍，可以使用無符號值。
FLOAT類型被用來標示近似數字的數據類型。ANSI/ISO SQL92標準允許一個可選的精度說明(但不是指數的範圍)，跟在關鍵詞FLOAT後面的括號內位數。MySQL實現也支援這個可選的精度說明。當關鍵詞FLOAT被用於一個列類型而沒有精度說明時，MySQL使用4個字節儲存值。一個變種的句法也被支援，在FLOAT關鍵詞後面的括號給出2個數字。用這個選項，第一個數字繼續表示在字節計算的值儲存需求，而第二個數字指定要被儲存的和顯示跟隨小數點後的位數(就像DECIMAL和NUMERIC)。當MySQL要求為這樣一個列，一個小數點後的小數位超過列指定的值，儲存值時，該值被四捨五入，去掉額外的位。
REAL和DOUBLE PRECISION類型不接受精度說明。作為對
ANSI/ISO SQL92 標準的擴展，MySQL識別出DOUBLE作為DOUBLE
PRECISION類型的一個同義詞。與REAL精度比用於DOUBLE
PRECISION的更小的標準要求相反，MySQL實現了兩種，作為8字節雙精度浮點值(當運行不是“Ansi模式”時)。為了最大的移植性，近似數字的數據值的儲存所需代碼應該使用沒有精度或小數位數說明的FLOAT或DOUBLE
PRECISION。
當要求在數字的列儲存超出該列類型允許的範圍的值時，MySQL剪切該值到範圍內的正確端點值並且儲存剪切後的結果值。
例如，一個INT列的範圍是-2147483648到2147483647。如果你試圖插入-9999999999到一個INT列中，值被剪切到範圍的低部端點，並儲存-2147483648。同樣，如果你試圖插入9999999999，2147483647被儲存。
如果INT列是UNSIGNED，列的範圍的大小是相同的，但是它的端點移到了0和4294967295。如果你試圖儲存-9999999999和9999999999，在列被儲存的值變為0和4294967296。
對於ALTER TABLE、LOAD DATA INFILE、UPDATE和多行INSERT語句，由於剪切所發生的變換作為“警告”被報告。
日期和時間類型是DATETIME、DATE、TIMESTAMP、TIME和YEAR。這些的每一個都有合法值的一個範圍，而“零”當你指定確實不合法的值時被使用。注意，MySQL允許你儲存某個“不嚴格地”合法的日期值，例如1999-11-31，原因我們認為它是應用程式的責任來處理日期檢查，而不是SQL伺服器。為了使日期檢查更“快”，MySQL僅檢查月份在0-12的範圍，天在0-31的範圍。上述範圍這樣被定義是因為MySQL允許你在一個DATE或DATETIME列中儲存日期，這裡的天或月是零。這對儲存你不知道準確的日期的一個生日的應用程式來說是極其有用的，在這種情況下，你簡單地儲存日期像1999-00-00或1999-01-00。（當然你不能期望從函數如DATE_SUB()或DATE_ADD()得到類似以這些日期的正確值)。
當用日期和時間工作時，這裡是的一些要記住的一般考慮：
'98-09-04')，而不是以其他地方常用的月-日-年或日-月-年的次序(例如，'09-04-98'、'04-09-98')。
TIME值被剪切為適當的TIME範圍端點值。)下表顯示對每種類型的“零”值的格式：
| 列類型 | “零”值 |
DATETIME |
'0000-00-00 00:00:00' |
DATE |
'0000-00-00' |
TIMESTAMP |
00000000000000（長度取決於顯示尺寸） |
TIME |
'00:00:00' |
YEAR |
0000 |
'0'或0做到,
這更容易寫。 NULL，因為ODBC不能處理這樣的值。
MySQL本身Y2K安全的(見1.6 2000年一致性)，但是呈交給MySQL的輸入值可能不是。一個包含2位年份值的任何輸入是由二義性的，因為世紀是未知的。這樣的值必須被解釋成4位形式，因為MySQL內部使用4位儲存年份。
對於DATETIME, DATE, TIMESTAMP和YEAR類型，MySQL使用下列規則的解釋二義性的年份值：
00-69的年值被變換到2000-2069。 70-99的年值被變換到1970-1999。記得這些規則僅僅提供對於你數據的含義的合理猜測。如果MySQL使用的啟發規則不產生正確的值，你應該提供無二義的包含4位年值的輸入。
DATETIME, DATE和TIMESTAMP類型DATETIME, DATE和TIMESTAMP類型是相關的。本節描述他們的特徵，他們是如何類似的而又不同的。
DATETIME類型用在你需要同時包含日期和時間資訊的值時。MySQL檢索並且以'YYYY-MM-DD
HH:MM:SS'格式顯示DATETIME值，支援的範圍是'1000-01-01
00:00:00'到'9999-12-31 23:59:59'。（“支援”意味著盡管更早的值可能工作，但不能保証他們可以。）
DATE類型用在你僅需要日期值時，沒有時間部分。MySQL檢索並且以'YYYY-MM-DD'格式顯示DATE值，支援的範圍是'1000-01-01'到'9999-12-31'。
TIMESTAMP列類型提供一種類型，你可以使用它自動地用當前的日期和時間標記INSERT或UPDATE的操作。如果你有多個TIMESTAMP列，只有第一個自動更新。
自動更新第一個TIMESTAMP列在下列任何條件下發生：
INSERT或LOAD DATA INFILE語句中指定。
UPDATE語句中指定且一些另外的列改變值。（注意一個UPDATE設置一個列為它已經有的值，這將不引起TIMESTAMP列被更新，因為如果你設置一個列為它當前的值，MySQL為了效率而忽略更改。）TIMESTAMP列為NULL. 除第一個以外的TIMESTAMP列也可以設置到當前的日期和時間，只要將列設為NULL，或NOW()。
通過明確地設置希望的值，你可以設置任何TIMESTAMP列為不同於當前日期和時間的值，即使對第一個TIMESTAMP列也是這樣。例如，如果，當你創建一個行時，你想要一個TIMESTAMP被設置到當前的日期和時間，但在以後無論何時行被更新時都不改變，你可以使用這個屬性：
TIMESTAMP列為它的當前值。
另一方面，你可能發現，當行被創建並且遠離隨後的更改時，很容易用一個你用NOW()初始化的DATETIME列。
TIMESTAMP值可以從1970的某時的開始一直到2037年，精度為一秒，其值作為數字顯示。
在MySQL檢索並且顯示TIMESTAMP值取決於顯示尺寸的格式如下表。“完整”TIMESTAMP格式是14位，但是TIMESTAMP列可以用更短的顯示尺寸創造：
| 列類型 | 顯示格式 |
TIMESTAMP(14) |
YYYYMMDDHHMMSS |
TIMESTAMP(12) |
YYMMDDHHMMSS |
TIMESTAMP(10) |
YYMMDDHHMM |
TIMESTAMP(8) |
YYYYMMDD |
TIMESTAMP(6) |
YYMMDD |
TIMESTAMP(4) |
YYMM |
TIMESTAMP(2) |
YY |
所有的TIMESTAMP列都有同樣的儲存大小，不考慮顯示尺寸。最常見的顯示尺寸是6、8、12、和14。你可以在表創建時間指定一個任意的顯示尺寸，但是值0或比14大被強制到14。在從1∼13範圍的奇數值尺寸被強制為下一個更大的偶數。
使用一個常用的格式集的任何一個，你可以指定DATETIME、DATE和TIMESTAMP值：
'YYYY-MM-DD HH:MM:SS'或'YY-MM-DD HH:MM:SS'格式的一個字符串。允許一種“寬松”的語法--任何標點可用作在日期部分和時間部分之間的分隔符。例如，'98-12-31
11:30:45'、'98.12.31 11+30+45'、'98/12/31 11*30*45'和'98@12@31
11^30^45'是等價的。 'YYYY-MM-DD'或'YY-MM-DD'格式的一個字符串。允許一種“寬松”的語法。例如，'98-12-31',
'98.12.31', '98/12/31'和'98@12@31'是等價的。 'YYYYMMDDHHMMSS'或'YYMMDDHHMMSS'格式的沒有任何分隔符的一個字符串，例如，'19970523091528'和'970523091528'被解釋為'1997-05-23
09:15:28'，但是'971122459015'是不合法的(它有毫無意義的分鐘部分)且變成'0000-00-00
00:00:00'。 'YYYYMMDD'或'YYMMDD'格式的沒有任何分隔符的一個字符串，如果字符串認為是一個日期。例如，'19970523'和'970523'被解釋作為'1997-05-23'，但是'971332'是不合法的(
它有無意義的月和天部分)且變成'0000-00-00'。 YYYYMMDDHHMMSS或YYMMDDHHMMSS格式的一個數字，如果數字認為是一個日期。例如，19830905132800和830905132800被解釋作為'1983-09-05
13:28:00'。 YYYYMMDD或YYMMDD格式的一個數字，如果數字認為是一個日期。例如，19830905和830905被解釋作為'1983-09-05'。
DATETIME, DATE或TIMESTAMP上下文環境中接受的函數，例如NOW()或CURRENT_DATE。
不合法DATETIME, DATE或TIMESTAMP值被變換到適當類型的“零”值('0000-00-00
00:00:00', '0000-00-00'或00000000000000)。
對於包括的日期部分分隔符的指定為字符串的值，不必要為小於10的月或天的值指定2位數字，'1979-6-9'與'1979-06-09'是一樣的。同樣,
對於包括的時間部分分隔符的指定為字符串的值，不必為小於10的小時、月或秒指定2位數字，'1979-10-30
1:2:3'與'1979-10-30 01:02:03'是一樣的。
指定為數字應該是6、8、12或14位長。如果數字是8或14位長，它被假定以YYYYMMDD或YYYYMMDDHHMMSS格式並且年份由頭4位數字給出。如果數字是6或12位長，它被假定是以YYMMDD或YYMMDDHHMMSS格式且年份由頭2位數字給出。不是這些長度之一的數字通過填補前頭的零到最接近的長度來解釋。
指定為無分隔符的字符串用它們給定的長度來解釋。如果字符串長度是8或14個字符，年份被假定頭4個字符給出，否則年份被假定由頭2個字符給出。對於字符串中呈現的多個部分，字符串從左到右邊被解釋，以找出年、月、日、小時、分鐘和秒值，這意味著，你不應該使用少於
6 個字符的字符串。例如，如果你指定'9903'，認為將代表1999年3月，你會發現MySQL把一個“零”日期插入到你的表中，這是因為年份和月份值99和03，但是日期部分丟失(零)，因此該值不是一個合法的日期。
TIMESTAMP列使用被指定的值的完整精度的儲存合法的值，不考慮顯示大小。這有幾個含意：
TIMESTAMP(4)或TIMESTAMP(2)。否則，值將不是一個合法的日期並且0將被儲存。
ALTER TABLE拓寬一個狹窄的TIMESTAMP列，以前被“隱蔽”的資訊將被顯示。
TIMESTAMP列不會導致資訊失去，除了感覺上值在顯示時，較少的資訊被顯示出。
TIMESTAMP值被儲存為完整精度，直接操作儲存值的唯一函數是UNIX_TIMESTAMP()，其他函數操作在格式化了的檢索的值上，這意味著你不能使用函數例如HOUR()或SECOND()，除非TIMESTAMP值的相關部分被包含在格式化的值中。例如，一個TIMESTAMP列的HH部分部被顯示，除非顯示大小至少是10，因此在更短的TIMESTAMP值上試試使用HOUR()產生一個無意義的結果。
在某種程度上，你可以把一種日期類型的值賦給一個不同的日期類型的對像。然而，這可能值有一些改變或資訊的損失：
DATE值賦給一個DATETIME或TIMESTAMP對像，結果值的時間部分被設置為'00:00:00'，因為DATE值不包含時間資訊。
DATETIME或TIMESTAMP值賦給一個DATE對像，結果值的時間部分被刪除，因為DATE類型不儲存時間資訊。
DATETIME, DATE和TIMESTAMP值全都可以用同樣的格式集來指定，但所有類型不都有同樣的值範圍。例如，TIMESTAMP值不能比1970早或比2037網晚，這意味著，一個日期例如'1968-01-01'，當作為一個DATETIME或DATE值合法時，它不是一個正確TIMESTAMP值，並且如果賦值給這樣一個對像，它將被變換到0。
當指定日期值時，當心某些缺陷：
'10:11:12'可能看起來像時間值，因為“:”分隔符，但是如果在一個日期中使用，上下文將作為年份被解釋成'2010-11-12'。值'10:45:15'將被變換到'0000-00-00'，因為'45'不是一個合法的月份。
00-69範圍的年值被變換到2000-2069。 70-99圍的年值被變換到1970-1999。 TIME類型MySQL檢索並以'HH:MM:SS'格式顯示TIME值(或對大小時值，'HHH:MM:SS'格式)。TIME值的範圍可以從'-838:59:59'到'838:59:59'。小時部分可能很大的的原因是TIME類型不僅可以被使用在表示一天的時間(它必須是不到24個小時)，而且用在表示在2個事件之間經過的時間或時間間隔(它可以是比24個小時大些，或甚至是負值)。
你能用多中格式指定TIME值：
'HH:MM:SS'格式的一個字符串。“寬松”的語法被允許--任何標點符號可用作時間部分的分隔符，例如，'10:11:12'和'10.11.12'是等價的。
'HHMMSS'格式的一個字符串，如果它作為一個時間解釋。例如，'101112'被理解為'10:11:12'，但是'109712'是不合法的(它有無意義的分鐘部分)並變成'00:00:00'。
HHMMSS格式的一個數字，如果它能解釋為一個時間。例如，101112被理解為'10:11:12'。
TIME上下文接受的函數，例如CURRENT_TIME。
對於作為包括一個時間分隔符的字符串被指定的TIME值，不必為小於10的小時、分鐘或秒值指定2位數字，'8:3:2'與'08:03:02'是一樣的。
將“短的”TIME值賦值給一個TIME行列是要格外小心。MySQL使用最右位代表秒的假設來解釋值。(MySQL將TIME值解釋為經過的時間，而非作為一天的時間
)例如，你可能想到'11:12'、'1112'和1112意味著'11:12:00'（11點12分)，但是MySQL解釋他們為'00:11:12'（11分12秒)。同樣，'12'和12被解釋為'00:00:12'。
但是超出TIME範圍之外的值是樣合法的，它被剪切到範圍適當的端點值。例如，'-850:00:00'和'850:00:00'被變換到'-838:59:59'和'838:59:59'。
不合法的TIME值被變換到'00:00:00'。注意，既然'00:00:00'本身是一個合法的TIME值，沒有其他方法區分表中儲存的一個'00:00:00'值，原來的值是否被指定為'00:00:00'或它是否是不合法的。
YEAR類型YEAR類型是一個 1 字節類型用於表示年份。
MySQL檢索並且以YYYY格式顯示YEAR值，其範圍是1901到2155。
你能用多種格式指定YEAR值：
'1901'到'2155'範圍的一個4位字符串。 1901到2155範圍的一個4位數字。 '00'到'99'範圍的一個2位字符串.在'00'到'69'和'70'到'99'範圍的值被變換到在2000到2069範圍和1970到1999的YEAR值。1到99範圍的一個2位數字。在範圍1到69和70到99的值被變換到在範圍2001到2069和1970到1999的YEAR的值。注意對於2位數字的範圍略微不同於2位數字字符串的範圍，因為你不能直接指定零作為一個數字並且把它解釋為2000。你必須作為一個字符串'0'或'00'指定它，它將被解釋為0000。
YEAR上下文環境中接受的函數，例如NOW()。
不合法YEAR值被變換到0000。
字符串類型是CHAR、VARCHAR、BLOB、TEXT、ENUM和SET。
CHAR和VARCHAR類型CHAR和VARCHAR類型是類似的，但是在他們被儲存和檢索的方式不同。
一個CHAR列的長度被修正為在你創造表時你所聲明的長度。長度可以是1和255之間的任何值。（在MySQL
3.23中，CHAR長度可以是0∼255。) 當CHAR值被儲存時，他們被用空格在右邊填補到指定的長度。當CHAR值被檢索時，拖後的空格被刪去。
在VARCHAR列中的值是變長字符串。你可以聲明一個VARCHAR列是在1和255之間的任何長度，就像對CHAR列。然而，與CHAR相反，VARCHAR值只儲存所需的字符，外加一個字節記錄長度，值不被填補﹔相反，當值被儲存時，拖後的空格被刪去。（這個空格刪除不同於ANSI
SQL規範。）
如果你把一個超過列最大長度的值賦給一個CHAR或VARCHAR列，值被截斷以適合它。
下表顯示了兩種類型的列的不同，通過演示儲存變長字符串值到CHAR(4)和VARCHAR(4)列：
| 值 | CHAR(4) |
儲存需求 | VARCHAR(4) |
儲存需求 |
'' |
' ' |
4 個字節 | '' |
1 字節 |
'ab' |
'ab ' |
4 個字節 | 'ab' |
3 個字節 |
'abcd' |
'abcd' |
4 個字節 | 'abcd' |
5 個字節 |
'abcdefgh' |
'abcd' |
4 個字節 | 'abcd' |
5 個字節 |
從CHAR(4)和VARCHAR(4)列檢索的值在每種情況下都是一樣的，因為拖後的空格從檢索的CHAR列上被刪除。
在CHAR和VARCHAR列中儲存和比較值是以大小寫不區分的方式進行的，除非當桌子被創建時，BINARY屬性被指定。BINARY屬性意味著該列的值根據MySQL伺服器正在運行的機器的ASCII順序以大小寫區分的方式儲存和比較。
BINARY屬性是“粘性”的。這意味著，如果標記了BINARY的列用於一個表達式中，整個的表達式作為一個BINARY值被比較。
MySQL在表創建時可以隱含地改變一個CHAR或VARCHAR列的類型。見7.7.1 隱含的的列說明改變。
BLOB和TEXT類型一個BLOB是一個能保存可變數量的數據的二進制的大對像。4個BLOB類型TINYBLOB、BLOB、MEDIUMBLOB和LONGBLOB僅僅在他們能保存值的最大長度方面有所不同。見7.3.1 列類型儲存需求。
4個TEXT類型TINYTEXT、TEXT、MEDIUMTEXT和LONGTEXT對應於4個BLOB類型，並且有同樣的最大長度和儲存需求。在BLOB和TEXT類型之間的唯一差別是對BLOB值的排序和比較以大小寫敏感方式執行，而對TEXT值是大小寫不敏感的。換句話說，一個TEXT是一個大小寫不敏感的BLOB。
如果你把一個超過列類型最大長度的值賦給一個BLOB或TEXT列，值被截斷以適合它。
在大多數方面，你可以認為一個TEXT行列是你所希望大的一個VARCHAR列。同樣，你可以認為一個BLOB列是一個VARCHAR
BINARY列。差別是：
BLOB和TEXT列上索引。更舊的MySQL版本不支援這個。
BLOB和TEXT列沒有拖後空格的刪除，因為對VARCHAR列有刪除。
BLOB和TEXT列不能有DEFAULT值。
MyODBC定義BLOB為LONGVARBINARY，TEXT值為LONGVARCHAR。
因為BLOB和TEXT值可以是非常長的，當使用他們時，你可能遇到一些限制：
BLOB或TEXT列上使用GROUP BY或ORDER
BY，你必須將列值變換成一個定長對像。這樣做的標準方法是用SUBSTRING函數。例如：
mysql> select comment from tbl_name,substring(comment,20) as substr ORDER BY substr;
如果你不這樣做，在排序時，只有列的首max_sort_length個字節被使用，預設的max_sort_length是1024﹔這個值能在啟動mysqld伺服器時使用-O選擇改變。你可以在包含BLOB或TEXT值得一個表達式上分組(group)，通過指定列的位置或使用一個別名：
mysql> select id,substring(blob_col,1,100) from tbl_name
GROUP BY 2;
mysql> select id,substring(blob_col,1,100) as b from tbl_name
GROUP BY b;
BLOB或TEXT對像的最大尺寸由其類型決定，但是你能在客戶與伺服器之間是實際傳輸的最大值由可用的內存數量和通訊緩衝區的大小來決定。你能改變消息緩衝區大小，但是你必須在伺服器和客戶兩端做。見10.2.3 調節伺服器參數。 注意，每個BLOB或TEXT值內部由一個獨立分配的對像表示。這與所有的其他列類型相反，它們是在打開表時，按列被分配一次儲存。
ENUM類型一個ENUM是一個字符對像，其值通常從一個在表創建時明確被列舉的允許值的一張表中選擇。
在下列的某個情形下，值也可以空字符串("")或NULL：
ENUM（即，一個不在允許的值列表中的字符串)，空字符串作為一個特殊錯誤的值被插入。
ENUM被聲明為NULL，NULL也是列的合法值，並且預設值是NULL。如果一個ENUM被聲明為NOT
NULL，預設值是允許值的列表的第一成員。 每枚舉值有一個編號：
SELECT語句找出被賦給無效ENUM值的行：
mysql> SELECT * FROM tbl_name WHERE enum_col=0;
NULL值的編號是NULL。 例如，指定為ENUM("one", "two", "three")的列可以有顯示在下面的值的任何一個。每個值的編號也被顯示：
| 值 | 編號 |
NULL |
NULL |
"" |
0 |
"one" |
1 |
"two" |
2 |
"three" |
3 |
枚舉可以有最大65535個成員。
當你把值賦給一個ENUM列時，字母的大小寫是無關緊要的。然而，以後從列中檢索的值大小寫匹配在表創建時用來指定允許值的值的大小寫。
如果你在一個數字的上下文環境中檢索一個ENUM，列值的編號被返回。如果你儲存一個數字到一個ENUM中，數字被當作一個標號，並且儲存的值是該編號的枚舉成員。
ENUM值根據列說明列舉的枚舉成員的次序被排序。（換句話說，ENUM值根據他們的編號數字被排序)
例如，對ENUM("a", "b")，"a"排在"b"前面，但是對ENUM("b",
"a")，"b"排在"a"前面。空字符串排序非空字符串之前，並且NULL排在所有其他枚舉值之前。
如果你想要得到一個ENUM列的所有可能的值，你應該使用：SHOW
COLUMNS FROM table_name LIKE enum_column_name並且分析在第二列的ENUM定義。
SET類型一個SET是可以有零或多個值的一個字符串對像，其每一個必須從表創建造被指定了的允許值的一張列表中被選擇。由多個集合成員組成的SET列通過由由逗號分隔(“,”)的成員被指定，其推論是該SET成員值不能包含逗號本身。
例如, 一個指定為SET("one", "two") NOT NULL的列可以有這些值的任何一個：
""
"one"
"two"
"one,two"
一個SET能有最多64個不同的成員。
MySQL用數字值儲存SET值，儲存值的低階位對應於第一個集合成員。如果你在數字上下文中檢索一個SET值，檢索的值把位設置位對應組成列值的集合成員。如果一個數字被儲存進一個SET列，在數字的二進制表示中設置的位決定了在列中的集合成員。假定一個列被指定為SET("a","b","c","d")，那麼成員有下列位值：
SET 成員 |
十進制的值 | 二進制的值 |
a |
1 |
0001 |
b |
2 |
0010 |
c |
4 |
0100 |
d |
8 |
1000 |
如果你給該列賦值9，即二進制的1001，這樣第一個和第四個SET值成員"a"和"d"被選擇並且結果值是"a,d"。
對於包含超過一個SET成員的值，當你插入值時，無所謂以什麼順序列舉值，也無所謂給定的值列舉了多少次。當以後檢索值時，在值中的每個成員將出現一次，根據他們在表創建時被指定的順序列出成員。例如，如果列指定為SET("a","b","c","d")，那麼"a,d"、"d,a"和"d,a,a,d,d"在檢索時將均作為"a,d"出現。
SET值以數字次序被排序。NULL指排在非NULL
SET值之前。
通常，你使用LIKE操作符或FIND_IN_SET()函數執行在一個SET上的一個SELECT：
mysql> SELECT * FROM tbl_name WHERE set_col LIKE '%value%';
mysql> SELECT * FROM tbl_name WHERE FIND_IN_SET('value',set_col)>0;
但是下列也會工作：
mysql> SELECT * FROM tbl_name WHERE set_col = 'val1,val2'; mysql> SELECT * FROM tbl_name WHERE set_col & 1;
這些語句的第一個語句尋找一個精確的匹配。第二個尋找包含第一個集合成員的值。
如果你想要得到一個SET列的所有可能的值，你應該使用：SHOW
COLUMNS FROM table_name LIKE set_column_name並且分析在第二列的SET定義。
為了最有效地使用儲存空間，試著在所有的情況下使用最精確的類型。例如，如果一個整數列被用於在之間1和99999的值，
MEDIUMINT UNSIGNED是最好的類型。
貨幣值的精確表示是一個常見的問題。在MySQL，你應該使用DECIMAL類型，它作為一個字符串被儲存，不會發生精確性的損失。如果精確性不是太重要，DOUBLE類型也是足夠好的。
對高精度，你總是能變換到以一個BIGINT儲存的定點類型。這允許你用整數做所有的計算，並且僅在必要時將結果轉換回浮點值。見10.6 選擇一個表類型。
所有的MySQL列類型能被索引。在相關的列上的使用索引是改進SELECT操作性能的最好方法。
一個表最多可有16個索引。最大索引長度是256個字節，盡管這可以在編譯MySQL時被改變。
對於CHAR和VARCHAR列，你可以索引列的前綴。這更快並且比索引整個列需要較少的磁碟空間。在CREATE
TABLE語句中索引列前綴的語法看起來像這樣：
KEY index_name (col_name(length))
下面的例子為name列的頭10個字符創建一個索引：
mysql> CREATE TABLE test (
name CHAR(200) NOT NULL,
KEY index_name (name(10)));
對於BLOB和TEXT列，你必須索引列的前綴，你不能索引列的全部。
MySQL能在多個列上創建索引。一個索引可以由最多15個列組成。（在CHAR和VARCHAR列上，你也可以使用列的前綴作為一個索引的部分)。
一個多重列索引可以認為是包含通過合並(concatenate)索引列值創建的值的一個排序數組。
當你為在一個WHERE子句索引的第一列指定已知的數量時，MySQL以這種方式使用多重列索引使得查詢非常快速，即使你不為其他列指定值。
假定一張表使用下列說明創建：
mysql> CREATE TABLE test (
id INT NOT NULL,
last_name CHAR(30) NOT NULL,
first_name CHAR(30) NOT NULL,
PRIMARY KEY (id),
INDEX name (last_name,first_name));
那麼索引name是一個在last_name和first_name上的索引，這個索引將被用於在last_name或last_name和first_name的一個已知範圍內指定值的查詢，因此，name索引將使用在下列查詢中：
mysql> SELECT * FROM test WHERE last_name="Widenius";
mysql> SELECT * FROM test WHERE last_name="Widenius"
AND first_name="Michael";
mysql> SELECT * FROM test WHERE last_name="Widenius"
AND (first_name="Michael" OR first_name="Monty");
mysql> SELECT * FROM test WHERE last_name="Widenius"
AND first_name >="M" AND first_name < "N";
然而，name索引將不用在下列詢問中：
mysql> SELECT * FROM test WHERE first_name="Michael";
mysql> SELECT * FROM test WHERE last_name="Widenius"
OR first_name="Michael";
關於MySQL使用索引改進性能的方式的更多的資訊，見10.4 使用MySQL索引。
為了跟容易地使用為其他供應商的SQL實現編寫的代碼，下表顯示了MySQL映射的列類型。這些映射使得從其他資料庫引擎移動表定義到MySQL更容易：
| 其他供應商類型 | MySQL類型 |
BINARY(NUM) |
CHAR(NUM) BINARY |
CHAR VARYING(NUM) |
VARCHAR(NUM) |
FLOAT4 |
FLOAT |
FLOAT8 |
DOUBLE |
INT1 |
TINYINT |
INT2 |
SMALLINT |
INT3 |
MEDIUMINT |
INT4 |
INT |
INT8 |
BIGINT |
LONG VARBINARY |
MEDIUMBLOB |
LONG VARCHAR |
MEDIUMTEXT |
MIDDLEINT |
MEDIUMINT |
VARBINARY(NUM) |
VARCHAR(NUM) BINARY |
列類型映射發生在表創建時。如果你用其他供應商使用的類型創建表，那麼發出一個DESCRIBE
tbl_name語句，MySQL使用等價的MySQL類型報告表結構。
SELECT和WHERE子句中的函數在一個SQL語句中的select_expression或where_definition可由使用下面描述的函數的任何表達式組成。
包含NULL的一個表達式總是產生一個NULL值，否則除非表達式所包含的操作符和函數在文檔中說明。
注意：在一個函數名和跟隨它的括號之間不許沒有空格。這幫助MySQL分析器區分函數調用和具有相同名字的對表或列的引用，盡管允許在參數周圍有空格。
為了簡潔，例子以縮寫形式顯示從mysql程式輸出。因此：
mysql> select MOD(29,9); 1 rows in set (0.00 sec) +-----------+ | mod(29,9) | +-----------+ | 2 | +-----------+
被顯示為這樣：
mysql> select MOD(29,9);
-> 2
( ... ) mysql> select 1+2*3;
-> 7
mysql> select (1+2)*3;
-> 9
一般的算術操作符是可用的。注意在-、+和*情況下，如果兩個參數是整數，結果用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
/ mysql> select 3/5;
-> 0.60
被零除產生一個NULL結果：
mysql> select 102/(1-1);
-> NULL
MySQL為位操作使用BIGINT（64位)算法，因此這些操作符有最大64位的一個範圍。
| mysql> select 29 | 15;
-> 31
& mysql> select 29 & 15;
-> 13
<< BIGINT)數字。 mysql> select 1 << 2
-> 4
>> BIGINT)數字。 mysql> select 4 >> 2
-> 1
~ mysql> select 5 & ~1
-> 4
BIT_COUNT(N) N設定的位的數量。 mysql> select BIT_COUNT(29);
-> 4
所有的邏輯函數返回1（TRUE）或0（FALSE）。
NOT ! 0，返回1，否則返回0。例外：
NOT NULL返回NULL。 mysql> select NOT 1;
-> 0
mysql> select NOT NULL;
-> NULL
mysql> select ! (1+1);
-> 0
mysql> select ! 1+1;
-> 1
最後的例子返回1，因為表達式作為(!1)+1計算。
OR || 0並且不NULL，返回1。
mysql> select 1 || 0;
-> 1
mysql> select 0 || 0;
-> 0
mysql> select 1 || NULL;
-> 1
AND && 0或NULL，返回0，否則返回1。
mysql> select 1 && NULL;
-> 0
mysql> select 1 && 0;
-> 0
比較操作得出值1（TRUE）、0（FALSE）或NULL等結果。這些函數工作運用在數字和字符串上。當需要時，字符串自動地被變換到數字且數字到字符串(如在Perl)。
MySQL使用下列規則執行比較：
NULL，比較的結果是NULL，除了<=>操作符。
TIMESTAMP或DATETIME列而其他參數是一個常數，在比較執行前，常數被轉換為一個時間標記。這樣做是為了對ODBC更友好。
預設地，字符串使用當前的字符集以大小寫敏感的方式進行(預設為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;
-> 1
>= mysql> select 2 >= 2;
-> 1
> mysql> select 2 > 2;
-> 0
<=> 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;
expr BETWEEN min AND max expr對大於或等於min且expr是小於或等於max，BETWEEN返回1，否則它返回0。如果所有的參數類型是一樣得，這等價於表達式(min
<= expr AND expr <= max)。第一個參數(expr)決定比較如何被執行。如果expr是一個大小寫不敏感的字符串表達式，進行一個大小寫不敏感的字符串比較。如果expr是一個大小寫敏感的字符串表達式，進行一個大小寫敏感的字符串比較。如果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 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
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
COALESCE(list) NULL的單元。 mysql> select COALESCE(NULL,1);
-> 1
mysql> select COALESCE(NULL,NULL,NULL);
-> NULL
INTERVAL(N,N1,N2,N3,...) 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
通常，如果在字符串比較中的任何表達式是區分大小寫的，比較以大小寫敏感的方式執行。
expr LIKE pat [ESCAPE 'escape-char'] 1（TRUE）或0（FALSE）。用LIKE，你可以在模式中使用下列2個通配符字符：
% |
匹配任何數目的字符，甚至零個字符 |
_ |
精確匹配一個字符 |
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
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 REGEXP pat expr RLIKE pat expr對一個模式pat的模式匹配。模式可以是一個擴充的正則表達式。見MySQL 正則表達式句法的 H 描述.如果expr匹配pat，返回1，否則返回0。RLIKE是REGEXP的一個同義詞，提供了與mSQL的兼容性。注意：因為MySQL在字符串中使用C轉義語法(例如，“\n”),
你必須在你的REGEXP字符串重複任何“\”。在MySQL3.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
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
BINARYBINARY操作符強制跟隨它後面的字符串為一個二進制字符串。即使列沒被定義為BINARY或BLOB，這是一個強制列比較區分大小寫的簡易方法。
mysql> select "a" = "A";
-> 1
mysql> select BINARY "a" = "A";
-> 0
BINARY在MySQL 3.23.0中被引入。
IFNULL(expr1,expr2) expr1不是NULL，IFNULL()返回expr1，否則它返回expr2。IFNULL()返回一個數字或字符串值，取決於它被使用的上下文環境。
mysql> select IFNULL(1,0);
-> 1
mysql> select IFNULL(0,10);
-> 0
mysql> select IFNULL(1/0,10);
-> 10
mysql> select IFNULL(1/0,'yes');
-> 'yes'
IF(expr1,expr2,expr3) expr1是TRUE(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'),'yes','no');
-> 'no'
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)。這可能不是你期望的。在第二種情況中，比較測試原來的浮點值看它是否是非零，比較的結果被用作一個整數。
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 result，其中value=compare-value。第二個版本中如果第一個條件為真，返回result。如果沒有匹配的result值，那麼結果在ELSE後的result被返回。如果沒有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
所有的數學函數在一個出錯的情況下返回NULL。
- mysql> select - 2;
注意，如果這個操作符與一個BIGINT使用，返回值是一個BIGINT！這意味著你應該避免在整數上使用-，那可能有值-2^63！
ABS(X) X的絕對值。 mysql> select ABS(2);
-> 2
mysql> select ABS(-32);
-> 32
SIGN(X) -1、0或1，取決於X是否是負數、零或正數。
mysql> select SIGN(-32);
-> -1
mysql> select SIGN(0);
-> 0
mysql> select SIGN(234);
-> 1
MOD(N,M) % %操作符)。返回N被M除的餘數。
mysql> select MOD(234, 10);
-> 4
mysql> select 253 % 7;
-> 1
mysql> select MOD(29,9);
-> 2
這個函數可安全用於BIGINT值。
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
ROUND(X) X的四捨五入的一個整數。 mysql> select ROUND(-1.23);
-> -1
mysql> select ROUND(-1.58);
-> -2
mysql> select ROUND(1.58);
-> 2
ROUND(X,D) X的四捨五入的有D為小數的一個數字。如果D為0，結果將沒有小數點或小數部分。
mysql> select ROUND(1.298, 1);
-> 1.3
mysql> select ROUND(1.298, 0);
-> 1
EXP(X) e（自然對數的底）的X次方。 mysql> select EXP(2);
-> 7.389056
mysql> select EXP(-2);
-> 0.135335
LOG(X) X的自然對數。 mysql> select LOG(2);
-> 0.693147
mysql> select LOG(-2);
-> NULL
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() mysql> select PI();
-> 3.141593
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。L如果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
ATAN2(X,Y) X和Y的反正切。它類似於計算Y/X的反正切，除了兩個參數的符號被用來決定結果的像限。
mysql> select ATAN(-2,2);
-> -0.785398
mysql> select ATAN(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.5925
mysql> select RAND(20);
-> 0.1811
mysql> select RAND(20);
-> 0.1811
mysql> select RAND();
-> 0.2079
mysql> select RAND();
-> 0.7888
你不能在一個ORDER BY子句用RAND()值使用列，因為ORDER
BY將重複計算列多次。然而在MySQL3.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被執行時重新評估。
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"
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
如果結果的長度大於伺服器參數max_allowed_packet，字符串值函數返回NULL。見10.2.3 調節伺服器參數。
對於針對字符串位置的操作，第一個位置被標記為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(str) ((first
byte ASCII code)*256+(second byte ASCII code))[*256+third byte ASCII code...]返回字符的ASCII代碼值來返回多字節字符代碼。如果最左面的字符不是一個多字節字符。返回與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) N一個字符串的表示，在此N是一個長整型(BIGINT)數字，這等價於CONV(N,10,16)。如果N是NULL，返回NULL。
mysql> select HEX(255);
-> 'FF'
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'
LENGTH(str) OCTET_LENGTH(str) CHAR_LENGTH(str) CHARACTER_LENGTH(str) str的長度。 mysql> select LENGTH('text');
-> 4
mysql> select OCTET_LENGTH('text');
-> 4
LOCATE(substr,str) POSITION(substr IN str) substr在字符串str第一個出現的位置，如果substr不是在str裡面，返回0.
mysql> select LOCATE('bar', 'foobarbar');
-> 4
mysql> select LOCATE('xbar', 'foobar');
-> 0
該函數是多字節可靠的。
LOCATE(substr,str,pos) substr在字符串str第一個出現的位置，從位置pos開始。如果substr不是在str裡面，返回0。mysql> select LOCATE('bar', 'foobarbar',5);
-> 7
INSTR(str,substr) substr在字符串str中的第一個出現的位置。這與有2個參數形式的LOCATE()相同，除了參數被顛倒。
mysql> select INSTR('foobarbar', 'bar');
-> 4
mysql> select INSTR('xbar', 'foobar');
-> 0
LPAD(str,len,padstr) str，左面用字符串padstr填補直到str是len個字符長。
mysql> select LPAD('hi',4,'??');
-> '??hi'
RPAD(str,len,padstr) str，右面用字符串padstr填補直到str是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返回一個len個字符的子串，從位置pos開始。使用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的一個同音字符串。聽起來“大致相同”的2個字符串應該有相同的同音字符串。一個“標準”的同音字符串長是4個字符，但是SOUNDEX()函數返回一個任意長的字符串。你可以在結果上使用SUBSTRING()得到一個“標準”的
同音串。所有非數字字母字符在給定的字符串中被忽略。所有在A-Z之外的字符國際字母被當作元音。
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('www.mysql.com', 'w', 'Ww');
-> 'WwWwWw.mysql.com'
REPEAT(str,count) countTimes次的字符串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) 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]]) mysql> select EXPORT_SET(5,'Y','N',',',4)
-> Y,N,Y,N
LCASE(str) LOWER(str) str，根據當前字符集映射(預設是ISO-8859-1
Latin1)把所有的字符改變成小寫。該函數對多字節是可靠的。 mysql> select LCASE('QUADRATICALLY');
-> 'quadratically'
UCASE(str) UPPER(str) str，根據當前字符集映射(預設是ISO-8859-1
Latin1)把所有的字符改變成大寫。該函數對多字節是可靠的。 mysql> select UCASE('Hej');
-> 'HEJ'
LOAD_FILE(file_name) max_allowed_packet。如果文件不存在或由於上面原因之一不能被讀出，函數返回NULL。
mysql> UPDATE table_name
SET blob_column=LOAD_FILE("/tmp/picture")
WHERE id=1;
MySQL必要時自動變換數字為字符串，並且反過來也如此：
mysql> SELECT 1+"1";
-> 2
mysql> SELECT CONCAT(2,' test');
-> '2 test'
如果你想要明確地變換一個數字到一個字符串，把它作為參數傳遞到CONCAT()。
如果字符串函數提供一個二進制字符串作為參數，結果字符串也是一個二進制字符串。被變換到一個字符串的數字被當作是一個二進制字符串。這僅影響比較。
對於每個類型擁有的值範圍以及並且指定日期何時間值的有效格式的描述見7.3.6 日期和時間類型。
這裡是一個使用日期函數的例子。下面的查詢選擇了所有記錄，其date_col的值是在最後30天以內：
mysql> SELECT something FROM table
WHERE TO_DAYS(NOW()) - TO_DAYS(date_col) <= 30;
DAYOFWEEK(date) date的星期索引(1=星期天，2=星期一,
……7=星期六)。這些索引值對應於ODBC標準。 mysql> select DAYOFWEEK('1998-02-03');
-> 3
WEEKDAY(date) date的星期索引(0=星期一，1=星期二,
……6= 星期天)。 mysql> select WEEKDAY('1997-10-04 22:23:00');
-> 5
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到52。2個參數形式WEEK()允許你指定星期是否開始於星期天或星期一。如果第二個參數是0，星期從星期天開始，如果第二個參數是1，從星期一開始。
mysql> select WEEK('1998-02-20');
-> 7
mysql> select WEEK('1998-02-20',0);
-> 7
mysql> select WEEK('1998-02-20',1);
-> 8
YEAR(date) date的年份，範圍在1000到9999。mysql> select YEAR('98-02-03');
-> 1998
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不是日期值。
mysql> select PERIOD_ADD(9801,2);
-> 199803
PERIOD_DIFF(P1,P2) P1和P2之間月數，P1和P2應該以格式YYMM或YYYYMM。注意，時期參數P1和P2不是日期值。
mysql> select PERIOD_DIFF(9802,199703);
-> 11
DATE_ADD(date,INTERVAL expr type) DATE_SUB(date,INTERVAL expr type) ADDDATE(date,INTERVAL expr type) SUBDATE(date,INTERVAL expr type) ADDDATE()和SUBDATE()是DATE_ADD()和DATE_SUB()的同義詞。在MySQL
3.23中，你可以使用+和-而不是DATE_ADD()和DATE_SUB()。（見例子）date是一個指定開始日期的DATETIME或DATE值，expr是指定加到開始日期或從開始日期減去的間隔值一個表達式，expr是一個字符串﹔它可以以一個“-”開始表示負間隔。type是一個關鍵詞，指明表達式應該如何被解釋。EXTRACT(type
FROM date)函數從日期中返回“type”間隔。下表顯示了type和expr參數怎樣被關聯：
type值 |
含義 | 期望的expr格式 |
SECOND |
秒 | SECONDS |
MINUTE |
分鐘 | MINUTES |
HOUR |
時間 | HOURS |
DAY |
天 | DAYS |
MONTH |
月 | MONTHS |
YEAR |
年 | YEARS |
MINUTE_SECOND |
分鐘和秒 | "MINUTES:SECONDS" |
HOUR_MINUTE |
小時和分鐘 | "HOURS:MINUTES" |
DAY_HOUR |
天和小時 | "DAYS HOURS" |
YEAR_MONTH |
年和月 | "YEARS-MONTHS" |
HOUR_SECOND |
小時, 分鐘， | "HOURS:MINUTES:SECONDS" |
DAY_MINUTE |
天, 小時, 分鐘 | "DAYS HOURS:MINUTES" |
DAY_SECOND |
天, 小時, 分鐘, 秒 | "DAYS HOURS:MINUTES:SECONDS" |
MySQL在expr格式中允許任何標點分隔符。表示顯示的是建議的分隔符。如果date參數是一個DATE值並且你的計算僅僅包含YEAR、MONTH和DAY部分(即，沒有時間部分)，結果是一個DATE值。否則結果是一個DATETIME值。
mysql> SELECT "1997-12-31 23:59:59" + INTERVAL 1 SECOND;
-> 1998-01-01 00:00:00
mysql> SELECT INTERVAL 1 DAY + "1997-12-31";
-> 1998-01-01
mysql> SELECT "1998-01-01" - INTERVAL 1 SECOND;
-> 1997-12-31 23:59:59
mysql> SELECT DATE_ADD("1997-12-31 23:59:59",
INTERVAL 1 SECOND);
-> 1998-01-01 00:00:00
mysql> SELECT DATE_ADD("1997-12-31 23:59:59",
INTERVAL 1 DAY);
-> 1998-01-01 23:59:59
mysql> SELECT DATE_ADD("1997-12-31 23:59:59",
INTERVAL "1:1" MINUTE_SECOND);
-> 1998-01-01 00:01:00
mysql> SELECT DATE_SUB("1998-01-01 00:00:00",
INTERVAL "1 1:1:1" DAY_SECOND);
-> 1997-12-30 22:58:59
mysql> SELECT DATE_ADD("1998-01-01 00:00:00",
INTERVAL "-1 10" DAY_HOUR);
-> 1997-12-30 14:00:00
mysql> SELECT DATE_SUB("1998-01-02", INTERVAL 31 DAY);
-> 1997-12-02
mysql> SELECT EXTRACT(YEAR FROM "1999-07-02");
-> 1999
mysql> SELECT EXTRACT(YEAR_MONTH FROM "1999-07-02 01:02:03");
-> 199907
mysql> SELECT EXTRACT(DAY_MINUTE FROM "1999-07-02 01:02:03");
-> 20102
如果你指定太短的間隔值(不包括type關鍵詞期望的間隔部分)，MySQL假設你省掉了間隔值的最左面部分。例如，如果你指定一個type是DAY_SECOND，值expr被希望有天、小時、分鐘和秒部分。如果你像"1:10"這樣指定值，MySQL假設日子和小時部分是丟失的並且值代表分鐘和秒。換句話說，"1:10"
DAY_SECOND以它等價於"1:10" MINUTE_SECOND的方式解釋，這對那MySQL解釋TIME值表示經過的時間而非作為一天的時間的方式有二義性。如果你使用確實不正確的日期，結果是NULL。如果你增加MONTH、YEAR_MONTH或YEAR並且結果日期大於新月份的最大值天數，日子在新月用最大的天調整。
mysql> select DATE_ADD('1998-01-30', Interval 1 month);
-> 1998-02-28
注意，從前面的例子中詞INTERVAL和type關鍵詞不是區分大小寫的。
TO_DAYS(date) date，返回一個天數(從0年的天數)。 mysql> select TO_DAYS(950501);
-> 728779
mysql> select TO_DAYS('1997-10-07');
-> 729669
FROM_DAYS(N) N，返回一個DATE值。 mysql> select FROM_DAYS(729669);
-> '1997-10-07'
DATE_FORMAT(date,format) format字符串格式化date值。下列修飾符可以被用在format字符串中：
%M |
月名字(January……December) |
%W |
星期名字(Sunday……Saturday) |
%D |
有英語前綴的月份的日期(1st, 2nd, 3rd,
等等。） |
%Y |
年, 數字, 4 位 |
%y |
年, 數字, 2 位 |
%a |
縮寫的星期名字(Sun……Sat) |
%d |
月份中的天數, 數字(00……31) |
%e |
月份中的天數, 數字(0……31) |
%m |
月, 數字(01……12) |
%c |
月, 數字(1……12) |
%b |
縮寫的月份名字(Jan……Dec) |
%j |
一年中的天數(001……366) |
%H |
小時(00……23) |
%k |
小時(0……23) |
%h |
小時(01……12) |
%I |
小時(01……12) |
%l |
小時(1……12) |
%i |
分鐘, 數字(00……59) |
%r |
時間,12 小時(hh:mm:ss [AP]M) |
%T |
時間,24 小時(hh:mm:ss) |
%S |
秒(00……59) |
%s |
秒(00……59) |
%p |
AM或PM |
%w |
一個星期中的天數(0=Sunday ……6=Saturday ） |
%U |
星期(0……52), 這裡星期天是星期的第一天 |
%u |
星期(0……52), 這裡星期一是星期的第一天 |
%% |
一個文字“%”。 |
所有的其他字符不做解釋被複製到結果中。
mysql> select DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
-> 'Saturday October 1997'
mysql> select DATE_FORMAT('1997-10-04 22:23:00', '%H:%i:%s');
-> '22:23:00'
mysql> select DATE_FORMAT('1997-10-04 22:23:00',
'%D %y %a %d %m %b %j');
-> '4th 97 Sat 04 10 Oct 277'
mysql> select DATE_FORMAT('1997-10-04 22:23:00',
'%H %k %I %r %T %S %w');
-> '22 22 10 10:23:00 PM 22:23:00 00 6'
TIME_FORMAT(time,format) DATE_FORMAT()函數一樣使用，但是format字符串只能包含處理小時、分鐘和秒的那些格式修飾符。其他修飾符產生一個NULL值或0。
CURDATE() CURRENT_DATE 'YYYY-MM-DD'或YYYYMMDD格式返回今天日期值，取決於函數是在一個字符串還是數字上下文被使用。
mysql> select CURDATE();
-> '1997-12-15'
mysql> select CURDATE() + 0;
-> 19971215
CURTIME() CURRENT_TIME 'HH:MM:SS'或HHMMSS格式返回當前時間值，取決於函數是在一個字符串還是在數字的上下文被使用。
mysql> select CURTIME();
-> '23:50:26'
mysql> select CURTIME() + 0;
-> 235026
NOW() SYSDATE() CURRENT_TIMESTAMP 'YYYY-MM-DD HH:MM:SS'或YYYYMMDDHHMMSS格式返回當前的日期和時間，取決於函數是在一個字符串還是在數字的上下文被使用。
mysql> select NOW();
-> '1997-12-15 23:50:26'
mysql> select NOW() + 0;
-> 19971215235026
UNIX_TIMESTAMP() UNIX_TIMESTAMP(date) '1970-01-01 00:00:00'GMT開始的秒數)。如果UNIX_TIMESTAMP()用一個date參數被調用，它返回從'1970-01-01
00:00:00' GMT開始的秒數值。date可以是一個DATE字符串、一個DATETIME字符串、一個TIMESTAMP或以YYMMDD或YYYYMMDD格式的本地時間的一個數字。
mysql> select UNIX_TIMESTAMP();
-> 882226357
mysql> select UNIX_TIMESTAMP('1997-10-04 22:23:00');
-> 875996580
當UNIX_TIMESTAMP被用於一個TIMESTAMP列，函數將直接接受值，沒有隱含的“string-to-unix-timestamp”變換。
FROM_UNIXTIME(unix_timestamp) 'YYYY-MM-DD HH:MM:SS'或YYYYMMDDHHMMSS格式返回unix_timestamp參數所表示的值，取決於函數是在一個字符串還是或數字上下文中被使用。
mysql> select FROM_UNIXTIME(875996580);
-> '1997-10-04 22:23:00'
mysql> select FROM_UNIXTIME(875996580) + 0;
-> 19971004222300
FROM_UNIXTIME(unix_timestamp,format) format字符串格式化。format可以包含與DATE_FORMAT()函數列出的條目同樣的修飾符。
mysql> select FROM_UNIXTIME(UNIX_TIMESTAMP(),
'%Y %D %M %h:%i:%s %x');
-> '1997 23rd December 03:43:30 x'
SEC_TO_TIME(seconds) seconds參數，變換成小時、分鐘和秒，值以'HH:MM:SS'或HHMMSS格式化，取決於函數是在一個字符串還是在數字上下文中被使用。
mysql> select SEC_TO_TIME(2378);
-> '00:39:38'
mysql> select SEC_TO_TIME(2378) + 0;
-> 3938
TIME_TO_SEC(time) time參數，轉換成秒。 mysql> select TIME_TO_SEC('22:23:00');
-> 80580
mysql> select TIME_TO_SEC('00:39:38');
-> 2378
DATABASE() mysql> select DATABASE();
-> 'test'
USER() SYSTEM_USER() SESSION_USER() mysql> select USER();
-> 'davida@localhost'
在MySQL 3.22.11或以後版本中，這包括用戶名和客戶主機名。你可以像這樣只提取用戶名部分(值是否包括主機名部分均可工作)：
mysql> select substring_index(USER(),"@",1);
-> 'davida'
PASSWORD(str) str計算一個密碼字符串。該函數被用於為了在user授權表的Password列中儲存密碼而加密MySQL密碼。
mysql> select PASSWORD('badpwd');
-> '7f84554057dd964b'
PASSWORD()加密是非可逆的。PASSWORD()不以與Unix密碼加密的相同的方法執行密碼加密。你不應該假定如果你的Unix
密碼和你的MySQL密碼是一樣的，PASSWORD()將導致與在Unix密碼文件儲存的相同的加密值。見ENCRYPT()。
ENCRYPT(str[,salt]) crypt()系統調用加密str。salt參數應該是一個有2個字符的字符串。（MySQL
3.22.16中，salt可以長於2個字符。）mysql> select ENCRYPT("hello");
-> 'VxuFAJXVARROc'
如果crypt()在你的系統上不可用，ENCRYPT()總是返回NULL。ENCRYPT()只保留str起始8個字符而忽略所有其他，至少在某些系統上是這樣。這將由底層的crypt()系統調用的行為決定。
ENCODE(str,pass_str) pass_str作為密碼加密str。為了解密結果，使用DECODE()。結果是一個二進制字符串，如果你想要在列中保存它，使用一個BLOB列類�