• 第12章:函数和操作符

    SQL 语句中,表达式可用于一些诸如SELECT语句的ORDER BY HAVING子句、SELECT DELETE UPDATE语句的WHERE 子句或 SET语句之类的地方。使用文本值、column值、NULL值、函数、 操作符来书写表达式。 本章叙述了可用于书写MySQL表达式的函数和操作符。

    除非在文档编制中对一个函数或操作符另有指定的情况外,一个包含NULL 的表达式通常产生一个NULL 值。

    注释 在默认状态下, 在函数和紧随其后的括号之间不得存在空格。这能帮助  MySQL 分析程序区分一些同函数名相同的函数调用以及表或列。不过,函数自变量周围允许有空格出现。

    可以通过选择--sql-mode=IGNORE_SPACE来打开MySQL服务器的方法使服务器接受函数名后的空格。 个人客户端程序可通过选择mysql_real_connect()CLIENT_IGNORE_SPACE 实现这一状态。在以上两种情况中, 所有的函数名都成为保留字。请参见5.3.2节,“SQL服务器模式”

    为节省时间,本章中对大多数例子使用简写形式展示了 mysql 程序的输出结果。 对于以下格式的举例展示:

    mysql> SELECT MOD(29,9);

    +-----------+

    | mod(29,9) |

    +-----------+

    |         2 |

    +-----------+

    1 rows in set (0.00 )

    使用如下格式进行代替:

    mysql> SELECT MOD(29,9);

            -> 2

    12.1. 操作符

    12.1.1. 操作符优先级

    以下列表显示了操作符优先级的由低到高的顺序。排列在同一行的操作符具有相同的优先级。

    :=

    ||, OR, XOR

    &&, AND

    NOT

    BETWEEN, CASE, WHEN, THEN, ELSE

    =, <=>, >=, >, <=, <, <>, !=, IS, LIKE, REGEXP, IN

    |

    &

    <<, >>

    -, +

    *, /, DIV, %, MOD

    ^

    - (一元减号), ~ (一元比特反转)

    !

    BINARY, COLLATE

    注释假如 HIGH_NOT_PRECEDENCE SQL 模式被激活,则 NOT 的优先级同 the  ! 操作符相同。请参见5.3.2节,“SQL服务器模式”

    12.1.2. 圆括号

    • ( ... )

      使用括弧来规定表达式的运算顺序,例如:

      mysql> SELECT 1+2*3;
              -> 7
      mysql> SELECT (1+2)*3;
              -> 9
      

    12.1.3. 比较函数和操作符

    比较运算产生的结果为1(TRUE)0 (FALSE) NULL。这些运算可用于数字和字符串。根据需要,字符串可自动转换为数字,而数字也可自动转换为字符串。

    本章中的一些函数 (LEAST()GREATEST()) 的所得值不包括 1 (TRUE) 0 (FALSE) NULL。然而,其所得值乃是基于按照下述规则运行的比较运算:  

    MySQL按照以下规则进行数值比较:

    • 若有一个或两个参数 NULL,除非NULL-safe <=> 等算符,则比较运算的结果为NULL
    • 若同一个比较运算中的两个参数都是字符串,则按照字符串进行比较。
    • 若两个参数均为整数,则按照整数进行比较。 
    • 十六进制值在不需要作为数字进行比较时,则按照二进制字符串进行处理。
    • 假如参数中的一个为 TIMESTAMP DATETIME 列,而其它参数均为常数, 则在进行比较前将常数转为 timestamp。这样做的目的是为了使ODBC的进行更加顺利。 注意,这不适合IN()中的参数!为了更加可靠,在进行对比时通常使用完整的 datetime/date/time字符串。
    • 在其它情况下,参数作为浮点数进行比较。  

    在默认状态下,字符串比较不区分大小写,并使用现有字符集(默认为cp1252 Latin1,同时对英语也适合)

    为了进行比较,可使用CAST()函数将某个值转为另外一种类型。 使用CONVERT()将字符串值转为不同的字符集。请参见12.8节,“Cast函数和操作符”

    以下例子说明了比较运算中将字符串转为数字的过程:

    mysql> SELECT 1 > '6x';

            -> 0

    mysql> SELECT 7 > '6x';

            -> 1

    mysql> SELECT 0 > 'x6';

            -> 0

    mysql> SELECT 0 = 'x6';

            -> 1

    注意,在将一个字符串列同一个数字进行比较时, MySQL 不能使用列中的索引进行快速查找。假如str_col 是一个编入索引的字符串列,则在以下语句中,索引不能执行查找功能:

    SELECT * FROM tbl_name WHERE str_col=1;

    其原因是许多不同的字符串都可被转换为数值 1: '1' ' 1' '1a'、 ……

    • =

    等于:

    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

    • <=>

    NULL-safe equal.这个操作符和=操作符执行相同的比较操作,不过在两个操作码均为NULL时,其所得值为1而不为NULL,而当一个操作码为NULL时,其所得值为0而不为NULL

    mysql> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;

            -> 1, 1, 0

    mysql> SELECT 1 = 1, NULL = NULL, 1 = NULL;

            -> 1, NULL, NULL

    • <> !=

    不等于:

    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

    • IS boolean_value IS NOT boolean_value

    根据一个布尔值来检验一个值,在这里,布尔值可以是TRUEFALSEUNKNOWN

    mysql> SELECT 1 IS TRUE, 0 IS FALSE, NULL IS UNKNOWN;

            -> 1, 1, 1

    mysql> SELECT 1 IS NOT UNKNOWN, 0 IS NOT UNKNOWN, NULL IS NOT UNKNOWN;

            -> 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

    为了能够顺利的使用ODBC 程序工作,在使用IS NULL时,MySQL支持一下额外特性:

      • 在一个值产生后,立即运行一个以下格式的语句,从而找到最新AUTO_INCREMENT 值的所在行:

    o                     SELECT * FROM tbl_name WHERE auto_col IS NULL

    当设置SQL_AUTO_IS_NULL=0时,这项操作无法运行。请参见13.5.3节,“SET语法”

      • 对于命名为NOT NULL DATE DATETIME列,可通过使用如下的 语句找到特定日期 '0000-00-00'

    o                     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)。其它类型的转换根据本章开篇所述规律进行,且适用于3参数中任意一种。 

    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)

    ·         COALESCE(value,...)

    返回值为列表当中的第一个非 NULL值,在没有非NULL 值得情况下返回值为 NULL

    mysql> SELECT COALESCE(NULL,1);

            -> 1

    mysql> SELECT COALESCE(NULL,NULL,NULL);

            -> NULL

    ·         GREATEST(value1,value2,...)

    当有2或多个参数时,返回值为最大(最大值的)参数。比较参数所依据的规律同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'

    在没有自变量为NULL的情况下,GREATEST()的返回值为NULL

    ·         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

    IN 列表中所列值的个数仅受限于 max_allowed_packet 值。

    为了同SQL 标准相一致,在左侧表达式为NULL的情况下,或是表中找不到匹配项或是表中一个表达式为NULL 的情况下,IN的返回值均为NULL

    IN() 语构也可用书写某些类型的子查询。请参见13.2.8.3节,“使用ANY、IN和SOME进行子查询”

    ·         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 值对比通常是错误的。

     ISNULL() 函数同 IS NULL比较操作符具有一些相同的特性。请参见有关IS NULL 的说明。

    ·         INTERVAL(N,N1,N2,N3,...)

    假如N < N1则返回值为0;假如N < N2 等等,则返回值为1;假如N NULL,则返回值为 -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

    ·         LEAST(value1,value2,...)

    在有两个或多个参数的情况下, 返回值为最小 (最小值) 参数。用一下规则将自变量进行对比:

      • 假如返回值被用在一个 INTEGER 语境中,或是所有参数均为整数值,则将其作为整数值进行比较。
      • 假如返回值被用在一个 REAL语境中,或所有参数均为实值,则 将其作为实值进行比较。
      • 假如任意一个参数是一个区分大小写的字符串,则将参数按照区分大小写的字符串进行比较。
      • 在其它情况下,将参数作为区分大小写的字符串进行比较。

    假如任意一个自变量为NULL,则 LEAST()的返回值为NULL

    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> SELECT CAST(LEAST(3600, 9223372036854775808.0) as SIGNED);

            -> -9223372036854775808

    发生这种情况的原因是MySQL在整数语境中读取9223372036854775808.0。整数表示法不利于保存数值,因此它包括一个带符号整数。

    12.1.4. 逻辑操作符

    SQL中,所有逻辑 操作符的求值所得结果均为 TRUEFALSE NULL (UNKNOWN)。在 MySQL中,它们体现为  1 (TRUE) 0 (FALSE) NULL。其大多数都与不同的数据库SQL通用,然而一些服务器对TRUE的返回值可能是任意一个非零值。

    • NOT !

    逻辑 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 &&

    逻辑AND。当所有操作数均为非零值、并且不为NULL时,计算所得结果为  1 ,当一个或多个操作数为0 时,所得结果为 0 ,其余情况返回值为 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

    • OR ||

    逻辑 OR。当两个操作数均为非 NULL值时,如有任意一个操作数为非零值,则结果为1,否则结果为0。当有一个操作数为NULL时,如另一个操作数为非零值,则结果为1,否则结果为 NULL 。假如两个操作数均为  NULL,则所得结果为 NULL

    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

    逻辑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) b)

    同样见 12.1.1节,“操作符优先级”

    12.2. 控制流程函数

    • 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。而第二个方案的返回结果是第一种情况的真实结果。如果没有匹配的结果值,则返回结果为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

    一个CASE表达式的默认返回值类型是任何返回值的相容集合类型,但具体情况视其所在语境而定。如果用在字符串语境中,则返回结果味字符串。如果用在数字语境中,则返回结果为十进制值、实值或整数值。 

    • IF(expr1,expr2,expr3)

    如果 expr1 TRUE (expr1 <> 0 and expr1 <> NULL),则 IF()的返回值为expr2; 否则返回值则为 expr3IF() 的返回值为数字值或字符串值,具体情况视其所在语境而定。

    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表达式的结果类型。

    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() (这一点在其被储存到临时表时很重要 ) 的默认返回值类型按照以下方式计算:

    表达式

    返回值

    expr2 expr3 返回值为一个字符串。

    字符串

    expr2 expr3 返回值为一个浮点值。

    浮点

    expr2 expr3 返回值为一个整数。 

    整数

    假如expr2 expr3 都是字符串,且其中任何一个字符串区分大小写,则返回结果是区分大小写。

    • IFNULL(expr1,expr2)

    假如expr1 不为 NULL,则 IFNULL() 的返回值为 expr1; 否则其返回值为 expr2IFNULL()的返回值是数字或是字符串,具体情况取决于其所使用的语境。

    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'

    IFNULL(expr1,expr2)的默认结果值为两个表达式中更加“通用”的一个,顺序为STRING REAL INTEGER。假设一个基于表达式的表的情况,  MySQL必须在内存储器中储存一个临时表中IFNULL()的返回值:

    CREATE TABLE tmp SELECT IFNULL(1,'test') AS test

    在这个例子中,测试列的类型为 CHAR(4)

    • NULLIF(expr1,expr2)

    如果expr1 = expr2  成立,那么返回值为NULL,否则返回值为 expr1。这和CASE WHEN expr1 = expr2 THEN NULL ELSE expr1 END相同。

    mysql> SELECT NULLIF(1,1);

            -> NULL

    mysql> SELECT NULLIF(1,2);

            -> 1

    注意,如果参数不相等,则 MySQL 两次求得的值为  expr1

    12.3. 字符串函数

    假如结果的长度大于 max_allowed_packet 系统变量的最大值时,字符串值函数的返回值为NULL。请参见7.5.2节,“调节服务器参数”

    对于在字符串位置操作的函数,第一个位置的编号为 1

    • ASCII(str)

    返回值为字符串str 的最左字符的数值。假如str为空字符串,则返回值为 0 。假如str NULL,则返回值为 NULL ASCII()用于带有从 0255的数值的字符。

    mysql> SELECT ASCII('2');

            -> 50

    mysql> SELECT ASCII(2);

            -> 50

    mysql> SELECT ASCII('dx');

            -> 100

    ORD()函数。

    • BIN(N)

    返回值为N的二进制值的字符串表示,其中  N 为一个longlong (BIGINT) 数字。这等同于 CONV(N,10,2)。假如N NULL,则返回值为 NULL

    mysql> SELECT BIN(12);

            -> '1100'

    • BIT_LENGTH(str)

    返回值为二进制的字符串str 长度。

    mysql> SELECT BIT_LENGTH('text');

            -> 32

    • CHAR(N,... [USING charset])

    CHAR()将每个参数N理解为一个整数,其返回值为一个包含这些整数的代码值所给出的字符的字符串。NULL值被省略。

    mysql> SELECT CHAR(77,121,83,81,'76');

            -> 'MySQL'

    mysql> SELECT CHAR(77,77.3,'77.3');

            -> 'MMM'

    大于 255CHAR()参数被转换为多结果字符。 例如,CHAR(256) 相当于 CHAR(1,0), CHAR(256*256) 则相当于 CHAR(1,0,0)

    mysql> SELECT HEX(CHAR(1,0)), HEX(CHAR(256));

    +----------------+----------------+

    | HEX(CHAR(1,0)) | HEX(CHAR(256)) |

    +----------------+----------------+

    | 0100           | 0100           |

    +----------------+----------------+

    mysql> SELECT HEX(CHAR(1,0,0)), HEX(CHAR(256*256));

    +------------------+--------------------+

    | HEX(CHAR(1,0,0)) | HEX(CHAR(256*256)) |

    +------------------+--------------------+

    | 010000           | 010000             |

    +------------------+--------------------+

    CHAR()的返回值为一个二进制字符串。可选择使用USING语句产生一个给出的字符集中的字符串:

    mysql> SELECT CHARSET(CHAR(0x65)), CHARSET(CHAR(0x65 USING utf8));

    mysql> SELECT CHARSET(CHAR(0x65)), CHARSET(CHAR(0x65 USING utf8));
    +---------------------+--------------------------------+
    | CHARSET(CHAR(0x65)) | CHARSET(CHAR(0x65 USING utf8)) |
    +---------------------+--------------------------------+
    | binary              | utf8                           |
    +---------------------+--------------------------------+

    如果 USING已经产生,而结果字符串不符合给出的字符集,则会发出警告。   同样,如果严格的SQL模式被激活,则CHAR()的结果会成为 NULL

    • CHAR_LENGTH(str)

    返回值为字符串str 的长度,长度的单位为字符。一个多字节字符算作一个单字符。对于一个包含五个二字节字符集, LENGTH()返回值为 10, CHAR_LENGTH()的返回值为5

    • CHARACTER_LENGTH(str)

    CHARACTER_LENGTH()CHAR_LENGTH()的同义词。

    • COMPRESS(string_to_compress)

    压缩一个字符串。这个函数要求 MySQL已经用一个诸如zlib的压缩库压缩过。   否则,返回值始终是NULLUNCOMPRESS() 可将压缩过的字符串进行解压缩。

    mysql> SELECT LENGTH(COMPRESS(REPEAT('a',1000)));

            -> 21

    mysql> SELECT LENGTH(COMPRESS(''));

            -> 0

    mysql> SELECT LENGTH(COMPRESS('a'));

            -> 13

    mysql> SELECT LENGTH(COMPRESS(REPEAT('a',16)));

            -> 15

    压缩后的字符串的内容按照以下方式存储:

      • 空字符串按照空字符串存储。
      • 非空字符串未压缩字符串的四字节长度进行存储(首先为低字节),后面是压缩字符串。如果字符串以空格结尾,就会在后加一".",以防止当结果值是存储在CHARVARCHAR类型的字段列时,出现自动把结尾空格去掉的现象。(不推荐使用 CHAR VARCHAR 来存储压缩字符串。最好使用一个 BLOB 列代替)
    • CONCAT(str1,str2,...)                       

    返回结果为连接参数产生的字符串。如有任何一个参数为NULL ,则返回值为 NULL。或许有一个或多个参数。 如果所有参数均为非二进制字符串,则结果为非二进制字符串。 如果自变量中含有任一二进制字符串,则结果为一个二进制字符串。一个数字参数被转化为与之相等的二进制字符串格式;若要避免这种情况,可使用显式类型 cast, 例如: SELECT CONCAT(CAST(int_col AS CHAR), char_col)

    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 With Separator ,是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'

    CONCAT_WS()不会忽略任何空字符串。 (然而会忽略所有的 NULL

    • CONV(N,from_base,to_base)

    不同数基间转换数字。返回值为数字的N字符串表示,由from_base基转化为 to_base 基。如有任意一个参数为NULL,则返回值为 NULL。自变量 N 被理解为一个整数,但是可以被指定为一个整数或字符串。最小基数为 2 ,而最大基数则为 36 If 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'

    • 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'

    • EXPORT_SET(bits,on,off[,separator[,number_of_bits]])

    返回值为一个字符串,其中对于bits值中的每个位组,可以得到一个 on 字符串,而对于每个清零比特位,可以得到一个off 字符串。bits 中的比特值按照从右到左的顺序接受检验 (由低位比特到高位比特)。字符串被分隔字符串分开(默认为逗号‘,),按照从左到右的顺序被添加到结果中。number_of_bits 会给出被检验的二进制位数 (默认为 64)

    mysql> SELECT EXPORT_SET(5,'Y','N',',',4);

            -> 'Y,N,Y,N'

    mysql> SELECT EXPORT_SET(6,'1','0',',',10);

            -> '0,1,1,0,0,0,0,0,0,0'

    • FIELD(str,str1,str2,str3,...)

    返回值为str1, str2, str3,……列表中的str 指数。在找不到str 的情况下,返回值为 0

    如果所有对于FIELD() 的参数均为字符串,则所有参数均按照字符串进行比较。如果所有的参数均为数字,则按照数字进行比较。否则,参数按照双倍进行比较。

    如果str NULL,则返回值为0 ,原因是NULL不能同任何值进行同等比较。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 之间 。一个字符串列表就是一个由一些被‘,’符号分开的自链组成的字符串。如果第一个参数是一个常数字符串,而第二个是type SET列,则   FIND_IN_SET() 函数被优化,使用比特计算。如果str不在strlist strlist 为空字符串,则返回值为 0 。如任意一个参数为NULL,则返回值为 NULL。 这个函数在第一个参数包含一个逗号(,)时将无法正常运行。 

    mysql> SELECT FIND_IN_SET('b','a,b,c,d');

            -> 2

    • FORMAT(X,D)

    number X设置为格式 '#,###,###.##', 以四舍五入的方式保留到小数点后D, 而返回结果为一个字符串。详见12.9.4节,“其他函数”.

    • HEX(N_or_S)

    如果N_OR_S 是一个数字,则返回一个 十六进制值 N 字符串表示,在这里,   N 是一个longlong (BIGINT)数。这相当于 CONV(N,10,16)

    如果N_OR_S 是一个字符串,则返回值为一个N_OR_S的十六进制字符串表示, 其中每个N_OR_S 里的每个字符被转化为两个十六进制数字。

    mysql> SELECT HEX(255);

            -> 'FF'

    mysql> SELECT 0x616263;

            -> 'abc'

    mysql> SELECT HEX('abc');

            -> 616263

    • INSERT(str,pos,len,newstr)

    返回字符串 str, 其子字符串起始于 pos 位置和长期被字符串 newstr取代的len 字符。  如果pos 超过字符串长度,则返回值为原始字符串。 假如len的长度大于其它字符串的长度,则从位置pos开始替换。若任何一个参数null,则返回值为NULL

    mysql> SELECT INSERT('Quadratic', 3, 4, 'What');

            -> 'QuWhattic'

    mysql> SELECT INSERT('Quadratic', -1, 4, 'What');

            -> 'Quadratic'

    mysql> SELECT INSERT('Quadratic', 3, 100, 'What');

            -> 'QuWhat'

    这个函数支持多字节字元

    • INSTR(str,substr)

    返回字符串 str 中子字符串的第一个出现位置。这和LOCATE()的双参数形式相同,除非参数的顺序被颠倒。 

    mysql> SELECT INSTR('foobarbar', 'bar');

            -> 4

    mysql> SELECT INSTR('xbar', 'foobar');

            -> 0

    这个函数支持多字节字元,并且只有当至少有一个参数是二进制字符串时区分大小写。

    • LCASE(str)

    LCASE() LOWER()的同义词。

    • LEFT(str,len)

    返回从字符串str 开始的len 最左字符。

    mysql> SELECT LEFT('foobarbar', 5);

            -> 'fooba'

    • LENGTH(str)

    返回值为字符串str 的长度,单位为字节。一个多字节字符算作多字节。这意味着 对于一个包含52字节字符的字符串, LENGTH() 的返回值为 10, CHAR_LENGTH()的返回值则为5

    mysql> SELECT LENGTH('text');

            -> 4

    • LOAD_FILE(file_name)

    读取文件并将这一文件按照字符串的格式返回。 文件的位置必须在服务器上,你必须为文件制定路径全名,而且你还必须拥有FILE 特许权。文件必须可读取,文件容量必须小于 max_allowed_packet字节。

    若文件不存在,或因不满足上述条件而不能被读取, 则函数返回值为 NULL

    mysql> UPDATE tbl_name

               SET blob_column=LOAD_FILE('/tmp/picture')

               WHERE id=1;

    • LOCATE(substr,str) , LOCATE(substr,str,pos)

    第一个语法返回字符串 str中子字符串substr的第一个出现位置。第二个语法返回字符串 str中子字符串substr的第一个出现位置, 起始位置在pos。如若substr 不在str中,则返回值为0

    mysql> SELECT LOCATE('bar', 'foobarbar');

            -> 4

    mysql> SELECT LOCATE('xbar', 'foobar');

            -> 0

    mysql> SELECT LOCATE('bar', 'foobarbar',5);

            -> 7

    这个函数支持多字节字元,并且只有当至少有一个参数是二进制字符串时区分大小写。 

    • LOWER(str)

    返回字符串 str 以及所有根据最新的字符集映射表变为小写字母的字符 (默认为  cp1252 Latin1)

    mysql> SELECT LOWER('QUADRATICALLY');

            -> 'quadratically'

    这个函数支持多字节字元。

    • LPAD(str,len,padstr)

    返回字符串 str, 其左边由字符串padstr 填补到len 字符长度。假如str 的长度大于len, 则返回值被缩短至 len 字符。

    mysql> SELECT LPAD('hi',4,'??');

            -> '??hi'

    mysql> SELECT LPAD('hi',1,'??');

            -> 'h'

    • LTRIM(str)

    返回字符串 str ,其引导空格字符被删除。

    mysql> SELECT LTRIM('  barbar');

            -> 'barbar'

    这个函数支持多字节字元。

    • 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(1 | 4,'hello','nice',NULL,'world');

            -> 'hello'

    mysql> SELECT MAKE_SET(0,'a','b','c');

            -> ''

    • MID(str,pos,len)

    MID(str,pos,len) SUBSTRING(str,pos,len)的同义词。

    • OCT(N)

    返回一个 N的八进制值的字符串表示,其中 N 是一个longlong (BIGINT)数。这等同于CONV(N,10,8)。若N NULL ,则返回值为NULL

    mysql> SELECT OCT(12);

            -> '14'

    • OCTET_LENGTH(str)

    OCTET_LENGTH() LENGTH()的同义词。

    • ORD(str)

    若字符串str 的最左字符是一个多字节字符,则返回该字符的代码, 代码的计算通过使用以下公式计算其组成字节的数值而得出:

       (1st byte code)
    + (2nd byte code × 256)
    + (3rd byte code × 2562) ...

     

    假如最左字符不是一个多字节字符,那么 ORD()和函数ASCII()返回相同的值。

    mysql> SELECT ORD('2');

            -> 50

    • POSITION(substr IN str)

    POSITION(substr IN str) LOCATE(substr,str)同义词。

    • QUOTE(str)

    引证一个字符串,由此产生一个在SQL语句中可用作完全转义数据值的结果。  返回的字符串由单引号标注,每例都带有单引号 (')、 反斜线符号 (\) ASCII NUL以及前面有反斜线符号的Control-Z 。如果自变量的值为NULL, 则返回不带单引号的单词 “NULL”。

    mysql> SELECT QUOTE('Don\'t!');

            -> 'Don\'t!'

    mysql> SELECT QUOTE(NULL);

            -> NULL

    • REPEAT(str,count)

    返回一个由重复的字符串str 组成的字符串,字符串str的数目等于count 。 若 count <= 0,则返回一个空字符串。若str count NULL,则返回 NULL

    mysql> SELECT REPEAT('MySQL', 3);

            -> 'MySQLMySQLMySQL'

    • REPLACE(str,from_str,to_str)

    返回字符串str 以及所有被字符串to_str替代的字符串from_str

    mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');

            -> 'WwWwWw.mysql.com'

    这个函数支持多字节字元。

    • REVERSE(str)

    返回字符串 str ,顺序和字符顺序相反。

    mysql> SELECT REVERSE('abc');

            -> 'cba'

    这个函数支持多字节字元。

    • RIGHT(str,len)

    从字符串str 开始,返回最右len 字符。

    mysql> SELECT RIGHT('foobarbar', 4);

            -> 'rbar'

    这个函数支持多字节字元。

    • RPAD(str,len,padstr)

    返回字符串str, 其右边被字符串 padstr填补至len 字符长度。假如字符串str 的长度大于 len,则返回值被缩短到与 len 字符相同长度。

    mysql> SELECT RPAD('hi',5,'?');

            -> 'hi???'

    mysql> SELECT RPAD('hi',1,'?');

            -> 'h'

    这个函数支持多字节字元。

    • RTRIM(str)

    返回字符串 str ,结尾空格字符被删去。

    mysql> SELECT RTRIM('barbar   ');

            -> 'barbar'

    这个函数支持多字节字元。

    • SOUNDEX(str)

    str返回一个soundex字符串。 两个具有几乎同样探测的字符串应该具有同样的 soundex 字符串。一个标准的soundex 字符串的长度为4个字符,然而SOUNDEX() 函数会返回一个人以长度的字符串。 可使用结果中的SUBSTRING() 来得到一个标准 soundex 字符串。在str会忽略所有未按照字母顺序排列的字符。 所有不在A-Z范围之内的国际字母符号被视为元音字母。

    mysql> SELECT SOUNDEX('Hello');

            -> 'H400'

    mysql> SELECT SOUNDEX('Quadratically');

            -> 'Q36324'

    注意:这个函数执行原始的Soundex算法,而非更加流行的加强版本(D. Knuth所述)。其区别在于原始版本首先会删去元音,其次是重复,而加强版则首先删去重复,而后删去元音。

    • expr1 SOUNDS LIKE expr2

    这相当于SOUNDEX(expr1) = SOUNDEX(expr2)

    • SPACE(N)

    返回一个由N 间隔符号组成的字符串。

    mysql> SELECT SPACE(6);

            -> '      '

    • SUBSTRING(str,pos) , SUBSTRING(str FROM pos) SUBSTRING(str,pos,len) , SUBSTRING(str FROM pos FOR len)

    不带有len 参数的格式从字符串str返回一个子字符串,起始于位置 pos。带有len参数的格式从字符串str返回一个长度同len字符相同的子字符串,起始于位置 pos。 使用 FROM的格式为标准 SQL 语法。也可能对pos使用一个负值。假若这样,则子字符串的位置起始于字符串结尾的pos 字符,而不是字符串的开头位置。在以下格式的函数中可以对pos 使用一个负值。

    mysql> SELECT SUBSTRING('Quadratically',5);

            -> 'ratically'

    mysql> SELECT SUBSTRING('foobarbar' FROM 4);

            -> 'barbar'

    mysql> SELECT SUBSTRING('Quadratically',5,6);

            -> 'ratica'       

    mysql> SELECT SUBSTRING('Sakila', -3);

            -> 'ila'       

    mysql> SELECT SUBSTRING('Sakila', -5, 3);

            -> 'aki'

    mysql> SELECT SUBSTRING('Sakila' FROM -4 FOR 2);

            -> 'ki'

    这个函数支持多字节字元。

    注意,如果对len使用的是一个小于1的值,则结果始终为空字符串。

    SUBSTR() SUBSTRING()的同义词。

    • SUBSTRING_INDEX(str,delim,count)

    在定界符 delim 以及count 出现前,从字符串str返回自字符串。若count为正值,则返回最终定界符(从左边开始)左边的一切内容。若count为负值,则返回定界符(从右边开始)右边的一切内容。

    mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);

            -> 'www.mysql'

    mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2);

            -> 'mysql.com'

    这个函数支持多字节字元。

    • TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str) TRIM(remstr FROM] str)

    返回字符串 str , 其中所有remstr 前缀和/或后缀都已被删除。若分类符BOTHLEADINTRAILING中没有一个是给定的,则假设为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'

    这个函数支持多字节字元。

    • UCASE(str)

    UCASE()UPPER()的同义词。

    • UNCOMPRESS(string_to_uncompress)

    对经COMPRESS()函数压缩后的字符串进行解压缩。若参数为压缩值,则结果为 NULL。这个函数要求  MySQL 已被诸如zlib 之类的压缩库编译过。否则, 返回值将始终是 NULL

    mysql> SELECT UNCOMPRESS(COMPRESS('any string'));

            -> 'any string'

    mysql> SELECT UNCOMPRESS('any string');

            -> NULL

    • UNCOMPRESSED_LENGTH(compressed_string)

    返回压缩字符串压缩前的长度。

    mysql> SELECT UNCOMPRESSED_LENGTH(COMPRESS(REPEAT('a',30)));

            -> 30

    • UNHEX(str)

    执行从HEX(str)的反向操作。就是说,它将参数中的每一对十六进制数字理解为一个数字,并将其转化为该数字代表的字符。结果字符以二进制字符串的形式返回。

    mysql> SELECT UNHEX('4D7953514C');

            -> 'MySQL'

    mysql> SELECT 0x4D7953514C;

            -> 'MySQL'

    mysql> SELECT UNHEX(HEX('string'));

            -> 'string'

    mysql> SELECT HEX(UNHEX('1267'));

            -> '1267'

    • UPPER(str)

    返回字符串str 以及根据最新字符集映射转化为大写字母的字符 (默认为cp1252 Latin1).

    mysql> SELECT UPPER('Hej');

            -> 'HEJ'

    该函数支持多字节字元。

    12.3.1. 字符串比较函数

    根据,MySQL 会自动将数字转化为字符串,反之亦然。 

    mysql> SELECT 1+'1';

            -> 2

    mysql> SELECT CONCAT(2,' test');

            -> '2 test'

    若想要将数字明确地转化为字符串,可使用 CAST() CONCAT()函数:

    mysql> SELECT 38.8, CAST(38.8 AS CHAR);

            -> 38.8, '38.8'

    mysql> SELECT 38.8, CONCAT(38.8);

            -> 38.8, '38.8'

    CAST() 比较可取。.

    若已经对一个字符串函数给定一个二进制字符串作为参数, 则所得到的结果字符串也是一个二进制字符串。一个转化为字符串的数字被作为二进制字符串对待。这仅会对比较结果产生影响。

    一般而言, 若字符串比较中任意一个表达式是区分大小写的,则执行比较时也区分大小写。 

    • expr LIKE pat [ESCAPE 'escape-char']

    模式匹配,使用SQL简单正规表达式比较。返回1 (TRUE) 0 (FALSE)。 若 expr pat 中任何一个为 NULL,则结果为 NULL

    模式不需要为文字字符串。例如,可以被指定为一个字符串表达式或表列。

    在模式中可以同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 5.1.2开始, 如若 NO_BACKSLASH_ESCAPES SQL模式被激活, 则该序列不能为空。

    以下两个语句举例说明了字符串比较不区分大小写,除非其中一个操作数为二进制字符串:

    mysql> SELECT 'abc' LIKE 'ABC';

            -> 1

    mysql> SELECT 'abc' LIKE BINARY 'ABC';

            -> 0

    MySQL, LIKE 允许出现在数字表达式中。 (这是标准SQL LIKE 的延伸)

    mysql> SELECT 10 LIKE '1%';

            -> 1

    注释 由于 MySQL在字符串中使用 C转义语法(例如, 用‘\n’代表一个换行字符),在LIKE字符串中,必须将用到的‘\’双写。例如, 若要查找 ‘\n, 必须将其写成 ‘\\n’。而若要查找 ‘\, 则必须将其写成 it as \\\\;原因是反斜线符号会被语法分析程序剥离一次,在进行模式匹配时,又会被剥离一次,最后会剩下一个反斜线符号接受匹配。

    • expr NOT LIKE pat [ESCAPE 'escape-char']

    这相当于 NOT (expr LIKE pat [ESCAPE 'escape-char'])

    • expr NOT REGEXP pat expr NOT RLIKE pat

    这相当于NOT (expr REGEXP pat)

    • expr REGEXP pat expr RLIKE pat

    执行字符串表达式 expr 和模式pat 的模式匹配。该模式可以被延伸为正规表达式。正规表达式的语法在附录G:MySQL正则表达式中有详细讨论。若expr 匹配 pat则返回 1; 否则返回0。若 expr pat 任意一个为 NULL, 则结果为 NULL RLIKE REGEXP的同义词, 作用是为mSQL 提供兼容性。

    模式不需要为文字字符串。例如,可以被指定为一个字符串表达式或表列。

    注释由于在字符串中, MySQL使用 C 转义语法 (例如, 用‘\n’来代表换行字符 ),REGEXP字符串中必须将用到的‘\’ 双写。

    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 使用当前字符集 (默认为cp1252 Latin1 )警告:这些操作符不支持多字节字元。

    • STRCMP(expr1,expr2)

    若所有的字符串均相同,则返回STRCMP(),若根据当前分类次序,第一个参数小于第二个,则返回  -1,其它情况返回 1

    mysql> SELECT STRCMP('text', 'text2');

            -> -1

    mysql> SELECT STRCMP('text2', 'text');

            -> 1

    mysql> SELECT STRCMP('text', 'text');

            -> 0

    在执行比较时,STRCMP() 使用当前字符集。这使得默认的比较区分大小写,当操作数中的一个或两个都是二进制字符串时除外。

    12.4. 数值函数

    12.4.1. 算术操作符

    可使用常见的算术操作符。注意就 - + *而言, 若两个参数均为正数,则其计算结果的精确度为 BIGINT (64比特),若其中一个参数为无符号整数, 而其它参数也是整数, 则结果为无符号整数。请参见12.8节,“Cast函数和操作符”

    • +

    加号:

    mysql> SELECT 3+5;

            -> 8

    • -

    减号:

    mysql> SELECT 3-5;

            -> -2

    • -

    一元减号。更换参数符号。

    mysql> SELECT - 2;

            -> -2

    注意:若该 操作符同一个BIGINT同时使用,则返回值也是一个BIGINT。这意味着你应当尽量避免对可能产生–263的整数使用 –。

    • *

    乘号:

    mysql> SELECT 3*5;

            -> 15

    mysql> SELECT 18014398509481984*18014398509481984.0;

            -> 324518553658426726783156020576256.0

    mysql> SELECT 18014398509481984*18014398509481984;

            -> 0

    最后一个表达式的结果是不正确的。原因是整数相乘的结果超过了BIGINT 计算的 64比特范围。 (11.2节,“数值类型”.)

    • /

    除号:

    mysql> SELECT 3/5;

            -> 0.60

    被零除的结果为 NULL

    mysql> SELECT 102/(1-1);

            -> NULL

    只有当执行的语境中,其结果要被转化为一个整数时 ,除法才会和 BIGINT 算法一起使用。

    • DIV

    整数除法。 类似于 FLOOR(),然而使用BIGINT 算法也是可靠的。

    mysql> SELECT 5 DIV 2;

            -> 2

    12.4.2. 数学函数

    若发生错误,所有数学函数会返回 NULL

    • ABS(X)

    返回X 的绝对值。

    mysql> SELECT ABS(2);

            -> 2

    mysql> SELECT ABS(-32);

            -> 32

    该函数支持使用BIGINT值。

    • ACOS(X)

    返回X 反余弦, , 余弦是X的值。若X 不在-1 1的范围之内,则返回 NULL

    mysql> SELECT ACOS(1);

            -> 0

    mysql> SELECT ACOS(1.0001);

            -> NULL

    mysql> SELECT ACOS(0);

            -> 1.5707963267949

    • ASIN(X)

    返回X 的反正弦,即,正弦为X 的值。若X  X 不在-1 1的范围之内,则返回 NULL

     

    mysql> SELECT ASIN(0.2);
            -> 0.20135792079033
    mysql> SELECT ASIN('foo');
     
    +-------------+
    | ASIN('foo') |
    +-------------+
    |           0 |
    +-------------+
    1 row in set, 1 warning (0.00 sec)
     
    mysql> SHOW WARNINGS;
    +---------+------+-----------------------------------------+
    | Level   | Code | Message                                 |
    +---------+------+-----------------------------------------+
    | Warning | 1292 | Truncated incorrect DOUBLE value: 'foo' |
    +---------+------+-----------------------------------------+
    • ATAN(X)

    返回X 的反正切,即,正切为X 的值。

    mysql> SELECT ATAN(2);

            -> 1.1071487177941

    mysql> SELECT ATAN(-2);

            -> -1.1071487177941

    • ATAN(Y,X) , ATAN2(Y,X)

    返回两个变量X Y的反正切。 它类似于 Y X的反正切计算 除非两个参数的符号均用于确定结果所在象限。

    mysql> SELECT ATAN(-2,2);

            -> -0.78539816339745

    mysql> SELECT ATAN2(PI(),0);

            -> 1.5707963267949

    • CEILING(X) CEIL(X)

    返回不小于X 的最小整数值。

    mysql> SELECT CEILING(1.23);

            -> 2

    mysql> SELECT CEIL(-1.23);

            -> -1

    这两个函数的意义相同。注意返回值会被转化为一个BIGINT

    • COS(X)

    返回X 的余弦,其中X在弧度上已知。 

    mysql> SELECT COS(PI());

            -> -1

    • COT(X)

    返回X 的余切。

    mysql> SELECT COT(12);

            -> -1.5726734063977

    mysql> SELECT COT(0);

            -> NULL

    • CRC32(expr)

    计算循环冗余码校验值并返回一个 32比特无符号值。若参数为NULL ,则结果为 NULL。该参数应为一个字符串,而且在不是字符串的情况下会被作为字符串处理(若有可能)。

    mysql> SELECT CRC32('MySQL');

            -> 3259397556

    mysql> SELECT CRC32('mysql');

            -> 2501908538

    • DEGREES(X)

    返回参数 X, 该参数由弧度被转化为度。

    mysql> SELECT DEGREES(PI());

            -> 180

    mysql> SELECT DEGREES(PI() / 2);

            -> 90

    • EXP(X)

    返回eX乘方后的值(自然对数的底)

    mysql> SELECT EXP(2);

            -> 7.3890560989307

    mysql> SELECT EXP(-2);

            -> 0.13533528323661

    mysql> SELECT EXP(0);

            -> 1

    • FLOOR(X)

    返回不大于X的最大整数值 。

    mysql> SELECT FLOOR(1.23);

            -> 1

    mysql> SELECT FLOOR(-1.23);

            -> -2

    注意,返回值会被转化为一个 BIGINT

    • FORMAT(X,D)

    将数字X 的格式写成'#,###,###.##'格式, 即保留小数点后 D位,而第D位的保留方式为四舍五入,然后将结果以字符串的形式返回。详见12.9.4节,“其他函数”

    • LN(X)

    返回X 的自然对数,, X 相对于基数e 的对数。

    mysql> SELECT LN(2);

            -> 0.69314718055995

    mysql> SELECT LN(-2);

            -> NULL

    这个函数同LOG(X)具有相同意义。

    • LOG(X) LOG(B,X)

    若用一个参数调用,这个函数就会返回X 的自然对数。

    mysql> SELECT LOG(2);

            -> 0.69314718055995

    mysql> SELECT LOG(-2);

            -> NULL

    若用两个参数进行调用,这个函数会返回X 对于任意基数B 的对数。

    mysql> SELECT LOG(2,65536);

            -> 16

    mysql> SELECT LOG(10,100);

            -> 2

    LOG(B,X) 就相当于 LOG(X) / LOG(B)

    • LOG2(X)

    返回X 的基数为2的对数。

    mysql> SELECT LOG2(65536);

            -> 16

    mysql> SELECT LOG2(-100);

            -> NULL

    对于查出存储一个数字需要多少个比特,LOG2()非常有效。这个函数相当于表达式 LOG(X) / LOG(2)

    • LOG10(X)

    返回X的基数为10的对数。

    mysql> SELECT LOG10(2);

            -> 0.30102999566398

    mysql> SELECT LOG10(100);

            -> 2

    mysql> SELECT LOG10(-100);

            -> NULL

    LOG10(X)相当于LOG(10,X)

    • MOD(N,M) , N % M N MOD M

    模操作。返回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 值。

    MOD() 对于带有小数部分的数值也起作用, 它返回除法运算后的精确余数:

    mysql> SELECT MOD(34.5,3);

            -> 1.5

    • PI()

    返回 ϖ (pi)的值。默认的显示小数位数是7,然而 MySQL内部会使用完全双精度值。

    mysql> SELECT PI();

            -> 3.141593

    mysql> SELECT PI()+0.000000000000000000;

            -> 3.141592653589793116

    • POW(X,Y) , POWER(X,Y)

    返回X Y乘方的结果值。

    mysql> SELECT POW(2,2);

            -> 4

    mysql> SELECT POW(2,-2);

            -> 0.25

    • RADIANS(X)

    返回由度转化为弧度的参数 X,  (注意 ϖ 弧度等于180度)

    mysql> SELECT RADIANS(90);

            -> 1.5707963267949

    • RAND() RAND(N)

    返回一个随机浮点值 v ,范围在 0 1 之间 (, 其范围为 0 v 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

    mysql> SELECT RAND(20);

            -> 0.15888261251047

    若要在i R j 这个范围得到一个随机整数R ,需要用到表达式 FLOOR(i + RAND() * (j i + 1))。例如, 若要在7 12 的范围(包括712)内得到一个随机整数, 可使用以下语句:

    SELECT FLOOR(7 + (RAND() * 6));

    ORDER BY语句中,不能使用一个带有RAND()值的列,原因是 ORDER BY 会计算列的多重时间。然而,可按照如下的随机顺序检索数据行:

    mysql> SELECT * FROM tbl_name ORDER BY RAND();

    ORDER BY RAND() LIMIT 的结合从一组列中选择随机样本很有用:

    mysql> SELECT * FROM table1, table2 WHERE a=b AND c<d

        -> ORDER BY RAND() LIMIT 1000;

    注意,在WHERE语句中,WHERE每执行一次, RAND()就会被再计算一次。

    RAND()的作用不是作为一个精确的随机发生器,而是一种用来发生在同样的 MySQL版本的平台之间的可移动ad hoc随机数的快速方式。

    • ROUND(X) ROUND(X,D)

    返回参数X, 其值接近于最近似的整数。在有两个参数的情况下,返回 X ,其值保留到小数点后D位,而第D位的保留方式为四舍五入。若要接保留X值小数点左边的D 位,可将 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

    mysql> SELECT ROUND(23.298, -1);

            -> 20

    返回值的类型同 第一个自变量相同(假设它是一个整数、双精度数或小数)。这意味着对于一个整数参数,结果也是一个整数(无小数部分)

    当第一个参数是十进制常数时,对于准确值参数,ROUND() 使用精密数学题库:

      • 对于准确值数字, ROUND() 使用“四舍五入” 或“舍入成最接近的数” 的规则:对于一个分数部分为 .5或大于 .5的值,正数则上舍入到邻近的整数值, 负数则下舍入临近的整数值。(换言之, 其舍入的方向是数轴上远离零的方向)对于一个分数部分小于.5 的值,正数则下舍入下一个整数值,负数则下舍入邻近的整数值,而正数则上舍入邻近的整数值。
      • 对于近似值数字,其结果根据C 库而定。在很多系统中,这意味着 ROUND()的使用遵循“舍入成最接近的偶数”的规则: 一个带有任何小数部分的值会被舍入成最接近的偶数整数。

    以下举例说明舍入法对于精确值和近似值的不同之处:

    mysql> SELECT ROUND(2.5), ROUND(25E-1);

    +------------+--------------+

    | ROUND(2.5) | ROUND(25E-1) |

    +------------+--------------+

    | 3          |            2 |

    +------------+--------------+

    详见第24章:精度数学

    • SIGN(X)

    返回参数作为-1 01的符号,该符号取决于X 的值为负、零或正。

    mysql> SELECT SIGN(-32);

            -> -1

    mysql> SELECT SIGN(0);

            -> 0

    mysql> SELECT SIGN(234);

            -> 1

    • SIN(X)

    返回X 正弦,其中 X 在弧度中被给定。

    mysql> SELECT SIN(PI());

            -> 1.2246063538224e-16

    mysql> SELECT ROUND(SIN(PI()));

            -> 0

    • SQRT(X)

    返回非负数X 的二次方根。

    mysql> SELECT SQRT(4);

            -> 2

    mysql> SELECT SQRT(20);

            -> 4.4721359549996

    mysql> SELECT SQRT(-16);

            -> NULL       

    • TAN(X)

    返回X 的正切,其中X 在弧度中被给定。

    mysql> SELECT TAN(PI());

            -> -1.2246063538224e-16

    mysql> SELECT TAN(PI()+1);

            -> 1.5574077246549

    • TRUNCATE(X,D)

    返回被舍去至小数点后D位的数字X。若D 的值为 0, 则结果不带有小数点或不带有小数部分。可以将D设为负数,若要截去(归零) X小数点左起第D位开始后面所有低位的值.  

    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> SELECT TRUNCATE(122,-2);

           -> 100

    mysql> SELECT TRUNCATE(10.28*100,0);

           -> 1028

    所有数字的舍入方向都接近于零。

    12.5. 日期和时间函数

    本章论述了一些可用于操作时间值的函数。关于每个时间和日期类型具有的值域及指定值的有效格式,请参见11.3节,“日期和时间类型”

    下面的例子使用了时间函数。以下询问选择了最近的 30天内所有带有date_col 值的记录:

    mysql> SELECT something FROM tbl_name

        -> WHERE DATE_SUB(CURDATE(),INTERVAL 30 DAY) <= date_col;

    注意,这个询问也能选择将来的日期记录。 

    用于日期值的函数通常会接受时间日期值而忽略时间部分。而用于时间值的函数通常接受时间日期值而忽略日期部分。

    返回各自当前日期或时间的函数在每次询问执行开始时计算一次。这意味着在一个单一询问中,对诸如NOW() 的函数多次访问总是会得到同样的结果(未达到我们的目的,单一询问也包括对存储程序或触发器和被该程序/触发器调用的所有子程序的调用 )。这项原则也适用于 CURDATE() CURTIME() UTC_DATE() UTC_TIME()UTC_TIMESTAMP(),以及所有和它们意义相同的函数。

    CURRENT_TIMESTAMP() CURRENT_TIME() CURRENT_DATE()以及FROM_UNIXTIME()函数返回连接当前时区内的值,这个值可用作time_zone系统变量的值。此外, UNIX_TIMESTAMP() 假设其参数为一个当前时区的时间日期值。请参见5.10.8节,“MySQL服务器时区支持”

    以下函数的论述中返回值的范围会请求完全日期。 若一个日期为“零” 值,或者是一个诸如'2001-11-00'之类的不完全日期, 提取部分日期值的函数可能会返回 0。 例如, DAYOFMONTH('2001-11-00') 会返回0

    • ADDDATE(date,INTERVAL expr type) ADDDATE(expr,days)

    当被第二个参数的INTERVAL格式激活后, ADDDATE()就是DATE_ADD()的同义词。相关函数SUBDATE() 则是DATE_SUB()的同义词。对于INTERVAL参数上的信息 ,请参见关于DATE_ADD()的论述。

    mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);

            -> '1998-02-02'

    mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);

            -> '1998-02-02'

    days 参数只是整数值,则 MySQL 5.1将其作为天数值添加至 expr

    mysql> SELECT ADDDATE('1998-01-02', 31);

            -> '1998-02-02'

    • ADDTIME(expr,expr2)

    ADDTIME()expr2添加至expr 然后返回结果。 expr 是一个时间或时间日期表达式,而expr2 是一个时间表达式。

    mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999',

        ->                '1 1:1:1.000002');

            -> '1998-01-02 01:01:01.000001'

    mysql> SELECT ADDTIME('01:00:00.999999', '02:00:00.999998');

            -> '03:00:01.999997'

    • CONVERT_TZ(dt,from_tz,to_tz)

    CONVERT_TZ() 将时间日期值dt from_tz 给出的时区转到to_tz给出的时区,然后返回结果值。关于可能指定的时区的详细论述,请参见5.10.8节,“MySQL服务器时区支持”。若自变量无效,则这个函数会返回 NULL

    在从若from_tz UTC的转化过程中,该值超出 TIMESTAMP 类型的被支持范围,那么转化不会发生。关于 TIMESTAMP 范围的论述,请参见11.1.2节,“日期和时间类型概述”

    mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');

            -> '2004-01-01 13:00:00'

    mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');

            -> '2004-01-01 22:00:00'

    注释若要使用诸如 'MET' 'Europe/Moscow'之类的指定时间区,首先要设置正确的时区表。详细说明见5.10.8节,“MySQL服务器时区支持”。 

    • CURDATE()

    将当前日期按照'YYYY-MM-DD' YYYYMMDD 格式的值返回,具体格式根据函数用在字符串或是数字语境中而定。

    mysql> SELECT CURDATE();

            -> '1997-12-15'

    mysql> SELECT CURDATE() + 0;

            -> 19971215

    • CURRENT_DATE CURRENT_DATE()

    CURRENT_DATECURRENT_DATE()是的同义词.

    • CURTIME()

    将当前时间以'HH:MM:SS' HHMMSS 的格式返回, 具体格式根据函数用在字符串或是数字语境中而定。 

    mysql> SELECT CURTIME();

            -> '23:50:26'

    mysql> SELECT CURTIME() + 0;

            -> 235026

    • CURRENT_TIME, CURRENT_TIME()

    CURRENT_TIME CURRENT_TIME() CURTIME()的同义词。

    • CURRENT_TIMESTAMP, CURRENT_TIMESTAMP()

    CURRENT_TIMESTAMP CURRENT_TIMESTAMP()NOW()的同义词。

    • DATE(expr)

    提取日期或时间日期表达式expr中的日期部分。

    mysql> SELECT DATE('2003-12-31 01:02:03');

            -> '2003-12-31'

    • DATEDIFF(expr,expr2)

    DATEDIFF() 返回起始时间 expr和结束时间expr2之间的天数。Exprexpr2 为日期或 date-and-time 表达式。计算中只用到这些值的日期部分。

    mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');

            -> 1

    mysql> SELECT DATEDIFF('1997-11-30 23:59:59','1997-12-31');

            -> -31

    • DATE_ADD(date,INTERVAL expr type) DATE_SUB(date,INTERVAL expr type)

    这些函数执行日期运算。 date 是一个 DATETIME DATE值,用来指定起始时间。 expr 是一个表达式,用来指定从起始日期添加或减去的时间间隔值。  Expr是一个字符串;对于负值的时间间隔,它可以以一个 ‘-’开头。 type 为关键词,它指示了表达式被解释的方式。 

    关键词INTERVAtype 分类符均不区分大小写。

    以下表显示了type expr 参数的关系:

    type

    预期的 expr 格式

    MICROSECOND

    MICROSECONDS

    SECOND

    SECONDS

    MINUTE

    MINUTES

    HOUR

    HOURS

    DAY

    DAYS

    WEEK

    WEEKS

    MONTH

    MONTHS

    QUARTER

    QUARTERS

    YEAR

    YEARS

    SECOND_MICROSECOND

    'SECONDS.MICROSECONDS'

    MINUTE_MICROSECOND

    'MINUTES.MICROSECONDS'

    MINUTE_SECOND

    'MINUTES:SECONDS'

    HOUR_MICROSECOND

    'HOURS.MICROSECONDS'

    HOUR_SECOND

    'HOURS:MINUTES:SECONDS'

    HOUR_MINUTE

    'HOURS:MINUTES'

    DAY_MICROSECOND

    'DAYS.MICROSECONDS'

    DAY_SECOND

    'DAYS HOURS:MINUTES:SECONDS'

    DAY_MINUTE

    'DAYS HOURS:MINUTES'

    DAY_HOUR

    'DAYS HOURS'

    YEAR_MONTH

    'YEARS-MONTHS'

    MySQL 允许任何expr 格式中的标点分隔符。表中所显示的是建议的 分隔符。若 date 参数是一个 DATE 值,而你的计算只会包括 YEARMONTHDAY部分(, 没有时间部分), 其结果是一个DATE 值。否则,结果将是一个 DATETIME值。

    若位于另一端的表达式是一个日期或日期时间值 , 则INTERVAL expr type只允许在 + 操作符的两端。对于 –操作符,  INTERVAL expr type 只允许在其右端,原因是从一个时间间隔中提取一个日期或日期时间值是毫无意义的。 (见下面的例子)

    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 DATE_ADD('1992-12-31 23:59:59.000002',

        ->            INTERVAL '1.999999' SECOND_MICROSECOND);

            -> '1993-01-01 00:00:01.000001'

    若你指定了一个过于短的时间间隔值 (不包括type 关键词所预期的所有时间间隔部分), MySQL 假定你已经省去了时间间隔值的最左部分。 例如,你指定了一种类型的DAY_SECOND, expr 的值预期应当具有天、 小时、分钟和秒部分。若你指定了一个类似 '1:10'的值, MySQL 假定天和小时部分不存在,那么这个值代表分和秒。换言之, '1:10' DAY_SECOND 被解释为相当于 '1:10' MINUTE_SECOND。这相当于 MySQLTIME 值解释为所耗费的时间而不是日时的解释方式。             

    假如你对一个日期值添加或减去一些含有时间部分的内容,则结果自动转化为一个日期时间值:

    mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 DAY);

            -> '1999-01-02'

    mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);

            -> '1999-01-01 01:00:00'

    假如你使用了格式严重错误的日期,则结果为 NULL。假如你添加了  MONTHYEAR_MONTHYEAR ,而结果日期中有一天的日期大于添加的月份的日期最大限度,则这个日期自动被调整为添加月份的最大日期:

    mysql> SELECT DATE_ADD('1998-01-30', INTERVAL 1 MONTH);

            -> '1998-02-28'

    • DATE_FORMAT(date,format)

    根据format 字符串安排date 值的格式。

    以下说明符可用在 format 字符串中:

    说明符

    说明

    %a

    工作日的缩写名称  (Sun..Sat)

    %b

    月份的缩写名称  (Jan..Dec)

    %c

    月份,数字形式(0..12)

    %D

    带有英语后缀的该月日期  (0th, 1st, 2nd, 3rd, ...)

    %d

    该月日期, 数字形式 (00..31)

    %e

    该月日期, 数字形式(0..31)

    %f

    微秒 (000000..999999)

    %H

    小时(00..23)

    %h

    小时(01..12)

    %I

    小时 (01..12)

    %i

    分钟,数字形式 (00..59)

    %j

    一年中的天数 (001..366)

    %k

    小时 (0..23)

    %l

    小时 (1..12)

    %M

    月份名称 (January..December)

    %m

    月份, 数字形式 (00..12)

    %p

    上午(AM)或下午( PM

    %r

    时间 , 12小时制 (小时hh:分钟mm:秒数ss 后加 AMPM)

    %S

    (00..59)

    %s

    (00..59)

    %T

    时间 , 24小时制 (小时hh:分钟mm:秒数ss)

    %U

    (00..53), 其中周日为每周的第一天

    %u

    (00..53), 其中周一为每周的第一天 

    %V

    (01..53), 其中周日为每周的第一天 ; %X同时使用

    %v

    (01..53), 其中周一为每周的第一天 ; %x同时使用

    %W

    工作日名称 (周日..周六)

    %w

    一周中的每日 (0=周日..6=周六)

    %X

    该周的年份,其中周日为每周的第一天, 数字形式,4位数;%V同时使用

    %x

    该周的年份,其中周一为每周的第一天, 数字形式,4位数;%v同时使用

    %Y

    年份, 数字形式,4位数

    %y

    年份, 数字形式 (2位数)

    %%

    %’文字字符

    所有其它字符都被复制到结果中,无需作出解释。

    注意, ‘%’字符要求在格式指定符之前。

    月份和日期说明符的范围从零开始,原因是 MySQL允许存储诸如 '2004-00-00'的不完全日期.

    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'
    mysql> SELECT DATE_FORMAT('1999-01-01', '%X %V');
            -> '1998 52'
    • DAY(date)

    DAY() DAYOFMONTH()的意义相同。

    • DAYNAME(date)

    返回date 对应的工作日名称。

    mysql> SELECT DAYNAME('1998-02-05');

            -> '周四'

    • DAYOFMONTH(date)

    返回date 对应的该月日期,范围是从 131

    mysql> SELECT DAYOFMONTH('1998-02-03');

            -> 3

    • DAYOFWEEK(date)

    返回date (1 = 周日, 2 = 周一, ..., 7 = 周六)对应的工作日索引。这些索引值符合 ODBC标准。

    mysql> SELECT DAYOFWEEK('1998-02-03');

            -> 3

    • DAYOFYEAR(date)

    返回date 对应的一年中的天数,范围是从 1366

    mysql> SELECT DAYOFYEAR('1998-02-03');

            -> 34

    • EXTRACT(type FROM date)

    EXTRACT()函数所使用的时间间隔类型说明符同 DATE_ADD()DATE_SUB()的相同,但它从日期中提取其部分,而不是执行日期运算。 

    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

    mysql> SELECT EXTRACT(MICROSECOND

        ->                FROM '2003-01-02 10:30:00.00123');

            -> 123

    • FROM_DAYS(N)

    给定一个天数  N, 返回一个DATE值。

    mysql> SELECT FROM_DAYS(729669);

            -> '1997-10-07'

    使用 FROM_DAYS()处理古老日期时,务必谨慎。他不用于处理阳历出现前的日期(1582)。请参见12.6节,“MySQL使用什么日历?”

    • FROM_UNIXTIME(unix_timestamp) , FROM_UNIXTIME(unix_timestamp,format)

    返回'YYYY-MM-DD HH:MM:SS'YYYYMMDDHHMMSS 格式值的unix_timestamp参数表示,具体格式取决于该函数是否用在字符串中或是数字语境中。

    format 已经给出,则结果的格式是根据format 字符串而定。 format 可以包含同DATE_FORMAT() 函数输入项列表中相同的说明符。

    mysql> SELECT FROM_UNIXTIME(875996580);

            -> '1997-10-04 22:23:00'

    mysql> SELECT FROM_UNIXTIME(875996580) + 0;

            -> 19971004222300

    mysql> SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(),

        ->                      '%Y %D %M %h:%i:%s %x');

            -> '2003 6th August 06:22:58 2003'

    • GET_FORMAT(DATE|TIME|DATETIME, 'EUR'|'USA'|'JIS'|'ISO'|'INTERNAL')

    返回一个格式字符串。这个函数在同DATE_FORMAT() STR_TO_DATE()函数结合时很有用。

    第一个参数的3个可能值和第二个参数的5个可能值产生 15 个可能格式字符串 (对于使用的说明符,请参见DATE_FORMAT()函数说明表 )

    函数调用

    结果

    GET_FORMAT(DATE,'USA')

    '%m.%d.%Y'

    GET_FORMAT(DATE,'JIS')

    '%Y-%m-%d'

    GET_FORMAT(DATE,'ISO')

    '%Y-%m-%d'

    GET_FORMAT(DATE,'EUR')

    '%d.%m.%Y'

    GET_FORMAT(DATE,'INTERNAL')

    '%Y%m%d'

    GET_FORMAT(DATETIME,'USA')

    '%Y-%m-%d-%H.%i.%s'

    GET_FORMAT(DATETIME,'JIS')

    '%Y-%m-%d %H:%i:%s'

    GET_FORMAT(DATETIME,'ISO')

    '%Y-%m-%d %H:%i:%s'

    GET_FORMAT(DATETIME,'EUR')

    '%Y-%m-%d-%H.%i.%s'

    GET_FORMAT(DATETIME,'INTERNAL')

    '%Y%m%d%H%i%s'

    GET_FORMAT(TIME,'USA')

    '%h:%i:%s %p'

    GET_FORMAT(TIME,'JIS')

    '%H:%i:%s'

    GET_FORMAT(TIME,'ISO')

    '%H:%i:%s'

    GET_FORMAT(TIME,'EUR')

    '%H.%i.%S'

    GET_FORMAT(TIME,'INTERNAL')

    '%H%i%s'

    ISO 格式为ISO 9075, 而非ISO 8601.

    也可以使用TIMESTAMP, 这时GET_FORMAT()的返回值和DATETIME相同。

    mysql> SELECT DATE_FORMAT('2003-10-03',GET_FORMAT(DATE,'EUR'));

            -> '03.10.2003'

    mysql> SELECT STR_TO_DATE('10.31.2003',GET_FORMAT(DATE,'USA'));

            -> '2003-10-31'

    或见13.5.3节,“SET语法”

    • HOUR(time)

    返回time 对应的小时数。对于日时值的返回值范围是从 0 23

    mysql> SELECT HOUR('10:05:03');

            -> 10

    然而,  TIME 值的范围实际上非常大, 所以HOUR可以返回大于23的值。

    mysql> SELECT HOUR('272:59:59');

            -> 272

    • LAST_DAY(date)

    获取一个日期或日期时间值,返回该月最后一天对应的值。若参数无效,则返回NULL

    mysql> SELECT LAST_DAY('2003-02-05');

            -> '2003-02-28'

    mysql> SELECT LAST_DAY('2004-02-05');

            -> '2004-02-29'

    mysql> SELECT LAST_DAY('2004-01-01 01:01:01');

            -> '2004-01-31'

    mysql> SELECT LAST_DAY('2003-03-32');

            -> NULL

    • LOCALTIME, LOCALTIME()

    LOCALTIME LOCALTIME()NOW()具有相同意义。

    • LOCALTIMESTAMP, LOCALTIMESTAMP()

    LOCALTIMESTAMPLOCALTIMESTAMP()NOW()具有相同意义。

    • MAKEDATE(year,dayofyear)

    给出年份值和一年中的天数值,返回一个日期。dayofyear 必须大于 0 ,否则结果为 NULL

    mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);

            -> '2001-01-31', '2001-02-01'

    mysql> SELECT MAKEDATE(2001,365), MAKEDATE(2004,365);

            -> '2001-12-31', '2004-12-30'

    mysql> SELECT MAKEDATE(2001,0);

            -> NULL

    • MAKETIME(hour,minute,second)

    返回由hourminutesecond 参数计算得出的时间值。

    mysql> SELECT MAKETIME(12,15,30);

            -> '12:15:30'

    • MICROSECOND(expr)

    从时间或日期时间表达式expr返回微秒值,其数字范围从 0 999999

    mysql> SELECT MICROSECOND('12:00:00.123456');

            -> 123456

    mysql> SELECT MICROSECOND('1997-12-31 23:59:59.000010');

            -> 10

    • MINUTE(time)

    返回 time 对应的分钟数,范围是从 0 59

    mysql> SELECT MINUTE('98-02-03 10:05:03');

            -> 5

    • MONTH(date)

    返回date 对应的月份,范围时从 1 12

    mysql> SELECT MONTH('1998-02-03');

            -> 2

    • MONTHNAME(date)

    返回date 对应月份的全名。

    mysql> SELECT MONTHNAME('1998-02-05');

            -> 'February '

    • NOW()

    返回当前日期和时间值,其格式为 'YYYY-MM-DD HH:MM:SS' YYYYMMDDHHMMSS , 具体格式取决于该函数是否用在字符串中或数字语境中。

    mysql> SELECT NOW();

            -> '1997-12-15 23:50:26'

    mysql> SELECT NOW() + 0;

            -> 19971215235026

    在一个存储程序或触发器内, NOW() 返回一个常数时间,该常数指示了该程序或触发语句开始执行的时间。这同SYSDATE()的运行有所不同。

    • PERIOD_ADD(P,N)

    添加 N 个月至周期P (格式为YYMM YYYYMM),返回值的格式为 YYYYMM。注意周期参数 P 不是日期值。 

    mysql> SELECT PERIOD_ADD(9801,2);

            -> 199803

    • PERIOD_DIFF(P1,P2

    返回周期P1P2 之间的月份数。P1 P2 的格式应该为YYMMYYYYMM。注意周期参数 P1P2 不是日期值。

    mysql> SELECT PERIOD_DIFF(9802,199703);

            -> 11

    • QUARTER(date)

    返回date 对应的一年中的季度值,范围是从 1 4

    mysql> SELECT QUARTER('98-04-01');

            -> 2

    • SECOND(time)

    返回time 对应的秒数, 范围是从 059

    mysql> SELECT SECOND('10:05:03');

            -> 3

    • 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

    • STR_TO_DATE(str,format)

    这是DATE_FORMAT() 函数的倒转。它获取一个字符串 str 和一个格式字符串format。若格式字符串包含日期和时间部分,则 STR_TO_DATE()返回一个 DATETIME 值, 若该字符串只包含日期部分或时间部分,则返回一个 DATE TIME值。

    str所包含的日期、时间或日期时间值应该在format指示的格式中被给定。对于可用在format中的说明符,请参见DATE_FORMAT() 函数说明表。 所有其它的字符被逐字获取,因此不会被解释。若 str 包含一个非法日期、时间或日期时间值,则 STR_TO_DATE()返回NULL。同时,一个非法值会引起警告。

    对日期值部分的范围检查在11.3.1节,“DATETIME、DATE和TIMESTAMP类型”有详细说明。其意义是,例如, 只要具体日期部分的范围时从 1 31之间,则允许一个日期中的具体日期部分大于一个月中天数值。并且,允许“零”日期或带有0值部分的日期。

    mysql> SELECT STR_TO_DATE('00/00/0000', '%m/%d/%Y');

            -> '0000-00-00'

    mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');

            -> '2004-04-31'

    • SUBDATE(date,INTERVAL expr type) SUBDATE(expr,days)

    当被第二个参数的 INTERVAL型式调用时, SUBDATE()DATE_SUB()的意义相同。对于有关INTERVAL参数的信息, 见有关 DATE_ADD()的讨论。

    mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);

            -> '1997-12-02'

    mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);

            -> '1997-12-02'

    第二个形式允许对days使用整数值。在这些情况下,它被算作由日期或日期时间表达式 expr中提取的天数。

    mysql> SELECT SUBDATE('1998-01-02 12:00:00', 31);

            -> '1997-12-02 12:00:00'

    注意不能使用格式 "%X%V" 来将一个 year-week 字符串转化为一个日期,原因是当一个星期跨越一个月份界限时,一个年和星期的组合不能标示一个唯一的年和月份。若要将year-week转化为一个日期,则也应指定具体工作日:

    mysql> select str_to_date('200442 Monday', '%X%V %W');

    -> 2004-10-18

    • SUBTIME(expr,expr2)

    SUBTIME()expr 中提取expr2 ,然后返回结果。expr 是一个时间或日期时间表达式,而xpr2 是一个时间表达式。

    mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999','1 1:1:1.000002');

            -> '1997-12-30 22:58:58.999997'

    mysql> SELECT SUBTIME('01:00:00.999999', '02:00:00.999998');

            -> '-00:59:59.999999'

    • SYSDATE()

    返回当前日期和时间值,格式为'YYYY-MM-DD HH:MM:SS' YYYYMMDDHHMMSS, 具体格式根据函数是否用在字符串或数字语境而定。

    在一个存储程序或触发器中, SYSDATE()返回其执行的时间, 而非存储成都或触发语句开始执行的时间。这个NOW()的运作有所不同。

    • TIME(expr)

    提取一个时间或日期时间表达式的时间部分,并将其以字符串形式返回。

    mysql> SELECT TIME('2003-12-31 01:02:03');

            -> '01:02:03'

    mysql> SELECT TIME('2003-12-31 01:02:03.000123');

            -> '01:02:03.000123'

    • TIMEDIFF(expr,expr2)

    TIMEDIFF() 返回起始时间 expr 和结束时间expr2 之间的时间。 expr expr2 为时间或 date-and-time 表达式,两个的类型必须一样。 

    mysql> SELECT TIMEDIFF('2000:01:01 00:00:00',

        ->                 '2000:01:01 00:00:00.000001');

            -> '-00:00:00.000001'

    mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001',

        ->                 '1997-12-30 01:01:01.000002');

            -> '46:58:57.999999'

    • TIMESTAMP(expr) , TIMESTAMP(expr,expr2)

    对于一个单参数,该函数将日期或日期时间表达式 expr 作为日期时间值返回.对于两个参数, 它将时间表达式 expr2 添加到日期或日期时间表达式 expr 中,将theresult作为日期时间值返回。

    mysql> SELECT TIMESTAMP('2003-12-31');

            -> '2003-12-31 00:00:00'

    mysql> SELECT TIMESTAMP('2003-12-31 12:00:00','12:00:00');

            -> '2004-01-01 00:00:00'

    • TIMESTAMPADD(interval,int_expr,datetime_expr)

    将整型表达式int_expr 添加到日期或日期时间表达式 datetime_expr中。 int_expr 的单位被时间间隔参数给定,该参数必须是以下值的其中一个: FRAC_SECONDSECOND MINUTE HOUR DAY WEEK MONTH QUARTER YEAR

    可使用所显示的关键词指定Interval值,或使用SQL_TSI_前缀。例如, DAYSQL_TSI_DAY 都是正确的。

    mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');

            -> '2003-01-02 00:01:00'

    mysql> SELECT TIMESTAMPADD(WEEK,1,'2003-01-02');

            -> '2003-01-09'

    • TIMESTAMPDIFF(interval,datetime_expr1,datetime_expr2)

    返回日期或日期时间表达式datetime_expr1 datetime_expr2the 之间的整数差。其结果的单位由interval 参数给出。interval 的法定值同TIMESTAMPADD()函数说明中所列出的相同。

    mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');

            -> 3

    mysql> SELECT TIMESTAMPDIFF(YEAR,'2002-05-01','2001-01-01');

            -> -1

    • TIME_FORMAT(time,format)

    其使用和 DATE_FORMAT()函数相同, 然而format 字符串可能仅会包含处理小时、分钟和秒的格式说明符。其它说明符产生一个NULL值或0

    time value包含一个大于23的小时部分,则 %H %k 小时格式说明符会产生一个大于0..23的通常范围的值。另一个小时格式说明符产生小时值模数12

    mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');

            -> '100 100 04 04 4'

    • TIME_TO_SEC(time)

    返回已转化为秒的time参数。

    mysql> SELECT TIME_TO_SEC('22:23:00');

            -> 80580

    mysql> SELECT TIME_TO_SEC('00:39:38');

            -> 2378

    • TO_DAYS(date)

    给定一个日期date, 返回一个天数 (从年份0开始的天数 )

    mysql> SELECT TO_DAYS(950501);

            -> 728779

    mysql> SELECT TO_DAYS('1997-10-07');

            -> 729669

    TO_DAYS() 不用于阳历出现(1582)前的值,原因是当日历改变时,遗失的日期不会被考虑在内。请参见12.6节,“MySQL使用什么日历?”

    请记住, MySQL使用11.3节,“日期和时间类型”中的规则将日期中的二位数年份值转化为四位。例如,  '1997-10-07' '97-10-07' 被视为同样的日期:

    mysql> SELECT TO_DAYS('1997-10-07'), TO_DAYS('97-10-07');

            -> 729669, 729669

    对于1582 年之前的日期(或许在其它地区为下一年 ), 该函数的结果实不可靠的。详见12.6节,“MySQL使用什么日历?” 

    • UNIX_TIMESTAMP(), UNIX_TIMESTAMP(date)

    若无参数调用,则返回一个Unix timestamp ('1970-01-01 00:00:00' GMT 之后的秒数) 作为无符号整数。若用date 来调用UNIX_TIMESTAMP(),它会将参数值以'1970-01-01 00:00:00' GMT后的秒数的形式返回。date 可以是一个DATE 字符串、一个 DATETIME字符串、一个 TIMESTAMP或一个当地时间的YYMMDD YYYMMDD格式的数字。

    mysql> SELECT UNIX_TIMESTAMP();

            -> 882226357

    mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');

            -> 875996580

    UNIX_TIMESTAMP被用在 TIMESTAMP列时, 函数直接返回内部时戳值,  而不进行任何隐含的 “string-to-Unix-timestamp”转化。假如你向UNIX_TIMESTAMP()传递一个溢出日期,它会返回 0,但请注意只有基本范围检查会被履行 (年份从1970 2037, 月份从0112,日期从  01 31)

    假如你想要减去 UNIX_TIMESTAMP() , 你或许希望删去带符号整数的结果。请参见12.8节,“Cast函数和操作符”

    • UTC_DATE, UTC_DATE()

    返回当前 UTC日期值,其格式为 'YYYY-MM-DD' YYYYMMDD,具体格式取决于函数是否用在字符串或数字语境中。 

    mysql> SELECT UTC_DATE(), UTC_DATE() + 0;

            -> '2003-08-14', 20030814

    • UTC_TIME, UTC_TIME()

    返回当前 UTC 值,其格式为  'HH:MM:SS' HHMMSS,具体格式根据该函数是否用在字符串或数字语境而定。

    mysql> SELECT UTC_TIME(), UTC_TIME() + 0;

            -> '18:07:53', 180753

    • UTC_TIMESTAMP, UTC_TIMESTAMP()

    返回当前UTC日期及时间值,格式为 'YYYY-MM-DD HH:MM:SS' YYYYMMDDHHMMSS,具体格式根据该函数是否用在字符串或数字语境而定。

    mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;

            -> '2003-08-14 18:08:04', 20030814180804

    • WEEK(date[,mode])

    该函数返回date 对应的星期数。WEEK() 的双参数形式允许你指定该星期是否起始于周日或周一, 以及返回值的范围是否为从0 53 或从1 53。若 mode参数被省略,则使用default_week_format系统自变量的值。请参见5.3.3节,“服务器系统变量”

    以下表说明了mode 参数的工作过程:d

     

    第一天

     

     

    Mode

    工作日

    范围

    Week 1 为第一周 ...

    0

    周日

    0-53

    本年度中有一个周日

    1

    周一

    0-53

    本年度中有3天以上

    2

    周日

    1-53

    本年度中有一个周日

    3

    周一

    1-53

    本年度中有3天以上

    4

    周日

    0-53

    本年度中有3天以上

    5

    周一

    0-53

    本年度中有一个周一

    6

    周日

    1-53

    本年度中有3天以上

    7

    周一

    1-53

    本年度中有一个周一

    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

    注意,假如有一个日期位于前一年的最后一周, 若你不使用2367作为mode 参数选择,则MySQL返回 0

    mysql> SELECT YEAR('2000-01-01'), WEEK('2000-01-01',0);

            -> 2000, 0

    有人或许会提出意见,认为 MySQL 对于WEEK() 函数应该返回 52 ,原因是给定的日期实际上发生在1999年的第52周。我们决定返回0作为代替的原因是我们希望该函数能返回“给定年份的星期数”。这使得WEEK() 函数在同其它从日期中抽取日期部分的函数结合时的使用更加可靠。

    假如你更希望所计算的关于年份的结果包括给定日期所在周的第一天,则应使用 025 7 作为mode参数选择。

    mysql> SELECT WEEK('2000-01-01',2);

            -> 52

    作为选择,可使用 YEARWEEK()函数:

    mysql> SELECT YEARWEEK('2000-01-01');

            -> 199952

    mysql> SELECT MID(YEARWEEK('2000-01-01'),5,2);

            -> '52'

    • WEEKDAY(date)

    返回date (0 = 周一, 1 = 周二, ... 6 = 周日)对应的工作日索引  weekday index for

    mysql> SELECT WEEKDAY('1998-02-03 22:23:00');

            -> 1

    mysql> SELECT WEEKDAY('1997-11-05');

            -> 2

    • WEEKOFYEAR(date)

    将该日期的阳历周以数字形式返回,范围是从153。它是一个兼容度函数,相当于WEEK(date,3)

    mysql> SELECT WEEKOFYEAR('1998-02-20');

            -> 8

    • YEAR(date)

    返回date 对应的年份,范围是从10009999

    mysql> SELECT YEAR('98-02-03');

            -> 1998

    • YEARWEEK(date), YEARWEEK(date,start)

    返回一个日期对应的年或周。start参数的工作同 start参数对 WEEK()的工作相同。结果中的年份可以和该年的第一周和最后一周对应的日期参数有所不同。

    mysql> SELECT YEARWEEK('1987-01-01');

            -> 198653

    注意,周数和WEEK()函数队可选参数0 1可能会返回的(0) w有所不同,原因是此时 WEEK() 返回给定年份的语境中的周。

    •         -> '1997-10-07'
      

    12.6. MySQL使用什么日历?

    MySQL 使用通常所说的 proleptic 阳历

    每个将日历由朱利安改为阳历的国家在改变日历期间都不得不删除至少10天。 为了了解其运作,让我们看看158210月,这是由朱利安日历转换为阳历的第一次:

    周一

    周二

    周三

    周四

    周五

    周六

    周日

    1

    2

    3

    4

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    104 日到1015日之间的日期为空白。这个中断被称为接入。接入前的日期均使用朱利安日历, 而接入后的日期均使用阳历。接入期间的日期是不存在的。

    当一个用于日期的日历并为得到实际使用时被称为 proleptic。因此, 若我们假设从来没有接入期的存在,而阳历历法则始终被使用,我们会有一个预期的阳历 。这就是MySQL 所使用的,正如标准SQL所要求的。 鉴于这个原因,作为MySQL DATE DATETIME值而被储存的接入前的日期必须调整这个差异。我们必须明白,接入的发生时间在不同的国家有所不同,而接入的时间越晚,遗失的日期越多。例如,在大不列颠, 接入发生在 1752,这时92日,周三后的第二天为914日,周二; 俄罗斯结束使用朱利安日历的时间为1918,接入过程中遗失天数为 13, 根据阳历,其普遍被称为“10月革命”的发生时间实际上是11月。

    12.7. 全文搜索功能

    12.7.1. 布尔全文搜索
    12.7.2. 全文搜索带查询扩展
    12.7.3. 全文停止字
    12.7.4. 全文限定条件
    12.7.5. 微调MySQL全文搜索

    MySQL支持全文索引和搜索功能。MySQL中的全文索引类型FULLTEXT的索引。  FULLTEXT 索引仅可用于 MyISAM 表;他们可以从CHAR VARCHARTEXT列中作为CREATE TABLE语句的一部分被创建,或是随后使用ALTER TABLE CREATE INDEX被添加。对于较大的数据集,将你的资料输入一个没有FULLTEXT索引的表中,然后创建索引, 其速度比把资料输入现有FULLTEXT索引的速度更为快。

    关于全文搜索的限制列表,请参见 12.7.4节,“全文限定条件”.

    全文搜索同MATCH()函数一起执行。 

    mysql> CREATE TABLE articles (
        ->   id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,
        ->   title VARCHAR(200),
        ->   body TEXT,
        ->   FULLTEXT (title,body)
        -> );
    Query OK, 0 rows affected (0.00 sec)
     
    mysql> INSERT INTO articles (title,body) VALUES
        -> ('MySQL Tutorial','DBMS stands for DataBase ...'),
        -> ('How To Use MySQL Well','After you went through a ...'),
        -> ('Optimizing MySQL','In this tutorial we will show ...'),
        -> ('1001 MySQL Tricks','1. Never run mysqld as root. 2. ...'),
        -> ('MySQL vs. YourSQL','In the following database comparison ...'),
        -> ('MySQL Security','When configured properly, MySQL ...');
    Query OK, 6 rows affected (0.00 sec)
    Records: 6  Duplicates: 0  Warnings: 0
     
    mysql> SELECT * FROM articles
        -> WHERE MATCH (title,body) AGAINST ('database');
    +----+-------------------+------------------------------------------+
    | id | title             | body                                     |
    +----+-------------------+------------------------------------------+
    |  5 | MySQL vs. YourSQL | In the following database comparison ... |
    |  1 | MySQL Tutorial    | DBMS stands for DataBase ...             |
    +----+-------------------+------------------------------------------+
    2 rows in set (0.00 sec)

    MATCH()函数对于一个字符串执行资料库内的自然语言搜索。一个资料库就是11个或2个包含在FULLTEXT内的列。搜索字符串作为对AGAINST()的参数而被给定。对于表中的每一行, MATCH() 返回一个相关值,即, 搜索字符串和 MATCH()表中指定列中该行文字之间的一个相似性度量。

    在默认状态下, 搜索的执行方式为不区分大小写方式。然而,你可以通过对编入索引的列使用二进制排序方式执行区分大小写的全文搜索。 例如,可以向一个使用latin1字符集的列给定latin1_bin 的排序方式,对于全文搜索区分大小写。

    如上述所举例子,当MATCH()被用在一个 WHERE 语句中时,相关值是非负浮点数。零相关的意思是没有相似性。相关性的计算是基于该行中单词的数目, 该行中独特子的数目,资料库中单词的总数,以及包含特殊词的文件()数目。

    对于自然语言全文搜索,要求MATCH() 函数中命名的列和你的表中一些FULLTEXT索引中包含的列相同。对于前述问讯, 注意,MATCH()函数(题目及全文)中所命名的列和文章表的FULLTEXT索引中的列相同。若要分别搜索题目和全文,应该对每个列创建FULLTEXT索引。

    或者也可以运行布尔搜索或使用查询扩展进行搜索。关于这些搜索类型的说明见12.7.1节,“布尔全文搜索”12.7.2节,“全文搜索带查询扩展”

    上面的例子基本上展示了怎样使用返回行的相关性顺序渐弱的MATCH()函数。而下面的例子则展示了怎样明确地检索相关值。返回行的顺序是不定的,原因是  SELECT 语句不包含 WHEREORDER BY 子句:

    mysql> SELECT id, MATCH (title,body) AGAINST ('Tutorial')
        -> FROM articles;
    +----+-----------------------------------------+
    | id | MATCH (title,body) AGAINST ('Tutorial') |
    +----+-----------------------------------------+
    |  1 |                        0.65545833110809 |
    |  2 |                                       0 |
    |  3 |                        0.66266459226608 |
    |  4 |                                       0 |
    |  5 |                                       0 |
    |  6 |                                       0 |
    +----+-----------------------------------------+
    6 rows in set (0.00 sec)

    下面的例子则更加复杂。询问返回相关值,同时对行按照相关性渐弱的顺序进行排序。为实现这个结果,你应该两次指定 MATCH(): 一次在 SELECT 列表中而另一次在 WHERE子句中。这不会引起额外的内务操作,原因是MySQL 优化程序注意到两个MATCH()调用是相同的,从而只会激活一次全文搜索代码。 

    mysql> SELECT id, body, MATCH (title,body) AGAINST
        -> ('Security implications of running MySQL as root') AS score
        -> FROM articles WHERE MATCH (title,body) AGAINST
        -> ('Security implications of running MySQL as root');
    +----+-------------------------------------+-----------------+
    | id | body                                | score           |
    +----+-------------------------------------+-----------------+
    |  4 | 1. Never run mysqld as root. 2. ... | 1.5219271183014 |
    |  6 | When configured properly, MySQL ... | 1.3114095926285 |
    +----+-------------------------------------+-----------------+
    2 rows in set (0.00 sec)

    表中有2(0.00 )

    MySQL FULLTEXT 执行将任何单字字符原形 (字母、数字和下划线部分)的序列视为一个单词。这个序列或许也包含单引号 ('),但在一行中不会超过一个。 这意味着 aaa'bbb 会被视为一个单词,而 aaa''bbb则被视为2个单词。位于单词之前或其后的单引号会被FULLTEXT分析程序去掉; 'aaa'bbb' 会变成   aaa'bbb

    FULLTEXT分析程序会通过寻找某些分隔符来确定单词的起始位置和结束位置,例如' ' (间隔符号) , (逗号)以及 . (句号 )。假如单词没有被分隔符分开,(例如在中文里 ), FULLTEXT 分析程序不能确定一个词的起始位置和结束位置。为