用于 SELECT 和 WHERE 子句的函数

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