目录
数学符号和特殊符号
1、& 位和
mysql> SELECT 29 & 15;
-> 132、> 大于
mysql> SELECT 2 > 2;
-> 0 0表示false3、 >>将一个(BIGINT)或二进制字符串右移。
mysql> SELECT 4 >> 2;
-> 14、>=大于等于
mysql> SELECT 2 >= 2;
-> 1 1表述true5、<小于
mysql> SELECT 2 < 2;
-> 06、<> 等价于！= 不相等
mysql> SELECT '.01' <> '0.01';
-> 17、<< 将一个(BIGINT)或二进制字符串向左移位。
mysql> SELECT HEX(_binary X'00FF00FF00FF' << 8);
-> 'FF00FF00FF00'8、<=小于等于
mysql> SELECT 0.1 <= 2;
-> 19、<=>
空值相等。该操作符执行类似于=操作符的相等比较，但如果两个操作数都为NULL，则返回1而不是NULL;如果一个操作数为NULL，则返回0而不是NULL。
mysql> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
-> 1, 1, 010、% 和 MOD 都表示模运算符
mysql> SELECT 10%3;
-> 111、* 乘法运算符 - 减法运算符 +加法运算符 /除法运算符
mysql> SELECT 3*5;
-> 15
mysql> SELECT 3-5;
-> -2
mysql> SELECT 3+5;
-> 8
mysql> SELECT 3/5;
-> 0.6012、 -> column->path
当与两个参数一起使用时，->操作符充当JSON_EXTRACT()函数的别名，左边是列标识符，右边是根据JSON文档(列值)计算的JSON路径(字符串字面值)。可以在SQL语句中任何出现列引用的地方使用这样的表达式。
mysql> SELECT c, JSON_EXTRACT(c, "$.id"), g
> FROM jemp
> WHERE JSON_EXTRACT(c, "$.id") > 1
> ORDER BY JSON_EXTRACT(c, "$.name");
+-------------------------------+-----------+------+
| c | c->"$.id" | g |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3" | 3 |
| {"id": "4", "name": "Betty"} | "4" | 4 |
| {"id": "2", "name": "Wilma"} | "2" | 2 |
+-------------------------------+-----------+------+
3 rows in set (0.00 sec)13、->> column->>path
这是一个改进的，不引用的提取运算符。->操作符只是提取值，而->>操作符还对提取的结果取消引号。换句话说，给定一个JSON列值列和一个路径表达式路径(字符串字面量)，下面三个表达式返回相同的值:
-
json_unquote(json_extract(column,path))
-
JSON_UNQUOTE(->columnpath) -
column->>path
14、:= 赋值
赋值运算符。使运算符左侧的user变量取其右侧的值。右边的值可以是一个文字值、另一个存储值的变量，或者产生标量值的任何合法表达式，包括查询的结果(前提是这个值是标量值)。您可以在同一个SET语句中执行多个赋值。可以在同一个语句中执行多个赋值。
与=不同，:=操作符永远不会被解释为比较操作符。这意味着可以在任何有效的SQL语句(不仅仅是SET语句)中使用:=来为变量赋值。
mysql> SELECT @var1 := 1, @var2;
-> 1, NULL15、=可以看作赋值，也可以看作相等运算符
在SET语句中使用时，=等同于:=
where 语句，一般视为相等运算符
16、^
按位异或。 结果类型取决于参数被计算为二进制字符串还是数字:
mysql> SELECT 1 ^ 1;
-> 0
mysql> SELECT 1 ^ 0;
-> 1
mysql> SELECT 11 ^ 3;
-> 8
mysql> SELECT HEX(_binary X'FEDC' ^ X'1111');
-> 'EFCD'A开头的函数
17、ABS 返回绝对值
mysql> SELECT ABS(-32);
-> 3218、 ACOS（X） 返回X的弧余弦，即余弦为X的值，如果X不在-1到1的范围内，或者X为NULL，则返回NULL。
mysql> SELECT ACOS(1);
-> 0
mysql> SELECT ACOS(1.0001);
-> NULL
mysql> SELECT ACOS(0);
-> 1.570796326794919、ADDDATE（）将时间值(间隔)添加到日期值
mysql> SELECT DATE_ADD('2008-01-02', INTERVAL 31 DAY);
-> '2008-02-02'
mysql> SELECT ADDDATE('2008-01-02', INTERVAL 31 DAY);
-> '2008-02-02'20、ADDTIME（）
ADDTIME(expr1，expr2)将expr2添加到expr1并返回结果。Expr1是一个时间或日期时间表达式，expr2是一个时间表达式。如果expr1或expr2为NULL则返回NULL。
mysql> SELECT ADDTIME('2007-12-31 23:59:59.999999', '1 1:1:1.000002');
-> '2008-01-02 01:01:01.000001'
mysql> SELECT ADDTIME('01:00:00.999999', '02:00:00.999998');
-> '03:00:01.999997'21、AES_DECRYPT() 使用AES解密
22、AES_ENCRYPT() 使用AES加密
23、AND && 逻辑和
mysql> SELECT 1 AND 1;
-> 1
mysql> SELECT 1 AND 0;
-> 0
mysql> SELECT 1 AND NULL;
-> NULL
mysql> SELECT 0 AND NULL;
-> 0
mysql> SELECT NULL AND 0;
-> 024、ANY_VALUE
ANY_VALUE()可以用于在没有GROUP BY子句的情况下引用聚合函数的查询:
当ONLY_FULL_GROUP_BY 被启用时，这个函数对于GROUP BY查询非常有用，当MySQL由于MySQL无法确定的原因拒绝了一个您知道是有效的查询时。函数的返回值和类型与其参数的返回值和类型相同，但不检查ONLY_FULL_GROUP_BY SQL模式的函数结果。
例如，如果name是一个非索引列，则在启用了ONLY_FULL_GROUP_BY时，以下查询将失败:
mysql> SELECT name, address, MAX(age) FROM t GROUP BY name;
ERROR 1055 (42000): Expression #2 of SELECT list is not in GROUP
BY clause and contains nonaggregated column 'mydb.t.address' which
is not functionally dependent on columns in GROUP BY clause; this
is incompatible with sql_mode=only_full_group_by25、ASCII 返回最左边字符的数值
mysql> SELECT ASCII('2');
-> 50
mysql> SELECT ASCII(2);
-> 50
mysql> SELECT ASCII('dx');
-> 10026、ASIN
返回X的反正弦值，即正弦值为X的值。如果X不在-1到1的范围内，或者X为NULL，则返回NULL。
27、ATAN
返回X的arctan值，即正切为X的值，如果X为NULL则返回NULL
28、ATAN2(Y,X),ATAN(Y,X)
返回两个变量X和Y的弧切线。它类似于计算Y / X的弧切线，除了两个参数的符号用于确定结果的象限。如果X或Y为NULL则返回NULL。
29、AVG() 返回参数的平均值
mysql> SELECT student_name, AVG(test_score)
FROM student
GROUP BY student_name;B开头的函数
30、BENCHMARK(count，expr) 重复执行一个表达式
BENCHMARK()函数重复执行表达式expr count次。它可以用来计算MySQL处理表达式的速度。结果值为0，对于不适当的参数，如NULL或负重复计数，则为NULL。
mysql> SELECT BENCHMARK(1000000,AES_ENCRYPT('hello','goodbye'));
+---------------------------------------------------+
| BENCHMARK(1000000,AES_ENCRYPT('hello','goodbye')) |
+---------------------------------------------------+
| 0 |
+---------------------------------------------------+
1 row in set (4.74 sec)31、between x and y 在 [x,y]之间
mysql> SELECT 2 BETWEEN 2 AND '3';
-> 132、BIN （） 返回一个包含数字二进制表示形式的字符串
mysql> SELECT BIN(12);
-> '1100'33、BIN TO UUID() 将二进制UUID转换为字符串
34、BINARY 将字符串转换为二进制字符串
35、BID AND（expr）
返回expr中所有位的按位与。
结果类型取决于函数实参值是作为二进制字符串还是数字进行计算:
36、BIT COUNT 返回所设置的bite数
mysql> SELECT BIT_COUNT(64), BIT_COUNT(BINARY 64);
-> 1, 7
mysql> SELECT BIT_COUNT('64'), BIT_COUNT(_binary '64');
-> 1, 7
mysql> SELECT BIT_COUNT(X'40'), BIT_COUNT(_binary X'40');
-> 1, 137、 BIT LENGTH() 以bite为单位返回参数长度
mysql> SELECT BIT_LENGTH('text');
-> 3238、BIT OR （expr）返回expr中所有位的按位或。
39、BIT XOR （expr）返回expr中所有位的按位异或运算。
C开头的函数
40、case ：CASE表达式的返回类型是所有结果值的聚合类型
一般和 case when ……then ……else…… 一起使用
compare_value THEN result时的CASE值[compare_value THEN result…][ELSE result]结束
CASE WHEN condition THEN result[当条件然后结果…][ELSE result]结束
第一种情况语法返回第一次value=compare_value比较的结果为true时的结果。第二种语法返回第一个条件为true时的结果。如果没有比较或条件为true，则返回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;
-> NULL41、 CAST（） 将值转换为特定类型
mysql> SELECT CAST("1979aaa" AS YEAR);
+-------------------------+
| CAST("1979aaa" AS YEAR) |
+-------------------------+
| 1979 |
+-------------------------+
1 row in set, 1 warning (0.00 sec)42、CEIL（）和 CEILING（） 都是返回不小于参数的最小整数值
mysql> SELECT CEILING(1.23);
-> 243、CHAR()将每个参数N解释为一个整数，并返回由这些整数的代码值给出的字符组成的字符串。NULL值会被跳过。
44、CHAR LENGTH（）和CHARACTER LENGTH（） 用法相同
返回字符串str的长度，以代码点为单位。多字节字符算作一个代码点。这意味着，对于包含两个3字节字符的字符串，LENGTH()返回6，而CHAR_LENGTH()返回2，如下所示:
mysql> SELECT LENGTH(@dolphin), CHAR_LENGTH(@dolphin);
+------------------+-----------------------+
| LENGTH(@dolphin) | CHAR_LENGTH(@dolphin) |
+------------------+-----------------------+
| 6 | 2 |
+------------------+-----------------------+
1 row in set (0.00 sec)45、CHARSET（）
返回字符串参数的字符集，如果参数为NULL，则返回NULL。
mysql> SELECT CHARSET('abc');
-> 'utf8mb3'46、COALESCE() 返回列表中的第一个非NULL值，如果没有非NULL值，则返回NULL。
mysql> SELECT COALESCE(NULL,1);
-> 1
mysql> SELECT COALESCE(NULL,NULL,NULL);
-> NULL47、COERCIBILITY 返回字符串参数的强制排序值。
返回值为0-6，值越小优先级越高。
mysql> SELECT COERCIBILITY('abc' COLLATE utf8mb4_swedish_ci);
-> 0
mysql> SELECT COERCIBILITY(USER());
-> 3
mysql> SELECT COERCIBILITY('abc');
-> 4
mysql> SELECT COERCIBILITY(1000);
-> 548、COLLATION（str）返回字符串参数的排序规则
mysql> SELECT COLLATION('abc');
-> 'utf8mb4_0900_ai_ci'
mysql> SELECT COLLATION(_utf8mb4'abc');
-> 'utf8mb4_0900_ai_ci'
mysql> SELECT COLLATION(_latin1'abc');
-> 'latin1_swedish_ci'49、compress 以二进制字符串形式返回结果
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)));
-> 1550、concat 返回拼接后的字符串
mysql> SELECT CONCAT('My', 'S', 'QL');
-> 'MySQL'
mysql> SELECT CONCAT('My', NULL, 'QL');
-> NULL
mysql> SELECT CONCAT(14.3);
-> '14.3'51、concat_ws 返回带有分隔符的拼接
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'52、connection_id()返回连接的连接ID(线程ID)
mysql> SELECT CONNECTION_ID();
-> 2378653、conv(n,from_base,to_base)
在不同的数字基之间转换数字。返回数字N的字符串表示形式，从base from_base转换为base to_base。如果任何参数为NULL则返回NULL。参数N被解释为整数，但可以指定为整数或字符串。最小底数是2，最大值是36。如果from_base为负数，则N被视为有符号数。否则，N被视为无符号。CONV()以64位精度工作。
如果CONV()的任何参数为NULL，则返回NULL。
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'+X'0a',10,10);
-> '40'54、convert 将值转换为特定字符集类型
SELECT CONVERT('abc' USING utf8mb4);55、convert tz（）从一个时区转换到另一个时区
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'56、cos（） 返回余弦值
mysql> SELECT COS(PI());
-> -157、cot () 返回余切值
mysql> SELECT COT(12);
-> -1.5726734063977
mysql> SELECT COT(0);
-> out-of-range error58、count 返回行数的计数
返回由SELECT语句检索的行中expr的非null值的数目。结果是一个BIGINT值。
如果没有匹配的行，COUNT()返回0。COUNT(NULL)返回0。
mysql> SELECT student.student_name,COUNT(*)
FROM student,course
WHERE student.student_id=course.student_id
GROUP BY student_name;59、count (distinct expr) 返回多个不同expr的计数
返回具有不同非null expr值的行数的计数。
如果没有匹配的行，COUNT(DISTINCT)返回0。
mysql> SELECT COUNT(DISTINCT results) FROM student;60、crc32 计算一个循环冗余校验值
计算循环冗余检查值并返回32位无符号值。如果参数为NULL，则结果为NULL。参数应该是一个字符串，如果不是字符串(如果可能)则被视为字符串。
mysql> SELECT CRC32('MySQL');
-> 3259397556
mysql> SELECT CRC32('mysql');
-> 250190853861、cume_dist 累积分布值
返回一个值在一组值中的累积分布;也就是说，分区值小于或等于当前行中的值的百分比。这表示在窗口分区的窗口顺序中，在当前行之前或与当前行的对等的行数除以窗口分区中的总行数。返回值范围为0到1。
这个函数应该与ORDER BY一起使用，将分区行按所需的顺序排序。如果没有ORDER BY，所有行都是对等行，值为N/N = 1，其中N为分区大小。
mysql> SELECT
val,
ROW_NUMBER() OVER w AS 'row_number',
CUME_DIST() OVER w AS 'cume_dist',
PERCENT_RANK() OVER w AS 'percent_rank'
FROM numbers
WINDOW w AS (ORDER BY val);
+------+------------+--------------------+--------------+
| val | row_number | cume_dist | percent_rank |
+------+------------+--------------------+--------------+
| 1 | 1 | 0.2222222222222222 | 0 |
| 1 | 2 | 0.2222222222222222 | 0 |
| 2 | 3 | 0.3333333333333333 | 0.25 |
| 3 | 4 | 0.6666666666666666 | 0.375 |
| 3 | 5 | 0.6666666666666666 | 0.375 |
| 3 | 6 | 0.6666666666666666 | 0.375 |
| 4 | 7 | 0.8888888888888888 | 0.75 |
| 4 | 8 | 0.8888888888888888 | 0.75 |
| 5 | 9 | 1 | 1 |
+------+------------+--------------------+--------------+62、curdate 和current date 都是返回当前日期
mysql> SELECT CURDATE();
-> '2008-06-13'
mysql> SELECT CURDATE() + 0;
-> 2008061363、current role（）返回当前活动角色
返回utf8mb3字符串，包含当前会话的当前活动角色，用逗号分隔，如果没有则为NONE。该值反映了sql_quote_show_create系统变量的设置。
64、 curtime 和current time 都是 返回当前时间
mysql> SELECT CURTIME();
+-----------+
| CURTIME() |
+-----------+
| 19:25:37 |
+-----------+65、current timestamp 和now 都是返回当前日期加时间
mysql> SELECT NOW();
-> '2007-12-15 23:50:26'
mysql> SELECT NOW() + 0;
-> 20071215235026.00000066、current user 认证的用户名和主机名
mysql> SELECT USER();
-> 'davida@localhost'
mysql> SELECT * FROM mysql.user;
ERROR 1044: Access denied for user ''@'localhost' to
database 'mysql'
mysql> SELECT CURRENT_USER();
-> '@localhost'D开头的函数
67、database 返回默认的(当前的)数据库名称
mysql> SELECT DATABASE();
-> 'test'68、date 提取date或datetime表达式的日期部分
mysql> SELECT DATE('2003-12-31 01:02:03');
-> '2003-12-31'69、date add 将时间值(间隔)添加到日期值
mysql> SELECT DATE_ADD('2018-05-01',INTERVAL 1 DAY);
-> '2018-05-02'
mysql> SELECT DATE_SUB('2018-05-01',INTERVAL 1 YEAR);
-> '2017-05-01'
mysql> SELECT DATE_ADD('2020-12-31 23:59:59',
-> INTERVAL 1 SECOND);
-> '2021-01-01 00:00:00'
mysql> SELECT DATE_ADD('2018-12-31 23:59:59',
-> INTERVAL 1 DAY);
-> '2019-01-01 23:59:59'
mysql> SELECT DATE_ADD('2100-12-31 23:59:59',
-> INTERVAL '1:1' MINUTE_SECOND);
-> '2101-01-01 00:01:00'
mysql> SELECT DATE_SUB('2025-01-01 00:00:00',
-> INTERVAL '1 1:1:1' DAY_SECOND);
-> '2024-12-30 22:58:59'
mysql> SELECT DATE_ADD('1900-01-01 00:00:00',
-> INTERVAL '-1 10' DAY_HOUR);
-> '1899-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'70、date format 格式指定日期
mysql> SELECT DATE_FORMAT('2009-10-04 22:23:00', '%W %M %Y');
-> 'Sunday October 2009'
mysql> SELECT DATE_FORMAT('2007-10-04 22:23:00', '%H:%i:%s');
-> '22:23:00'
mysql> SELECT DATE_FORMAT('1900-10-04 22:23:00',
-> '%D %y %a %d %m %b %j');
-> '4th 00 Thu 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'
mysql> SELECT DATE_FORMAT('2006-06-00', '%d');
-> '00'
71、date sub 从日期中减去时间值(间隔)
mysql> SELECT DATE_SUB('2018-05-01',INTERVAL 1 YEAR);
-> '2017-05-01'72、datediff 两个日期相减
mysql> SELECT DATEDIFF('2007-12-31 23:59:59','2007-12-30');
-> 1
mysql> SELECT DATEDIFF('2010-11-30 23:59:59','2010-12-31');
-> -3173、dayofmonth 返回月份中的天数(0 ~ 31)
mysql> SELECT DAYOFMONTH('2007-02-03');
-> 374、dayname 返回日期的星期几的名称
mysql> SELECT DAYNAME('2007-02-03');
-> 'Saturday'75、dayofweek
返回date对象的工作日索引(1 =周日，2 =周一，…，7 =周六)。这些索引值对应于ODBC标准。如果date为NULL，返回NULL。
mysql> SELECT DAYOFWEEK('2007-02-03');
-> 776、dayofyear 返回一年中的哪一天(1-366)
mysql> SELECT DAYOFYEAR('2007-02-03');
-> 3477、default 返回表列的默认值，如果列没有默认值，将导致错误。
78、degrees 将弧度转换为度数
mysql> SELECT DEGREES(PI());
-> 180
mysql> SELECT DEGREES(PI() / 2);
-> 9079、dense_ rank 当前行在其分区内的排名，无间隙
该函数应该与ORDER BY一起使用，以便将分区中的行排序为所需的顺序。没有ORDER BY，所有行都是对等的。
select distinct t.*
from(
select s.CID ,s.score,
dense_rank() over (partition by CID order by s.score desc) 名次
from sc s ) t;
80、div 整数的除法
整数的除法。从除法结果中丢弃小数点右边的任何小数部分。
如果任一操作数具有非整数类型，则操作数被转换为DECIMAL并在将结果转换为BIGINT之前使用DECIMAL算术进行除法。如果结果超出BIGINT范围，则发生错误。
mysql> SELECT 5 DIV 2, -5 DIV 2, 5 DIV -2, -5 DIV -2;
-> 2, -2, -2, 2E开头的函数
81、elt 返回索引号处的字符串
mysql> SELECT ELT(1, 'Aa', 'Bb', 'Cc', 'Dd');
-> 'Aa'
mysql> SELECT ELT(4, 'Aa', 'Bb', 'Cc', 'Dd');
-> 'Dd'82、EXP（x）
返回e(自然对数的底)的x次方的值。这个函数的倒数是LOG()(只使用一个参数)或LN()。
如果X为NULL，该函数返回NULL。
mysql> SELECT EXP(2);
-> 7.3890560989307
mysql> SELECT EXP(-2);
-> 0.13533528323661
mysql> SELECT EXP(0);
-> 183、export_set
返回一个字符串，值中每一个比特位被设置，就得到一个on字符串，值中每一个比特位未设置，就得到一个off字符串。位中的位从右到左(从低阶到高阶)检查。字符串从左到右添加到结果中，由分隔符字符串(默认为逗号)分隔。所检查的比特位数由number_of_bits给出，如果没有指定，默认值为64。如果Number_of_bits大于64，则静默地裁剪为64。它被视为无符号整数，因此−1的值实际上等同于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'84、extract 提取日期的一部分
mysql> SELECT EXTRACT(YEAR FROM '2019-07-02');
-> 2019
mysql> SELECT EXTRACT(YEAR_MONTH FROM '2019-07-02 01:02:03');
-> 201907
mysql> SELECT EXTRACT(DAY_MINUTE FROM '2019-07-02 01:02:03');
-> 20102
mysql> SELECT EXTRACT(MICROSECOND
-> FROM '2003-01-02 10:30:00.000123');
-> 12385、ExtractValue() 接受两个字符串参数:一个XML标记片段xml_frag和一个XPath表达式xpath_expr(也称为定位器);它返回第一个文本节点的文本(CDATA)，该文本节点是XPath表达式匹配的一个或多个元素的子节点。
mysql> SELECT ExtractValue('<a><b/></a>', '/a/b');
+-------------------------------------+
| ExtractValue('<a><b/></a>', '/a/b') |
+-------------------------------------+
| |
+-------------------------------------+
1 row in set (0.00 sec)F开头的字符串
86、field 第一个参数在后续参数中的索引(位置)
mysql> SELECT FIELD('Bb', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
-> 2
mysql> SELECT FIELD('Gg', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
-> 087、find_ in_set(str,strlist) 第一个参数在第二个参数中的索引(位置)
如果字符串str在由N个子字符串组成的字符串列表strlist中，则返回一个范围为1到N的值。字符串列表是由由字符分隔的子字符串组成的字符串。如果第一个参数是常量字符串，第二个是类型为SET的列，那么FIND_IN_SET()函数会被优化为使用位运算。如果str不在strlist中，或者strlist是空字符串，则返回0。如果任何一个参数为NULL，则返回NULL。如果第一个参数包含逗号(，)，这个函数将无法正常工作。
mysql> SELECT FIND_IN_SET('b','a,b,c,d');
-> 288、first_value( EXPR ) over( partition by col1 order by col2 )
其中EXPR通常是直接是列名，也可以是从其他行返回的表达式，根据字段col1进行分组，在分组内部根据字段col2进行排序，first_value函数返回一组排序值后的第一个值
+------+------+------+-------+
| id | name | sale | rank1 |
+------+------+------+-------+
| 1 | aaa | 100 | 100 | <--分组的第一个值为100，开窗结果100
| 1 | bbb | 200 | 100 | <--分组的第一个值为100，开窗结果100
| 1 | ccc | 200 | 100 | <--分组的第一个值为100，开窗结果100
| 1 | ddd | 300 | 100 | <--分组的第一个值为100，开窗结果100
| 2 | eee | 400 | 400 |
| 2 | fff | 200 | 400 |
+------+------+------+-------+
89、floor 返回不大于参数的最大整数值
mysql> SELECT FLOOR(1.23), FLOOR(-1.23);
-> 1, -290、format 返回格式化为指定的小数位数的数字
mysql> SELECT FORMAT(12332.123456, 4);
-> '12,332.1235'
mysql> SELECT FORMAT(12332.1,4);
-> '12,332.1000'
mysql> SELECT FORMAT(12332.2,0);
-> '12,332'
mysql> SELECT FORMAT(12332.2,2,'de_DE');
-> '12.332,20'91、 format bytes (count) 将字节计数转换为有单位的值
给定一个数值型字节计数，将其转换为人类可读的格式，并返回一个由值和单位指示符组成的字符串。字符串包含四舍五入到2位小数和最小3位有效数字的字节数。小于1024字节的数字表示为整数，不会四舍五入。如果count为NULL，返回NULL。
mysql> SELECT FORMAT_BYTES(512), FORMAT_BYTES(18446644073709551615);
+-------------------+------------------------------------+
| FORMAT_BYTES(512) | FORMAT_BYTES(18446644073709551615) |
+-------------------+------------------------------------+
| 512 bytes | 16.00 EiB |
+-------------------+------------------------------------+92、format_pico_time (time_val)
给定以皮秒为单位的数值型性能模式延迟或等待时间，将其转换为人类可读的格式，并返回一个由值和单位指示符组成的字符串。该字符串包含四舍五入到2位的小数时间和最小3位有效数字。小于1纳秒的时间表示为整数，不会四舍五入。
如果time_val为NULL，该函数返回NULL。
mysql> SELECT FORMAT_PICO_TIME(3501), FORMAT_PICO_TIME(188732396662000);
+------------------------+-----------------------------------+
| FORMAT_PICO_TIME(3501) | FORMAT_PICO_TIME(188732396662000) |
+------------------------+-----------------------------------+
| 3.50 ns | 3.15 min 93、found_rows()
对于带有LIMIT子句的SELECT，如果没有LIMIT子句，则返回的行数
SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name WHERE id > 100 LIMIT 10;
SELECT FOUND_ROWS();94、from_base64(str ) 解码base64编码的字符串并返回结果
mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
-> 'JWJj', 'abc'95、from_days() 将数字转换为日期
mysql> SELECT FROM_DAYS(730669);
-> '2000-07-03'96、from_unixtime 将Unix时间戳格式化为日期
mysql> SELECT FROM_UNIXTIME(1447430881);
-> '2015-11-13 10:08:01'
mysql> SELECT FROM_UNIXTIME(1447430881) + 0;
-> 20151113100801
mysql> SELECT FROM_UNIXTIME(1447430881,
-> '%Y %D %M %h:%i:%s %x');
-> '2015 13th November 10:08:01 2015'G开头的函数
97、GeomCollection 和 geometrycollection从几何体中构建几何体集合
98、get_format 返回一个日期格式字符串
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'
99、get_lock() 获取一个命名的锁
用GET_LOCK()获得的锁会通过执行RELEASE_LOCK()显式释放，或者在会话终止(正常或异常)时隐式释放。用GET_LOCK()获得的锁不会在事务提交或回滚时释放。
SELECT GET_LOCK('lock1',10);
SELECT GET_LOCK('lock2',10);
SELECT RELEASE_LOCK('lock2');
SELECT RELEASE_LOCK('lock1');100、greatest 返回最大的参数
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'101、group_concat 返回拼接后的字符串
GROUP_CONCAT([DISTINCT] expr [,expr ...]
[ORDER BY {unsigned_integer | col_name | expr}
[ASC | DESC] [,col_name ...]]
[SEPARATOR str_val])
mysql> SELECT student_name,
GROUP_CONCAT(test_score)
FROM student
GROUP BY student_name;
mysql> SELECT student_name,
GROUP_CONCAT(DISTINCT test_score
ORDER BY test_score DESC SEPARATOR ' ')
FROM student
GROUP BY student_name;102、grouping 区分超级聚合汇总行和普通行
对于包含WITH ROLLUP修饰符的GROUP BY查询，ROLLUP操作产生超级聚合输出行，其中NULL表示所有值的集合。GROUPING()函数可以让你区分超聚合行的NULL值和常规分组行的NULL值。
mysql> SELECT
name, size, SUM(quantity) AS quantity,
GROUPING(name) AS grp_name,
GROUPING(size) AS grp_size
FROM t1
GROUP BY name, size WITH ROLLUP;
+------+-------+----------+----------+----------+
| name | size | quantity | grp_name | grp_size |
+------+-------+----------+----------+----------+
| ball | NULL | 5 | 0 | 0 |
| ball | large | 20 | 0 | 0 |
| ball | small | 10 | 0 | 0 |
| ball | NULL | 35 | 0 | 1 |
| hoop | NULL | 3 | 0 | 0 |
| hoop | large | 5 | 0 | 0 |
| hoop | small | 15 | 0 | 0 |
| hoop | NULL | 23 | 0 | 1 |
| NULL | NULL | 58 | 1 | 1 |
+------+-------+----------+----------+----------+103、gtid_subset(set1,set2) 如果子集中的所有gtid也在set中，则返回true;否则错误。
给定两组全局事务标识符set1和set2，如果set1中的所有gtid都在set2中，则返回true。如果set1或set2为NULL，则返回NULL。否则返回false。
104、gtid_subtract(set1,set2) 返回set中所有不在subset中的gtid
H开头的函数
105、hex() 十进制或字符串值的十六进制表示
mysql> SELECT X'616263', HEX('abc'), UNHEX(HEX('abc'));
-> 'abc', 616263, 'abc'
mysql> SELECT HEX(255), CONV(HEX(255),16,10);
-> 'FF', 255106、hour() 返回时间的小时数。对于一天中的时间值，返回值的范围是0到23。然而，时间范围实际上要大得多，因此HOUR的返回值可以大于23。如果time为NULL，则返回NULL。
mysql> SELECT HOUR('10:05:03');
-> 10
mysql> SELECT HOUR('272:59:59');
-> 272I开头的函数
107、ICU_version
用于支持正则表达式操作的国际Unicode组件(International Components for Unicode, ICU)库的版本(参见12.8.2节)。该函数主要用于测试用例。
108、if（expr1，expr2，expr3） 如果expr1为TRUE 返回expr2。否则，返回expr3。
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'109、ifnull（expr1，expr2）如果expr1不是NULL, IFNULL()返回expr1;否则返回expr2。
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'110、in() 一个值是否在一组值中
mysql> SELECT 2 IN (0,3,5,7);
-> 0
mysql> SELECT 'wefwf' IN ('wee','wefwf','weg');
-> 1111、inet_aton()返回IP地址的数值
给定IPv4网络地址的四元组点阵表示的字符串，返回一个整数，表示该地址的网络字节序(大端序)。如果INET_ATON()不理解其参数，或者expr为NULL，则返回NULL。
mysql> SELECT INET_ATON('10.0.5.9');
-> 167773449112、inet_ntoa()用数值返回IP地址
给定网络字节顺序的数字IPv4网络地址，返回该地址作为连接字符集字符串的点四字符串表示形式。如果INET_NTOA()不理解其参数，则返回NULL。
mysql> SELECT INET_NTOA(167773449);
-> '10.0.5.9'113、inet6_aton 返回IPv6地址的数值
给定一个IPv6或IPv4的网络地址字符串，返回一个二进制字符串，以网络字节序(大端序)表示该地址的数值。因为数字格式的IPv6地址比最大的整数类型需要更多的字节，所以该函数返回的表示形式是VARBINARY数据类型:IPv6地址为VARBINARY(16)， IPv4地址为VARBINARY(4)。如果参数不是有效的地址，或者是NULL, INET6_ATON()返回NULL。
mysql> SELECT HEX(INET6_ATON('fdfe::5a55:caff:fefa:9089'));
-> 'FDFE0000000000005A55CAFFFEFA9089'
mysql> SELECT HEX(INET6_ATON('10.0.5.9'));
-> '0A000509'114、inet6_ntoa 从数值返回IPv6地址
mysql> SELECT INET6_NTOA(UNHEX('FDFE0000000000005A55CAFFFEFA9089'));
-> 'fdfe::5a55:caff:fefa:9089'
mysql> SELECT INET6_NTOA(UNHEX('0A000509'));
-> '10.0.5.9'115、insert(str,pos,len,newstr) 在指定位置插入不超过指定字符数的子串
返回字符串str，起始位置为pos和len的子字符串替换为字符串newstr。如果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'116、instr() 返回第一个出现的子字符串的索引
mysql> SELECT INSTR('foobarbar', 'bar');
-> 4
mysql> SELECT INSTR('xbar', 'foobar');
-> 0117、interval(n,n1,n2,n3,n4.....) 返回小于第一个参数的参数索引
如果N < N1，返回0;如果N < N2，返回1;如果N为空，返回-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);
-> 0118、is 用布尔值测试一个值
is_free_lock :指定的锁是否空闲
is_ipv4 :参数是否为IPv4地址
is_ipv4_compat :参数是否为ipv4兼容地址
is_ipv4_mapped :参数是否为ipv4映射地址
is_ipv6: 是否为IPv6地址
is not: 是否
is not null ：非空检验
is null ： 空值检验
is _used_lock: 指定的锁是否正在使用;如果为真，返回连接标识符
is_uuid :参数是否为有效的UUID
isnull ： 测试实参是否为NULL
J开头的函数
以下都为json函数，就不排序了
一、创建 JSON 值的函数
JSON_ARRAY([val[, val] …])
评估（可能为空）值列表并返回包含这些值的 JSON 数组。
JSON_OBJECT([key, val[, key, val] …])
评估键值对（可能为空）列表并返回包含这些对的 JSON 对象。如果任何键名称是NULL或参数数量是奇数，则会发生错误。
JSON_QUOTE(string)
通过用双引号字符包裹字符串并转义内部引号和其他字符，将utf8mb4字符串引用为 JSON 值，然后将结果作为字符串返回 。NULL如果参数为 ，则 返回 NULL。
二、搜索 JSON 值的函数
JSON_CONTAINS(target, candidate[, path])
判断是否包含某个json值
SELECT * FROM json where JSON_CONTAINS(jsonData,'{"user_name":"tom"}');
JSON_CONTAINS_PATH(json_doc, one_or_all, path[, path] …)
判断某个路径下是否包json值
MySQL里的json分为json array和json object。 $表示整个json对象，在索引数据时用下标(对于json array，从0开始)或键值(对于json object，含有特殊字符的key要用"括起来，比如$."my name")。
例如：[3, {"a": [5, 6], "b": 10}, [99, 100]]，那么：
$[0]：3
$[1]： {"a": [5, 6], "b": 10}
$[2] ：[99, 100]
$[3] ： NULL
SELECT id,jsonData,JSON_CONTAINS_PATH(jsonData, 'one', '$.user_name') as json FROM json;
SELECT JSON_CONTAINS_PATH(jsonData, 'one', '$.bbs') as json FROM json;
json_extract（提取json值）的简洁写法
column->path
Id jsonData
1 [{"a": [5, 6], "b": 10}]
2 {"age": "23", "sex": "1", "user_name": "tom"}
3 [{"user_name": "bob"}, {"user_name": "jack"}]
SELECT JSON_EXTRACT(jsonData, '$.user_name') json_extract FROM json where id = 2;
在 MySQL 5.7.9 及更高版本中，当与两个参数一起使用时， -> 运算符用作JSON_EXTRACT()函数的别名， 左侧的列标识符和右侧的 JSON 路径（字符串文字）根据 JSON 文档（列值）。
SELECT jsonData -> '$.user_name' json_extract FROM json where id = 2;
SELECT jsonData -> '$[0].user_name' json_extract FROM json where id = 3;
json_unquote的简洁写法:
column->>path
去除json字符串的引号，将值转成string类型
SELECT jsonData ->> ‘$.user_name’ json_unquote FROM json;
JSON_KEYS(json_doc[, path])提取json中的键值为json数组
SELECT JSON_KEYS(jsonData) jsonKey FROM json;
SELECT JSON_KEYS(jsonData -> ‘$[0]’) jsonKey2 FROM json;
JSON_SEARCH(json_doc, one_or_all, search_str[, escape_char[, path] …])
查询包含指定字符串的paths，并作为一个json array返回。如果有参数为NUL或path不存在，则返回NULL。
one_or_all："one"表示查询到一个即返回；"all"表示查询所有。
search_str：要查询的字符串。 可以用LIKE里的’%'或‘_’匹配。
path：在指定path下查。
SET @j = '["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}]';
SELECT JSON_SEARCH(@j, 'all', '10') jsonSearch;
SELECT JSON_SEARCH(jsonData, 'one', '23') as jsonSearch FROM json;
三、修改 JSON 值的函数
JSON_APPEND(json_doc, path, val[, path, val] …)将值附加到 JSON 文档中指定数组的末尾并返回结果
json_append 废弃，MySQL 5.7.9开始改名为json_array_append
JSON_ARRAY_APPEND(json_doc, path, val[, path, val] …)
末尾添加数组元素，如果原有值是数值或json对象，则转成数组后，再添加元素
SELECT JSON_ARRAY_APPEND(jsonData, '$[0]', '1') as newJson FROM json where id = 1;
SELECT JSON_ARRAY_APPEND(jsonData, '$[1]', '1') as newJson FROM json where id = 1;
JSON_ARRAY_INSERT(json_doc, path, val[, path, val] …)
在指定索引插入字符并返回对应的字符
SELECT JSON_ARRAY_INSERT(jsonData, ‘$[0]’, ‘2’) jsonArray FROM json where id = 1;
JSON_INSERT(json_doc, path, val[, path, val] …)
插入值（插入新值，但不替换已经存在的旧值）
SELECT JSON_INSERT(jsonData,'$[1].a','996','$[10]','mysql-json') jsonInsert FROM json where id = 1;
JSON_MERGE(json_doc, json_doc[, json_doc] …)
合并json数组或对象
SELECT JSON_MERGE('[1, 2]', '[true, false]');
JSON_MERGE(json_doc, json_doc[, json_doc] …)
合并json数组或对象
SELECT JSON_MERGE('[1, 2]', '[true, false]');
JSON_REMOVE(json_doc, path[, path] …)
从 JSON 文档中删除数据并返回结果
SELECT JSON_REMOVE(jsonData,'$[0]') as jsonRemove FROM json where id = 1;
JSON_REPLACE(json_doc, path, val[, path, val] …)
替换 JSON 文档中的现有值并返回结果
SELECT JSON_REPLACE(jsonData, '$[1].a', '{1,2,3}') FROM json where id =1;
JSON_SET(json_doc, path, val[, path, val] …)
在 JSON 文档中插入或更新数据并返回结果
SELECT JSON_SET(jsonData,'$.sex','男','$[100]','json') jsonSet FROM json where id = 2;
JSON_SET()， JSON_INSERT()和 JSON_REPLACE()功能的关系：
JSON_SET() 替换现有值并添加不存在的值。
JSON_INSERT() 插入值而不替换现有值。
JSON_REPLACE()仅替换 现有值。
四、返回 JSON 值属性的函数
JSON_DEPTH(json_doc) 返回json文档的最大深度
SELECT JSON_DEPTH(jsonData) from json;
JSON_LENGTH(json_doc[, path]) 返回json文档的长度
SELECT JSON_LENGTH(jsondata,'$[1].b') json_length FROM json where id = 1;
JSON_TYPE(json_val)
返回JSON 值类型的字符串。这可以是对象、数组或标量类型
SELECT jsonData,JSON_TYPE(jsonData) FROM json;
SELECT JSON_TYPE(jsonData -> '$.age') FROM json where id = 2;
json_valid 判断是否为合法json文档
L开头的函数
119、lag（）
lag(EXPR,<OFFSET>,<DEFAULT>) over（partition by col1 order by col2）
EXPR通常是直接是列名，也可以是从其他行返回的表达式；
OFFSET是默认为1，表示在当前分区内基于当前行的偏移行数；
DEFAULT是在OFFSET指定的偏移行数超出了分组的范围时(因为默认会返回null)，可以通过设置这个字段来返回一个默认值来替代null。
120、last_day(date)
接受一个date或datetime值，并返回当月最后一天的对应值。如果参数无效，则返回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');
-> NULL121、last_insert_id 上一次插入的自动递增列的值
122、last_value( EXPR ) over( partition by col1 order by col2 )
其中EXPR通常是直接是列名，也可以是从其他行返回的表达式，根据字段col1进行分组，在分组内部根据字段col2进行排序，first_value函数返回一组排序值后的第一个值，last_value返回一组排序值后的最后一个值
重点注意：因为在开窗函数over()中除了分组和排序，还有一个窗口的从句，在经过排序之后，使用last_value函数生效的范围是第一行至当前行，在上面的例子id=1分组中，每一行显示的所谓最后一个值last value来自第一行到当前行这个范围内的最后一个，这里，我们仅对id=1组逐行分析，id=2分组同理可证
123、lcase() 和 lower() 返回字符串str，根据当前字符集映射将所有字符改为小写，如果str为NULL则返回NULL。默认的字符集是utf8mb4。
mysql> SELECT LOWER('QUADRATICALLY');
-> 'quadratically'124、lead() 分区中当前行的前导行的参数值
lead（expr [ , N [,default] ] )
返回分区中当前行前面(后面)N行的expr值。如果没有这样的行，则返回值为default。例如，如果N是3，则最后三行的返回值为默认值。如果缺少N或default，则默认值分别为1和NULL。
N必须是一个非负整数字面量。如果N为0，则对当前行的expr进行计算。
125、least 返回最小的参数
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'126、left 返回指定的最左边的字符数
127、length 返回字符串的长度（以字节为单位）
mysql> SELECT LENGTH('text');
-> 4128、like 简单的模式匹配，类似
mysql> SELECT 'David!' LIKE 'David_';
-> 1
mysql> SELECT 'David!' LIKE '%D%v%';
-> 1129、ln(x)
返回 X 的自然对数;也就是说， X 的底 e 对数。如果 X 小于或等于 0.0E0， 该函数返回并报告警告“对数参数无效”。
mysql> SELECT LN(2);
-> 0.69314718055995
mysql> SELECT LN(-2);
-> NULL130、load_file 加载命名文件
mysql> UPDATE t
SET blob_col=LOAD_FILE('/tmp/picture')
WHERE id=1;131、localtime localtimestamp 和now 都是返回当前日期和时间
mysql> SELECT NOW();
-> '2007-12-15 23:50:26'132、locate 返回字符串第一次出现的位置
mysql> SELECT LOCATE('bar', 'foobarbar');
-> 4
mysql> SELECT LOCATE('xbar', 'foobar');
-> 0
mysql> SELECT LOCATE('bar', 'foobarbar', 5);
-> 7133、Log 返回第一个参数的自然对数 同 ln
log2(x) :返回 的以 2 为底的对数。如果 X 小于或等于 0.0E0， 该函数返回并报告警告“对数参数无效”
log10(x):返回 的以 10为底的对数。如果 X 小于或等于 0.0E0， 该函数返回并报告警告“对数参数无效”
134、lower ：返回小写参数
mysql> SELECT LOWER('QUADRATICALLY');
-> 'quadratically'135、lpad（str,len,padstr） 返回字符串参数，用指定的字符串左填充
返回字符串 str，左填充 用绳子垫到一定长度 的 len 字符。如果 str 比 len 长，则返回值缩短 到len字符。
mysql> SELECT LPAD('hi',4,'??');
-> '??hi'
mysql> SELECT LPAD('hi',1,'??');
-> 'h'136、ltrim（str) 删除字符串str的空格
mysql> SELECT LTRIM(' barbar');
-> 'barbar'137、make_set(bits,str1,str2,...) 返回一组逗号分隔的字符串，其中设置了对应的位
返回一个设置值（包含分隔的子字符串的字符串 按字符）组成的字符串 设置了相应的位。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');
-> ''138、makedate(year,dayofyear) 从一年中的哪一天创建日期
返回给定年份和日期值的日期。年份中的天数必须大于 0
mysql> SELECT MAKEDATE(2011,31), MAKEDATE(2011,32);
-> '2011-01-31', '2011-02-01'
mysql> SELECT MAKEDATE(2011,365), MAKEDATE(2014,365);
-> '2011-12-31', '2014-12-31'
mysql> SELECT MAKEDATE(2011,0);
-> NULL139、maketime(hour,minute,second) 从小时、分钟、秒创建时间
mysql> SELECT MAKETIME(12,15,30);
-> '12:15:30'140、master_pos_wait 阻塞直到副本读取并将所有更新应用到指定位置
141、match 执行全文搜索
SELECT MATCH (a) AGAINST ('abc') FROM t GROUP BY a WITH ROLLUP;142、max 求最大值
mysql> SELECT student_name, MIN(test_score), MAX(test_score)
FROM student
GROUP BY student_name;143、
MBRContains() ：一个几何的MBR是否包含另一个的MBR
MBRCoveredBy() ：一个MBR是否被另一个覆盖
MBRCovers() ：一个MBR是否覆盖另一个
MBRDisjoint() ：两个几何的MBR是否是不相交的
MBREqual() (弃用5.7.6) ：两个几何的MBR是否相等
MBREquals()：两个几何的MBR是否相等
MBRIntersects() ：两个几何的MBR是否相交
MBROverlaps() ：两个几何的MBR是否重叠
MBRTouches() ：是否触摸两个几何的MBR
MBRWithin() ：一个几何的MBR是否在另一个几何的MBR之内
144、MD5 计算MD5校验和 用来加密
mysql> SELECT MD5('testing');
-> 'ae2b1fca515949e5d54fb22b8ed95575'145、 member of ()
value member of (json array)
如果value是json_array的元素，返回true(1)，否则返回false(0)。value必须是标量或JSON文档;如果是标量，运算符会尝试将其视为JSON数组的元素。如果value或json_array为NULL，函数返回NULL。
mysql> SELECT 17 MEMBER OF('[23, "abc", 17, "ab", 10]');
+-------------------------------------------+
| 17 MEMBER OF('[23, "abc", 17, "ab", 10]') |
+-------------------------------------------+
| 1 |
+-------------------------------------------+
1 row in set (0.00 sec)146、microsecond 从时间或日期时间表达式 expr 返回微秒，作为 到 范围内的数字
mysql> SELECT MICROSECOND('12:00:00.123456');
-> 123456
mysql> SELECT MICROSECOND('2019-12-31 23:59:59.000010');
-> 10147、mid(str,pos,len) 返回从指定位置开始的子字符串 同substring
没有len参数的表单从字符串str返回一个从位置pos开始的子字符串。有len参数的表单从位置pos开始返回一个长度为len的子字符串。使用from的表单是标准的SQL语法。也可以使用负数表示pos。在这个例子中，子字符串的起始位置是字符串末尾的pos字符，而不是字符串的起始位置。在该函数的任何形式中，负数都可以用于pos。pos的值为0将返回一个空字符串。
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'148、min 返回最小值
mysql> SELECT student_name, MIN(test_score), MAX(test_score)
FROM student
GROUP BY student_name;149、minute（time）返回time的分钟数，范围为0到59，如果time为NULL则返回NULL。
mysql> SELECT MINUTE('2008-02-03 10:05:03');
-> 5150、mod（n,m) 模操作。返回N除以M的余数，如果M或N为空，返回NULL
mysql> SELECT MOD(234, 10);
-> 4
mysql> SELECT 253 % 7;
-> 1
mysql> SELECT MOD(29,9);
-> 2
mysql> SELECT 29 MOD 9;
-> 2151、month(date)
返回日期的月份，范围是1到12，表示一月到十二月;返回0，表示诸如'0000-00-00'或'2008-00-00'这样的日期，月份部分为0。如果date为NULL，返回NULL。
mysql> SELECT MONTH('2008-02-03');
-> 2152、monthname(date) 返回date月份的全名
mysql> SELECT MONTHNAME('2008-02-03');
-> 'February'153、
MultiLineString() ：从LineString值引发MultiLineString
MultiPoint() ：从点值构造多点
MultiPolygon() ：从多边形值构造MultiPolygon
N开头的函数
154、name_const 使列具有给定的名称
返回给定的值。在用于生成结果集列时，NAME_CONST()会使列具有给定的名称。参数应该是常量。
mysql> SELECT NAME_CONST('myname', 14);
+--------+
| myname |
+--------+
| 14 |
+--------+155、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;
-> 1156、not between...and...某个值是否不在某个范围内
157、not in() 一个值是否不在一组值中
158、not like 否定简单模式匹配 不类似
159、NOT REGEXP ：否定REGEXP
160、now 返回当前日期和时间
161、nth_value(expr,N)
返回窗口框架第n行expr的值。如果没有这样的行，则返回值为NULL。
N必须是一个正整数。
162、ntile（N） over（）
将一个分区划分为N组(桶)，为分区中的每一行指定桶号，并返回当前行在该分区中的桶号。例如，如果N为4,NTILE()将行分成4个桶。如果N是100,NTILE()将行分成100个桶。
N必须是一个正整数。桶编号返回值的范围是1 ~ N。
163、nullif(expr1.expr2)
如果expr1 = expr2为true，返回NULL，否则返回expr1。这与expr1 = expr2然后为NULL否则expr1结束的情况相同。
返回值的类型与第一个参数相同。
mysql> SELECT NULLIF(1,1);
-> NULL
mysql> SELECT NULLIF(1,2);
-> 1O开头的函数
164、oct（N）
返回N的八进制值的字符串表示形式，其中N是longlong (BIGINT)数。它等价于CONV(N,10,8)如果N为NULL，返回NULL。
mysql> SELECT OCT(12);
-> '14'165、octet_lengeth 同length()
166、or，||
逻辑或。□在两个操作数都非null的情况下，如果有操作数非零，则结果为1，否则为0;□对于NULL操作数，如果另一个操作数非零，则结果为1，否则为NULL;□如果两个操作数都是NULL，结果是NULL;
mysql> SELECT 1 OR 1;
-> 1
mysql> SELECT 1 OR 0;
-> 1
mysql> SELECT 0 OR 0;
-> 0
mysql> SELECT 0 OR NULL;
-> NULL
mysql> SELECT 1 OR NULL;
-> 1167、ord（str）
ORD()返回与ASCII()函数相同的值。如果str为NULL，该函数返回NULL。
mysql> SELECT ORD('2');
-> 50P开头的函数
168、percent_rank() over()
返回分区值小于当前行的值的百分比(不包括最高值)。返回值范围从0到1，表示行相对排名，通过这个公式计算得出，其中rank是行排名，rows是分区行数:
169、period_add(P,N)
在周期P上增加N个月(格式为YYMM或YYYYMM)。返回格式为YYYYMM的值。
mysql> SELECT PERIOD_ADD(200801,2);
-> 200803170、period_differ (p1,p2)
返回时期P1和P2之间的月数。P1和P2的格式应该是YYMM或YYYYMM。注意，句点参数P1和P2不是日期值。
mysql> SELECT PERIOD_DIFF(200802,200703);
-> 11
171、PI()
mysql> SELECT PI();
-> 3.141593172、point(x,y) 使用其坐标构造一个点。
173、polygon(ls [,ls ] ...)
根据一些LineString或WKB LineString参数构造多边形值。如果任何参数不表示LinearRing(即不是闭合的简单LineString)，则返回值为NULL。
174、position 同 locate
175、pow(x,y) 同power(x,y) 返回X的Y次方的值，如果X或Y为NULL，返回NULL
mysql> SELECT POW(2,2);
-> 4
mysql> SELECT POW(2,-2);
-> 0.25176、ps_current_thread_id()
返回一个BIGINT无符号值，表示分配给当前连接的性能架构线程ID。
线程ID返回值是性能模式表的THREAD_ID列中给定类型的值。
性能模式配置对PS_CURRENT_THREAD_ID()的影响与对PS_THREAD_ID()的影响相同
177、ps_thread_id(connection_id)
给定一个连接ID，返回一个BIGINT无符号值，表示分配给连接ID的性能模式线程ID，如果连接ID不存在线程ID，则返回NULL。后一种情况可能发生在没有检测的线程中，或者connection_id为NULL时。
Q开头的函数
178、quarter 返回1到4之间的季度，如果date为NULL，则返回NULL。
mysql> SELECT QUARTER('2008-04-01');
-> 2179、quote
将字符串加引号，生成的结果可以在SQL语句中作为正确转义的数据值使用。返回的字符串由单引号括起来，每一个反斜杠(\)、单引号(')、ASCII NUL和Control+Z的实例前面都有一个反斜杠。如果参数是NULL，返回值是单词“NULL”，不包含单引号。
mysql> SELECT QUOTE('Don\'t!');
-> 'Don\'t!'
mysql> SELECT QUOTE(NULL);
-> NULL180、padians 返回参数X，从度数转换为弧度。(注意，π弧度等于180度。)如果X为NULL，返回NULL。
mysql> SELECT RADIANS(90);
-> 1.5707963267949R开头的函数
181、rand([n]) 随机生成小数
返回一个范围为0 <= v < 1.0的随机浮点值v。要获得一个i <= R < j范围内的随机整数R，可以使用表达式FLOOR(i + RAND() * (j−i))。例如，要获得一个范围为7 <= R < 12的随机整数，使用下面的语句:
mysql> SELECT i, RAND(3) FROM t;
+------+------------------+
| i | RAND(3) |
+------+------------------+
| 1 | 0.90576975597606 |
| 2 | 0.37307905813035 |
| 3 | 0.14808605345719 |
+------+------------------+
3 rows in set (0.01 sec)182、random_bytes(len)
该函数返回一个使用SSL库的随机数生成器生成的len随机字节的二进制字符串。允许的len值范围是1 ~ 1024。对于超出此范围的值，则会发生错误。如果len为NULL，返回NULL。
183、rank 排名
mysql> SELECT
val,
ROW_NUMBER() OVER w AS 'row_number',
RANK() OVER w AS 'rank',
DENSE_RANK() OVER w AS 'dense_rank'
FROM numbers
WINDOW w AS (ORDER BY val);
+------+------------+------+------------+
| val | row_number | rank | dense_rank |
+------+------------+------+------------+
| 1 | 1 | 1 | 1 |
| 1 | 2 | 1 | 1 |
| 2 | 3 | 3 | 2 |
| 3 | 4 | 4 | 3 |
| 3 | 5 | 4 | 3 |
| 3 | 6 | 4 | 3 |
| 4 | 7 | 7 | 4 |
| 4 | 8 | 7 | 4 |
| 5 | 9 | 9 | 5 |
+------+------------+------+------------+184、regexp 格式：expr regexp pat
如果字符串expr匹配模式pat指定的正则表达式，则返回1，否则返回0。如果expr或pat为NULL，则返回值为NULL。
mysql> SELECT 'Michael!' REGEXP '.*';
+------------------------+
| 'Michael!' REGEXP '.*' |
+------------------------+
| 1 |
+------------------------+
mysql> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
+---------------------------------------+
| 'new*\n*line' REGEXP 'new\\*.\\*line' |
+---------------------------------------+
| 0 |
+---------------------------------------+
mysql> SELECT 'a' REGEXP '^[a-d]';
+---------------------+
| 'a' REGEXP '^[a-d]' |
+---------------------+
| 1 |
+---------------------+185、regexp_instr (expr,pat...）
返回与模式pat指定的正则表达式匹配的字符串expr的子字符串的起始索引，如果没有匹配，则为0。如果expr或pat为NULL，则返回值为NULL。字符索引从1开始。
mysql> SELECT REGEXP_INSTR('dog cat dog', 'dog');
+------------------------------------+
| REGEXP_INSTR('dog cat dog', 'dog') |
+------------------------------------+
| 1 |
+------------------------------------+
mysql> SELECT REGEXP_INSTR('dog cat dog', 'dog', 2);
+---------------------------------------+
| REGEXP_INSTR('dog cat dog', 'dog', 2) |
+---------------------------------------+
| 9 |
+---------------------------------------+
mysql> SELECT REGEXP_INSTR('aa aaa aaaa', 'a{2}');
+-------------------------------------+
| REGEXP_INSTR('aa aaa aaaa', 'a{2}') |
+-------------------------------------+
| 1 |
+-------------------------------------+
mysql> SELECT REGEXP_INSTR('aa aaa aaaa', 'a{4}');
+-------------------------------------+
| REGEXP_INSTR('aa aaa aaaa', 'a{4}') |
+-------------------------------------+
| 8 |
+-------------------------------------+186、RELEASE_ALL_LOCKS() ：释放所有当前命名的锁
187、RELEASE_LOCK() ：释放命名的锁
188、repeat(str,count) 返回一个字符串，包含字符串str repeat count次。如果count小于1，返回空字符串。如果str或count为NULL，则返回NULL。
mysql> SELECT REPEAT('MySQL', 3);
-> 'MySQLMySQLMySQL'189、replace(str,from_str,to_str) 返回字符串str，所有from_str出现的地方都被替换为字符串to_str。REPLACE()在搜索from_str时执行区分大小写的匹配。
mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
-> 'WwWwWw.mysql.com'190、reverse 返回字符顺序颠倒后的字符串str，如果str为NULL则返回NULL。
mysql> SELECT REVERSE('abc');
-> 'cba'191、right(str,len) 返回字符串str最右边的len字符，如果任何参数为NULL，则返回NULL。
mysql> SELECT RIGHT('foobarbar', 4);
-> 'rbar'192、rlike 同 regexp
193、roles_graphml()
返回utf8mb3字符串，其中包含表示内存角色子图的GraphML文档。要查看<graphml>元素中的内容，需要ROLE_ADMIN权限(或已弃用的超级权限)。否则，结果只会显示一个空元素:
mysql> SELECT ROLES_GRAPHML();
+---------------------------------------------------+
| ROLES_GRAPHML() |
+---------------------------------------------------+
| <?xml version="1.0" encoding="UTF-8"?><graphml /> |
+------------194、round(x),round(x,D)
将参数X舍入到D位小数。取整算法取决于x的数据类型。如果没有指定，D默认为0。D可以是负数，这使得X的小数点左边的D位变为0。D的绝对值最大值为30;超过30(或-30)的任何数字都被截断。如果X或D为NULL，函数返回NULL。
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
mysql> SELECT ROUND(.12345678901234567890123456789012345, 35);
-> 0.123456789012345678901234567890195、row_count()
ROW_COUNT()返回一个值:
DDL语句:0。这适用于CREATE TABLE或DROP TABLE之类的语句。
除SELECT之外的DML语句:受影响的行数。这适用于UPDATE、INSERT或DELETE之类的语句(和以前一样)，现在也适用于ALTER TABLE和LOAD DATA之类的语句。
如果语句返回结果集，则选择:-1;如果不返回，则选择“受影响”的行数。例如，对于SELECT * FROM t1, ROW_COUNT()返回-1。对于SELECT * FROM t1 INTO OUTFILE 'file_name'， ROW_COUNT()返回写入文件的行数。
信号语句:0。
对于UPDATE语句，默认情况下的affected-rows值是实际改变的行数。如果你在连接mysqld时给mysql_real_connect()指定了CLIENT_FOUND_ROWS标志，affected-rows值就是“found”的行数;也就是说，由WHERE子句匹配。
对于REPLACE语句，如果新行替换了旧行，则affected-rows值为2，因为在这种情况下，在删除重复的行之后插入了一行。
For INSERT…在重复的键更新语句中，如果该行作为新行插入，则每行的affected-rows值为1，如果已存在的行被更新，则为2，如果已存在的行被设置为当前值，则为0。如果指定了CLIENT_FOUND_ROWS标志，如果现有行设置为其当前值，则affected-rows值为1(不是0)。
ROW_COUNT()的值类似于mysql_affected_rows()的C API函数的值，以及mysql客户端在语句执行后显示的行计数。
mysql> INSERT INTO t VALUES(1),(2),(3);
Query OK, 3 rows affected (0.00 sec)
Records: 3 Duplicates: 0 Warnings: 0
mysql> SELECT ROW_COUNT();
+-------------+
| ROW_COUNT() |
+-------------+
| 3 |
+-------------+
1 row in set (0.00 sec)
mysql> DELETE FROM t WHERE i IN(1,2);
Query OK, 2 rows affected (0.00 sec)
mysql> SELECT ROW_COUNT();
+-------------+
| ROW_COUNT() |
+-------------+
| 2 |
+-------------+
1 row in set (0.00 sec)196、row_number() over()
返回其分区内的当前行编号。行号范围从1到分区行数。
ORDER BY影响行编号的顺序。如果没有ORDER BY，行编号是不确定的。
ROW_NUMBER()为节点分配不同的行号。要给节点分配相同的值，可以使用RANK()或DENSE_RANK()。
197、rpad(str,len,padstr)
返回字符串str，用字符串padstr右填充到长度为len的字符串。如果str比len长，返回值会缩短为len字符。如果str、padstr或len为NULL，则函数返回NULL。
mysql> SELECT RPAD('hi',5,'?');
-> 'hi???'
mysql> SELECT RPAD('hi',1,'?');
-> 'h'198、rtrim(str) 返回删除末尾空格字符的字符串str。
mysql> SELECT RTRIM('barbar ');
-> 'barbar'
882
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
