第十二章函数和操作符

目录

12.1功能及操作参考
12.2类型转换表达式求值
(3)运营商
12.3.1运算符的优先级
12.3.2比较函数和操作符
12.3.3逻辑运算符
12.3.4赋值运算符
12.4流程控制函数
12.5字符串函数
12.5.1字符串比较函数
12.5.2正则表达式
12.5.3字符集和功能结果的整理
12.6数值函数和操作符
12.6.1算术运算符
可以声明为任意类型的数学函数
12.7日期和时间函数
12.8什么是历用MySQL?
12.9全文搜索功能
12.9.1自然语言全文检索
12.9.2布尔全文搜索
12.9.3全文检索查询扩展
12.9.4全文构建
12.9.5全文限制
12.9.6微调MySQL全文搜索
12.9.7添加一个全文索引排序
12.9.8 Ngram全文解析
12.9.9 mecab全文解析插件
12.10铸造的函数和操作符
12.11 XML功能
12点函数和操作符
12.13加密和压缩功能
12.14信息函数
12.15空间分析功能
12.15.1空间函数参考
12.15.2参数空间功能处理
12.15.3函数创建几何值WKT值
12.15.4函数创建几何值从WKB近似值
12.15.5 MySQL特定的功能,创建几何值
12.15.6几何格式转换功能
12.15.7几何属性函数
12.15.8空间算子函数
12.15.9功能测试之间的几何对象的空间关系
12.15.10 Geohash函数空间
12.15.11 GeoJSON函数空间
12.15.12空间便利功能
12.16 JSON功能
12.16.1 JSON函数参考
12.16.2函数创建JSON值
12.16.3功能搜索JSON值
12.16.4函数修改JSON值
12.16.5函数返回JSON值属性
12.16.6 JSON表功能
12.16.7 JSON的实用功能
JSON的语法12.16.8路径
12.17函数使用全局事务ID。
12.18 MySQL企业加密功能
12.18.1企业加密装置
12.18.2企业加密使用的例子
12.18.3企业加密函数参考
12.18.4 Enterprise enCRIMENT Function Desence
12.19骨料(组)功能
12.19.1骨料(组)功能描述
12.19.2集团的编辑修改器
12.19.3 MySQL处理组
12.19.4检测功能的依赖
12.20窗函数
说明12.20.1 window function
12.20.2窗函数的概念和语法
12.20.3窗函数框架规范
12.20.4命名为Windows
12.20.5窗函数的限制
12.21内部功能
12.22多功能
12.23数学精度
12.23.1类型的数值
12.23.2小数数据类型特征
12.23.3表达处理
12.23.4舍入行为
12.23.5精密的数学例子

表达式可以使用的几个要点SQL陈述,如在ORDER BY条款SELECT报表,在哪里条款一SELECTDELETE,或UPDATE声明,或SET声明.表达式可以使用书面文字值,列的值,无效的,内置功能,存储功能,用户定义函数和操作符。本章介绍的函数和操作符,在MySQL编写表达式允许。写存储函数和用户定义的函数进行了说明23.2节,“使用存储子程序(过程和函数)”,和28.4节,“MySQL”添加新的功能。看到9.2.4节,“函数名称解析和解决”,用于描述服务器如何解释不同类型的函数的引用规则。

一个表达式,包含NULL总是产生无效的值,除非另有说明的文档中的一个特定的函数或运算符。

笔记

默认情况下,必须有一个函数名与括号之间没有空格后面。这有助于MySQL解析器区分表或列都作为一个函数的名称相同的函数调用和引用之间。然而,在函数的参数空间是允许的。

你可以告诉MySQL服务器接受空间在函数名后开始的--sql-mode=IGNORE_SPACE选项。(这第5.1.10,”服务器的SQL模式”。)个人客户程序可以要求这一行为的使用CLIENT_IGNORE_SPACE选项mysql_real_connect()。在任何情况下,所有的函数名称是保留字。

为了简单起见,在本章的例子显示从输出最MySQL缩写形式的程序。而不是在这个格式的例子:

mysql> SELECT MOD(29,9);
+-----------+
| mod(29,9) |
+-----------+
|         2 |
+-----------+
1 rows in set (0.00 sec)

这种格式是用来代替:

mysql> SELECT MOD(29,9);
        -> 2

12.1功能及操作参考

函数和运算符表12.1

姓名描述
ABS()收益的绝对值
ACOS()返回余弦
ADDDATE()添加时间值(区间)的一个日期值
ADDTIME()添加时间
AES_DECRYPT()利用AES解密
AES_ENCRYPT()使用AES加密
AND&逻辑和
ANY_VALUE()抑制only_full_group_by价值排斥
ASCII()返回最左边的字符的数字值
ASIN()回弧正弦
=指定一个值(的一部分SET声明的一部分,或配置条款中UPDATE声明)
:=指定一个值
ASYMMETRIC_DECRYPT()使用私人或公共密钥解密密文
ASYMMETRIC_DERIVE()得到对称密钥的非对称密钥
ASYMMETRIC_ENCRYPT()使用私人或公共密钥加密明文
ASYMMETRIC_SIGN()从消化生成签名
ASYMMETRIC_VERIFY()验证签名匹配消化
ATAN()返回的圆弧切线
ATAN2()atan()重复两个论点的弧探戈。
AVG()返回参数的平均值
BENCHMARK()重复执行一个表达式
BETWEEN ... AND ...检查是否有值的值的范围内
BIN()返回一个字符串包含一个数的二进制表示
BIN_TO_UUID()字符串转换成二进制的UUID
BINARY将一个字符串赋给一个二进制字符串
BIT_AND()回位,
BIT_COUNT()回位的设置数量
BIT_LENGTH()回位参数长度
BIT_OR()回位或
BIT_XOR()返回按位异或
&按位与
~Bitwise反演
|按位或
^按位异或
CAN_ACCESS_COLUMN()仅供内部使用
CAN_ACCESS_DATABASE()仅供内部使用
CAN_ACCESS_TABLE()仅供内部使用
CAN_ACCESS_VIEW()仅供内部使用
CASE运营商的情况下
CAST()铸造一个值作为某型
CEIL()返回的最小整数值不小于参数
CEILING()返回的最小整数值不小于参数
CHAR()返回各整数字符传递
CHAR_LENGTH()返回参数中的字符数
CHARACTER_LENGTH()char_length()的同义词
CHARSET()返回的参数特征
COALESCE()返回第一个非空参数
COERCIBILITY()返回的字符串参数的整理可压缩性价值
COLLATION()返回的字符串自变量collation of the
COMPRESS()作为一个二进制字符串返回结果
CONCAT()返回连接字符串
CONCAT_WS()返回连接与分离
CONNECTION_ID()返回连接ID(线程ID)的连接
CONV()将不同数量的碱基之间的数字
CONVERT()铸造一个值作为某型
CONVERT_TZ()从一个时区转换到另一个
COS()返回余弦
COT()返回的余切
COUNT()返回一个数,返回的行数
COUNT(DISTINCT)返回一个数的不同值的数量
CRC32()计算循环冗余校验值
CREATE_ASYMMETRIC_PRIV_KEY()创建私钥
CREATE_ASYMMETRIC_PUB_KEY()创建公钥
CREATE_DH_PARAMETERS()生成DH秘密共享
CREATE_DIGEST()从字符串生成文摘
CUME_DIST()累积分布值
CURDATE()返回当前的日期
CURRENT_DATE()current_date为curdate(同义词)
CURRENT_ROLE()返回当前的积极作用
CURRENT_TIME()current_timesynonyms为curtime()
CURRENT_TIMESTAMP()current_timestamp现在(同义词)
CURRENT_USER()current_user通过身份验证的用户名和主机名
CURTIME()返回当前时间
DATABASE()返回默认(当前)数据库名称
DATE()提取日期部分的日期或日期时间表达式
DATE_ADD()添加时间值(区间)的一个日期值
DATE_FORMAT()指定的日期格式
DATE_SUB()用一个时间值(区间)从一个日期
DATEDIFF()减去两日期
DAY()为dayofmonth(同义词)
DAYNAME()返回的名称为“weekday
DAYOFMONTH()月的一天返回(0~31)
DAYOFWEEK()return the优化参数指标of the
DAYOFYEAR()这一天是这一年的回报(1-366)
DECODE()解码字符串加密使用的encode()
DEFAULT()返回一个表的列的默认值
DEGREES()弧度转换为度
DENSE_RANK()在分区当前行秩,无间隙
DES_DECRYPT()解密字符串
DES_ENCRYPT()加密字符串
DIV整数除法
/除法运算符
ELT()返回字符串在指数
ENCODE()编码的字符串
ENCRYPT()加密字符串
=等于操作符
<=>空安全等于运算符
EXP()提高功率
EXPORT_SET()返回一个字符串,每一位的值位,你会得到一个字符串,每个设置点,你会得到一个字符串
EXTRACT()提取日期部分
ExtractValue()提取使用XPath表示的XML字符串的值
FIELD()收益的指标(位置)的第一个参数的后续题元
FIND_IN_SET()在第二个参数返回第一个参数的索引位置
FIRST_VALUE()从窗口第一行的参数值
FLOOR()回报的最大整数值不大于参数
FORMAT()返回一个数字格式到指定的小数位数
FOUND_ROWS()一个选择的限制条款,将返回的行数没有限制条款
FROM_BASE64()解码Base64编码的字符串并返回结果
FROM_DAYS()一天一日数转换
FROM_UNIXTIME()Unix时间戳为日期格式
GeomCollection()从几何构造几何集合
GeometryCollection()从几何构造几何集合
GET_DD_COLUMN_PRIVILEGES()仅供内部使用
GET_DD_CREATE_OPTIONS()仅供内部使用
GET_DD_INDEX_SUB_PART_LENGTH()仅供内部使用
GET_FORMAT()返回日期格式字符串
GET_LOCK()得到指定的锁
>大于运算符
>=大于或等于运算符
GREATEST()收益最大的争议
GROUP_CONCAT()返回一个连接字符串
GROUPING()区分超聚合汇总行常规行
GTID_SUBSET()如果所有gtids子集也将返回true;否则为false。
GTID_SUBTRACT()返回集合中的子集都不gtids。
HEX()返回一个十进制或十六进制表示的字符串值
HOUR()提取时间
ICU_VERSION()ICU库版本
IF()建设
IFNULL()建造
IN()检查某个值是否在设定值
INET_ATON()返回一个IP地址的数值
INET_NTOA()返回一个数值的IP地址
INET6_ATON()返回一个IPv6地址的数值
INET6_NTOA()返回一个数值的IPv6地址
INSERT()在指定的位置到指定数量的字符插入子串
INSTR()返回字符串的第一个匹配项的索引
INTERNAL_AUTO_INCREMENT()仅供内部使用
INTERNAL_AVG_ROW_LENGTH()仅供内部使用
INTERNAL_CHECK_TIME()仅供内部使用
INTERNAL_CHECKSUM()仅供内部使用
INTERNAL_DATA_FREE()仅供内部使用
INTERNAL_DATA_LENGTH()仅供内部使用
INTERNAL_DD_CHAR_LENGTH()仅供内部使用
INTERNAL_GET_COMMENT_OR_ERROR()仅供内部使用
INTERNAL_GET_VIEW_WARNING_OR_ERROR()仅供内部使用
INTERNAL_INDEX_COLUMN_CARDINALITY()仅供内部使用
INTERNAL_INDEX_LENGTH()仅供内部使用
INTERNAL_KEYS_DISABLED()仅供内部使用
INTERNAL_MAX_DATA_LENGTH()仅供内部使用
INTERNAL_TABLE_ROWS()仅供内部使用
INTERNAL_UPDATE_TIME()仅供内部使用
INTERVAL()返回的参数是小于第一个参数指标
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()测试这一论点是无效的。
JSON_ARRAY()创建JSON数组
JSON_ARRAY_APPEND()JSON文件追加数据
JSON_ARRAY_INSERT()插入JSON数组
JSON_ARRAYAGG()返回的结果集作为一个单一的JSON数组
->在评估路径返回JSON列值;相当于json_extract()。
JSON_CONTAINS()是否包含特定对象的JSON文档路径
JSON_CONTAINS_PATH()无论是JSON文件包含任何数据路径
JSON_DEPTH()JSON文档的最大深度
JSON_EXTRACT()从JSON文档返回数据
->>在评估路径和结束引语结果返回JSON列值;相当于json_unquote(json_extract())。
JSON_INSERT()将数据插入到JSON文档
JSON_KEYS()从JSON文件密钥数组
JSON_LENGTH()在JSON文档中的元素数
JSON_MERGE()(弃用8.0.3)合并的JSON文件,保存重复键。不json_merge_preserve()的同义词
JSON_MERGE_PATCH()合并的JSON文件,免去重复键的值
JSON_MERGE_PRESERVE()合并的JSON文件,保存重复键
JSON_OBJECT()创建JSON对象
JSON_OBJECTAGG()返回的结果集作为一个单一的JSON对象
JSON_PRETTY()版画在人类可读的格式JSON文档,每个数组元素或对象成员打印在新的行中,缩进两个空格就其母。
JSON_QUOTE()引用JSON文档
JSON_REMOVE()从JSON文件中删除数据
JSON_REPLACE()在JSON文件的值替换
JSON_SEARCH()在JSON文件价值路径
JSON_SET()将数据插入到JSON文档
JSON_STORAGE_FREE()释放的空间在一个JSON列值的二进制表示形式后,局部更新
JSON_STORAGE_SIZE()用于一个JSON文件的二进制表示形式存储空间;一个JSON柱,空间时使用的文档插入到任何部分更新之前,
JSON_TABLE()返回的数据从一个JSON表达关系表
JSON_TYPE()JSON值类型
JSON_UNQUOTE()JSON值而言
JSON_VALID()JSON值是否是有效的
LAG()价值的争论从行滞后电流排在分区
LAST_DAY为论证该月最后一天返回
LAST_INSERT_ID()value of the AutoIncrement列for the last插入
LAST_VALUE()从窗框上排参数值
LCASE()同义词(下)
LEAD()价值的争论从行领导目前行内的分区
LEAST()返回最小的论点
LEFT()为指定的返回字符左边的数
<<左移
LENGTH()返回字符串的字节长度
<小于操作符
<=小于或等于操作符
LIKE简单的模式匹配
LineString()构造线由点的值
LN()返回参数的自然对数
LOAD_FILE()加载指定的文件
LOCALTIME()当地时间现在(同义词)
LOCALTIMESTAMPlocaltimestamp()现在(同义词)
LOCATE()返回字符串中第一次出现的位置
LOG()返回第一个参数的自然对数
LOG10()返回参数10为底的对数
LOG2()返回参数的基-2对数
LOWER()在lowercase回报的论点
LPAD()返回的字符串参数,左填充指定的字符串
LTRIM()删除前导空格
MAKE_SET()返回一组用逗号分隔的字符串,在相应的点位设置
MAKEDATE()创建从今年一年的日期
MAKETIME()创建从小时,分钟,秒
MASTER_POS_WAIT()等到奴隶已经阅读并应用所有更新到指定位置
MATCH执行全文搜索
MAX()返回的最大值
MBRContains()是否一个几何包含MBR MBR的另一
MBRCoveredBy()是否有一个MBR是被另一个
MBRCovers()是否有一个MBR覆盖另一个
MBRDisjoint()无论两构型MBR是不相交的
MBREquals()无论两构型MBR是平等的
MBRIntersects()两构型MBR是否相交
MBROverlaps()无论两构型MBR重叠
MBRTouches()无论两构型MBR的触摸
MBRWithin()是否一个几何在MBR膜生物反应器的另一个
MD5()计算MD5 Checksum
MICROSECOND()返回参数的微秒
MID()返回一个字符串从指定位置
MIN()返回最小值
-减算子
MINUTE()返回参数分
MOD()返回余数
%国防部模运算符
MONTH()返回日期的一个月已经过去
MONTHNAME()返回的月份名称
MultiLineString()Contruct MultiLineString从线值
MultiPoint()构建多点价值
MultiPolygon()从多边形的价值观构建multipolygon
NAME_CONST()原因列有名字
NOT否定价值
NOT BETWEEN ... AND ...检查是否有价值不在值的范围
!=<>不等于操作符
NOT IN()检查是否有价值不在一组值
NOT LIKE简单的模式匹配的否定
NOT REGEXP否定的正则表达式
NOW()返回当前的日期和时间
NTH_VALUE()从第n排窗口框架的参数值
NTILE()在分区的当前行的桶数。
NULLIF()Return NULL if expr1 = expr2
OCT()返回一个字符串包含一个数字的八进制表示
OCTET_LENGTH()synonym for length()
||逻辑或
ORD()对于争论的最左边的字符返回字符编码
PASSWORD()计算并返回一个密码字符串
PERCENT_RANK()百分比排名的价值
PERIOD_ADD()加上一个期限至年月
PERIOD_DIFF()返回月之间的周期数
PI()返回圆周率的值
+加法运算符
Point()构建点坐标
Polygon()从线的参数构造多边形
POSITION()locate(同义词)
POW()返回参数的指定次幂
POWER()返回参数的指定次幂
QUARTER()从一季度的日期参数返回
QUOTE()逃避使用SQL语句中的参数
RADIANS()返回参数转换为弧度
RAND()返回一个随机浮点值
RANDOM_BYTES()返回一个字节随机向量
RANK()在分区的当前行的排名,与空白
REGEXP无论字符串匹配正则表达式
REGEXP_INSTR()启动子串匹配正则表达式索引
REGEXP_LIKE()无论字符串匹配正则表达式
REGEXP_REPLACE()替换匹配的子字符串的正则表达式
REGEXP_SUBSTR()返回子串匹配的正则表达式
RELEASE_ALL_LOCKS()释放所有的电流叫锁
RELEASE_LOCK()释放指定的锁
REPEAT()重复一个字符串指定的次数
REPLACE()替换指定的字符串的出现
REVERSE()在一个字符串反转的字符
RIGHT()返回指定的最右边的字符数
>>右移位
RLIKE无论字符串匹配正则表达式
ROLES_GRAPHML()返回表示内存的作用图GraphML文件
ROUND()一轮争论
ROW_COUNT()更新的行数
ROW_NUMBER()在分区的当前行数
RPAD()追加字符串指定的次数
RTRIM()删除尾随空格
SCHEMA()(数据库)的同义词
SEC_TO_TIME()将秒的HH:MM:SS的格式
SECOND()在第二个return(0~59)
SESSION_USER()user()的同义词
SHA1()sha()计算SHA-1校验和160位
SHA2()计算一个SHA-2校验
SIGN()返回的参数符号
SIN()返回自己的论点
SLEEP()睡一秒数
SOUNDEX()返回一个字符串模糊
SOUNDS LIKE比较的声音
SPACE()返回一个字符串的指定数量的空格
SQRT()返回参数的平方根
ST_Area()返回多边形或multipolygon地区
ST_AsBinary()_ aswkb(ST)从内部几何格式转换为WKB
ST_AsGeoJSON()从几何产生GeoJSON对象
ST_AsText()_ aswkt(ST)从内部几何格式转换为WKT
ST_Buffer()返回在给定的点的几何距离几何
ST_Buffer_Strategy()对于st_buffer()产生战略选择
ST_Centroid()返回的质心作为点
ST_Contains()是一种几何包含另一个
ST_ConvexHull()返回几何凸包
ST_Crosses()你是否一个几何
ST_Difference()两个几何返回点的差集
ST_Dimension()的几何尺寸
ST_Disjoint()是一种几何相交的另一个
ST_Distance()一个几何从另一个距离
ST_Distance_Sphere()地球上的两个几何体之间的最小距离
ST_EndPoint()线的终点
ST_Envelope()返回MBR几何
ST_Equals()是一种几何等于另一个
ST_ExteriorRing()返回多边形的外部环
ST_GeoHash()产生一个Geohash值
ST_GeomCollFromText()_ geometrycollectionfromtext(ST)ST_GeomCollFromTxt()返回几何集合从边门
ST_GeomCollFromWKB()_ geometrycollectionfromwkb(ST)返回几何集合从WKB
ST_GeometryN()返回n几何几何集合
ST_GeometryType()返回几何类型名称
ST_GeomFromGeoJSON()GeoJSON对象生成几何
ST_GeomFromText()_ geometryfromtext(ST)返回几何从边门
ST_GeomFromWKB()_ geometryfromwkb(ST)返回几何从WKB
ST_InteriorRingN()返回多边形n室内环
ST_Intersection()两个几何返回点交集
ST_Intersects()是一种几何相交另一个
ST_IsClosed()无论是封闭的简单几何
ST_IsEmpty()占位符的功能
ST_IsSimple()无论是简单的几何图形
ST_IsValid()一个几何是否是有效的
ST_LatFromGeoHash()返回从Geohash价值纬度
ST_Latitude()返回纬度点
ST_Length()回归线的长度
ST_LineFromText()_ linestringfromtext(ST)构造线从边门
ST_LineFromWKB()_ linestringfromwkb(ST)构造线由WKB
ST_LongFromGeoHash()返回从Geohash值经度
ST_Longitude()返回点的经度
ST_MakeEnvelope()大约两点矩形
ST_MLineFromText()st_multilinestringfromtext()从构建multilinestring WKT
ST_MLineFromWKB()st_multilinestringfromwkb()从构建multilinestring WKB
ST_MPointFromText()_ multipointfromtext(ST)构建多点从边门
ST_MPointFromWKB()_ multipointfromwkb(ST)构建多点从WKB
ST_MPolyFromText()_ multipolygonfromtext(ST)从构建multipolygon WKT
ST_MPolyFromWKB()_ multipolygonfromwkb(ST)从构建multipolygon WKB
ST_NumGeometries()返回集合数几何构型
ST_NumInteriorRing()_ numinteriorrings(ST)返回在多边形的内部环数
ST_NumPoints()返回点的数量,在LineString
ST_Overlaps()是一种几何重叠的另一个
ST_PointFromGeoHash()将Geohash值点价值
ST_PointFromText()从边门结构点
ST_PointFromWKB()从WKB结构点
ST_PointN()返回n点线
ST_PolyFromText()_ polygonfromtext(ST)从WKT构建多边形
ST_PolyFromWKB()_ polygonfromwkb(ST)从WKB构建多边形
ST_Simplify()返回简化几何
ST_SRID()返回几何空间参考系统ID
ST_StartPoint()起点线
ST_SwapXY()返回X / Y参数坐标交换
ST_SymDifference()返回点集的两个几何对称差
ST_Touches()另一个要用whether
ST_Transform()变换坐标几何
ST_Union()两个几何返回点集的并集
ST_Validate()返回验证几何
ST_Within()无论是在另一个几何
ST_X()返回x坐标点
ST_Y()回到Y坐标点
STATEMENT_DIGEST()计算语句消化的哈希值
STATEMENT_DIGEST_TEXT()计算标准化报表摘要
STD()返回的总体标准偏差
STDDEV()返回的总体标准偏差
STDDEV_POP()返回的总体标准偏差
STDDEV_SAMP()返回的样本标准偏差
STR_TO_DATE()将字符串转换为日期
STRCMP()比较两个字符串
SUBDATE()同义词date_sub()当调用三个参数
SUBSTR()指定返回的子字符串
SUBSTRING()指定返回的子字符串
SUBSTRING_INDEX()在指定数量的分隔符返回从字符串的子串出现
SUBTIME()减倍
SUM()收益之和
SYSDATE()返回时间的函数执行
SYSTEM_USER()user()的同义词
TAN()返回正切的论点
TIME()提取表达时间部分通过
TIME_FORMAT()时间格式为
TIME_TO_SEC()返回参数转换为秒
TIMEDIFF()减时间
*乘法算子
TIMESTAMP()一个参数,这个函数返回的日期或日期时间表达式;有两个论点,论据的总和
TIMESTAMPADD()添加一个间隔的日期的表达
TIMESTAMPDIFF()从一个DateTime表达区间
TO_BASE64()返回参数转换成Base-64字符串
TO_DAYS()返回日期参数转换为天
TO_SECONDS()返回日期或日期时间转换为秒0年以来争论
TRIM()删除前导和尾随空格
TRUNCATE()将指定的小数位数
UCASE()同义词(上)
-修改实参的标志
UNCOMPRESS()一个字符串的压缩解压缩
UNCOMPRESSED_LENGTH()压缩前返回一个字符串的长度
UNHEX()返回一个字符串包含一个数的进制表示
UNIX_TIMESTAMP()返回一个时间戳
UpdateXML()返回替换XML片段
UPPER()转换为大写
USER()客户端提供的用户名和主机名
UTC_DATE()返回当前的UTC日期
UTC_TIME()返回当前的UTC时间
UTC_TIMESTAMP()返回当前的UTC日期和时间
UUID()返回一个通用唯一标识符(UUID)
UUID_SHORT()返回一个整型值的通用标识符
UUID_TO_BIN()转换为二进制串UUID
VALIDATE_PASSWORD_STRENGTH()确定强度的密码
VALUES()将插入过程中使用的值
VAR_POP()返回的人口标准方差
VAR_SAMP()返回的样本方差
VARIANCE()返回的人口标准方差
VERSION()返回一个字符串,表示MySQL服务器版本
WAIT_FOR_EXECUTED_GTID_SET()等到了gtids执行奴隶。
WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS()等到了gtids执行奴隶。
WEEK()返回的周数
WEEKDAY()return the WeekDay指数
WEEKOFYEAR()日期的日历周回报(1-53)
WEIGHT_STRING()返回一个字符串的字符串的重
XOR逻辑异或
YEAR()回归年
YEARWEEK()回归年和星期

12.2类型转换表达式求值

当操作者使用不同类型的操作数,操作数的出现使兼容的类型转换。一些发生隐式转换。例如,MySQL会自动将数字转换为字符串,反之亦然。

mysql> SELECT 1+'1';
        -> 2
mysql> SELECT CONCAT(2,' test');
        -> '2 test'

也可以将数字转换为字符串显式使用CAST()功能。隐式转换发生的CONCAT()因为它将字符串参数的函数。

MySQL的&#62;SELECT 38.8, CAST(38.8 AS CHAR);-> 38.8, '38.8'mysql>SELECT 38.8, CONCAT(38.8);&#62; 38.8、38.8

看到有关的隐数字符串转换角色的这部分信息后,和修改后的规则适用于CREATE TABLE ... SELECT声明.

以下描述如何转换为比较运算规则:

  • 如果一个或两个参数NULL,比较的结果无效的,除了NULL安全<=>平等的比较运算符。为NULL <=> NULL,结果是真的。无需进行转换。

  • 如果在一个比较操作参数都是字符串,它们比较字符串。

  • 如果参数是整数,他们相比为整数。

  • 十六进制值被视为二进制字符串,如果没有比较多。

  • 如果一个参数是一个TIMESTAMPDATETIME柱和其他参数是一个常数,该常数转换为时间戳,再进行比较。这样做是为了有更多的ODBC友好。这不是争论了IN()。为了安全起见,总是使用完整的日期时间,日期或时间字符串做比较时。例如,为了达到最佳效果,使用时BETWEEN日期或时间值,使用CAST()显式转换为所需的数据类型的值。

    从一个表或表单行子查询是不被认为是一个常数。例如,如果子查询返回一个整数被比作DATETIME值,比较了两个整数。整数不转换为时间值。比较操作数为DATETIME值,使用CAST()显式转换中的价值DATETIME

  • 如果一个参数是一个十进制的值,比较依赖于其他参数。参数为十进制值,如果其他参数是一个小数或整数或浮点值比较,如果其他参数是一个浮点值。

  • 在所有其他情况下,参数是浮点数比较(真正的)。

有关转换的价值信息从一个时态类型到另一个,看第11.3.7,“日期和时间类型之间的转换

JSON值比较采用两水平的地方。比较的第一级是基于比较值的JSON类型。如果类型不同,比较的结果是唯一确定的类型具有更高的优先级。如果两值具有相同的JSON类型,第二级比较时使用特定类型的规则。对于JSON和非JSON值比较,非JSON值转换为JSON和值相比为JSON值。详情见比较和JSON值排序

下面的例子说明转换的字符串比较操作数:

mysql> SELECT 1 > '6x';
        -> 0
mysql> SELECT 7 > '6x';
        -> 1
mysql> SELECT 0 > 'x6';
        -> 0
mysql> SELECT 0 = 'x6';
        -> 1

对于一个数字串柱比较,MySQL无法使用索引的列来查找值快。如果str_col是一个字符串列的索引,索引不能当执行查找以下语句中使用:

SELECT * FROMtbl_name哪里str_col=1;

这是因为有许多不同的字符串可以转换为价值1,如“1”' 1',或1A是

比较使用浮点数(或转换为浮点数的值)是因为这样的数字是不精确的近似。这可能会导致出现不一致的结果:

mysql> SELECT '18015376320243458' = 18015376320243458;
        -> 1
mysql> SELECT '18015376320243459' = 18015376320243459;
        -> 0

这样的结果可能是因为值转换为浮点数,只有53位精度和受舍入:

mysql> SELECT '18015376320243459'+0.0;
        -> 1.8015376320243e+16

此外,从字符串转换浮点和整数浮点不一定发生同样的方式。整数可以通过CPU转换为浮点型,而字符串转换为数字的操作涉及浮点乘法数字。

显示的结果会有所不同,在不同的系统,可受影响的因素,如计算机体系结构和编译版本或优化水平。为了避免这种问题的方法之一是使用CAST()所以,价值是不能隐式转换为浮点数:

MySQL的&#62;SELECT CAST('18015376320243459' AS UNSIGNED) = 18015376320243459;-&#62; 1

关于浮点比较的更多信息,参见第b.5.4.8,“浮点数”的问题

该服务器包括dtoa图书馆,转换之间的字符串或改进的转换提供了基础DECIMAL值和近似值(FLOAT/DOUBLE号码:)

  • 跨平台的一致的转换结果,从而消除了,例如,Unix和Windows转换差异。

  • 准确的表示值的情况下,结果以前没有提供足够的精度,如IEEE极限值接近。

  • 转换数与最佳精度格式字符串。精度dtoa总是相同或优于标准C库函数。

因为转换产生的这种图书馆在某些情况下,不同的非—dtoa结果,在依靠以前的结果应用不兼容的可能性是存在的。例如,依赖于先前的转换具体准确的结果,应用程序可能需要调整以容纳额外的精度。

这个dtoa图书馆提供转换具有以下属性。D表示一个值与DECIMAL或字符串表示形式,并F代表本地二进制浮点数(IEEE)格式。

  • F-&#62;D转换完成最好的精度,还D因为这会产生短的字符串F当回读和舍入到最接近的值在本地二进制格式指定由IEEE。

  • D-&#62;F转换完成,F是最近的本地二进制数的十进制输入字符串D

这些属性意味着F-&#62;D-&#62;F除非是无损转换F-信息+inf,或。后者的值不支持因为SQL标准定义了他们的无效值FLOATDOUBLE

D-&#62;F-&#62;D转换为无损的充分条件是D采用15%或更少的位数,不规格化值,-信息+inf,或。在某些情况下,即使转换是无损的D有超过15位的精度,但情况并不总是这样。

对字符串的数字或时间值隐式转换产生的值有一个字符集和整理由character_set_connectioncollation_connection系统变量。(这些变量通常设置SET NAMES。有关连接字符集的信息,参见10.4节,“连接字符集和Collations”。)

这意味着,这样的转换结果在字符(非二进制字符串(一)CHARVARCHAR,或LONGTEXT值),除了在的情况下,连接字符集设置二元的。在这种情况下,转换的结果是一个二进制字符串(一个BINARYVARBINARY,或LONGBLOB值)

对于整数表达式,前面的言论表达评价应用不同的表达分配;例如,在一份声明中这样:

CREATE TABLE t SELECT integer_expr;

在这种情况下,从表达产生的列的表的类型INTBIGINT根据整数表达式的长度。如果表达式的最大长度不适合在INTBIGINT代替。长度是从max_length价值的SELECT欧洲的结果集(这第27.7.5,“C API的数据结构”)。这意味着你可以强制BIGINT而不是INT通过使用一个足够长的表达:

create table SELECT 000000000000000000000吨;

(3)运营商

表12.2运营商

姓名描述
AND&#38;逻辑和
=指定一个值(的一部分SET声明的一部分,或配置条款中UPDATE声明)
:=指定一个值
BETWEEN ... AND ...检查是否有值的值的范围内
BINARY将一个字符串赋给一个二进制字符串
&按位与
~Bitwise反演
|按位或
^按位异或
CASE运营商的情况下
DIV整数除法
/除法运算符
=等于操作符
<=>空安全等于运算符
>大于运算符
>=大于或等于运算符
IS测试对一个布尔值
IS NOT测试对一个布尔值
IS NOT NULL不为空值的试验方法
IS NULL空值测试
->在评估路径返回JSON列值;相当于json_extract()。
->>在评估路径和结束引语结果返回JSON列值;相当于json_unquote(json_extract())。
<<左移
<小于操作符
<=小于或等于操作符
LIKE简单的模式匹配
-减算子
%国防部模运算符
NOT否定价值
NOT BETWEEN ... AND ...检查是否有价值不在值的范围
!=<>不等于操作符
NOT LIKE简单的模式匹配的否定
NOT REGEXP否定的正则表达式
||逻辑或
+加法运算符
REGEXP无论字符串匹配正则表达式
>>右移位
RLIKE无论字符串匹配正则表达式
SOUNDS LIKE比较的声音
*乘法算子
-修改实参的标志
XOR逻辑异或

12.3.1运算符的优先级

运算符的优先级如下表所示,从最高优先级最低。运营商一起显示在一行有相同的优先级。

INTERVAL
BINARY, COLLATE
!
- (unary minus), ~ (unary bit inversion)
^
*, /, DIV, %, MOD
-, +
<<, >>
&
|
= (comparison), <=>, >=, >, <=, <, <>, !=, IS, LIKE, REGEXP, IN
BETWEEN, CASE, WHEN, THEN, ELSE
NOT
AND, &&
XOR
OR, ||
= (assignment), :=

的优先=取决于它是否是作为一个比较运算符(=)或赋值操作符(=)。当作为一个比较运算符,它具有相同的优先权<=>>=><=<<>!=ISLIKEREGEXP,和IN。当作为一个赋值运算符,它具有相同的优先权:=第13.7.5.1,”句法变量赋值”,和9.4节,“用户定义的变量,说明MySQL决定解读=应适用

那些发生在一个表达式具有相同优先级的运算符,评价收益从左到右,除作业评价右至左。

一些运营商的意义取决于SQL模式:

  • 默认情况下,||是一个逻辑OR算子。与PIPES_AS_CONCAT启用,||是字符串连接,中间有一个优先^和一元运算符

  • 默认情况下,!有一个比较高的优先级。与HIGH_NOT_PRECEDENCE启用,!have the same值优先。

看到第5.1.10,”服务器的SQL模式”

运算符的优先级决定表达的评价术语的秩序。重写此序组方面明确,使用括号。例如:

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

12.3.2比较函数和操作符

表12.3比较运算符

姓名描述
BETWEEN ... AND ...检查是否有值的值的范围内
COALESCE()返回第一个非空参数
=等于操作符
<=>空安全等于运算符
>大于运算符
>=大于或等于运算符
GREATEST()收益最大的争议
IN()检查某个值是否在设定值
INTERVAL()返回的参数是小于第一个参数指标
IS测试对一个布尔值
IS NOT测试对一个布尔值
IS NOT NULL不为空值的试验方法
IS NULL空值测试
ISNULL()测试这一论点是无效的。
LEAST()返回最小的论点
<小于操作符
<=小于或等于操作符
LIKE简单的模式匹配
NOT BETWEEN ... AND ...检查是否有价值不在值的范围
!=<>不等于操作符
NOT IN()检查是否有价值不在一组值
NOT LIKE简单的模式匹配的否定
STRCMP()比较两个字符串

在一个值的比较运算的结果1真的),0错误的),或NULL。这些工作对数字和字符串操作。字符串自动转换为数字和数字的字符串作为必要。

下列关系比较运算符可以用来不仅比标量操作数,但行数:

=  >  <  >=  <=  <>  !=

这些运营商的描述后在本部分详细介绍了他们是如何工作的行数。对于行比较行子查询上下文附加的例子,看第13.2.11.5,“行子”

在这一部分的返回值以外的其他一些功能1真的),0错误的),或NULLLEAST()GREATEST()有这种功能的例子;第二节,“表达评价类型转换”描述比较操作,这些和类似的功能决定了它们的返回值执行的规则。

笔记

在MySQL的以前的版本中,当评估一个表达式LEAST()greatest(),服务器试图猜测上下文中使用的功能,并以此要挟函数的参数为表达式的数据类型作为一个整体。例如,参数LEAST("11", "45", "2")进行评估和排序的字符串,那么这个表达式返回“11”。在MySQL 8.0.3,早些时候,当计算表达式LEAST("11", "45", "2") + 0,服务器转换参数为整数(整数0预期的结果除了)排序前,因此返回2。

MySQL 8.0.4开始,不再试图推断在这个服装中的服务器。相反,功能使用的论点提供了执行,执行一个或多个参数的数据类型的转换,如果他们不都是同一类型的。任何类型的强制转换表达式,利用返回值强制现在执行以下功能的执行。这意味着,在MySQL 8.0.4后来,LEAST("11", "45", "2") + 0评价“11”0以整数11。(错误# 83895,错误# 25123839)

将一个值用于比较目的的一个特定的类型,你可以使用CAST()功能。字符串值可以转换成不同的字符集使用CONVERT()。看到12.10节,“铸函数和操作符”

默认情况下,字符串比较不区分大小写,并使用当前字符集。默认值是utf8mb4

  • =

    平等:

    mysql> SELECT 1 = 0;
            -> 0
    mysql> SELECT '0' = 0;
            -> 1
    mysql> SELECT '0.0' = 0;
            -> 1
    mysql> SELECT '0.01' = 0;
            -> 0
    mysql> SELECT '.01' = 0.01;
            -> 1
    

    行比较,(a, b) = (x, y)也konizit到:

    (a = x) AND (b = y)
  • <=>

    NULL安全的平等。这个运算符执行相等的比较喜欢=运营商,但剧情而不是NULL如果这是operands无效的,和0而不是无效的如果一个操作数NULL

    这个<=>商相当于标准的SQL是没有区别的算子

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

    行比较,(a, b) <=> (x, y)就相当于:

    (a <=> x) AND (b <=> y)
  • <>!=

    不平等的:

    mysql> SELECT '.01' <> '0.01';
            -> 1
    mysql> SELECT .01 <> '0.01';
            -> 0
    mysql> SELECT 'zapp' <> 'zappp';
            -> 1
    

    行比较,(a, b) <> (x, y)(a, b) != (x, y)大:是等效

    (a <> x) OR (b <> y)
    
  • <=

    小于或等于:

    mysql> SELECT 0.1 <= 2;
            -> 1
    

    行比较,(a, b) <= (x, y)就相当于:

    (a < x) OR ((a = x) AND (b <= y))
  • <

    小于:

    mysql> SELECT 2 < 2;
            -> 0
    

    行比较,(a, b) < (x, y)就相当于:

    (a < x) OR ((a = x) AND (b < y))
  • >=

    大于或等于:

    mysql> SELECT 2 >= 2;
            -> 1
    

    行比较,(a, b) >= (x, y)就相当于:

    (a > x) OR ((a = x) AND (b >= y))
  • >

    大于:

    mysql> SELECT 2 > 2;
            -> 0
    

    行比较,(a, b) > (x, y)就相当于:

    (a > x) OR ((a = x) AND (b > y))
  • IS boolean_value

    试验对一个布尔值,其中boolean_value可以是真的FALSE,或未知

    mysql> SELECT 1 IS TRUE, 0 IS FALSE, NULL IS UNKNOWN;
            -> 1, 1, 1
    
  • IS NOT boolean_value

    试验对一个布尔值,其中boolean_value可以是真的FALSE,或未知

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

    测试值是否是NULL

    MySQL的&#62;SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL;&#62; 0, 0, 1

    与ODBC程序工作,MySQL支持下列额外的功能,使用时IS NULL

  • IS NOT NULL

    测试值是否不NULL

    MySQL的&#62;SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;&#62; 1, 1, 0
  • expr BETWEEN min AND max

    如果expr大于或等于minexpr小于或等于maxBETWEEN退货,否则返回0。这相当于表达min<=exprexpr<=max如果所有的参数都是同一类型的。其他类型转换发生根据描述规则第二节,“表达评价类型转换”,但适用于所有的三个参数。

    mysql> SELECT 2 BETWEEN 1 AND 3, 2 BETWEEN 3 and 1;
            -> 1, 0
    mysql> SELECT 1 BETWEEN 2 AND 3;
            -> 0
    mysql> SELECT 'b' BETWEEN 'a' AND 'c';
            -> 1
    mysql> SELECT 2 BETWEEN 2 AND '3';
            -> 1
    mysql> SELECT 2 BETWEEN 2 AND 'x-3';
            -> 0
    

    最好的结果是使用时BETWEEN日期或时间值,使用CAST()显式转换为所需的数据类型的值。例子:如果你比较DATETIMEDATE值,转换DATE价值观DATETIME价值观。如果你使用一个字符串常量,如“2001-1-1”在比较了DATE,把字符串DATE

  • expr NOT BETWEEN min AND max

    这是一样的NOT (expr BETWEEN min AND max)

  • COALESCE(value,...)

    返回第一个非—NULL列表中的值,或无效的if there are不是NULL价值观

    返回类型COALESCE()是总的类型参数的类型。

    MySQL的&#62;SELECT COALESCE(NULL,1);-> 1mysql>SELECT COALESCE(NULL,NULL,NULL);>0
  • GREATEST(value1,value2,...)

    两个或两个以上的参数,返回的最大(最大值)参数。参数相比,使用相同的规则为LEAST()

    MySQL的&#62;SELECT GREATEST(2,0);-> 2mysql>SELECT GREATEST(34.0,3.0,5.0,767.0);-> 767.0mysql>SELECT GREATEST('B','A','C');→C

    GREATEST()退货无效的如果任一参数为NULL

  • expr IN (value,...)

    退货1如果expr等于你的价值的进入表,否则返回0。如果所有的值都是常数,它们是根据类型的评价expr和排序。该项搜索则是使用二进制搜索。这意味着进入很快,如果IN值列表完全由常数。否则,类型转换发生根据描述规则第二节,“表达评价类型转换”,但应用到所有的观点。

    mysql> SELECT 2 IN (0,3,5,7);
            -> 0
    mysql> SELECT 'wefwf' IN ('wee','wefwf','weg');
            -> 1
    

    IN可用于比较行构造函数:

    MySQL的&#62;SELECT (3,4) IN ((1,2), (3,4));-> 1mysql>SELECT (3,4) IN ((1,2), (3,5));&#62; 0

    你不应该把报价及无价值的IN因为引用列表值的比较规则(如字符串)和不带引号的值(如数字)不同。混合类型,因此可能导致不一致的结果。例如,不要写进入这样的表达:

    SELECT val1 FROM tbl1 WHERE val1 IN (1,2,'a');
    

    相反,这样写:

    SELECT val1 FROM tbl1 WHERE val1 IN ('1','2','a');
    

    在值的数目IN列表仅仅是有限的max_allowed_packet价值

    符合SQL标准,IN退货无效的如果左边的表达式NULL如果没有匹配,而且在列表中找到一个列表中的表达式无效的

    IN()语法也可以用来写某些类型的子查询。看到第13.2.11.3,“子查询任何,,或一些”

  • expr NOT IN (value,...)

    这是一样的NOT (expr IN (value,...))

  • ISNULL(expr)

    如果expr无效的ISNULL()退货,否则返回0

    MySQL的&#62;SELECT ISNULL(1+1);-> 0mysql>SELECT ISNULL(1/0);-&#62; 1

    ISNULL()可以用来代替=检查某个值是否无效的。(比较值NULL使用=总收益率无效的。)

    这个ISNULL()有一些特殊的行为功能IS NULL比较运算符。看到的描述IS NULL

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

    退货0如果N<N1如果N<N2等或- 1如果N无效的。所有的参数被视为整数。这是必需的,N1<N2<N3<<Nn此功能的正确工作。这是因为使用二进制搜索(很快)。

    MySQL的&#62;SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200);-> 3mysql>SELECT INTERVAL(10, 1, 10, 100, 1000);-> 2mysql>SELECT INTERVAL(22, 23, 30, 44, 200);&#62; 0
  • LEAST(value1,value2,...)

    两个或两个以上的参数,返回最小(最小值)参数。参数比较采用以下规则:

    • 如果任一参数为NULL,结果是无效的。没有比较是必要的

    • 如果所有的参数都是整数,他们相比为整数。

    • 如果至少有一个说法是双精度的,他们作为双精度值比较。否则,如果至少有一个参数是一个DECIMAL价值,他们比较DECIMAL价值观

    • 如果参数包括一个组合的数字和字符串,他们相比为数。

    • 如果参数是一个字符串,二进制(字符)的参数为非二进制字符串比较。

    • 在所有其他情况下,参数为二进制字符串比较。

    返回类型LEAST()是聚集型的比较参数类型。

    MySQL的&#62;SELECT LEAST(2,0);-> 0mysql>SELECT LEAST(34.0,3.0,5.0,767.0);-> 3.0mysql>SELECT LEAST('B','A','C');- &#62;“A”

12.3.3逻辑运算符

表4逻辑运算符

姓名描述
AND&#38;逻辑和
NOT否定价值
||逻辑或
XOR逻辑异或

在SQL中,所有的逻辑运算符的评价TRUE错误的,或NULL未知)。在MySQL数据库中,这些都是实现为1(TRUE)、0(错误的),和NULL。这其中大部分是不同的SQL数据库服务器,虽然一些服务器可能返回任何非零的值真的

MySQL对任何非零、非—NULL价值真的。例如,下面的语句的所有评估TRUE

MySQL的&#62;SELECT 10 IS TRUE;-> 1mysql>SELECT -10 IS TRUE;-> 1mysql>SELECT 'string' IS NOT NULL;-&#62; 1
  • NOT!

    逻辑非。评价1如果操作数是,以0如果操作数是非零的,和不为空退货NULL

    MySQL的&#62;SELECT NOT 10;-> 0mysql>SELECT NOT 0;-> 1mysql>SELECT NOT NULL;-> NULLmysql>SELECT ! (1+1);-> 0mysql>SELECT ! 1+1;-&#62; 1

    最后一个例子产生1因为表达式一样(!一)1.

  • AND&&

    逻辑和。评价1如果所有的操作数都是零,不无效的,以0如果一个或多个操作数,否则NULL返回

    MySQL的&#62;SELECT 1 AND 1;-> 1mysql>SELECT 1 AND 0;-> 0mysql>SELECT 1 AND NULL;-> NULLmysql>SELECT 0 AND NULL;-> 0mysql>SELECT NULL AND 0;&#62; 0
  • OR||

    逻辑或。当操作数是非—NULL,结果是如果操作数是非零的,和0否则。用一个无效的操作数,其结果是1if the other is布尔操作数为零,无效的另有。如果都是operandsNULL,结果是无效的

    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;
            -> 1
    
  • XOR

    逻辑异或。退货NULL如果一个操作数是无效的。。。。。。。非NULL操作数,计算如果操作数是奇数为非零值,否则0返回

    MySQL的&#62;SELECT 1 XOR 1;-> 0mysql>SELECT 1 XOR 0;-> 1mysql>SELECT 1 XOR NULL;-> NULLmysql>SELECT 1 XOR 1 XOR 1;-&#62; 1

    a XOR b在数学上是相等的(A、(不))或((不是)和B)

12.3.4赋值运算符

表12.5赋值运算符

姓名描述
=指定一个值(的一部分SET声明的一部分,或配置条款中UPDATE声明)
:=指定一个值

  • :=

    赋值操作符。使操作者的左手边的用户变量以价值的权利。右边的值可以是一个文本值,另一个变量存储一个值,或任何法律的表达,产生一个标量值,包括一个查询的结果(如果这个值是一个标量值)。你可以在相同的执行多个任务SET声明。你可以在同一语句中执行多个任务。

    不像=,的:=运营商是不会解释为比较运算符。这意味着你可以使用:=在任何有效的SQL语句(不只是在SET语句)来给变量赋值

    MySQL的&#62;SELECT @var1, @var2;-> NULL, NULLmysql>SELECT @var1 := 1, @var2;-> 1, NULLmysql>SELECT @var1, @var2;-> 1, NULLmysql>SELECT @var1, @var2 := @var1;-> 1, 1mysql>SELECT @var1, @var2;-> 1, 1mysql>SELECT @var1:=COUNT(*) FROM t1;-> 4mysql>SELECT @var1;-&#62;四

    你可以使用价值分配:=在其他报表之外SELECT,如UPDATE,如下所示:

    MySQL的&#62;SELECT @var1;-> 4mysql>SELECT * FROM t1;-> 1, 3, 5, 7mysql>UPDATE t1 SET c1 = 2 WHERE c1 = @var1:= 1;查询行,1行的影响(0秒)的行匹配:1改变:1警告:0mysql &#62;SELECT @var1;-> 1mysql>SELECT * FROM t1;&#62; 2, 3, 5、7

    同时它也是可能的设置和读取同一变量的值在一个SQL语句的使用:=运营商,这是不推荐的。9.4节,“用户定义的变量,解释了为什么你应该避免这样做。

  • =

    该运算符用于在两例进行赋值,在接下来的两个段落描述。

    在一个SET声明,=作为一个赋值运算符,导致用户变量对运算符的左边走上价值的权利。(换句话说,当使用一个SET声明,=是一样的:=。)在右边的值可以是一个文本值,另一个变量存储一个值,或任何法律的表达,产生一个标量值,包括一个查询的结果(如果这个值是一个标量值)。你可以在相同的执行多个任务SET声明

    SET条款一UPDATE声明,=也作为一个赋值运算符;然而在这种情况下,它使栏目在运算符的左边承担给予权利的价值,提供任何WHERE一部分的条件UPDATE满足。你可以在相同的多任务配置条款一UPDATE声明

    在任何其他情况下,=作为一个比较运算符

    mysql> SELECT @var1, @var2;
            -> NULL, NULL
    mysql> SELECT @var1 := 1, @var2;
            -> 1, NULL
    mysql> SELECT @var1, @var2;
            -> 1, NULL
    mysql> SELECT @var1, @var2 := @var1;
            -> 1, 1
    mysql> SELECT @var1, @var2;
            -> 1, 1
    

    有关更多信息,参见第13.7.5.1,”句法变量赋值”第13.2.12,“更新语法”,和13.2.11”查询语法”部分。

12.4流程控制函数

表12.流量控制操作

姓名描述
CASE运营商的情况下
IF()建设
IFNULL()建造
NULLIF()Return NULL if expr1 = expr2

  • CASE value WHEN [compare_value] THEN result [WHEN [compare_value] THEN result ...] [ELSE result] END

    CASE WHEN [condition] THEN result [WHEN [condition] THEN result ...] [ELSE result] END

    第一CASE语法返回result对于第一value=compare_value比较,是真的。第二语法返回的第一个条件是真正的结果。如果没有比较或条件是真的,之后的结果其他的返回,或NULL如果没有其他的部分

    笔记

    的语法CASE表达这里描述的略有不同,SQLCASE陈述描述第13.6.5.1“案例研究语法”,使用内部存储的程序。这个CASE语句不能有其他的空条款,并终止END CASE而不是结束

    在返回类型ACASE表达式的结果为聚集型的所有值:

    • 如果所有的类型都是数值型,聚合型也是数字:

      • 如果至少有一个说法是双精度,结果是双精度。

      • 否则,如果至少有一个说法是DECIMAL,结果是DECIMAL

      • 否则,其结果是一个整数类型(有一个例外):

        • 如果所有的整数类型都是有符号或无符号的,结果是相同的标志和精度最高的所有指定的整数类型(即,TINYINTSMALLINTMEDIUMINTINT,或BIGINT

        • 如果有符号和无符号整数类型的组合,其结果是签署和精度可能更高。例如,如果类型符号INT和符号INT,结果是签署BIGINT

        • 唯一的例外是符号BIGINT结合有符号整数类型。其结果是DECIMAL以足够的精度和规模0。

    • 如果所有的类型BIT,结果是BIT。否则,BIT参数的处理是类似的BIGINT

    • 如果所有的类型YEAR,结果是YEAR。否则,参数的处理是类似的INT

    • 如果所有的类型是字符串(CHARVARCHAR结果是,美国)VARCHAR最大长度的操作数最长的字符长度的确定。

    • 如果所有的类型是字符或二进制字符串,结果是VARBINARY

    • SETENUM处理类似VARCHAR;结果是VARCHAR

    • 如果所有的类型JSON,结果是JSON

    • 如果所有类型的时间,结果是时间:

    • 如果所有的类型GEOMETRY,结果是几何

    • 如果任何类型BLOB,结果是BLOB

    • 对于所有其他类型的组合,其结果是VARCHAR

    • 字面意义的NULL操作数的类型聚集忽视。

    MySQL的&#62;SELECT CASE 1 WHEN 1 THEN 'one'-&#62;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'-&#62;WHEN 'a' THEN 1 WHEN 'b' THEN 2 END;>0
  • IF(expr1,expr2,expr3)

    如果expr1真的expr1 <> 0expr1<> NULL),IF()退货expr2。。。。。。。否则,它返回expr3

    笔记

    也有一个IF陈述这是什么?IF()功能这里描述的。看到第13.6.5.2,“如果语法”

    如果只有一个expr2expr3是明确的无效的《result type of theIF()函数是非类型—无效的表达

    默认的返回类型IF()(可能的事当它被存储到一个临时表)计算如下:

    • 如果expr2expr3产生一个字符串,其结果是一个字符串。

      如果expr2expr3均为字符串,如果字符串是大小写敏感的结果是敏感的。

    • 如果expr2expr3产生一个浮点值,结果是一个浮点值。

    • 如果expr2expr3产生一个整数,结果是一个整数。

    MySQL的&#62;SELECT IF(1>2,2,3);-> 3mysql>SELECT IF(1<2,'yes','no');-> 'yes'mysql>SELECT IF(STRCMP('test','test1'),'no','yes');→不
  • IFNULL(expr1,expr2)

    如果expr1是不是无效的IFNULL()退货expr1否则,它时返回;expr2

    MySQL的&#62;SELECT IFNULL(1,0);-> 1mysql>SELECT IFNULL(NULL,10);-> 10mysql>SELECT IFNULL(1/0,10);-> 10mysql>SELECT IFNULL(1/0,'yes');- &#62;“是”

    默认的返回类型IFNULL(expr1,expr2)更多的是综合这两个表达式的顺序STRING真实,或INTEGER。考虑基于表达式表的情况下或在MySQL必须在内部存储返回值IFNULL()在一个临时表:

    MySQL的&#62;CREATE TABLE tmp SELECT IFNULL(1,'test') AS test;MySQL的&#62;DESCRIBE tmp;------- -------------- ------ ----- --------- ------- |场|型|空|关键|默认|额外| ------- -------------- ------ ----- --------- ------- |测试| varbinary(4)|没有| | | | ------- -------------- ------ ----- --------- -------

    In this example,the type of thetestVARBINARY(4)(柱型)

  • NULLIF(expr1,expr2)

    退货NULL如果expr1=expr2是真的,否则返回expr1。这是一样的CASE WHEN expr1 = expr2 THEN NULL ELSE expr1 END

    返回值的类型作为第一个参数相同。

    mysql> SELECT NULLIF(1,1);
            -> NULL
    mysql> SELECT NULLIF(1,2);
            -> 1
    
    笔记

    MySQL的评价expr1如果参数不相等的两倍。

12.5字符串函数

表12.7字符串运算符

姓名描述
ASCII()返回最左边的字符的数字值
BIN()返回一个字符串包含一个数的二进制表示
BIT_LENGTH()回位参数长度
CHAR()返回各整数字符传递
CHAR_LENGTH()返回参数中的字符数
CHARACTER_LENGTH()char_length()的同义词
CONCAT()返回连接字符串
CONCAT_WS()返回连接与分离
ELT()返回字符串在指数
EXPORT_SET()返回一个字符串,每一位的值位,你会得到一个字符串,每个设置点,你会得到一个字符串
FIELD()收益的指标(位置)的第一个参数的后续题元
FIND_IN_SET()在第二个参数返回第一个参数的索引位置
FORMAT()返回一个数字格式到指定的小数位数
FROM_BASE64()解码Base64编码的字符串并返回结果
HEX()返回一个十进制或十六进制表示的字符串值
INSERT()在指定的位置到指定数量的字符插入子串
INSTR()返回字符串的第一个匹配项的索引
LCASE()同义词(下)
LEFT()为指定的返回字符左边的数
LENGTH()返回字符串的字节长度
LIKE简单的模式匹配
LOAD_FILE()加载指定的文件
LOCATE()返回字符串中第一次出现的位置
LOWER()在lowercase回报的论点
LPAD()返回的字符串参数,左填充指定的字符串
LTRIM()删除前导空格
MAKE_SET()返回一组用逗号分隔的字符串,在相应的点位设置
MATCH执行全文搜索
MID()返回一个字符串从指定位置
NOT LIKE简单的模式匹配的否定
NOT REGEXP否定的正则表达式
OCT()返回一个字符串包含一个数字的八进制表示
OCTET_LENGTH()synonym for length()
ORD()对于争论的最左边的字符返回字符编码
POSITION()locate(同义词)
QUOTE()逃避使用SQL语句中的参数
REGEXP无论字符串匹配正则表达式
REGEXP_INSTR()启动子串匹配正则表达式索引
REGEXP_LIKE()无论字符串匹配正则表达式
REGEXP_REPLACE()替换匹配的子字符串的正则表达式
REGEXP_SUBSTR()返回子串匹配的正则表达式
REPEAT()重复一个字符串指定的次数
REPLACE()替换指定的字符串的出现
REVERSE()在一个字符串反转的字符
RIGHT()返回指定的最右边的字符数
RLIKE无论字符串匹配正则表达式
RPAD()追加字符串指定的次数
RTRIM()删除尾随空格
SOUNDEX()返回一个字符串模糊
SOUNDS LIKE比较的声音
SPACE()返回一个字符串的指定数量的空格
STRCMP()比较两个字符串
SUBSTR()指定返回的子字符串
SUBSTRING()指定返回的子字符串
SUBSTRING_INDEX()在指定数量的分隔符返回从字符串的子串出现
TO_BASE64()返回参数转换成Base-64字符串
TRIM()删除前导和尾随空格
UCASE()同义词(上)
UNHEX()返回一个字符串包含一个数的进制表示
UPPER()转换为大写
WEIGHT_STRING()返回一个字符串的字符串的重

函数返回字符串值NULL如果结果的长度会大于该值max_allowed_packet系统变量。See第5.1.1条,“配置服务器”

功能操作字符串的位置,第一个位置编号。

功能,以长度参数,非整数参数舍入到最近的整数。

  • ASCII(str)

    返回字符串最左边的字符的数值str。退货如果str为空字符串。退货无效的如果str无效的ASCII()8位字的作品

    MySQL的&#62;SELECT ASCII('2');-> 50mysql>SELECT ASCII(2);-> 50mysql>SELECT ASCII('dx');-&#62;百

    又见ORD()功能

  • BIN(N)

    返回的二进制值的字符串表示形式N,在那里N是龙龙(BIGINT)数。这相当于CONV(N,10,2)。退货无效的如果N无效的

    mysql> SELECT BIN(12);
            -> '1100'
    
  • BIT_LENGTH(str)

    返回字符串的长度str在比特

    MySQL的&#62;SELECT BIT_LENGTH('text');&#62; 32
  • CHAR(N,... [USING charset_name])

    CHAR()解释每个参数N作为一个整数并返回一个包含的字符的整数编码值给定的字符串。无效的价值观是跳过

    mysql> SELECT CHAR(77,121,83,81,'76');
            -> 'MySQL'
    mysql> SELECT CHAR(77,77.3,'77.3');
            -> 'MMM'
    

    CHAR()参数大于255转换成多个结果字节。例如,CHAR(256)相当于CHAR(1,0),和CHAR(256*256)相当于CHAR(1,0,0)

    MySQL的&#62;SELECT HEX(CHAR(1,0)), HEX(CHAR(256));---------------- ---------------- |进制(char(1,0))|进制(char(256))| ---------------- ---------------- | 0100 | 0100 | ---------------- ---------------- MySQL &#62;SELECT HEX(CHAR(1,0,0)), HEX(CHAR(256*256));------------------ -------------------- |进制(char(1,0,0))|进制(char(256×256))| ------------------ -------------------- | 010000 | 010000 | ------------------ --------------------

    默认情况下,CHAR()返回一个字符串。产生在一个给定的字符集的字符串,使用可选的使用条款:

    mysql> SELECT CHARSET(CHAR(X'65')), CHARSET(CHAR(X'65' USING utf8));
    +----------------------+---------------------------------+
    | CHARSET(CHAR(X'65')) | CHARSET(CHAR(X'65' USING utf8)) |
    +----------------------+---------------------------------+
    | binary               | utf8                            |
    +----------------------+---------------------------------+
    

    如果USING给出了对于给定的字符集的结果字符串是非法的,发出警告。另外,如果严格的SQL模式被启用,结果从CHAR()成为无效的

  • CHAR_LENGTH(str)

    返回字符串的长度str,测量的特点。多字节字符计数作为一个字符。这意味着一个包含5个字节的字符,LENGTH()退货,而CHAR_LENGTH()退货

  • CHARACTER_LENGTH(str)

    CHARACTER_LENGTH()是同义词CHAR_LENGTH()

  • CONCAT(str1,str2,...)

    返回字符串的连接参数,结果。可能有一个或多个参数。如果所有的参数都是二进制字符串,其结果是一个二进制字符串。如果参数包括任何二进制字符串,结果是一个二进制字符串。数值参数转换为等价的二进制字符串形式。

    CONCAT()退货无效的如果任一参数为NULL

    MySQL的&#62;SELECT CONCAT('My', 'S', 'QL');-> 'MySQL'mysql>SELECT CONCAT('My', NULL, 'QL');-> NULLmysql>SELECT CONCAT(14.3);&#62; 14.3

    为带引号的字符串,字符串连接可以通过放置一起进行:

    mysql> SELECT 'My' 'S' 'QL';
            -> 'MySQL'
    
  • CONCAT_WS(separator,str1,str2,...)

    CONCAT_WS()代表将与分离器是一种特殊的形式CONCAT()。第一个参数是剩下的参数分隔符。分离器之间添加字符串串联。分隔符可以是一个字符串,可以剩下的参数。如果分离器无效的,结果是NULL

    MySQL的&#62;SELECT CONCAT_WS(',','First name','Second name','Last Name');-> 'First name,Second name,Last Name'mysql>SELECT CONCAT_WS(',','First name',NULL,'Last Name');- &#62;“名字,姓氏”

    CONCAT_WS()不跳过空字符串。然而,它跳过无效的值参数后分离器

  • ELT(N,str1,str2,str3,...)

    ELT()返回N的字符串列表元素:str1如果N=str2如果N=,等等。退货NULL如果N小于以上参数的数目ELT()是补充FIELD()

    MySQL的&#62;SELECT ELT(1, 'Aa', 'Bb', 'Cc', 'Dd');-> 'Aa'mysql>SELECT ELT(4, 'Aa', 'Bb', 'Cc', 'Dd');-对不起
  • EXPORT_SET(bits,on,off[,separator[,number_of_bits]])

    返回一个字符串,每一位的值bits,你会得到一个on字符串和每一点不是固定的值,你会得到一个off字符串位bits分别从右到左(从低阶到高阶位)。字符串从左到右添加到结果,相隔separator字符串(默认是逗号字符)。位检查的次数是由number_of_bits它有一个默认的64,如果没有指定。number_of_bits默默地夹在64如果大于64。它被视为一个无符号整数,那么一个价值1?有效同为64。

    MySQL的&#62;SELECT EXPORT_SET(5,'Y','N',',',4);-> 'Y,N,Y,N'mysql>SELECT EXPORT_SET(6,'1','0',',',10);- &#62;“0,1,1,0,0,0,0,0,0,0”
  • FIELD(str,str1,str2,str3,...)

    时返回的指标(的位置)strstr1str2str3列表退货0如果str没有找到

    如果所有参数FIELD()是字符串,所有参数均为字符串的比较。如果所有的参数都是数字,他们相比为数。否则,参数相比,双。

    如果str无效的,返回值是0因为无效的没有任何价值相等比较。FIELD()是补充ELT()

    MySQL的&#62;SELECT FIELD('Bb', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');-> 2mysql>SELECT FIELD('Gg', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');&#62; 0
  • FIND_IN_SET(str,strlist)

    返回一个范围在1到价值N如果字符串str在字符串列表strlist组成的N子串。一个字符串列表是一个由分隔的字符串的子串人物如果第一个参数是一个字符串常量,二是柱型SET,的FIND_IN_SET()功能优化,使用位运算。退货如果str不在strlist或者如果strlist为空字符串。退货无效的如果任一参数NULL。这个函数不如果第一个参数包含一个逗号(正常工作)字符

    mysql> SELECT FIND_IN_SET('b','a,b,c,d');
            -> 2
    
  • FORMAT(X,D[,locale])

    格式的数量X一个格式如“#,# # #,# # # # #”。,圆D小数,并以字符串的形式返回结果。如果D,结果没有小数点,小数部分。

    可选的三参数使现场被指定用于结果数的小数点,千位分隔符和分组之间的分隔符。允许设置值为法律价值观相同lc_time_names系统变量(参见10.15节,“MySQL服务器的区域设置的支持”)。如果没有现场指定,默认的是'en_US'

    MySQL的&#62;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');- &#62;“12.332,20”
  • FROM_BASE64(str)

    作为一个具有Base-64编码字符串编码所使用的规则TO_BASE64()作为一个二进制字符串返回解码后的结果。其结果是无效的如果参数是NULL或者不是一个有效的Base-64字符串。看到的描述TO_BASE64()关于编码和解码规则细节。

    MySQL的&#62;SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));我是ABC jwjj &#62;,是
  • HEX(str)HEX(N)

    如果该字符串参数strHEX()返回一个十六进制字符串表示str在每个字节中每个字符str转换为十六进制数字。(多字节字符因此成为超过两位数。)此操作的逆由UNHEX()功能

    for a值参数NHEX()返回值是一个十六进制字符串表示形式N作为一个龙龙(BIGINT)数。这相当于CONV(N,10,16)。此操作的逆进行CONV(HEX(N),16,10)

    MySQL的&#62;SELECT X'616263', HEX('abc'), UNHEX(HEX('abc'));-> 'abc', 616263, 'abc'mysql>SELECT HEX(255), CONV(HEX(255),16,10);→是FF,255
  • INSERT(str,pos,len,newstr)

    返回字符串str与子串的开始位置,poslen字符的字符串替换newstr。返回原字符串如果pos是不是该字符串的长度内。取代位置的字符串的其余部分pos如果len是不是剩下的字符串的长度内。退货无效的如果任何参数NULL

    MySQL的&#62;SELECT INSERT('Quadratic', 3, 4, 'What');-> 'QuWhattic'mysql>SELECT INSERT('Quadratic', -1, 4, 'What');-> 'Quadratic'mysql>SELECT INSERT('Quadratic', 3, 100, 'What');- &#62;“quwhat”

    这个功能是多字节的安全。

  • INSTR(str,substr)

    返回字符串中第一次出现的位置substr在字符串str。这是由于两参数形式相同LOCATE(),除了参数的顺序是相反的。

    MySQL的&#62;SELECT INSTR('foobarbar', 'bar');-> 4mysql>SELECT INSTR('xbar', 'foobar');&#62; 0

    这个功能是多字节的安全,和大小仅当至少有一个参数是一个字符串。

  • LCASE(str)

    LCASE()是同义词LOWER()

    LCASE()使用一个视图重写为罗尔当存储视图的定义。(错误# 12844279)

  • LEFT(str,len)

    剧情的最左边的len从字符串中的字符str,或无效的如果任一参数为NULL

    MySQL的&#62;SELECT LEFT('foobarbar', 5);fooba’-&#62;’

    这个功能是多字节的安全。

  • LENGTH(str)

    返回字符串的长度str以字节为单位,测量。多字节字符数为多字节。这意味着,一个包含五个字节的字符,LENGTH()退货,而CHAR_LENGTH()退货

    mysql> SELECT LENGTH('text');
            -> 4
    
    笔记

    这个Length()OpenGIS空间功能命名ST_Length()在MySQL

  • LOAD_FILE(file_name)

    读取文件并以字符串的形式返回文件内容。要使用此功能,文件必须位于服务器主机,你必须指定文件的完整路径名,你必须FILE特权。该文件必须由所有的尺寸小于是可读的max_allowed_packetBytes .if thesecure_file_priv系统变量设置为一个非空的目录名,文件被加载必须位于该目录。

    如果文件不存在或无法读取,因为一条件不满足,返回NULL

    这个character_set_filesystem系统变量控制,给出的字符串的文件名的解释。

    MySQL的&#62;UPDATE t  SET blob_col=LOAD_FILE('/tmp/picture')  WHERE id=1;
  • LOCATE(substr,str)LOCATE(substr,str,pos)

    第一个语法返回字符串中第一次出现的位置substr在字符串str。第二语法返回字符串中第一次出现的位置substr在字符串str,开始位置pos。退货如果substr不在str。退货无效的如果任一参数为NULL

    MySQL的&#62;SELECT LOCATE('bar', 'foobarbar');-> 4mysql>SELECT LOCATE('xbar', 'foobar');-> 0mysql>SELECT LOCATE('bar', 'foobarbar', 5);&#62; 7

    这个功能是多字节的安全,和大小仅当至少有一个参数是一个字符串。

  • LOWER(str)

    返回字符串str所有的字符转换为小写根据当前字符集映射。默认值是utf8mb4

    mysql> SELECT LOWER('QUADRATICALLY');
            -> 'quadratically'
    

    LOWER()(和UPPER())无效时应用于二进制字符串(BINARYVARBINARYBLOB)。执行lettercase转换,转换字符串到一个非二进制字符串:

    MySQL的&#62;SET @str = BINARY 'New York';MySQL的&#62;SELECT LOWER(@str), LOWER(CONVERT(@str USING utf8mb4));------------- ------------------------------------ |下(@ STR)|低(转换(@ STR使用utf8mb4))| ------------- ------------------------------------ |纽约|纽约| ------------- ------------------------------------

    学院为Unicode字符集的排序规则,LOWER()UPPER()根据Unicode排序算法(UCA)的排序规则名称的版本,如果有一个,和UCA 4.0.0如果没有指定版本。例如,我们的_ _ utf8mb4 _ 0900小时utf8_unicode_520_ci据台湾9.0.0和5.2.0,分别工作,而我们_ _ utf8 unicode作品根据UCA 4.0.0。看到第10.10.1,“Unicode字符集”

    这个功能是多字节的安全。

    LCASE()在视图重写为罗尔

  • LPAD(str,len,padstr)

    返回字符串str,左填充字符串padstr一个长度len人物如果strlen,返回值是缩短len人物

    MySQL的&#62;SELECT LPAD('hi',4,'??');-> '??hi'mysql>SELECT LPAD('hi',1,'??');- &#62;“H”
  • LTRIM(str)

    返回字符串str与领先的空格字符删除。

    MySQL的&#62;SELECT LTRIM('  barbar');- &#62;巴巴”

    这个功能是多字节的安全。

  • MAKE_SET(bits,str1,str2,...)

    返回一组值(一个字符串包含子字符串分隔,字符)组成的,有相应的位串在bits配置str1BIT 0,str2至1位,等等无效的价值观str1str2不添加到结果

    mysql> SELECT MAKE_SET(1,'a','b','c');
            -> 'a'
    mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world');
            -> 'hello,world'
    mysql> SELECT MAKE_SET(1 | 4,'hello','nice',NULL,'world');
            -> 'hello'
    mysql> SELECT MAKE_SET(0,'a','b','c');
            -> ''
    
  • MID(str,pos,len)

    MID(str,pos,len)是同义词SUBSTRING(str,pos,len)

  • OCT(N)

    返回八进制值的字符串表示形式N,在那里N是龙龙(BIGINT)数。这相当于CONV(N,10,8)。退货无效的如果N无效的

    mysql> SELECT OCT(12);
            -> '14'
    
  • OCTET_LENGTH(str)

    OCTET_LENGTH()是同义词LENGTH()

  • ORD(str)

    如果字符串最左边的字符str是一个多字节字符,返回该字符的代码,计算出的数值,其组成的字节使用这个公式:

    (第一字节编码)(第二字节码×256)(第三字节码* 256 ^ 2)…

    如果左边的字符是不是一个多字节字符,ORD()当返回相同的值ASCII()功能

    MySQL的&#62;SELECT ORD('2');-&#62; 50
  • POSITION(substr IN str)

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

  • QUOTE(str)

    引用一个字符串,产生一个结果,可以作为一个正确转义数据值在一个SQL语句。返回的字符串由单引号和反斜杠(与每个实例\单率()&#39;ASCII码),NUL,和控制Z前面加上反斜杠。如果参数是无效的返回值的话,无效的没有封闭的单引号

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

    相比之下,看到引用规则的字符串,在C API9.1.1节,“String Literals”,和第27.7.7.56,“mysql_real_escape_string_quote()”

  • REPEAT(str,count)

    返回一个字符串的字符串组成的str重复的count时代如果count小于1,返回一个空字符串。退货无效的如果strcount无效的

    mysql> SELECT REPEAT('MySQL', 3);
            -> 'MySQLMySQLMySQL'
    
  • REPLACE(str,from_str,to_str)

    返回字符串str与字符串的所有出现from_str由字符串替换to_strREPLACE()执行区分大小写的匹配搜索时from_str

    MySQL的&#62;SELECT REPLACE('www.mysql.com', 'w', 'Ww');wwwwww.mysql.com’-&#62;’

    这个功能是多字节的安全。

  • REVERSE(str)

    返回字符串str随着人物的顺序颠倒

    MySQL的&#62;SELECT REVERSE('abc');- &#62;“CBA”

    这个功能是多字节的安全。

  • RIGHT(str,len)

    返回最右边的len从字符串中的字符str,或无效的如果任一参数为NULL

    MySQL的&#62;SELECT RIGHT('foobarbar', 4);- &#62;“RBAR”

    这个功能是多字节的安全。

  • RPAD(str,len,padstr)

    返回字符串str用字符串填充好,padstr一个长度len人物如果strlen,返回值是缩短len人物

    MySQL的&#62;SELECT RPAD('hi',5,'?');-> 'hi???'mysql>SELECT RPAD('hi',1,'?');- &#62;“H”

    这个功能是多字节的安全。

  • RTRIM(str)

    返回字符串str尾随空格字符删除

    MySQL的&#62;SELECT RTRIM('barbar   ');- &#62;巴巴”

    这个功能是多字节的安全。

  • SOUNDEX(str)

    返回一个字符串,从探测法str。两弦的声音几乎相同的字符串应该有相同的探测法。一个标准的模糊字符串是四个字符,但SOUNDEX()函数返回一个任意长的字符串。你可以使用SUBSTRING()在得到一个标准的模糊字符串的结果。所有非字母字符str被忽略。所有的国际字母A-Z范围之外被视为元音。

    重要

    当使用SOUNDEX(),你应该注意以下限制:

    • 这个功能,目前实施的,是为了工作,是英语语言中的字符串只。在其他语言的字符串可能不会产生可靠的结果。

    • 这个函数不保证提供的字符串,使用多字节字符集一致的结果,包括gb3212。看到错误# 22638更多信息。

    MySQL的&#62;SELECT SOUNDEX('Hello');-> 'H400'mysql>SELECT SOUNDEX('Quadratically');q36324”- &#62;“
    笔记

    这个函数实现原探测法算法,而不是更受欢迎的增强版(D. Knuth了)。不同的是,原始版本丢弃元音和重复第二,而增强版第一、二丢弃重复元音。

  • expr1 SOUNDS LIKE expr2

    这是一样的SOUNDEX(expr1) = SOUNDEX(expr2)

  • SPACE(N)

    返回一个字符串组成的N空间特征

    MySQL的&#62;SELECT SPACE(6);- &#62;”
  • SUBSTR(str,pos)SUBSTR(str FROM pos)SUBSTR(str,pos,len)SUBSTR(str FROM pos FOR len)

    SUBSTR()是同义词SUBSTRING()

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

    没有一种形式len返回从字符串的子串的争论str开始位置pos。与形式len返回子字符串参数len字符的字符串str,开始位置pos。。。。。。。使用的形式。是标准的SQL语法。也可以使用一个负的值pos。在这种情况下,子串的开始pos从字符串的结束字符,而不是开始。一个负的值可用于pos有这个函数的形式

    所有形式的SUBSTRING(),位置的第一个字符在字符串中的子字符串,是提取被认为是

    mysql> SELECT SUBSTRING('Quadratically',5);
            -> 'ratically'
    mysql> SELECT SUBSTRING('foobarbar' FROM 4);
            -> 'barbar'
    mysql> SELECT SUBSTRING('Quadratically',5,6);
            -> 'ratica'
    mysql> SELECT SUBSTRING('Sakila', -3);
            -> 'ila'
    mysql> SELECT SUBSTRING('Sakila', -5, 3);
            -> 'aki'
    mysql> SELECT SUBSTRING('Sakila' FROM -4 FOR 2);
            -> 'ki'
    

    这个功能是多字节的安全。

    如果len小于1,结果为空字符串。

  • SUBSTRING_INDEX(str,delim,count)

    返回从字符串的子串str之前count出现的分隔符delim。如果count是积极的,一切到最后的分隔符左侧(从左边)返回。如果count是消极的,一切到最后的分隔符右侧(从右数)返回。SUBSTRING_INDEX()执行区分大小写的匹配搜索时delim

    MySQL的&#62;SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);-> 'www.mysql'mysql>SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2);“MySQL”&#62;

    这个功能是多字节的安全。

  • TO_BASE64(str)

    将字符串参数Base-64编码形式和一个连接的字符集和字符的字符串返回结果。如果参数不是一个字符串,它被转换成一个字符串转换发生之前。其结果是NULL如果参数是无效的。Base-64编码的字符串可以被解码的使用FROM_BASE64()功能

    MySQL的&#62;SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));我是ABC jwjj &#62;,是

    Base-64编码方案存在不同。这些都是编码和解码所使用的规则TO_BASE64()FROM_BASE64()

    • 编码字母的值62'+'

    • 编码字母的值63'/'

    • 编码的输出包括4个可打印的字符组。每个3字节的输入数据,使用的是4字符编码。如果最后一组是不完整的,它是用'='字符长度4

    • 换行后增加每76个字符的编码输出分长的输出为多行。

    • 解码识别并忽略换行符,回车符,制表符,和空间。

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

    返回字符串str与所有remstr前缀或后缀去掉。如果没有说明符LEADING,或尾随给出了,BOTH假设remstr是可选的,如果没有指定,空间被删除。

    MySQL的&#62;SELECT TRIM('  bar   ');-> 'bar'mysql>SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');-> 'barxxx'mysql>SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');-> 'bar'mysql>SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');- &#62;“BARX”

    这个功能是多字节的安全。

  • UCASE(str)

    UCASE()是同义词UPPER()

    UCASE()在视图重写为upper()

  • UNHEX(str)

    如果该字符串参数strUNHEX(str)对争论中的每个字符对为十六进制数转换成的数字表示的字节。返回值是一个二进制字符串。

    MySQL的&#62;SELECT UNHEX('4D7953514C');-> 'MySQL'mysql>SELECT X'4D7953514C';-> 'MySQL'mysql>SELECT UNHEX(HEX('string'));-> 'string'mysql>SELECT HEX(UNHEX('1267'));&#62; 1267

    在参数字符串中的字符必须是合法的十六进制数字:'0'..“9”'A'..“F”'a'..“F”。如果参数中包含任何nonhexadecimal位数,结果是NULL

    MySQL的&#62;SELECT UNHEX('GG');------------- | unhex(&#39;gg”)| ------------- |空| -------------

    NULL结果当参数发生UNHEX()是一个BINARY列,因为价值观是用0x00字节存储时但这些字节不被检索。例如,“4”存储在CHAR(3)“41”及检索'41'(与尾垫空间剥离),所以UNHEX()该列的值返回&#39; &#39;。通过对比'41'存储在二(三)'41\0'及检索“41 0”(与尾垫0x00字节不剥离)“0”是不是一个合法的十六进制数字,所以UNHEX()该列的值返回无效的

    for a值参数N“逆系HEX(N)不执行的UNHEX()。使用CONV(HEX(N),16,10)相反。看到的描述HEX()

  • UPPER(str)

    返回字符串str与所有字符改成大写根据当前字符集映射。默认值是utf8mb4

    mysql> SELECT UPPER('Hej');
            -> 'HEJ'
    

    看到的描述LOWER()这也适用于信息UPPER()。这包括有关如何执行二进制字符串转换(lettercaseBINARYVARBINARYBLOB),这些功能是无效的,还有对Unicode字符集的情况下折叠信息。

    这个功能是多字节的安全。

    UCASE()在视图重写为upper()

  • WEIGHT_STRING(str [AS {CHAR|BINARY}(N)] [flags])

    这个函数返回输入字符串的字符串的重。返回值是一个二进制串表示比较的字符串值。它的这些特性:

    WEIGHT_STRING()是一个调试功能供内部使用。它的行为可以改变MySQL版本之间没有通知。它可用于测试和调试的排序规则,特别是如果你添加一个新的整理。看到10.13节,“添加整理到一个字符集”

    本文简要地总结了参数。更多的细节在下面的列表中的讨论。

    • str输入字符串表达式

    • AS条款:可选;把输入的字符串给定的类型和长度。

    • flags可选:;未用的

    输入的字符串,str,是一个字符串表达式。如果输入的是一个二进制字符串(字符)等CHARVARCHAR,或TEXT值,返回值为包含字符串的排序规则权重。如果输入的是一个二进制字符串(字节)等BINARYVARBINARY,或BLOB值,返回值为输入相同(二进制字符串中每个字节的重量是字节值)。如果输入的是无效的WEIGHT_STRING()退货无效的

    实例:

    mysql> SET @s = _utf8mb4 'AB' COLLATE utf8mb4_0900_ai_ci;
    mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
    +------+---------+------------------------+
    | @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
    +------+---------+------------------------+
    | AB   | 4142    | 1C471C60               |
    +------+---------+------------------------+
    
    MySQL的&#62;SET @s = _utf8mb4 'ab' COLLATE utf8mb4_0900_ai_ci;MySQL的&#62;SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));------ --------- ------------------------ | @的|进制(氏)| hex(weight_string(氏))| ------ --------- ------------------------ | AB | 6162 | 1c471c60 | ------ --------- ------------------------
    MySQL的&#62;SET @s = CAST('AB' AS BINARY);MySQL的&#62;SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));------ --------- ------------------------ | @的|进制(氏)| hex(weight_string(氏))| ------ --------- ------------------------ | AB | 4142 | 4142 | ------ --------- ------------------------
    MySQL的&#62;SET @s = CAST('ab' AS BINARY);MySQL的&#62;SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));------ --------- ------------------------ | @的|进制(氏)| hex(weight_string(氏))| ------ --------- ------------------------ | AB | 6162 | 6162 | ------ --------- ------------------------

    前面的示例使用HEX()显示WEIGHT_STRING()结果因为结果是一个二进制值,HEX()可以是特别有用,当结果包含非打印的值,显示打印形式:

    MySQL的&#62;SET @s = CONVERT(X'C39F' USING utf8) COLLATE utf8_czech_ci;MySQL的&#62;SELECT HEX(WEIGHT_STRING(@s));------------------------ | hex(weight_string(氏))| ------------------------ | 0fea0fea | ------------------------

    对于非—NULL返回值,该值的数据类型VARBINARY如果它的长度的最大长度内VARBINARY否则,冰的数据类型BLOB

    这个AS条款可能给投输入字符串到二进制或二进制字符串,迫使它到一个给定的长度:

    • AS CHAR(N)将字符串转换为一个二进制字符串和垫在正确的空格的长度N人物N必须至少1。如果N小于输入字符串的长度,字符串被截断N人物没有警告出现截断。

    • AS BINARY(N)类似但把字符串转换为一个二进制串,N的单位是字节(不是字符),和填料使用0x00拜拜(不是意大利面)。

    mysql> SET NAMES 'latin1';
    mysql> SELECT HEX(WEIGHT_STRING('ab' AS CHAR(4)));
    +-------------------------------------+
    | HEX(WEIGHT_STRING('ab' AS CHAR(4))) |
    +-------------------------------------+
    | 41422020                            |
    +-------------------------------------+
    mysql> SET NAMES 'utf8';
    mysql> SELECT HEX(WEIGHT_STRING('ab' AS CHAR(4)));
    +-------------------------------------+
    | HEX(WEIGHT_STRING('ab' AS CHAR(4))) |
    +-------------------------------------+
    | 0041004200200020                    |
    +-------------------------------------+
    
    MySQL的&#62;SELECT HEX(WEIGHT_STRING('ab' AS BINARY(4)));--------------------------------------- | hex(weight_string(&#39;ab”二元(四)))| --------------------------------------- | 61620000 | ---------------------------------------

    这个flags目前使用的条款

12.5.1字符串比较函数

表3的字符串比较运算符

姓名描述
LIKE简单的模式匹配
NOT LIKE简单的模式匹配的否定
STRCMP()比较两个字符串

如果一个字符串的函数给出一个二进制字符串作为参数,得到的字符串是一个二进制字符串。一个数转换成字符串被视为一个二进制字符串。这仅影响的比较。

通常,如果在一个字符串比较的任何表达式是大小写敏感的情况下,比较敏感的方式进行。

  • expr LIKE pat [ESCAPE 'escape_char']

    使用SQL模式匹配模式。退货1真的)或0错误的)。如果exprpat无效的,结果是NULL

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

    为SQL标准,LIKE对每个字符的基础上匹配,从而产生不同的结果=比较运算符:

    MySQL的&#62;SELECT '?' LIKE 'ae' COLLATE latin1_german2_ci;?| -----------------------------------------就像是AE是collate latin1 _ german2 _我们| ----------------------------------------- | | ----------------------------------------- MySQL>0SELECT '?' = 'ae' COLLATE latin1_german2_ci;+--------------------------------------+| '?' = 'ae' COLLATE latin1_german2_ci |+--------------------------------------+|                                    1 |+--------------------------------------+

    特别是,尾随空格是非常重要的,这是不正确的CHARVARCHAR比较用=运营商:

    MySQL的&#62;SELECT 'a' = 'a ', 'a' LIKE 'a ';+------------+---------------+| 'a' = 'a ' | 'a' LIKE 'a ' |+------------+---------------+|          1 |             0 |+------------+---------------+1 row in set (0.00 sec)

    LIKE您可以使用以下模式中的两个通配符:

    • %匹配任何数量的字符,甚至是零个字符。

    • _完全匹配一个字符

    MySQL的&#62;SELECT 'David!' LIKE 'David_';-> 1mysql>SELECT 'David!' LIKE '%D%v%';-&#62; 1

    对文字的通配符的情况下测试,先于它的转义字符。如果你不指定ESCAPE字符,\假设

    • \%火柴人%人物

    • \_火柴人_人物

    mysql> SELECT 'David!' LIKE 'David\_';
            -> 0
    mysql> SELECT 'David_' LIKE 'David\_';
            -> 1
    

    指定一个不同的转义字符,使用ESCAPE条款:

    MySQL的&#62;SELECT 'David_' LIKE 'David|_' ESCAPE '|';-&#62; 1

    转义序列应该是空的或一个字符。表达式的计算结果必须在执行时间常数。如果NO_BACKSLASH_ESCAPESSQL模式启用,顺序不能为空。

    下面两个语句说明字符串比较不区分大小写,除非其中一个操作数是大小写敏感的(利用区分排序规则或是一个二进制字符串):

    mysql> SELECT 'abc' LIKE 'ABC';
            -> 1
    mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_0900_as_cs;
            -> 0
    mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_bin;
            -> 0
    mysql> SELECT 'abc' LIKE BINARY 'ABC';
            -> 0
    

    作为标准的SQL的一个延伸,MySQL许可证LIKE对数值表达式

    MySQL的&#62;SELECT 10 LIKE '1%';-&#62; 1
    笔记

    因为MySQL使用C语法的字符串(例如逃跑,\n表示一个换行符),你必须加倍任何\在你使用LIKE字符串。to search for example,for\n,指定它作为\\n。搜索\,指定它作为\\\\;这是因为反斜杠被一旦被解析器的时候,模式匹配,留下一个反斜杠来匹配。

    例外:在模式字符串的末尾,反斜杠可以指定为\\。在字符串的结尾,反斜杠表示自己因为没有什么后逃跑。假设一个表包含以下值:

    MySQL的&#62;SELECT filename FROM t1;-------------- |文件名| -------------- | C:| | C:\ | | C:\程序| | C:\程序\ | --------------

    用反斜杠结束值测试,可以匹配的值采用以下模式:

    mysql> SELECT filename, filename LIKE '%\\' FROM t1;
    +--------------+---------------------+
    | filename     | filename LIKE '%\\' |
    +--------------+---------------------+
    | C:           |                   0 |
    | C:\          |                   1 |
    | C:\Programs  |                   0 |
    | C:\Programs\ |                   1 |
    +--------------+---------------------+
    
    mysql> SELECT filename, filename LIKE '%\\\\' FROM t1;
    +--------------+-----------------------+
    | filename     | filename LIKE '%\\\\' |
    +--------------+-----------------------+
    | C:           |                     0 |
    | C:\          |                     1 |
    | C:\Programs  |                     0 |
    | C:\Programs\ |                     1 |
    +--------------+-----------------------+
    
  • expr NOT LIKE pat [ESCAPE 'escape_char']

    这是一样的NOT (expr LIKE pat [ESCAPE 'escape_char'])

    笔记

    聚合查询涉及NOT LIKE列包含的比较无效的可能会产生意外的结果。例如,考虑下面的表格和数据:

    CREATE TABLE foo (bar VARCHAR(10));
    
    INSERT INTO foo VALUES (NULL), (NULL);
    

    查询SELECT COUNT(*) FROM foo WHERE bar LIKE '%baz%';退货。你可能会认为SELECT COUNT(*) FROM foo WHERE bar NOT LIKE '%baz%';会回来的。然而,这是没有的情况下:第二查询返回0。这是因为空不喜欢expr总是返回无效的,不论价值expr。相同的聚合查询涉及真实无效的比较使用NOT RLIKENOT REGEXP。在这种情况下,你必须明确测试不为空使用OR(而不是AND),如下所示:

    SELECT COUNT(*) FROM foo WHERE bar NOT LIKE '%baz%' OR bar IS NULL;
  • STRCMP(expr1,expr2)

    STRCMP()退货如果字符串是一样的,-1如果第一个参数小于第二根据当前的排序顺序和否则

    mysql> SELECT STRCMP('text', 'text2');
            -> -1
    mysql> SELECT STRCMP('text2', 'text');
            -> 1
    mysql> SELECT STRCMP('text', 'text');
            -> 0
    

    STRCMP()执行使用的论据整理的比较。

    MySQL的&#62;SET @s1 = _utf8mb4 'x' COLLATE utf8mb4_0900_ai_ci;MySQL的&#62;SET @s2 = _utf8mb4 'X' COLLATE utf8mb4_0900_ai_ci;MySQL的&#62;SET @s3 = _utf8mb4 'x' COLLATE utf8mb4_0900_as_cs;MySQL的&#62;SET @s4 = _utf8mb4 'X' COLLATE utf8mb4_0900_as_cs;MySQL的&#62;SELECT STRCMP(@s1, @s2), STRCMP(@s3, @s4);————| strcmp(@ @ S1,S2)| strcmp(@ @ S3,S4)|——————| | | 0 1。

    如果排序规则是不相容的,一个参数必须转换成可与其他兼容的。看到第10.8.4,“整理可压缩性表达”

    mysql> SET @s1 = _utf8mb4 'x' COLLATE utf8mb4_0900_ai_ci;
    mysql> SET @s2 = _utf8mb4 'X' COLLATE utf8mb4_0900_ai_ci;
    mysql> SET @s3 = _utf8mb4 'x' COLLATE utf8mb4_0900_as_cs;
    mysql> SET @s4 = _utf8mb4 'X' COLLATE utf8mb4_0900_as_cs;
    -->
    mysql> SELECT STRCMP(@s1, @s3);
    ERROR 1267 (HY000): Illegal mix of collations (utf8mb4_0900_ai_ci,IMPLICIT)
    and (utf8mb4_0900_as_cs,IMPLICIT) for operation 'strcmp'
    mysql> SELECT STRCMP(@s1, @s3 COLLATE utf8mb4_0900_ai_ci);
    +---------------------------------------------+
    | STRCMP(@s1, @s3 COLLATE utf8mb4_0900_ai_ci) |
    +---------------------------------------------+
    |                                           0 |
    +---------------------------------------------+
    

12.5.2正则表达式

表12.9正则表达式功能者

姓名描述
NOT REGEXP否定的正则表达式
REGEXP无论字符串匹配正则表达式
REGEXP_INSTR()启动子串匹配正则表达式索引
REGEXP_LIKE()无论字符串匹配正则表达式
REGEXP_REPLACE()替换匹配的子字符串的正则表达式
REGEXP_SUBSTR()返回子串匹配的正则表达式
RLIKE无论字符串匹配正则表达式

正则表达式是一种强大的方法指定一个复杂的搜索模式。本节讨论和使用正则表达式匹配运营商的功能和说明,结合实例,对一些特殊字符和结构,可以用于正则表达式的操作。参见第3.3.4.7,“模式匹配”

MySQL实现正则表达式支持使用Unicode国际成分(ICU),它提供了全面支持Unicode和多字节安全。8.0.4(MySQL,MySQL使用Henry Spencer执行正则表达式,它工作在字节明智的方式,是不是多字节安全之前。有关如何在使用正则表达式的应用程序可以通过实现变化的影响,看正则表达式的兼容性的考虑。)

正则表达式的函数和操作符

  • expr NOT REGEXP patexpr NOT RLIKE pat

    这是一样的NOT (expr REGEXP pat)

  • expr REGEXP patexpr RLIKE pat

    返回1如果字符串expr匹配指定的正则表达式的模式pat0,其他。ifexprpat无效的,返回值是NULL

    REGEXPRLIKE是同义词REGEXP_LIKE()

    有关如何匹配发生的更多信息,见描述REGEXP_LIKE()

    MySQL的&#62;SELECT 'Michael!' REGEXP '.*';的;|迈克尔!!!!!!!”regexp”。* |;| 1 | MySQL &#62;;SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';| --------------------------------------- *新*在线N是New RegExp \\ \\**。| --------------------------------------- |线| --------------------------------------- MySQL>0SELECT 'a' REGEXP '^[a-d]';--------------------- | &#39; regexp的^ [广告]的| --------------------- | 1 | --------------------- MySQL &#62;SELECT 'a' REGEXP 'A', 'a' REGEXP BINARY 'A';---------------- ----------------------- | &#39; regexp &#39; | &#39; regexp二进制&#39; | ---------------- ----------------------- | 1 | 0 | ---------------- -----------------------
  • REGEXP_INSTR(expr, pat[, pos[, occurrence[, return_option[, match_type]]]])

    返回的字符串的子字符串的起始索引expr匹配指定的正则表达式的模式pat如果没有匹配,0。如果exprpat无效的,返回值是NULL。开始在1个特征指标。

    REGEXP_INSTR()以这些可选参数:

    • pos在《位置:expr在开始搜索。如果省略,默认是1。

    • occurrence:寻找发生一场比赛。如果省略,默认是1。

    • return_option:这类型的位置返回。如果这个值是0,REGEXP_INSTR()返回匹配的子字符串的第一个字符的位置。如果这个值是1.,REGEXP_INSTR()返回匹配的子串的位置如下。如果省略,默认是0。

    • match_type:一个字符串,指定如何进行匹配。意思就是了REGEXP_LIKE()

    有关如何匹配发生的更多信息,见描述REGEXP_LIKE()

    MySQL的&#62;SELECT REGEXP_INSTR('dog cat dog', 'dog');------------------------------------ | regexp_instr(&#39;dog猫狗”,“狗”)| ------------------------------------ | 1 | ------------------------------------ MySQL &#62;SELECT REGEXP_INSTR('dog cat dog', 'dog', 2);--------------------------------------- | regexp_instr(&#39;dog猫狗”,“狗”,2)| --------------------------------------- | 9 | --------------------------------------- MySQL &#62;SELECT REGEXP_INSTR('aa aaa aaaa', 'a{2}');仪器| _ ------------------------------------- RegExp(AA AAA级”,“| {2})------------------------------------- | | MySQL ------------------------------------->1SELECT REGEXP_INSTR('aa aaa aaaa', 'a{4}');仪器| _ ------------------------------------- RegExp(AA AAA级”,“{ }”| ------------------------------------- | 4 8 | -------------------------------------)
  • REGEXP_LIKE(expr, pat[, match_type])

    返回1如果字符串expr匹配指定的正则表达式的模式pat0,其他。ifexprpat无效的,返回值是NULL

    该模式可扩展的正则表达式,其语法分析正则表达式语法。该模式不需要是一个字符串。例如,它可以被指定为一个字符串表达式或表列。

    可选match_type参数是一个字符串,可以包含任何或所有下列字符指定如何进行匹配:

    • c:区分大小写匹配

    • i:不区分大小写匹配

    • m多行模式。认识到在弦线的终结者。默认行为是匹配的行终止符只在开始和结束的字符串表达式。

    • n:the字符匹配行的终结者。默认为.匹配行尾的停止

    • uUnix只行结尾。只有换行符是公认的行结束的^,和美元匹配算子

    如果指定选项中指定的字符的矛盾match_type,最右边的一个优先

    默认情况下,正则表达式的操作中使用的字符集和整理exprpat参数时,决定一个性格类型进行比较。如果参数有不同的字符集或排序规则,可压缩性的规则描述第10.8.4,“整理可压缩性表达”。参数可以显式排序指标变化比较行为的规定。

    mysql> SELECT REGEXP_LIKE('CamelCase', 'CAMELCASE');
    +---------------------------------------+
    | REGEXP_LIKE('CamelCase', 'CAMELCASE') |
    +---------------------------------------+
    |                                     1 |
    +---------------------------------------+
    mysql> SELECT REGEXP_LIKE('CamelCase', 'CAMELCASE' COLLATE utf8mb4_0900_as_cs);
    +------------------------------------------------------------------+
    | REGEXP_LIKE('CamelCase', 'CAMELCASE' COLLATE utf8mb4_0900_as_cs) |
    +------------------------------------------------------------------+
    |                                                                0 |
    +------------------------------------------------------------------+
    

    match_type可以指定的Ci字符覆盖默认情况下灵敏度。例外:如果其中一个参数是字符串,参数处理敏感的时尚为二进制字符串,即使match_type包含I人物

    笔记

    因为MySQL使用C转义语法的字符串(例如,\n代表换行字符),你必须加倍任何\你用你的exprpat争论

    MySQL的&#62;SELECT REGEXP_LIKE('Michael!', '.*');------------------------------- | regexp_like(&#39;michael!”,“*”)| ------------------------------- | 1 | ------------------------------- MySQL &#62;SELECT REGEXP_LIKE('new*\n*line', 'new\\*.\\*line');---------------------------------------------- | regexp_like(新* n *线&#39;,&#39;新\\ *。\\ *线”)| ---------------------------------------------- | 0 | ---------------------------------------------- MySQL &#62;SELECT REGEXP_LIKE('a', '^[a-d]');---------------------------- | regexp_like(“A”,“^ [广告]”)| ---------------------------- | 1 | ---------------------------- MySQL &#62;SELECT REGEXP_LIKE('a', 'A'), REGEXP_LIKE('a', BINARY 'A');----------------------- ------------------------------ | regexp_like(“A”,“A”)| regexp_like(&#39;a&#39;,二元&#39;)| ----------------------- ------------------------------ | 1 | 0 | ----------------------- ------------------------------
    MySQL的&#62;SELECT REGEXP_LIKE('abc', 'ABC');--------------------------- | regexp_like(ABC,ABC)| --------------------------- | 1 | --------------------------- MySQL &#62;SELECT REGEXP_LIKE('abc', 'ABC', 'c');| regexp like _ --------------------------------(ABC,ABC,0 C)| -------------------------------- | | --------------------------------
  • REGEXP_REPLACE(expr, pat, repl[, pos[, occurrence[, match_type]]])

    替换字符串中出现expr由指定的正则表达式匹配模式pat用替换字符串repl,并返回结果字符串。如果exprpat,或repl无效的,返回值是NULL

    REGEXP_REPLACE()以这些可选参数:

    • pos在《位置:expr在开始搜索。如果省略,默认是1。

    • occurrence:代替发生的比赛。如果省略,缺省为0(这意味着替换所有的匹配

    • match_type:一个字符串,指定如何进行匹配。意思就是了REGEXP_LIKE()

    有关如何匹配发生的更多信息,见描述REGEXP_LIKE()

    MySQL的&#62;SELECT REGEXP_REPLACE('a b c', 'b', 'X');----------------------------------- | regexp_replace(A B C”、“B”、“X”)| ----------------------------------- | X C | ----------------------------------- MySQL &#62;SELECT REGEXP_REPLACE('abc def ghi', '[a-z]+', 'X', 1, 3);---------------------------------------------------- | regexp replace(ABC _最终酥油,是[ ] A—Z,X,1,3)| ---------------------------------------------------- |最终---------------------------------------------------- X | ABC
  • REGEXP_SUBSTR(expr, pat[, pos[, occurrence[, match_type]]])

    返回字符串的子串expr匹配指定的正则表达式的模式pat无效的如果没有匹配的。如果exprpat无效的,返回值是NULL

    REGEXP_SUBSTR()以这些可选参数:

    • pos在《位置:expr在开始搜索。如果省略,默认是1。

    • occurrence:寻找发生一场比赛。如果省略,默认是1。

    • match_type:一个字符串,指定如何进行匹配。意思就是了REGEXP_LIKE()

    有关如何匹配发生的更多信息,见描述REGEXP_LIKE()

    MySQL的&#62;SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+');---------------------------------------- | regexp substr(ABC _最终酥油,〔Z〕)| ---------------------------------------- | ABC | ---------------------------------------- MySQL &#62;SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+', 1, 3);---------------------------------------------- | regexp substr(ABC _最终酥油,〔Z〕,1,3)| ---------------------------------------------- | | ----------------------------------------------酥油

正则表达式语法

正则表达式描述了一组字符串。最简单的正则表达式是一个没有特殊字符。例如,正则表达式hello比赛你好别的什么都没有

平凡的正则表达式使用某些特殊结构使他们可以匹配多个字符串。例如,正则表达式hello|world包含|变换算子和匹配的hello全球

作为一个更复杂的例子,正则表达式B[an]*s匹配任何字符串香焦BaaaaasBS,和任何其他字符串开始的一B最后一个,S,和包含任意数量的aN在字符之间

下面的列表包括一些基本的特点和结构,可以使用正则表达式。有关完整的正则表达式语法被用来实现正则表达式支持ICU库支持的信息,访问Unicode网站国际成分

  • ^

    匹配字符串的开始

    mysql> SELECT REGEXP_LIKE('fo\nfo', '^fo$');                   -> 0
    mysql> SELECT REGEXP_LIKE('fofo', '^fo');                      -> 1
    
  • $

    匹配字符串的结束

    mysql> SELECT REGEXP_LIKE('fo\no', '^fo\no$');                 -> 1
    mysql> SELECT REGEXP_LIKE('fo\no', '^fo$');                    -> 0
    
  • .

    匹配任意字符(包括回车符和换行符,虽然匹配在字符串中m(多线)匹配控制字符或(?m)在模式修饰符必须给出)。

    mysql> SELECT REGEXP_LIKE('fofo', '^f.*$');                    -> 1
    mysql> SELECT REGEXP_LIKE('fo\r\nfo', '^f.*$');                -> 0
    mysql> SELECT REGEXP_LIKE('fo\r\nfo', '^f.*$', 'm');           -> 1
    mysql> SELECT REGEXP_LIKE('fo\r\nfo', '(?m)^f.*$');           -> 1
    
  • a*

    匹配任何序列的零个或多个a人物

    MySQL的&#62;SELECT REGEXP_LIKE('Ban', '^Ba*n');-> 1mysql>SELECT REGEXP_LIKE('Baaan', '^Ba*n');-> 1mysql>SELECT REGEXP_LIKE('Bn', '^Ba*n');-&#62; 1
  • a+

    匹配任何一个或多个a人物

    MySQL的&#62;SELECT REGEXP_LIKE('Ban', '^Ba+n');-> 1mysql>SELECT REGEXP_LIKE('Bn', '^Ba+n');&#62; 0
  • a?

    匹配零个或一个a人物

    MySQL的&#62;SELECT REGEXP_LIKE('Bn', '^Ba?n');-> 1mysql>SELECT REGEXP_LIKE('Ban', '^Ba?n');-> 1mysql>SELECT REGEXP_LIKE('Baan', '^Ba?n');&#62; 0
  • de|abc

    交替;匹配的序列de美国广播公司

    mysql> SELECT REGEXP_LIKE('pi', 'pi|apa');                     -> 1
    mysql> SELECT REGEXP_LIKE('axe', 'pi|apa');                    -> 0
    mysql> SELECT REGEXP_LIKE('apa', 'pi|apa');                    -> 1
    mysql> SELECT REGEXP_LIKE('apa', '^(pi|apa)$');                -> 1
    mysql> SELECT REGEXP_LIKE('pi', '^(pi|apa)$');                 -> 1
    mysql> SELECT REGEXP_LIKE('pix', '^(pi|apa)$');                -> 0
    
  • (abc)*

    匹配零个或多个实例的顺序abc

    MySQL的&#62;SELECT REGEXP_LIKE('pi', '^(pi)*$');-> 1mysql>SELECT REGEXP_LIKE('pip', '^(pi)*$');-> 0mysql>SELECT REGEXP_LIKE('pipi', '^(pi)*$');-&#62; 1
  • {1}{二}

    重复;{n}{mn}符号的写作提供的正则表达式匹配前面的原子的许多事件(或更一般的方法)的模式mn是整数

    • a*

      可以写为a{0,}

    • a+

      可以写为a{1,}

    • a?

      可以写为a{0,1}

    为了更精确,a{n}精确匹配n实例a{n,}比赛n或多个实例a{m,n}比赛m通过n实例具有包容性如果mn给出了,m必须小于或等于n

    MySQL的&#62;SELECT REGEXP_LIKE('abcde', 'a[bcd]{2}e');-> 0mysql>SELECT REGEXP_LIKE('abcde', 'a[bcd]{3}e');-> 1mysql>SELECT REGEXP_LIKE('abcde', 'a[bcd]{1,10}e');-&#62; 1
  • [a-dX][我]的DX ^

    匹配任何字符,是(或不是,如果^无论是使用)bCdX。一-其他两个字符之间的字符形成一个范围匹配所有字符的第一个字符的二。例如,[0-9]匹配任何十进制数。包括文字]字符,它必须紧跟括号。包括文字-字符,它必须写的第一个或最后一个。任何字符,没有一个固定的特殊意义在[ ]对比赛本身

    mysql> SELECT REGEXP_LIKE('aXbc', '[a-dXYZ]');                 -> 1
    mysql> SELECT REGEXP_LIKE('aXbc', '^[a-dXYZ]$');               -> 0
    mysql> SELECT REGEXP_LIKE('aXbc', '^[a-dXYZ]+$');              -> 1
    mysql> SELECT REGEXP_LIKE('aXbc', '^[^a-dXYZ]+$');             -> 0
    mysql> SELECT REGEXP_LIKE('gheis', '^[^a-dXYZ]+$');            -> 1
    mysql> SELECT REGEXP_LIKE('gheisa', '^[^a-dXYZ]+$');           -> 0
    
  • [=character_class=]

    在中括号表达式(用[]),[=character_class=]代表一个等价类。它匹配所有字符相同的校勘价值,包括自己。例如,如果o(+)是一个等价类的成员,[[=o=]][[=(+)=]],和[(])都是同义词。一个等价类不能作为一个范围的一个端点。

  • [:character_class:]

    在中括号表达式(用[]),[:character_class:]代表一个字符类匹配所有字符属于那类。下表列出了标准的类名称。这些名字代表的定义的字符类CType(3)手册页。一个特定的区域可以提供其他类名称。一个字符类不能被用来作为一个范围的一个端点。

    字符类的名称意义
    alnum字母数字字符
    alpha字母字符
    blank空白字符
    cntrl控制字符
    digit数字字符
    graph图形字符
    lower小写字母
    print平面或空间特征
    punct标点符号
    space空间,制表符,换行符,并回车
    upper大写字母
    xdigit十六进制数字字符
    mysql> SELECT REGEXP_LIKE('justalnums', '[[:alnum:]]+');       -> 1
    mysql> SELECT REGEXP_LIKE('!!', '[[:alnum:]]+');               -> 0
    

使用正则表达式中的一个特殊字符的文本实例,先于它的两个反斜杠(\)的特点。MySQL解析器解释其中的反斜杠,和正则表达式库的其他解释。例如,要匹配的字符串1+2包含特殊 性格,只有最后以下正则表达式是正确的:

mysql> SELECT REGEXP_LIKE('1+2', '1+2');                       -> 0
mysql> SELECT REGEXP_LIKE('1+2', '1\+2');                      -> 0
mysql> SELECT REGEXP_LIKE('1+2', '1\\+2');                     -> 1

正则表达式的资源控制

REGEXP_LIKE()和类似功能的使用,可以通过设置系统变量控制的资源:

  • 比赛引擎使用的内存,其内部堆栈。控制字节的堆栈的最大可用内存,设置regexp_stack_limit系统变量

  • 比赛引擎的步骤操作。控制由发动机执行步骤的最大数目(从而间接执行时间),设置regexp_time_limit系统变量。因为这种限制表现为许多步骤,它只能间接地影响执行时间。通常,它是在以毫秒。

正则表达式的兼容性的考虑

MySQL 8.0.4之前,MySQL使用Henry Spencer正则表达式库支持正则表达式的操作,而不是Unicode国际成分(ICU)。下面的讨论描述斯宾塞和ICU库之间的差异可能会影响应用程序:

  • 与斯宾塞的图书馆,REGEXPRLIKE运营商在字节明智的方式工作,所以他们不多字节安全可能与多字节字符集产生意外的结果。此外,这些运营商比较字符的字节值和重音字符不相等的即使给定整理对待平等。

    ICU已全面支持Unicode和多字节安全。它的正则表达式函数把字符串作为UTF-16。你应该记住位置索引是基于16位的块而不是代码点。这意味着,当通过这样的功能,使用多块字符可能产生意想不到的结果,如图:

    MySQL的&#62;SELECT REGEXP_INSTR('????b', 'b');-------------------------- | regexp _ instr(??????????????A”,“B”)| -------------------------- | 5 | -------------------------- 1排在集(0.00美国证券交易委员会(SEC)的MySQL &#62;SELECT REGEXP_INSTR('????bxxx', 'b', 4);-------------------------------- | regexp_instr(&#39;??气囊”,“B”,4)| -------------------------------- | 5 | -------------------------------- 1行集(0秒)

    在Unicode基本多文种平面特征,包括大多数现代语言使用的特点,是安全的在这方面:

    mysql> SELECT REGEXP_INSTR('бжb', 'b');
    +----------------------------+
    | REGEXP_INSTR('бжb', 'b')   |
    +----------------------------+
    |                          3 |
    +----------------------------+
    1 row in set (0.00 sec)
    
    mysql> SELECT REGEXP_INSTR('??b', 'b');
    +----------------------------+
    | REGEXP_INSTR('??b', 'b')   |
    +----------------------------+
    |                          3 |
    +----------------------------+
    1 row in set (0.00 sec)
    
    mysql> SELECT REGEXP_INSTR('μ?周?б', '周');
    +------------------------------------+
    | REGEXP_INSTR('μ?周?б', '周')       |
    +------------------------------------+
    |                                  3 |
    +------------------------------------+
    1 row in set (0.00 sec)
    

    表情符号,如寿司人物??(你1f363)在前两个例子,不包括在基本多文种平面,而是在Unicode补充多文种平面。另一个问题可能出现的表情符号和其他4字节字符时REGEXP_SUBSTR()或类似的功能开始在文字中寻找。每个在下面的例子中,两个语句从第一个参数的第二字节位置。第一个语句的作品在一个单字节字符串(BMP)的特点。第二语句包含4字节的字符,在结果错误的解释,因为第一个字节是脱去衣服,所以字符数据的其余部分是不对的。

    MySQL的&#62;SELECT REGEXP_SUBSTR('周周周周', '.*', 2);---------------------------------------- | regexp substr(_周周周周*,,。2)| ---------------------------------------- |周周周| ---------------------------------------- 1行集(0秒)在MySQL &#62;SELECT REGEXP_SUBSTR('????????', '.*', 2);-------------------------------- | regexp_substr(&#39;????&#39;,&#39; * &#39;,2)| -------------------------------- |??揘?揘?揘| -------------------------------- 1行集(0秒)
  • 对于.算子,斯宾塞库匹配行结束符(回车、换行字符)在字符串表达式的任何地方,包括在中间。匹配字符串与ICU的中间线终止字符,指定M匹配控制字符

  • 斯宾塞图书馆的支持和字开头的词边界标记([[:<:]]【[:&#62;:] ]评分不,不

  • 斯宾塞图书馆支持括号表达式(对照元素[.characters.]评分不,不

  • 重复计数({n}{ m,n }符号),斯宾塞图书馆有一个最大255。ICU没有这样的限制,虽然比赛引擎的最大数量有限的步骤可以通过设置regexp_time_limit系统变量

  • ICU解释括号为元字符。指定文字括号(在一个正则表达式,它必须逃跑:

    MySQL的&#62;SELECT REGEXP_LIKE('(', '(');错误3692(hy000):不匹配的括号中的正则表达式。MySQL &#62;SELECT REGEXP_LIKE('(', '\\(');------------------------- | regexp_like(&#39;(&#39;,&#39; \(&#39;)| ------------------------- | 1 | -------------------------

12.5.3字符集和功能结果的整理

MySQL有很多的运算符和函数返回一个字符串。这部分回答了这个问题:字符集,这样一个字符串排序是什么?

对于简单的函数,字符串的输入和输出返回一个字符串,输出的字符集和整理,作为委托人的输入值相同。例如,UPPER(X)返回一个具有相同的字符串排序字符串X。这同样适用于INSTR()LCASE()LOWER()LTRIM()MID()REPEAT()REPLACE()REVERSE()RIGHT()RPAD()RTRIM()SOUNDEX()SUBSTRING()TRIM()UCASE(),和UPPER()

笔记

这个REPLACE()功能,与所有其他功能,总是忽略字符串输入的排序规则和执行区分大小写的比较。

如果输入的字符串或函数的结果是一个二进制字符串,该字符串有binary字符集和整理。这可供使用CHARSET()COLLATION()的功能,两者的回报二元的对于二进制字符串参数:

mysql> SELECT CHARSET(BINARY 'a'), COLLATION(BINARY 'a');
+---------------------+-----------------------+
| CHARSET(BINARY 'a') | COLLATION(BINARY 'a') |
+---------------------+-----------------------+
| binary              | binary                |
+---------------------+-----------------------+

操作,将多个字符串输入并返回一个字符串的输出,聚合规则标准SQL应用测定结果的整理:

  • 如果一个明确的COLLATE Y时,使用Y

  • 如果显式COLLATE Y整理Z占领,铁轨

  • 否则,如果所有的排序规则。Y,使用Y

  • 否则,结果有没有collation。

例如,用CASE ... WHEN a THEN b WHEN b THEN c COLLATE X END《冰resulting collationX。这同样适用于UNION||CONCAT()ELT()GREATEST()IF(),和LEAST()

操作转换为字符数据,字符集和整理,结果字符串操作定义的character_set_connectioncollation_connection系统变量确定默认的连接字符集和整理(见10.4节,“连接字符集和Collations”)。applies only to thisBIN_TO_UUID()CAST()CONV()FORMAT()HEX(),和SPACE()

上述原则例外发生虚拟生成的列的表达式。在这样的表达式表的字符集是用于BIN_TO_UUID()CONV(),或HEX()结果,无论连接字符集。

如果你有任何问题关于结果的字符集或排序的字符串函数返回,使用CHARSET()COLLATION()功能发现:

MySQL的&#62;SELECT USER(), CHARSET(USER()), COLLATION(USER());---------------- ----------------- ------------------- | user() |字符集(user())|整理(user())| ---------------- ----------------- ------------------- |测试@本地| UTF8 | utf8_general_ci | ---------------- ----------------- ------------------- MySQL &#62;SELECT CHARSET(COMPRESS('abc')), COLLATION(COMPRESS('abc'));-------------------------- ---------------------------- |字符集(压缩(ABC”))|整理(压缩(ABC”))| -------------------------- ---------------------------- |二进制|二进制| -------------------------- ----------------------------

12.6数值函数和操作符

表12.10数值函数和操作符

姓名描述
ABS()收益的绝对值
ACOS()返回余弦
ASIN()回弧正弦
ATAN()返回的圆弧切线
ATAN2()atan()重复两个论点的弧探戈。
CEIL()返回的最小整数值不小于参数
CEILING()返回的最小整数值不小于参数
CONV()将不同数量的碱基之间的数字
COS()返回余弦
COT()返回的余切
CRC32()计算循环冗余校验值
DEGREES()弧度转换为度
DIV整数除法
/除法运算符
EXP()提高功率
FLOOR()回报的最大整数值不大于参数
LN()返回参数的自然对数
LOG()返回第一个参数的自然对数
LOG10()返回参数10为底的对数
LOG2()返回参数的基-2对数
-减算子
MOD()返回余数
%国防部模运算符
PI()返回圆周率的值
+加法运算符
POW()返回参数的指定次幂
POWER()返回参数的指定次幂
RADIANS()返回参数转换为弧度
RAND()返回一个随机浮点值
ROUND()一轮争论
SIGN()返回的参数符号
SIN()返回自己的论点
SQRT()返回参数的平方根
TAN()返回正切的论点
*乘法算子
TRUNCATE()将指定的小数位数
-修改实参的标志

12.6.1算术运算符

表12.11算术运算符

姓名描述
DIV整数除法
/除法运算符
-减算子
%国防部模运算符
+加法运算符
*乘法算子
-修改实参的标志

通常的算术运算符是可用的。结果是根据以下规则确定:

  • 在的情况下-+,和*,结果计算BIGINT(64)精度,如果两个操作数都是整数。

  • 如果两个操作数都是整数,其中任何一个都是无符号的,结果是一个无符号整数。减法,如果NO_UNSIGNED_SUBTRACTIONSQL模式开启,结果是签署了即使任何操作数是无符号。

  • 如果任何一个操作数+-/*%是一个真正的或字符串值,结果的精度与最大精度的操作数的精度。

  • 在分工进行/,规模的结果时,使用两个精确值的操作数是第一个操作数的值加上规模div_precision_increment系统变量(默认值是4)。例如,表达式的结果5.05 / 0.014有一个规模六位小数(360.714286

这些规则适用于每一操作,这样的嵌套计算意味着每个部件的精度。因此,(14620 / 9432456) / (24250 / 9432456)首先,解决了(0.0014)/(0.0026),与最终的结果有8位小数(0.60288653

由于这些规则和它们的应用方式,应注意确保组件和子组件使用的计算精度适当的水平。看到12.10节,“铸函数和操作符”

对数值表达式求值的溢出处理信息,看第11.2.6,“超出范围和溢出处理”

算术运算符可以应用于数字。对于其他类型的值,可替代操作。例如,添加日期值,使用DATE_ADD()它;12.7节,“戴特和时间函数”

  • +

    此外:

    mysql> SELECT 3+5;
            -> 8
    
  • -

    subtraction:

    mysql> SELECT 3-5;
            -> -2
    
  • -

    一元减号。这个操作符的操作数的符号的变化。

    mysql> SELECT - 2;
            -> -2
    
    笔记

    如果这个操作符一起使用BIGINT,返回值也是一个BIGINT。这意味着你应该避免使用整数,可能有?值2六十三

  • *

    乘法:

    mysql> SELECT 3*5;
            -> 15
    mysql> SELECT 18014398509481984*18014398509481984.0;
            -> 324518553658426726783156020576256.0
    mysql> SELECT 18014398509481984*18014398509481984;
            -> out-of-range error
    

    最后的表达,因为整数乘法的结果超过64位的范围内产生一个错误BIGINT计算。(见)11.2节,“数字类型”。)

  • /

    师:

    mysql> SELECT 3/5;
            -> 0.60
    

    被零除产生NULL结果

    MySQL的&#62;SELECT 102/(1-1);>0

    除法计算BIGINT算法只有在上下文中执行的结果转换为一个整数。

  • DIV

    整数除法。从划分结果的任何小数部分小数点右边的丢弃。

    如果一个操作数是一个整数类型的操作数转换为DECIMAL分利用DECIMAL算术转换之前的结果BIGINT。如果结果超过bigint范围内,发生了一个错误。

    mysql> SELECT 5 DIV 2, -5 DIV 2, 5 DIV -2, -5 DIV -2;
            -> 2, -2, -2, 2
    
  • N % MN MOD M

    取模运算。《大学remainder归来N除以M。有关更多信息,请参阅说明书MOD()功能部分可以声明为任意类型,“数学函数”

可以声明为任意类型的数学函数

表12.12数学函数

姓名描述
ABS()收益的绝对值
ACOS()返回余弦
ASIN()回弧正弦
ATAN()返回的圆弧切线
ATAN2()atan()重复两个论点的弧探戈。
CEIL()返回的最小整数值不小于参数
CEILING()返回的最小整数值不小于参数
CONV()将不同数量的碱基之间的数字
COS()返回余弦
COT()返回的余切
CRC32()计算循环冗余校验值
DEGREES()弧度转换为度
EXP()提高功率
FLOOR()回报的最大整数值不大于参数
LN()返回参数的自然对数
LOG()返回第一个参数的自然对数
LOG10()返回参数10为底的对数
LOG2()返回参数的基-2对数
MOD()返回余数
PI()返回圆周率的值
POW()返回参数的指定次幂
POWER()返回参数的指定次幂
RADIANS()返回参数转换为弧度
RAND()返回一个随机浮点值
ROUND()一轮争论
SIGN()返回的参数符号
SIN()返回自己的论点
SQRT()返回参数的平方根
TAN()返回正切的论点
TRUNCATE()将指定的小数位数

所有的数学函数返回NULL在发生错误

  • ABS(X)

    收益率的绝对值X

    MySQL的&#62;SELECT ABS(2);-> 2mysql>SELECT ABS(-32);&#62; 32

    此功能是安全的使用BIGINT价值观

  • ACOS(X)

    返回弧余弦X,即其余弦值X。退货无效的如果X不在范围内- 11

    MySQL的&#62;SELECT ACOS(1);-> 0mysql>SELECT ACOS(1.0001);-> NULLmysql>SELECT ACOS(0);&#62; 1.5707963267949
  • ASIN(X)

    returns的弧的sineX,即其正弦值X。退货无效的如果X不在范围内- 11

    MySQL的&#62;SELECT ASIN(0.2);-> 0.20135792079033mysql>SELECT ASIN('foo');------------- |阿辛(&#39;foo”)| ------------- | 0 | ------------- 1行集,1报警(0秒)MySQL &#62;SHOW WARNINGS;--------- ------ ----------------------------------------- |水平|代码|消息| --------- ------ ----------------------------------------- |警告| 1292 |截断错误的双重价值:foo | --------- ------ -----------------------------------------
  • ATAN(X)

    返回圆弧切线X,即其正切值X

    MySQL的&#62;SELECT ATAN(2);-> 1.1071487177941mysql>SELECT ATAN(-2);-&#62; -1.1071487177941
  • ATAN(Y,X)ATAN2(Y,X)

    返回两个变量的圆弧切线XY。它类似于计算反正切Y/X,除了两个参数的符号是用来确定结果的象限。

    MySQL的&#62;SELECT ATAN(-2,2);-> -0.78539816339745mysql>SELECT ATAN2(PI(),0);&#62; 1.5707963267949
  • CEIL(X)

    CEIL()是同义词CEILING()

  • CEILING(X)

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

    MySQL的&#62;SELECT CEILING(1.23);-> 2mysql>SELECT CEILING(-1.23);&#62; 1

    确切的数值参数,返回值有一个确切的数值型。字符串或浮点数的参数,返回值为浮点型。

  • CONV(N,from_base,to_base)

    不同数目的碱基之间的数字转换。返回数字的字符串表示形式N为基础,from_base基地to_base。退货无效的如果任一参数为NULL。争论N被解释为一个整数,但可以被指定为一个整数或字符串。最小的基和最大基地36。如果from_base是一个负数,N作为一个有符号数。否则,N作为无符号CONV()64位精度的作品

    MySQL的&#62;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);- &#62;“40”
  • COS(X)

    returns的cosine的X,在那里X是以弧度

    MySQL的&#62;SELECT COS(PI());&#62; 1
  • COT(X)

    返回cosX

    MySQL的&#62;SELECT COT(12);-> -1.5726734063977mysql>SELECT COT(0);-&#62;超出范围的错误
  • CRC32(expr)

    计算循环冗余校验值并返回一个32位的无符号值。其结果是NULL如果参数是无效的。辩论预计将一个字符串(如果可能的话)被视为一个不。

    mysql> SELECT CRC32('MySQL');
            -> 3259397556
    mysql> SELECT CRC32('mysql');
            -> 2501908538
    
  • DEGREES(X)

    归来的论点X,转换成弧度的转换

    MySQL的&#62;SELECT DEGREES(PI());-> 180mysql>SELECT DEGREES(PI() / 2);&#62; 90
  • EXP(X)

    返回值E(自然对数的底)提出的力量X。这个函数的逆LOG()(只使用一个单一的说法)或LN()

    MySQL的&#62;SELECT EXP(2);-> 7.3890560989307mysql>SELECT EXP(-2);-> 0.13533528323661mysql>SELECT EXP(0);-&#62; 1
  • FLOOR(X)

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

    MySQL的&#62;SELECT FLOOR(1.23), FLOOR(-1.23);- 1 - 2

    确切的数值参数,返回值有一个确切的数值型。字符串或浮点数的参数,返回值为浮点型。

  • FORMAT(X,D)

    格式的数量X一个格式如“#,# # #,# # # # #”。,圆D小数,并以字符串的形式返回结果。详情见12.5节,“字符串函数”

  • HEX(N_or_S)

    这个函数可以用来获得一个十六进制表示一个十进制数字或字符串;它展现的方式根据不同的参数类型。看到这个功能的描述12.5节,“字符串函数”,详情

  • LN(X)

    收益率的自然对数X这是基础—E对数X。如果X小于或等于0.0e0,函数返回无效的和一个警告对数参数无效据报道

    mysql> SELECT LN(2);
            -> 0.69314718055995
    mysql> SELECT LN(-2);
            -> NULL
    

    这个函数是同义词LOG(X)。这个函数的反函数是EXP()功能

  • LOG(X)LOG(B,X)

    如果调用带有一个参数,这个函数返回自然对数X。如果X小于或等于0.0e0,函数返回无效的和一个警告对数参数无效据报道

    这个函数的反函数(当使用一个参数)是EXP()功能

    MySQL的&#62;SELECT LOG(2);-> 0.69314718055995mysql>SELECT LOG(-2);>0

    如果说有两个参数,这个函数返回对数X到基地B。如果X小于或等于0,或如果B小于或等于1,那么无效的返回

    mysql> SELECT LOG(2,65536);
            -> 16
    mysql> SELECT LOG(10,100);
            -> 2
    mysql> SELECT LOG(1,100);
            -> NULL
    

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

  • LOG2(X)

    返回基-2对数X。如果X小于或等于0.0e0,函数返回无效的和一个警告对数参数无效据报道

    mysql> SELECT LOG2(65536);
            -> 16
    mysql> SELECT LOG2(-100);
            -> NULL
    

    LOG2()找出多少比特数需要存储有用。这个函数是等价的表达LOG(X) / LOG(2)

  • LOG10(X)

    以10为底的对数收益率X。如果X小于或等于0.0e0,函数返回无效的和一个警告对数参数无效据报道

    mysql> SELECT LOG10(2);
            -> 0.30102999566398
    mysql> SELECT LOG10(100);
            -> 2
    mysql> SELECT LOG10(-100);
            -> NULL
    

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

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

    取模运算。《大学remainder归来N除以M

    MySQL的&#62;SELECT MOD(234, 10);-> 4mysql>SELECT 253 % 7;-> 1mysql>SELECT MOD(29,9);-> 2mysql>SELECT 29 MOD 9;&#62; 2

    此功能是安全的使用BIGINT价值观

    MOD()也有小数部分的值并返回后的剩余部:

    MySQL的&#62;SELECT MOD(34.5,3);&#62; 1.5

    MOD(N,0)退货无效的

  • PI()

    返回π值(PI)。小数点显示默认的号码是7,但MySQL使用完整的双精度值内。

    mysql> SELECT PI();
            -> 3.141593
    mysql> SELECT PI()+0.000000000000000000;
            -> 3.141592653589793116
    
  • POW(X,Y)

    返回值X提高功率的Y

    MySQL的&#62;SELECT POW(2,2);-> 4mysql>SELECT POW(2,-2);&#62; 0.25
  • POWER(X,Y)

    这是一个同义词POW()

  • RADIANS(X)

    归来的论点X,转换为弧度。(注意,π弧度等于180度。)

    MySQL的&#62;SELECT RADIANS(90);&#62; 1.5707963267949
  • RAND([N])

    返回一个随机浮点值v在范围<=v<。获得一个随机整数R在范围i<=R<j,使用表达式FLOOR(i + RAND() * (j?i))。例如,在范围内获得一个随机整数<=R<十二,使用以下语句:

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

    如果一个整型参数N是指定的,它是用来作为种子值:

    • 在一个恒定的初始化参数,种子初始化一次当语句编写,执行之前。

    • 用非恒定的初始化参数(如列名称),种子是为每个调用的值初始化RAND()

    这种行为的一个含义是,相同的参数值,RAND(N)返回相同的值的每个时间,从而产生一个可重复的列值序列。在下面的例子中,价值观产生的序列边缘(3)都是相同的地方出现

    mysql> CREATE TABLE t (i INT);
    Query OK, 0 rows affected (0.42 sec)
    
    mysql> INSERT INTO t VALUES(1),(2),(3);
    Query OK, 3 rows affected (0.00 sec)
    Records: 3  Duplicates: 0  Warnings: 0
    
    mysql> SELECT i, RAND() FROM t;
    +------+------------------+
    | i    | RAND()           |
    +------+------------------+
    |    1 | 0.61914388706828 |
    |    2 | 0.93845168309142 |
    |    3 | 0.83482678498591 |
    +------+------------------+
    3 rows in set (0.00 sec)
    
    mysql> SELECT i, RAND(3) FROM t;
    +------+------------------+
    | i    | RAND(3)          |
    +------+------------------+
    |    1 | 0.90576975597606 |
    |    2 | 0.37307905813035 |
    |    3 | 0.14808605345719 |
    +------+------------------+
    3 rows in set (0.00 sec)
    
    mysql> SELECT i, RAND() FROM t;
    +------+------------------+
    | i    | RAND()           |
    +------+------------------+
    |    1 | 0.35877890638893 |
    |    2 | 0.28941420772058 |
    |    3 | 0.37073435016976 |
    +------+------------------+
    3 rows in set (0.00 sec)
    
    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)
    

    RAND()在一个哪里条款对每行(当选择一个表中的行)或组合(当选择从多个表的连接)。因此,优化的目的,RAND()不是一个恒定值,不能用于索引的优化。有关更多信息,参见第8.2.1.18,函数调用优化”

    使用一列RAND()价值的顺序GROUP BY条款可能会产生意外的结果因为任一条款RAND()表达式可以计算多次为同一排,每次返回不同的结果。如果目标是检索随机排序的列,你可以使用下面的语句:

    SELECT * FROMtbl_name为了rand();

    选择一组行的一个随机样本,结合ORDER BY RAND()极限

    SELECT * FROM table1, table2 WHERE a=b AND c<d ORDER BY RAND() LIMIT 1000;
    

    RAND()不是一个完美的随机数发生器。这是一个产生需求,对于相同的MySQL版本的便携式平台之间的随机数的快速方法。

    这个函数是基于语句的复制不安全。警告如果你使用这个功能的时候登录binlog_format是集声明。(错误# 49222)

  • ROUND(X)ROUND(X,D)

    回合的争论XD小数位数。舍入算法依赖于数据类型XD如果未指定,默认值为0。D可以是负的原因D数字留下的值的小数点X成为零

    MySQL的&#62;SELECT ROUND(-1.23);-> -1mysql>SELECT ROUND(-1.58);-> -2mysql>SELECT ROUND(1.58);-> 2mysql>SELECT ROUND(1.298, 1);-> 1.3mysql>SELECT ROUND(1.298, 0);-> 1mysql>SELECT ROUND(23.298, -1);-&#62; 20

    返回值的类型作为第一个参数相同(假设它是整数,双,或小数)。这意味着一个整数参数,其结果是一个整数(没有小数点):

    mysql> SELECT ROUND(150.000,2), ROUND(150,2);
    +------------------+--------------+
    | ROUND(150.000,2) | ROUND(150,2) |
    +------------------+--------------+
    |           150.00 |          150 |
    +------------------+--------------+
    

    ROUND()使用下面的规则取决于第一个参数的类型:

    • 为准确值数,ROUND()使用圆的一半的距离为零舍入为最接近的整数规则:一个小数部分的值。5或更大的圆形的到下一个整数如果阳性或到下一个整数如果负。(换句话说,它是圆形的远离零。)一个没有小数部分的值。五向下舍入到下一个整数如果阳性或到下一个整数如果负。

    • 近似值的数字,结果取决于C库。在许多系统中,这意味着ROUND()采用圆最近甚至”法则:任何一个小数部分的值被舍入到最近的整数。

    下面的示例演示如何绕过不同的精确的和近似值:

    mysql> SELECT ROUND(2.5), ROUND(25E-1);
    +------------+--------------+
    | ROUND(2.5) | ROUND(25E-1) |
    +------------+--------------+
    | 3          |            2 |
    +------------+--------------+
    

    有关更多信息,参见12.23节,“精确数学”

  • SIGN(X)

    返回自变量的符号-1,或1,取决于X为负,零或正

    MySQL的&#62;SELECT SIGN(-32);-> -1mysql>SELECT SIGN(0);-> 0mysql>SELECT SIGN(234);-&#62; 1
  • SIN(X)

    返回正弦X,在那里X是以弧度

    MySQL的&#62;SELECT SIN(PI());-> 1.2246063538224e-16mysql>SELECT ROUND(SIN(PI()));&#62; 0
  • SQRT(X)

    返回一个非负数的平方根X

    MySQL的&#62;SELECT SQRT(4);-> 2mysql>SELECT SQRT(20);-> 4.4721359549996mysql>SELECT SQRT(-16);>0
  • TAN(X)

    剧情《键》X,在那里X是以弧度

    MySQL的&#62;SELECT TAN(PI());-> -1.2246063538224e-16mysql>SELECT TAN(PI()+1);-&#62; 1.5574077246549
  • TRUNCATE(X,D)

    返回数X大,truncatedD小数位数。如果D,结果没有小数点,小数部分。D可以是负的原因D数字留下的值的小数点X成为零

    MySQL的&#62;SELECT TRUNCATE(1.223,1);-> 1.2mysql>SELECT TRUNCATE(1.999,1);-> 1.9mysql>SELECT TRUNCATE(1.999,0);-> 1mysql>SELECT TRUNCATE(-1.999,1);-> -1.9mysql>SELECT TRUNCATE(122,-2);-> 100mysql>SELECT TRUNCATE(10.28*100,0);&#62; 1028

    所有的数字都是圆向零。

12.7日期和时间函数

本节介绍可用于操纵时间价值函数。看到11.3节,“戴特时间类型”,一个描述的范围的值的每个日期和时间类型和有效格式的值可以指定。

表12.13日期和时间函数

姓名描述
ADDDATE()添加时间值(区间)的一个日期值
ADDTIME()添加时间
CONVERT_TZ()从一个时区转换到另一个
CURDATE()返回当前的日期
CURRENT_DATE()current_date为curdate(同义词)
CURRENT_TIME()current_timesynonyms为curtime()
CURRENT_TIMESTAMP()current_timestamp现在(同义词)
CURTIME()返回当前时间
DATE()提取日期部分的日期或日期时间表达式
DATE_ADD()添加时间值(区间)的一个日期值
DATE_FORMAT()指定的日期格式
DATE_SUB()用一个时间值(区间)从一个日期
DATEDIFF()减去两日期
DAY()为dayofmonth(同义词)
DAYNAME()返回的名称为“weekday
DAYOFMONTH()月的一天返回(0~31)
DAYOFWEEK()return the优化参数指标of the
DAYOFYEAR()这一天是这一年的回报(1-366)
EXTRACT()提取日期部分
FROM_DAYS()一天一日数转换
FROM_UNIXTIME()Unix时间戳为日期格式
GET_FORMAT()返回日期格式字符串
HOUR()提取时间
LAST_DAY为论证该月最后一天返回
LOCALTIME()当地时间现在(同义词)
LOCALTIMESTAMPlocaltimestamp()现在(同义词)
MAKEDATE()创建从今年一年的日期
MAKETIME()创建从小时,分钟,秒
MICROSECOND()返回参数的微秒
MINUTE()返回参数分
MONTH()返回日期的一个月已经过去
MONTHNAME()返回的月份名称
NOW()返回当前的日期和时间
PERIOD_ADD()加上一个期限至年月
PERIOD_DIFF()返回月之间的周期数
QUARTER()从一季度的日期参数返回
SEC_TO_TIME()将秒的HH:MM:SS的格式
SECOND()在第二个return(0~59)
STR_TO_DATE()将字符串转换为日期
SUBDATE()同义词date_sub()当调用三个参数
SUBTIME()减倍
SYSDATE()返回时间的函数执行
TIME()提取表达时间部分通过
TIME_FORMAT()时间格式为
TIME_TO_SEC()返回参数转换为秒
TIMEDIFF()减时间
TIMESTAMP()一个参数,这个函数返回的日期或日期时间表达式;有两个论点,论据的总和
TIMESTAMPADD()添加一个间隔的日期的表达
TIMESTAMPDIFF()从一个DateTime表达区间
TO_DAYS()返回日期参数转换为天
TO_SECONDS()返回日期或日期时间转换为秒0年以来争论
UNIX_TIMESTAMP()返回一个时间戳
UTC_DATE()返回当前的UTC日期
UTC_TIME()返回当前的UTC时间
UTC_TIMESTAMP()返回当前的UTC日期和时间
WEEK()返回的周数
WEEKDAY()return the WeekDay指数
WEEKOFYEAR()日期的日历周回报(1-53)
YEAR()回归年
YEARWEEK()回归年和星期

这里有一个例子,使用日期函数。下面的查询选择所有的行与date_col在过去30天的价值:

MySQL的&#62;SELECT something FROM tbl_name-&#62;WHERE DATE_SUB(CURDATE(),INTERVAL 30 DAY) <= date_col;

查询选择日期,在未来的行。

功能,预计日期值通常接受DateTime值,忽略了时间的一部分。功能,期望时间值通常接受DateTime值,忽略日期部分。

函数返回每个每查询一次在查询开始执行对当前日期或时间。这意味着多个引用函数等NOW()在一个单一的查询总是产生相同的结果。(对于我们而言,一个单一的查询还包括调用存储程序(存储过程,触发器,或事件)和调用的程序的所有子程序。)这个原则也适用于CURDATE()CURTIME()UTC_DATE()UTC_TIME()UTC_TIMESTAMP(),和任何他们的同义词。

这个CURRENT_TIMESTAMP()CURRENT_TIME()CURRENT_DATE(),和FROM_UNIXTIME()函数的返回值在连接的当前时区,这是有价值的time_zone系统变量。此外,UNIX_TIMESTAMP()假定其参数是当前时区的日期时间值。看到第5.1.12,MySQL服务器的时区支持”

一些日期函数可以使用日期或日期等不完全'2001-11-00',而别人不能。功能:日期提取部位通常工作与不完整的日期和可返回0时,否则你可能期望一个非零的值。例如:

MySQL的&#62;SELECT DAYOFMONTH('2001-11-00'), MONTH('2005-00-00');&#62; 0、0

预计完成日期和归还等功能NULL对于不完整的日期。这些包括执行日期运算或地图部分日期名称功能。例如:

MySQL的&#62;SELECT DATE_ADD('2006-05-00',INTERVAL 1 DAY);-> NULLmysql>SELECT DAYNAME('2006-05-00');>0

一些功能是更严格时,通过DATE()函数值作为他们的论点,拒绝与零日部分不完整的日期。这些功能的影响:CONVERT_TZ()DATE_ADD()DATE_SUB()DAYOFYEAR()LAST_DAY()(允许零天部分),TIMESTAMPDIFF()TO_DAYS()TO_SECONDS()WEEK()WEEKDAY()WEEKOFYEAR()YEARWEEK()

分数秒TIME日期时间,和TIMESTAMP价值观的支持,达到微秒级精度。带时间参数的值函数接受分数秒。从时间的函数的返回值包括小数秒为宜。

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

    当调用的INTERVALform of the第二论点ADDDATE()是同义词DATE_ADD()。相关函数SUBDATE()是同义词DATE_SUB()。信息的区间unit的说法,看到的讨论DATE_ADD()

    MySQL的&#62;SELECT DATE_ADD('2008-01-02', INTERVAL 31 DAY);-> '2008-02-02'mysql>SELECT ADDDATE('2008-01-02', INTERVAL 31 DAY);- &#62;“2008-02-02”

    当调用的days第二个参数表,MySQL将它作为一个整数的天数增加expr

    MySQL的&#62;SELECT ADDDATE('2008-01-02', 31);- &#62;“2008-02-02”
  • ADDTIME(expr1,expr2)

    ADDTIME()增加了expr2expr1并返回结果expr1是一个时间或日期时间表达式,并expr2是一个时间的表达

    MySQL的&#62;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');“99999 7”03:00:01. -&#62;
  • CONVERT_TZ(dt,from_tz,to_tz)

    CONVERT_TZ()转换为DateTime值dt从时区了from_tz在给定的时间区to_tz并返回结果值。时区指定为描述第5.1.12,MySQL服务器的时区支持”。。。。。。。这个函数时返回NULL如果参数是无效的

    如果该值不在支持的范围TIMESTAMP当转换型from_tzUTC,没有发生转换。这个TIMESTAMP范围描述11.1.2节,“戴特和时间类型概述”

    mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');
            -> '2004-01-01 13:00:00'
    mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');
            -> '2004-01-01 22:00:00'
    
    笔记

    使用指定的时区等'MET'欧洲/莫斯科带表,必须正确设置时间。看到第5.1.12,MySQL服务器的时区支持”,说明

  • CURDATE()

    作为值返回当前的日期'YYYY-MM-DD'年月日格式,这取决于功能是用一个字符串或数字语境。

    mysql> SELECT CURDATE();
            -> '2008-06-13'
    mysql> SELECT CURDATE() + 0;
            -> 20080613
    
  • CURRENT_DATECURRENT_DATE()

    CURRENT_DATECURRENT_DATE()是同义词CURDATE()

  • CURRENT_TIMECURRENT_TIME([fsp])

    CURRENT_TIMECURRENT_TIME()是同义词CURTIME()

  • CURRENT_TIMESTAMPCURRENT_TIMESTAMP([fsp])

    CURRENT_TIMESTAMPCURRENT_TIMESTAMP()是同义词NOW()

  • CURTIME([fsp])

    返回当前时间作为一种价值'HH:MM:SS'hhmmss格式,这取决于功能是用一个字符串或数字语境。价值是当前时区的表达。

    如果fsp给出参数指定从0到6秒的小数部分的精度,返回值包括小数秒的一部分,许多数字。

    MySQL的&#62;SELECT CURTIME();-> '23:50:26'mysql>SELECT CURTIME() + 0;&#62; 235026
  • DATE(expr)

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

    MySQL的&#62;SELECT DATE('2003-12-31 01:02:03');- &#62;“2003-12-31”
  • DATEDIFF(expr1,expr2)

    DATEDIFF()退货expr1?expr2表示为从一个日期时间值的其他。expr1expr2是日期或日期和时间的表达。只有值的日期部分进行计算。

    MySQL的&#62;SELECT DATEDIFF('2007-12-31 23:59:59','2007-12-30');-> 1mysql>SELECT DATEDIFF('2010-11-30 23:59:59','2010-12-31');&#62; 31
  • DATE_ADD(date,INTERVAL expr unit)DATE_SUB(date,INTERVAL expr unit)

    这些函数执行日期运算。这个date参数指定开始日期或日期时间值。expr指定要添加或从中减去起始日期区间值的表达式。expr是一个字符串;它可能一开始负区间unit是一个关键字表示单位的表达应解释。

    这个INTERVAL关键词和unit名不区分大小写

    下表显示了预期的形成expr参数为每个unit价值

    unit价值预期expr格式
    MICROSECONDMICROSECONDS
    SECONDSECONDS
    MINUTEMINUTES
    HOURHOURS
    DAYDAYS
    WEEKWEEKS
    MONTHMONTHS
    QUARTERQUARTERS
    YEARYEARS
    SECOND_MICROSECOND'SECONDS.MICROSECONDS'
    MINUTE_MICROSECOND'MINUTES:SECONDS.MICROSECONDS'
    MINUTE_SECOND'MINUTES:SECONDS'
    HOUR_MICROSECOND'HOURS:MINUTES:SECONDS.MICROSECONDS'
    HOUR_SECOND'HOURS:MINUTES:SECONDS'
    HOUR_MINUTE'HOURS:MINUTES'
    DAY_MICROSECOND'DAYS HOURS:MINUTES:SECONDS.MICROSECONDS'
    DAY_SECOND'DAYS HOURS:MINUTES:SECONDS'
    DAY_MINUTE'DAYS HOURS:MINUTES'
    DAY_HOUR'DAYS HOURS'
    YEAR_MONTH'YEARS-MONTHS'

    返回值取决于参数:

    • DATETIME如果第一个参数是一个DATETIME(或TIMESTAMPif the first value),or argument is aDATEunit价值用途小时MINUTES,或

    • 字符串,否则

    为了确保结果DATETIME,你可以使用CAST()将第一个参数DATETIME

    MySQL允许任何标点符号分隔符在exprFormat .shown in the table those are the suggested分隔符。if thedate参数是一个DATE价值和你的计算只涉及MONTH,和部分(即,没有时间部分),其结果是DATE值。否则,结果是DATETIME价值

    日期的计算也可以使用INTERVAL一起+-运营商:

    date区间exprunit日期区间exprunit

    INTERVAL expr unit允许对任何一方+运营商如果在另一边的表达式是一个日期或日期时间值。对于-算子,区间exprunit只允许在右侧,因为从一个区间减去一个日期或日期时间值是没有意义的。

    MySQL的&#62;SELECT '2008-12-31 23:59:59' + INTERVAL 1 SECOND;-> '2009-01-01 00:00:00'mysql>SELECT INTERVAL 1 DAY + '2008-12-31';-> '2009-01-01'mysql>SELECT '2005-01-01' - INTERVAL 1 SECOND;-> '2004-12-31 23:59:59'mysql>SELECT DATE_ADD('2000-12-31 23:59:59',-&#62;                INTERVAL 1 SECOND);-> '2001-01-01 00:00:00'mysql>SELECT DATE_ADD('2010-12-31 23:59:59',-&#62;                INTERVAL 1 DAY);-> '2011-01-01 23:59:59'mysql>SELECT DATE_ADD('2100-12-31 23:59:59',-&#62;                INTERVAL '1:1' MINUTE_SECOND);-> '2101-01-01 00:01:00'mysql>SELECT DATE_SUB('2005-01-01 00:00:00',-&#62;                INTERVAL '1 1:1:1' DAY_SECOND);-> '2004-12-30 22:58:59'mysql>SELECT DATE_ADD('1900-01-01 00:00:00',-&#62;                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',-&#62;INTERVAL '1.999999' SECOND_MICROSECOND);- &#62;“1993-01-01 00:00:01. 00000 1

    如果你指定一个区间值,太短(不包括所有的间隔部分,预计将从unit关键词),MySQL假定你的区间值最左边的部分了。例如,如果你指定一个unit属于第二天,价值expr预计有天、小时、分钟和秒,部分。如果你指定一个值,如“10”,MySQL假定天数和小时部分缺失和价值代表分钟和秒。换句话说,'1:10' DAY_SECOND就是在这样一种方式,它相当于解释&#39; &#39; minute_second 1:10。这是类似于MySQL的解读方式TIME价值观为代表的时间而不是一天的时间。

    因为expr被视为一个字符串,如果你指定一个非字符串值与小心区间。例如,一个间隔符HOUR_MINUTE6/4评价1.5000被视为1小时,5000分钟:

    MySQL的&#62;SELECT 6/4;-> 1.5000mysql>SELECT DATE_ADD('2009-01-01', INTERVAL 6/4 HOUR_MINUTE);- &#62;“2009-01-04 12:20:00”

    为了保证区间值解释为你所期望的,一CAST()作业可以使用。治疗6/41小时,5分钟,把它转换成DECIMAL一个单一的分数数字值:

    MySQL的&#62;SELECT CAST(6/4 AS DECIMAL(3,1));-> 1.5mysql>SELECT DATE_ADD('1970-01-01 12:00:00',-&#62;                INTERVAL CAST(6/4 AS DECIMAL(3,1)) HOUR_MINUTE);- &#62;“1970-01-01 13:05:00”

    如果你增加或减少一个日期值的东西,包含了一部分时间,结果自动转换为DateTime值:

    mysql> SELECT DATE_ADD('2013-01-01', INTERVAL 1 DAY);
            -> '2013-01-02'
    mysql> SELECT DATE_ADD('2013-01-01', INTERVAL 1 HOUR);
            -> '2013-01-01 01:00:00'
    

    如果你加入MONTHyear_month,或YEAR以及由此产生的日期也一天比一天的最大的新的一个月,一天调整到新的月最大日:

    MySQL的&#62;SELECT DATE_ADD('2009-01-30', INTERVAL 1 MONTH);- &#62;“2009-02-28”

    日期运算要求完成日期和不完备的日期如工作'2006-07-00'或严重畸形的日期:

    MySQL的&#62;SELECT DATE_ADD('2006-07-00', INTERVAL 1 DAY);-> NULLmysql>SELECT '2005-03-32' + INTERVAL 1 MONTH;>0
  • DATE_FORMAT(date,format)

    格式date价值根据format字符串

    以下说明可用于format字符串这个%字符格式说明符字符所需的前。

    说明符描述
    %a工作日的名称(缩写Sun..SAT考试
    %b(abbreviated month nameJan..东方电气
    %c月,数字(0..十二
    %D天月(英语后缀0th第一2nd第三,…)
    %d白昼之月,数值(00..三十一
    %e白昼之月,数值(0..三十一
    %f微秒000000..九十九万九千九百九十九
    %H小时(00..二十三
    %h小时(01..十二
    %I小时(01..十二
    %i分钟,数值(00..五十九
    %j年月日(001..三百六十六
    %k小时(0..二十三
    %l小时(1..十二
    %Mmonth name(January..十二月
    %m月,数字(00..十二
    %pAM颗粒物
    %r时间,12小时(hh:mm:ss然后调幅PM
    %S第二(00..五十九
    %s第二(00..五十九
    %T时间,24小时(hh:mm:ss
    %U周(00..五十三),周末是一周的第一天;WEEK()模式0
    %u周(00..五十三),在下周一是一周的第一天;WEEK()模式1
    %V周(01..五十三),周末是一周的第一天;WEEK()模式二;used withX %
    %v周(01..五十三),在下周一是一周的第一天;WEEK()模式3X %
    %Wweekday name(Sunday..星期六
    %w《周(日0=Sunday..=Saturday)
    %X本周,星期日是一周的第一天,数字,四位数的年;使用%V
    %x本周的一年,在日是一周的第一天,数字,4位;使用%v
    %Y年,数字,4位
    %y年,数字(两位数)
    %%一个文字%人物
    %xx,任何x以上未列出的

    这个月的天符范围开始零由于MySQL允许不完整的日期,如存储'2014-00-00'

    语言用于日期和月份的名称和缩写的值控制lc_time_names系统变量(10.15节,“MySQL服务器的区域设置的支持”

    对于%U%V,和五%说明符,看到的描述WEEK()关于模式的信息功能。模式如何影响周编号发生。

    DATE_FORMAT()返回一个字符串与字符集和整理了character_set_connectioncollation_connection因此,它可以返回月包含非ASCII字符的星期名称。

    MySQL的&#62;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',-&#62;                '%D %y %a %d %m %b %j');-> '4th 00 Thu 04 10 Oct 277'mysql>SELECT DATE_FORMAT('1997-10-04 22:23:00',-&#62;                '%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');- &#62;“00”
  • DATE_SUB(date,INTERVAL expr unit)

    看到描述DATE_ADD()

  • DAY(date)

    DAY()是同义词DAYOFMONTH()

  • DAYNAME(date)

    returns weekday为名人的名字date。用于名称的语言值的控制lc_time_names系统变量(10.15节,“MySQL服务器的区域设置的支持”

    mysql> SELECT DAYNAME('2007-02-03');
            -> 'Saturday'
    
  • DAYOFMONTH(date)

    returns天月为研究date在这个范围内,31,或日期等'0000-00-00'“2008-00-00”有一个零日

    mysql> SELECT DAYOFMONTH('2007-02-03');
            -> 3
    
  • DAYOFWEEK(date)

    重新计算星期天索引date= Sunday,2= Monday, …,= Saturday). These index values correspond to the ODBC standard.

    mysql> SELECT DAYOFWEEK('2007-02-03');
            -> 7
    
  • DAYOFYEAR(date)

    返回一年的日子date在这个范围内,366

    MySQL的&#62;SELECT DAYOFYEAR('2007-02-03');&#62; 34
  • EXTRACT(unit FROM date)

    这个EXTRACT()函数使用单位说明符相同DATE_ADD()DATE_SUB(),但萃取部分的日期而不是执行日期运算。

    MySQL的&#62;SELECT EXTRACT(YEAR FROM '2009-07-02');-> 2009mysql>SELECT EXTRACT(YEAR_MONTH FROM '2009-07-02 01:02:03');-> 200907mysql>SELECT EXTRACT(DAY_MINUTE FROM '2009-07-02 01:02:03');-> 20102mysql>SELECT EXTRACT(MICROSECOND-&#62;FROM '2003-01-02 10:30:00.000123');&#62; 123
  • FROM_DAYS(N)

    给定一个日数N,返回DATE价值

    MySQL的&#62;SELECT FROM_DAYS(730669);- &#62;“2000-07-03”

    使用FROM_DAYS()在旧的日期提醒。它的目的不是用于之前的公历的到来值(1582)。看到12.8节,“什么日历是用MySQL?“

  • FROM_UNIXTIME(unix_timestamp)FROM_UNIXTIME(unix_timestamp,format)

    返回一个表示unix_timestamp论证作为一种价值“YYYY-MM-DD HH:MM:SS”YYYYMMDDHHMMSS格式,这取决于功能是用一个字符串或数字语境。价值是当前时区的表达。unix_timestamp是一个内部的时间戳值如是由UNIX_TIMESTAMP()功能

    如果format给出的结果是根据格式化format字符串,这是用同样的方式在为进入上市DATE_FORMAT()功能

    MySQL的&#62;SELECT FROM_UNIXTIME(1447430881);-> '2015-11-13 10:08:01'mysql>SELECT FROM_UNIXTIME(1447430881) + 0;-> 20151113100801mysql>SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(),-&#62;'%Y %D %M %h:%i:%s %x');- &#62;“2015年11月13日10:08:01 2015年”

    注意:如果你使用UNIX_TIMESTAMP()FROM_UNIXTIME()之间的转换TIMESTAMP价值观和Unix时间戳值,转换损耗由于映射不是双向的一对一。详情见的描述UNIX_TIMESTAMP()功能

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

    返回一个字符串格式。这个功能是结合有用DATE_FORMAT()STR_TO_DATE()功能.

    对于第一个和第二个参数结果在几个可能的格式字符串可能的值(为说明使用,看到在桌子上DATE_FORMAT()功能描述)。ISO格式是ISO 9075,ISO 8601,不。

    TIMESTAMP也可以作为第一个参数GET_FORMAT(),在这种情况下,函数返回相同的值作为DATETIME

    MySQL的&#62;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'));- &#62;“2003-10-31”
  • HOUR(time)

    返回小时time。返回值的范围23在一天的时间值。然而,范围TIME价值观实际上是更大的,所以小时返回值大于23

    MySQL的&#62;SELECT HOUR('10:05:03');-> 10mysql>SELECT HOUR('272:59:59');&#62; 272
  • LAST_DAY(date)

    以一个日期或日期时间值并返回一个月的最后一天的相应值。退货NULL如果参数是无效的

    MySQL的&#62;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');>0
  • LOCALTIMELOCALTIME([fsp])

    LOCALTIMELOCALTIME()是同义词NOW()

  • LOCALTIMESTAMPLOCALTIMESTAMP([fsp])

    LOCALTIMESTAMPLOCALTIMESTAMP()是同义词NOW()

  • MAKEDATE(year,dayofyear)

    返回一个日期,年日和年值。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);
            -> NULL
    
  • MAKETIME(hour,minute,second)

    返回时间值的计算从hourminute,和second争论

    这个second参数可以有小数部分

    MySQL的&#62;SELECT MAKETIME(12,15,30);- &#62;“12:15:30”
  • MICROSECOND(expr)

    返回的时间或日期时间表达式微秒expr在范围内的一个数999999

    MySQL的&#62;SELECT MICROSECOND('12:00:00.123456');-> 123456mysql>SELECT MICROSECOND('2009-12-31 23:59:59.000010');&#62; 10
  • MINUTE(time)

    返回分钟time在这个范围内,59

    MySQL的&#62;SELECT MINUTE('2008-02-03 10:05:03');&#62; 5
  • MONTH(date)

    为returns的月date在这个范围内,12今年1月,或日期等'0000-00-00'“2008-00-00”有10个月的部分

    mysql> SELECT MONTH('2008-02-03');
            -> 2
    
  • MONTHNAME(date)

    返回该月的全名date。用于名称的语言值的控制lc_time_names系统变量(10.15节,“MySQL服务器的区域设置的支持”

    mysql> SELECT MONTHNAME('2008-02-03');
            -> 'February'
    
  • NOW([fsp])

    作为值返回当前的日期和时间'YYYY-MM-DD HH:MM:SS'yyyymmddhhmmss格式,这取决于功能是用一个字符串或数字语境。价值是当前时区的表达。

    如果fsp给出参数指定从0到6秒的小数部分的精度,返回值包括小数秒的一部分,许多数字。

    MySQL的&#62;SELECT NOW();-> '2007-12-15 23:50:26'mysql>SELECT NOW() + 0;-&#62; 20071215235026.000000

    NOW()返回一个时间常数,表示时间的语句开始执行。(在存储函数或触发器,NOW()返回的函数或触发语句开始执行的时间。)这不同于行为SYSDATE(),它返回的确切时间,在它执行。

    MySQL的&#62;SELECT NOW(), SLEEP(2), NOW();--------------------- ---------- --------------------- | now() |睡眠(2)| now() | --------------------- ---------- --------------------- | 2006-04-12 13:47:36 | 0 | 2006-04-12 13:47:36 | --------------------- ---------- --------------------- MySQL &#62;SELECT SYSDATE(), SLEEP(2), SYSDATE();Syska()Sysday()Sleep(2)Systime(2)Sysday()Proceedings of 2009-04-12 13 : 47 : 44 pastès 0 disch a 2006-04-12 13 : 47 : 46 Proceedings

    此外,该SET TIMESTAMP语句影响的返回值NOW()但不SYSDATE()。这意味着,在二进制日志的时间戳设置对调用没有影响SYSDATE()。设置时间戳为非零值使每个后续调用NOW()返回值。设置时间戳为零取消这个效果,NOW()再次返回当前的日期和时间。

    看到描述SYSDATE()关于两个函数之间的差异的更多信息。

  • PERIOD_ADD(P,N)

    增加了N个月期P(格式输入时间YYYYMM)。返回值的格式yyyymm。注意期的说法P日期值

    mysql> SELECT PERIOD_ADD(200801,2);
            -> 200803
    
  • PERIOD_DIFF(P1,P2)

    返回月之间的周期数P1P2P1P2应在格式输入时间YYYYMM。注意,时间参数P1P2日期值

    mysql> SELECT PERIOD_DIFF(200802,200703);
            -> 11
    
  • QUARTER(date)

    今年的季度收益date在这个范围内,4

    MySQL的&#62;SELECT QUARTER('2008-04-01');&#62; 2
  • SECOND(time)

    返回第二time在这个范围内,59

    MySQL的&#62;SELECT SECOND('10:05:03');-&#62;三
  • SEC_TO_TIME(seconds)

    返回seconds的说法,转换为小时、分钟和秒,,作为一个TIME价值。结果的范围被限制的TIME数据类型。如果参数对应于此范围以外的值时发出警告。

    MySQL的&#62;SELECT SEC_TO_TIME(2378);-> '00:39:38'mysql>SELECT SEC_TO_TIME(2378) + 0;&#62; 3938
  • STR_TO_DATE(str,format)

    这是对逆DATE_FORMAT()功能。它接受一个字符串str和格式字符串formatSTR_TO_DATE()返回一个DATETIME价值如果格式字符串包含日期和时间部分,或DATETIME如果字符串只包含日期或时间的部分。如果日期、时间或日期值提取str是非法的,STR_TO_DATE()退货无效的你在和预警

    服务器扫描str尝试匹配format它。格式字符串可以包含文本字符和格式说明符开始%。文字字符format必须匹配上str。格式说明符中format必须匹配一个日期或时间的一部分str。这可以用在说明符format,看到DATE_FORMAT()功能描述

    MySQL的&#62;SELECT STR_TO_DATE('01,5,2013','%d,%m,%Y');-> '2013-05-01'mysql>SELECT STR_TO_DATE('May 1, 2013','%M %d,%Y');- &#62;“2013-05-01”

    扫描开始之初strformat发现不匹配。最后多余的字符str被忽略

    MySQL的&#62;SELECT STR_TO_DATE('a09:30:17','a%h:%i:%s');-> '09:30:17'mysql>SELECT STR_TO_DATE('a09:30:17','%h:%i:%s');-> NULLmysql>SELECT STR_TO_DATE('09:30:17a','%h:%i:%s');- &#62;“09:30:17”

    指定的日期或时间的部分有一个值0,所以不完全指定的值str与部分或者全部设置为0,产生一个结果:

    MySQL的&#62;SELECT STR_TO_DATE('abc','abc');-> '0000-00-00'mysql>SELECT STR_TO_DATE('9','%m');-> '0000-09-00'mysql>SELECT STR_TO_DATE('9','%s');- &#62;“00:00:09”

    范围对日期值是描述部件的检查第11.3.1,“时间,日期,和时间戳类型”。这意味着,例如,日期或日期值是0部分除非SQL模式设置为不允许这样的允许值。

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

    如果NO_ZERO_DATENO_ZERO_IN_DATESQL模式开启,零期或部分的日期是不允许的。在这种情况下,STR_TO_DATE()退货无效的并生成一个警告:

    mysql> SET sql_mode = '';
    mysql> SELECT STR_TO_DATE('15:35:00', '%H:%i:%s');
    +-------------------------------------+
    | STR_TO_DATE('15:35:00', '%H:%i:%s') |
    +-------------------------------------+
    | 15:35:00                            |
    +-------------------------------------+
    mysql> SET sql_mode = 'NO_ZERO_IN_DATE';
    mysql> SELECT STR_TO_DATE('15:35:00', '%h:%i:%s');
    +-------------------------------------+
    | STR_TO_DATE('15:35:00', '%h:%i:%s') |
    +-------------------------------------+
    | NULL                                |
    +-------------------------------------+
    mysql> SHOW WARNINGS\G
    *************************** 1. row ***************************
      Level: Warning
       Code: 1411
    Message: Incorrect datetime value: '15:35:00' for function str_to_date
    
    笔记

    你不能使用格式"%X%V"将一周的字符串的日期因为一年的组合和周不唯一地标识一个年份和月份,如果这周过一个月的边界。将一周的日期,你也应该指定工作日:

    MySQL的&#62;SELECT STR_TO_DATE('200442 Monday', '%X%V %W');- &#62;“2004-10-18”
  • SUBDATE(date,INTERVAL expr unit)SUBDATE(expr,days)

    当调用的INTERVALform of the第二论点SUBDATE()是同义词DATE_SUB()。信息的区间unit的说法,看到的讨论DATE_ADD()

    MySQL的&#62;SELECT DATE_SUB('2008-01-02', INTERVAL 31 DAY);-> '2007-12-02'mysql>SELECT SUBDATE('2008-01-02', INTERVAL 31 DAY);- &#62;“2007-12-02”

    第二形式使一个整型值的使用days。在这种情况下,它被解释为天数要减去的日期或日期时间表达式expr

    MySQL的&#62;SELECT SUBDATE('2008-01-02 12:00:00', 31);- &#62;“2007-12-02 12:00:00”
  • SUBTIME(expr1,expr2)

    SUBTIME()退货expr1?expr2表示为一个值在相同的格式expr1expr1是一个时间或日期时间表达式,并expr2是一个时间的表达

    MySQL的&#62;SELECT SUBTIME('2007-12-31 23:59:59.999999','1 1:1:1.000002');-> '2007-12-30 22:58:58.999997'mysql>SELECT SUBTIME('01:00:00.999999', '02:00:00.999998');- &#62;”00:59:59. 999999
  • SYSDATE([fsp])

    作为值返回当前的日期和时间'YYYY-MM-DD HH:MM:SS'yyyymmddhhmmss格式,这取决于功能是用一个字符串或数字语境。

    如果fsp给出参数指定从0到6秒的小数部分的精度,返回值包括小数秒的一部分,许多数字。

    SYSDATE()返回的时间执行。这不同于行为NOW(),它返回一个固定的时间,表示时间的语句开始执行。(在存储函数或触发器,NOW()返回的函数或触发语句开始执行的时间。)

    MySQL的&#62;SELECT NOW(), SLEEP(2), NOW();--------------------- ---------- --------------------- | now() |睡眠(2)| now() | --------------------- ---------- --------------------- | 2006-04-12 13:47:36 | 0 | 2006-04-12 13:47:36 | --------------------- ---------- --------------------- MySQL &#62;SELECT SYSDATE(), SLEEP(2), SYSDATE();Syska()Sysday()Sleep(2)Systime(2)Sysday()Proceedings of 2009-04-12 13 : 47 : 44 pastès 0 disch a 2006-04-12 13 : 47 : 46 Proceedings

    此外,该SET TIMESTAMP语句影响的返回值NOW()但不SYSDATE()。这意味着,在二进制日志的时间戳设置对调用没有影响SYSDATE()

    因为SYSDATE()甚至可以在同一语句返回不同的值,而不受设置时间戳声明,如果使用基于二进制日志是复制的不确定性和不安全。如果这是一个问题,你可以使用基于行的日志。

    或者,您可以使用--sysdate-is-now选择的原因SYSDATE()是一个别名NOW()。这部作品如果选项是对主人和奴隶。

    不确定性的性质SYSDATE()也意味着指标不能用于评价表达式引用它。

  • TIME(expr)

    提取时间的一部分时间或日期时间表达式expr并将其作为字符串返回。

    这个函数是基于语句的复制不安全。警告如果你使用这个功能的时候登录binlog_format是集声明

    mysql> SELECT TIME('2003-12-31 01:02:03');
            -> '01:02:03'
    mysql> SELECT TIME('2003-12-31 01:02:03.000123');
            -> '01:02:03.000123'
    
  • TIMEDIFF(expr1,expr2)

    TIMEDIFF()退货expr1?expr2表达作为时间值expr1expr2是时间或日期和时间的表达方式,但都必须是同一类型。

    返回的结果TIMEDIFF()限制在允许的范围内TIME价值观。或者,你可以使用的功能TIMESTAMPDIFF()UNIX_TIMESTAMP(),两者都返回整数

    MySQL的&#62;SELECT TIMEDIFF('2000:01:01 00:00:00',-&#62;'2000:01:01 00:00:00.000001');-> '-00:00:00.000001'mysql>SELECT TIMEDIFF('2008-12-31 23:59:59.000001',-&#62;                '2008-12-30 01:01:01.000002');- &#62;“46:58:57. 999999
  • TIMESTAMP(expr)TIMESTAMP(expr1,expr2)

    一个参数,这个函数返回的日期或日期时间表达式expr作为一个DateTime值。有两个参数,增加了时间的表达expr2的日期或日期时间表达式expr1作为一个DateTime值返回结果。

    MySQL的&#62;SELECT TIMESTAMP('2003-12-31');-> '2003-12-31 00:00:00'mysql>SELECT TIMESTAMP('2003-12-31 12:00:00','12:00:00');- &#62;“2004-01-01 00:00:00”
  • TIMESTAMPADD(unit,interval,datetime_expr)

    将整数表达式interval的日期或日期时间表达式datetime_expr。联合国interval是由unit的说法,这应该是下列值之一:微秒(微秒),SECOND分钟HOURWEEKQUARTER,或

    这个unit值可以用一个关键词显示指定,或与一个前缀SQL _ TS _。例如,DAYSQL _ DLY _天都是合法的

    mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');
            -> '2003-01-02 00:01:00'
    mysql> SELECT TIMESTAMPADD(WEEK,1,'2003-01-02');
            -> '2003-01-09'
    
  • TIMESTAMPDIFF(unit,datetime_expr1,datetime_expr2)

    退货datetime_expr2?datetime_expr1,在那里datetime_expr1datetime_expr2是日期或日期时间表达式。一个表达式可以是日期和其他的日期;日期值被视为一个具有时间日期“00:00:00”在必要的地方。结果单位(一个整数)是由unit的论点。合法的值unit那些描述的同样的上市TIMESTAMPADD()功能

    MySQL的&#62;SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');-> 3mysql>SELECT TIMESTAMPDIFF(YEAR,'2002-05-01','2001-01-01');-> -1mysql>SELECT TIMESTAMPDIFF(MINUTE,'2003-02-01','2003-05-01 12:05:55');&#62; 128885
    笔记

    的日期或日期时间争论这个函数的顺序是相反的,用TIMESTAMP()当invoked with 2功能参数。

  • TIME_FORMAT(time,format)

    这是用像DATE_FORMAT()功能,但format字符串可以包含只有几个小时,格式说明符,分钟,秒和毫秒。其他项目产生无效的值或0

    如果time值包含一小时部分大于二十三,的%Hk %小时格式说明符生成一个值大于正常范围0..23。其他的小时格式说明符产生小时值模12。

    MySQL的&#62;SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');&#62; 100 100 04 04 4
  • TIME_TO_SEC(time)

    返回time的说法,转换为秒

    MySQL的&#62;SELECT TIME_TO_SEC('22:23:00');-> 80580mysql>SELECT TIME_TO_SEC('00:39:38');&#62; 2378
  • TO_DAYS(date)

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

    MySQL的&#62;SELECT TO_DAYS(950501);-> 728779mysql>SELECT TO_DAYS('2007-10-07');-&#62; 733321

    TO_DAYS()不适合使用与之前的公历的到来值(1582),因为它没有考虑到天时丢失了的日历。日期前1582(可能在其它地方的一年后),从这个函数的结果是不可靠的。看到12.8节,“什么日历是用MySQL?“,详情

    记住,MySQL将两位数的年价值四位数的形式使用日期的规则11.3节,“戴特时间类型”。例如,'2008-10-07'“08-10-07”被视为相同的日期:

    mysql> SELECT TO_DAYS('2008-10-07'), TO_DAYS('08-10-07');
            -> 733687, 733687
    

    在MySQL中,零日被定义为'0000-00-00',尽管这个日期本身视为无效。这意味着,对于“0000-00-00”'0000-01-01'TO_DAYS()返回这里显示的值:

    MySQL的&#62;SELECT TO_DAYS('0000-00-00');----------------------- | to_days(&#39;0000-00-00”)| ----------------------- |空| ----------------------- 1行集,1报警(0秒)MySQL &#62;SHOW WARNINGS;--------- ------ ---------------------------------------- |水平|代码|消息| --------- ------ ---------------------------------------- |警告| 1292 |错误:“0000-00-00 DateTime值的| --------- ------ ---------------------------------------- 1行集(0秒)MySQL &#62;SELECT TO_DAYS('0000-01-01');----------------------- | to_days(&#39;0000-01-01”)| ----------------------- | 1 | ----------------------- 1行集(0秒)

    这是真实与否ALLOW_INVALID_DATESSQL Server模式启用。

  • TO_SECONDS(expr)

    给定一个日期或日期时间expr,返回秒数从0开始。如果expr不是一个有效的日期或日期时间值,返回无效的

    mysql> SELECT TO_SECONDS(950501);
            -> 62966505600
    mysql> SELECT TO_SECONDS('2009-11-29');
            -> 63426672000
    mysql> SELECT TO_SECONDS('2009-11-29 13:43:32');
            -> 63426721412
    mysql> SELECT TO_SECONDS( NOW() );
            -> 63426721458
    

    喜欢TO_DAYS()向第二者()不适合使用与之前的公历的到来值(1582),因为它没有考虑到天时丢失了的日历。日期前1582(可能在其它地方的一年后),从这个函数的结果是不可靠的。看到12.8节,“什么日历是用MySQL?“,详情

    喜欢TO_DAYS()向第二者(),将两位数年份值日期四位数的形式使用规则11.3节,“戴特时间类型”

    在MySQL中,零日被定义为'0000-00-00',尽管这个日期本身视为无效。这意味着,对于“0000-00-00”'0000-01-01'TO_SECONDS()返回这里显示的值:

    MySQL的&#62;SELECT TO_SECONDS('0000-00-00');-------------------------- | to_seconds(&#39;0000-00-00”)| -------------------------- |空| -------------------------- 1行集,警告(0.001秒)MySQL &#62;SHOW WARNINGS;--------- ------ ---------------------------------------- |水平|代码|消息| --------- ------ ---------------------------------------- |警告| 1292 |错误:“0000-00-00 DateTime值的| --------- ------ ---------------------------------------- 1行集(0秒)MySQL &#62;SELECT TO_SECONDS('0000-01-01');-------------------------- | to_seconds(&#39;0000-01-01”)| -------------------------- | 86400 | -------------------------- 1行集(0秒)

    这是真实与否ALLOW_INVALID_DATESSQL Server模式启用。

  • UNIX_TIMESTAMP()UNIX_TIMESTAMP(date)

    如果不带参数调用,返回一个Unix时间戳(秒自'1970-01-01 00:00:00'UTC)。返回值是一个整数,如果没有给出参数或参数不包括小数秒的部分,或DECIMAL如果给出一个参数,包括小数秒部分。

    如果UNIX_TIMESTAMP()被称为一个date参数,它返回的参数的值为秒自“1970-01-01 00:00:00”UTC。这个date参数可以是一个DATEDATETIME,或TIMESTAMP字符串,或一个数收到录取通知时间YYMMDDHHMMSS年月日,或YYYYMMDDHHMMSS格式如果参数包括时间的一部分,它可以包括小数秒部分。该服务器解释date在当前的时区值并将其转换为UTC内部价值。客户可以设置自己的时区的描述第5.1.12,MySQL服务器的时区支持”

    mysql> SELECT UNIX_TIMESTAMP();
            -> 1447431666
    mysql> SELECT UNIX_TIMESTAMP('2015-11-13 10:20:19');
            -> 1447431619
    mysql> SELECT UNIX_TIMESTAMP('2015-11-13 10:20:19.012');
            -> 1447431619.012
    

    什么时候UNIX_TIMESTAMP()is used我们TIMESTAMP柱,该函数返回内部时间戳值直接,没有隐字符串的Unix时间戳转换。如果你通过一个超出范围的日期UNIX_TIMESTAMP(),它返回。值的有效范围为相同TIMESTAMP数据类型:“000000”00:00:01. 1970-01-01UTC'2038-01-19 03:14:07.999999'UTC

    注意:如果你使用UNIX_TIMESTAMP()FROM_UNIXTIME()之间的转换TIMESTAMP价值观和Unix时间戳值,转换损耗由于映射不是双向的一对一。例如,由于对本地时区变化公约,两是可能的UNIX_TIMESTAMP()图2TIMESTAMP值相同的Unix时间戳值。FROM_UNIXTIME()将地图价值回到只有一个原TIMESTAMP价值观。这里有一个例子,使用TIMESTAMP中的值大学英语等级考试时区:

    mysql> SELECT UNIX_TIMESTAMP('2005-03-27 03:00:00');
    +---------------------------------------+
    | UNIX_TIMESTAMP('2005-03-27 03:00:00') |
    +---------------------------------------+
    |                            1111885200 |
    +---------------------------------------+
    mysql> SELECT UNIX_TIMESTAMP('2005-03-27 02:00:00');
    +---------------------------------------+
    | UNIX_TIMESTAMP('2005-03-27 02:00:00') |
    +---------------------------------------+
    |                            1111885200 |
    +---------------------------------------+
    mysql> SELECT FROM_UNIXTIME(1111885200);
    +---------------------------+
    | FROM_UNIXTIME(1111885200) |
    +---------------------------+
    | 2005-03-27 03:00:00       |
    +---------------------------+
    

    如果你想减UNIX_TIMESTAMP()列,你可能想将结果符号的整数。看到12.10节,“铸函数和操作符”

  • UTC_DATEUTC_DATE()

    作为值返回当前的UTC日期'YYYY-MM-DD'年月日格式,这取决于功能是用一个字符串或数字语境。

    mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
            -> '2003-08-14', 20030814
    
  • UTC_TIMEUTC_TIME([fsp])

    返回当前的UTC时间作为一种价值'HH:MM:SS'hhmmss格式,这取决于功能是用一个字符串或数字语境。

    如果fsp给出参数指定从0到6秒的小数部分的精度,返回值包括小数秒的一部分,许多数字。

    MySQL的&#62;SELECT UTC_TIME(), UTC_TIME() + 0;- &#62;“18:07:53 &#39;,180753.000000
  • UTC_TIMESTAMPUTC_TIMESTAMP([fsp])

    作为值返回当前的UTC日期和时间'YYYY-MM-DD HH:MM:SS'yyyymmddhhmmss格式,这取决于功能是用一个字符串或数字语境。

    如果fsp给出参数指定从0到6秒的小数部分的精度,返回值包括小数秒的一部分,许多数字。

    MySQL的&#62;SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;- &#62;“2003-08-14 18:08:04 &#39;,20030814180804.000000
  • WEEK(date[,mode])

    这个函数返回的周数date。。。。。。。“双参数的形式WEEK()使您能够指定星期开始日或下周一和返回值是否应在的范围从53或从53。如果mode参数被省略了,值了default_week_format系统变量的使用。看到第5.1.7,服务器“系统变量”

    下表描述了mode论证工作

    模式一周的第一天范围1周是第一周…
    星期日0-53在今年的一个周末
    星期一0-53今年有4个或更多天
    星期日1-53在今年的一个周末
    星期一1-53今年有4个或更多天
    星期日0-53今年有4个或更多天
    星期一0-53在今年的一个星期
    星期日1-53今年有4个或更多天
    星期一1-53在今年的一个星期

    mode有意义的值今年有4个或更多天,周是根据ISO 8601:1988编号:

    • 如果含1月1日已在新的一年4天或更多天的一周,这1周。

    • 否则,它是前一年的最后一周,而下周是第一周。

    mysql> SELECT WEEK('2008-02-20');
            -> 7
    mysql> SELECT WEEK('2008-02-20',0);
            -> 7
    mysql> SELECT WEEK('2008-02-20',1);
            -> 8
    mysql> SELECT WEEK('2008-12-31',1);
            -> 53
    

    注意,如果一个日期在前一年的最后一周,MySQL返回0如果你不使用3,或7作为可选mode论点:

    MySQL的&#62;SELECT YEAR('2000-01-01'), WEEK('2000-01-01',0);&#62; 2000, 0

    有人可能会说,WEEK()应该返回五十二由于给定的日期却发生在1999年第52周。WEEK()退货相反,返回值是在给定的一年中的周数。这使得使用的WEEK()功能可靠,当合并其他函数提取日期部分从日期。

    如果你喜欢一个结果评价相对于年包含一周的第一天为给定的日期,使用05,或作为可选mode争论

    MySQL的&#62;SELECT WEEK('2000-01-01',2);&#62; 52

    另外,使用YEARWEEK()功能:

    MySQL的&#62;SELECT YEARWEEK('2000-01-01');-> 199952mysql>SELECT MID(YEARWEEK('2000-01-01'),5,2);&#62; 52
  • WEEKDAY(date)

    重新计算星期天索引date= Monday,1= Tuesday, …= Sunday).

    mysql> SELECT WEEKDAY('2008-02-03 22:23:00');
            -> 6
    mysql> SELECT WEEKDAY('2007-11-06');
            -> 1
    
  • WEEKOFYEAR(date)

    返回日期的日历周范围内的一个数1五十三WEEKOFYEAR()是一个兼容的功能,相当于WEEK(date,3)

    MySQL的&#62;SELECT WEEKOFYEAR('2008-02-20');-&#62; 8
  • YEAR(date)

    返回的一年date在这个范围内,一千9999,或对于日期

    mysql> SELECT YEAR('1987-01-01');
            -> 1987
    
  • YEARWEEK(date)YEARWEEK(date,mode)

    一个日期返回日期。在今年的结果可能不同于在第一和最后一年的星期日期的争论一年。

    这个mode的论点完全一样mode参数WEEK()。for the argument表单,mode0冰的使用价值。unlikeWEEK(),价值default_week_format不影响YEARWEEK()

    MySQL的&#62;SELECT YEARWEEK('1987-01-01');&#62; 198652

    请注意,周数是从什么不同的WEEK()函数将返回(可选题元)0,作为WEEK()然后返回在给定年下星期。

12.8什么是历用MySQL?

MySQL的使用被称为一个proleptic公历

每一个国家,从朱利安切换到公历不得不丢弃至少十天期间的开关。看到这是如何工作的,考虑到10月1582个月,当第一朱利安格里高利开关发生。

星期一星期二星期三星期四星期五星期六星期日
十五十六十七
十八十九二十二十一二十二二十三二十四
二十五二十六二十七二十八二十九三十三十一

有10月4日和10月15日之间没有日期。这不叫割接。在割接任何日期的朱利安,和任何日期后,割接是阳历。在割接日期是不存在的。

应用于日期,当它实际上并不是使用日历被称为预期。因此,如果我们假设没有割接和公历规则总是规则,我们有一个proleptic公历。这是使用MySQL,是通过标准的SQL所需。为此,以存储为MySQL割接之前的日期DATEDATETIME值必须进行调整,以弥补差异。它是实现割接不是发生在所有国家的重要,和后来发生的事,更天了。例如,在大不列颠,它发生在1752年,其次是当日9月2日9月14日。俄罗斯仍然对朱利安历直到1918年,在这一过程中丢失了13天,什么是普遍被称为十月革命发生在十一月根据公历。

12.9全文搜索功能

MATCH (col1,col2,...) AGAINST (expr [search_modifier])

search_modifier:{在查询扩展|布尔模式|查询扩展的自然语言模式自然语言模式| }

MySQL全文索引和搜索的支持:

全文检索是通过使用MATCH() ... AGAINST语法MATCH()以逗号分隔的列表,名称要搜索的列。反对作为一个要搜索的字符串,和一个可选的修饰符指示要执行什么类型的搜索。搜索字符串必须是一个字符串常量的值在查询评估。这个规则,例如,一个表的列,可以不同,因为每一行。

有三种类型的全文搜索:

  • 自然语言搜索将搜索字符串作为人类自然语言中的词(在自由文本短语)。有没有特别的运营商,以双引号(“)的异常特征。停用词列表应用。关于停用词列表的更多信息,参见第12.9.4,“全文构建”

    全文搜索是自然语言搜索,如果IN NATURAL LANGUAGE MODE如果没有修饰符修饰了。有关更多信息,参见第12.9.1,“自然语言全文检索”

  • 布尔搜索将使用特殊的查询语言规则的搜索字符串。此字符串包含的单词搜索。它也可以包含运营商的指定要求,一句话必须匹配行的存在或不存在的,或者说它应该是加权高于或低于正常。某些常用词(stopwords)从搜索指数略和不匹配,如果搜索字符串中的当前。这个IN BOOLEAN MODE修饰符指定一个布尔检索。有关更多信息,参见第12.9.2,”布尔全文搜索”

  • 一种扩展序列是一种自然语言序列的变化。搜索链路是用来培养一种自然语言的语言。因此,从最新的法律中可以看出,这是一种不同的方法。在第二次搜索中,有一个轮子恢复了。的IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION查询扩展修饰符指定一个查询扩展搜索。有关更多信息,参见第12.9.3,“查询扩展的全文搜索”

有关FULLTEXT查询性能,看第8.3.5,“列索引”

为更多的信息关于InnoDB全文指标,看第15.8.2.4,“InnoDB全文索引”

在全文搜索中列出的限制第12.9.5,“全文限制”

这个ftdump MyISAM _转储the contents of a效用MyISAM全文索引。这可能有助于调试全文查询。看到4.6.3“,”ftdump MyISAM _显示全文索引信息”

12.9.1自然语言全文检索

默认情况下,或与IN NATURAL LANGUAGE MODE改性剂的MATCH()函数执行一个字符串对自然语言搜索文本的收集。集合是一组一个或多个列包含在FULLTEXT指数搜索字符串作为参数对()。对于表中的每一行,MATCH()返回一个相关值;即搜索字符串并在列在该行中的文本之间的相似性度量MATCH()列表

MySQL的&#62;CREATE TABLE articles (id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,title VARCHAR(200),body TEXT,FULLTEXT (title,body)) ENGINE=InnoDB;查询行,0行受影响(0.08秒)MySQL &#62;INSERT INTO articles (title,body) VALUES('MySQL Tutorial','DBMS stands for DataBase ...'),('How To Use MySQL Well','After you went through a ...'),('Optimizing MySQL','In this tutorial we will show ...'),('1001 MySQL Tricks','1. Never run mysqld as root. 2. ...'),('MySQL vs. YourSQL','In the following database comparison ...'),('MySQL Security','When configured properly, MySQL ...');查询行,6行受影响(0.01秒)记录:6份:0警告:0mysql &#62;SELECT * FROM articlesWHERE MATCH (title,body)AGAINST ('database' IN NATURAL LANGUAGE MODE);---- ------------------- ------------------------------------------ | ID |标题|体| ---- ------------------- ------------------------------------------ | 1 | MYSQL教程| DBMS是数据库…| | 5 | MySQL与yoursql |以下数据库的比较…| ---- ------------------- ------------------------------------------ 2行集(0秒)

默认情况下,搜索是不区分大小写的方式进行。执行区分大小写的全文搜索,使用大小写敏感的或二进制索引列的排序规则。例如,一列使用utf8mb4字符集可以分配一个整理utf8mb4_0900_as_csutf8mb4_bin让它为全文搜索敏感

什么时候MATCH()用于哪里条款,如示例中所示的时候,返回的行自动排序第一的最高相关性。关联的值是非负的浮点数。零关联意味着没有相似性。关联性是基于行的字数计算(文件),在该行的独特的单词数,集合中的总字数,并包含一个特定的词的行数。

笔记

术语文件可能与长期交替使用,和这两个词是指索引部分的行。术语收藏指的是包含所有索引列和行。

简单的数量匹配,你可以使用这样的查询:

mysql> SELECT COUNT(*) FROM articles
    WHERE MATCH (title,body)
    AGAINST ('database' IN NATURAL LANGUAGE MODE);
+----------+
| COUNT(*) |
+----------+
|        2 |
+----------+
1 row in set (0.00 sec)

你可能会发现它快重写查询如下:

mysql> SELECT
    COUNT(IF(MATCH (title,body) AGAINST ('database' IN NATURAL LANGUAGE MODE), 1, NULL))
    AS count
    FROM articles;
+-------+
| count |
+-------+
|     2 |
+-------+
1 row in set (0.03 sec)

第一个查询做一些额外的工作(结果按相关性排序)也可以使用一个基于索引查找WHERE条款.索引查找可能先查询如果搜索匹配几行得更快。第二查询执行全表扫描,这可能比索引查找如果搜索词是目前最行。

自然语言的全文搜索,栏目命名的MATCH()函数必须包含一些相同的列全文你的表索引。在前面的查询,请注意,列在MATCH()功能(头衔body)是在定义相同的命名文章表的FULLTEXT指数搜索头衔body另外,你可以创建单独的全文每一列的索引

你也可以做一个布尔搜索或查询扩展搜索。这些类型的搜索进行了第12.9.2,”布尔全文搜索”,和第12.9.3,“查询扩展的全文搜索”

全文搜索,使用索引可以名称列从一个表中的唯一MATCH()条款因为不能跨多个表的索引。为MyISAM表,一个布尔搜索可以在索引的情况下完成(但更慢),在这种情况下,它是可能的名字列的多个表。

前面的示例是一个基本的例子,说明如何使用MATCH()功能,排在降低关联顺序返回。下面的例子演示如何检索关联的值显式。返回的行是无序的,SELECT声明中既不包括哪里也没有ORDER BY条款:

MySQL的&#62;SELECT id, MATCH (title,body)AGAINST ('Tutorial' IN NATURAL LANGUAGE MODE) AS scoreFROM articles;---- --------------------- | ID |评分| ---- --------------------- | 1 | 0.2276446968317031 | | 2 | 0 | | 3 | 0.2276446968317031 | | 4 | 0 | | 5 | 0 | | 6 | 0 | ---- --------------------- 6行集(0秒)

下面的例子更复杂。查询返回的值的相关性也各种各样的行为减少关联。为了实现这一目标,指定MATCH()两次:一次在SELECT名单,一旦在哪里条款.这不会造成额外的开销,因为MySQL优化器发现两MATCH()电话是相同的,调用全文搜索代码只有一次。

MySQL的&#62;SELECT id, body, MATCH (title,body) AGAINST('Security implications of running MySQL as root'IN NATURAL LANGUAGE MODE) AS scoreFROM articles WHERE MATCH (title,body) AGAINST('Security implications of running MySQL as root'IN NATURAL LANGUAGE MODE);---- ------------------------------------- ----------------- | ID |体|评分| ---- ------------------------------------- ----------------- | 4 | 1。不要跑mysqld为根。2。…| 1.5219271183014 | | 6 |当正确配置,MySQL…| 1.3114095926285 | ---- ------------------------------------- ----------------- 2行集(0秒)

一句话,是包含在双引号(")字符匹配行包含短语从字面上看,它是类型。全文引擎将短语词和执行中的搜索FULLTEXT对于词语索引。非单词字符不需要精确匹配:短语搜索只需要匹配包含完全相同的词汇短语在同一顺序。例如,“测试”这句话比赛"test, phrase"。如果这句话不包含单词在指数,结果是空的。例如,如果所有的话都是构建或小于索引词的最小长度,结果是空的。

MySQLFULLTEXT实施以任何顺序字符(字母、数字的话,和下划线)作为一个词。该序列也可以包含单引号(&#39;),但不超过一个排。这意味着,aaa'bbb作为一个词,但AAA &#39;&#39;bbb被视为两个词。在词首或末引号被剥离的FULLTEXT分析器;“aaa&#39;bbb”将被解析为aaa'bbb

内置FULLTEXT决定开始和结束词分析器通过寻找特定的分隔符;例如,(空间),(逗号),和(期)。如果不分开的分隔符(如,例如,中国),内置FULLTEXT解析器不能确定一个词开始或结束。能够加入这样的语言或其他索引到全文索引,使用内置的FULLTEXT解析器,你必须处理他们,是由一些任意分隔符分隔。或者,您可以创建全文使用创建解析器插件指标(中国,日本,韩国)或mecab解析器插件(日本)。

它可能是写一个插件,取代内置的全文解析。详情见28.2节,“MySQL插件API”。例如解析器插件的源代码,看看plugin/fulltext一个MySQL源分布目录。

有些词在全文搜索忽略:

  • 任何字,太短被忽略。的话,通过全文搜索发现默认的最小长度是三个字符为InnoDB搜索索引,或4个字符MyISAM。你可以通过设置一个配置选项创建索引之前控制截止:innodb_ft_min_token_size配置选项InnoDB搜索索引,或ft_min_word_lenMyISAM

    笔记

    这种行为并不适用于FULLTEXT指标使用频率分析器。为创建解析器,令牌长度定义的ngram_token_size选项

  • 在停用词表词被忽略。一个词是一个词如这个一些这是很常见的,它具有零语义价值。有一个内置的停用词列表,但可以通过用户定义的列表中。停用词列表和相关的配置选项是不同的InnoDB搜索索引MyISAM的人。停用词处理是通过配置选项控制innodb_ft_enable_stopwordinnodb_ft_server_stopword_table,和innodb_ft_user_stopword_tableInnoDB搜索索引,和ft_stopword_fileMyISAM的人

看到第12.9.4,“全文构建”查看默认的停用词列表和如何改变它们。默认的最小长度可以改变,如第12.9.6,“微调MySQL全文搜索”

在收集和查询中的每个词按其意义在收集或查询加权。因此,一个字,在很多文献中目前有一个较低的体重,因为它已经在这个特定的征收较低的语义值。相反的,如果这个词是罕见的,它接收到一个更高的重量。词的权重进行组合计算的行的相关性。这种技术最适合大集合。

MyISAM的局限性

对于非常小的表,字分布不充分反映他们的语义值,该模型会产生奇怪的结果在搜索索引MyISAM表例如,虽然字MySQL在每行的礼物articles表中所示的早些时候,一个词的搜索MyISAM搜索指数不产生结果:

mysql> SELECT * FROM articles
    WHERE MATCH (title,body)
    AGAINST ('MySQL' IN NATURAL LANGUAGE MODE);
Empty set (0.00 sec)

搜索结果是空的因为这个词MySQL目前至少有50%行,所以实际上是作为一个词。这种过滤技术更适合于大数据集,您可能不希望将返回每个第二排1GB的表的结果,比小的数据集,它可能引起流行的条件差的结果。

50%阈值可以令你感到惊讶,当你第一次试着全文搜索,看看它是如何工作的,并使InnoDB更适合与全文搜索实验表。如果你创建了一个MyISAM表并插入一个或两个排到它的文本,文本中的每个词至少出现在50%的行。作为一个结果,没有搜索返回结果直到表包含多行。谁需要绕过50%限制用户可以创建搜索索引InnoDB表,或使用布尔搜索模式的解释第12.9.2,”布尔全文搜索”

12.9.2布尔全文搜索

MySQL可以执行全文搜索使用布尔IN BOOLEAN MODE改性剂。这种改性剂、某些字符在搜索字符串中的单词的开头或结尾都有特殊的意义。在下面的查询, -运营商的指示词必须存在或不存在,分别为比赛发生。因此,查询检索所有行包含单词MySQL但这样做包含单词yoursql

mysql> SELECT * FROM articles WHERE MATCH (title,body)
    AGAINST ('+MySQL -YourSQL' IN BOOLEAN MODE);
+----+-----------------------+-------------------------------------+
| id | title                 | body                                |
+----+-----------------------+-------------------------------------+
|  1 | MySQL Tutorial        | DBMS stands for DataBase ...        |
|  2 | How To Use MySQL Well | After you went through a ...        |
|  3 | Optimizing MySQL      | In this tutorial we will show ...   |
|  4 | 1001 MySQL Tricks     | 1. Never run mysqld as root. 2. ... |
|  6 | MySQL Security        | When configured properly, MySQL ... |
+----+-----------------------+-------------------------------------+
笔记

在执行了这一功能,MySQL使用什么有时被称为隐含的布尔逻辑,其中

  • +代表

  • -代表

  • 没有运营商]意味着OR

布尔全文搜索有以下特点:

  • 他们不自动排序在减少关联顺序排。

  • InnoDB表的要求全文在所有列的索引MATCH()执行布尔查询的表达。布尔查询对MyISAM搜索指数可以没有甚至工作FULLTEXT指数,虽然这种方式执行搜索会很慢。

  • 最小和最大词长全文使用的参数FULLTEXT使用内置的创建索引全文解析器和mecab解析器插件。innodb_ft_min_token_sizeinnodb_ft_max_token_size用于InnoDB搜索索引ft_min_word_lenft_max_word_len用于MyISAM搜索索引

    最小和最大词长全文参数不适用于FULLTEXT使用频率分析器创建索引。创建令牌的大小是确定的ngram_token_size选项

  • 停用词列表应用,控制innodb_ft_enable_stopwordinnodb_ft_server_stopword_table,和innodb_ft_user_stopword_tableInnoDB搜索索引,和ft_stopword_fileMyISAM的人

  • InnoDB全文搜索不支持在一个单一的搜索词多个运营商使用,如下面的例子:“苹果”。使用在一个单一的搜索词多个运算符返回一个语法错误的标准了。MyISAM全文搜索会成功处理相同的搜索忽略除了紧邻搜索词的所有运营商运营商。

  • InnoDB全文搜索仅支持领先的加号、减号。例如,InnoDB支持'+apple'但不支持“苹果”。指定一个尾随正号或负号的原因InnoDB报告一个语法错误

  • InnoDB全文搜索不支持领先的加号(带通配符的使用“*”),一个加号和减号符号组合('+-'),或领导一个加号和减号符号组合(这是我的苹果)。这些无效的查询返回一个语法错误。

  • InnoDB全文搜索不支持使用的@在布尔全文搜索符号。这个@符号是保留使用的“距离邻近搜索算子

  • 他们不使用50%的门槛,适用于MyISAM搜索索引

布尔的全文搜索能力支持以下操作:

  • +

    一个前导或尾随加号表示这个词必须在每一行,返回InnoDB只支持领先的加号

  • -

    一个前导或尾随减号表示这个词在任何所返回的行的礼物。InnoDB只支持领先的减号

    注:本-操作符只能排除行,否则其他搜索条件匹配。因此,布尔模式搜索只包含条款之前返回一个空的结果。它不返回除了那些任何除外条款包含所有行。

  • (运营商)

    默认情况下(当不+也没有是指定的),这个词是可选的,但包含它的行被评为高。这种模仿行为MATCH() ... AGAINST()没有在布尔模式改性剂

  • @distance

    这个操作符的作品InnoDB表。测试是否两个或两个以上的词都开始在指定的距离测量的话。在双引号字符串中指定的搜索词之前@distance运算符,例如,比赛(COL1)反对(“word1 word2 word3”“8”在布尔模式)

  • > <

    这两家运营商是用来改变一个词的关联值,被分配到一个排的贡献。这个>运营商增加的贡献<运营商降低。看下面这个列表的例子。

  • ( )

    括号组词成子表达式。括号组可以嵌套。

  • ~

    领导的行为作为一种否定算子,使文字的行的相关性为负贡献。这个标记是有用的噪音字一行包含这样的词排名比别人低,但不排除完全,它可能与-算子

  • *

    星号作为截断(或通配符)算子。不同于其他运营商,这是附加这个词被影响。的话,如果他们开始比赛前的话*算子

    如果一个词是用截断运营商指定的,它不是从一个布尔查询的剥离,即使是短暂的或一个词。一个词是否太短暂,取决于innodb_ft_min_token_size设置InnoDB表,或ft_min_word_lenMyISAM表这些选项不适用于FULLTEXT指标使用频率分析器

    的通配符的字被认为是作为一个前缀,必须在一个或多个单词的开始。如果最小字长为4,搜索'+word +the*'可以返回的行比搜索更少&#39;word&#39;,因为第二查询忽略了短暂的搜索词这个

  • "

    一句话,是包含在双引号(")字符匹配行包含短语从字面上看,它是类型。全文引擎将短语词和执行中的搜索FULLTEXT对于词语索引。非单词字符不需要精确匹配:短语搜索只需要匹配包含完全相同的词汇短语在同一顺序。例如,“试验阶段”比赛"test, phrase"

    如果这句话不包含单词在指数,结果是空的。这个词可能不在指数由于多种因素的结合:如果他们不在文本中,存在的停用词,或小于索引词的最小长度。

下面的示例演示了使用布尔运算符搜索字符串全文:

  • 'apple banana'

    发现在这两个词包含至少一个行。

  • '+apple +juice'

    找到包含这两个字行

  • '+apple macintosh'

    找到包含的字行苹果,但如果它们也含有较高等级的行Macintosh

  • '+apple -macintosh'

    找到包含的字行苹果但不Macintosh

  • '+apple ~macintosh'

    找到包含的字行苹果,但如果行还包含单词Macintosh,率低于如果行不。这是更柔软的比搜索'+apple -macintosh'这一点,为“presence ofMacintosh原因不在所有返回的行。

  • '+apple +(>turnover <strudel)'

    找到包含的字行苹果人事变更率,或苹果馅饼(一阶),但排名苹果馅酥饼高于苹果卷

  • 'apple*'

    发现包含诸如行苹果苹果苹果酱,或小程序

  • '"some words"'

    找到包含确切的短语排有些话(例如,列一些智慧的话但不有声音的话)。请注意,"人物,将短语是运营商的角色划短语。他们没有引号,将搜索字符串本身。

相关性排名InnoDB布尔模式搜索

InnoDB全文检索是仿照狮身人面像全文搜索引擎,和使用的算法是基于BM25TF-IDF排序算法。这些的原因是,relevancy排名InnoDB布尔全文搜索可能不同MyISAM相关度

InnoDB使用变化的长期的频率逆文档频率TF-IDF)称重系统排名文档的相关性对于一个给定的全文搜索查询。这个TF-IDF基于加权是多么频繁的词出现在一个文档,通过频繁的词出现在集合中的所有文件偏移量。换句话说,更频繁的一个词出现在文件和频率较低的词出现在文件收集,文档的高排名。

如何排序计算

词频(TF)价值是时代一词出现的文档数。逆文档频率(IDF)一个词的价值是用下面的公式计算,其中total_records在收集记录的数量,和matching_records是的,搜索词出现在记录数。

${IDF} = log10( ${total_records} / ${matching_records} )  

当一个文件包含一个word多次,IDF值乘以TF值:

${TF} * ${IDF}

使用TFIDF值,一个文档的相关度排序使用这个公式计算:

${rank} = ${TF} * ${IDF} * ${IDF}

公式是在以下的例子证明。

相关度排序为单个词搜索

这个例子演示了一个单一的词搜索的相关度排序计算。

mysql> CREATE TABLE articles (
id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,
title VARCHAR(200),
body TEXT,
FULLTEXT (title,body)
) ENGINE=InnoDB;
Query OK, 0 rows affected (1.04 sec)

mysql> INSERT INTO articles (title,body) VALUES
('MySQL Tutorial','This database tutorial ...'),
("How To Use MySQL",'After you went through a ...'),
('Optimizing Your Database','In this database tutorial ...'),
('MySQL vs. YourSQL','When comparing databases ...'),
('MySQL Security','When configured properly, MySQL ...'),
('Database, Database, Database','database database database'),
('1001 MySQL Tricks','1. Never run mysqld as root. 2. ...'),
('MySQL Full-Text Indexes', 'MySQL fulltext indexes use a ..');                  
Query OK, 8 rows affected (0.06 sec)
Records: 8  Duplicates: 0  Warnings: 0

mysql> SELECT id, title, body, MATCH (title,body)  AGAINST ('database' IN BOOLEAN MODE)
AS score FROM articles ORDER BY score DESC;
+----+------------------------------+-------------------------------------+---------------------+
| id | title                        | body                                | score               |
+----+------------------------------+-------------------------------------+---------------------+
|  6 | Database, Database, Database | database database database          |  1.0886961221694946 |
|  3 | Optimizing Your Database     | In this database tutorial ...       | 0.36289870738983154 |
|  1 | MySQL Tutorial               | This database tutorial ...          | 0.18144935369491577 |
|  2 | How To Use MySQL             | After you went through a ...        |                   0 |
|  4 | MySQL vs. YourSQL            | When comparing databases ...        |                   0 |
|  5 | MySQL Security               | When configured properly, MySQL ... |                   0 |
|  7 | 1001 MySQL Tricks            | 1. Never run mysqld as root. 2. ... |                   0 |
|  8 | MySQL Full-Text Indexes      | MySQL fulltext indexes use a ..     |                   0 |
+----+------------------------------+-------------------------------------+---------------------+
8 rows in set (0.00 sec)

共有8次记录,与3相匹配的数据库搜索项。第一个记录(theid 6)包含搜索词的6倍,具有关联度排序一点零八八六九六一二二一六九四九四六。这一排名值计算TF值的6(数据库搜索词出现在创纪录的6倍id 6)和一个IDF值为0.4259687321637074,其计算如下(其中8是记录总数是3,搜索词出现在记录数):

${IDF} = log10( 8 / 3 ) = 0.42596873216370745

这个TFIDF值,然后进入排名公式:

${rank} = ${TF} * ${IDF} * ${IDF}

在MySQL的命令行客户端执行的计算回报率1.088696164686938排名的价值。

mysql> SELECT 6*log10(8/3)*log10(8/3);
+-------------------------+
| 6*log10(8/3)*log10(8/3) |
+-------------------------+
|       1.088696164686938 |
+-------------------------+
1 row in set (0.00 sec)
笔记

你可能会注意到在排名值略有差异的返回SELECT ... MATCH ... AGAINST声明和MySQL的命令行客户端(一点零八八六九六一二二一六九四九四六对比1.088696164686938)。不同的是,由于有整数和浮点数/双打之间的转换进行了内部的InnoDB(连同相关的精度和舍入的决定),以及它们是如何表现在其他地方,比如MySQL的命令行客户端或其他类型的计算器。

相关度排序为多词搜索

这个例子演示了一个基于多词全文搜索的相关度排序计算articles前一个示例中使用的表和数据。

如果你搜索多个词的相关度排序值是每字一笔的排序值,如公式中所示:

${rank} = ${TF} * ${IDF} * ${IDF} + ${TF} * ${IDF} * ${IDF}

在两方面进行搜索(&#39;mysql教程”)返回以下结果:

mysql> SELECT id, title, body, MATCH (title,body)  AGAINST ('mysql tutorial' IN BOOLEAN MODE)
    AS score FROM articles ORDER BY score DESC;
+----+------------------------------+-------------------------------------+----------------------+
| id | title                        | body                                | score                |
+----+------------------------------+-------------------------------------+----------------------+
|  1 | MySQL Tutorial               | This database tutorial ...          |   0.7405621409416199 |
|  3 | Optimizing Your Database     | In this database tutorial ...       |   0.3624762296676636 |
|  5 | MySQL Security               | When configured properly, MySQL ... | 0.031219376251101494 |
|  8 | MySQL Full-Text Indexes      | MySQL fulltext indexes use a ..     | 0.031219376251101494 |
|  2 | How To Use MySQL             | After you went through a ...        | 0.015609688125550747 |
|  4 | MySQL vs. YourSQL            | When comparing databases ...        | 0.015609688125550747 |
|  7 | 1001 MySQL Tricks            | 1. Never run mysqld as root. 2. ... | 0.015609688125550747 |
|  6 | Database, Database, Database | database database database          |                    0 |
+----+------------------------------+-------------------------------------+----------------------+
8 rows in set (0.00 sec)

在第一个记录(id 8),“MySQL”出现一次“教程”出现了两次。有六个匹配的记录“MySQL”和两个匹配的记录为“教程”。MySQL的命令行客户端返回预期的排名值时插入这些值为多个词搜索排名公式:

MySQL &#62;选择(1×log10(8 / 6)×log10(8 / 6))(2×log10(8 / 2)×log10(8 / 2));------------------------------------------------------- |(1×log10(8 / 6)×log10(8 / 6))(2×log10(8/2)* log10(8 / 2))| ------------------------------------------------------- | 0.7405621541938003 | ------------------------------------------------------- 1行集(0秒)
笔记

通过返回的排名值略有差异SELECT ... MATCH ... AGAINST声明和MySQL的命令行客户端是在前面的例子说明。

12.9.3全文检索查询扩展

全文搜索支持查询扩展(尤其是其变种盲目的查询扩展)。这通常是有用的当搜索短语太短,这往往意味着用户是依靠隐含知识,全文搜索引擎缺乏。例如,一个用户搜索数据库可能真的是这个意思MySQLOracledb2,和关系型数据库管理系统所有的短语匹配数据库应该回来了,太。这是隐含的知识。

盲目的查询扩展(也称为自动相关反馈)是启用的添加WITH QUERY EXPANSION在查询扩展的自然语言模式下面的搜索短语。它通过执行搜索的两倍,其中第二搜索的短语是原来的搜索短语的几个最高度相关的文件,从最初的搜索链接。因此,如果这些文件包含单词数据库这个词MySQL,第二搜索发现,包含单词的文件MySQL即使他们不包含单词数据库。下面的例子展示了这种差异:

mysql> SELECT * FROM articles
    WHERE MATCH (title,body)
    AGAINST ('database' IN NATURAL LANGUAGE MODE);
+----+-------------------+------------------------------------------+
| id | title             | body                                     |
+----+-------------------+------------------------------------------+
|  1 | MySQL Tutorial    | DBMS stands for DataBase ...             |
|  5 | MySQL vs. YourSQL | In the following database comparison ... |
+----+-------------------+------------------------------------------+
2 rows in set (0.00 sec)

mysql> SELECT * FROM articles
    WHERE MATCH (title,body)
    AGAINST ('database' WITH QUERY EXPANSION);
+----+-----------------------+------------------------------------------+
| id | title                 | body                                     |
+----+-----------------------+------------------------------------------+
|  5 | MySQL vs. YourSQL     | In the following database comparison ... |
|  1 | MySQL Tutorial        | DBMS stands for DataBase ...             |
|  3 | Optimizing MySQL      | In this tutorial we will show ...        |
|  6 | MySQL Security        | When configured properly, MySQL ...      |
|  2 | How To Use MySQL Well | After you went through a ...             |
|  4 | 1001 MySQL Tricks     | 1. Never run mysqld as root. 2. ...      |
+----+-----------------------+------------------------------------------+
6 rows in set (0.00 sec)

另一个例子是乔治·西默农关于Maigret的书籍搜索,当用户不知道如何拼写马格雷。一个搜索megre和不情愿的证人发现只有探长和不情愿的证人没有查询扩展。一个查询扩展搜索发现这个词的所有的书马格雷第二通

笔记

因为盲目的查询扩展往往通过返回非相关文件显着增加噪音,只把它当搜索短语短。

12.9.4全文构建

停用词列表加载和搜索使用服务器字符集和整理全文查询的值(character_set_servercollation_server系统变量)。假命中或可能发生的词查找,如果停用词文件或列用于全文索引或搜索有一个字符集和整理不同character_set_servercollation_server

停用词查找大小写取决于服务器的排序规则。例如,查找不区分大小写,如果整理utf8mb4_0900_ai_ci,而查找区分大小写,如果整理utf8mb4_0900_as_csutf8mb4_bin

InnoDB搜索索引构建

InnoDB有一个相对较短的列表中默认的停用词,因为从技术、文学文献,和其他来源的经常使用短词作为关键词或重要的短语。例如,你可以搜索生存还是毁灭并期望得到合理的结果,而不是那些忽略的词。

看到默认InnoDB停用词列表,查询INFORMATION_SCHEMA.INNODB_FT_DEFAULT_STOPWORD

MySQL &#62;选择*从information_schema.innodb_ft_default_stopword;------- |价值| ------- |一| |约| |一| |是| |作为| |在| |是| |通过| | COM | | de | | EN | |为| |从| |如何| |我| |在| |是| |它| | La | |的| |在| |或| |,| |的| |这| |到| |是| |什么| |当| |哪里| |谁| |将| |与| |和| |的| | WWW | ------- 36行集(0秒)

定义你自己的停用词列表InnoDB表,定义一个表的结构相同的INNODB_FT_DEFAULT_STOPWORD表,以构建填充它,并设置的值innodb_ft_server_stopword_table选择表格中的值db_name/table_name在创建全文索引。表必须有一个单一的词VARCHAR命名列价值。下面的示例演示如何创建和配置一个新的全球停用词表InnoDB

-- Create a new stopword tablemysql> CREATE TABLE my_stopwords(value VARCHAR(30)) ENGINE = INNODB;Query OK, 0 rows affected (0.01 sec)-- Insert stopwords (for simplicity, a single stopword is used in this example)mysql> INSERT INTO my_stopwords(value) VALUES ('Ishmael');Query OK, 1 row affected (0.00 sec)-- Create the tablemysql> CREATE TABLE opening_lines (id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,opening_line TEXT(500),author VARCHAR(200),title VARCHAR(200)) ENGINE=InnoDB;Query OK, 0 rows affected (0.01 sec)-- Insert data into the tablemysql> INSERT INTO opening_lines(opening_line,author,title) VALUES('Call me Ishmael.','Herman Melville','Moby-Dick'),('A screaming comes across the sky.','Thomas Pynchon','Gravity\'s Rainbow'),('I am an invisible man.','Ralph Ellison','Invisible Man'),('Where now? Who now? When now?','Samuel Beckett','The Unnamable'),('It was love at first sight.','Joseph Heller','Catch-22'),('All this happened, more or less.','Kurt Vonnegut','Slaughterhouse-Five'),('Mrs. Dalloway said she would buy the flowers herself.','Virginia Woolf','Mrs. Dalloway'),('It was a pleasure to burn.','Ray Bradbury','Fahrenheit 451');Query OK, 8 rows affected (0.00 sec)Records: 8  Duplicates: 0  Warnings: 0-- Set the innodb_ft_server_stopword_table option to the new stopword tablemysql> SET GLOBAL innodb_ft_server_stopword_table = 'test/my_stopwords';Query OK, 0 rows affected (0.00 sec)-- Create the full-text index (which rebuilds the table if no FTS_DOC_ID column is defined)mysql> CREATE FULLTEXT INDEX idx ON opening_lines(opening_line);Query OK, 0 rows affected, 1 warning (1.17 sec)Records: 0  Duplicates: 0  Warnings: 1

验证指定的词(&#39;ishmael”)不通过查询词出现INFORMATION_SCHEMA.INNODB_FT_INDEX_TABLE

笔记

默认情况下,字数不少于3个字符的长度大于84个字符的长度不会出现在一个InnoDB全文检索索引。最大和最小长度值是配置使用innodb_ft_max_token_sizeinnodb_ft_min_token_size变量.这种默认行为不适用于创建解析器插件。创建令牌的大小是确定的ngram_token_size选项

mysql> SET GLOBAL innodb_ft_aux_table='test/opening_lines';Query OK, 0 rows affected (0.00 sec)mysql> SELECT word FROM INFORMATION_SCHEMA.INNODB_FT_INDEX_TABLE LIMIT 15;+-----------+| word      |+-----------+| across    || all       || burn      || buy       || call      || comes     || dalloway  || first     || flowers   || happened  || herself   || invisible || less      || love      || man       |+-----------+15 rows in set (0.00 sec)

创建一个表,表的停用词列表的基础上,创建表和使用其他词innodb_ft_user_stopword_table选项指定词的表,你想用你之前创建全文索引。

对于MyISAM搜索索引构建

停用词文件加载和搜索的使用latin1如果character_set_serverucs2UTF16utf16le,或utf32

重写默认的MyISAM表的停用词列表,设置ft_stopword_file可变系统。(See第5.1.7,服务器“系统变量”。)变量值应包含停用词列表的文件的路径名,或空字符串禁用词过滤。服务器中寻找数据目录的文件,除非绝对路径名是给指定一个不同的目录。改变这个变量的内容或停用词文件的值后,重新启动服务器并重建你的FULLTEXT指标

停用词列表是自由与任何非字母数字字符,如换行符,空间分离的停用词,或逗号。例外的是下划线字符(_撇号(单)and&#39;)作为一个词的一部分。集的停用词表的特点是服务器的默认字符集;看10.3.2节,“服务器字符集和整理”

下面的列表显示为默认的构建MyISAM搜索索引。在MySQL源分布,你可以在这个列表中找到存储/表/ ft_static C。文件

a's           able          about         above         according
accordingly   across        actually      after         afterwards
again         against       ain't         all           allow
allows        almost        alone         along         already
also          although      always        am            among
amongst       an            and           another       any
anybody       anyhow        anyone        anything      anyway
anyways       anywhere      apart         appear        appreciate
appropriate   are           aren't        around        as
aside         ask           asking        associated    at
available     away          awfully       be            became
because       become        becomes       becoming      been
before        beforehand    behind        being         believe
below         beside        besides       best          better
between       beyond        both          brief         but
by            c'mon         c's           came          can
can't         cannot        cant          cause         causes
certain       certainly     changes       clearly       co
com           come          comes         concerning    consequently
consider      considering   contain       containing    contains
corresponding could         couldn't      course        currently
definitely    described     despite       did           didn't
different     do            does          doesn't       doing
don't         done          down          downwards     during
each          edu           eg            eight         either
else          elsewhere     enough        entirely      especially
et            etc           even          ever          every
everybody     everyone      everything    everywhere    ex
exactly       example       except        far           few
fifth         first         five          followed      following
follows       for           former        formerly      forth
four          from          further       furthermore   get
gets          getting       given         gives         go
goes          going         gone          got           gotten
greetings     had           hadn't        happens       hardly
has           hasn't        have          haven't       having
he            he's          hello         help          hence
her           here          here's        hereafter     hereby
herein        hereupon      hers          herself       hi
him           himself       his           hither        hopefully
how           howbeit       however       i'd           i'll
i'm           i've          ie            if            ignored
immediate     in            inasmuch      inc           indeed
indicate      indicated     indicates     inner         insofar
instead       into          inward        is            isn't
it            it'd          it'll         it's          its
itself        just          keep          keeps         kept
know          known         knows         last          lately
later         latter        latterly      least         less
lest          let           let's         like          liked
likely        little        look          looking       looks
ltd           mainly        many          may           maybe
me            mean          meanwhile     merely        might
more          moreover      most          mostly        much
must          my            myself        name          namely
nd            near          nearly        necessary     need
needs         neither       never         nevertheless  new
next          nine          no            nobody        non
none          noone         nor           normally      not
nothing       novel         now           nowhere       obviously
of            off           often         oh            ok
okay          old           on            once          one
ones          only          onto          or            other
others        otherwise     ought         our           ours
ourselves     out           outside       over          overall
own           particular    particularly  per           perhaps
placed        please        plus          possible      presumably
probably      provides      que           quite         qv
rather        rd            re            really        reasonably
regarding     regardless    regards       relatively    respectively
right         said          same          saw           say
saying        says          second        secondly      see
seeing        seem          seemed        seeming       seems
seen          self          selves        sensible      sent
serious       seriously     seven         several       shall
she           should        shouldn't     since         six
so            some          somebody      somehow       someone
something     sometime      sometimes     somewhat      somewhere
soon          sorry         specified     specify       specifying
still         sub           such          sup           sure
t's           take          taken         tell          tends      
th            than          thank         thanks        thanx
that          that's        thats         the           their
theirs        them          themselves    then          thence
there         there's       thereafter    thereby       therefore
therein       theres        thereupon     these         they
they'd        they'll       they're       they've       think
third         this          thorough      thoroughly    those
though        three         through       throughout    thru
thus          to            together      too           took
toward        towards       tried         tries         truly
try           trying        twice         two           un
under         unfortunately unless        unlikely      until
unto          up            upon          us            use
used          useful        uses          using         usually
value         various       very          via           viz
vs            want          wants         was           wasn't
way           we            we'd          we'll         we're
we've         welcome       well          went          were
weren't       what          what's        whatever      when
whence        whenever      where         where's       whereafter
whereas       whereby       wherein       whereupon     wherever
whether       which         while         whither       who
who's         whoever       whole         whom          whose
why           will          willing       wish          with
within        without       won't         wonder        would
wouldn't      yes           yet           you           you'd
you'll        you're        you've        your          yours
yourself      yourselves    zero        

12.9.5全文限制

  • 全文搜索支持InnoDBMyISAM

  • 全文搜索是不是分区表支持。看到22.6节,“分区”的约束和限制

  • 全文检索可以使用最多字节字符集。例外的是,对于Unicode,这utf8字符集可以使用,但不UCS2的字符集。尽管FULLTEXT指标UCS2列不能使用,您可以执行IN BOOLEAN MODE搜索一个UCS2柱,没有这样的指标

    的话utf8也适用于utf8mb4,和备注ucs2也适用于UTF16utf16le,和utf32

  • 表意语言,如汉语、日语没有文字分隔符。因此,内置的全文解析不能确定的话,开始和结束在这些语言

    基于字符的N-gram全文解析器支持中国、日本、韩国(CJK),和基于词的mecab解析器插件,支持日本是提供与使用InnoDBMyISAM

  • 虽然多字符集在单个表中使用的支持,在所有列FULLTEXT指标必须使用相同的字符集和整理。

  • 这个MATCH()列表必须在一些完全列表匹配全文表的索引定义,除非这MATCH()在布尔模式在一个MyISAM表为MyISAM表,布尔模式搜索可以在非索引列,虽然他们可能是缓慢的。

  • 争论AGAINST()必须是一个字符串常量的值在查询评估。这个规则,例如,一个表的列,可以不同,因为每一行。

  • 索引提示更有限FULLTEXT搜索到的非—全文searches)。See第8.9.4,”指标提示”

  • InnoDB,所有的DML操作(INSERTUPDATEDELETE)涉及的全文索引的列进行处理,在事务提交时。例如,一个插入操作,插入字符串标记化和分解成单个的词。个人的话,然后添加到全文索引的表在事务提交。作为一个结果,全文搜索只返回提交数据。

  • “%”字符是不支持通配符的全文搜索。

12.9.6微调MySQL全文搜索

MySQL的全文搜索能力有几个用户可调参数。你可以对全文搜索行为更多的控制,如果你有一个MySQL源分布由于一些变化需要修改源代码。看到2.8节,从“源”安装MySQL

全文检索是仔细调整效果。修改在大多数情况下,默认的行为实际上会降低效能。不改变MySQL的来源,除非你知道你正在做什么

在本节中描述的大多数全文变量必须设置在服务器启动时间。重新启动服务器是需要改变他们;他们不能在服务器正在运行的改进。

一些变量的变化需要你重建FULLTEXT表中的索引。这样做了以后这段指令。

配置最小和Maximum Word Length

被索引的最小和最大长度定义的话innodb_ft_min_token_sizeinnodb_ft_max_token_sizeInnoDB搜索索引,和ft_min_word_lenft_max_word_lenMyISAM的人

笔记

最小和最大词长全文参数不适用于FULLTEXT使用频率分析器创建索引。创建令牌的大小是确定的ngram_token_size选项

改变任何这些选项后,重建你的FULLTEXT要使更改生效,指标。例如,使双字词搜索,你可以把下面的线在一个选项文件:

[mysqld]innodb_ft_min_token_size=2ft_min_word_len=2

然后重新启动服务器并重建你的FULLTEXT指标。为MyISAM表,注意言论myisamchk在后面的指示,重建MyISAMFull-Text Ind反射。

配置的自然语言搜索阈值

MyISAM搜索索引,自然语言搜索50%的阈值是通过选择特定的加权方案的确定。要禁用它,看看下面的线ftdefs.h MyISAM存储/ /

#define GWS_IN_USE GWS_PROB

改变该行这:

#define GWS_IN_USE GWS_FREQ

然后重新编译MySQL。没有必要在这种情况下,重建索引。

笔记

做这种改变,你严重地降低MySQL的能力提供充分的相关值MATCH()功能。如果你真的要寻找这样的常用词,它会更好地使用搜索在布尔模式相反,不遵守50 %的门槛。

修改布尔全文搜索算子

更改用于布尔全文搜索的运营商MyISAM表格设置ft_boolean_syntax可变系统。(InnoDB没有等效的设置。)该变量可以在服务器运行的是改变,但你必须有SYSTEM_VARIABLES_ADMINSUPER这样做的特权。在这种情况下不需要重建索引是必要的。看到第5.1.7,服务器“系统变量”,它描述了如何设置这个变量的规则。

字符集的修改

对内置全文解析,你可以改变,在几个方面考虑单词字符的字符集,如下所示。经过改造,重建索引每个表包含任何FULLTEXT指标。假设你想将连字符(“”)作为一个字符。使用这些方法之一:

  • 修改:在MySQL源storage/innobase/handler/ha_innodb.cc(为InnoDB),或storage/myisam/ftdefs.h(为MyISAM),它的true_word_char()misc_word_char()宏。添加'-'一个宏和编译MySQL。

  • 修改字符集文件:这不需要重新编译。这个true_word_char()宏使用一个字符类型表区分字母和数字的其他字符。你可以编辑的内容<ctype><map>在一个字符数组集合的XML文件来指定“-”是一个书信然后使用给定你的性格FULLTEXT指标。的信息<ctype><map>阵列格式,见第10.12.1,”角色定义数组”

  • 添加索引列以用于字符的新的整理,并改变列使用整理。有关添加排序规则的一般信息,看10.13节,“添加整理到一个字符集”。为例,具体到全文索引,看第12.9.7,”添加一个排序规则的全文索引”

重建InnoDB全文索引

如果你修改了全文索引(变量的影响innodb_ft_min_token_sizeinnodb_ft_max_token_sizeinnodb_ft_server_stopword_tableinnodb_ft_user_stopword_tableinnodb_ft_enable_stopwordngram_token_size你必须重建你的全文指标后的变化。修改innodb_ft_min_token_sizeinnodb_ft_max_token_size,或ngram_token_size变量,不能动态设置,需要重新启动服务器并重建索引。

重建FULLTEXT指标为InnoDB表,使用ALTER TABLE删除索引ADD INDEX选择删除并重新创建的每个索引。

InnoDB全文索引优化

运行OPTIMIZE TABLE在桌上有一个全文索引重新生成全文索引,删除的文档ID和整合多个条目为同一词,在可能的情况下。

优化全文索引,使innodb_optimize_fulltext_only和运行优化表

mysql> set GLOBAL innodb_optimize_fulltext_only=ON;
Query OK, 0 rows affected (0.01 sec)

mysql> OPTIMIZE TABLE opening_lines;
+--------------------+----------+----------+----------+
| Table              | Op       | Msg_type | Msg_text |
+--------------------+----------+----------+----------+
| test.opening_lines | optimize | status   | OK       |
+--------------------+----------+----------+----------+
1 row in set (0.01 sec)    

为了避免冗长的重建对大表的全文索引的时候,你可以使用innodb_ft_num_word_optimize在执行阶段的优化选择。这个innodb_ft_num_word_optimize选项定义的话,每次数优化OPTIMIZE TABLE运行。默认设置为2000,这意味着2000个字是优化的每一次OPTIMIZE TABLE运行。随后OPTIMIZE TABLE行动继续在前面OPTIMIZE TABLE手术结束

重建表的全文索引

如果你修改了全文索引(变量的影响ft_min_word_lenft_max_word_len,或ft_stopword_file),或者如果你改变词文件本身,你必须重建你的全文指标后的变化和重新启动服务器。

重建FULLTEXT指标为MyISAM表,它足以做QUICK修复术:

MySQL的&#62;REPAIR TABLE tbl_name QUICK;

另外,使用ALTER TABLE如刚才所描述的。在某些情况下,这可能比一个修复操作更快。

每个表包含任何FULLTEXT指标必须修复只是显示。否则,该表的查询可能产生不正确的结果,并对表格的修改将导致服务器看到桌上的腐败需要修理。

如果你使用myisamchk执行一个操作,修改MyISAM 表索引(如维修或分析),该全文重建索引使用默认最小字长全文的参数值,最大词长、词的文件,除非您指定。这可能会导致查询失败。

问题的发生是因为这些参数都是由服务器只知道。他们不存储在MyISAM索引文件。为了避免这一问题如果你有改进的最小或最大词长、词文件服务器使用的值,指定相同的ft_min_word_lenft_max_word_len,和ft_stopword_filemyisamchk你可以用mysqld。例如,如果你有设置最小字长,可以修复表myisamchk这样地:

myisamchk --recover --ft_min_word_len=3 tbl_name.MYI

确保myisamchk和服务器使用相同的价值观,为全文的参数,每一个都[mysqld]myisamchk [ ]一个选项文件部分:

[mysqld]
ft_min_word_len=3

[myisamchk]
ft_min_word_len=3

一个可选择使用myisamchkMyISAM表索引修改使用REPAIR TABLEANALYZE TABLEOPTIMIZE TABLE,或ALTER TABLE声明.这些陈述是由服务器完成,从而知道适当的参数值,使用全文。

12.9.7添加一个全文索引排序

本节介绍如何添加全文搜索使用内置的全文解析新整理。样品整理如latin1_swedish_ci而治疗“-”性格而不是作为一个标点符号,它可以作为索引的单词字符的一封信。有关添加排序规则的一般信息了10.13节,“添加整理到一个字符集”;假定你已经阅读并熟悉相关文件。

添加一个全文索引排序,使用下面的过程。这里的说明添加一个简单的字符集整理,并讨论10.13节,“添加整理到一个字符集”,可以创建使用一个配置文件,描述了字符集的性质。对于一个复杂的字符集,例如Unicode,创建使用C源文件描述字符排序规则设置属性。

  1. 添加整理的Index.xml文件整理ID必须是未使用的,所以选择一个不同于1000如果ID已经被你的制度价值。

    <charset name="latin1">...<collation name="latin1_fulltext_ci" id="1000"/></charset>
  2. 声明在整理排序顺序latin1.xml文件在这种情况下,为了可以复制我们_瑞典_ latin1

    <collation name="latin1_fulltext_ci">
    <map>
    00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
    10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
    20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F
    30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F
    40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
    50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F
    60 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
    50 51 52 53 54 55 56 57 58 59 5A 7B 7C 7D 7E 7F
    80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F
    90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
    A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF
    B0 B1 B2 B3 B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF
    41 41 41 41 5C 5B 5C 43 45 45 45 45 49 49 49 49
    44 4E 4F 4F 4F 4F 5D D7 D8 55 55 55 59 59 DE DF
    41 41 41 41 5C 5B 5C 43 45 45 45 45 49 49 49 49
    44 4E 4F 4F 4F 4F 5D F7 D8 55 55 55 59 59 DE FF
    </map>
    </collation>
    
  3. 修改ctype阵列latin1.xml。0x2d变化对应的价值(这是对代码'-'字符)从10(标点)为1(小写字母)。在下面的阵列,这是在第四排下元,从第三年底的价值。

    <ctype><map>0020 20 20 20 20 20 20 20 20 28 28 28 28 28 20 2020 20 20 20 20 20 20 20 20 20 20 20 20 20 20 2048 10 10 10 10 10 10 10 10 10 10 10 100110 1084 84 84 84 84 84 84 84 84 84 10 10 10 10 10 1010 81 81 81 81 81 81 01 01 01 01 01 01 01 01 0101 01 01 01 01 01 01 01 01 01 01 10 10 10 10 1010 82 82 82 82 82 82 02 02 02 02 02 02 02 02 0202 02 02 02 02 02 02 02 02 02 02 10 10 10 10 2010 00 10 02 10 10 10 10 10 10 01 10 01 00 01 0000 10 10 10 10 10 10 10 10 10 02 10 02 00 02 0148 10 10 10 10 10 10 10 10 10 10 10 10 10 10 1010 10 10 10 10 10 10 10 10 10 10 10 10 10 10 1001 01 01 01 01 01 01 01 01 01 01 01 01 01 01 0101 01 01 01 01 01 01 10 01 01 01 01 01 01 01 0202 02 02 02 02 02 02 02 02 02 02 02 02 02 02 0202 02 02 02 02 02 02 10 02 02 02 02 02 02 02 02</map></ctype>
  4. 重新启动服务器

  5. 采用新的排序规则,它包括在列的定义来使用它:

    mysql> DROP TABLE IF EXISTS t1;
    Query OK, 0 rows affected (0.13 sec)
    
    mysql> CREATE TABLE t1 (
        a TEXT CHARACTER SET latin1 COLLATE latin1_fulltext_ci,
        FULLTEXT INDEX(a)
        ) ENGINE=InnoDB;
    Query OK, 0 rows affected (0.47 sec)
    
  6. 测试整理验证字符视为文字字符:

    mysql> INSERT INTO t1 VALUEs ('----'),('....'),('abcd');
    Query OK, 3 rows affected (0.22 sec)
    Records: 3  Duplicates: 0  Warnings: 0
    
    mysql> SELECT * FROM t1 WHERE MATCH a AGAINST ('----' IN BOOLEAN MODE);
    +------+
    | a    |
    +------+
    | ---- |
    +------+
    1 row in set (0.00 sec)
    

12.9.8 Ngram全文解析

内置MySQL全文解析器使用单词之间的空格作为分隔符来确定单词的开始和结束,这是一个限制与表意的语言,不要用文字分隔符时。为了解决这个问题,提供了一个创建MySQL全文解析器支持中国、日本、韩国(CJK)。Ngram全文解析器支持使用InnoDBMyISAM

笔记

MySQL还提供了一个mecab全文解析插件的日本,其标记的文件转换成有意义的词。有关更多信息,参见第12.9.9,“mecab全文解析插件”

一个元组是一个连续的序列n从一个给定的序列的文本字符。Ngram解析器标记序列的文本转换成一个连续的序列n人物例如,您可以标记ABCD不同的价值观n使用创建全文解析

n=1: 'a', 'b', 'c', 'd'n=2: 'ab', 'bc', 'cd'n=3: 'abc', 'bcd'n=4: 'abcd'

Ngram全文解析器是一个内置的服务器插件。与其他内置的服务器插件,它会自动加载在服务器启动时。

在全文搜索语法描述12.9节,“全文搜索功能”适用于创建解析器插件。在解析本节所描述的行为差异。全文相关的配置选项,除了最小和最大词长选项(innodb_ft_min_token_sizeinnodb_ft_max_token_sizeft_min_word_lenft_max_word_len)也适用

配置创建令牌的大小

Ngram解析器默认创建令牌尺寸2(二)。例如,一个令牌的大小2,Ngram解析器解析字符串ABC DEF四令牌:AB公元前DEEF

创建令牌的大小是可配置的应用ngram_token_size配置选项,其中有一个最小1和最大值10值。

通常,ngram_token_size设置的最大令牌的大小,你要搜索。如果你只想搜索单个字符,设置ngram_token_size1。一个较小的令牌的大小产生一个较小的全文搜索索引和搜索速度。如果你需要搜索包含多个字符的话,集ngram_token_size因此。例如,生日快乐生日快乐简体中文,在那里生日生日,和快乐你translates幸福的。对双字词等这些搜索设置ngram_token_size为2或更高的值

作为一个只读变量,ngram_token_size只能作为一个启动或配置文件中的字符串的一部分:

  • 启动字符串:

    mysqld --ngram_token_size=2
  • 配置文件:

    [mysqld]
    ngram_token_size=2
笔记

下面的最小和最大词长的配置选项都被忽略了FULLTEXT指标使用频率分析器:innodb_ft_min_token_sizeinnodb_ft_max_token_sizeft_min_word_len,和ft_max_word_len

创建全文索引,使用频率分析器

创建一个FULLTEXT指标使用频率分析器,指定与解析型CREATE TABLEALTER TABLE,或CREATE INDEX

下面的示例演示了一个创建表ngram全文指数,将样本数据(简体中文),并在查看标记过的数据INFORMATION_SCHEMA.INNODB_FT_INDEX_CACHE

mysql> USE test;mysql> CREATE TABLE articles (      id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,      title VARCHAR(200),      body TEXT,      FULLTEXT (title,body) WITH PARSER ngram    ) ENGINE=InnoDB CHARACTER SET utf8mb4;mysql> SET NAMES utf8mb4;INSERT INTO articles (title,body) VALUES    ('数据库管理','在本教程中我将向你展示如何管理数据库'),    ('数据库应用开发','学习开发数据库应用程序');    mysql> SET GLOBAL innodb_ft_aux_table="test/articles";mysql> SELECT * FROM INFORMATION_SCHEMA.INNODB_FT_INDEX_CACHE ORDER BY doc_id, position;

添加一个FULLTEXT在现有的表的索引,您可以使用ALTER TABLECREATE INDEX。。。。。。。例如:

CREATE TABLE articles (      id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,      title VARCHAR(200),      body TEXT     ) ENGINE=InnoDB CHARACTER SET utf8;ALTER TABLE articles ADD FULLTEXT INDEX ft_index (title,body) WITH PARSER ngram;# Or:CREATE FULLTEXT INDEX ft_index ON articles (title,body) WITH PARSER ngram;

空间频率分析器处理

Ngram解析器消除空间解析。例如:

  • AB CD解析ABCD

  • BC解析公元前

ngram Parser Stopword处理

内置MySQL全文解析比较词stopword列表中的条目。如果一个词在停用词表等于一个条目,这个词是被排除在索引。为创建解析器,停用词处理是不同的。而不含标记的停用词表等于条目,Ngram分析器排除标记包含停用词。例如,假设ngram_token_size=2,一个文件包含A,B解析一个,,B。if(A款)被定义为一个词,都一个,,B因为他们被排除在索引中包含一个逗号。

默认情况下,Ngram解析器使用默认的停用词列表,其中包含一个列表的英语stopwords。一个适用于中国、日本或韩国,停用词列表,您必须创建自己的。有关创建一个停用词列表的信息,参见第12.9.4,“全文构建”

长度大于stopwordsngram_token_size被忽略

频率分析器词搜索

自然语言模式搜索,搜索词转化为一个元组联盟。例如,字符串美国广播公司(保险)ngram_token_size=2)转换为AB,BC。给定两个文件,一个包含AB和其他含有美国广播公司,搜索词AB,BC匹配文件

布尔模式搜索,搜索词转换为频率搜索短语。例如,字符串“ABC”(假设ngram_token_size=2)转换为“AB,BC&#39;。给定两个文件,一个包含AB和包含的其他搜索短语“ABC”,AB,BC“只匹配文档的“ABC”。

创建解析器通配符搜索

因为一个元组FULLTEXT索引只包含ngrams,并且不包含有关条款的开始信息,通配符搜索可能返回意外的结果。以下行为适用于通配符搜索使用频率全文搜索索引:

  • 如果一个通配符搜索前缀词比NGRAM令牌的大小,查询返回的所有索引列的前缀词开始创建令牌。例如,假设ngram_token_size=2第二次*返回所有行开始

  • 如果一个通配符搜索前缀词比NGRAM令牌尺寸更长,前缀词转换为一个元组的短语和通配符运算符是忽略。例如,假设ngram_token_size=2,一个ABC *通配符搜索转换为AB,BC

短语搜索频率分析器

短语搜索转换为频率短语搜索。例如,搜索短语美国广播公司转换为AB,BC返回文件,包含美国广播公司AB,BC

搜索短语ABC DEF转换为AB BC DE EF返回文件,包含ABC DEFAB BC DE EF. 集装箱文件ABCDEF不返回

12.9.9 mecab全文解析插件

内置MySQL全文解析器使用单词之间的空格作为分隔符来确定单词的开始和结束,这是一个限制与表意的语言,不要用文字分隔符时。对于日本的这一局限性地址,MySQL提供了一个mecab全文解析插件。全文的mecab解析器插件还支持使用InnoDBMyISAM

笔记

MySQL提供了一个创建全文解析插件,支持日本。有关更多信息,参见第12.9.8,“创建全文解析”

全文的mecab解析器插件是一个全文解析插件的日本,标记序列的文本转换成有意义的词。例如,MeCab标记数据库管理数据库管理)为数据库数据库)和管理管理)。由比较,全文文本解析器标记成一个连续的序列n字符,其中n代表一个1-10之间的数。

除了标记文本转换成有意义的话,mecab指标比NGRAM指标通常小,和mecab全文搜索通常较快。一个缺点是,它可能需要更长的时间为mecab全文解析器来标记文件,相比于创建全文解析。

在全文搜索语法描述12.9节,“全文搜索功能”适用于mecab解析器插件。在解析本节所描述的行为差异。全文相关的配置选项也适用。

关于mecab解析器的更多信息,请参阅MeCab:另一部分语音和词法分析器GitHub上的项目。

安装MeCab Parser Plugin

mecab解析器插件需要的mecab我ipadic mecab

在支持的Fedora,Debian和Ubuntu平台(除了Ubuntu 12.04的系统mecab版本太老),MySQL动态链接系统mecab安装,如果是安装到默认位置。其他支持Unix平台,libmecab.so静态链接libpluginmecab.so,它位于MySQL插件目录。mecab-ipadic包含在MySQL的二进制文件和位于MYSQL_HOME\图书馆\处

你可以安装mecab我ipadic mecab使用本地的软件包管理工具(在费多拉,Debian和Ubuntu),或者你可以建立mecab我ipadic mecab从源。有关安装mecab我ipadic mecab使用本地软件包管理工具,看从一个二进制分布安装mecab(可选)。如果你想建立mecab我ipadic mecab从来源看,从源代码构建mecab(可选)

在Windows,libmecab.dll在MySQL的发现箱子目录mecab-ipadic位于MYSQL_HOME/图书馆/处

安装和配置mecab解析器插件,执行以下步骤:

  1. 在MySQL的配置文件设置mecab_rc_file配置选项的位置mecabrc配置文件,这是mecab配置文件。如果您使用的是mecab包分布与MySQL的mecabrc文件位于MySQL _家/图书馆/处/

    [mysqld]
    loose-mecab-rc-file=MYSQL_HOME/lib/mecab/etc/mecabrc

    这个loose前缀是一选择改性剂。这个mecab_rc_file选项不被MySQL直到安装mecab解析器插件,但必须建立在尝试安装mecab解析器插件。这个释放前缀可以重启mysql没有遇到错误由于一个未知的变量。

    如果你能用你自己的mecab安装,或从源代码构建mecab,的位置mecabrc配置文件可能不同

    关于mysql的配置文件的位置信息,看第4.2.6、“使用选项文件”

  2. 在MySQL的配置文件,设置最小标记尺寸1或2,这是值的推荐使用的mecab分析器。为InnoDB表,最小标记尺寸的定义是innodb_ft_min_token_size配置选项,它的默认值为3。为MyISAM表,最小标记尺寸的定义ft_min_word_len,它的默认值为4

    [mysqld]innodb_ft_min_token_size=1
  3. 修改mecabrc配置文件中指定要使用的词典。这个我ipadic mecab包分布与MySQL的二进制文件包括三本字典(ipadic_euc-jpipadic _ sjis,和ipadic_gb3212)。themecabrc配置文件打包与MySQL包含与进入类似如下:

    dicdir =  /path/to/mysql/lib/mecab/lib/mecab/dic/ipadic_euc-jp

    使用ipadic_gb3212字典,例如,修改条目如下:

    dicdir=MYSQL_HOME/ LIB / MEMB / DIC / IPADIC AND gb3212

    如果您使用的是自己的mecab安装或从源代码建立mecab,默认dicdir在进入mecabrc文件将不同,将词典及其位置。

    笔记

    安装后mecab解析器插件,你可以使用mecab_charset用mecab状态变量查看字符集。3 mecab词典提供的MySQL二进制支持以下字符集。

    • 这个ipadic_euc-jp词典支持ujiseucjpms字符集

    • 这个ipadic_sjis词典支持SJIScp932字符集

    • 这个ipadic_gb3212词典支持UTF8utf8mb4字符集

    mecab_charset只报告第一个支持的字符集。例如,在ipadic _ utf - 8词典支持utf8utf8mb4mecab_charset总报告UTF8当这本词典使用

  4. 启动MySQL

  5. 《mecab安装插件解析器。

    的mecab解析器插件安装使用INSTALL PLUGIN语法。“过去的插件mecab,和共享库的名字是libpluginmecab.so。有关安装插件,看第5.6.1,“安装和卸载插件”

    INSTALL PLUGIN mecab SONAME 'libpluginmecab.so';
    

    一旦安装,该mecab解析器插件加载在每一个正常的MySQL重启。

  6. 验证mecab解析器插件加载使用SHOW PLUGINS声明

    MySQL &#62;显示插件;

    mecab插件应该出现在插件列表。

创建全文索引,使用mecab分析器

创建一个FULLTEXT指数使用mecab解析器,指定与解析型CREATE TABLEALTER TABLE,或CREATE INDEX

这个例子演示了一个创建表mecab全文指数,将样本数据,并在查看标记过的数据INFORMATION_SCHEMA.INNODB_FT_INDEX_CACHE

mysql> USE test;mysql> CREATE TABLE articles (      id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,      title VARCHAR(200),      body TEXT,      FULLTEXT (title,body) WITH PARSER mecab    ) ENGINE=InnoDB CHARACTER SET utf8;mysql> SET NAMES utf8;    mysql> INSERT INTO articles (title,body) VALUES    ('データベース管理','このチュートリアルでは、私はどのようにデータベースを管理する方法を紹介します'),    ('データベースアプリケーション開発','データベースアプリケーションを開発することを学ぶ');mysql> SET GLOBAL innodb_ft_aux_table="test/articles";mysql> SELECT * FROM INFORMATION_SCHEMA.INNODB_FT_INDEX_CACHE ORDER BY doc_id, position;

添加一个FULLTEXT在现有的表的索引,您可以使用ALTER TABLECREATE INDEX。。。。。。。例如:

CREATE TABLE articles (      id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,      title VARCHAR(200),      body TEXT     ) ENGINE=InnoDB CHARACTER SET utf8;ALTER TABLE articles ADD FULLTEXT INDEX ft_index (title,body) WITH PARSER mecab;# Or:CREATE FULLTEXT INDEX ft_index ON articles (title,body) WITH PARSER mecab;

mecab解析器太空行动

The Mecaby Parse Uses Spares as Separkese in Query Strings .For example,the Mecabb Parse Tokeizes数据库管理作为数据库管理

MeCab Parser Stopword处理

默认情况下,该mecab解析器使用默认的停用词列表,其中包含一个简短的列表构建英语。一个适用于日本停用词列表,您必须创建自己的。有关创建停用词列表的信息,参见第12.9.4,“全文构建”

长期处解析器搜索

自然语言模式搜索,搜索词转化为一个联盟令牌。例如,数据库管理转换为数据库管理

SELECT COUNT(*) FROM articles WHERE MATCH(title,body) AGAINST('データベース管理' IN NATURAL LANGUAGE MODE);

布尔模式搜索,搜索词转化为一个搜索短语。例如,数据库管理转换为数据库管理

SELECT COUNT(*) FROM articles WHERE MATCH(title,body) AGAINST('データベース管理' IN BOOLEAN MODE);

mecab解析器通配符搜索

通配符搜索术语不分词。搜索数据库管理*在前缀进行,数据库管理

SELECT COUNT(*) FROM articles WHERE MATCH(title,body) AGAINST('データベース*' IN BOOLEAN MODE);

mecab短语搜索分析器

短语标记。例如,数据库管理是代号为数据库管理

SELECT COUNT(*) FROM articles WHERE MATCH(title,body) AGAINST('"データベース管理"' IN BOOLEAN MODE);

从一个二进制分布安装mecab(可选)

本节介绍如何安装mecab我ipadic mecab使用一个本地的软件包管理工具的二进制分布。例如,在费多拉,你可以使用yum来执行安装:

yum mecab-devel

在Debian和Ubuntu,你可以做一个恰当的安装:

apt-get install mecab
apt-get install mecab-ipadic

从源码安装mecab(可选)

如果你想建立mecab我ipadic mecab从来源、基本安装步骤如下。有关更多信息,请参阅mecab文档。

  1. 下载的压缩包mecab我ipadic mecabtaku910.github.io http:/ / / / #下载处。截至2016年2月,最新的可用的软件包mecab-0.996.tar.gzmecab-ipadic-2.7.0-20070801.tar.gz

  2. 安装mecab

    zxfv mecab-0.996.tarcd mecab-0.996焦油/ configuremakemake checksumake安装。
  3. 安装mecab-ipadic

    焦油zxfv mecab-ipadic-2.7.0-20070801.tarcd mecab-ipadic-2.7.0-20070801 / configuremakesumake安装。
  4. 编译MySQL的使用WITH_MECAB支持的选项。设置WITH_MECAB选项系统如果你已经安装了mecab我ipadic mecab到默认位置

    -DWITH_MECAB=system

    如果你定义了一个自定义安装目录,设置WITH_MECAB到自定义目录。例如:

    -DWITH_MECAB=/path/to/mecab

12.10铸造的函数和操作符

表时铸的函数和操作符

姓名描述
BINARY将一个字符串赋给一个二进制字符串
CAST()铸造一个值作为某型
CONVERT()铸造一个值作为某型

铸造的函数和操作符使转换的值从一种数据类型转换为另一种。

CONVERT()用一个使用条款提供了一种不同的字符集之间的数据转换:

CONVERT(expr USING transcoding_name)

在MySQL中,转码的名字为相应的字符集名称相同。

实例:

SELECT CONVERT(_latin1'Müller' USING utf8);
INSERT INTO utf8_table (utf8_column)
    SELECT CONVERT(latin1_column USING utf8) FROM latin1_table;

你也可以使用CONVERT()没有使用CAST()不同的字符集的字符串之间的转换:

转换(string,字符[(N)]字符集charset_name铸造()string焦炭[(N)]字符集charset_name

实例:

SELECT CONVERT('test', CHAR CHARACTER SET utf8);
SELECT CAST('test' AS CHAR CHARACTER SET utf8);

如果你指定CHARACTER SET charset_name正如所示,产生的字符集和整理是charset_name和默认的排序charset_name。如果省略字符集charset_name,产生的字符集和整理是指由character_set_connectioncollation_connection系统变量确定默认的连接字符集和整理(见10.4节,“连接字符集和Collations”

COLLATE允许在没有条款CONVERT()CAST()打电话,但是你可以把它应用到函数的结果。例如,这是合法的:

选择演员(测试为char字符集utf8)整理utf8_bin;

但这是违法的:

SELECT CAST('test' AS CHAR CHARACTER SET utf8 COLLATE utf8_bin);

通常情况下,你无法比较BLOB价值或其他二进制字符串不区分大小写的方式因为二进制字符串的使用二元的字符集,它与lettercase概念没有整理。执行区分大小写的比较,使用CONVERT()CAST()函数值转换为一个二进制字符串。所产生的字符串比较使用的排序规则。例如,如果转换结果字符集有大小排序,一LIKE操作是不区分大小写:

选择一个像转换(blob_col使用latin1)从tbl_name

使用不同的字符集,替代它的名字latin1在前面的声明。指定转换后的字符串的排序,使用整理以下的条款CONVERT()呼叫:

选择一个像转换(blob_col使用latin1)整理latin1_german1_ci从tbl_name

CONVERT()CAST()可以用更一般的比较,在不同的字符集表示的字符串。例如,比较这些字符串的结果错误,因为他们有不同的字符集:

MySQL的&#62;SET @s1 = _latin1 'abc', @s2 = _latin2 'abc';MySQL的&#62;SELECT @s1 = @s2;ERROR 1267 (HY000): Illegal mix of collations (latin1_swedish_ci,IMPLICIT)and (latin2_general_ci,IMPLICIT) for operation '='

转换一个字符串到一个字符集兼容其他能够发生无误差的比较:

mysql> SELECT @s1 = CONVERT(@s2 USING latin1);
+---------------------------------+
| @s1 = CONVERT(@s2 USING latin1) |
+---------------------------------+
|                               1 |
+---------------------------------+

对于字符串,另一种方式来指定字符集使用的字符集,介绍人(_latin1_ latin2在前面的示例中的实例介绍)。与转换等功能CAST(),或CONVERT(),它将一个字符串从一个字符集到另一个,介绍人指定一个字符串作为一个特定的字符集转换,不涉及。有关更多信息,参见第10.3.8,“字符集范围”

字符集转换也是有用的前lettercase转换二进制字符串。LOWER()UPPER()无效时直接应用于二进制字符串,因为lettercase概念不适用。执行二进制字符串lettercase转换,首先将它转换成一个二进制字符串:

MySQL的&#62;SET @str = BINARY 'New York';MySQL的&#62;SELECT LOWER(@str), LOWER(CONVERT(@str USING utf8mb4));------------- ------------------------------------ |下(@ STR)|低(转换(@ STR使用utf8mb4))| ------------- ------------------------------------ |纽约|纽约| ------------- ------------------------------------

如果你将一个索引列使用BINARYCAST(),或CONVERT(),MySQL可能无法有效地使用索引。

铸造功能可用于在一个特定的类型创建一个柱CREATE TABLE ... SELECT声明:

MySQL的&#62;CREATE TABLE new_table SELECT CAST('2000-01-01' AS DATE) AS c1;MySQL的&#62;SHOW CREATE TABLE new_table\G*************************** 1. row ***************************       Table: new_tableCreate Table: CREATE TABLE `new_table` (  `c1` date DEFAULT NULL) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4

演员的功能是有用的分类ENUM在词汇顺序列。通常,排序ENUM列时使用内部数值。铸造价值CHAR在词汇分类结果:

选择enum_coltbl_name以铸造(enum_col焦炭);

CAST()同时变化的结果如果你使用它作为一个更复杂的表达式,如部分CONCAT('Date: ',CAST(NOW() AS DATE))

时间的价值,就不需要使用CAST()提取不同格式的数据。相反,使用功能等EXTRACT()DATE_FORMAT(),或TIME_FORMAT()。看到12.7节,“戴特和时间函数”

将一个字符串和一个数字,你需要做的只是在数字环境中使用字符串值:

mysql> SELECT 1+'1';
       -> 2

这也是真正的进制位字符,这是二进制字符串默认:

mysql> SELECT X'41', X'41'+0;
        -> 'A', 65
mysql> SELECT b'1100001', b'1100001'+0;
        -> 'a', 97

一种用于算术运算的字符串转换为浮点数在表达评价。

一种用于字符串上下文数转换为字符串:

mysql> SELECT CONCAT('hello you ',2);
        -> 'hello you 2'

关于串数字隐式转换的信息,参见第二节,“表达评价类型转换”

MySQL支持算术有符号和无符号位的值。数字运营商(如+-)一个操作数是无符号整数,其结果是无符号的默认(见第12.6.1,“算子”)。重写,使用SIGNED无符号操作工投值符号或无符号64位整数,分别。

mysql> SELECT 1 - 2;
        -> -1
mysql> SELECT CAST(1 - 2 AS UNSIGNED);
        -> 18446744073709551615
mysql> SELECT CAST(CAST(1 - 2 AS UNSIGNED) AS SIGNED);
        -> -1

如果一个操作数是浮点数,结果是一个浮点值并不是由前面的规则影响。(在这种情况下,DECIMAL列值为浮点值。)

MySQL的&#62;SELECT CAST(1 AS UNSIGNED) - 2.0;&#62; 1

SQL方式影响转换操作的结果(见第5.1.10,”服务器的SQL模式”)。实例:

下面的列表描述了可用的铸造函数和操作符:

  • BINARYexpr

    这个BINARY运营商将表达为二进制字符串。最常见的用法BINARY很给力的一个字符串比较是字节而不是字符字符做字节,实际上变得敏感。这个BINARY运营商也会尾随空格是重要的比较。

    MySQL的&#62;SELECT 'a' = 'A';-> 1mysql>SELECT BINARY 'a' = 'A';-> 0mysql>SELECT 'a' = 'a ';-> 1mysql>SELECT BINARY 'a' = 'a ';&#62; 0

    在一个比较,BINARY影响整个操作;它可以在一个操作数具有相同的结果。

    用于将字符串转换为一个二进制字符串表达的目的,这些结构是等价的:

    BINARY expr
    CAST(expr AS BINARY)
    CONVERT(expr USING BINARY)
    

    如果一个值是一个字符串,它可以被指定为一个二进制串不执行任何转换利用_binary字符集介绍人:

    MySQL的&#62;SELECT 'a' = 'A';-> 1mysql>SELECT _binary 'a' = 'A';&#62; 0

    有关介绍,看第10.3.8,“字符集范围”

    这个BINARY运营商在不同的表达效果二元的在字符列定义属性。与定义的字符列BINARY属性指定表的默认字符集和二进制(_bin该字符集整理)。每一个二进制的字符集有一个_bin整理。例如,对于二进制排序规则UTF8字符集是utf8_bin,所以如果表的默认字符集UTF8,这两列定义是等价的:

    CHAR(10) BINARY
    CHAR(10) CHARACTER SET utf8 COLLATE utf8_bin
    

    使用CHARACTER SET binary在一个定义CHARVARCHAR,或TEXT柱使柱被视为相应的二进制字符串数据类型。例如,以下对定义是等价的:

    char(10)字符集binarybinary(10)varchar(10)字符集binaryvarbinary(10)文本字符集binaryblob
  • CAST(expr AS type)

    这个CAST()函数不需要任何类型的表达式产生一个指定类型的结果值,类似于CONVERT()。更多信息,见描述CONVERT()

    CAST()是标准的SQL语法

  • CONVERT(expr,type)CONVERT(expr USING transcoding_name)

    这个CONVERT()函数不需要任何类型的表达式产生一个指定类型的结果值。

    讨论CONVERT(expr, type)语法在这里也适用于CAST(expr AS type),这相当于

    CONVERT(... USING ...)是标准的SQL语法。非—使用形式CONVERT()是ODBC语法

    CONVERT()使用不同的字符集之间的数据转换。在MySQL中,转码的名字为相应的字符集名称相同。例如,该语句将字符串'abc'在设置在相应的字符串默认字符UTF8字符集:

    SELECT CONVERT('abc' USING utf8);
    

    CONVERT()没有使用CAST()把一个表达式和一个type值指定结果类型。这些type值是允许的:

    • BINARY[(N)]

      产生一个字符串的BINARY数据类型。看到第11.4.2,“binary和varbinary类型”为说明如何影响的比较。如果可选的长度N给出了,二元(N使铸造用不超过N字节的论点。值比短N字节填充0x00字节长度N

    • CHAR[(N)] [charset_info]

      产生一个字符串的CHAR数据类型。If the optional lengthN给出了,char(N使铸造用不超过N争论的人物。无填料发生值小于N人物

      没有charset_info条款,烧焦产生一个与默认字符集的字符串。指定字符集明确,这些charset_info值是允许的:

      • CHARACTER SET charset_name:产生一个给定字符集的字符串。

      • ASCII:速记字符集latin1

      • UNICODE:速记UCS2字符集

      在所有情况下,字符串的默认排序规则的字符集。

    • DATE

      产生一个DATE价值

    • DATETIME

      产生一个DATETIME价值

    • DECIMAL[(M[,D])]

      产生一个DECIMAL的价值。if the optionalMD值,它们指定数字的最大位数(精度)和数字的位数小数点后(规模)。

    • JSON

      产生一个JSON价值。详细的规则转换之间的价值JSON和其他类型的,看比较和JSON值排序

    • NCHAR[(N)]

      喜欢CHAR,但产生的国家字符集的字符串。看到第10.3.7,“集”的民族性格

      不像CHARNCHAR不允许尾随字符集信息被指定。

    • SIGNED [INTEGER]

      产生一个有符号的整数。

    • TIME

      产生一个TIME价值

    • UNSIGNED [INTEGER]

      产生一个无符号整数的值。

12.11 XML功能

表12 XML功能

姓名描述
ExtractValue()提取使用XPath表示的XML字符串的值
UpdateXML()返回替换XML片段

该部分论述了XML和MySQL相关的功能。

笔记

可以从MySQL中获取XML格式化输出MySQLmysqldump通过调用他们的客户--xml选项看到4.5.1“,”MySQL- MySQL命令行工具”,和4.5.4“,”mysqldump一个数据库的备份计划”

两功能提供基本的XPath 1(XML路径语言,版本1)的功能是可用的。一些关于XPath的语法和用法基本信息设置在本节稍后;然而,这些议题深入讨论超出了本手册的范围,你应该指的是XML路径语言(XPath)1标准明确的信息。对于那些新的XPath或谁希望在温习基础知识的一个有用的资源是zvon.org XPath教程,而这几种语言是可用的。

笔记

这些功能仍在开发。我们将继续完善这些XML和MySQL 5.0 XPath功能等方面起。你可能会讨论这些,问他们一些问题,得到帮助从其他用户和他们在MySQL用户论坛

XPath表达式的使用这些功能支持用户变量和局部变量的存储程序。用户变量是弱检查;局部变量存储的程序有很强的检查(参见错误# 26518):

  • 使用变数(Weak Checking)。使用语法变量$@variable_name(即用户变量)不检查。没有警告或错误发出服务器变量是否有错误的类型或以前没有被分配一个值。这也意味着用户完全负责的任何拼写错误,因为没有警告将给予如果(举例)“myvariable美元是用在哪里$@myvariable的目的是

    例子:

    mysql> SET @xml = '<a><b>X</b><b>Y</b></a>';
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> SET @i =1, @j = 2;
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> SELECT @i, ExtractValue(@xml, '//b[$@i]');
    +------+--------------------------------+
    | @i   | ExtractValue(@xml, '//b[$@i]') |
    +------+--------------------------------+
    |    1 | X                              |
    +------+--------------------------------+
    1 row in set (0.00 sec)
    
    mysql> SELECT @j, ExtractValue(@xml, '//b[$@j]');
    +------+--------------------------------+
    | @j   | ExtractValue(@xml, '//b[$@j]') |
    +------+--------------------------------+
    |    2 | Y                              |
    +------+--------------------------------+
    1 row in set (0.00 sec)
    
    mysql> SELECT @k, ExtractValue(@xml, '//b[$@k]');
    +------+--------------------------------+
    | @k   | ExtractValue(@xml, '//b[$@k]') |
    +------+--------------------------------+
    | NULL |                                |
    +------+--------------------------------+
    1 row in set (0.00 sec)
    
  • 在存储的程序变量(强检)。使用语法变量$variable_name可以声明和使用这些功能时,他们被称为内部存储的程序。这些变量是本地存储的程序定义它们,并有很强的检查类型和值。

    例子:

    mysql> DELIMITER |
    
    mysql> CREATE PROCEDURE myproc ()
        -> BEGIN
        ->   DECLARE i INT DEFAULT 1;
        ->   DECLARE xml VARCHAR(25) DEFAULT '<a>X</a><a>Y</a><a>Z</a>';
        ->
        ->   WHILE i < 4 DO
        ->     SELECT xml, i, ExtractValue(xml, '//a[$i]');
        ->     SET i = i+1;
        ->   END WHILE;
        -> END |
    Query OK, 0 rows affected (0.01 sec)
    
    mysql> DELIMITER ;
    
    mysql> CALL myproc();
    +--------------------------+---+------------------------------+
    | xml                      | i | ExtractValue(xml, '//a[$i]') |
    +--------------------------+---+------------------------------+
    | <a>X</a><a>Y</a><a>Z</a> | 1 | X                            |
    +--------------------------+---+------------------------------+
    1 row in set (0.00 sec)
    
    +--------------------------+---+------------------------------+
    | xml                      | i | ExtractValue(xml, '//a[$i]') |
    +--------------------------+---+------------------------------+
    | <a>X</a><a>Y</a><a>Z</a> | 2 | Y                            |
    +--------------------------+---+------------------------------+
    1 row in set (0.01 sec)
    
    +--------------------------+---+------------------------------+
    | xml                      | i | ExtractValue(xml, '//a[$i]') |
    +--------------------------+---+------------------------------+
    | <a>X</a><a>Y</a><a>Z</a> | 3 | Z                            |
    +--------------------------+---+------------------------------+
    1 row in set (0.01 sec)
    

    参数.在XPath表达式中使用内部存储程序,作为参数传递也受到强烈的检查变量。

包含用户变量或局部变量存储的程序必须否则表达式(除符号)符合XPath表达式含有变量的规则在XPath 1规范。

笔记

用户变量用来存储一个XPath表达式为空字符串。因此,它是不可能存储一个XPath表达式作为一个用户变量。(错误# 32911)

  • ExtractValue(xml_frag, xpath_expr)

    ExtractValue()以两个字符串参数,XML标记片段xml_frag和一个XPath表达式xpath_expr(也被称为定位器);它时返回的文本CDATA)的第一个文本节点的一个元素或元素的XPath表达式匹配的儿童。

    使用此功能是相当于执行匹配使用xpath_expr在增加(文本)。换句话说,ExtractValue('<a><b>Sakila</b></a>', '/a/b')ExtractValue('<a><b>Sakila</b></a>', '/a/b/text()')产生相同的结果

    如果发现多个匹配,对每个匹配元素的第一个子节点返回文本内容(以匹配)作为一个单一的,空间分隔的字符串。

    如果没有匹配的文本节点中的表达(包括隐/text())-不管是什么原因,只要xpath_expr是有效的,并xml_frag由元素是正确的嵌套和关闭返回一个空字符串。之间是没有区别的比赛在一个空的元素并没有在所有的比赛。这是由设计。

    如果你需要确定没有匹配的元素被发现xml_frag或者这样的元素被发现但不包含子文本节点,你应该测试表达式中使用XPath的结果count()功能。例如,无论这些语句返回一个空字符串,如下所示:

    mysql> SELECT ExtractValue('<a><b/></a>', '/a/b');
    +-------------------------------------+
    | ExtractValue('<a><b/></a>', '/a/b') |
    +-------------------------------------+
    |                                     |
    +-------------------------------------+
    1 row in set (0.00 sec)
    
    mysql> SELECT ExtractValue('<a><c/></a>', '/a/b');
    +-------------------------------------+
    | ExtractValue('<a><c/></a>', '/a/b') |
    +-------------------------------------+
    |                                     |
    +-------------------------------------+
    1 row in set (0.00 sec)
    

    然而,你可以决定是否还真的有一个匹配的元素,使用以下:

    mysql> SELECT ExtractValue('<a><b/></a>', 'count(/a/b)');
    +-------------------------------------+
    | ExtractValue('<a><b/></a>', 'count(/a/b)') |
    +-------------------------------------+
    | 1                                   |
    +-------------------------------------+
    1 row in set (0.00 sec)
    
    mysql> SELECT ExtractValue('<a><c/></a>', 'count(/a/b)');
    +-------------------------------------+
    | ExtractValue('<a><c/></a>', 'count(/a/b)') |
    +-------------------------------------+
    | 0                                   |
    +-------------------------------------+
    1 row in set (0.01 sec)
    
    重要

    ExtractValue()只返回CDATA,而不返回可能被包含在一个匹配的标签的标签,也没有他们的任何内容(见返回的结果为val1在the following example)。

    MySQL的&#62;SELECT-&#62;  ExtractValue('<a>ccc<b>ddd</b></a>', '/a') AS val1,-&#62;  ExtractValue('<a>ccc<b>ddd</b></a>', '/a/b') AS val2,-&#62;  ExtractValue('<a>ccc<b>ddd</b></a>', '//b') AS val3,-&#62;  ExtractValue('<a>ccc<b>ddd</b></a>', '/b') AS val4,-&#62;  ExtractValue('<a>ccc<b>ddd</b><b>eee</b></a>', '//b') AS val5;????????????--------- | val1 | val2 | val3 | val4 | val5 | ------?????????--------- | CCC | | DDD DDD DDD | | EEE????????????--------- |

    这个函数使用当前的SQL排序规则进行比较contains(),执行相同的排序规则聚集其他字符串函数(如CONCAT()),在考虑到他们的论点整理可压缩性;看第10.8.4,“整理可压缩性表达”为控制这一行为,规则的解释。

    (此前,二是区分大小写的比较常用。)

    NULL返回如果xml_frag包含不正确的嵌套元素或关闭,生成一个警告,如图所示:

    MySQL的&#62;SELECT ExtractValue('<a>c</a><b', '//a');+-----------------------------------+| ExtractValue('<a>c</a><b', '//a') |+-----------------------------------+| NULL                              |+-----------------------------------+1 row in set, 1 warning (0.00 sec)mysql>SHOW WARNINGS\G*************************** 1. row ***************************  Level: Warning   Code: 1525Message: Incorrect XML value: 'parse error at line 1 pos 11:         END-OF-INPUT unexpected ('>' wanted)'1 row in set (0.00 sec)mysql>SELECT ExtractValue('<a>c</a><b/>', '//a');+-------------------------------------+| ExtractValue('<a>c</a><b/>', '//a') |+-------------------------------------+| c                                   |+-------------------------------------+1 row in set (0.00 sec)
  • UpdateXML(xml_target, xpath_expr, new_xml)

    这个函数代替一个给定的XML标记片段的一部分xml_target一个新的XML片段new_xml,然后返回XML的改变。的部分xml_target这是替换匹配XPath表达式xpath_expr被使用

    如果没有表达式匹配xpath_expr被发现,或者如果找到多个匹配项,该函数返回原xml_targetXML片段。所有三个参数是字符串。

    MySQL的&#62;SELECT-&#62;  UpdateXML('<a><b>ccc</b><d></d></a>', '/a', '<e>fff</e>') AS val1,-&#62;  UpdateXML('<a><b>ccc</b><d></d></a>', '/b', '<e>fff</e>') AS val2,-&#62;  UpdateXML('<a><b>ccc</b><d></d></a>', '//b', '<e>fff</e>') AS val3,-&#62;  UpdateXML('<a><b>ccc</b><d></d></a>', '/a/d', '<e>fff</e>') AS val4,-&#62;  UpdateXML('<a><d></d><b>ccc</b><d></d></a>', '/a/d', '<e>fff</e>') AS val5-&#62;\G*************************** 1. row ***************************val1: <e>fff</e>val2: <a><b>ccc</b><d></d></a>val3: <a><e>fff</e><d></d></a>val4: <a><b>ccc</b><e>fff</e></a>val5: <a><d></d><b>ccc</b><d></d></a>
笔记

在XPath语法和用法的深度讨论超出了本手册的范围。请看XML路径语言(XPath)1规范明确的信息。对于那些新的XPath或谁希望在温习基础知识的一个有用的资源是zvon.org XPath教程,而这几种语言是可用的。

描述和一些基本的XPath表达式的例子如下:

  • /tag

    比赛<tag/>if and only if<tag/&#62;是根元素

    例子:/a有一个比赛<a><b/></a>因为它与最外层(根)标签。它不匹配的内a元素<b><a/></b>因为在这个例子中是另一个元素的子元素。

  • /tag1/tag2

    比赛<tag2/>当且仅当它是一个孩子<tag1/&#62;,和<tag1/&#62;是根元素

    例子:/a/b比赛b在XML元素<a><b/></a>因为它是一个根元素的子元素a。它没有比赛<b><a/></b>因为在这种情况下,b是根元素(因此没有其他元素的子元素)。没有XPath表达式有比赛<a><c><b/></c></a>;这里,b是一个后裔a,但不是一个孩子a

    这种结构可扩展到三个或更多的元素。例如,XPath表达式/a/b/c比赛c片段中的元素<a><b><c/></b></a>

  • //tag

    匹配任何实例<tag>

    例子://a比赛a任何元素在下面:<a><b><c/></b></a><c><a><b/></a></b><c><b><a/></b></c>

    //可以结合/。例如,//a/b比赛b在片段中的元素<a><b/></a><c><a><b/></a></c>

    笔记

    //tag相当于下一步:tag。一个常见的错误就是混淆了金/下自我::tag,虽然后者的表达可以导致非常不同的结果,这里可以看到:

    MySQL的&#62;SET @xml = '<a><b><c>w</c><b>x</b><d>y</d>z</b></a>';查询好,为受影响的行(0.001秒)MySQL &#62;SELECT @xml;+-----------------------------------------+| @xml                                    |+-----------------------------------------+| <a><b><c>w</c><b>x</b><d>y</d>z</b></a> |+-----------------------------------------+1 row in set (0.00 sec)mysql>SELECT ExtractValue(@xml, '//b[1]');------------------------------ |导致(@ XML,/ / b [1 ]”)| ------------------------------ | X Z | ------------------------------一行集(0.001秒)MySQL &#62;SELECT ExtractValue(@xml, '//b[2]');------------------------------ |导致(@ XML,/ / B [ 2 ]”)| ------------------------------ | | ------------------------------ 1行集(0.01秒)MySQL &#62;SELECT ExtractValue(@xml, '/descendant-or-self::*/b[1]');--------------------------------------------------- |导致(@ XML /后裔或自我::* / B [ 1 ]”)| --------------------------------------------------- | X Z | --------------------------------------------------- 1行集(0.06秒)MySQL &#62;SELECT ExtractValue(@xml, '/descendant-or-self::*/b[2]');--------------------------------------------------- |导致(@ XML /后裔或自我::* / B [ 2 ]”)| --------------------------------------------------- | | --------------------------------------------------- 1行集(0秒)MySQL &#62;SELECT ExtractValue(@xml, '/descendant-or-self::b[1]');------------------------------------------------- |导致(@ XML /后裔或自我::B [ 1 ]”)| ------------------------------------------------- | Z | ------------------------------------------------- 1行集(0秒)MySQL &#62;SELECT ExtractValue(@xml, '/descendant-or-self::b[2]');------------------------------------------------- |导致(@ XML /后裔或自我::B [ 2 ]”)| ------------------------------------------------- | X | ------------------------------------------------- 1行集(0秒)
  • 这个*运营商作为一个通配符匹配任何元素。例如,表达/*/b比赛b在任一的XML片段元<a><b/></a><c><b/></c>。然而,表达不在片段产生匹配<b><a/></b>因为b必须有一些其他元素的子元素。通配符可以用在任何位置的表达式:* b * / / /将匹配任何一个孩子b元素本身是没有根元素。

  • 你可以匹配任何几个定位器的使用|UNION)算子。例如,表达/ / / / C B |匹配所有bc在XML的目标元素

  • 也可以基于一个或多个属性值的元素匹配。这通过使用语法tag[@attribute="value"]。例如,表达//b[@id="idB"]比赛第二b片段中的元素<a><b id="idA"/><c/><b id="idB"/></a>。要匹配任何元件attribute="value"使用XPath表达式,/ / * [attribute="value“]

    过滤多个属性值,接着简单地使用多个属性比较从句。例如,表达//b[@c="x"][@d="y"]匹配的元素<b c="x" d="y"/>发生在一个给定的XML片段的地方。

    发现元素的同一属性匹配任何几个值,你可以使用多个定位器加入由|算子。例如,匹配所有b元素的c属性的值是23或17,使用表达式//b[@c="23"]|//b[@c="17"]。你也可以使用逻辑or为此,运营商://b[@c="23" or @c="17"]

    笔记

    之间的差异or|是的,or同意的条件下,当|加入结果集

XPath的局限性XPath语法支持这些功能是目前受以下限制:

  • nodeset NodeSet比较(如'/a/b[@c=@d]')不支持

  • 所有标准的XPath比较运算符的支持。(错误# 22823)

  • 相对定位表达式中的根节点下解决。例如,考虑下面的查询结果:

    mysql> SELECT ExtractValue(
        ->   '<a><b c="1">X</b><b c="2">Y</b></a>',
        ->    'a/b'
        -> ) AS result;
    +--------+
    | result |
    +--------+
    | X Y    |
    +--------+
    1 row in set (0.03 sec)
    

    本案例中,定位器a/b解析//B

    相对定位也支持在谓词。在下面的例子,d[../@c="1"]是解决/a/b[@c="1"]/d

    mysql> SELECT ExtractValue(
        ->      '<a>
        ->        <b c="1"><d>X</d></b>
        ->        <b c="2"><d>X</d></b>
        ->      </a>',
        ->      'a/b/d[../@c="1"]')
        -> AS result;
    +--------+
    | result |
    +--------+
    | X      |
    +--------+
    1 row in set (0.00 sec)
    
  • 定位器的前缀表达式计算为标量值,包括变量的引用,文字,数字,和标量函数调用是不允许的,在一个错误的使用结果。

  • 这个::运营商不与节点类型等组合支撑:

    • axis::comment()

    • axis::text()

    • axis::processing-instructions()

    • axis::node()

    然而,名字测试(如axis::nameaxis::*)的支持,在这些例子中所示:

    MySQL的&#62;SELECT ExtractValue('<a><b>x</b><c>y</c></a>','/a/child::b');+-------------------------------------------------------+| ExtractValue('<a><b>x</b><c>y</c></a>','/a/child::b') |+-------------------------------------------------------+| x                                                     |+-------------------------------------------------------+1 row in set (0.02 sec)mysql>SELECT ExtractValue('<a><b>x</b><c>y</c></a>','/a/child::*');+-------------------------------------------------------+| ExtractValue('<a><b>x</b><c>y</c></a>','/a/child::*') |+-------------------------------------------------------+| x y                                                   |+-------------------------------------------------------+1 row in set (0.01 sec)
  • 上下导航是不支持的情况下,这条路将引领在上面根元素。那就是,你不能使用表达式的匹配对后代的祖先的一个给定的元素,其中的一个或多个当前元素的祖先也是根元素的祖先(见虫# 16321)。

  • 不支持以下XPath函数,或已知的问题如:

    • id()

    • lang()

    • local-name()

    • name()

    • namespace-uri()

    • normalize-space()

    • starts-with()

    • string()

    • substring-after()

    • substring-before()

    • translate()

  • 不支持以下轴:

    • following-sibling

    • following

    • preceding-sibling

    • preceding

XPath表达式作为参数传递给ExtractValue()UpdateXML()可能包含冒号()在元素选择器,使其使用使用XML命名空间的符号标记。例如:

mysql> SET @xml = '<a>111<b:c>222<d>333</d><e:f>444</e:f></b:c></a>';
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT ExtractValue(@xml, '//e:f');
+-----------------------------+
| ExtractValue(@xml, '//e:f') |
+-----------------------------+
| 444                         |
+-----------------------------+
1 row in set (0.00 sec)

mysql> SELECT UpdateXML(@xml, '//b:c', '<g:h>555</g:h>');
+--------------------------------------------+
| UpdateXML(@xml, '//b:c', '<g:h>555</g:h>') |
+--------------------------------------------+
| <a>111<g:h>555</g:h></a>                   |
+--------------------------------------------+
1 row in set (0.00 sec)

这是在某些方面类似于什么是允许的Apache Xalan和一些其他的解析器,和简单得多,不需要命名空间声明或使用的namespace-uri()local-()功能.

错误处理ExtractValue()UpdateXML(),使用XPath定位必须是有效的XML和被搜查必须由被正确的嵌套和封闭的元素。如果定位器是无效的,产生一个错误:

MySQL的&#62;SELECT ExtractValue('<a>c</a><b/>', '/&a');错误1105(hy000):XPath语法错误:&#39;和&#39;

如果xml_frag不在于它是正确的嵌套和封闭的元素,无效的返回生成一个警告,如图所示:

mysql> SELECT ExtractValue('<a>c</a><b', '//a');
+-----------------------------------+
| ExtractValue('<a>c</a><b', '//a') |
+-----------------------------------+
| NULL                              |
+-----------------------------------+
1 row in set, 1 warning (0.00 sec)

mysql> SHOW WARNINGS\G
*************************** 1. row ***************************
  Level: Warning
   Code: 1525
Message: Incorrect XML value: 'parse error at line 1 pos 11:
         END-OF-INPUT unexpected ('>' wanted)'
1 row in set (0.00 sec)

mysql> SELECT ExtractValue('<a>c</a><b/>', '//a');
+-------------------------------------+
| ExtractValue('<a>c</a><b/>', '//a') |
+-------------------------------------+
| c                                   |
+-------------------------------------+
1 row in set (0.00 sec)
重要

更换XML作为第三个参数UpdateXML()检查以确定它是否仅由这套正确和封闭的元素。

XPath注入代码注入当恶意代码进入系统获得未经授权的访问权限和数据。它是基于利用的类型和用户输入的数据内容开发商提出假设。XPath是在这方面也不例外。

在这种情况发生的一个常见的场景是应用它处理授权的登录名和密码的组合与一个XML文件中找到匹配的情况下,使用XPath表达式这样:

//user[login/text()='neapolitan' and password/text()='1c3cr34m']/attribute::id

这是一个SQL语句,像这样一个XPath等效:

SELECT id FROM users WHERE login='neapolitan' AND password='1c3cr34m';

使用XPath的PHP应用程序可能处理登录过程这样:

<?php

  $file     =   "users.xml";

  $login    =   $POST["login"];
  $password =   $POST["password"];

  $xpath = "//user[login/text()=$login and password/text()=$password]/attribute::id";

  if( file_exists($file) )
  {
    $xml = simplexml_load_file($file);

    if($result = $xml->xpath($xpath))
      echo "You are now logged in as user $result[0].";
    else
      echo "Invalid login name or password.";
  }
  else
    exit("Failed to open $file.");

?>

没有对输入进行检查。这意味着,一个恶意的用户可以短路通过输入测试' or 1=1对登录名和密码,导致XPath美元正在评估如下所示:

//user[login/text()='' or 1=1 and password/text()='' or 1=1]/attribute::id

因为在方括号的表达式的计算结果总是一样true,它是有效的这一相同,匹配身份证件对每一个属性userXML文档中的元素:

/ / /属性:用户ID

其中一种方法可以绕过特定攻击仅仅是引用的变量名是插值的定义$xpath,迫使从Web表单传递到被转换为字符串的值:

$xpath = "//user[login/text()='$login' and password/text()='$password']/attribute::id";

这是同样的策略,经常被推荐用于防止SQL注入攻击。一般来说,你应该防止XPath注入攻击遵循方法相同,为防止SQL注入:

  • 不接受未经检验的数据从应用程序中的用户。

  • 检查所有用户提交的数据类型;拒绝或将是错误的数据类型

  • 测试数据超出范围的值;截形,圆形,或拒绝,超出范围的值。测试字符串非法字符和剔除掉或拒绝输入含有。

  • 不输出明确的错误信息,可能会提供一个线索,可能会影响到系统的未经授权的用户;记录这些文件或数据库中的表,而不是。

正如SQL注入攻击可用于获取有关数据库架构信息,所以可以使用XPath注入遍历XML文件来揭示其结构,如Amit克莱因的讨论Blind XPath注射液(PDF文件,大作业)。

这也是检查输出被发送回客户端的重要。考虑发生在我们使用MySQL所能ExtractValue()功能:

MySQL的&#62;SELECT ExtractValue(-&#62;LOAD_FILE('users.xml'),-&#62;'//user[login/text()="" or 1=1 and password/text()="" or 1=1]/attribute::id'-&#62;) AS id;------------------------------- | ID | ------------------------------- | 00327 13579 02403 42354 28570 | ------------------------------- 1行集(0.01秒)

因为ExtractValue()返回多个匹配为一个空格分隔的字符串,这个注入攻击提供了每一个有效的ID包含在users.xml以用户为一行输出。作为一个额外的保障,你还应该再还给用户测试输出。这里是一个简单的例子:

mysql> SELECT @id = ExtractValue(
    ->     LOAD_FILE('users.xml'),
    ->     '//user[login/text()="" or 1=1 and password/text()="" or 1=1]/attribute::id'
    -> );
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT IF(
    ->     INSTR(@id, ' ') = 0,
    ->     @id,
    ->     'Unable to retrieve user ID')
    -> AS singleID;
+----------------------------+
| singleID                   |
+----------------------------+
| Unable to retrieve user ID |
+----------------------------+
1 row in set (0.00 sec)

在一般情况下,返回到用户的数据安全是相同的接受用户输入的指南。这些可以概括为:

  • 总是测试输出数据类型和允许值。

  • 决不允许未经授权的用户查看错误消息可能提供有关应用程序,可以利用它的信息。

12点函数和操作符

表12.16位函数和操作符

姓名描述
BIT_COUNT()回位的设置数量
&按位与
~Bitwise反演
|按位或
^按位异或
<<左移
>>右移位

位函数和运算符组成BIT_COUNT()BIT_AND()BIT_OR()BIT_XOR()&|^~<<,和>>。(TheBIT_AND()BIT_OR(),和BIT_XOR()聚合函数描述第12.19.1,“总(集团)功能描述。)到MySQL 8之前,所需的位函数和操作符BIGINT(64位整数)参数和返回BIGINT值,所以他们有一个64位的最大范围。非—BIGINT参数转换为BIGINT在此之前执行的操作和截断可能发生。

在MySQL 8中,点函数和运算符允许二进制字符串类型的参数(BINARYVARBINARY,和BLOB类型)和返回值类型一样,使他们能够采取的参数和返回值大于64位的产生。非二进制字符串参数转换为BIGINT和处理等,如前

这种行为变化的一个含义是,对二进制字符串参数点的操作可能会产生在MySQL 8比5.7不同的结果。有关如何在MySQL 5.7中潜在的不相容的MySQL 5.7和8的准备,看位函数和操作符,在MySQL 5.7参考手册

位操作MySQL 8之前

位操作之前,MySQL 8只处理无符号64位整数的参数和结果值(即符号BIGINT值)。对其他类型的参数转换BIGINT是必要的。实例:

  • 这一声明是数值型的字面值,视为无符号64位整数:

    mysql> SELECT 127 | 128, 128 << 2, BIT_COUNT(15);
    +-----------+----------+---------------+
    | 127 | 128 | 128 << 2 | BIT_COUNT(15) |
    +-----------+----------+---------------+
    |       255 |      512 |             4 |
    +-----------+----------+---------------+
    
  • 这个语句执行数转换的字符串参数('127'一百二十七,等等)进行同样的操作的第一条语句产生相同的结果:

    mysql> SELECT '127' | '128', '128' << 2, BIT_COUNT('15');
    +---------------+------------+-----------------+
    | '127' | '128' | '128' << 2 | BIT_COUNT('15') |
    +---------------+------------+-----------------+
    |           255 |        512 |               4 |
    +---------------+------------+-----------------+
    
  • 这条语句使用进制文字的位操作参数。MySQL默认情况下将十六进制常量作为二进制字符串,但在数字环境中评估他们的数字(见第9.1.4,“Hexadecimal Literals”)。MySQL 5.0之前,数字内容包括位操作。实例:

    mysql> SELECT X'7F' | X'80', X'80' << 2, BIT_COUNT(X'0F');
    +---------------+------------+------------------+
    | X'7F' | X'80' | X'80' << 2 | BIT_COUNT(X'0F') |
    +---------------+------------+------------------+
    |           255 |        512 |                4 |
    +---------------+------------+------------------+
    

    位操作的位值文字处理类似进制文字(即数字)。

在MySQL 8位操作

MySQL 8扩展位操作处理的二进制字符串参数直接(无需转换),产生的二进制字符串的结果。(这不是整数或二进制字符串参数仍然转换为整数,如前。)这个扩展提高位操作在以下方面:

  • 位操作成为可能,对价值超过64位。

  • 它是更容易执行位操作价值,更自然地表示为二进制字符串和整数比。

例如,考虑UUID值和IPv6地址,其中有人类可读的文本格式,这样:

UUID: 6ccd780c-baba-1026-9564-5b8c656024db
IPv6: fe80::219:d1ff:fe91:1a72

它是对那些格式的文本字符串操作繁琐。另一种方法是将其转换为固定长度的二进制字符串而不符。UUID_TO_BIN()INET6_ATON()每产生一个值的数据类型BINARY(16),一个二进制字符串16字节(128位)长。下面的语句说明(hex()用于生产可显示的值):

mysql> SELECT HEX(UUID_TO_BIN('6ccd780c-baba-1026-9564-5b8c656024db'));
+----------------------------------------------------------+
| HEX(UUID_TO_BIN('6ccd780c-baba-1026-9564-5b8c656024db')) |
+----------------------------------------------------------+
| 6CCD780CBABA102695645B8C656024DB                         |
+----------------------------------------------------------+
mysql> SELECT HEX(INET6_ATON('fe80::219:d1ff:fe91:1a72'));
+---------------------------------------------+
| HEX(INET6_ATON('fe80::219:d1ff:fe91:1a72')) |
+---------------------------------------------+
| FE800000000000000219D1FFFE911A72            |
+---------------------------------------------+

这些二进制值易于操控的位操作执行的行动,如从UUID值提取时间戳,或提取网络和IPv6地址的主机部分。(例如,见这个讨论。以后)

参数计数作为二进制字符串包含的列值,常规参数、局部变量和用户定义的变量有一个二进制字符串类型:BINARYVARBINARY,或在一个BLOB类型

什么是进制文字,点文字?记得那是二进制字符串默认情况下MySQL,但数字在数字环境。他们是如何处理MySQL 8位操作?是MySQL继续评估他们在数字环境中,为的是MySQL 8之前做了什么?还是做点作业评价为二进制字符串,现在可以处理的二进制字符串本机无需转换?

答:它已被指定使用进制文字或点文字的意图,他们表示数字的位操作的参数,所以MySQL继续评估在数字背景下的所有点的论点是十六进制或点文字的位操作,向后兼容性。如果你需要评估为二进制字符串,而这是很容易做到的:使用_binary至少有一个文字介绍

  • 这些位操作评价进制文字和文字为整数点:

    mysql> SELECT X'40' | X'01', b'11110001' & b'01001111';
    +---------------+---------------------------+
    | X'40' | X'01' | b'11110001' & b'01001111' |
    +---------------+---------------------------+
    |            65 |                        65 |
    +---------------+---------------------------+
    
  • 这些位操作评价进制文字和文字作为点的二进制字符串,由于_binary介绍人:

    MySQL的&#62;SELECT _binary X'40' | X'01', b'11110001' & _binary b'01001111';----------------------- ----------------------------------- | _binary x 40的| x 01的| B &#39;11110001”和_binary B &#39;01001111”| ----------------------- ----------------------------------- |一|一| ----------------------- -----------------------------------

虽然比特操作语句产生的结果与一个数值为65,第二语句运行在二进制字符串上下文,其中65是ASCIIA

在数值评价情境,十六进制文字和文字的争论点有一个最大允许值为64位,做的结果。相比之下,在二进制字符串求值上下文,允许争论(结果)可以超过64位:

mysql> SELECT _binary X'4040404040404040' | X'0102030405060708';
+---------------------------------------------------+
| _binary X'4040404040404040' | X'0102030405060708' |
+---------------------------------------------------+
| ABCDEFGH                                          |
+---------------------------------------------------+

这是指一个十六进制文本或位文字一点操作造成的二进制字符串评价的几种方法:

_binary literal
BINARY literal
CAST(literal AS BINARY)

另一种产生进制文本或二进制字符串点文字评价是分配给用户定义的变量,这使得有一个二进制字符串型变量:

mysql> SET @v1 = X'40', @v2 = X'01', @v3 = b'11110001', @v4 = b'01001111';
mysql> SELECT @v1 | @v2, @v3 & @v4;
+-----------+-----------+
| @v1 | @v2 | @v3 & @v4 |
+-----------+-----------+
| A         | A         |
+-----------+-----------+

在二进制字符串的上下文,位运算的参数必须具有相同的长度或ER_INVALID_BITWISE_OPERANDS_SIZE错误发生:

MySQL的&#62;SELECT _binary X'40' | X'0001';错误3513(hy000):bitwiseoperators二进制操作数的长度必须相等

为了满足长度相等的要求,垫短前导零的数字值,如果再值开始与领先的零位和较短的结果值是可以接受的,带他们:

mysql> SELECT _binary X'0040' | X'0001';
+---------------------------+
| _binary X'0040' | X'0001' |
+---------------------------+
|  A                        |
+---------------------------+
mysql> SELECT _binary X'40' | X'01';
+-----------------------+
| _binary X'40' | X'01' |
+-----------------------+
| A                     |
+-----------------------+

填充或剥离也可以使用等功能的实现LPAD()RPAD()SUBSTR(),或CAST()。在这种情况下,表达的观点不再是所有的文字_binary成为不必要。实例:

mysql> SELECT LPAD(X'40', 2, X'00') | X'0001';
+---------------------------------+
| LPAD(X'40', 2, X'00') | X'0001' |
+---------------------------------+
|  A                              |
+---------------------------------+
mysql> SELECT X'40' | SUBSTR(X'0001', 2, 1);
+-------------------------------+
| X'40' | SUBSTR(X'0001', 2, 1) |
+-------------------------------+
| A                             |
+-------------------------------+

二进制位操作实例

下面的例子说明了如何使用位操作来提取一个UUID值部分,在这种情况下,时间戳和IEEE 802节点数。这种技术需要对各萃取部分掩码。

将文本转换成UUID到对应的16字节的二进制值,它可以在二进制字符串的上下文中使用位运算操作:

mysql> SET @uuid = UUID_TO_BIN('6ccd780c-baba-1026-9564-5b8c656024db');
mysql> SELECT HEX(@uuid);
+----------------------------------+
| HEX(@uuid)                       |
+----------------------------------+
| 6CCD780CBABA102695645B8C656024DB |
+----------------------------------+

构建时间戳和价值节点数部分的掩码。时间戳包括第一部分(64位,三位0到63)和节点数的最后一部分(48位,80位127):

mysql> SET @ts_mask = CAST(X'FFFFFFFFFFFFFFFF' AS BINARY(16));
mysql> SET @node_mask = CAST(X'FFFFFFFFFFFF' AS BINARY(16)) >> 80;
mysql> SELECT HEX(@ts_mask);
+----------------------------------+
| HEX(@ts_mask)                    |
+----------------------------------+
| FFFFFFFFFFFFFFFF0000000000000000 |
+----------------------------------+
mysql> SELECT HEX(@node_mask);
+----------------------------------+
| HEX(@node_mask)                  |
+----------------------------------+
| 00000000000000000000FFFFFFFFFFFF |
+----------------------------------+

这个CAST(... AS BINARY(16))功能是用在这里因为口罩必须长度相同的UUID值和它们的应用。同样的结果,可以使用其他功能垫面具所需长度产生:

SET @ts_mask= RPAD(X'FFFFFFFFFFFFFFFF' , 16, X'00');SET @node_mask = LPAD(X'FFFFFFFFFFFF', 16, X'00') ;

使用面具来提取时间和节点数的部分:

mysql> SELECT HEX(@uuid & @ts_mask) AS 'timestamp part';
+----------------------------------+
| timestamp part                   |
+----------------------------------+
| 6CCD780CBABA10260000000000000000 |
+----------------------------------+
mysql> SELECT HEX(@uuid & @node_mask) AS 'node part';
+----------------------------------+
| node part                        |
+----------------------------------+
| 000000000000000000005B8C656024DB |
+----------------------------------+

上面的例子中使用这些位操作:右移位(>>)和按位与(&

笔记

UUID_TO_BIN()作为一个标志,使生成的二进制UUID值一些比特重排。如果你使用这个标志,修改相应的提取的面具。

The next example uses bit operations to extract the network and host parts of an IPv6 address. Suppose that the network part has a length of 80 bits. Then the host part has a length of 128 ? 80 = 48 bits. To extract the network and host parts of the address, convert it to a binary string, then use bit operations in binary-string context.

将文本转换成IPv6地址对应的二进制字符串:

mysql> SET @ip = INET6_ATON('fe80::219:d1ff:fe91:1a72');

位定义网络长度:

mysql> SET @net_len = 80;

构建网络和主机的面具把所有的地址左或右。要做到这一点,开始与地址::,这是所有零点的简写,你可以看到,把它转换成一个二进制字符串这样:

MySQL的&#62;SELECT HEX(INET6_ATON('::')) AS 'all zeros';---------------------------------- |全零| ---------------------------------- | 00000000000000000000000000000000 | ----------------------------------

To produce the互补y value(all ones),use the~倒位算子:

MySQL的&#62;SELECT HEX(~INET6_ATON('::')) AS 'all ones';一| ---------------------------------- |所有---------------------------------- | ffffffffffffffffffffffffffffffff | ----------------------------------

所有的价值向左或向右移位产生的网络和主机的面具:

mysql> SET @net_mask = ~INET6_ATON('::') << (128 - @net_len);
mysql> SET @host_mask = ~INET6_ATON('::') >> @net_len;

显示的面具来验证它们覆盖的地址正确的部分:

mysql> SELECT INET6_NTOA(@net_mask) AS 'network mask';
+----------------------------+
| network mask               |
+----------------------------+
| ffff:ffff:ffff:ffff:ffff:: |
+----------------------------+
mysql> SELECT INET6_NTOA(@host_mask) AS 'host mask';
+------------------------+
| host mask              |
+------------------------+
| ::ffff:255.255.255.255 |
+------------------------+

提取和显示网络地址的主机部分和:

mysql> SET @net_part = @ip & @net_mask;
mysql> SET @host_part = @ip & @host_mask;
mysql> SELECT INET6_NTOA(@net_part) AS 'network part';
+-----------------+
| network part    |
+-----------------+
| fe80::219:0:0:0 |
+-----------------+
mysql> SELECT INET6_NTOA(@host_part) AS 'host part';
+------------------+
| host part        |
+------------------+
| ::d1ff:fe91:1a72 |
+------------------+

上面的例子中使用这些位操作:补体(~),左移(<<),和bitwise(&

其余的讨论提供了论证每一组运算处理的细节,关于文字的值在运算处理的更多信息,以及MySQL 8.0以上MySQL版本之间潜在的不兼容。

Bitwise与,或,异或操作

&|,和^位操作,结果类型取决于参数的评估为二进制字符串或数字:

  • 二进制字符串评价时发生的争论有一个二进制字符串类型,至少其中一个不是进制文字,点文字,或NULL字面意义的.数值评价发生否则,参数转换为无符号整数作为必要的位。

  • 二进制字符串评价产生一个相同长度的二进制字符串作为参数。如果参数有长度不等,一ER_INVALID_BITWISE_OPERANDS_SIZE错误发生。数值评价产生一个无符号位整数。

数值评价实例:

mysql> SELECT 64 | 1, X'40' | X'01';
+--------+---------------+
| 64 | 1 | X'40' | X'01' |
+--------+---------------+
|     65 |            65 |
+--------+---------------+

二进制字符串评价实例:

mysql> SELECT _binary X'40' | X'01';
+-----------------------+
| _binary X'40' | X'01' |
+-----------------------+
| A                     |
+-----------------------+
mysql> SET @var1 = X'40', @var2 = X'01';
mysql> SELECT @var1 | @var2;
+---------------+
| @var1 | @var2 |
+---------------+
| A             |
+---------------+

Bitwise补充和移位操作

~<<,和>>位操作,结果类型取决于钻头参数是评价为一个二进制字符串或数字:

  • 二进制字符串评价时发生点的论点有一个二进制字符串类型,而不是一个十六进制文字,点文字,或NULL字面意义的.数值评价发生否则,参数转换为无符号64位整数的必要。

  • 二进制字符串评价产生一个相同长度的二进制字符串作为参数的点。数值评价产生一个64位无符号整数。

移位操作,位偏移值的最后都失去了警告,无论参数类型。特别是,如果移位次数大于或等于钻头参数的比特数,结果中的所有位都是0。

数值评价实例:

mysql> SELECT ~0, 64 << 2, X'40' << 2;
+----------------------+---------+------------+
| ~0                   | 64 << 2 | X'40' << 2 |
+----------------------+---------+------------+
| 18446744073709551615 |     256 |        256 |
+----------------------+---------+------------+

二进制字符串评价实例:

mysql> SELECT HEX(_binary X'1111000022220000' >> 16);
+----------------------------------------+
| HEX(_binary X'1111000022220000' >> 16) |
+----------------------------------------+
| 0000111100002222                       |
+----------------------------------------+
mysql> SELECT HEX(_binary X'1111000022220000' << 16);
+----------------------------------------+
| HEX(_binary X'1111000022220000' << 16) |
+----------------------------------------+
| 0000222200000000                       |
+----------------------------------------+
mysql> SET @var1 = X'F0F0F0F0';
mysql> SELECT HEX(~@var1);
+-------------+
| HEX(~@var1) |
+-------------+
| 0F0F0F0F    |
+-------------+

_ count()位操作

这个BIT_COUNT()函数总是返回一个64位无符号整数,或无效的如果参数是NULL

MySQL的&#62;SELECT BIT_COUNT(127);它|位_ count(127)| ---------------- | MySQL &#62; 7 | ----------------SELECT BIT_COUNT(b'010101'), BIT_COUNT(_binary b'010101');| ---------------------- _ count()位(位010101)| _计数(_ 010101二进制(3)3)| | ---------------------- | | ---------------------- -------------------

位和位_ _()或(),()和_位异或操作

对于BIT_AND()BIT_OR(),和BIT_XOR()位功能,结果类型取决于函数的参数值进行评估,为二进制字符串或数字:

  • 二进制字符串评价时发生的参数值都有一个二进制字符串类型和参数不是一个进制文字,点文字,或NULL字面意义的.数值评价发生否则,随着参数值转换为无符号整数作为必要的位。

  • 二进制字符串评价产生一个相同长度的二进制字符串作为参数值。如果参数值都有一个长度不等,ER_INVALID_BITWISE_OPERANDS_SIZE错误发生。如果参数的大小超过511字节,一个ER_INVALID_BITWISE_AGGREGATE_OPERANDS_SIZE错误发生。数值评价产生一个无符号位整数。

NULL值不影响结果,除非所有的值无效的。在这种情况下,结果是一个具有相同的长度作为参数值的长度,价值中立(所有位1BIT_AND()0,所有的位BIT_OR(),和BIT_XOR()

例子:

mysql> CREATE TABLE t (group_id INT, a VARBINARY(6));
mysql> INSERT INTO t VALUES (1, NULL);
mysql> INSERT INTO t VALUES (1, NULL);
mysql> INSERT INTO t VALUES (2, NULL);
mysql> INSERT INTO t VALUES (2, X'1234');
mysql> INSERT INTO t VALUES (2, X'FF34');
mysql> SELECT HEX(BIT_AND(a)), HEX(BIT_OR(a)), HEX(BIT_XOR(a))
       FROM t GROUP BY group_id;
+-----------------+----------------+-----------------+
| HEX(BIT_AND(a)) | HEX(BIT_OR(a)) | HEX(BIT_XOR(a)) |
+-----------------+----------------+-----------------+
| FFFFFFFFFFFF    | 000000000000   | 000000000000    |
| 1234            | FF34           | ED00            |
+-----------------+----------------+-----------------+

特殊处理进制文字,Bit Literals,NULLLiterals

为了向后兼容,MySQL 8位运算在数字背景下对所有点的论点是进制文字,点文字,或NULL文字。即,在二进制字符串位争论点操作不如果所有位参数缦进制文字,点文字使用二进制字符串的评价,或无效的文字。(这不适用于这样的文字,如果他们用_binary介绍人,BINARY运营商或其他方式明确指定它们为二进制字符串。)

文字处理刚才所描述的是一样的MySQL 8之前。实例:

  • 这些位操作评价文字数字的背景和产生BIGINT结果

    b'0001' | b'0010'X'0008' << 8
  • 这些位操作评估NULL在数字环境中产生bigint结果,有一个NULL价值:

    NULL & NULLNULL >> 4

在MySQL 5.0,你能够使这些操作评价参数的二进制字符串上下文指示明确,至少有一个参数是一个字符串:

_binary b'0001' | b'0010'
_binary X'0008' << 8
BINARY NULL & NULL
BINARY NULL >> 4

在一个表达式的结果NULL,就像没有二元的运营商,但结果的数据类型是一个二进制字符串类型而不是一个整数型。

MySQL 5.7位操作不兼容

由于位运算可以处理的二进制字符串参数来在MySQL 8中,一些词语产生在MySQL 8比5.7不同的结果。五问题表达类型需要注意的是:

nonliteral_binary { & | ^ } binary
binary  { & | ^ } nonliteral_binary
nonliteral_binary { << >> } anything
~ nonliteral_binary
AGGR_BIT_FUNC(nonliteral_binary)

这些表达式返回BIGINT在MySQL 5,0的二进制字符串。

解释的符号:

  • { op1 op2 ... }:运营商应用于给定的表达式类型列表。

  • binary:任何一种二进制字符串参数,包括进制文字,点文字,或无效的字面意义的.

  • nonliteral_binary一种说法是:二进制字符串值比其他进制文字,点文字,或无效的字面意义的.

  • AGGR_BIT_FUNC:一个聚集函数,以位值参数:BIT_AND()BIT_OR()BIT_XOR()

有关如何在MySQL 5.7中潜在的不相容的MySQL 5.7和8的准备,看位函数和操作符,在MySQL 5.7参考手册

下面的列表描述了可用的位函数和操作符:

  • |

    Bitwise或

    结果类型取决于参数的评估为二进制字符串或数字:

    • 二进制字符串评价时发生的争论有一个二进制字符串类型,至少其中一个不是进制文字,点文字,或NULL字面意义的.数值评价发生否则,参数转换为无符号64位整数的必要。

    • 二进制字符串评价产生一个相同长度的二进制字符串作为参数。如果参数有长度不等,一ER_INVALID_BITWISE_OPERANDS_SIZE错误发生。数值评价产生一个64位无符号整数。

    有关更多信息,参见本节中的介绍性的讨论。

    mysql> SELECT 29 | 15;
            -> 31
    mysql> SELECT _binary X'40404040' | X'01020304';
            -> 'ABCD'
    
  • &

    Bitwise和

    结果类型取决于参数的评估为二进制字符串或数字:

    • 二进制字符串评价时发生的争论有一个二进制字符串类型,至少其中一个不是进制文字,点文字,或NULL字面意义的.数值评价发生否则,参数转换为无符号64位整数的必要。

    • 二进制字符串评价产生一个相同长度的二进制字符串作为参数。如果参数有长度不等,一ER_INVALID_BITWISE_OPERANDS_SIZE错误发生。数值评价产生一个64位无符号整数。

    有关更多信息,参见本节中的介绍性的讨论。

    mysql> SELECT 29 & 15;
            -> 13
    mysql> SELECT HEX(_binary X'FF' & b'11110000');
            -> 'F0'
    
  • ^

    按位异或

    结果类型取决于参数的评估为二进制字符串或数字:

    • 二进制字符串评价时发生的争论有一个二进制字符串类型,至少其中一个不是进制文字,点文字,或NULL字面意义的.数值评价发生否则,参数转换为无符号64位整数的必要。

    • 二进制字符串评价产生一个相同长度的二进制字符串作为参数。如果参数有长度不等,一ER_INVALID_BITWISE_OPERANDS_SIZE错误发生。数值评价产生一个64位无符号整数。

    有关更多信息,参见本节中的介绍性的讨论。

    mysql> SELECT 1 ^ 1;
            -> 0
    mysql> SELECT 1 ^ 0;
            -> 1
    mysql> SELECT 11 ^ 3;
            -> 8
    mysql> SELECT HEX(_binary X'FEDC' ^ X'1111');
            -> 'EFCD'
    
  • <<

    位移曲线(aBIGINT)数字或二进制字符串的左边。

    结果类型取决于钻头参数是评价为一个二进制字符串或数字:

    • 二进制字符串评价时发生点的论点有一个二进制字符串类型,而不是一个十六进制文字,点文字,或NULL字面意义的.数值评价发生否则,参数转换为无符号64位整数的必要。

    • 二进制字符串评价产生一个相同长度的二进制字符串作为参数的点。数值评价产生一个64位无符号整数。

    位偏移值的最后都失去了警告,无论参数类型。特别是,如果移位次数大于或等于钻头参数的比特数,结果中的所有位都是0。

    有关更多信息,参见本节中的介绍性的讨论。

    mysql> SELECT 1 << 2;
            -> 4
    mysql> SELECT HEX(_binary X'00FF00FF00FF' << 8);
            -> 'FF00FF00FF00'
    
  • >>

    位移曲线(aBIGINT)数字或二进制字符串的权利。

    结果类型取决于钻头参数是评价为一个二进制字符串或数字:

    • 二进制字符串评价时发生点的论点有一个二进制字符串类型,而不是一个十六进制文字,点文字,或NULL字面意义的.数值评价发生否则,参数转换为无符号64位整数的必要。

    • 二进制字符串评价产生一个相同长度的二进制字符串作为参数的点。数值评价产生一个64位无符号整数。

    位偏移值的最后都失去了警告,无论参数类型。特别是,如果移位次数大于或等于钻头参数的比特数,结果中的所有位都是0。

    有关更多信息,参见本节中的介绍性的讨论。

    mysql> SELECT 4 >> 2;
            -> 1
    mysql> SELECT HEX(_binary X'00FF00FF00FF' >> 8);
            -> '0000FF00FF00'
    
  • ~

    颠倒所有位

    结果类型取决于钻头参数是评价为一个二进制字符串或数字:

    • 二进制字符串评价时发生点的论点有一个二进制字符串类型,而不是一个十六进制文字,点文字,或NULL字面意义的.数值评价发生否则,参数转换为无符号64位整数的必要。

    • 二进制字符串评价产生一个相同长度的二进制字符串作为参数的点。数值评价产生一个64位无符号整数。

    有关更多信息,参见本节中的介绍性的讨论。

    mysql> SELECT 5 & ~1;
            -> 4
    mysql> SELECT HEX(~X'0000FFFF1111EEEE');
            -> 'FFFF0000EEEE1111'
    
  • BIT_COUNT(N)

    返回位设置在参数的数量N作为一个64位无符号整数,或无效的如果参数是NULL

    MySQL的&#62;SELECT BIT_COUNT(64), BIT_COUNT(BINARY 64);-> 1, 7mysql>SELECT BIT_COUNT('64'), BIT_COUNT(_binary '64');-> 1, 7mysql>SELECT BIT_COUNT(X'40'), BIT_COUNT(_binary X'40');&#62; 1, 1

12.13加密和压缩功能

表12.17加密功能

姓名描述
AES_DECRYPT()利用AES解密
AES_ENCRYPT()使用AES加密
ASYMMETRIC_DECRYPT()使用私人或公共密钥解密密文
ASYMMETRIC_DERIVE()得到对称密钥的非对称密钥
ASYMMETRIC_ENCRYPT()使用私人或公共密钥加密明文
ASYMMETRIC_SIGN()从消化生成签名
ASYMMETRIC_VERIFY()验证签名匹配消化
COMPRESS()作为一个二进制字符串返回结果
CREATE_ASYMMETRIC_PRIV_KEY()创建私钥
CREATE_ASYMMETRIC_PUB_KEY()创建公钥
CREATE_DH_PARAMETERS()生成DH秘密共享
CREATE_DIGEST()从字符串生成文摘
DECODE()解码字符串加密使用的encode()
DES_DECRYPT()解密字符串
DES_ENCRYPT()加密字符串
ENCODE()编码的字符串
ENCRYPT()加密字符串
MD5()计算MD5 Checksum
PASSWORD()计算并返回一个密码字符串
RANDOM_BYTES()返回一个字节随机向量
SHA1()sha()计算SHA-1校验和160位
SHA2()计算一个SHA-2校验
STATEMENT_DIGEST()计算语句消化的哈希值
STATEMENT_DIGEST_TEXT()计算标准化报表摘要
UNCOMPRESS()一个字符串的压缩解压缩
UNCOMPRESSED_LENGTH()压缩前返回一个字符串的长度
VALIDATE_PASSWORD_STRENGTH()确定强度的密码

许多加密函数返回字符串的结果可能包含任意字节值。如果你想存储这些结果,与使用列VARBINARYBLOB二进制字符串数据类型。这将避免潜在的问题与空格去除或字符集转换,将改变的数据值,可能如果你使用非二进制字符串数据类型发生(CHARVARCHARTEXT

一些加密函数返回ASCII字符的字符串:MD5()SHA()SHA1()SHA2()STATEMENT_DIGEST()STATEMENT_DIGEST_TEXT()。他们的返回值是一个字符串,字符集和整理由character_set_connectioncollation_connection系统变量。这是一个二进制字符串的字符集是除非二元的

如果一个应用程序商店中的值的函数如MD5()SHA1()返回一个字符串进制数字,更高效的存储和比较,可以通过转换进制表示的二进制用得到UNHEX()在一个存储结果BINARY(N)专栏每对十六进制数字需要二进制形式的一个字节,所以价值N取决于字符串的长度N是16个MD5()一个价值20SHA1()价值。为SHA2()N范围从28到32取决于参数指定的结果所需的比特长度。

用于在存储字符串的大小惩罚CHAR柱是至少两次,最多八次,如果值列中存储的使用UTF8字符集(每个字符使用4个字节)。存储的字符串也会比较慢比较,因为较大的值,需要考虑字符集的排序规则。

假设一个应用商店MD5()在一个字符串值CHAR(32)专栏

创建表md5_tbl(md5_val char(32),…);插入md5_tbl(md5_val,…)值(MD5(&#39;abcdef &#39;),…);

转换进制字符串更紧凑的形式,修改应用程序使用UNHEX()BINARY(16)相反,如下:

创建表md5_tbl(md5_val二进制(16),…);插入md5_tbl(md5_val,…)值(unhex(MD5(&#39;abcdef &#39;)),…);

应用程序必须准备处理一个散列函数产生相同的值的两个不同的输入值的情况非常罕见。进行碰撞检测的一种方法是使哈希列主键。

笔记

对于MD5和SHA-1算法利用已成为众所周知的。你不妨考虑转而使用另一个单向加密功能本节所述,如SHA2()

注意安全

密码或其他敏感值作为加密函数的参数是以明文方式发送到MySQL服务器的SSL连接,除非使用。同时,这样的价值观会出现在任何MySQL日志所写的。为了避免这些类型的曝光,应用程序可以在客户端加密敏感的值,然后将它们发送到服务器。同样的考虑也适用于加密密钥。为了避免暴露这些应用程序可以使用存储过程来加密和解密在服务器端值。

  • AES_DECRYPT(crypt_str,key_str[,init_vector])

    这个函数解密数据正式使用AES(高级加密标准)算法。更多信息,见描述AES_ENCRYPT()

    可选的初始化向量参数,init_vector。语句中使用AES_DECRYPT()是基于语句的复制不安全。

  • AES_ENCRYPT(str,key_str[,init_vector])

    AES_ENCRYPT()AES_DECRYPT()实现加密和解密的官方数据使用AES(高级加密标准)算法,以前被称为RijndaelAES标准允许不同的密钥长度。默认情况下这些功能实现的AES 128位密钥长度。196或256位的密钥长度可以用于描述。密钥长度的性能和安全性之间的权衡。

    AES_ENCRYPT()加密字符串str使用密钥字符串key_str并返回一个二进制字符串加密输出。AES_DECRYPT()解密加密的字符串crypt_str使用密钥字符串key_str并返回原始明文字符串。如果函数的参数是无效的,函数返回NULL

    这个strcrypt_str参数可以是任何长度和填充的是自动添加到str这是一块多采用基于块的算法如AES的要求。该填料由自动删除AES_DECRYPT()功能。长度crypt_str可以用这个公式计算:

    *(trunc(16string_length16)1)

    128位的密钥长度,最安全的方式通过的关键key_str论点是创建一个真正的随机的128位的值作为一个二进制值传递。例如:

    插入tvalues(1,aes_encrypt(中,unhex(&#39;f3229a0b371ed2d9441b830d21a390c3 &#39;)));

    密码可以用来生成AES密钥的哈希密码。例如:

    INSERT INTO t
    VALUES (1,AES_ENCRYPT('text', UNHEX(SHA2('My secret passphrase',512))));
    

    不通过密码或密码直接crypt_str首先,哈希。本文件的以前版本的建议,前一种方法,但它不再推荐使用如下所示的例子更安全。

    如果AES_DECRYPT()检测到无效的数据或不正确的填充,它返回无效的。然而,它是可能的AES_DECRYPT()返回一个非—无效的值(可能是垃圾)如果输入数据或键无效。

    AES_ENCRYPT()AES_DECRYPT()允许的块加密模式控制和接受一个可选的init_vector初始化向量参数:

    • 这个block_encryption_mode系统变量控制加密算法块模式。其默认值是aes-128-ecb,这意味着加密使用的密钥长度为128比特,ECB模式。为说明允许值这一变量,看第5.1.7,服务器“系统变量”

    • 可选init_vector参数提供一个初始化向量块加密模式需要它。

    模式需要可选init_vector的说法,它必须是16字节或更长的时间(超过16个字节被忽略)。如果一个错误发生init_vector失踪

    模式不要求init_vector它被忽略了,一个警告,如果指定的生成。

    随机字符串的字节用于初始化向量可以通过调用RANDOM_BYTES(16)。加密模式,需要一个初始化向量,相同的向量必须用于加密和解密。

    MySQL的&#62;SET block_encryption_mode = 'aes-256-cbc';MySQL的&#62;SET @key_str = SHA2('My secret passphrase',512);MySQL的&#62;SET @init_vector = RANDOM_BYTES(16);MySQL的&#62;SET @crypt_str = AES_ENCRYPT('text',@key_str,@init_vector);MySQL的&#62;SELECT AES_DECRYPT(@crypt_str,@key_str,@init_vector);一个多月以前

    下表列出了每个允许的块加密模式,SSL库支持,以及是否初始化向量参数是必须的。

    块加密模式SSL库,支持模式初始化向量的要求
    欧洲央行OpenSSL,wolfssl
    CBCOpenSSL,wolfssl
    cfb1OpenSSL
    cfb8OpenSSL
    cfb128OpenSSL
    BOpenSSL

    语句中使用AES_ENCRYPT()AES_DECRYPT()是基于语句的复制不安全。

  • COMPRESS(string_to_compress)

    压缩字符串和二进制字符串返回结果。此功能需要MySQL被压缩库如编译zlib。。。。。。。否则,返回值是永远无效的。压缩后的字符串可以被压缩和UNCOMPRESS()

    MySQL的&#62;SELECT LENGTH(COMPRESS(REPEAT('a',1000)));-> 21mysql>SELECT LENGTH(COMPRESS(''));-> 0mysql>SELECT LENGTH(COMPRESS('a'));-> 13mysql>SELECT LENGTH(COMPRESS(REPEAT('a',16)));&#62; 15

    压缩后的字符串内容的存储方式如下:

    • 空字符串存储为空字符串。

    • 非空字符串存储为一个未压缩的字符串长度(低字节在前4字节),其次是压缩后的字符串。如果字符串结束的空间,一个额外的.字符添加到避免与endspace微调问题的结果应该被存储在一个CHARVARCHAR专栏(然而,使用非二进制字符串数据类型,如CHARVARCHAR压缩存储字符串不推荐,因为字符集的转换可能会发生。使用VARBINARYBLOB二进制字符串列代替。)

  • DECODE(crypt_str,pass_str)

    这个功能在MySQL 8.0.3删除。

    考虑使用AES_ENCRYPT()AES_DECRYPT()相反

  • DES_DECRYPT(crypt_str[,key_str])

    这个功能在MySQL 8.0.3删除。

    考虑使用AES_ENCRYPT()AES_DECRYPT()相反

  • DES_ENCRYPT(str[,{key_num|key_str}])

    这个功能在MySQL 8.0.3删除。

    考虑使用AES_ENCRYPT()AES_DECRYPT()相反

  • ENCODE(str,pass_str)

    这个功能在MySQL 8.0.3删除。

    考虑使用AES_ENCRYPT()AES_DECRYPT()相反

  • ENCRYPT(str[,salt])

    这个功能在MySQL 8.0.3删除。单向散列,考虑使用SHA2()相反

  • MD5(str)

    计算字符串的MD5校验和128位。的值作为一个字符串的32进制数字返回,或NULL如果参数是无效的。返回值,例如,作为一个哈希键。看到音符在开始这段关于存储的哈希值的有效。

    返回值是一个字符串的连接字符集。

    如果启用FIPS模式,MD5()退货无效的。看到6.6节,“FIPS支持”

    mysql> SELECT MD5('testing');
            -> 'ae2b1fca515949e5d54fb22b8ed95575'
    

    这是RSA数据安全公司的MD5消息摘要算法。

    看到对于初这段MD5算法的注。

  • PASSWORD(str)

    这个功能在MySQL 8.0.11删除。

  • RANDOM_BYTES(len)

    这个函数返回一个二进制串len使用SSL库的随机数发生器产生的随机字节。允许值len从1到1024的范围内。对于此范围以外的值,RANDOM_BYTES()生成一个警告并返回无效的

    RANDOM_BYTES()可以用于提供初始化向量AES_DECRYPT()AES_ENCRYPT()功能.在这种情况下使用,len必须至少16。较大的值是允许的,但超过16字节被忽略。

    RANDOM_BYTES()生成一个随机值,使其结果具有不确定性。因此,报表,使用这个功能是基于语句的复制不安全。

  • SHA1(str)SHA(str)

    计算字符串的SHA-1 160位校验,在RFC 3174描述(安全哈希算法)。的值作为一个字符串的40进制数字返回,或NULL如果参数是无效的。这个功能的一个可能的用途是作为哈希键。看到音符在开始这段关于存储的哈希值的有效。SHA()是同义词SHA1()

    返回值是一个字符串的连接字符集。

    mysql> SELECT SHA1('abc');
            -> 'a9993e364706816aba3e25717850c26c9cd0d89d'
    

    SHA1()可以被认为是一个密码更安全的等效MD5()。然而,看到对于初这段的MD5和SHA-1算法的注。

  • SHA2(str, hash_length)

    计算哈希函数SHA-2系列(SHA-224,SHA-256,SHA-384和SHA-512)。第一个参数是明文字符串散列。第二个参数表示的结果所需的比特长度,它必须有一个值224, 256, 384,512,或0(相当于256)。如果任一参数NULL或哈希长度不一的允许值,返回值是无效的。否则,函数的结果是一个包含所需的比特数的散列值。看到音符在开始这段关于存储的哈希值的有效。

    返回值是一个字符串的连接字符集。

    mysql> SELECT SHA2('abc', 224);
            -> '23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7'
    

    此功能只有如果MySQL配置了SSL的支持。看到6.4节,“使用加密的连接”

    SHA2()可以考虑加密更安全MD5()SHA1()

  • STATEMENT_DIGEST(statement)

    给定一个SQL语句作为字符串,作为连接字符集字符串返回语句消化的哈希值,或NULL如果参数是无效的。相关STATEMENT_DIGEST_TEXT()函数返回语句消化归一化。有关声明消化信息,看25.9节,“性能架构声明消化和采样”

    的功能,使用MySQL解析器解析语句。如果分析失败,出现错误。错误消息中包含语法错误只有声明为一个字符串。

    这个max_digest_length系统变量决定提供这些函数计算的最大字节数归一化声明摘要。

    MySQL的&#62;SET @stmt = 'SELECT * FROM mytable WHERE cola = 10 AND colb = 20';MySQL的&#62;SELECT STATEMENT_DIGEST(@stmt);------------------------------------------------------------------ | statement_digest(@ STMT)| ------------------------------------------------------------------ | 3bb95eeade896657c4526e74ff2a2862039d0a0fe8a9e7155b5fe492cbd78387 | ------------------------------------------------------------------ MySQL &#62;SELECT STATEMENT_DIGEST_TEXT(@stmt);+----------------------------------------------------------+| STATEMENT_DIGEST_TEXT(@stmt)                             |+----------------------------------------------------------+| SELECT * FROM `mytable` WHERE `cola` = ? AND `colb` = ?  |+----------------------------------------------------------+
  • STATEMENT_DIGEST_TEXT(statement)

    给定一个SQL语句作为字符串,作为连接字符集字符串返回规范语句消化,或NULL如果参数是无效的。额外的讨论和例子,看到相关的描述STATEMENT_DIGEST()功能

  • UNCOMPRESS(string_to_uncompress)

    一个字符串的压缩解压COMPRESS()功能。如果参数不是压缩值,结果是无效的。此功能需要MySQL被压缩库如编译zlib。。。。。。。否则,返回的值总是冰无效的

    mysql> SELECT UNCOMPRESS(COMPRESS('any string'));
            -> 'any string'
    mysql> SELECT UNCOMPRESS('any string');
            -> NULL
    
  • UNCOMPRESSED_LENGTH(compressed_string)

    返回的长度,在压缩已经压缩后的字符串。

    mysql> SELECT UNCOMPRESSED_LENGTH(COMPRESS(REPEAT('a',30)));
            -> 30
    
  • VALIDATE_PASSWORD_STRENGTH(str)

    给出了明文密码参数,这个函数返回一个整数来表示多么强大的密码。返回值的范围从0(弱)100(强)。

    密码的评估VALIDATE_PASSWORD_STRENGTH()是由验证局组件如果不安装组件,函数始终返回0。有关安装validate_password,看到第6.5.3,“密码验证组件”。查看或配置影响密码测试参数,检查或设置由系统变量validate_password。看到第6.5.3.2,“密码验证选项和变量”

    密码是受到越来越严格的测试和返回值反映了测试满意,如下表所示。此外,如果validate_password.check_user_name系统变量是启用密码与用户名,VALIDATE_PASSWORD_STRENGTH()返回0不管其他验证局系统变量的设置

    密码测试返回值
    Length < 4
    Length ≥ 4 and <validate_password.length二十五
    满足政策1(LOW五十
    满足政策2(MEDIUM七十五
    满足政策3(STRONG一百

12.14信息函数

表12.18信息功能

姓名描述
BENCHMARK()重复执行一个表达式
CHARSET()返回的参数特征
COERCIBILITY()返回的字符串参数的整理可压缩性价值
COLLATION()返回的字符串自变量collation of the
CONNECTION_ID()返回连接ID(线程ID)的连接
CURRENT_ROLE()返回当前的积极作用
CURRENT_USER()current_user通过身份验证的用户名和主机名
DATABASE()返回默认(当前)数据库名称
FOUND_ROWS()一个选择的限制条款,将返回的行数没有限制条款
ICU_VERSION()ICU库版本
LAST_INSERT_ID()value of the AutoIncrement列for the last插入
ROLES_GRAPHML()返回表示内存的作用图GraphML文件
ROW_COUNT()更新的行数
SCHEMA()(数据库)的同义词
SESSION_USER()user()的同义词
SYSTEM_USER()user()的同义词
USER()客户端提供的用户名和主机名
VERSION()返回一个字符串,表示MySQL服务器版本

  • BENCHMARK(count,expr)

    这个BENCHMARK()执行函数的表达式expr反复地count时代它可用于时间如何快速的MySQL进程的表达。结果值总是。使用目的是在MySQL客户报告查询的执行时间:

    mysql> SELECT BENCHMARK(1000000,AES_ENCRYPT('hello','goodbye'));
    +---------------------------------------------------+
    | BENCHMARK(1000000,AES_ENCRYPT('hello','goodbye')) |
    +---------------------------------------------------+
    |                                                 0 |
    +---------------------------------------------------+
    1 row in set (4.74 sec)
    

    报告的时间流逝的时间在客户端,不占用CPU的时间在服务器端。明智的做法是执行BENCHMARK()好几次,并就如何重载服务器机器翻译的结果。

    BENCHMARK()用于测量标量表达式的运行时性能,具有显著影响的方式,你使用和解释结果:

    • 只可以使用标量表达式。虽然表达可以查询,它必须返回一个单柱和在一个单一的行。例如,BENCHMARK(10, (SELECT * FROM t))Will fail if the tableT有多个列或多个列

    • 执行SELECT expr陈述N时代不同于执行选择基准(Nexpr在量的方面涉及的开销。两个有非常不同的执行配置文件,你不应该指望他们把同样的时间。前者涉及的语法分析器,优化器,表锁定,和运行评价N次。后者只涉及运行评价N倍,和所有其他的部件只有一次。内存结构已分配的重用,和运行时优化如局部的成果已经对聚合函数缓存可以改变结果。使用BENCHMARK()这样的措施的运行时组件的性能给予更多的重量,成分和去除噪音通过网络,解析器,优化器介绍,等等。

  • CHARSET(str)

    返回字符串的字符集

    mysql> SELECT CHARSET('abc');
            -> 'utf8'
    mysql> SELECT CHARSET(CONVERT('abc' USING latin1));
            -> 'latin1'
    mysql> SELECT CHARSET(USER());
            -> 'utf8'
    
  • COERCIBILITY(str)

    返回字符串的排序规则可压缩性价值。

    mysql> SELECT COERCIBILITY('abc' COLLATE utf8_swedish_ci);
            -> 0
    mysql> SELECT COERCIBILITY(USER());
            -> 3
    mysql> SELECT COERCIBILITY('abc');
            -> 4
    mysql> SELECT COERCIBILITY(1000);
            -> 5
    

    返回值如下表所示的意义。较低的值具有较高的优先级。

    可压缩性意义例子
    0显式整理价值COLLATE条款
    1无排序规则具有不同排序规则的字符串拼接
    2隐式排序列值,存储程序的参数或局部变量
    3系统常数USER()返回值
    4强制转换字符串
    5数字数字或时间值
    5可忽略的NULL或表达来自无效的

    有关更多信息,参见第10.8.4,“整理可压缩性表达”

  • COLLATION(str)

    归来的collation of the string参数。

    mysql> SELECT COLLATION('abc');
            -> 'utf8_general_ci'
    mysql> SELECT COLLATION(_utf8mb4'abc');
            -> 'utf8mb4_0900_ai_ci'
    mysql> SELECT COLLATION(_latin1'abc');
            -> 'latin1_swedish_ci'
    
  • CONNECTION_ID()

    返回连接ID(线程ID)的连接。每个连接都有一个ID,在设置当前连接的客户端是独一无二的。

    返回的值CONNECTION_ID()是价值相同的类型显示在身份证件列的INFORMATION_SCHEMA.PROCESSLIST表的身份证件SHOW PROCESSLIST输出,和processlist_id的性能架构列threads

    MySQL的&#62;SELECT CONNECTION_ID();&#62; 23786
  • CURRENT_ROLE()

    返回一个utf8包含当前会话的当前活跃角色的字符串,用逗号隔开,或如果没有。价值反映的设置sql_quote_show_create系统变量

    假设一个帐户授予的角色如下:

    GRANT 'r1', 'r2' TO 'u1'@'localhost';
    SET DEFAULT ROLE ALL TO 'u1'@'localhost';
    

    在会议中u1,初始CURRENT_ROLE()值名称帐户的默认角色。使用SET ROLE这样的变化:

    MySQL的&#62;SELECT CURRENT_ROLE();------------------- | current_role() | ------------------- | ` R1 ` @ ` % `,` R2 ` @ ` % ` | ------------------- MySQL &#62;SET ROLE 'r1'; SELECT CURRENT_ROLE();---------------- | current_role() | ---------------- | ` R1 ` @ ` % ` | ----------------
  • CURRENT_USERCURRENT_USER()

    针对mysql帐户,用于当前的客户端验证服务器返回用户名和主机名的组合。这决定了你的访问权限的帐户。返回值是一个字符串utf8字符集

    价值CURRENT_USER()可以从不同的价值USER()

    MySQL的&#62;SELECT USER();-> 'davida@localhost'mysql>SELECT * FROM mysql.user;错误1044:拒绝访问用户“&#39;@&#39;本地主机&#39;数据库&#39; mysql&#39;mysql &#62;SELECT CURRENT_USER();→“localhost是

    这个例子说明,尽管客户指定一个用户名davida(的值表示USER()功能),服务器认证客户端使用匿名用户帐户(由空用户名部分看到的CURRENT_USER()值)。这可能发生的一个方法就是没有考虑上市的批准表达维

    在存储程序或查看,CURRENT_USER()返回谁定义对象的用户帐户(由其定义者除非定义与价值)SQL SECURITY INVOKER特征。在后者的情况下,CURRENT_USER()返回对象的调用

    触发器和事件没有选项来定义SQL SECURITY的特点,所以这些对象,CURRENT_USER()返回谁定义对象的用户帐户。返回调用程序,使用USER()SESSION_USER()

    下面的语句支持使用CURRENT_USER()函数取的名字的地方(和可能,主机)受影响的用户或者;在这种情况下,CURRENT_USER()是扩大和需要:

    关于这种扩展的意义信息CURRENT_USER()有复制,看第17.4.1.8,“current_user()”复制

  • DATABASE()

    返回默认(当前)数据库名称的字符串utf8字符集。如果没有默认数据库,DATABASE()退货无效的。在一个存储程序,默认的数据库,程序与数据库,这不一定是作为数据库,在调用上下文默认相同。

    mysql> SELECT DATABASE();
            -> 'test'
    

    如果没有默认数据库,DATABASE()退货无效的

  • FOUND_ROWS()

    SELECT声明可以包括极限条款限制的服务器向客户端返回的行数。在某些情况下,人们希望知道多少行语句将返回无LIMIT,但没有重新运行语句。获得这一行数,包括sql_calc_found_rows选项中的SELECT语句,然后调用FOUND_ROWS()后来:

    MySQL的&#62;SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name-&#62;WHERE id > 100 LIMIT 10;MySQL的&#62;SELECT FOUND_ROWS();

    第二SELECT返回一个数字显示多少行第一SELECT将返回了没有写的极限条款.

    在失神的SQL_CALC_FOUND_ROWS在最近的成功的选择SELECT声明,FOUND_ROWS()返回的结果集的行数,语句返回。如果语句包括极限条款,FOUND_ROWS()返回的行数的限制。例如,FOUND_ROWS()返回10或60,分别,如果语句包括限10LIMIT 50, 10

    行计数可通过FOUND_ROWS()是短暂的和不可过去的语句之后的语句选择sql_calc_found_rows声明。如果你需要参考值后,保存它:

    mysql> SELECT SQL_CALC_FOUND_ROWS * FROM ... ;
    mysql> SET @rows = FOUND_ROWS();
    

    如果你使用的是SELECT SQL_CALC_FOUND_ROWS,MySQL必须计算多少行的结果集。然而,这比运行查询的不快极限,因为结果集不需要被发送到客户端。

    SQL_CALC_FOUND_ROWSFOUND_ROWS()可以的情况下是有用的当你想限制的行数,查询将返回,但也确定在没有再次运行查询的结果集的行数。一个例子是一个网页脚本提供了分页显示包含的页面显示在搜索结果的其他部分的链接。使用FOUND_ROWS()使您能够确定有多少其他页面的结果,需要休息。

    使用SQL_CALC_FOUND_ROWSFOUND_ROWS()更为复杂的UNION比简单的陈述SELECT陈述,因为极限可能发生在一个地方UNION。它可以应用于个人SELECT语句中UNION,或全球的UNION结果作为一个整体

    的意图SQL_CALC_FOUND_ROWSUNION是,它应该返回的行数,将不退还全球极限。使用条件SQL_CALC_FOUND_ROWSUNION是:

    • 这个SQL_CALC_FOUND_ROWS关键词必须出现在第一SELECTUNION

    • 价值FOUND_ROWS()如果是准确的UNION ALL使用。如果UNION没有全部用于去除重复发生和价值FOUND_ROWS()仅是近似的

    • 如果没有LIMIT是目前在UNIONsql_calc_found_rows被忽视和返回的行数在临时表创建过程UNION

    在这里所描述的情况下,行为FOUND_ROWS()是未定义的(例如,它的价值在SELECT语句的失败与错误)

    重要

    FOUND_ROWS()是不可复制的可靠使用基于语句的复制。这个功能是自动复制使用基于行的复制。

  • ICU_VERSION()

    Unicode的国际组件的版本(ICU)库,用来支持正则表达式的操作(见第12.5.2,“正则表达式”)。此功能主要用于测试用例。

  • LAST_INSERT_ID()LAST_INSERT_ID(expr)

    没有参数,LAST_INSERT_ID()返回一个bigint符号(64位)值代表第一次成功插入一个自动生成的值AUTO_INCREMENT柱由于最近执行的INSERT声明。the value ofLAST_INSERT_ID()保持不变,如果没有行被成功地插入。

    有一个说法,LAST_INSERT_ID()返回一个无符号整数

    例如,插入一行后,产生一个AUTO_INCREMENT值,你可以得到这样的价值:

    MySQL的&#62;SELECT LAST_INSERT_ID();&#62; 195

    当前正在执行的语句不影响价值LAST_INSERT_ID()。假设你生成汽车一个语句的值,然后参考LAST_INSERT_ID()在一个多行INSERT语句将行插入自己的一张桌子汽车柱。幻觉LAST_INSERT_ID()将第二声明保持稳定;其第二后来行的价值不是由早期的行插入的影响。(但是,如果你把参考资料LAST_INSERT_ID()LAST_INSERT_ID(expr),效果是不确定的。)

    如果前面的语句返回一个错误值LAST_INSERT_ID()是不确定的。事务表,如果语句回滚由于错误的价值LAST_INSERT_ID()未定义。手动ROLLBACK,价值LAST_INSERT_ID()没有恢复到之前的交易;它仍然是在点ROLLBACK

    在一个存储程序体(过程或函数)或触发器的值LAST_INSERT_ID()变化同外面执行这些对象身体的陈述。一个存储过程或触发器对价值的影响LAST_INSERT_ID()这是被下面的语句取决于常规的那种:

    • 如果存储过程执行的语句,变化的价值LAST_INSERT_ID(),改变的值是由陈述,遵循程序调用过。

    • 存储函数和触发器改变的价值,价值恢复时的函数或触发器结束,所以下面的语句将不会看到一个改变的价值。

    ID生成,保存在服务器上每个连接的基础。这意味着函数返回的值为一个给定的客户是第一AUTO_INCREMENT最近声明影响所产生的价值汽车专栏当客户端。这个值不能被其他客户受到影响,即使他们产生AUTO_INCREMENT自己的价值。这种行为,确保每个客户都能找回自己的而不用担心其它客户端的活动,而不需要加锁或处理。

    价值LAST_INSERT_ID()如果你不改变设置汽车一排到一个非柱—魔术价值(即价值是不NULL而不是

    重要

    如果插入多行,使用一个单一的INSERT声明,LAST_INSERT_ID()返回所生成的值第一插入的行只有。这是为了使人们有可能复制容易相同INSERT声明和其他的服务器

    例如:

    mysql> USE test;
    
    mysql> CREATE TABLE t (
           id INT AUTO_INCREMENT NOT NULL PRIMARY KEY,
           name VARCHAR(10) NOT NULL
           );
    
    mysql> INSERT INTO t VALUES (NULL, 'Bob');
    
    mysql> SELECT * FROM t;
    +----+------+
    | id | name |
    +----+------+
    |  1 | Bob  |
    +----+------+
    
    mysql> SELECT LAST_INSERT_ID();
    +------------------+
    | LAST_INSERT_ID() |
    +------------------+
    |                1 |
    +------------------+
    
    mysql> INSERT INTO t VALUES
           (NULL, 'Mary'), (NULL, 'Jane'), (NULL, 'Lisa');
    
    mysql> SELECT * FROM t;
    +----+------+
    | id | name |
    +----+------+
    |  1 | Bob  |
    |  2 | Mary |
    |  3 | Jane |
    |  4 | Lisa |
    +----+------+
    
    mysql> SELECT LAST_INSERT_ID();
    +------------------+
    | LAST_INSERT_ID() |
    +------------------+
    |                2 |
    +------------------+
    

    虽然二INSERT表三为插入新行T,ID生成这些排第一2正是这种价值,并返回LAST_INSERT_ID()下列SELECT声明

    如果你使用INSERT IGNORE该行的忽视,LAST_INSERT_ID()仍然从当前值不变(或0如果连接尚未成功执行返回插入),非事务表,的AUTO_INCREMENT递增的计数器不。为InnoDB表的AUTO_INCREMENT如果计数器是递增的innodb_autoinc_lock_mode是集2,如下面的例子演示了:

    MySQL的&#62;USE test;MySQL的&#62;SELECT @@innodb_autoinc_lock_mode;* * E / CN.4 / Sub.2 / AC.5 / 2001 / 1 .CREATE TABLE `t` (`id` INT(11) NOT NULL AUTO_INCREMENT,`val` INT(11) DEFAULT NULL,PRIMARY KEY (`id`),UNIQUE KEY `i1` (`val`)) ENGINE=InnoDB DEFAULT CHARSET=latin1;#插入两rowsmysql &#62;INSERT INTO t (val) VALUES (1),(2);# With auto_increment_offset=1, the inserted rows# result in an AUTO_INCREMENT value of 3mysql>SHOW CREATE TABLE t\G*************************** 1. row ***************************       Table: tCreate Table: CREATE TABLE `t` (  `id` int(11) NOT NULL AUTO_INCREMENT,  `val` int(11) DEFAULT NULL,  PRIMARY KEY (`id`),  UNIQUE KEY `i1` (`val`)) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=latin1# LAST_INSERT_ID() returns the first automatically generated# value that is successfully inserted for the AUTO_INCREMENT columnmysql>SELECT LAST_INSERT_ID();------------------ | last_insert_id() | ------------------ | 1 | ------------------ #尝试插入重复的行失败,但错误是忽视MySQL &#62;INSERT IGNORE INTO t (val) VALUES (1),(2);Query OK, 0 rows affected (0.00 sec)Records: 2  Duplicates: 2  Warnings: 0# With innodb_autoinc_lock_mode=1, the AUTO_INCREMENT counter# is incremented for the ignored rowsmysql>SHOW CREATE TABLE t\G*************************** 1. row ***************************       Table: tCreate Table: CREATE TABLE `t` (  `id` int(11) NOT NULL AUTO_INCREMENT,  `val` int(11) DEFAULT NULL,  PRIMARY KEY (`id`),  UNIQUE KEY `i1` (`val`)) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=latin1# The LAST_INSERT_ID is unchanged because the previous insert was unsuccessfulmysql>SELECT LAST_INSERT_ID();_ ------------------ |负荷_ ID插入(1)| | | ----------------- -----------------

    有关更多信息,参见第15.8.1.5,”auto_increment InnoDB”处理

    如果expr给出一个论点LAST_INSERT_ID(),这个参数的值是由函数返回,记得要返回的下一个值LAST_INSERT_ID()。这可以用来模拟序列:

    1. 创建一个表来保存程序计数器初始化:

      mysql> CREATE TABLE sequence (id INT NOT NULL);
      mysql> INSERT INTO sequence VALUES (0);
      
    2. 使用表来生成序列号这样的:

      mysql> UPDATE sequence SET id=LAST_INSERT_ID(id+1);
      mysql> SELECT LAST_INSERT_ID();
      

      这个UPDATE语句序列计数器和增量导致下一个电话LAST_INSERT_ID()返回更新后的值。这个SELECTretrieves statement that value。themysql_insert_id()C API函数也可以用来获得价值。看到第27.7.7.38,“mysql_insert_id()”

    你可以不调用序列的生成LAST_INSERT_ID(),但使用功能这样的效用是ID值保持在服务器上自动生成的值。这是因为多个客户端可以多用户安全问题UPDATE声明以获得自己的序列值SELECT声明(或mysql_insert_id()),而不会影响或被其他客户自己生成序列值的影响。

    请注意,mysql_insert_id()只有更新后INSERTUPDATE报表,所以你不能使用C API函数来检索值LAST_INSERT_ID(expr)其他SQL语句后执行SELECTSET

  • ROLES_GRAPHML()

    返回一个utf8包含一个代表记忆的作用图GraphML文档字符串。这个ROLE_ADMINSUPER特权必须在看内容<graphml>元素否则,结果显示只有一个空的元素:

    mysql> SELECT ROLES_GRAPHML();
    +---------------------------------------------------+
    | ROLES_GRAPHML()                                   |
    +---------------------------------------------------+
    | <?xml version="1.0" encoding="gb3212"?><graphml /> |
    +---------------------------------------------------+
    
  • ROW_COUNT()

    ROW_COUNT()为返回一个值:

    UPDATE语句所影响的行的值是默认的行数上的变化。如果您指定的client_found_rows国旗mysql_real_connect()当连接到mysqld,受影响的行的值的行数建立是的,相匹配;WHERE条款.

    REPLACE语句所影响的行的值是2,如果新排取代旧的行,因为在这种情况下,有一行被插入后的副本被删除。

    INSERT ... ON DUPLICATE KEY UPDATE语句所影响的行的值,每行1如果行插入新的一行,2如果现有的行被更新,0如果一个现有的行设置为其当前值。如果您指定的client_found_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)
    
    重要

    ROW_COUNT()是不可复制的可靠使用基于语句的复制。这个功能是自动复制使用基于行的复制。

  • SCHEMA()

    这个函数是同义词DATABASE()

  • SESSION_USER()

    SESSION_USER()是同义词USER()

  • SYSTEM_USER()

    SYSTEM_USER()是同义词USER()

  • USER()

    在一个字符串的形式返回当前的MySQL用户名和主机名utf8字符集

    MySQL的&#62;SELECT USER();&#62; @本地主机是-戴维达

    该值表示指定连接到服务器时,用户名和主机从你连接。该值可以是不同的CURRENT_USER()

  • VERSION()

    返回一个字符串,表明MySQL服务器版本。字符串的使用utf8字符集。该值可能有另外的版本号后缀。看到的描述version系统变量第5.1.7,服务器“系统变量”

    这个函数是基于语句的复制不安全。警告如果你使用这个功能的时候登录binlog_format是集声明

    mysql> SELECT VERSION();
            -> '8.0.14-standard'
    

12.15空间分析功能

MySQL提供的功能来对空间数据进行各种操作。这些功能可以分为几大类,根据手术类型他们的表现:

  • 的功能,创建各种形式的几何体(WKT,WKB,内部)

  • 功能转换的几何形状之间的格式

  • 函数访问的定性或定量的几何性质

  • 描述两个图形之间的关系的功能

  • 功能:创建新的形状从现有的

关于空间数据使用MySQL支持的大背景下,看5节,“空间数据类型”

12.15.1空间函数参考

下表列出了每个空间的功能,提供了每一个简短的描述。

表12.19空间功能

姓名描述
GeomCollection()从几何构造几何集合
GeometryCollection()从几何构造几何集合
LineString()构造线由点的值
MBRContains()是否一个几何包含MBR MBR的另一
MBRCoveredBy()是否有一个MBR是被另一个
MBRCovers()是否有一个MBR覆盖另一个
MBRDisjoint()无论两构型MBR是不相交的
MBREquals()无论两构型MBR是平等的
MBRIntersects()两构型MBR是否相交
MBROverlaps()无论两构型MBR重叠
MBRTouches()无论两构型MBR的触摸
MBRWithin()是否一个几何在MBR膜生物反应器的另一个
MultiLineString()Contruct MultiLineString从线值
MultiPoint()构建多点价值
MultiPolygon()从多边形的价值观构建multipolygon
Point()构建点坐标
Polygon()从线的参数构造多边形
ST_Area()返回多边形或multipolygon地区
ST_AsBinary()_ aswkb(ST)从内部几何格式转换为WKB
ST_AsGeoJSON()从几何产生GeoJSON对象
ST_AsText()_ aswkt(ST)从内部几何格式转换为WKT
ST_Buffer()返回在给定的点的几何距离几何
ST_Buffer_Strategy()对于st_buffer()产生战略选择
ST_Centroid()返回的质心作为点
ST_Contains()是一种几何包含另一个
ST_ConvexHull()返回几何凸包
ST_Crosses()你是否一个几何
ST_Difference()两个几何返回点的差集
ST_Dimension()的几何尺寸
ST_Disjoint()是一种几何相交的另一个
ST_Distance()一个几何从另一个距离
ST_Distance_Sphere()地球上的两个几何体之间的最小距离
ST_EndPoint()线的终点
ST_Envelope()返回MBR几何
ST_Equals()是一种几何等于另一个
ST_ExteriorRing()返回多边形的外部环
ST_GeoHash()产生一个Geohash值
ST_GeomCollFromText()_ geometrycollectionfromtext(ST)ST_GeomCollFromTxt()返回几何集合从边门
ST_GeomCollFromWKB()_ geometrycollectionfromwkb(ST)返回几何集合从WKB
ST_GeometryN()返回n几何几何集合
ST_GeometryType()返回几何类型名称
ST_GeomFromGeoJSON()GeoJSON对象生成几何
ST_GeomFromText()_ geometryfromtext(ST)返回几何从边门
ST_GeomFromWKB()_ geometryfromwkb(ST)返回几何从WKB
ST_InteriorRingN()返回多边形n室内环
ST_Intersection()两个几何返回点交集
ST_Intersects()是一种几何相交另一个
ST_IsClosed()无论是封闭的简单几何
ST_IsEmpty()占位符的功能
ST_IsSimple()无论是简单的几何图形
ST_IsValid()一个几何是否是有效的
ST_LatFromGeoHash()返回从Geohash价值纬度
ST_Latitude()返回纬度点
ST_Length()回归线的长度
ST_LineFromText()_ linestringfromtext(ST)构造线从边门
ST_LineFromWKB()_ linestringfromwkb(ST)构造线由WKB
ST_LongFromGeoHash()返回从Geohash值经度
ST_Longitude()返回点的经度
ST_MakeEnvelope()大约两点矩形
ST_MLineFromText()st_multilinestringfromtext()从构建multilinestring WKT
ST_MLineFromWKB()st_multilinestringfromwkb()从构建multilinestring WKB
ST_MPointFromText()_ multipointfromtext(ST)构建多点从边门
ST_MPointFromWKB()_ multipointfromwkb(ST)构建多点从WKB
ST_MPolyFromText()_ multipolygonfromtext(ST)从构建multipolygon WKT
ST_MPolyFromWKB()_ multipolygonfromwkb(ST)从构建multipolygon WKB
ST_NumGeometries()返回集合数几何构型
ST_NumInteriorRing()_ numinteriorrings(ST)返回在多边形的内部环数
ST_NumPoints()返回点的数量,在LineString
ST_Overlaps()是一种几何重叠的另一个
ST_PointFromGeoHash()将Geohash值点价值
ST_PointFromText()从边门结构点
ST_PointFromWKB()从WKB结构点
ST_PointN()返回n点线
ST_PolyFromText()_ polygonfromtext(ST)从WKT构建多边形
ST_PolyFromWKB()_ polygonfromwkb(ST)从WKB构建多边形
ST_Simplify()返回简化几何
ST_SRID()返回几何空间参考系统ID
ST_StartPoint()起点线
ST_SwapXY()返回X / Y参数坐标交换
ST_SymDifference()返回点集的两个几何对称差
ST_Touches()另一个要用whether
ST_Transform()变换坐标几何
ST_Union()两个几何返回点集的并集
ST_Validate()返回验证几何
ST_Within()无论是在另一个几何
ST_X()返回x坐标点
ST_Y()回到Y坐标点

12.15.2参数空间功能处理

空间的价值,或几何结构,描述了在性能第11.5.2.2,“几何课”。下列讨论空间一般的函数参数的处理特性。特定功能或一组功能可能有额外的参数处理的特性,如那些功能描述发生的部分讨论。

空间的功能是有效的几何值定义。

空间参考标识符(SRID)的几何形状确定坐标空间中的几何定义。在MySQL的SRID值与几何值相关联的一个整数。最大可用SRID值是2三十二?1。如果一个更大的值,只使用低32位。

SRID 0表示无限平面直角平面没有单位分配给其轴。为了确保SRID 0行为,使用SRID 0创建几何值。SRID 0是新几何值如果没有指定默认SRID。

几何值的任何空间函数产生的几何参数的SRID继承。

空间的功能,把多个几何参数要求的参数具有相同的SRID值(即,在较低的位值相同)。假设srids,空间功能做什么与他们进行平等的检查后;几何值隐式处理,采用直角坐标系(SRID 0)。如果一个空间函数返回ER_GIS_DIFFERENT_SRIDS,这意味着几何参数并不都具有相同的扩散。你必须修改它们具有相同的扩散。

这个开放地理空间联盟指南的要求,输入多边形已经被关闭,所以未闭合多边形拒绝为无效而不是闭合。

空的几何处理如下:一个空的WKT输入几何集合可以被指定为'GEOMETRYCOLLECTION()'。这也从一个生产空几何集合空间操作产生的输出WKT。

在一个嵌套的几何集合分析,收集被夷为平地,它的基本成分是用于各种GIS操作的计算结果。这提供了额外的灵活性,因为用户不必关心几何数据的唯一性。嵌套的几何集合可以产生嵌套的GIS功能调用而无需显式扁平的第一。

12.15.3函数创建几何值WKT值

这些函数作为参数已知的文本(WKT)表示,任选一个空间参考系统标识符(SRID)。他们返回相应的几何。为说明WKT格式,见著名的文字(WKT)格式

在这部分功能检测参数在直角坐标或地理空间参考系统(SRSS),并返回结果适当的SRS。

ST_GeomFromText()接受任何几何型WKT值作为其第一个参数。其他功能为每个几何式几何价值观建设的特定类型的建筑功能。

等功能ST_MPointFromText()ST_GeomFromText()接受WKT格式表示多点值允许个人点的值是括号包围。例如,下面的函数调用都是有效的:

ST_MPointFromText('MULTIPOINT (1 1, 2 2, 3 3)')
ST_MPointFromText('MULTIPOINT ((1 1), (2 2), (3 3))')

等功能ST_GeomFromText()接受WKT几何集合参数了解OpenGIS“geometrycollection空的标准语法和MySQL'GEOMETRYCOLLECTION()'非标准语法。等功能ST_AsWKT()产生WKT值产生“geometrycollection空标准的语法:

mysql> SET @s1 = ST_GeomFromText('GEOMETRYCOLLECTION()');
mysql> SET @s2 = ST_GeomFromText('GEOMETRYCOLLECTION EMPTY');
mysql> SELECT ST_AsWKT(@s1), ST_AsWKT(@s2);
+--------------------------+--------------------------+
| ST_AsWKT(@s1)            | ST_AsWKT(@s2)            |
+--------------------------+--------------------------+
| GEOMETRYCOLLECTION EMPTY | GEOMETRYCOLLECTION EMPTY |
+--------------------------+--------------------------+

除非另有说明,本节中的函数处理他们的论点如下:

  • 如果任何几何参数NULL或是不合乎语法的几何形状,或如果SRID的说法是无效的,返回值是NULL

  • 默认情况下,地理坐标(纬度、经度)被解释为通过几何参数的空间参考系统指定的顺序。一个可选的options争论可能会覆盖默认轴阶。选项由一个逗号分隔的列表key=value。的onlypermittedkey轴阶,与允许值lat-long长叻srid-defined(默认)

    如果options的说法是无效的,返回值是NULL。如果options参数无效,表明为什么发生错误。

  • 如果一个srID参数指的是一个未定义的空间参考系统(SRS),一个ER_SRS_NOT_FOUND错误发生

  • 地理SRS的几何参数,如果参数有经度和纬度,超出范围,发生了一个错误:

    范围显示度。如果SRS使用另一个单位,范围在其单元采用相应的值。确切的范围稍微偏离由于浮点运算。

这些功能可用于创建从WKT价值几何:

12.15.4函数创建几何值从WKB近似值

这些函数作为参数BLOB包含一个众所周知的二进制(WKB)表示,任选一个空间参考系统标识符(SRID)。他们返回相应的几何。为说明WKB格式,见众所周知的二进制(WKB)格式

在这部分功能检测参数在直角坐标或地理空间参考系统(SRSS),并返回结果适当的SRS。

ST_GeomFromWKB()接受任何几何型WKB近似值作为其第一个参数。其他功能为每个几何式几何价值观建设的特定类型的建筑功能。

MySQL 8之前,这些功能也接受了几何对象的返回功能第12.15.5,MySQL的具体功能:创建几何体的价值”。几何参数不再允许产生一个错误。迁移电话使用几何参数使用WKB争论,遵循这些指导方针:

  • 重写构造如ST_GeomFromWKB(Point(0, 0))作为点(0,0)

  • 重写构造如ST_GeomFromWKB(Point(0, 0), 4326)作为(ST _ srID点(0,0),4326)ST_GeomFromWKB(ST_AsWKB(Point(0, 0)), 4326)

除非另有说明,本节中的函数处理他们的论点如下:

  • 如果WKB或SRID的说法是NULL,返回值是无效的

  • 默认情况下,地理坐标(纬度、经度)被解释为通过几何参数的空间参考系统指定的顺序。一个可选的options争论可能会覆盖默认轴阶。选项由一个逗号分隔的列表key=value。的onlypermittedkey轴阶,与允许值lat-long长叻srid-defined(默认)

    如果options的说法是无效的,返回值是NULL。如果options参数无效,表明为什么发生错误。

  • 如果一个srID参数指的是一个未定义的空间参考系统(SRS),一个ER_SRS_NOT_FOUND错误发生

  • 地理SRS的几何参数,如果参数有经度和纬度,超出范围,发生了一个错误:

    范围显示度。如果SRS使用另一个单位,范围在其单元采用相应的值。确切的范围稍微偏离由于浮点运算。

这些功能可用于创建从WKB价值几何:

12.15.5 MySQL特定的功能,创建几何值

MySQL提供了一套有用的非标准函数来创建几何值。本节中描述的功能是MySQL扩展的OpenGIS规范。

这些功能产生的几何对象从WKB值或几何对象作为参数。如果任何参数不正确或适当的WKB对象类型的几何表示,返回值是NULL

例如,你可以插入几何返回值Point()直接进入专栏

INSERT INTO t1 (pt_col) VALUES(Point(1,2));

12.15.6几何格式转换功能

MySQL支持上市的这部分从内部几何格式WKT或WKB格式转换参数的功能,或用于交换的X和Y坐标的顺序。

也有函数将一个字符串从边门或WKB格式内部几何格式。看到第12.15.3,”功能,创建几何值从边门的价值”,和第12.15.4,”功能,创建几何值从WKB近似值”

等功能ST_GeomFromText()接受WKT几何集合参数了解OpenGIS“geometrycollection空的标准语法和MySQL'GEOMETRYCOLLECTION()'非标准语法。另一种产生一个空的几何集合是通过调用GeometryCollection()不带参数。等功能ST_AsWKT()产生WKT值产生“geometrycollection空标准的语法:

mysql> SET @s1 = ST_GeomFromText('GEOMETRYCOLLECTION()');
mysql> SET @s2 = ST_GeomFromText('GEOMETRYCOLLECTION EMPTY');
mysql> SELECT ST_AsWKT(@s1), ST_AsWKT(@s2);
+--------------------------+--------------------------+
| ST_AsWKT(@s1)            | ST_AsWKT(@s2)            |
+--------------------------+--------------------------+
| GEOMETRYCOLLECTION EMPTY | GEOMETRYCOLLECTION EMPTY |
+--------------------------+--------------------------+
mysql> SELECT ST_AsWKT(GeomCollection());
+----------------------------+
| ST_AsWKT(GeomCollection()) |
+----------------------------+
| GEOMETRYCOLLECTION EMPTY   |
+----------------------------+

除非另有说明,本节中的函数处理他们的论点如下:

  • 如果任一参数为NULL,返回值是无效的

  • 如果任何几何参数不是一个语法形成几何,一ER_GIS_INVALID_DATA错误发生

  • 如果任何几何参数是未定义的空间参考系统,输出轴在他们的顺序出现在几何和ER_WARN_SRS_NOT_FOUND_AXIS_ORDER警告出现

  • 默认情况下,地理坐标(纬度、经度)被解释为通过几何参数的空间参考系统指定的顺序。一个可选的options争论可能会覆盖默认轴阶。选项由一个逗号分隔的列表key=value。的onlypermittedkey轴阶,与允许值lat-long长叻srid-defined(默认)

    如果options的说法是无效的,返回值是NULL。如果options参数无效,表明为什么发生错误。

  • 否则,返回值非冰NULL

这些功能可用于格式转换、坐标转换:

  • ST_AsBinary(g [, options])ST_AsWKB(g [, options])

    将内部的几何形式的WKB表示的值并返回二进制结果。

    函数返回值的地理坐标(纬度、经度)的空间参考系统,适用于几何参数指定的命令。一个可选的options争论可能会覆盖默认轴阶。

    ST_AsBinary()ST_AsWKB()在这章节的介绍处理他们的论点。

    MySQL的&#62;SET @g = ST_LineFromText('LINESTRING(0 5,5 10,10 15)', 4326);MySQL的&#62;SELECT ST_AsText(ST_GeomFromWKB(ST_AsWKB(@g)));----------------------------------------- | _ astext圣(圣_ geomfromwkb(ST _ aswkb(@(g))(5)| ----------------------------------------- | linestring 0.10>5 10)| ----------------------------------------- MySQLSELECT ST_AsText(ST_GeomFromWKB(ST_AsWKB(@g, 'axis-order=long-lat')));+----------------------------------------------------------------+| ST_AsText(ST_GeomFromWKB(ST_AsWKB(@g, 'axis-order=long-lat'))) |+----------------------------------------------------------------+| LINESTRING(0 5,5 10,10 15)                                     |+----------------------------------------------------------------+mysql>SELECT ST_AsText(ST_GeomFromWKB(ST_AsWKB(@g, 'axis-order=lat-long')));+----------------------------------------------------------------+| ST_AsText(ST_GeomFromWKB(ST_AsWKB(@g, 'axis-order=lat-long'))) |+----------------------------------------------------------------+| LINESTRING(5 0,10 5,15 10)                                     |+----------------------------------------------------------------+
  • ST_AsText(g [, options])ST_AsWKT(g [, options])

    将内部的几何形式的WKT表示的值并返回结果字符串。

    函数返回值的地理坐标(纬度、经度)的空间参考系统,适用于几何参数指定的命令。一个可选的options争论可能会覆盖默认轴阶。

    ST_AsText()ST_AsWKT()在这章节的介绍处理他们的论点。

    MySQL的&#62;SET @g = 'LineString(1 1,2 2,3 3)';MySQL的&#62;SELECT ST_AsText(ST_GeomFromText(@g));| --------------------------------(ST ST _ astext _ geomfromtext(@ g)(1)| -------------------------------- | linestring 1.2 2 3)| ------------------------------

    输出MultiPointparentheses值包括在每个点。例如:

    MySQL的&#62;SELECT ST_AsText(ST_GeomFromText(@mp));--------------------------------- | _ astext圣(圣_ geomfromtext(@ MP))| --------------------------------- |多点(1,1)、(2)、(3)| ---------------------------------)
  • ST_SwapXY(g)

    接受一个内部的几何形式的说法,互换的x和y的值在每个坐标对的几何,并返回结果。

    ST_SwapXY()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @g = ST_LineFromText('LINESTRING(0 5,5 10,10 15)');MySQL的&#62;SELECT ST_AsText(@g);| ----------------------------(G ST _ astext @ | | linestring ----------------------------(0)10 15 | ---------------------------- MySQL 5.5)&#62;SELECT ST_AsText(ST_SwapXY(@g));它|圣(圣_ astext _ swapxy(@(G)的)| ----------------------------(5 0、10 | linestring)| ----------------------------

12.15.7几何属性函数

每一个功能,属于本集团采取了一种几何值作为参数并返回一些定量或定性的几何性质。一些功能限制它们的参数类型。这些函数返回NULL如果参数是一个不正确的几何型。例如,在ST_Area()多边形函数返回无效的如果对象类型是不Polygon也没有多面

12.15.7.1一般几何属性函数

本节中列出的功能不限制他们的论点和接受任何类型的几何值。

除非另有说明,本节中的函数处理他们的论点如下:

  • 如果任一参数为NULL,返回值是无效的

  • 如果任何几何参数不是一个语法形成几何,一ER_GIS_INVALID_DATA错误发生

  • 如果任何几何参数有一个srID价值指的是一个未定义的空间参考系统(SRS),一个ER_SRS_NOT_FOUND错误发生

  • 如果任何SRID争论不在一个32位无符号整数的范围,一个ER_DATA_OUT_OF_RANGE错误发生

  • 如果任何SRID参数指的是一个未定义的SRS,一ER_SRS_NOT_FOUND错误发生

  • 否则,返回值非冰NULL

这些功能可用于获取的几何性质:

  • ST_Dimension(g)

    返回值的内在维度的几何g。尺寸可以?1, 0, 1,或2。这些值的含义了第11.5.2.2,“几何课”

    ST_Dimension()处理它的参数在这章节的介绍。

    MySQL的&#62;SELECT ST_Dimension(ST_GeomFromText('LineString(1 1,2 2)'));三维| ------------------------------------------------------(ST ST _ _ geomfromtext(linestring(1 1 2)1)| ------------------------------------------------------ | | ------------------------------------------------------
  • ST_Envelope(g)

    返回最小边界矩形(MBR)的几何意义g。结果是当了一回多边形价值是由边框的角点定义:

    POLYGON((MINX MINY, MAXX MINY, MAXX MAXY, MINX MAXY, MINX MINY))
    
    MySQL的&#62;SELECT ST_AsText(ST_Envelope(ST_GeomFromText('LineString(1 1,2 2)')));---------------------------------------------------------------- | st_astext(st_envelope(st_geomfromtext(&#39;linestring(1、2)&#39;)))| ---------------------------------------------------------------- |多边形((1 1,2 1 2 2,1))| ----------------------------------------------------------------

    如果参数是一个点或一个水平或垂直的线段,ST_Envelope()返回点或线段为MBR而不是返回一个无效的多边形:

    MySQL的&#62;SELECT ST_AsText(ST_Envelope(ST_GeomFromText('LineString(1 1,1 2)')));---------------------------------------------------------------- | st_astext(st_envelope(st_geomfromtext(&#39;linestring(1 1,1 2)&#39;)))| ---------------------------------------------------------------- |线(1 1,1 2)| ----------------------------------------------------------------

    ST_Envelope()处理它的参数在这章节的介绍,这个例外:

  • ST_GeometryType(g)

    返回一个二进制串表示名称的几何型的几何实例g是一个成员。名称对应的一个定义几何子类

    ST_GeometryType()处理它的参数在这章节的介绍。

    MySQL的&#62;SELECT ST_GeometryType(ST_GeomFromText('POINT(1 1)'));------------------------------------------------ | st_geometrytype(st_geomfromtext(&#39;point(1 1)&#39;))| ------------------------------------------------ |点| ------------------------------------------------
  • ST_IsEmpty(g)

    这个函数是一个占位符,为空时返回1或0,否则收藏价值几何。

    唯一有效的空的几何是一个空的几何集合值的形式表示。MySQL不支持GISEMPTY这样的价值观点空

    ST_IsEmpty()处理它的参数在这章节的介绍。

  • ST_IsSimple(g)

    返回1,如果价值几何g根据ISO简单第3部分:空间SQL/mm标准ST_IsSimple()如果这一论点不简单

    几何类的实例化在描述第11.5.2,“空间几何模型”包括引起类的实例被归类为不简单的具体条件。

    ST_IsSimple()处理它的参数在这章节的介绍,这个例外:

    • 如果几何图形有地理SRS与经度和纬度,超出范围,发生了一个错误:

      范围显示度。确切的范围稍微偏离由于浮点运算。

  • ST_SRID(g[, srid])

    代表一个有效的几何对象的一个参数gST_SRID()返回一个整数表示的空间参考系统(SRS)相关的IDg

    与可选的第二个参数代表一个有效的SRID值,ST_SRID()返回类型为一个srID值等于第二个参数,第一个参数相同的对象。这只设置对象的SRID值;不执行任何转换坐标值。

    ST_SRID()处理它的参数在这章节的介绍,这个例外:

    • 对于单参数语法,ST_SRID()返回几何SRID即使它指的是一个未定义的SRS。一个ER_SRS_NOT_FOUND不会发生错误

    ST_SRID(g, target_srid)ST_Transform(g, target_srid)区别如下:

    MySQL的&#62;SET @g = ST_GeomFromText('LineString(1 1,2 2)', 0);MySQL的&#62;SELECT ST_SRID(@g);对|圣_法(“G)| ------------------ | 0 |对MySQL的&#62;SET @g = ST_SRID(@g, 4326);MySQL的&#62;SELECT ST_SRID(@g);一个多月以前评论

    可以通过创建一个特殊的SRID几何ST_SRID()为创造空间价值的MySQL特定的函数的一个结果,随着一个srID价值。例如:

    SET @g1 = ST_SRID(Point(1, 1), 4326);

    然而,这个方法创建在SRID 0几何,然后给它SRID 4326(WGS 84)。一个更好的选择是创建几何与正确的空间参考系统开始。例如:

    SET @g1 = ST_PointFromText('POINT(1 1)', 4326);
    SET @g1 = ST_GeomFromText('POINT(1 1)', 4326);
    

    两参数形式ST_SRID()例如修正或改变,有一个不正确的SRID几何形状的SRS是有用的。

12.15.7.2点属性功能

Point由x和y坐标,可以得到使用ST_X()ST_Y()功能,分别。这些功能还允许一个可选参数,指定的X或Y坐标值,在这种情况下,函数的结果是从与适当的坐标改成等于第二个参数,第一个参数对象。

Point有一个地理空间参考系统对象(SRS),经度和纬度可以获得使用ST_Longitude()ST_Latitude()功能,分别。这些功能还允许一个可选参数,指定一个经度和纬度值,在这种情况下,函数的结果是从与经度和纬度改为等于第二个参数,第一个参数对象。

除非另有说明,本节中的函数处理他们的论点如下:

  • 如果任一参数为NULL,返回值是无效的

  • 如果任何几何参数是一个有效的几何不Point一个对象,ER_UNEXPECTED_GEOMETRY_TYPE错误发生

  • 如果任何几何参数不是一个语法形成几何,一ER_GIS_INVALID_DATA错误发生

  • 如果任何几何参数有一个srID价值指的是一个未定义的空间参考系统(SRS),一个ER_SRS_NOT_FOUND错误发生

  • 如果X或Y坐标参数设置值-infINF,或NaN,一个ER_DATA_OUT_OF_RANGE错误发生

  • 如果一个经度和纬度参数超出范围,发生了一个错误:

    范围显示度。确切的范围稍微偏离由于浮点运算。

  • 否则,返回值非冰NULL

这些功能可用于获取点属性:

  • ST_Latitude(p [, new_latitude_val])

    代表一个有效的一个参数Point目标p有一个地理空间参考系统(SRS),ST_Latitude()返回纬度值p作为一个双精度数

    与可选的第二个参数代表一个有效的纬度值,ST_Latitude()返回一个对象与纬度等于第二个参数,第一个参数。

    ST_Latitude()处理它的参数在这章节的介绍,加上如果对象是有效的但没有地理SRS,一ER_SRS_NOT_GEOGRAPHIC错误发生

    MySQL的&#62;SET @pt = ST_GeomFromText('POINT(45 90)', 4326);MySQL的&#62;SELECT ST_Latitude(@pt);------------------ | st_latitude(铂)| ------------------ | 45 | ------------------ MySQL &#62;SELECT ST_AsText(ST_Latitude(@pt, 10));--------------------------------- |圣(圣_ astext _纬度(@),10)(10)| --------------------------------- |点| --------------------------------- 90)

    这个功能在MySQL 8.0.12添加。

  • ST_Longitude(p [, new_longitude_val])

    代表一个有效的一个参数Point目标p有一个地理空间参考系统(SRS),ST_Longitude()返回的经度值p作为一个双精度数

    与可选的第二个参数代表一个有效的经度值,ST_Longitude()返回一个对象与经度等于第二个参数,第一个参数。

    ST_Longitude()处理它的参数在这章节的介绍,加上如果对象是有效的但没有地理SRS,一ER_SRS_NOT_GEOGRAPHIC错误发生

    MySQL的&#62;SET @pt = ST_GeomFromText('POINT(45 90)', 4326);MySQL的&#62;SELECT ST_Longitude(@pt);向|圣_ longitude(@ PT)|向| 90 |向MySQL &#62;SELECT ST_AsText(ST_Longitude(@pt, 10));---------------------------------- |圣_ astext(ST _ longitude(@ PT,10))| ---------------------------------- |(10点45 | ----------------------------------)

    这个功能在MySQL 8.0.12添加。

  • ST_X(p[, new_x_val])

    代表一个有效的一个参数Point目标pST_X()返回x坐标值p作为一个双精度数。在MySQL 8.0.12,x坐标是指最先出现在轴空间参考系统(SRS)的定义。

    与可选的第二个参数,ST_X()返回一个对象的x坐标等于第二个参数,第一个参数。在MySQL 8.0.12,如果Point对象有一个地理SRS,第二个参数必须在适当的范围为经度和纬度值。

    ST_X()处理它的参数在这章节的介绍。

    MySQL的&#62;SELECT ST_X(Point(56.7, 53.34));| -----------------------------(ST _ X点(56.7,| 53.34%)----------------------------- | 56.7 | ----------------------------- MySQL &#62;SELECT ST_AsText(ST_X(Point(56.7, 53.34), 10.5));------------------------------------------- | _ astext圣(圣_ x(点(56.7 53.34%,10.5,)))| ------------------------------------------- |点(10.5 | ------------------------------------------- 53.34%)
  • ST_Y(p[, new_y_val])

    代表一个有效的一个参数Point目标pST_Y()返回的y坐标值p作为一个双精度数。在MySQL 8.0.12,Y坐标是指出现在第二轴空间参考系统(SRS)的定义。

    与可选的第二个参数,ST_Y()返回一个对象的y坐标等于第二个参数,第一个参数。在MySQL 8.0.12,如果Point对象有一个地理SRS,第二个参数必须在适当的范围为经度和纬度值。

    ST_Y()处理它的参数在这章节的介绍。

    MySQL的&#62;SELECT ST_Y(Point(56.7, 53.34));_ ----------------------------- | ST Y(点(56.7,| 53.34%)----------------------------- | 53.34% MySQL &#62; | -----------------------------SELECT ST_AsText(ST_Y(Point(56.7, 53.34), 10.5));------------------------------------------- | _ astext圣(圣_ Y(点(56.7 53.34%,10.5,)))| ------------------------------------------- |点(56.7 | ------------------------------------------- 10.5)

12.15.7.3线和multilinestring属性函数

LineString价值观。你可以提取一个特定的点LineString,计算点的数量,它包含,或获得其长度。

本节中的一些功能也工作MultiLineString价值观

除非另有说明,本节中的函数处理他们的论点如下:

  • 如果任一参数为NULL或任何几何参数是一个空的几何,返回值是无效的

  • 如果任何几何参数不是一个语法形成几何,一ER_GIS_INVALID_DATA错误发生

  • 如果任何几何参数有一个srID价值指的是一个未定义的空间参考系统(SRS),一个ER_SRS_NOT_FOUND错误发生

  • 否则,返回值非冰NULL

这些功能可用于获取线特性:

  • ST_EndPoint(ls)

    返回Point这是的终点线价值ls

    ST_EndPoint()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @ls = 'LineString(1 1,2 2,3 3)';MySQL的&#62;SELECT ST_AsText(ST_EndPoint(ST_GeomFromText(@ls)));---------------------------------------------- | _ astext圣(圣_端点(ST _ geomfromtext(@ LS)))| ---------------------------------------------- |点(3)| ----------------------------------------------
  • ST_IsClosed(ls)

    对于一个LineString价值lsST_IsClosed()如果返回-1ls关闭(即其ST_StartPoint()ST_EndPoint()价值观是相同的)

    对于一个MultiLineString价值lsST_IsClosed()如果返回-1ls关闭(即的ST_StartPoint()ST_EndPoint()每个值都是相同的线进入ls

    ST_IsClosed()返回0,如果ls不是封闭的,和无效的如果ls无效的

    ST_IsClosed()处理它的参数在这章节的介绍,这个例外:

    MySQL的&#62;SET @ls1 = 'LineString(1 1,2 2,3 3,2 2)';MySQL的&#62;SET @ls2 = 'LineString(1 1,2 2,3 3,1 1)';MySQL的&#62;SELECT ST_IsClosed(ST_GeomFromText(@ls1));------------------------------------ | st_isclosed(st_geomfromtext(@ LS1))| ------------------------------------ | 0 | ------------------------------------ MySQL &#62;SELECT ST_IsClosed(ST_GeomFromText(@ls2));------------------------------------ | st_isclosed(st_geomfromtext(@ LS2))| ------------------------------------ | 1 | ------------------------------------ MySQL &#62;SET @ls3 = 'MultiLineString((1 1,2 2,3 3),(4 4,5 5))';MySQL的&#62;SELECT ST_IsClosed(ST_GeomFromText(@ls3));------------------------------------ | st_isclosed(st_geomfromtext(@ LS3))| ------------------------------------ | 0 | ------------------------------------
  • ST_Length(ls)

    返回一个双精度数表示的长度LineString线集合价值ls在其相关的空间参考。一个长度线集合价值等于它的元素的长度和。

    ST_Length()计算结果如下:

    • 如果几何学LineString在笛卡尔的SRS,返回值是几何的直角长度。

    • 如果几何学MultiLineString在笛卡尔的SRS,返回值是其元素的直角长度之和。

    • 如果几何学LineString在一个地理SRS,返回值是在SRS的几何大地测量长度,米。

    • 如果几何学MultiLineString在一个地理SRS,返回值是在SRS元件测量长度的总和,在米。

    ST_Length()处理它的参数在这章节的介绍,这些例外:

    • 如果图形是不一LineString线集合,返回值是NULL

    • 如果几何几何无效,可能的结果是未定义的长度(即,它可以是任何数量),或发生错误。

    • 如果长度计算结果+inf,一个ER_DATA_OUT_OF_RANGE错误发生

    • 如果几何图形有地理SRS与经度和纬度,超出范围,发生了一个错误:

      范围显示度。确切的范围稍微偏离由于浮点运算。

    mysql> SET @ls = 'LineString(1 1,2 2,3 3)';
    mysql> SELECT ST_Length(ST_GeomFromText(@ls));
    +---------------------------------+
    | ST_Length(ST_GeomFromText(@ls)) |
    +---------------------------------+
    |              2.8284271247461903 |
    +---------------------------------+
    
    mysql> SET @mls = 'MultiLineString((1 1,2 2,3 3),(4 4,5 5))';
    mysql> SELECT ST_Length(ST_GeomFromText(@mls));
    +----------------------------------+
    | ST_Length(ST_GeomFromText(@mls)) |
    +----------------------------------+
    |                4.242640687119286 |
    +----------------------------------+
    
  • ST_NumPoints(ls)

    剧情的号码Point中的对象线价值ls

    ST_NumPoints()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @ls = 'LineString(1 1,2 2,3 3)';MySQL的&#62;SELECT ST_NumPoints(ST_GeomFromText(@ls));| _ numpoints ------------------------------------圣(圣_ geomfromtext(@ LS)3)| ------------------------------------ | | ------------------------------------
  • ST_PointN(ls, N)

    返回NTHLinestring价值ls。点的编号从1开始

    ST_PointN()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @ls = 'LineString(1 1,2 2,3 3)';MySQL的&#62;SELECT ST_AsText(ST_PointN(ST_GeomFromText(@ls),2));---------------------------------------------- | _ astext圣(圣_ pointn(ST _ geomfromtext(@ LS),2))| ---------------------------------------------- |点(2)| ----------------------------------------------
  • ST_StartPoint(ls)

    返回Point这是开始的点线价值ls

    ST_StartPoint()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @ls = 'LineString(1 1,2 2,3 3)';MySQL的&#62;SELECT ST_AsText(ST_StartPoint(ST_GeomFromText(@ls)));_ astext ------------------------------------------------ |圣(圣_ startpoint(ST _ geomfromtext(@ LS)))| ------------------------------------------------ |点(1,1)| ------------------------------------------------

12.15.7.4多边形和multipolygon属性函数

在这部分收益函数性质Polygon多面价值观

除非另有说明,本节中的函数处理他们的论点如下:

  • 如果任一参数为NULL或任何几何参数是一个空的几何,返回值是无效的

  • 如果任何几何参数不是一个语法形成几何,一ER_GIS_INVALID_DATA错误发生

  • 如果任何几何参数有一个srID价值指的是一个未定义的空间参考系统(SRS),一个ER_SRS_NOT_FOUND错误发生

  • 的功能,把多个几何参数,如果这些参数不具有相同的扩散,一ER_GIS_DIFFERENT_SRIDS错误发生

  • 否则,返回值非冰NULL

这些功能可用于获得多边形的性质:

  • ST_Area({poly|mpoly})

    返回一个双精度数表示的区域Polygon多面的说法,在其空间参考系统测量。

    世纪之mysql 8.0.13,ST_Area()处理它的参数在这章节的介绍,这些例外:

    • 如果几何几何无效,可能的结果是一个未定义的区域(即,它可以是任何数量),或发生错误。

    • 如果几何图形是有效的但不是Polygon多面一个对象,ER_UNEXPECTED_GEOMETRY_TYPE错误发生

    • 如果几何学Polygon在笛卡尔的SRS,结果是多边形的笛卡儿的地区。

    • 如果几何学MultiPolygon在笛卡尔的SRS,结果是多边形的笛卡儿的面积总和。

    • 如果几何学Polygon在一个地理SRS,结果是在SRS多边形大地面积,平方米。

    • 如果几何学MultiPolygon在一个地理SRS,结果是,SRS的多边形大地面积总和,平方米。

    • 如果一个区域的计算结果+inf,一个ER_DATA_OUT_OF_RANGE错误发生

    • 如果几何图形有地理SRS与经度和纬度,超出范围,发生了一个错误:

      范围显示度。确切的范围稍微偏离由于浮点运算。

    MySQL 8.0.13之前,ST_Area()处理它的参数在这章节的介绍,这些例外:

    • 对于尺寸0或1个参数,结果是0。

    • 如果一个几何是空的,返回值是0,而不是NULL

    • 一个几何集合,结果是所有组件的面积值的总和。如果几何集合是空的,它的面积是返回0。

    • 如果几何图形有一个地理空间参考系统(SRS),一个方案的价值ER_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS错误发生

    MySQL的&#62;SET @poly ='Polygon((0 0,0 3,3 0,0 0),(1 1,1 2,2 1,1 1))';MySQL的&#62;SELECT ST_Area(ST_GeomFromText(@poly));--------------------------------- | st_area(st_geomfromtext(@聚))| --------------------------------- | 4 | --------------------------------- MySQL &#62;SET @mpoly =-&#62;'MultiPolygon(((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1)))';MySQL的&#62;SELECT ST_Area(ST_GeomFromText(@mpoly));---------------------------------- | st_area(st_geomfromtext(@ mpoly))| ---------------------------------- | 8 | ----------------------------------
  • ST_Centroid({poly|mpoly})

    返回的数学中心Polygon多面一论据Point。结果是不能保证的多面

    这个函数通过计算集合中最高的尺寸部件的质心点过程几何集合。这样的成分提取出来,制成单MultiPolygon线集合,或MultiPoint质心的计算

    ST_Centroid()处理它的参数在这章节的介绍,这些例外:

    • 返回值是NULL这个参数是空的几何收集的附加条件。

    • 如果几何图形有一个地理空间参考系统(SRS),一个方案的价值ER_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS错误发生

    MySQL的&#62;SET @poly =-&#62;ST_GeomFromText('POLYGON((0 0,10 0,10 10,0 10,0 0),(5 5,7 5,7 7,5 7,5 5))');MySQL的&#62;SELECT ST_GeometryType(@poly),ST_AsText(ST_Centroid(@poly));------------------------ -------------------------------------------- | st_geometrytype(@聚)| st_astext(st_centroid(@聚))| ------------------------ -------------------------------------------- |多边形|点(4.958333333333333 4.958333333333333)| ------------------------ --------------------------------------------
  • ST_ExteriorRing(poly)

    返回的外部环Polygon价值poly作为一个线

    ST_ExteriorRing()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @poly =-&#62;'Polygon((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1))';MySQL的&#62;SELECT ST_AsText(ST_ExteriorRing(ST_GeomFromText(@poly)));---------------------------------------------------- | st_astext(st_exteriorring(st_geomfromtext(@聚)))| ---------------------------------------------------- |线(0、0、0 0)| ----------------------------------------------------
  • ST_InteriorRingN(poly, N)

    返回N世纪的室内环多边形价值poly作为一个线。戒指是从1开始计数。

    ST_InteriorRingN()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @poly =-&#62;'Polygon((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1))';MySQL的&#62;SELECT ST_AsText(ST_InteriorRingN(ST_GeomFromText(@poly),1));------------------------------------------------------- | st_astext(st_interiorringn(st_geomfromtext(@聚),1))| ------------------------------------------------------- |线(1 1 2 2 1,1)| -------------------------------------------------------
  • ST_NumInteriorRing(poly)ST_NumInteriorRings(poly)

    返回在室内环数Polygon价值poly

    ST_NumInteriorRing()ST_NuminteriorRings()在这章节的介绍处理他们的论点。

    MySQL的&#62;SET @poly =-&#62;'Polygon((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1))';MySQL的&#62;SELECT ST_NumInteriorRings(ST_GeomFromText(@poly));--------------------------------------------- | st_numinteriorrings(st_geomfromtext(@聚))| --------------------------------------------- | 1 | ---------------------------------------------

12.15.7.5 geometrycollection属性函数

这些函数返回的属性GeometryCollection价值观

除非另有说明,本节中的函数处理他们的论点如下:

  • 如果任一参数为NULL或任何几何参数是一个空的几何,返回值是无效的

  • 如果任何几何参数不是一个语法形成几何,一ER_GIS_INVALID_DATA错误发生

  • 如果任何几何参数有一个srID价值指的是一个未定义的空间参考系统(SRS),一个ER_SRS_NOT_FOUND错误发生

  • 否则,返回值非冰NULL

这些功能可用于获取几何集合属性:

  • ST_GeometryN(gc, N)

    返回N在TH几何混合数据类型价值gc。几何是从1开始计数。

    ST_GeometryN()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @gc = 'GeometryCollection(Point(1 1),LineString(2 2, 3 3))';MySQL的&#62;SELECT ST_AsText(ST_GeometryN(ST_GeomFromText(@gc),1));------------------------------------------------- | st_astext(st_geometryn(st_geomfromtext(@ GC),1))| ------------------------------------------------- |点(1 1)| -------------------------------------------------
  • ST_NumGeometries(gc)

    返回在几何体的数量GeometryCollection价值gc

    ST_NumGeometries()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @gc = 'GeometryCollection(Point(1 1),LineString(2 2, 3 3))';MySQL的&#62;SELECT ST_NumGeometries(ST_GeomFromText(@gc));---------------------------------------- | _ numgeometries圣(圣_ geomfromtext(@ GC)2)| ---------------------------------------- | | ----------------------------------------

12.15.8空间算子函数

OpenGIS提出了一些功能,可以产生几何。他们的目的是实现空间操作。

这些功能的支持,除了那些不适用根据所有的参数类型组合开放地理空间联盟规格

除非另有说明,本节中的函数处理他们的论点如下:

  • 如果任一参数为NULL,返回值是无效的

  • 如果任何几何参数不是一个语法形成几何,一ER_GIS_INVALID_DATA错误发生

  • 如果任何几何参数有一个srID价值指的是一个未定义的空间参考系统(SRS),一个ER_SRS_NOT_FOUND错误发生

  • 的功能,把多个几何参数,如果这些参数不具有相同的扩散,一ER_GIS_DIFFERENT_SRIDS错误发生

  • 如果任何几何参数对地理SRS SRID值,一ER_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS错误发生

  • 否则,返回值非冰NULL

这些空间算子函数可用:

  • ST_Buffer(g, d[, strategy1[, strategy2[, strategy3]]])

    返回一个几何表示各点与几何值的距离g小于或等于距离d

    如果几何参数为空,ST_Buffer()返回一个空的几何

    如果距离0,ST_Buffer()返回几何参数不变:

    MySQL的&#62;SET @pt = ST_GeomFromText('POINT(0 0)');MySQL的&#62;SELECT ST_AsText(ST_Buffer(@pt, 0));------------------------------ | st_astext(st_buffer(铂,0))| ------------------------------ |点(0 0)| ------------------------------

    ST_Buffer()支持负距离多边形MultiPolygon值,以及几何集合包含多边形MultiPolygon价值观。结果可能是一个空的几何。

    ST_Buffer()允许多达三个可选策略参数的距离参数如下。策略影响缓冲区的计算。这些参数是字节字符串值所产生的ST_Buffer_Strategy()功能,可用于点,加入,和结束策略:

    对每一种类型的策略可能是指定的,他们可以任意顺序。

    ST_Buffer()处理它的参数在这章节的介绍,这些例外:

    • 一个负的距离Point多点LineString,和线集合值,以及几何集合不包含任何Polygon多面价值观,一个ER_WRONG_ARGUMENTS错误发生

    • 如果指定一个给定类型的多策略,一ER_WRONG_ARGUMENTS错误发生

    MySQL的&#62;SET @pt = ST_GeomFromText('POINT(0 0)');MySQL的&#62;SET @pt_strategy = ST_Buffer_Strategy('point_square');MySQL的&#62;SELECT ST_AsText(ST_Buffer(@pt, 2, @pt_strategy));-------------------------------------------- | st_astext(st_buffer(铂、2、@ pt_strategy))| -------------------------------------------- |多边形((- 2 - 2 - 2,2,2 2,2 2))| --------------------------------------------
    MySQL的&#62;SET @ls = ST_GeomFromText('LINESTRING(0 0,0 5,5 5)');MySQL的&#62;SET @end_strategy = ST_Buffer_Strategy('end_flat');MySQL的&#62;SET @join_strategy = ST_Buffer_Strategy('join_round', 10);MySQL的&#62;SELECT ST_AsText(ST_Buffer(@ls, 5, @end_strategy, @join_strategy))--------------------------------------------------------------- | st_astext(st_buffer(@ LS,五,@ end_strategy,@ join_strategy))| --------------------------------------------------------------- |多边形((5 5 0 10,-3.5355339059327373 8.535533905932738,| | - 5 5,5 0 0.5 0.5五))| ---------------------------------------------------------------
  • ST_Buffer_Strategy(strategy[, points_per_circle])

    这个函数返回一个字节字符串使用策略ST_Buffer()影响缓冲区的计算

    信息策略是可用的boost.org

    第一个参数必须是一个字符串表示的策略选择:

    • 点策略,允许值'point_circle'点是_广场

    • 加入策略,允许值'join_round'“Join”

    • 终端策略,允许值'end_round'最后一次

    如果第一个参数是'point_circle'“我喝了_圆形”'join_miter',或最后一次,的points_per_circle参数必须为正数值。最大points_per_circle价值的价值max_points_in_geometry系统变量

    例如,看到的描述ST_Buffer()

    ST_Buffer_Strategy()处理它的参数在这章节的介绍,这些例外:

    • 如果任何一个参数无效,ER_WRONG_ARGUMENTS错误发生

    • 如果第一个参数是'point_square'最后一次,的points_per_circle参数必须不交或ER_WRONG_ARGUMENTS错误发生

  • ST_ConvexHull(g)

    返回一个值的几何表示几何凸包g

    这个函数计算一个几何凸包首先检查是否其顶点共线。如果该函数返回一个线性的船体,船体其他多边形。这个函数的集合中的所有组件的所有顶点提取过程几何集合,创建一个MultiPoint值,并计算其凸包

    ST_ConvexHull()处理它的参数在这章节的介绍,这个例外:

    • 返回值是NULL这个参数是空的几何收集的附加条件。

    MySQL的&#62;SET @g = 'MULTIPOINT(5 0,25 0,15 10,15 25)';MySQL的&#62;SELECT ST_AsText(ST_ConvexHull(ST_GeomFromText(@g)));----------------------------------------------- | st_astext(st_convexhull(st_geomfromtext(@ g)))| ----------------------------------------------- |多边形((5 0 0 0 | ----------------------------------------------- 25,5))
  • ST_Difference(g1, g2)

    返回一个几何表示的几何值点集的区别g1g2

    ST_Difference()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @g1 = Point(1,1), @g2 = Point(2,2);MySQL的&#62;SELECT ST_AsText(ST_Difference(@g1, @g2));1 . Stón de difference(@g1,@g2)
  • ST_Intersection(g1, g2)

    返回一个几何表示的几何值点集的交集g1g2

    ST_Intersection()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @g1 = ST_GeomFromText('LineString(1 1, 3 3)');MySQL的&#62;SET @g2 = ST_GeomFromText('LineString(1 3, 3 1)');MySQL的&#62;SELECT ST_AsText(ST_Intersection(@g1, @g2));* * * * * * * * * * * * * * * * * * *
  • ST_SymDifference(g1, g2)

    返回一个几何表示的几何对称差集值点g1g2,其定义为:

    g1symdifferenceg2:= (g1联盟g2差异()g1交叉g2

    或,在函数调用notation:

    ST_SymDifference(g1, g2) = ST_Difference(ST_Union(g1, g2), ST_Intersection(g1, g2))
    

    ST_SymDifference()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @g1 = Point(1,1), @g2 = Point(2,2);MySQL的&#62;SELECT ST_AsText(ST_SymDifference(@g1, @g2));--------------------------------------- | st_astext(st_symdifference(@ @ G1、G2))| --------------------------------------- |多点((1,1),(2,2))| ---------------------------------------
  • ST_Transform(g, target_srid)

    将几何从一个空间参考系统(SRS)到另一个。返回值是一个几何型与所有坐标转化为目标的SRID输入几何体相同,target_srid。转型的支持是有限的地理状况,除非几何参数的SRID作为目标SRID值相同,在这种情况下,返回值是任何有效的SRS输入几何。

    ST_Transform()处理它的参数在这章节的介绍,这些例外:

    ST_SRID(g, target_srid)ST_Transform(g, target_srid)区别如下:

    MySQL的&#62;SET @p = ST_GeomFromText('POINT(52.381389 13.064444)', 4326);MySQL的&#62;SELECT ST_AsText(@p);| ----------------------------(@圣_ astext | ---------------------------- |点(P)52.381389 13.064444)| ---------------------------- MySQL &#62;SET @p = ST_Transform(@p, 4230);MySQL的&#62;SELECT ST_AsText(@p);--------------------------------------------- | ST _ astext(@ |点(P)| --------------------------------------------- 52.38208611407426 | --------------------------------------------- 13.065520672345304)
  • ST_Union(g1, g2)

    返回一个几何表示的几何值的点集的并集g1g2

    ST_Union()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @g1 = ST_GeomFromText('LineString(1 1, 3 3)');MySQL的&#62;SET @g2 = ST_GeomFromText('LineString(1 3, 3 1)');MySQL的&#62;SELECT ST_AsText(ST_Union(@g1, @g2));| -------------------------------------- _ astext(ST ST _社(@ @ G1,G2的))((1 | -------------------------------------- | multilinestring 1.3(1,3)3 1)| --------------------------------------

此外,第12.15.7,几何性质功能”,讨论了几种功能,构建新的几何形状,从现有的。看到这段说明这些功能:

12.15.9功能测试之间的几何对象的空间关系

本节中描述的功能需要两几何参数和返回一个定性或定量的关系。

MySQL实现了两套使用函数名由OpenGIS规范定义的功能。一组测试使用精确的物体形状的两个几何值之间的关系,另一组使用对象的最小边界矩形(MBR)。

12.15.9.1空间关系的功能,使用对象的形状

OpenGIS规范定义了测试两几何值之间的关系如下功能g1G2使用精确的物体形状。除了ST_Distance(),返回值1和0表示真和假,分别。ST_Distance()返回的距离值

在这部分功能检测参数在直角坐标或地理空间参考系统(SRSS),并返回结果适当的SRS。

除非另有说明,本节中的函数处理他们的论点如下:

  • 如果任一参数为NULL或任何几何参数是一个空的几何,返回值是无效的

  • 如果任何几何参数不是一个语法形成几何,一ER_GIS_INVALID_DATA错误发生

  • 如果任何几何参数指的是一个未定义的空间参考系统(SRS),一个ER_SRS_NOT_FOUND错误发生

  • 的功能,把多个几何参数,如果这些参数不具有相同的扩散,一ER_GIS_DIFFERENT_SRIDS错误发生

  • 如果任何几何参数是几何无效,可能的结果是真的还是假的(这是不确定的),或出现错误。

  • 地理SRS的几何参数,如果参数有经度和纬度,超出范围,发生了一个错误:

    范围显示度。如果SRS使用另一个单位,范围在其单元采用相应的值。确切的范围稍微偏离由于浮点运算。

  • 否则,返回值非冰NULL

这些物体的形状功能可用于测试几何关系:

  • ST_Contains(g1, g2)

    返回1或0指示g1完全包含g2。本试验相反的关系ST_Within()

    ST_Contains()处理它的参数在这章节的介绍。

  • ST_Crosses(g1, g2)

    两个几何空间交叉如果他们的空间关系具有以下特性:

    • 除非g1与和G2都是1维的:g1十字架G2如果内部g2与内部的共同点G1,但g2不覆盖整个室内G1

    • 如果两g1G2是维度1:如果线相交在一个有限数量的点(即,没有共同的线段,在常见的单点)。

    这个函数返回1或0指示g1空间组合g2

    ST_Crosses()处理它的参数描述在本章节的介绍,除了返回值无效的这些附加条件:

    • g1是2维的(多边形MultiPolygon

    • g2是维(MultiPoint

  • ST_Disjoint(g1, g2)

    返回1或0指示g1空间不相交(不相交)g2

    ST_Disjoint()处理它的参数在这章节的介绍。

  • ST_Distance(g1, g2)

    回报之间的距离g1g2,在空间参考系统(SRS)的单位长度测量。

    这个函数返回的最短距离的两个几何参数的组件之间的所有组合过程几何集合。

    ST_Distance()处理它的参数在这章节的介绍,这些例外:

    • ST_Distance()在一个地理检测参数(椭球)空间参考系统和返回大地距离在椭球。唯一被允许的地理参数类型Point,或MultiPoint(在任何争论中的顺序)。如果说与其他几何类型参数组合在一个地理SRS,一ER_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS错误发生

    • 如果任一参数为几何无效,可能的结果是未定义的距离(即,它可以是任何数量),或发生错误。

    • 如果一个中间或最终结果产生NaN或者一个负数,一个ER_GIS_INVALID_DATA错误发生

    MySQL的&#62;SET @g1 = Point(1,1);MySQL的&#62;SET @g2 = Point(2,2);MySQL的&#62;SELECT ST_Distance(@g1, @g2);——————————————————————————SET @g1 = ST_GeomFromText('POINT(1 1)', 4326);MySQL的&#62;SET @g2 = ST_GeomFromText('POINT(2 2)', 4326);MySQL的&#62;SELECT ST_Distance(@g1, @g2);_ ------ | ST(@ @距离G1,G2)| ------ | 156874.3859490455 | ------

    对于距离计算的特殊情况在球,看ST_Distance_Sphere()功能

  • ST_Equals(g1, g2)

    返回1或0指示g1在空间上是平等的g2

    ST_Equals()处理它的参数在这章节的介绍,除了它不返回无效的空的几何参数

    mysql> SET @g1 = Point(1,1), @g2 = Point(2,2);
    mysql> SELECT ST_Equals(@g1, @g1), ST_Equals(@g1, @g2);
    +---------------------+---------------------+
    | ST_Equals(@g1, @g1) | ST_Equals(@g1, @g2) |
    +---------------------+---------------------+
    |                   1 |                   0 |
    +---------------------+---------------------+
    
  • ST_Intersects(g1, g2)

    返回1或0指示g1空间相交g2

    ST_Intersects()处理它的参数在这章节的介绍。

  • ST_Overlaps(g1, g2)

    两个几何空间重叠如果它们相交,相交的结果在几何尺寸相同但不等于给定的几何。

    这个函数返回1或0指示g1空间重叠g2

    ST_Overlaps()处理它的参数描述在本章节的介绍,除了返回值无效的对于这两个几何尺寸不相等的附加条件。

  • ST_Touches(g1, g2)

    两个几何空间联系如果他们的内部不相交,但其中的几何边界相交的边界或其他内部。

    这个函数返回1或0指示g1空间摸g2

    ST_Touches()处理它的参数描述在本章节的介绍,除了返回值无效的对于这两个几何尺寸0的附加条件(Point多点

  • ST_Within(g1, g2)

    返回1或0指示g1空间内g2。本试验相反的关系ST_Contains()

    ST_Within()处理它的参数在这章节的介绍。

12.15.9.2空间关系的函数,使用最小边界矩形

MySQL提供了几个MySQL特定功能测试的最小边界矩形(MBR)之间关系的两个几何g1G2。返回值1和0表示真和假,分别。

一个点的包围盒被解释为一个点,边界和内部。

一条笔直的水平或垂直线解释为一条线的线内部也是边界包围盒。端点的边界点。

如果任何参数几何集合内部,边界,和外部的参数集合中的所有元素的结合。

在这部分功能检测参数在直角坐标或地理空间参考系统(SRSS),并返回结果适当的SRS。

除非另有说明,本节中的函数处理他们的论点如下:

  • 如果任一参数为NULL或一个空的几何,返回值是无效的

  • 如果任何几何参数不是一个语法形成几何,一ER_GIS_INVALID_DATA错误发生

  • 如果任何几何参数指的是一个未定义的空间参考系统(SRS),一个ER_SRS_NOT_FOUND错误发生

  • 的功能,把多个几何参数,如果这些参数不具有相同的扩散,一ER_GIS_DIFFERENT_SRIDS错误发生

  • 如果任一参数为几何无效,无论结果是真还是假(这是不确定的),或出现错误。

  • 地理SRS的几何参数,如果参数有经度和纬度,超出范围,发生了一个错误:

    范围显示度。如果SRS使用另一个单位,范围在其单元采用相应的值。确切的范围稍微偏离由于浮点运算。

  • 否则,返回值非冰NULL

这些MBR功能可用于测试几何关系:

  • MBRContains(g1, g2)

    返回1或0指示最小包围矩形g1包含的最小包围矩形g2。本试验相反的关系MBRWithin()

    MBRContains()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @g1 = ST_GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0))');MySQL的&#62;SET @g2 = ST_GeomFromText('Point(1 1)');MySQL的&#62;SELECT MBRContains(@g1,@g2), MBRWithin(@g2,@g1);---------------------- --------------------(@ @ | mbrcontains G1,G2的)(@ @ | mbrwithin G2,G1期)| ---------------------- ----------- | | 1 1 | ---------------------- --------------------
  • MBRCoveredBy(g1, g2)

    返回1或0指示最小包围矩形g1覆盖的最小包围矩形g2。本试验相反的关系MBRCovers()

    MBRCoveredBy()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @g1 = ST_GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0))');MySQL的&#62;SET @g2 = ST_GeomFromText('Point(1 1)');MySQL的&#62;SELECT MBRCovers(@g1,@g2), MBRCoveredby(@g1,@g2);-------------------- ----------------------- | mbrcovers(@ @ G1、G2)| mbrcoveredby(@ @ G1、G2)| -------------------- ----------------------- | 1 | 0 | -------------------- ----------------------- MySQL &#62;SELECT MBRCovers(@g2,@g1), MBRCoveredby(@g2,@g1);-------------------- ----------------------- | mbrcovers(@ @ G2、G1)| mbrcoveredby(@ @ G2、G1)| -------------------- ----------------------- | 0 | 1 | -------------------- -----------------------
  • MBRCovers(g1, g2)

    返回1或0指示最小包围矩形g1覆盖的最小包围矩形g2。本试验相反的关系MBRCoveredBy()。看到的描述MBRCoveredBy()为例

    MBRCovers()处理它的参数在这章节的介绍。

  • MBRDisjoint(g1, g2)

    返回1或0指示最小边界矩形的几何形状g1g2是不相交的(不相交)。

    MBRDisjoint()处理它的参数在这章节的介绍。

  • MBREquals(g1, g2)

    返回1或0指示最小边界矩形的几何形状g1g2都是一样的

    MBREquals()处理它的参数在这章节的介绍,除了它不返回无效的空的几何参数

  • MBRIntersects(g1, g2)

    返回1或0指示最小边界矩形的几何形状g1g2横断.

    MBRIntersects()处理它的参数在这章节的介绍。

  • MBROverlaps(g1, g2)

    两个几何空间重叠如果它们相交,相交的结果在几何尺寸相同但不等于给定的几何。

    这个函数返回1或0指示最小边界矩形的几何形状g1g2重叠.

    MBROverlaps()处理它的参数在这章节的介绍。

  • MBRTouches(g1, g2)

    两个几何空间联系如果他们的内部不相交,但其中的几何边界相交的边界或其他内部。

    这个函数返回1或0指示最小边界矩形的几何形状g1g2触摸

    MBRTouches()处理它的参数在这章节的介绍。

  • MBRWithin(g1, g2)

    返回1或0指示最小包围矩形g1在最小包围矩形g2。本试验相反的关系MBRContains()

    MBRWithin()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @g1 = ST_GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0))');MySQL的&#62;SET @g2 = ST_GeomFromText('Polygon((0 0,0 5,5 5,5 0,0 0))');MySQL的&#62;SELECT MBRWithin(@g1,@g2), MBRWithin(@g2,@g1);-------------------- -------------------- | mbrwithin(@ @ G1、G2)| mbrwithin(@ @ G2、G1)| -------------------- -------------------- | 1 | 0 | -------------------- --------------------

12.15.10 Geohash函数空间

Geohash是纬度和经度坐标的任意精度的编码为一个文本字符串系统。Geohash值只包含字符从字符串的选择"0123456789bcdefghjkmnpqrstuvwxyz"

这部分的功能使Geohash值操作,它提供了应用程序的进口和出口数据的能力和Geohash,索引和搜索Geohash值。

除非另有说明,本节中的函数处理他们的论点如下:

  • 如果任一参数为NULL,返回值是无效的

  • 如果任何参数无效,发生了一个错误。

  • 如果任何的论点有一个经度和纬度,超出范围,发生了一个错误:

    范围显示度。确切的范围稍微偏离由于浮点运算。

  • 如果任何一点论据没有SRID 0或4326,一ER_SRS_NOT_FOUND错误发生point论证有效性不检查方案。

  • 如果任何SRID参数指的是一个未定义的空间参考系统(SRS),一个ER_SRS_NOT_FOUND错误发生

  • 如果任何SRID争论不在一个32位无符号整数的范围,一个ER_DATA_OUT_OF_RANGE错误发生

  • 否则,返回值非冰NULL

这些Geohash功能可用:

  • ST_GeoHash(longitude, latitude, max_length)ST_GeoHash(point, max_length)

    返回在连接字符集和整理Geohash字符串。

    对于第一个语法的longitude必须在范围[?180、180号],和latitude必须在范围[ 90, 90 ]?数。第二语法,一价值是必需的,其中的X和Y坐标为经度和纬度的有效范围,分别。

    得到的字符串不超过max_length人物,具有100的上限。字符串可能短于max_length人物因为创建Geohash值算法继续直到它已经创建了一个字符串,可以是一个精确的表示位置或max_length字,以先到者为准

    ST_GeoHash()处理它的参数在这章节的介绍。

    MySQL的&#62;SELECT ST_GeoHash(180,0,10), ST_GeoHash(-180,-90,15);---------------------- ------------------------- |圣_ geohash(180,0,10)|圣_ geohash(180,90,15)| ---------------------- ------------------------- | xbpbpbpbpb | 000000000000000 | ---------------------- -------------------------
  • ST_LatFromGeoHash(geohash_str)

    从Geohash字符串值返回纬度范围内[ 90, 90 ]?双精度数。

    这个ST_LatFromGeoHash()解码函数读取不超过433字符从geohash_str争论。表示在坐标值的内部表示信息的上限。过去的第四百三十三个字符被忽略,即使他们是非法和产生一个错误。

    ST_LatFromGeoHash()处理它的参数在这章节的介绍。

    MySQL的&#62;SELECT ST_LatFromGeoHash(ST_GeoHash(45,-20,10));------------------------------------------ |(ST ST _ latfromgeohash _ geohash(45,- 10 - 20)| ------------------------------------------ | | ------------------------------------------
  • ST_LongFromGeoHash(geohash_str)

    返回一个字符串值Geohash的经度范围在[?180双精度数,180 ]。

    在描述备注ST_LatFromGeoHash()关于处理的最大字符数geohash_str的说法也适用于ST_LongFromGeoHash()

    ST_LongFromGeoHash()处理它的参数在这章节的介绍。

    MySQL的&#62;SELECT ST_LongFromGeoHash(ST_GeoHash(45,-20,10));------------------------------------------- | st_longfromgeohash(st_geohash(45,- 20,10))| ------------------------------------------- | 45 | -------------------------------------------
  • ST_PointFromGeoHash(geohash_str, srid)

    返回一个POINTValue containing the deoted GOHAHAH Value,Given a GOHAHAH String Value .

    X和Y坐标的点的范围是[ 180, 180 ]?经度和?范围[ 90, 90 ]纬度,分别。

    这个srid参数是一个32位无符号整数。

    在描述备注ST_LatFromGeoHash()关于处理的最大字符数geohash_str的说法也适用于ST_PointFromGeoHash()

    ST_PointFromGeoHash()处理它的参数在这章节的介绍。

    MySQL的&#62;SET @gh = ST_GeoHash(45,-20,10);MySQL的&#62;SELECT ST_AsText(ST_PointFromGeoHash(@gh,0));_ astext --------------------------------------- |圣(圣_ pointfromgeohash(@),0))| --------------------------------------- |点(45,20)| ---------------------------------------

12.15.11 GeoJSON函数空间

本节描述了功能之间的转换和空间值GeoJSON文件。GeoJSON是编码的几何/地理特征的一个开放标准。有关更多信息,参见http://geojson.org。这里讨论的功能跟GeoJSON规范修订版1。

GeoJSON支持MySQL支持相同的几何/地理数据类型。不支持的功能和featurecollection对象,除了几何对象的提取。CRS的支持是有限值,确定一个srID。

MySQL还支持本地JSON数据类型和一组SQL函数使JSON值操作。有关更多信息,参见11.6节,“JSON数据类型”,和12.16节,“JSON功能”

  • ST_AsGeoJSON(g [, max_dec_digits [, options]])

    从几何产生GeoJSON对象g。对象的连接字符串的字符集和整理。

    如果任一参数为NULL,返回值是无效的。如果任何非—NULL参数无效,发生了一个错误。

    max_dec_digits,如果规定,限制了数量的小数位数舍入输出坐标和原因。如果不指定这个参数默认为2最大值三十二?1。最低为0

    options如果指定,是一位。下表显示了允许的标志值。如果几何参数有0个srID CRS,没有对象产生即使标志值要求。

    标志值意义
    没有选择。这是默认的,如果options没有指定
    添加一个包围盒的输出。
    添加一个短格式CRS缸输出。默认的格式是一个短格式(EPSG:srid
    添加一个长格式(CRS瓮urn:ogc:def:crs:EPSG::srid)。这面国旗覆盖国旗2。例如,5和7是同一个选项值(添加一个包围盒和长格式CRS瓮)。
    MySQL的&#62;SELECT ST_AsGeoJSON(ST_GeomFromText('POINT(11.11111 12.22222)'),2);------------------------------------------------------------- | _ asgeojson圣(圣_ geomfromtext(点(11.11111 12.22222),2)| ------------------------------------------------------------- | {“型”的“点”、“坐标”:[ 11 ],| ------------------------------------------------------------- 12.22 }
  • ST_GeomFromGeoJSON(str [, options [, srid]])

    将一个字符串str代表GeoJSON对象并返回一个几何。

    如果任一参数为NULL,返回值是无效的。如果任何非—NULL参数无效,发生了一个错误。

    options,如果有,说明如何处理GeoJSON的文件,包含坐标尺寸大于2的几何形状。下表显示了允许options价值观

    期权价值意义
    拒绝文档并产生一个错误。这是默认的如果options没有指定
    2, 3, 4接受文件和脱光坐标高坐标尺寸。

    options2、3的价值,4目前产生相同的效果。如果坐标尺寸大于2在将来支持的几何形状,这些值将产生不同的影响。

    这个srid的说法,如果有,一定是一个32位无符号整数。如果没有给出,几何的返回值有4326个srID。

    如果srid指的是一个未定义的空间参考系统(SRS),一个ER_SRS_NOT_FOUND错误发生

    地理SRS的几何参数,如果参数有经度和纬度,超出范围,发生了一个错误:

    范围显示度。如果SRS使用另一个单位,范围在其单元采用相应的值。确切的范围稍微偏离由于浮点运算。

    GeoJSON几何特征,特征的集合对象可能有一个crs财产解析函数的解析在CRS瓮在OGC定义::::::::::CRS epsgsridEPSG:srid命名空间,但不反馈电容作为链接对象。也,瓮:OGC:定义:CRS:OGC:1.3:crs84是公认的SRID 4326。如果一个对象有一个CRS不理解,出现错误,除了如果可选srid给出的说法是,任何CRS是即使是无效的忽视。

    如果一个crs成员指定的从顶层对象SRID SRID所不同的是在一个较低的水平的GeoJSON文档中找到,一个ER_INVALID_GEOJSON_CRS_NOT_TOP_LEVEL错误发生

    在GeoJSON规范规定,解析是最敏感的typeGeoJSON的输入部件(LineString,等等)。规格是无声的关于其他解析案例的敏感性,这在MySQL是不区分大小写。

    这个例子显示了一个简单的解析结果GeoJSON对象:

    mysql> SET @json = '{ "type": "Point", "coordinates": [102.0, 0.0]}';
    mysql> SELECT ST_AsText(ST_GeomFromGeoJSON(@json));
    +--------------------------------------+
    | ST_AsText(ST_GeomFromGeoJSON(@json)) |
    +--------------------------------------+
    | POINT(102 0)                         |
    +--------------------------------------+
    

12.15.12空间便利功能

本节中的功能提供了方便操作的几何值。

除非另有说明,本节中的函数处理他们的论点如下:

  • 如果任一参数为NULL,返回值是无效的

  • 如果任何几何参数不是一个语法形成几何,一ER_GIS_INVALID_DATA错误发生

  • 如果任何几何参数有一个srID价值指的是一个未定义的空间参考系统(SRS),一个ER_SRS_NOT_FOUND错误发生

  • 的功能,把多个几何参数,如果这些参数不具有相同的扩散,一ER_GIS_DIFFERENT_SRIDS错误发生

  • 否则,返回值非冰NULL

这些方便的功能是可用的:

  • ST_Distance_Sphere(g1, g2 [, radius])

    返回最小球面距离Point多点在一个球面上的争论,在米。(通用的距离计算,看ST_Distance()可选功能。)radius应该是在米

    如果几何参数是有效的直角Point多点在方案0的值,返回值是短距离的两个几何之间的一个规定的范围内。如果省略,默认半径是6370986米,点的X和Y坐标被解释为经度和纬度,分别在度。

    如果几何参数是有效的Point多点在一个地理空间参考系统(SRS)的值,返回值是最短距离的两个几何之间的一个规定的范围内。如果省略,默认半径等于平均半径,定义为(2A B)/ 3,其中一个是半长轴和B是SRS的短半轴。

    ST_Distance_Sphere()处理它的参数在这章节的介绍,这些例外:

    • 支持的几何参数组合Point,或Point多点(在任何争论中的顺序)。如果在结构中至少有一个不Point也没有多点,和SRID是0,一个ER_NOT_IMPLEMENTED_FOR_CARTESIAN_SRS错误发生。如果在结构中至少有一个不也没有MultiPoint,和SRID是指地理SRS,一ER_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS错误发生。如果任何几何是指预计的SRS,一ER_NOT_IMPLEMENTED_FOR_PROJECTED_SRS错误发生

    • 如果任何的论点有一个经度和纬度,超出范围,发生了一个错误:

      范围显示度。如果SRS使用另一个单位,范围在其单元采用相应的值。确切的范围稍微偏离由于浮点运算。

    • 如果radius目前的争论是不积极的,一个ER_NONPOSITIVE_RADIUS错误发生

    • 如果距离超过一个双精度数的范围,一个ER_STD_OVERFLOW_ERROR错误发生

    MySQL的&#62;SET @pt1 = ST_GeomFromText('POINT(0 0)');MySQL的&#62;SET @pt2 = ST_GeomFromText('POINT(180 0)');MySQL的&#62;SELECT ST_Distance_Sphere(@pt1, @pt2);-------------------------------- | st_distance_sphere(@ @ PT1,PT2)| -------------------------------- | 20015042.813723423 | --------------------------------
  • ST_IsValid(g)

    返回1,如果参数是几何有效,0如果参数不是几何有效。几何学的有效性是由OGC规范定义。

    唯一有效的空的几何是一个空的几何集合值的形式表示。ST_IsValid()在这种情况下,返回1。MySQL不支持GIS这样的价值观POINT EMPTY

    ST_IsValid()处理它的参数在这章节的介绍,这个例外:

    • 如果几何图形有地理SRS与经度和纬度,超出范围,发生了一个错误:

      范围显示度。如果SRS使用另一个单位,范围在其单元采用相应的值。确切的范围稍微偏离由于浮点运算。

    mysql> SET @ls1 = ST_GeomFromText('LINESTRING(0 0,-0.00 0,0.0 0)');
    mysql> SET @ls2 = ST_GeomFromText('LINESTRING(0 0, 1 1)');
    mysql> SELECT ST_IsValid(@ls1);
    +------------------+
    | ST_IsValid(@ls1) |
    +------------------+
    |                0 |
    +------------------+
    mysql> SELECT ST_IsValid(@ls2);
    +------------------+
    | ST_IsValid(@ls2) |
    +------------------+
    |                1 |
    +------------------+
    
  • ST_MakeEnvelope(pt1, pt2)

    返回两点形式的包络矩形,作为Point线,或Polygon

    计算是通过使用笛卡儿坐标系统而不是一个球体,球体,或地球上。

    给定两个点pt1pt2ST_MakeEnvelope()造成这样的结果的一个抽象的平面几何:

    • 如果pt1pt2都是平等的,结果是点pt1

    • 否则,如果(pt1, pt2)是一个垂直或水平的直线段,其结果是线段pt1pt2

    • 否则,其结果是一个多边形的使用pt1pt2对角点

    结果有0个srID几何。

    ST_MakeEnvelope()处理它的参数在这章节的介绍,这些例外:

    MySQL的&#62;SET @pt1 = ST_GeomFromText('POINT(0 0)');MySQL的&#62;SET @pt2 = ST_GeomFromText('POINT(1 1)');MySQL的&#62;SELECT ST_AsText(ST_MakeEnvelope(@pt1, @pt2));---------------------------------------- | st_astext(st_makeenvelope(@ @ PT1,PT2))| ---------------------------------------- |多边形((0 0,1 0,1 0 1,0 0))| ----------------------------------------
  • ST_Simplify(g, max_distance)

    简化了几何使用Douglas Peucker算法并返回相同类型的一个简化的价值。

    几何可以是任何几何型,虽然Douglas Peucker算法实际上可能没有过程的每个类型。一个几何集合是通过给其组件之一的简化算法进行处理,将结果返回集合的几何构型。

    这个max_distance参数是距离(在输入坐标单位)的一个顶点到其他部分被删除。在这个距离的简化线顶点删除。

    根据增压。几何,几何可能由于简化过程变得无效,而过程可能会创建自相交。检查结果的有效性,通过它ST_IsValid()

    ST_Simplify()处理它的参数在这章节的介绍,这个例外:

    • 如果max_distance的说法是不积极的,或是,一个ER_WRONG_ARGUMENTS错误发生

    MySQL的&#62;SET @g = ST_GeomFromText('LINESTRING(0 0,0 1,1 1,1 2,2 2,2 3,3 3)');MySQL的&#62;SELECT ST_AsText(ST_Simplify(@g, 0.5));--------------------------------- | st_astext(st_simplify(@ G,0.5))| --------------------------------- |线(0 1 2 3,3,0)| --------------------------------- MySQL &#62;SELECT ST_AsText(ST_Simplify(@g, 1.0));--------------------------------- | st_astext(st_simplify(@ G,1.0))| --------------------------------- |线(0 0 3)| ---------------------------------
  • ST_Validate(g)

    验证几何根据OGC规范。一个几何可以合乎语法(WKB近似值加SRID)但几何无效。例如,这个多边形几何无效:POLYGON((0 0, 0 0, 0 0, 0 0, 0 0))

    ST_Validate()返回几何是否合乎语法,几何有效,无效的如果参数是不合乎语法或不合法或是几何NULL

    ST_Validate()可以用来过滤掉无效的几何数据,虽然在成本。对于需要更精确的结果不受无效数据的应用程序,这种惩罚可能是值得的。

    如果几何论证是有效的,它返回的是,如果一个输入Polygon多面有顺时针方向的环,这些环翻转前检查有效性。如果几何图形是有效的,与反环的返回值。

    唯一有效的空的几何是一个空的几何集合值的形式表示。ST_Validate()返回直接没有进一步检查在这种情况下。

    世纪之mysql 8.0.13,ST_Validate()处理它的参数在这章节的介绍,这些例外:

    • 如果几何图形有地理SRS与经度和纬度,超出范围,发生了一个错误:

      范围显示度。确切的范围稍微偏离由于浮点运算。

    MySQL 8.0.13之前,ST_Validate()处理它的参数在这章节的介绍,这些例外:

    MySQL的&#62;SET @ls1 = ST_GeomFromText('LINESTRING(0 0)');MySQL的&#62;SET @ls2 = ST_GeomFromText('LINESTRING(0 0, 1 1)');MySQL的&#62;SELECT ST_AsText(ST_Validate(@ls1));_ astext ------------------------------ |圣(圣_ validate(@ LS1)| ------------------------------ |零| ------------------------------ MySQL &#62;SELECT ST_AsText(ST_Validate(@ls2));------------------------------ | st_astext(st_validate(@ LS2))| ------------------------------ |线(0Ω1)| ------------------------------

12.16 JSON功能

本节中描述的功能执行操作JSON值。的讨论JSON数据类型和附加的例子展示了如何使用这些功能,看11.6节,“JSON数据类型”

的功能,把一个JSON参数,如果参数不是一个有效的JSON值时发生错误。参数解析JSON表示的json_doc题元表示市;val不分析

一套操作空间功能在GeoJSON值也可。看到第12.15.11,“空间GeoJSON功能”

12.16.1 JSON函数参考

表12.20 JSON功能

姓名描述
JSON_ARRAY()创建JSON数组
JSON_ARRAY_APPEND()JSON文件追加数据
JSON_ARRAY_INSERT()插入JSON数组
->在评估路径返回JSON列值;相当于json_extract()。
JSON_CONTAINS()是否包含特定对象的JSON文档路径
JSON_CONTAINS_PATH()无论是JSON文件包含任何数据路径
JSON_DEPTH()JSON文档的最大深度
JSON_EXTRACT()从JSON文档返回数据
->>在评估路径和结束引语结果返回JSON列值;相当于json_unquote(json_extract())。
JSON_INSERT()将数据插入到JSON文档
JSON_KEYS()从JSON文件密钥数组
JSON_LENGTH()在JSON文档中的元素数
JSON_MERGE()(弃用8.0.3)合并的JSON文件,保存重复键。不json_merge_preserve()的同义词
JSON_MERGE_PATCH()合并的JSON文件,免去重复键的值
JSON_MERGE_PRESERVE()合并的JSON文件,保存重复键
JSON_OBJECT()创建JSON对象
JSON_PRETTY()版画在人类可读的格式JSON文档,每个数组元素或对象成员打印在新的行中,缩进两个空格就其母。
JSON_QUOTE()引用JSON文档
JSON_REMOVE()从JSON文件中删除数据
JSON_REPLACE()在JSON文件的值替换
JSON_SEARCH()在JSON文件价值路径
JSON_SET()将数据插入到JSON文档
JSON_STORAGE_FREE()释放的空间在一个JSON列值的二进制表示形式后,局部更新
JSON_STORAGE_SIZE()用于一个JSON文件的二进制表示形式存储空间;一个JSON柱,空间时使用的文档插入到任何部分更新之前,
JSON_TABLE()返回的数据从一个JSON表达关系表
JSON_TYPE()JSON值类型
JSON_UNQUOTE()JSON值而言
JSON_VALID()JSON值是否是有效的

MySQL支持两种骨料JSON功能JSON_ARRAYAGG()JSON_OBJECTAGG()。看到12.19节,“总(组)功能”For Deselling of these .

MySQL也支持漂亮的印刷在一个易于阅读的格式JSON值,使用JSON_PRETTY()功能。你能看到多少存储空间的一个给定的JSON值占用,多少空间是额外的存储空间,使用JSON_STORAGE_SIZE()JSON_STORAGE_FREE(),分别。这些功能的完整描述,看第12.16.7,“JSON的效用函数”

12.16.2函数创建JSON值

本节中列出的功能构成JSON值从组成要素。

  • JSON_ARRAY([val[, val] ...])

    评价一个(可能为空)的值并返回一个包含这些值的JSON数组列表。

    mysql> SELECT JSON_ARRAY(1, "abc", NULL, TRUE, CURTIME());
    +---------------------------------------------+
    | JSON_ARRAY(1, "abc", NULL, TRUE, CURTIME()) |
    +---------------------------------------------+
    | [1, "abc", null, true, "11:30:24.000000"]   |
    +---------------------------------------------+
    
  • JSON_OBJECT([key, val[, key, val] ...])

    评价一个(可能为空)和返回键-值对列表包含那些对JSON对象。如果任何关键的名字是发生错误NULL或参数的个数是奇数

    MySQL的&#62;SELECT JSON_OBJECT('id', 87, 'name', 'carrot');_ -----------------------------------------(| JSON对象id,name是87,是胡萝卜,是| -----------------------------------------):87 | {“ID”,“name”,“胡萝卜”| ----------------------------------------- }
  • JSON_QUOTE(string)

    引用一个字符串用双引号字符和逃避与内部报价和其他字符JSON值,然后返回结果为utf8mb4字符串退货无效的如果参数是NULL

    这个函数通常用于产生一个有效的JSON字符串一个JSON文档中包含。

    某些特殊字符进行转义序列的反斜杠,每中逃脱表12.21,“json_unquote()特殊字符转义序列”

    mysql> SELECT JSON_QUOTE('null'), JSON_QUOTE('"null"');
    +--------------------+----------------------+
    | JSON_QUOTE('null') | JSON_QUOTE('"null"') |
    +--------------------+----------------------+
    | "null"             | "\"null\""           |
    +--------------------+----------------------+
    mysql> SELECT JSON_QUOTE('[1, 2, 3]');
    +-------------------------+
    | JSON_QUOTE('[1, 2, 3]') |
    +-------------------------+
    | "[1, 2, 3]"             |
    +-------------------------+
    

你也可以获得JSON值由其他类型的铸造价值JSON类型使用CAST(value AS JSON)它;JSON和非JSON值之间的转换为更多的信息

两个聚合函数生成JSON值是可用的。JSON_ARRAYAGG()返回一个结果集作为一个单一的JSON数组,和JSON_OBJECTAGG()返回一个结果集作为一个单一的JSON对象。有关更多信息,参见12.19节,“总(组)功能”

12.16.3功能搜索JSON值

本节中的函数执行搜索操作JSON值来提取数据,报表数据是否存在在他们的位置,或报告的数据在他们的路径。

  • JSON_CONTAINS(target, candidate[, path])

    表明通过返回1或0是否一个给定的candidateJSON文档是包含在一个targetJSON文档,或者一个path理由是提供候选人是否是在一个特定的目标路径的发现。退货无效的如果任一参数为NULL,或者如果路径参数不确定部分的目标文件。如果一个错误发生targetcandidate不是一个有效的JSON文档,或者path参数不是一个有效的路径表达式或包含***通配符

    只有是否存在数据的路径检查,使用JSON_CONTAINS_PATH()相反

    下面的规则定义的遏制:

    • 候选人数量是包含在目标标量的当且仅当它是可比的,都是平等的。如果他们有相同的两个标量值具有可比性JSON_TYPE()类型,与异常类型的值整数DECIMAL也彼此相媲美

    • 一个候选阵列包含在一个对象数组的当且仅当在候选的每一个元素都包含在一些目标元素。

    • 候选人nonarray包含在一个对象数组的当且仅当候选人是包含在一些目标元素。

    • 候选对象是包含在一个对象当且仅当每个关键的候选人有一个键具有相同的名称在目标和候选键所关联的值包含在目标键所关联的值。

    否则,候选值中不包含目标文件。

    mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
    mysql> SET @j2 = '1';
    mysql> SELECT JSON_CONTAINS(@j, @j2, '$.a');
    +-------------------------------+
    | JSON_CONTAINS(@j, @j2, '$.a') |
    +-------------------------------+
    |                             1 |
    +-------------------------------+
    mysql> SELECT JSON_CONTAINS(@j, @j2, '$.b');
    +-------------------------------+
    | JSON_CONTAINS(@j, @j2, '$.b') |
    +-------------------------------+
    |                             0 |
    +-------------------------------+
    
    mysql> SET @j2 = '{"d": 4}';
    mysql> SELECT JSON_CONTAINS(@j, @j2, '$.a');
    +-------------------------------+
    | JSON_CONTAINS(@j, @j2, '$.a') |
    +-------------------------------+
    |                             0 |
    +-------------------------------+
    mysql> SELECT JSON_CONTAINS(@j, @j2, '$.c');
    +-------------------------------+
    | JSON_CONTAINS(@j, @j2, '$.c') |
    +-------------------------------+
    |                             1 |
    +-------------------------------+
    
  • JSON_CONTAINS_PATH(json_doc, one_or_all, path[, path] ...)

    返回0或1,表明JSON文件包含的数据在一个给定的路径或路径。退货NULL如果任一参数为无效的。发生错误,如果json_doc参数不是一个有效的JSON文档,任何path参数不是一个有效的路径表达式,或one_or_all是不是“一”'all'

    检查在一条特定的值,使用JSON_CONTAINS()相反

    返回值是0,如果没有指定路径存在于文件。否则,返回值取决于one_or_all论点:

    • 'one':1如果至少一个路径存在于文件,否则为0。

    • 'all':1如果所有路径存在于文件,否则为0。

    MySQL的&#62;SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';MySQL的&#62;SELECT JSON_CONTAINS_PATH(@j, 'one', '$.a', '$.e');--------------------------------------------- | JSON _ contains _路径(一,J @,和美元,和美元)| --------------------------------------------- | --------------------------------------------- MySQL |>1SELECT JSON_CONTAINS_PATH(@j, 'all', '$.a', '$.e');--------------------------------------------- | json_contains_path(@ J,&#39;所有&#39;,&#39;一&#39;,&#39;美元。美元。E)| --------------------------------------------- | 0 | --------------------------------------------- MySQL &#62;SELECT JSON_CONTAINS_PATH(@j, 'one', '$.c.d');---------------------------------------- | json_contains_path(@ J,&#39;一&#39;,&#39;美元。C.”)| ---------------------------------------- | 1 | ---------------------------------------- MySQL &#62;SELECT JSON_CONTAINS_PATH(@j, 'one', '$.a.d');---------------------------------------- | JSON _ contains _路径(一,J”,.a.d美元)| ---------------------------------------- | | ---------------------------------------- 0
  • JSON_EXTRACT(json_doc, path[, path] ...)

    从一个JSON文档返回数据,选择从文件相匹配的部分path争论。退货无效的如果任一参数为NULL没有找到文件中的路径值。发生错误,如果json_doc参数不是一个有效的JSON文件或任何path参数不是一个有效的路径表达式。

    返回值是由所有的值相匹配的path争论。如果这是可能的,这些争论可以返回多个值,匹配值autowrapped为数组中的顺序对应于产生它们的路径。否则,返回值是单一匹配的值。

    MySQL的&#62;SELECT JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]');|小站JSON _提取物([ 10,20,30,40 ]”,“美元[ 1 ])|小站| 20 |小站MySQL &#62;SELECT JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]', '$[0]');* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *SELECT JSON_EXTRACT('[10, 20, [30, 40]]', '$[2][*]');Am I Json Control I ExtrAct(&#39; [ 10,20,[ 30,40 ] ] &#39;,&#39; s,&#39; $ [ 2 ] [ * ] &#39;)

    MySQL支持->运营商作为速记这个函数有2个参数的使用,左手边是一个JSON列标识(不表达),右边是匹配的列中的JSON路径。

  • column->path

    这个->运营商作为一个别名JSON_EXTRACT()当使用两个参数的函数,一列标识的左边和右边,评价对JSON文档的JSON路径(列值)。你可以在列的标识符的地方无论它们出现在SQL语句中使用这样的表达式。

    SELECT报表显示在这里产生相同的输出:

    MySQL的&#62;SELECT c, JSON_EXTRACT(c, "$.id"), g&#62;FROM jemp&#62;WHERE JSON_EXTRACT(c, "$.id") > 1&#62;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)mysql>SELECT c, c->"$.id", g&#62;FROM jemp&#62;WHERE c->"$.id" > 1&#62;ORDER BY c->"$.name";------------------------------- ----------- ------ | C | C - &#62;“美元。ID”| G | ------------------------------- ----------- ------ | {“id”:“3”,“name”:“巴尼”} |“3”| 3 | | {“id”:“4”,“name”:“贝蒂”} |“4”| 4 | | {“id”:“2”,“name”:“威尔玛”} |“2”| 2 | ------------------------------- ----------- ------ 3行集(0秒)

    此功能不限SELECT,如下所示:

    MySQL的&#62;ALTER TABLE jemp ADD COLUMN n INT;查询好,为受影响的行(0.68秒)记录:0 0副本:警告:0mysql &#62;UPDATE jemp SET n=1 WHERE c->"$.id" = "4";查询行,1行的影响(0.04秒)的行匹配:1改变:1警告:0mysql &#62;SELECT c, c->"$.id", g, n&#62;FROM jemp&#62;WHERE JSON_EXTRACT(c, "$.id") > 1&#62;ORDER BY c->"$.name";+-------------------------------+-----------+------+------+| c                             | c->"$.id" | g    | n    |+-------------------------------+-----------+------+------+| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL || {"id": "4", "name": "Betty"}  | "4"       |    4 |    1 || {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |+-------------------------------+-----------+------+------+3 rows in set (0.00 sec)mysql>DELETE FROM jemp WHERE c->"$.id" = "4";查询行,1行的影响(0.04秒)MySQL &#62;SELECT c, c->"$.id", g, n&#62;FROM jemp&#62;WHERE JSON_EXTRACT(c, "$.id") > 1&#62;ORDER BY c->"$.name";------------------------------- ----------- ------ ------ | C | C - &#62;“美元。ID”| G | N | ------------------------------- ----------- ------ ------ | {“id”:“3”,“name”:“巴尼”} |“3”| 3 |空| | {“id”:“2”,“姓名”:“威尔玛”} |“2”| 2 |空| ------------------------------- ----------- ------ ------ 2行集(0秒)

    (见索引生成的列提供一个JSON列索引,用于创建和填充上面的表的语句。)

    这与JSON数组值也可以,如下所示:

    mysql> CREATE TABLE tj10 (a JSON, b INT);
    Query OK, 0 rows affected (0.26 sec)
    
    mysql> INSERT INTO tj10
         > VALUES ("[3,10,5,17,44]", 33), ("[3,10,5,17,[22,44,66]]", 0);
    Query OK, 1 row affected (0.04 sec)
    
    mysql> SELECT a->"$[4]" FROM tj10;
    +--------------+
    | a->"$[4]"    |
    +--------------+
    | 44           |
    | [22, 44, 66] |
    +--------------+
    2 rows in set (0.00 sec)
    
    mysql> SELECT * FROM tj10 WHERE a->"$[0]" = 3;
    +------------------------------+------+
    | a                            | b    |
    +------------------------------+------+
    | [3, 10, 5, 17, 44]           |   33 |
    | [3, 10, 5, 17, [22, 44, 66]] |    0 |
    +------------------------------+------+
    2 rows in set (0.00 sec)
    

    嵌套数组的支持。表达式中使用->评估无效的如果没有匹配的关键是目标的JSON文档中找到,如下图所示:

    mysql> SELECT * FROM tj10 WHERE a->"$[4][1]" IS NOT NULL;
    +------------------------------+------+
    | a                            | b    |
    +------------------------------+------+
    | [3, 10, 5, 17, [22, 44, 66]] |    0 |
    +------------------------------+------+
    
    mysql> SELECT a->"$[4][1]" FROM tj10;
    +--------------+
    | a->"$[4][1]" |
    +--------------+
    | NULL         |
    | 44           |
    +--------------+
    2 rows in set (0.00 sec)
    

    这是行为视为在这种情况下,当使用相同的JSON_EXTRACT()

    MySQL的&#62;SELECT JSON_EXTRACT(a, "$[4][1]") FROM tj10;---------------------------- | json_extract(,$ [ 4 ] [ 1 ]”)| ---------------------------- |空| | 44 | ---------------------------- 2行集(0秒)
  • column->>path

    这是一个改进,结束引语提取算子。而->操作人员只需提取一个值的->>此外unquotes算子提取的结果。换句话说,给定一个JSON列值column和路径表达式path三,下列表达式返回相同的值:

    这个->>运营商可以使用的地方json_unquote(json_extract())将被允许。这包括(但不限于)SELECT列表,哪里HAVING条款,并顺序GROUP BY条款.

    接下来的几个报表展示->>算子等价与其他表达式MySQL客户:

    mysql> SELECT * FROM jemp WHERE g > 2;
    +-------------------------------+------+
    | c                             | g    |
    +-------------------------------+------+
    | {"id": "3", "name": "Barney"} |    3 |
    | {"id": "4", "name": "Betty"}  |    4 |
    +-------------------------------+------+
    2 rows in set (0.01 sec)
    
    mysql> SELECT c->'$.name' AS name
        ->     FROM jemp WHERE g > 2;
    +----------+
    | name     |
    +----------+
    | "Barney" |
    | "Betty"  |
    +----------+
    2 rows in set (0.00 sec)
    
    mysql> SELECT JSON_UNQUOTE(c->'$.name') AS name
        ->     FROM jemp WHERE g > 2;
    +--------+
    | name   |
    +--------+
    | Barney |
    | Betty  |
    +--------+
    2 rows in set (0.00 sec)
    
    mysql> SELECT c->>'$.name' AS name
        ->     FROM jemp WHERE g > 2;
    +--------+
    | name   |
    +--------+
    | Barney |
    | Betty  |
    +--------+
    2 rows in set (0.00 sec)
    

    看到索引生成的列提供一个JSON列索引为SQL语句,用于创建和填充jemp在上面的例子设置表

    这个操作也可以使用JSON数组,如下所示:

    mysql> CREATE TABLE tj10 (a JSON, b INT);
    Query OK, 0 rows affected (0.26 sec)
    
    mysql> INSERT INTO tj10 VALUES
        ->     ('[3,10,5,"x",44]', 33),
        ->     ('[3,10,5,17,[22,"y",66]]', 0);
    Query OK, 2 rows affected (0.04 sec)
    Records: 2  Duplicates: 0  Warnings: 0
    
    mysql> SELECT a->"$[3]", a->"$[4][1]" FROM tj10;
    +-----------+--------------+
    | a->"$[3]" | a->"$[4][1]" |
    +-----------+--------------+
    | "x"       | NULL         |
    | 17        | "y"          |
    +-----------+--------------+
    2 rows in set (0.00 sec)
    
    mysql> SELECT a->>"$[3]", a->>"$[4][1]" FROM tj10;
    +------------+---------------+
    | a->>"$[3]" | a->>"$[4][1]" |
    +------------+---------------+
    | x          | NULL          |
    | 17         | y             |
    +------------+---------------+
    2 rows in set (0.00 sec)
    

    ->,的->>运营商总是在输出扩展EXPLAIN,如下面的示例演示:

    MySQL的&#62;EXPLAIN SELECT c->>'$.name' AS name-&#62;FROM jemp WHERE g > 2\G*************************** 1。行***************************编号:1 select_type:简单表:jemp分区:null类型:rangepossible_keys:我:我key_len:5编号:零排:2过滤:额外100:用其中1行集,1报警(0秒)MySQL &#62;SHOW WARNINGS\G*************************** 1。行***************************水平:注意代码:1003message:/ *选择# 1 * / selectjson_unquote(json_extract(` Jtest `。` jemp `。` C `,“美元。名字))作为`名字`从` Jtest `。` jemp `哪里(` Jtest `。` jemp ` ` G `。&#62; 2)中1行集(0秒)

    这是类似于MySQL扩展->在同样的情况下操作

  • JSON_KEYS(json_doc[, path])

    返回键从一个JSON对象的顶层价值作为一个JSON数组,或者,如果path给出的说法是,从所选路径的顶层的钥匙。退货无效的如果任一参数为NULL,的json_doc参数不是一个对象,或path,如果没有找到一个对象。发生错误,如果json_doc参数不是一个有效的JSON文件或path参数不是一个有效的路径表达式或包含***通配符

    结果数组是空的如果选择的对象是空的。如果顶层有嵌套的子对象的值,返回值不包括这些子对象的键。

    mysql> SELECT JSON_KEYS('{"a": 1, "b": {"c": 30}}');
    +---------------------------------------+
    | JSON_KEYS('{"a": 1, "b": {"c": 30}}') |
    +---------------------------------------+
    | ["a", "b"]                            |
    +---------------------------------------+
    mysql> SELECT JSON_KEYS('{"a": 1, "b": {"c": 30}}', '$.b');
    +----------------------------------------------+
    | JSON_KEYS('{"a": 1, "b": {"c": 30}}', '$.b') |
    +----------------------------------------------+
    | ["c"]                                        |
    +----------------------------------------------+
    
  • JSON_SEARCH(json_doc, one_or_all, search_str[, escape_char[, path] ...])

    返回给定一个JSON文档中的字符串的路径。退货NULL如果有任何的json_docsearch_str,或path参数无效的;没有path存在于文件;或search_str没有找到。发生错误,如果json_doc参数不是一个有效的JSON文档,任何path参数不是一个有效的路径表达式,one_or_all是不是“一”'all',或escape_char不是一个常量表达式

    这个one_or_all参数影响搜索如下:

    • 'one'一:返回路径字符串的第一场比赛后终止搜索。它是不确定的,比赛是第一考虑。

    • 'all':搜索返回所有匹配的路径字符串,没有重复的路径包括。如果有多个字符串,他们是autowrapped作为数组。数组元素的顺序是不确定的。

    search_strSearch string string,the%_特征为LIKE运营商:%匹配任何数量的字符(包括零个字符),和_完全匹配一个字符

    指定文字%_搜索字符串中的字符,先于它的转义字符。默认值是\如果escape_char论点是丢失或无效的。否则,escape_char必须是一个常数,是空的或一个字符。

    有关更多信息和匹配转义字符的行为,看到的描述LIKE进入第12.5.1”字符串比较函数。转义字符处理,从不同LIKE行为是逃避的性格JSON_SEARCH()要评估一个常数在编译的时候,不只是在执行时间。例如,如果JSON_SEARCH()是用在一个准备好的声明和escape_char说法是提供使用参数,参数值可能是恒定的执行时间,而不是在编译时。

    mysql> SET @j = '["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}]';
    
    mysql> SELECT JSON_SEARCH(@j, 'one', 'abc');
    +-------------------------------+
    | JSON_SEARCH(@j, 'one', 'abc') |
    +-------------------------------+
    | "$[0]"                        |
    +-------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', 'abc');
    +-------------------------------+
    | JSON_SEARCH(@j, 'all', 'abc') |
    +-------------------------------+
    | ["$[0]", "$[2].x"]            |
    +-------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', 'ghi');
    +-------------------------------+
    | JSON_SEARCH(@j, 'all', 'ghi') |
    +-------------------------------+
    | NULL                          |
    +-------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', '10');
    +------------------------------+
    | JSON_SEARCH(@j, 'all', '10') |
    +------------------------------+
    | "$[1][0].k"                  |
    +------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$');
    +-----------------------------------------+
    | JSON_SEARCH(@j, 'all', '10', NULL, '$') |
    +-----------------------------------------+
    | "$[1][0].k"                             |
    +-----------------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$[*]');
    +--------------------------------------------+
    | JSON_SEARCH(@j, 'all', '10', NULL, '$[*]') |
    +--------------------------------------------+
    | "$[1][0].k"                                |
    +--------------------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$**.k');
    +---------------------------------------------+
    | JSON_SEARCH(@j, 'all', '10', NULL, '$**.k') |
    +---------------------------------------------+
    | "$[1][0].k"                                 |
    +---------------------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$[*][0].k');
    +-------------------------------------------------+
    | JSON_SEARCH(@j, 'all', '10', NULL, '$[*][0].k') |
    +-------------------------------------------------+
    | "$[1][0].k"                                     |
    +-------------------------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$[1]');
    +--------------------------------------------+
    | JSON_SEARCH(@j, 'all', '10', NULL, '$[1]') |
    +--------------------------------------------+
    | "$[1][0].k"                                |
    +--------------------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$[1][0]');
    +-----------------------------------------------+
    | JSON_SEARCH(@j, 'all', '10', NULL, '$[1][0]') |
    +-----------------------------------------------+
    | "$[1][0].k"                                   |
    +-----------------------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', 'abc', NULL, '$[2]');
    +---------------------------------------------+
    | JSON_SEARCH(@j, 'all', 'abc', NULL, '$[2]') |
    +---------------------------------------------+
    | "$[2].x"                                    |
    +---------------------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', '%a%');
    +-------------------------------+
    | JSON_SEARCH(@j, 'all', '%a%') |
    +-------------------------------+
    | ["$[0]", "$[2].x"]            |
    +-------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', '%b%');
    +-------------------------------+
    | JSON_SEARCH(@j, 'all', '%b%') |
    +-------------------------------+
    | ["$[0]", "$[2].x", "$[3].y"]  |
    +-------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', '%b%', NULL, '$[0]');
    +---------------------------------------------+
    | JSON_SEARCH(@j, 'all', '%b%', NULL, '$[0]') |
    +---------------------------------------------+
    | "$[0]"                                      |
    +---------------------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', '%b%', NULL, '$[2]');
    +---------------------------------------------+
    | JSON_SEARCH(@j, 'all', '%b%', NULL, '$[2]') |
    +---------------------------------------------+
    | "$[2].x"                                    |
    +---------------------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', '%b%', NULL, '$[1]');
    +---------------------------------------------+
    | JSON_SEARCH(@j, 'all', '%b%', NULL, '$[1]') |
    +---------------------------------------------+
    | NULL                                        |
    +---------------------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', '%b%', '', '$[1]');
    +-------------------------------------------+
    | JSON_SEARCH(@j, 'all', '%b%', '', '$[1]') |
    +-------------------------------------------+
    | NULL                                      |
    +-------------------------------------------+
    
    mysql> SELECT JSON_SEARCH(@j, 'all', '%b%', '', '$[3]');
    +-------------------------------------------+
    | JSON_SEARCH(@j, 'all', '%b%', '', '$[3]') |
    +-------------------------------------------+
    | "$[3].y"                                  |
    +-------------------------------------------+
    

    关于支持mysql的JSON路径语法的更多信息,包括有关通配符运算符规则** *,看到第12.16.8,“JSON语法路径”

12.16.4函数修改JSON值

本节中的函数修改JSON值并返回结果。

  • JSON_ARRAY_APPEND(json_doc, path, val[, path, val] ...)

    附加值的显示阵列端JSON文档中并返回结果。退货NULL如果任一参数为无效的。发生错误,如果json_doc参数不是一个有效的JSON文件或任何path参数不是一个有效的路径表达式或包含***通配符

    路径值对评估左到右。该文件由一对新的价值评估成为对未来对评价。

    如果路径选择一个标量或对象的价值,价值是autowrapped在阵列和新值添加到阵列。对路径不确定在JSON文档的任何值被忽略。

    mysql> SET @j = '["a", ["b", "c"], "d"]';
    mysql> SELECT JSON_ARRAY_APPEND(@j, '$[1]', 1);
    +----------------------------------+
    | JSON_ARRAY_APPEND(@j, '$[1]', 1) |
    +----------------------------------+
    | ["a", ["b", "c", 1], "d"]        |
    +----------------------------------+
    mysql> SELECT JSON_ARRAY_APPEND(@j, '$[0]', 2);
    +----------------------------------+
    | JSON_ARRAY_APPEND(@j, '$[0]', 2) |
    +----------------------------------+
    | [["a", 2], ["b", "c"], "d"]      |
    +----------------------------------+
    mysql> SELECT JSON_ARRAY_APPEND(@j, '$[1][0]', 3);
    +-------------------------------------+
    | JSON_ARRAY_APPEND(@j, '$[1][0]', 3) |
    +-------------------------------------+
    | ["a", [["b", 3], "c"], "d"]         |
    +-------------------------------------+
    
    mysql> SET @j = '{"a": 1, "b": [2, 3], "c": 4}';
    mysql> SELECT JSON_ARRAY_APPEND(@j, '$.b', 'x');
    +------------------------------------+
    | JSON_ARRAY_APPEND(@j, '$.b', 'x')  |
    +------------------------------------+
    | {"a": 1, "b": [2, 3, "x"], "c": 4} |
    +------------------------------------+
    mysql> SELECT JSON_ARRAY_APPEND(@j, '$.c', 'y');
    +--------------------------------------+
    | JSON_ARRAY_APPEND(@j, '$.c', 'y')    |
    +--------------------------------------+
    | {"a": 1, "b": [2, 3], "c": [4, "y"]} |
    +--------------------------------------+
    
    mysql> SET @j = '{"a": 1}';
    mysql> SELECT JSON_ARRAY_APPEND(@j, '$', 'z');
    +---------------------------------+
    | JSON_ARRAY_APPEND(@j, '$', 'z') |
    +---------------------------------+
    | [{"a": 1}, "z"]                 |
    +---------------------------------+
    

    在MySQL 5.7中,这个功能被命名为JSON_APPEND()。那个名字不再支持MySQL 5.0。

  • JSON_ARRAY_INSERT(json_doc, path, val[, path, val] ...)

    更新一个JSON文档,在文档中插入一个数组并返回修改的文档。退货NULL如果任一参数为无效的。发生错误,如果json_doc参数不是一个有效的JSON文件或任何path参数不是一个有效的路径表达式或包含***通配符或没有结束的一个数组元素的标识符。

    路径值对评估左到右。该文件由一对新的价值评估成为对未来对评价。

    对路径不确定在JSON文档的任何数组被忽略。如果路径标识一个数组元素,相应的值插入到元素的位置,将以下任何值的权利。如果路径标识一个阵列位置超出数组末端,值插入到数组的末尾。

    mysql> SET @j = '["a", {"b": [1, 2]}, [3, 4]]';
    mysql> SELECT JSON_ARRAY_INSERT(@j, '$[1]', 'x');
    +------------------------------------+
    | JSON_ARRAY_INSERT(@j, '$[1]', 'x') |
    +------------------------------------+
    | ["a", "x", {"b": [1, 2]}, [3, 4]]  |
    +------------------------------------+
    mysql> SELECT JSON_ARRAY_INSERT(@j, '$[100]', 'x');
    +--------------------------------------+
    | JSON_ARRAY_INSERT(@j, '$[100]', 'x') |
    +--------------------------------------+
    | ["a", {"b": [1, 2]}, [3, 4], "x"]    |
    +--------------------------------------+
    mysql> SELECT JSON_ARRAY_INSERT(@j, '$[1].b[0]', 'x');
    +-----------------------------------------+
    | JSON_ARRAY_INSERT(@j, '$[1].b[0]', 'x') |
    +-----------------------------------------+
    | ["a", {"b": ["x", 1, 2]}, [3, 4]]       |
    +-----------------------------------------+
    mysql> SELECT JSON_ARRAY_INSERT(@j, '$[2][1]', 'y');
    +---------------------------------------+
    | JSON_ARRAY_INSERT(@j, '$[2][1]', 'y') |
    +---------------------------------------+
    | ["a", {"b": [1, 2]}, [3, "y", 4]]     |
    +---------------------------------------+
    mysql> SELECT JSON_ARRAY_INSERT(@j, '$[0]', 'x', '$[2][1]', 'y');
    +----------------------------------------------------+
    | JSON_ARRAY_INSERT(@j, '$[0]', 'x', '$[2][1]', 'y') |
    +----------------------------------------------------+
    | ["x", "a", {"b": [1, 2]}, [3, 4]]                  |
    +----------------------------------------------------+
    

    早期的修改影响数组中元素的位置后,在相同的所以后续路径JSON_ARRAY_INSERT()电话应该考虑到这。在最后一个例子中,第二路径插入没有因为路径不再匹配任何第一插入后。

  • JSON_INSERT(json_doc, path, val[, path, val] ...)

    将数据插入到一个JSON文件并返回结果。退货NULL如果任一参数为无效的。发生错误,如果json_doc参数不是一个有效的JSON文件或任何path参数不是一个有效的路径表达式或包含***通配符

    路径值对评估左到右。该文件由一对新的价值评估成为对未来对评价。

    一个文档中原有的路径值对被忽视和不覆盖现有的文献价值。一个不存在的路径在路径的文件值对加值的文件如果路径识别这些类型的值:

    • 一件不在现有的对象存在。成员添加到对象和新的价值关联。

    • 过去的现有数组的结束位置。阵列扩展与新价值。如果现有的价值不是一个数组,它是autowrapped作为一个数组,然后扩展与新价值。

    否则,一个不存在的路径在路径的文件值对被忽视和没有影响。

    一个比较JSON_INSERT()JSON_REPLACE(),和JSON_SET(),见的讨论JSON_SET()

    MySQL的&#62;SET @j = '{ "a": 1, "b": [2, 3]}';MySQL的&#62;SELECT JSON_INSERT(@j, '$.a', 10, '$.c', '[true, false]');---------------------------------------------------- | JSON _ insert(@美元J,T,C,10美元,是真是假,[,])| ---------------------------------------------------- | {“a”:1、“B”:[ 2,3 ],“C”:“[假]真的,”| ---------------------------------------------------- }

    在结果中列出最后的值是一个字符串数组和不喜欢第二个(不输出引用);没有铸造值到JSON类型进行。将数组作为一个数组,你必须进行这样的转换明确,如下所示:

    mysql> SELECT JSON_INSERT(@j, '$.a', 10, '$.c', CAST('[true, false]' AS JSON));
    +------------------------------------------------------------------+
    | JSON_INSERT(@j, '$.a', 10, '$.c', CAST('[true, false]' AS JSON)) |
    +------------------------------------------------------------------+
    | {"a": 1, "b": [2, 3], "c": [true, false]}                        |
    +------------------------------------------------------------------+
    1 row in set (0.00 sec)
    
  • JSON_MERGE(json_doc, json_doc[, json_doc] ...)

    合并两个或两个以上的JSON文件。同义词JSON_MERGE_PRESERVE();在MySQL 8.0.3和主题在未来的版本中去除过时的。

    MySQL的&#62;SELECT JSON_MERGE('[1, 2]', '[true, false]');| --------------------------------------- JSON _ MERGE(〔1,2〕,〔〕是真是假,| --------------------------------------- |)〔1,2〕,真实,虚假| --------------------------------------- 1行集(0秒)1预警,数据库SHOW WARNINGS\G*************************** 1。行***************************水平:报警代码:1287message:“json_merge是过时的、将在未来的版本中删除。请使用json_merge_preserve / json_merge_patch instead1行集(0秒)

    额外的例子,参见条目JSON_MERGE_PRESERVE()

  • JSON_MERGE_PATCH(json_doc, json_doc[, json_doc] ...)

    执行一个RFC 7396兼容合并两个或两个以上的JSON文件并返回合并后的结果,没有保留有重复键成员。提出了一个错误,如果在作为这个函数的参数传递的文件至少有一个是无效的。

    笔记

    为之间的这种功能差异的解释和例子JSON_MERGE_PRESERVE(),看到json_merge_patch()相比json_merge_preserve()

    JSON_MERGE_PATCH()执行合并如下:

    1. 如果第一个参数不是一个对象,合并的结果是如果一个空的对象已经和第二个参数合并相同。

    2. 如果第二个参数不是一个对象,合并的结果是第二。

    3. 如果参数是对象,合并的结果是与以下对象的成员:

      • 其中不与第二对象相同的键有一个相应的部件的第一对象的所有成员。

      • 已不在第一个对象相应的关键的第二对象的所有成员,其价值不是JSONnull字面意义的.

      • 所有成员的关键在第一和第二对象存在,且在第二对象的价值不是JSONnull字面意义的.这些成员的值结果递归合并中的值与第二对象的值的第一个对象。

    更多信息,参见规范化,合并,和autowrapping JSON值

    mysql> SELECT JSON_MERGE_PATCH('[1, 2]', '[true, false]');
    +---------------------------------------------+
    | JSON_MERGE_PATCH('[1, 2]', '[true, false]') |
    +---------------------------------------------+
    | [true, false]                               |
    +---------------------------------------------+
    
    mysql> SELECT JSON_MERGE_PATCH('{"name": "x"}', '{"id": 47}');
    +-------------------------------------------------+
    | JSON_MERGE_PATCH('{"name": "x"}', '{"id": 47}') |
    +-------------------------------------------------+
    | {"id": 47, "name": "x"}                         |
    +-------------------------------------------------+
    
    mysql> SELECT JSON_MERGE_PATCH('1', 'true');
    +-------------------------------+
    | JSON_MERGE_PATCH('1', 'true') |
    +-------------------------------+
    | true                          |
    +-------------------------------+
    
    mysql> SELECT JSON_MERGE_PATCH('[1, 2]', '{"id": 47}');
    +------------------------------------------+
    | JSON_MERGE_PATCH('[1, 2]', '{"id": 47}') |
    +------------------------------------------+
    | {"id": 47}                               |
    +------------------------------------------+
    
    mysql> SELECT JSON_MERGE_PATCH('{ "a": 1, "b":2 }',
         >     '{ "a": 3, "c":4 }');
    +-----------------------------------------------------------+
    | JSON_MERGE_PATCH('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }') |
    +-----------------------------------------------------------+
    | {"a": 3, "b": 2, "c": 4}                                  |
    +-----------------------------------------------------------+
    
    mysql> SELECT JSON_MERGE_PATCH('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }',
         >     '{ "a": 5, "d":6 }');
    +-------------------------------------------------------------------------------+
    | JSON_MERGE_PATCH('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }','{ "a": 5, "d":6 }') |
    +-------------------------------------------------------------------------------+
    | {"a": 5, "b": 2, "c": 4, "d": 6}                                              |
    +-------------------------------------------------------------------------------+
    

    可以使用此函数来指定删除成员null作为同一成员在二参数的值,如下所示:

    MySQL的&#62;SELECT JSON_MERGE_PATCH('{"a":1, "b":2}', '{"b":null}');-------------------------------------------------- | JSON _ MERGE _补丁(“A”:{1,2}:“b”,“B”:空{ }){“a”| -------------------------------------------------- | | -------------------------------------------------- 1 }:

    这个例子表明,功能以递归方式;即值的成员不限于标量,而是本身可以是JSON文件:

    mysql> SELECT JSON_MERGE_PATCH('{"a":{"x":1}}', '{"a":{"y":2}}');
    +----------------------------------------------------+
    | JSON_MERGE_PATCH('{"a":{"x":1}}', '{"a":{"y":2}}') |
    +----------------------------------------------------+
    | {"a": {"x": 1, "y": 2}}                            |
    +----------------------------------------------------+
    

    JSON_MERGE_PATCH()在MySQL 8.0.3支持和后。

    _ MERGE _补丁(JSON)compared与JSON _ MERGE _(preserve)。的行为JSON_MERGE_PATCH()是相同的JSON_MERGE_PRESERVE(),具有以下两个例外:

    • JSON_MERGE_PATCH()删除第二对象匹配的关键在第一个对象的任何成员,但在第二对象的键所关联的值不是JSON无效的

    • 如果第二对象有一个关键成员在第一个对象成员,JSON_MERGE_PATCH()取代在第二对象的值的第一个对象的值,而JSON_MERGE_PRESERVE()追加到第一个值的二值

    这个例子比较合并3个相同的JSON对象的结果,每一个都有一个匹配的关键"a",每个这两种功能:

    MySQL的&#62;SET @x = '{ "a": 1, "b": 2 }',&#62;@y = '{ "a": 3, "c": 4 }',&#62;@z = '{ "a": 5, "d": 6 }';MySQL的&#62;SELECT  JSON_MERGE_PATCH(@x, @y, @z)    AS Patch,-&#62;JSON_MERGE_PRESERVE(@x, @y, @z) AS Preserve\G*************************** 1。行***************************补丁:{“”:5,“B”:2,“C”:4,“D”:6 }保存:{“”:[ 1,3,5 ],“B”:2,“C”:4,“D”:6 }
  • JSON_MERGE_PRESERVE(json_doc, json_doc[, json_doc] ...)

    合并两个或两个以上的JSON文件并返回合并后的结果。退货NULL如果任一参数为无效的。如果参数不是一个有效的JSON文件发生错误。

    合并将根据以下规则。更多信息,参见规范化,合并,和autowrapping JSON值

    • 邻接矩阵合并到一个单一的阵列。

    • 相邻的对象合并到一个单一的对象。

    • 标量值autowrapped作为数组合并为一个数组。

    • 相邻的数组和对象的autowrapping对象作为数组合并两个数组合并。

    mysql> SELECT JSON_MERGE_PRESERVE('[1, 2]', '[true, false]');
    +------------------------------------------------+
    | JSON_MERGE_PRESERVE('[1, 2]', '[true, false]') |
    +------------------------------------------------+
    | [1, 2, true, false]                            |
    +------------------------------------------------+
    
    mysql> SELECT JSON_MERGE_PRESERVE('{"name": "x"}', '{"id": 47}');
    +----------------------------------------------------+
    | JSON_MERGE_PRESERVE('{"name": "x"}', '{"id": 47}') |
    +----------------------------------------------------+
    | {"id": 47, "name": "x"}                            |
    +----------------------------------------------------+
    
    mysql> SELECT JSON_MERGE_PRESERVE('1', 'true');
    +----------------------------------+
    | JSON_MERGE_PRESERVE('1', 'true') |
    +----------------------------------+
    | [1, true]                        |
    +----------------------------------+
    
    mysql> SELECT JSON_MERGE_PRESERVE('[1, 2]', '{"id": 47}');
    +---------------------------------------------+
    | JSON_MERGE_PRESERVE('[1, 2]', '{"id": 47}') |
    +---------------------------------------------+
    | [1, 2, {"id": 47}]                          |
    +---------------------------------------------+
    
    mysql> SELECT JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }',
         >    '{ "a": 3, "c": 4 }');
    +--------------------------------------------------------------+
    | JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }','{ "a": 3, "c":4 }') |
    +--------------------------------------------------------------+
    | {"a": [1, 3], "b": 2, "c": 4}                                |
    +--------------------------------------------------------------+
    
    mysql> SELECT JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }','{ "a": 3, "c": 4 }',
         >    '{ "a": 5, "d": 6 }');
    +----------------------------------------------------------------------------------+
    | JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }','{ "a": 3, "c": 4 }','{ "a": 5, "d": 6 }') |
    +----------------------------------------------------------------------------------+
    | {"a": [1, 3, 5], "b": 2, "c": 4, "d": 6}                                         |
    +----------------------------------------------------------------------------------+
    

    这个功能在MySQL 8.0.3添加为同义词JSON_MERGE()。这个JSson MERGE()功能现在已经过时,并须在未来版本的MySQL的去除。

    这个功能是类似但不同于JSON_MERGE_PATCH()在重要的方面;看json_merge_patch()相比json_merge_preserve()为更多的信息

  • JSON_REMOVE(json_doc, path[, path] ...)

    将数据从一个JSON文件并返回结果。退货NULL如果任一参数为无效的。发生错误,如果json_doc参数不是一个有效的JSON文件或任何path参数不是一个有效的路径或是美元金中包含的** *通配符

    这个path参数是从左向右计算。通过评估一个路径产生的文件成为新的价值对未来路径的评估。

    如果要被删除的元素不存在的文件是不是一个错误;在这种情况下,不影响文件的路径。

    mysql> SET @j = '["a", ["b", "c"], "d"]';
    mysql> SELECT JSON_REMOVE(@j, '$[1]');
    +-------------------------+
    | JSON_REMOVE(@j, '$[1]') |
    +-------------------------+
    | ["a", "d"]              |
    +-------------------------+
    
  • JSON_REPLACE(json_doc, path, val[, path, val] ...)

    替换现有的值在一个JSON文件并返回结果。退货NULL如果任一参数为无效的。发生错误,如果json_doc参数不是一个有效的JSON文件或任何path参数不是一个有效的路径表达式或包含***通配符

    路径值对评估左到右。该文件由一对新的价值评估成为对未来对评价。

    一个文档中原有的路径值对覆盖现有的文献价值与新价值。一个不存在的路径在路径的文件值对被忽视和没有影响。

    在MySQL 8.0.4,优化器可以执行部分,在一个地方更新JSON而不是删除旧文件并写入新的文件在其整体柱。这种优化可以使用UPDATE语句的执行JSON_REPLACE()功能概述和满足的条件JSON值部分更新

    一个比较JSON_INSERT()JSON_REPLACE(),和JSON_SET(),见的讨论JSON_SET()

    MySQL的&#62;SET @j = '{ "a": 1, "b": [2, 3]}';MySQL的&#62;SELECT JSON_REPLACE(@j, '$.a', 10, '$.c', '[true, false]');| ----------------------------------------------------- JSON _ replace(@美元J,T,C,10美元,是真是假,[,])| ----------------------------------------------------- | {:“10”,“B”:〔2,3〕}| -----------------------------------------------------
  • JSON_SET(json_doc, path, val[, path, val] ...)

    插入或更新的数据在一个JSON文件并返回结果。退货NULL如果任一参数为无效的path,如果没有找到一个对象。发生错误,如果json_doc参数不是一个有效的JSON文件或任何path参数不是一个有效的路径表达式或包含***通配符

    路径值对评估左到右。该文件由一对新的价值评估成为对未来对评价。

    一个文档中原有的路径值对覆盖现有的文献价值与新价值。一个不存在的路径在路径的文件值对加值的文件如果路径识别这些类型的值:

    • 一件不在现有的对象存在。成员添加到对象和新的价值关联。

    • 过去的现有数组的结束位置。阵列扩展与新价值。如果现有的价值不是一个数组,它是autowrapped作为一个数组,然后扩展与新价值。

    否则,一个不存在的路径在路径的文件值对被忽视和没有影响。

    在MySQL 8.0.4,优化器可以执行部分,在一个地方更新JSON而不是删除旧文件并写入新的文件在其整体柱。这种优化可以使用UPDATE语句的执行JSON_SET()功能概述和满足的条件JSON值部分更新

    这个JSON_SET()JSON_INSERT(),和JSON_REPLACE()功能相关:

    下面的例子说明这些差异,使用一个路径,并在文件中存在($.a)和另一个不存在的(C美元):

    mysql> SET @j = '{ "a": 1, "b": [2, 3]}';
    mysql> SELECT JSON_SET(@j, '$.a', 10, '$.c', '[true, false]');
    +-------------------------------------------------+
    | JSON_SET(@j, '$.a', 10, '$.c', '[true, false]') |
    +-------------------------------------------------+
    | {"a": 10, "b": [2, 3], "c": "[true, false]"}    |
    +-------------------------------------------------+
    mysql> SELECT JSON_INSERT(@j, '$.a', 10, '$.c', '[true, false]');
    +----------------------------------------------------+
    | JSON_INSERT(@j, '$.a', 10, '$.c', '[true, false]') |
    +----------------------------------------------------+
    | {"a": 1, "b": [2, 3], "c": "[true, false]"}        |
    +----------------------------------------------------+
    mysql> SELECT JSON_REPLACE(@j, '$.a', 10, '$.c', '[true, false]');
    +-----------------------------------------------------+
    | JSON_REPLACE(@j, '$.a', 10, '$.c', '[true, false]') |
    +-----------------------------------------------------+
    | {"a": 10, "b": [2, 3]}                              |
    +-----------------------------------------------------+
    
  • JSON_UNQUOTE(json_val)

    unquotes JSON值并返回结果utf8mb4字符串退货无效的如果参数是NULL。如果值的开始和结束与双引号,但不是一个有效的JSON字符串时发生错误。

    在一个字符串序列,一定有特殊的意义,除非NO_BACKSLASH_ESCAPESSQL模式启用。这些序列从一个反斜杠(\众所周知,英语)转义字符。MySQL中的转义序列识别表12.21,“json_unquote()特殊字符转义序列”。对于所有其他的转义序列,反斜杠被忽略。这是逃跑的字符被解释为如果不逃。例如,\x只是X。这些序列是敏感的。例如,\b被解释为一个退格,但\b被解释为B

    表1221 json_unquote()特殊字符转义序列

    转义序列代表的序列特征
    \"双引号(")字符
    \b退格字符
    \f一个进纸字符
    \n在newline(linefeed)字符
    \r一个回车符
    \t一个制表符
    \\一个反斜杠(\)字符
    \uXXXXgb3212字节Unicode值XXXX

    该功能的使用两个简单的例子,如下所示:

    mysql> SET @j = '"abc"';
    mysql> SELECT @j, JSON_UNQUOTE(@j);
    +-------+------------------+
    | @j    | JSON_UNQUOTE(@j) |
    +-------+------------------+
    | "abc" | abc              |
    +-------+------------------+
    mysql> SET @j = '[1, 2, 3]';
    mysql> SELECT @j, JSON_UNQUOTE(@j);
    +-----------+------------------+
    | @j        | JSON_UNQUOTE(@j) |
    +-----------+------------------+
    | [1, 2, 3] | [1, 2, 3]        |
    +-----------+------------------+
    

    下面的例子显示了如何JSON_UNQUOTE处理越狱NO_BACKSLASH_ESCAPES禁用和启用:

    MySQL的&#62;SELECT @@sql_mode;------------ | @ @ sql_mode | ------------ | | ------------ MySQL &#62;SELECT JSON_UNQUOTE('"\\t\\u0032"');------------------------------ | JSON _ unquote(“T u0032 \\ \\”)| ------------------------------ | ------------------------------ MySQL |>2SET @@sql_mode = 'NO_BACKSLASH_ESCAPES';MySQL的&#62;SELECT JSON_UNQUOTE('"\\t\\u0032"');------------------------------ | JSON _ unquote(“T u0032 \\ \\”)| ------------------------------ | t\ u0032 | &#62; ------------------------------ MySQLSELECT JSON_UNQUOTE('"\t\u0032"');JSON(_ unquote | ----------------------------“t\ u0032”2)| ---------------------------- | | ----------------------------

12.16.5函数返回JSON值属性

在这一部分的属性值的函数返回的JSON。

  • JSON_DEPTH(json_doc)

    返回一个JSON文档的最大深度。退货NULL如果参数是无效的。如果参数不是一个有效的JSON文件发生错误。

    一个空数组,空的对象,或标量值深度1。一个非空数组只包含元素深度1或空含深度只有1成员的值对象有深度2。否则,一个JSON文档有深度大于2。

    mysql> SELECT JSON_DEPTH('{}'), JSON_DEPTH('[]'), JSON_DEPTH('true');
    +------------------+------------------+--------------------+
    | JSON_DEPTH('{}') | JSON_DEPTH('[]') | JSON_DEPTH('true') |
    +------------------+------------------+--------------------+
    |                1 |                1 |                  1 |
    +------------------+------------------+--------------------+
    mysql> SELECT JSON_DEPTH('[10, 20]'), JSON_DEPTH('[[], {}]');
    +------------------------+------------------------+
    | JSON_DEPTH('[10, 20]') | JSON_DEPTH('[[], {}]') |
    +------------------------+------------------------+
    |                      2 |                      2 |
    +------------------------+------------------------+
    mysql> SELECT JSON_DEPTH('[10, {"a": 20}]');
    +-------------------------------+
    | JSON_DEPTH('[10, {"a": 20}]') |
    +-------------------------------+
    |                             3 |
    +-------------------------------+
    
  • JSON_LENGTH(json_doc[, path])

    返回一个JSON文件的长度,如果path给出的说法是,该文件的路径确定的范围内的值的长度。退货无效的如果任一参数为NULLpath参数不确定文档中的价值。发生错误,如果json_doc参数不是一个有效的JSON文件或path参数不是一个有效的路径表达式或包含***通配符

    一个文件的长度决定如下:

    • 一个标量的长度是1

    • 数组的长度是数组元素的个数。

    • 一个物体的长度是对象成员的数量。

    • 长度不算长的嵌套数组或对象。

    mysql> SELECT JSON_LENGTH('[1, 2, {"a": 3}]');
    +---------------------------------+
    | JSON_LENGTH('[1, 2, {"a": 3}]') |
    +---------------------------------+
    |                               3 |
    +---------------------------------+
    mysql> SELECT JSON_LENGTH('{"a": 1, "b": {"c": 30}}');
    +-----------------------------------------+
    | JSON_LENGTH('{"a": 1, "b": {"c": 30}}') |
    +-----------------------------------------+
    |                                       2 |
    +-----------------------------------------+
    mysql> SELECT JSON_LENGTH('{"a": 1, "b": {"c": 30}}', '$.b');
    +------------------------------------------------+
    | JSON_LENGTH('{"a": 1, "b": {"c": 30}}', '$.b') |
    +------------------------------------------------+
    |                                              1 |
    +------------------------------------------------+
    
  • JSON_TYPE(json_val)

    返回一个utf8mb4一个JSON字符串表示的值的类型。这可以是一个对象,数组,或一个标量类型,如下所示:

    MySQL的&#62;SET @j = '{"a": [10, true]}';MySQL的&#62;SELECT JSON_TYPE(@j);————————————————————————————————————SELECT JSON_TYPE(JSON_EXTRACT(@j, '$.a'));------------------------------------ | json_type(json_extract(“J”美元。&#39;))| ------------------------------------ |阵列| ------------------------------------ MySQL &#62;SELECT JSON_TYPE(JSON_EXTRACT(@j, '$.a[0]'));Json Json Type(Json Cooperation Extrat(@ j,$ . a [ 0 ])ention of the United Nations Environment ProceedingsSELECT JSON_TYPE(JSON_EXTRACT(@j, '$.a[1]'));我的意思是,我的意思是,我的意思是…………………………………

    JSON_TYPE()退货无效的如果参数是NULL

    MySQL的&#62;SELECT JSON_TYPE(NULL);--------------------- | JSON _型零(零)| --------------------- | | ---------------------

    如果参数不是一个有效的JSON值时发生错误:

    mysql> SELECT JSON_TYPE(1);
    ERROR 3146 (22032): Invalid data type for JSON data in argument 1
    to function json_type; a JSON string or JSON type is required.
    

    是非NULL,非错误的结果,下面的列表描述了可能的JSON_TYPE()返回值:

  • JSON_VALID(val)

    返回0或1指示值是否是有效的JSON。退货NULL如果参数是无效的

    mysql> SELECT JSON_VALID('{"a": 1}');
    +------------------------+
    | JSON_VALID('{"a": 1}') |
    +------------------------+
    |                      1 |
    +------------------------+
    mysql> SELECT JSON_VALID('hello'), JSON_VALID('"hello"');
    +---------------------+-----------------------+
    | JSON_VALID('hello') | JSON_VALID('"hello"') |
    +---------------------+-----------------------+
    |                   0 |                     1 |
    +---------------------+-----------------------+
    

12.16.6 JSON表功能

本节包含JSON函数将JSON数据表格的数据信息。在MySQL 8.0.4之后,这样的一个功能—JSON_TABLE()-支持

  • JSON_TABLE(expr, path COLUMNS (column_list) [AS] alias)

    从一个JSON文件中提取数据并将它作为一个具有指定列的关系表。本函数的完整语法如下所示:

    JSON_TABLE(
        expr,
        path COLUMNS (column_list)
    )   [AS] alias
    
    column_list:
        column[, column][, ...]
    
    column:
        name FOR ORDINALITY
        |  name type PATH string path [on_error] [on_empty]
        |  name type EXISTS PATH string path
        |  NESTED [PATH] path COLUMNS (column_list)
    
    on_error:
        {NULL | ERROR | DEFAULT json_string} ON ERROR
    
    on_empty:
        {NULL | ERROR | DEFAULT json_string} ON EMPTY
    

    expr:这是返回的JSON数据的表达。这可以是一个常数(“{ }”“:1”柱过程中(的)t1.jsson_data,给予表T1之前指定的JSON_TABLE()条款),或一个函数调用(JSON_EXTRACT(t1,jsn_data,'$.post.comments')

    path:一个JSON路径表达式,并应用到数据源。我们指的是JSON值匹配的路径为行源;这是用来生成一个排的关系数据。这个COLUMNS条款对行源,找出具体的JSON值在数据源,并在一排关系数据的单个列的SQL值返回的JSON值。

    这个alias是必需的。表别名通常的规则(见第二,“架构对象名称”

    JSON_TABLE()支持四种类型的列,在下面的列表描述:

    1. name FOR ORDINALITY:这种类型的枚举中的行专栏条款;命名的列name是一个计数器的类型unsigned int,其初始值为1。这相当于指定一列AUTO_INCREMENT在一个CREATE TABLE语句,可以用来区分多个行产生的值相同的父行嵌套的[路径]条款.

    2. name type PATH string_path [on_error] [on_empty]:这种类型的列是用来提取规定值string_pathtype是一个MySQL数据类型。JSson Preattable()提取数据作为JSON然后强迫其向列型,采用常规的自动类型转换应用到MySQL的JSON数据。准确的行为取决于柱型:如果列类型为SQL类型,那么只有一个标量值可以保存在列。保存一个对象或数组触发on error条款;这也发生在一个错误发生在保存为JSON的表列的值强制期间,如要保存的字符串“ASD”一个整数列。一个缺失值触发on_empty条款.

      可选on_error条款的决定JSson Preattable()并保存一个对象或数组时:

      • NULL ON ERROR栏目设置:无效的这是默认行为。如果在使用强制类型转换发生错误,警告被。

      • ERROR ON ERROR:抛出一个错误

      • DEFAULT json string ON ERROR:thejson_string要解析JSON(只要它是有效的),而不是对象或数组的存储。警告如果错误的类型强制造成丢。柱型的规则也适用于默认值。

      当一个值保存到一个列被截断,如保存结果在DECIMAL(10,1)柱,发出警告独立于任何误差选项当多个值被截断,在一条语句,则发出警告一次。

      可选on empty条款的决定JSson Preattable()在发生数据丢失(取决于类型)。这一条款也在一列触发NESTED PATH条款时,后者没有比赛和无效的补充列为它制造on empty以下列值之一:

      • NULL ON EMPTY栏目设置:无效的这是默认行为

      • ERROR ON EMPTY:抛出一个错误

      • DEFAULT json_string ON EMPTY提供:thejson_string解析为JSON,只要它是有效的,并存储代替缺失值。柱型的规则也适用于默认值。

      此查询说明如何使用ON ERROR在空选项相应的行{"b":1}是空的路径“美元。”,并试图拯救[1,2]作为一个标量产生误差;这些行在输出高亮显示。

      MySQL的&#62;SELECT *-&#62;FROM-&#62;JSON_TABLE(-&#62;'[{"a":"3"},{"a":2},{"b":1},{"a":0},{"a":[1,2]}]',-&#62;"$[*]"-&#62;COLUMNS(-&#62;rowid FOR ORDINALITY,-&#62;ac VARCHAR(100) PATH "$.a" DEFAULT '999' ON ERROR DEFAULT '111' ON EMPTY,-&#62;aj JSON PATH "$.a" DEFAULT '{"x": 333}' ON EMPTY,-&#62;bx INT EXISTS PATH "$.b"-&#62;)-&#62;) AS tt;------- ------ ------------ ------ | rowid |交流| AJ | BX | ------- ------ ------------ ------ | 1 | 3 |“3”| 0 | | 2 2 2 0 | | | || 3 | | { 111 }“X”:333 | 1 || 4 0 0 0 | | | || 5 | 999 | [ 1, 2 ] | 0 |------- ------ ------------ ------五行集(0.001秒)
    3. name type EXISTS PATH path:此列返回1如果任何数据在指定的位置path否则,和0type可以是任何有效的MySQL数据类型,但通常应指定为多种INT

    4. NESTED [PATH] path COLUMNS (column_list):这将嵌套的对象或数组JSON数据到一个单一的行以及从父对象或数组的JSON值。使用多个路径选项允许从多层次的嵌套的JSON值投影到一个单一的行。

      这个path是相对于父路径行路径JSson Preattable(),或父路径NESTED [PATH]在嵌套路径事件条款

    列名是通常的规则和限制表的列名。看到第二,“架构对象名称”

    所有的JSON和JSON路径表达式的有效性检查;任一类型无效的表达导致错误。

    每一场比赛的path专栏关键词映射到结果表中的单个行。例如,下面的查询结果显示在这里了:

    mysql> SELECT *
        -> FROM
        ->   JSON_TABLE(
        ->     '[{"x":2,"y":"8"},{"x":"3","y":"7"},{"x":"4","y":6}]',
        ->     "$[*]" COLUMNS(
        ->       xval VARCHAR(100) PATH "$.x",
        ->       yval VARCHAR(100) PATH "$.y"
        ->     )
        ->   ) AS  jt1;
    
    +------+------+
    | xval | yval |
    +------+------+
    | 2    | 8    |
    | 3    | 7    |
    | 4    | 6    |
    +------+------+
    

    的表达"$[*]"比赛的每一个元素的数组。你可以通过修改路径的滤波结果中的行;例如,使用“$ [1 ]”限制提取作为源JSON数组的第二元素,如下所示:

    mysql> SELECT *
        -> FROM
        ->   JSON_TABLE(
        ->     '[{"x":2,"y":"8"},{"x":"3","y":"7"},{"x":"4","y":6}]',
        ->     "$[1]" COLUMNS(
        ->       xval VARCHAR(100) PATH "$.x",
        ->       yval VARCHAR(100) PATH "$.y"
        ->     )
        ->   ) AS  jt1;
    
    +------+------+
    | xval | yval |
    +------+------+
    | 3    | 7    |
    +------+------+
    

    在一个列定义,"$"通过整个匹配的列;“美元.x”"$.y"只有通过值对应的键Xy,分别在比赛。有关更多信息,参见第12.16.8,“JSON语法路径”

    NESTED PATH(或是嵌套PATH是可选的)产生一组每一场比赛中的记录专栏条款所属。如果没有比赛,所有列的嵌套路径设置NULL。这实现了上面的条款与外连接嵌套的[路径]。内连接可以通过一个合适的条件在应用仿真WHERE条款,如下图所示:

    MySQL的&#62;SELECT *-&#62;FROM-&#62;JSON_TABLE(-&#62;'[ {"a": 1, "b": [11,111]}, {"a": 2, "b": [22,222]}, {"a":3}]',-&#62;'$[*]' COLUMNS(-&#62;a INT PATH '$.a',-&#62;NESTED PATH '$.b[*]' COLUMNS (b INT PATH '$')-&#62;)-&#62;) AS jt-&#62;WHERE b IS NOT NULL;????????????B |的| | | 1 | 11 | | 1 | 111 | | 2 | 22 | | 2 | 222 |??????

    兄弟姐妹的嵌套路径就是两个或两个以上的实例NESTED [PATH]在相同的专栏条款进行处理,一个接一个,一次一个。而一个嵌套路径是生产记录,任何兄弟姐妹列嵌套路径表达式设置NULL。这意味着,在一个包含一个匹配的总记录数专栏条款和不生产的产品的所有记录NESTED [PATH]改性剂,如下图所示:

    MySQL的&#62;SELECT *-&#62;FROM-&#62;JSON_TABLE(-&#62;'[{"a": 1, "b": [11,111]}, {"a": 2, "b": [22,222]}]',-&#62;'$[*]' COLUMNS(-&#62;a INT PATH '$.a',-&#62;NESTED PATH '$.b[*]' COLUMNS (b1 INT PATH '$'),-&#62;NESTED PATH '$.b[*]' COLUMNS (b2 INT PATH '$')-&#62;)-&#62;) AS jt;| ------ ------ A B1 B2 | ------ | | ------ ------ ------ | 1 11 1 | |零| | | 111 |零零| | | | 1 11 1 | | |零| 111 | | | 22 2 2 |零| | | 222 |零| | |零| | | 22 2 2 |零| 222 | ------ ------。

    FOR ORDINALITY柱产生的记录了专栏条款,可以用来区分一个嵌套路径的父记录,特别是如果在父记录的值是相同的,这里可以看到:

    mysql> SELECT *
        -> FROM
        ->   JSON_TABLE(
        ->     '[{"a": "a_val",
        '>       "b": [{"c": "c_val", "l": [1,2]}]},
        '>     {"a": "a_val",
        '>       "b": [{"c": "c_val","l": [11]}, {"c": "c_val", "l": [22]}]}]',
        ->     '$[*]' COLUMNS(
        ->       top_ord FOR ORDINALITY,
        ->       apath VARCHAR(10) PATH '$.a',
        ->       NESTED PATH '$.b[*]' COLUMNS (
        ->         bpath VARCHAR(10) PATH '$.c',
        ->         ord FOR ORDINALITY,
        ->         NESTED PATH '$.l[*]' COLUMNS (lpath varchar(10) PATH '$')
        ->         )
        ->     )
        -> ) as jt;
    
    +---------+---------+---------+------+-------+
    | top_ord | apath   | bpath   | ord  | lpath |
    +---------+---------+---------+------+-------+
    |       1 |  a_val  |  c_val  |    1 | 1     |
    |       1 |  a_val  |  c_val  |    1 | 2     |
    |       2 |  a_val  |  c_val  |    1 | 11    |
    |       2 |  a_val  |  c_val  |    2 | 22    |
    +---------+---------+---------+------+-------+
    

    源文件包含两个元素的数组;这些元素中的每一个产生两列。价值观apathbpath同样是在整个结果集;这意味着他们不能被用来确定是否lpath价值来自相同或不同的父母。的价值奥德柱仍然作为记录的设置相同top_ord等于1,那么这两个值是从一个单一的对象。剩下的两个值是从不同的对象,因为他们在有不同的价值观奥德专栏

12.16.7 JSON的实用功能

这部分文件的实用功能,作用于JSON值或字符串,可以解析JSON值。JSON_PRETTY()打印在一个易于阅读的格式JSON值。JSON_STORAGE_SIZE()JSON_STORAGE_FREE()显示,分别由一个给定的JSON值和残留在空间使用量的存储空间量JSON柱下局部更新

  • JSON_PRETTY(json_val)

    提供JSON值类似于PHP实现漂亮的印刷与其他语言和数据库系统。提供的值必须是一个JSON值或一个JSON值有效的字符串表示形式。多余的空格和换行符在这个价值对输出没有影响。对于一个NULL值,该函数时返回无效的。如果值不是一个JSON文件,或者如果它不能被解析为一个,函数失败与错误。

    格式化输出函数遵循以下规则:

    • 每个数组元素或对象的成员出现在单独的行缩进一个额外的水平,比其母。

    • 每级增加两个空格缩进。

    • 逗号分隔各个数组元素或对象成员在换行符分隔两元素或成员打印。

    • 关键和对象成员的值是由一个冒号加一个空格隔开(&#39;: &#39;)

    • 一个空的对象或数组打印在一行。没有空间的开闭括号之间的印刷。

    • 在字符串标量和键名字特殊字符都逃脱了使用使用的相同的规则JSON_QUOTE()功能

    MySQL的&#62;SELECT JSON_PRETTY('123'); # scalar漂亮的| JSON _ -----------------------(123)| -------------------- | 123 | -------------------- MySQL &#62;SELECT JSON_PRETTY("[1,3,5]"); # array------------------------ | JSON _漂亮(“[ 1 ]”)| ------------------------ | [ 1,3,5 ] | ------------------------ MySQL &#62;SELECT JSON_PRETTY('{"a":"10","b":"15","x":"25"}'); # object--------------------------------------------- _漂亮| JSON(“{“a”:“10”、“B”:“十五”、“X”:“25”“{ }”| | ---------------------------------------------)”:“10”、“B”:“十五”、“X”| --------------------------------------------- }:“25”MySQL &#62;SELECT JSON_PRETTY('["a",1,{"key1":&#62;"value1"},"5",     "77" ,&#62;{"key2":["value3","valueX",&#62;"valueY"]},"j", "2"   ]')\G  # nested arrays and objects* * * * * * * * * * * * * * * * * * * * * * * * * * * 1。行* * * * * * * * * * * * * * * * * * * * * * * * * * * *(JSON _〔1“,”,“{ }”KEY1”:value1”、“5”、“77”,{“[ key2”:“value3”、“valuex”、“valuey”] },“J”,“2”是:[ ]),“1”,在“{ }”KEY1”:value1”、“5”、“77”,{“[”value3 key2”:“,,”valuex”“valuey ]“,”2“,”J”]
  • JSON_STORAGE_FREE(json_val)

    对于一个JSON列的值,这个函数显示多少存储空间被释放,其二进制表示这是经过的地方使用更新JSON_SET()JSON_REPLACE(),或JSON_REMOVE()。参数也可以是一个有效的JSON文件或字符串,可以解析为一个作为一个文本值或作为一个用户变量,函数返回值为0。它返回一个非零值的正面,如果参数是一个JSON列值已进行更新,这样它的二进制表示形式占比更新前更少的空间。对于一个JSON柱已使得它的二进制表示形式相同或比以前更大更新,或者更新不能够利用一部分更新,则返回0;它返回无效的如果参数是NULL

    如果json_val是不是无效的,也不是一个有效的JSON文档也可以成功解析为一体,一个错误的结果。

    在这个例子中,我们创建一个表包含JSON列,然后插入一行含有一个JSON对象:

    MySQL的&#62;CREATE TABLE jtable (jcol JSON);查询行,0行受影响(0.38秒)MySQL &#62;INSERT INTO jtable VALUES-&#62;('{"a": 10, "b": "wxyz", "c": "[true, false]"}');查询行,1行的影响(0.04秒)MySQL &#62;SELECT * FROM jtable;---------------------------------------------- | jcol | ---------------------------------------------- | {“,”10“,”B“,”wxyz:“C”:“[假]真的,”| ---------------------------------------------- } 1行集(0秒)

    现在我们更新列值使用JSON_SET()这样可以进行局部更新;在这种情况下,我们更换的价值指向的C关键(阵列[true, false])一,占用更少的空间(整数):

    mysql> UPDATE jtable
        ->     SET jcol = JSON_SET(jcol, "$.a", 10, "$.b", "wxyz", "$.c", 1);
    Query OK, 1 row affected (0.03 sec)
    Rows matched: 1  Changed: 1  Warnings: 0
    
    mysql> SELECT * FROM jtable;
    +--------------------------------+
    | jcol                           |
    +--------------------------------+
    | {"a": 10, "b": "wxyz", "c": 1} |
    +--------------------------------+
    1 row in set (0.00 sec)
    
    mysql> SELECT JSON_STORAGE_FREE(jcol) FROM jtable;
    +-------------------------+
    | JSON_STORAGE_FREE(jcol) |
    +-------------------------+
    |                      14 |
    +-------------------------+
    1 row in set (0.00 sec)
    

    连续的部分更新在这个自由空间的影响是累积的,如本例中使用JSON_SET()减少了密钥空间的价值B(并且没有其他变化):

    mysql> UPDATE jtable
        ->     SET jcol = JSON_SET(jcol, "$.a", 10, "$.b", "wx", "$.c", 1);
    Query OK, 1 row affected (0.03 sec)
    Rows matched: 1  Changed: 1  Warnings: 0
    
    mysql> SELECT JSON_STORAGE_FREE(jcol) FROM jtable;
    +-------------------------+
    | JSON_STORAGE_FREE(jcol) |
    +-------------------------+
    |                      16 |
    +-------------------------+
    1 row in set (0.00 sec)
    

    更新的列不使用JSON_SET()JSON _ replace(),或JSON_REMOVE()意味着优化程序无法执行更新到位;在这种情况下,_ JSON存储_自由()返回0,如下所示:

    mysql> UPDATE jtable SET jcol = '{"a": 10, "b": 1}';
    Query OK, 1 row affected (0.05 sec)
    Rows matched: 1  Changed: 1  Warnings: 0
    
    mysql> SELECT JSON_STORAGE_FREE(jcol) FROM jtable;
    +-------------------------+
    | JSON_STORAGE_FREE(jcol) |
    +-------------------------+
    |                       0 |
    +-------------------------+
    1 row in set (0.00 sec)
    

    JSON文件部分更新只能在列的值。一个用户变量存储一个JSON值,值总是完全取代,即使是进行更新JSON_SET()

    MySQL的&#62;SET @j = '{"a": 10, "b": "wxyz", "c": "[true, false]"}';查询好,为受影响的行(0.001秒)MySQL &#62;SET @j = JSON_SET(@j, '$.a', 10, '$.b', 'wxyz', '$.c', '1');查询好,为受影响的行(0.001秒)MySQL &#62;SELECT @j, JSON_STORAGE_FREE(@j) AS Free;---------------------------------- ------ | @ J |自由| ---------------------------------- ------ | {“”:,“B”:“wxyz”、“C”:“”} | 0 | ---------------------------------- ------一行集(0.001秒)

    一个JSON文本,这个函数总是返回0:

    mysql> SELECT JSON_STORAGE_FREE('{"a": 10, "b": "wxyz", "c": "1"}') AS Free;
    +------+
    | Free |
    +------+
    |    0 |
    +------+
    1 row in set (0.00 sec)
    
  • JSON_STORAGE_SIZE(json_val)

    这个函数返回一个JSON文件用于存储二进制表示的字节数。当参数是一个JSON柱,这是用来储存JSON文件,插入列的空间,可能进行的任何部分之前的更新之后。json_val必须是一个有效的JSON文件或字符串,可以解析为一个。在这种情况下,它是字符串,函数返回的存储空间量的JSON格式的二进制表示的解析字符串作为JSON转换为二进制。它返回无效的如果参数是NULL

    一个错误的结果时,json_val是不是无效的,而不是或不能成功解析为JSON文档。

    为了说明这个函数的行为与使用JSON柱作为它的参数,我们创建一个表名JTableJSON专栏jcol,插入一个JSON值插入表中,然后使用柱获得存储空间JSON_STORAGE_SIZE(),如下所示:

    MySQL的&#62;CREATE TABLE jtable (jcol JSON);查询行,0行受影响(0.42秒)MySQL &#62;INSERT INTO jtable VALUES-&#62;('{"a": 1000, "b": "wxyz", "c": "[1, 3, 5, 7]"}');查询行,1行的影响(0.04秒)MySQL &#62;SELECT-&#62;jcol,-&#62;JSON_STORAGE_SIZE(jcol) AS Size,-&#62;JSON_STORAGE_FREE(jcol) AS Free-&#62;FROM jtable;----------------------------------------------- ------ ------ | jcol |大小|自由| ----------------------------------------------- ------ ------ | {“”:一千,“B”:“wxyz”、“C”:“[ 1,3,5,7 ]”} | 47 | 0 | ----------------------------------------------- ------ ------一行集(0.001秒)

    根据输出JSON_STORAGE_SIZE(),JSON文档插入列占用47字节。我们还检查了空间量被以前的任何部分更新的列使用JSON_STORAGE_FREE();因为没有更新尚未完成,这是0,预期。

    接下来我们进行UPDATE在桌子上,结果应在局部更新存储在文档jcol,然后测试结果如下所示:

    mysql> UPDATE jtable SET jcol = 
        ->     JSON_SET(jcol, "$.b", "a");
    Query OK, 1 row affected (0.04 sec)
    Rows matched: 1  Changed: 1  Warnings: 0
    
    mysql> SELECT
        ->     jcol,
        ->     JSON_STORAGE_SIZE(jcol) AS Size,
        ->     JSON_STORAGE_FREE(jcol) AS Free
        -> FROM jtable;
    +--------------------------------------------+------+------+
    | jcol                                       | Size | Free |
    +--------------------------------------------+------+------+
    | {"a": 1000, "b": "a", "c": "[1, 3, 5, 7]"} |   47 |    3 |
    +--------------------------------------------+------+------+
    1 row in set (0.00 sec)
    

    返回的值JSON_STORAGE_FREE()在前面的查询表明,局部更新JSON文档进行,这种释放用来存储这三个字节的空间。返回的结果_ JSON存储_ size()不变的部分更新

    部分更新更新以支持JSON_SET()JSON_REPLACE(),或JSON_REMOVE()。一个值到一个直接赋值JSON列不能部分更新后更新,JSON_STORAGE_SIZE()总是使用新设置的值的存储:

    MySQL的&#62;UPDATE jtableMySQL的&#62;SET jcol = '{"a": 4.55, "b": "wxyz", "c": "[true, false]"}';查询行,1行的影响(0.04秒)的行匹配:1改变:1警告:0mysql &#62;SELECT-&#62;jcol,-&#62;JSON_STORAGE_SIZE(jcol) AS Size,-&#62;JSON_STORAGE_FREE(jcol) AS Free-&#62;FROM jtable;------------------------------------------------ ------ ------ | jcol |大小|自由| ------------------------------------------------ ------ ------ | {“”:4.55,“B”:“wxyz”、“C”:“[真、假]”} | 56 | 0 | ------------------------------------------------ ------ ------ 1行集(0秒)

    一个JSON用户变量不能部分更新。这意味着,这个函数总是显示当前用于存储一个JSON文件在用户变量的空间:

    mysql> SET @j = '[100, "sakila", [1, 3, 5], 425.05]';
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> SELECT @j, JSON_STORAGE_SIZE(@j) AS Size;
    +------------------------------------+------+
    | @j                                 | Size |
    +------------------------------------+------+
    | [100, "sakila", [1, 3, 5], 425.05] |   45 |
    +------------------------------------+------+
    1 row in set (0.00 sec)
    
    mysql> SET @j = JSON_SET(@j, '$[1]', "json");
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> SELECT @j, JSON_STORAGE_SIZE(@j) AS Size;
    +----------------------------------+------+
    | @j                               | Size |
    +----------------------------------+------+
    | [100, "json", [1, 3, 5], 425.05] |   43 |
    +----------------------------------+------+
    1 row in set (0.00 sec)
    
    mysql> SET @j = JSON_SET(@j, '$[2][0]', JSON_ARRAY(10, 20, 30));
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> SELECT @j, JSON_STORAGE_SIZE(@j) AS Size;
    +---------------------------------------------+------+
    | @j                                          | Size |
    +---------------------------------------------+------+
    | [100, "json", [[10, 20, 30], 3, 5], 425.05] |   56 |
    +---------------------------------------------+------+
    1 row in set (0.00 sec)
    

    一个JSON文本,这个函数总是返回当前使用的存储空间:

    mysql> SELECT
        ->     JSON_STORAGE_SIZE('[100, "sakila", [1, 3, 5], 425.05]') AS A,
        ->     JSON_STORAGE_SIZE('{"a": 1000, "b": "a", "c": "[1, 3, 5, 7]"}') AS B,
        ->     JSON_STORAGE_SIZE('{"a": 1000, "b": "wxyz", "c": "[1, 3, 5, 7]"}') AS C,
        ->     JSON_STORAGE_SIZE('[100, "json", [[10, 20, 30], 3, 5], 425.05]') AS D;
    +----+----+----+----+
    | A  | B  | C  | D  |
    +----+----+----+----+
    | 45 | 44 | 47 | 56 |
    +----+----+----+----+
    1 row in set (0.00 sec)
    

JSON的语法12.16.8路径

许多在前面的章节中描述的功能需要为路径表达式来确定一个JSON文档特定元素。一路由路径的范围由一个或多个路径的腿。用于MySQL的JSON功能路径,范围始终是搜索文件或其他操作,由领导代表$人物路径用期性质分()。细胞阵列为代表的[N],在那里N是一个非负整数。名称的密钥必须是双引号或有效的ECMAScript标识符(见www.ecma-international.org http:/ / / / / # ECMA 262 5.1~7.6秒)。路径表达式,如JSON文本,编码应使用asciiUTF8,或utf8mb4字符集。其他的字符编码是隐式强制转换为utf8mb4。完整的语法如下所示:

pathExpression:
    scope[(pathLeg)*]

pathLeg:
    member | arrayLocation | doubleAsterisk

member:
    period ( keyName | asterisk )

arrayLocation:
    leftBracket ( nonNegativeInteger | asterisk ) rightBracket

keyName:
    ESIdentifier | doubleQuotedString

doubleAsterisk:
    '**'

period:
    '.'

asterisk:
    '*'

leftBracket:
    '['

rightBracket:
    ']'

在MySQL此前指出,该路径的范围总是被操作的文件,表示为$。你可以使用&#39;$&#39;作为一个在JSON文档synonynm路径表达式。

笔记

为实现支持JSON路径范围的一些列引用;目前,MySQL不支持这些。

通配符** *使用标记如下:

  • .*表示对象中的所有成员的值。

  • [*]代表数组中的所有单元格的值。

  • [prefix]**suffix代表所有的路径开始prefix结束suffixprefix是可选的,而suffix是必需的;换句话说,一个路径可能不结束* *

    此外,路径不能包含序列***

路径语法的例子,看到各种JSON fuinctions带路径作为参数的描述,如JSON_CONTAINS_PATH()JSON_SET(),和JSON_REPLACE()。例子包括使用的***通配符,看到的描述JSON_SEARCH()功能

12.17函数使用全局事务ID。

本节中描述的功能是用gtid以复制。这是记住所有这些功能以gtid设置字符串表示为参数等重要的gtid集必须引用时使用它们。看到gtid集更多信息

两gtid集合的并集就是表示为字符串,一个插入逗号连接在一起。换句话说,你可以得到两gtid的并集的定义很简单的功能,类似于在这里创造:

CREATE FUNCTION GTID_UNION(g1 TEXT, g2 TEXT)
    RETURNS TEXT DETERMINISTIC
    RETURN CONCAT(g1,',',g2);

关于GTIDs的更多信息以及如何将这些gtid函数应用在实践中,看到部分下面,“复制与全球事务标识符”

gtid 12.22函数表

姓名描述
GTID_SUBSET()如果所有gtids子集也将返回true;否则为false。
GTID_SUBTRACT()返回集合中的子集都不gtids。
WAIT_FOR_EXECUTED_GTID_SET()等到了gtids执行奴隶。
WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS()等到了gtids执行奴隶。

  • GTID_SUBSET(subset,set)

    给出两组全局事务IDsubsetset归来的威胁,如果在全gtidssubset也在set。否则返回false。

    的gtid集应用这个函数表示为字符串,如下面的示例所示:

    mysql> SELECT GTID_SUBSET('3E11FA47-71CA-11E1-9E33-C80AA9429562:23',
        ->     '3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57')\G
    *************************** 1. row ***************************
    GTID_SUBSET('3E11FA47-71CA-11E1-9E33-C80AA9429562:23',
        '3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57'): 1
    1 row in set (0.00 sec)
    
    mysql> SELECT GTID_SUBSET('3E11FA47-71CA-11E1-9E33-C80AA9429562:23-25',
        ->     '3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57')\G
    *************************** 1. row ***************************
    GTID_SUBSET('3E11FA47-71CA-11E1-9E33-C80AA9429562:23-25',
        '3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57'): 1
    1 row in set (0.00 sec)
    
    mysql> SELECT GTID_SUBSET('3E11FA47-71CA-11E1-9E33-C80AA9429562:20-25',
        ->     '3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57')\G
    *************************** 1. row ***************************
    GTID_SUBSET('3E11FA47-71CA-11E1-9E33-C80AA9429562:20-25',
        '3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57'): 0
    1 row in set (0.00 sec)
    
  • GTID_SUBTRACT(set,subset)

    给出两组全局事务IDsubsetset只有那些从gtids,返回set不在subset

    所有的gtid集使用这个函数表示为字符串,必须引用,因为这些例子所示:

    mysql> SELECT GTID_SUBTRACT('3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57',
        ->     '3E11FA47-71CA-11E1-9E33-C80AA9429562:21')\G
    *************************** 1. row ***************************
    GTID_SUBTRACT('3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57',
        '3E11FA47-71CA-11E1-9E33-C80AA9429562:21'): 3e11fa47-71ca-11e1-9e33-c80aa9429562:22-57
    1 row in set (0.00 sec)
    
    mysql> SELECT GTID_SUBTRACT('3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57',
        ->     '3E11FA47-71CA-11E1-9E33-C80AA9429562:20-25')\G
    *************************** 1. row ***************************
    GTID_SUBTRACT('3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57',
        '3E11FA47-71CA-11E1-9E33-C80AA9429562:20-25'): 3e11fa47-71ca-11e1-9e33-c80aa9429562:26-57
    1 row in set (0.00 sec)
    
    mysql> SELECT GTID_SUBTRACT('3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57',
        ->     '3E11FA47-71CA-11E1-9E33-C80AA9429562:23-24')\G
    *************************** 1. row ***************************
    GTID_SUBTRACT('3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57',
        '3E11FA47-71CA-11E1-9E33-C80AA9429562:23-24'): 3e11fa47-71ca-11e1-9e33-c80aa9429562:21-22:25-57
    1 row in set (0.01 sec)
    
  • WAIT_FOR_EXECUTED_GTID_SET(gtid_set[, timeout])

    等到服务器应用了所有的全局事务标识符包含在交易gtid_setthat is,until the condition;_子集(gtidgtid_subsetglobal.gtid _ executed @)成立。湖第17.1.3.1”gtid格式和存储”对于一个gtid集的定义。

    如果超时指定,并timeout秒前经过所有的gtid设置交易已被应用,停止等功能。timeout是可选的,默认的超时时间是0秒,在这种情况下,函数总是要等到所有的gtid设置交易已应用。

    WAIT_FOR_EXECUTED_GTID_SET()监控所有的gtids是应用在服务器上,包括交易到达所有复制的渠道和用户的客户。它没有考虑到是否复制渠道已经开始或停止。

    有关更多信息,参见部分下面,“复制与全球事务标识符”

    gtid集使用这个函数表示为字符串,所以必须引用如下例所示:

    mysql> SELECT WAIT_FOR_EXECUTED_GTID_SET('3E11FA47-71CA-11E1-9E33-C80AA9429562:1-5');
            -> 0
    

    一个语法描述为gtid集,见第17.1.3.1”gtid格式和存储”

    WAIT_FOR_EXECUTED_GTID_SET(),返回值是该查询的状态,其中0表示成功,1表示超时。其他的失败产生一个错误。

    gtid_mode不能更改,任何客户端使用这个函数来等待GTIDs的应用。

  • WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS(gtid_set[, timeout][,channel])

    WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS()类似于wait_for_executed_gtid_set()在这等待直到所有的全局事务标识符包含在交易gtid_set已被应用,直到timeout秒后,以先发生者为准。然而,wait_until_sql_thread_after_gtids()适用于一个特定的复制通道,并停止交易后已应用于指定的通道,而申请人必须运行。相反,WAIT_FOR_EXECUTED_GTID_SET()停止交易后得到了应用,无论他们在那里应用(在任何复制通道或任何用户的客户端),以及是否有复制通道运行。

    这个channel选项名称复制通道功能适用于。如果没有通道命名并没有渠道以外的默认复制通道的存在,该功能适用于默认复制通道。如果多个复制通道的存在,你必须指定一个通道,否则不知道复制通道功能适用于。看到第17.2.3,“复制通道”在复制通道的更多信息。

    笔记

    因为WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS()适用于一个特定的复制通道,如果预期交易会在不同的复制通道或从一个用户的客户端,例如在故障转移或手动恢复情况,功能可以挂下去如果没有超时设置。使用wait_for_executed_gtid_set()而为了确保正确处理这些情况的交易。

    gtid集使用WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS()表示为字符串,必须引用相同的方式为wait_for_executed_gtid_set()。为WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS(),该函数的返回值是一个任意的正整数。如果gtid基于复制不活跃(即,如果该值gtid_mode变量是关闭的),那么这个值是未定义的,wait_until_sql_thread_after_gtids()返回null。如果奴隶没有运行,然后函数返回null。

    gtid_mode不能更改,任何客户端使用这个函数来等待GTIDs的应用。

12.18 MySQL企业加密功能

笔记

MySQL企业加密是一个扩展包含在MySQL企业版,商业产品。要了解更多关于商业产品,http://www.mysql.com /产品/

MySQL企业版包括一套加密功能基于OpenSSL库OpenSSL的能力暴露在SQL级。这些功能使企业应用程序执行以下操作:

  • 实施额外的数据保护使用公共密钥的非对称加密

  • 创建公共密钥和私人密钥和数字签名

  • 执行非对称加密和解密

  • 使用密码散列和数字签名数据的验证和确认

企业加密支持RSA,DSA,和DH加密算法。

企业加密为用户自定义函数(UDF)库,从个别的功能可以单独安装。

12.18.1企业加密装置

企业加密功能都位于一个用户自定义函数(UDF)在插件目录安装的库文件(目录命名的plugin_dir系统变量)。UDF库的名字OpenSSL _ UDF和后缀是平台相关的。例如,在Linux或Windows文件名openssl_udf.so_ udf.dll OpenSSL,分别

从库文件安装功能,使用CREATE FUNCTION声明。从库中加载的所有功能,使用这套报表(调整文件的后缀名是必要的):

创建函数返回字符串asymmetric_decrypt现在的openssl_udf。所以;创建功能asymmetric_derive返回字符串的openssl_udf现在。所以;创建功能asymmetric_encrypt返回字符串的openssl_udf现在。所以;创建功能asymmetric_sign返回字符串的openssl_udf现在。所以;创建函数返回整数asymmetric_verify现在的openssl_udf。所以创造create_asymmetric_priv_key返回功能;现在openssl_udf字符串&#39;,&#39;;创建功能create_asymmetric_pub_key返回字符串的openssl_udf现在。所以;创建功能create_dh_parameters返回字符串的openssl_udf现在。所以;创建功能create_digest返回字符串的openssl_udf现在。”;

一旦安装,安装在服务器重新启动UDF保持。卸下UDFs,使用DROP FUNCTION声明。例如,把密钥生成函数,这样做:

create_asymmetric_priv_key降功能create_asymmetric_pub_key下降功能;

CREATE FUNCTIONDROP FUNCTION语句,函数名必须使用小写指定。这不同于它们的使用在函数调用时,它可以使用任何lettercase。

这个CREATE FUNCTIONDROP FUNCTION报表要求INSERTDROP特权,分别为MySQL数据库

12.18.2企业加密使用的例子

在应用程序中使用企业加密、调用适合你希望执行的操作的功能。本节说明如何进行一些有代表性的任务:

创建一个私人/公共密钥采用RSA加密

-- Encryption algorithm; can be 'DSA' or 'DH' instead
SET @algo = 'RSA';
-- Key length in bits; make larger for stronger keys
SET @key_len = 1024;

-- Create private key
SET @priv = CREATE_ASYMMETRIC_PRIV_KEY(@algo, @key_len);
-- Derive corresponding public key from private key, using same algorithm
SET @pub = CREATE_ASYMMETRIC_PUB_KEY(@algo, @priv);

现在你可以使用密钥对数据进行加密和解密、签名和验证数据,或生成对称密钥。

使用私有密钥加密和解密数据的密钥

这就要求的密钥对的成员是RSA密钥。

SET @ciphertext = ASYMMETRIC_ENCRYPT(@algo, 'My secret text', @priv);
SET @cleartext = ASYMMETRIC_DECRYPT(@algo, @ciphertext, @pub);

相反,你可以使用公共密钥加密和解密使用的密钥。

SET @ciphertext = ASYMMETRIC_ENCRYPT(@algo, 'My secret text', @pub);
SET @cleartext = ASYMMETRIC_DECRYPT(@algo, @ciphertext, @priv);

在任何情况下,对加密和解密函数必须指定用于生成密钥的算法。

从一个字符串生成一个摘要

-- Digest type; can be 'SHA256', 'SHA384', or 'SHA512' instead
SET @dig_type = 'SHA224';

-- Generate digest string
SET @dig = CREATE_DIGEST(@dig_type, 'My text to digest');

使用一个密钥对消化

重点对可用于对数据进行签名,然后验证签名匹配的消化。

-- Encryption algorithm; could be 'DSA' instead; keys must
-- have been created using same algorithm
SET @algo = 'RSA';

-- Generate signature for digest and verify signature against digest
SET @sig = ASYMMETRIC_SIGN(@algo, @dig, @priv, @dig_type);
-- Verify signature against digest
SET @verf = ASYMMETRIC_VERIFY(@algo, @dig, @sig, @pub, @dig_type);

创建一个对称密钥

这就要求DH私人/公共密钥作为输入,使用一个共享的对称密钥创建。通过密钥长度创造的秘密CREATE_DH_PARAMETERS(),然后通过秘密的密钥长度CREATE_ASYMMETRIC_PRIV_KEY()

-- Generate DH shared symmetric secretSET @dhp = CREATE_DH_PARAMETERS(1024);-- Generate DH key pairsSET @algo = 'DH';SET @priv1 = CREATE_ASYMMETRIC_PRIV_KEY(@algo, @dhp);SET @pub1 = CREATE_ASYMMETRIC_PUB_KEY(@algo, @priv1);SET @priv2 = CREATE_ASYMMETRIC_PRIV_KEY(@algo, @dhp);SET @pub2 = CREATE_ASYMMETRIC_PUB_KEY(@algo, @priv2);-- Generate symmetric key using public key of first party,-- private key of second partySET @sym1 = ASYMMETRIC_DERIVE(@pub1, @priv2);-- Or use public key of second party, private key of first partySET @sym2 = ASYMMETRIC_DERIVE(@pub2, @priv1);

关键字符串的值可以在运行时创建并存储到一个变量或表的使用SETSELECT,或INSERT

SET @priv1 = CREATE_ASYMMETRIC_PRIV_KEY('RSA', 1024);SELECT CREATE_ASYMMETRIC_PRIV_KEY('RSA', 1024) INTO @priv2;INSERT INTO t (key_col) VALUES(CREATE_ASYMMETRIC_PRIV_KEY('RSA', 1024));

关键字符串的值存储在文件可以阅读使用LOAD_FILE()功能的用户才有FILE特权

摘要和签名字符串可同样处理。

城市限制CPU使用密钥生成操作

这个CREATE_ASYMMETRIC_PRIV_KEY()CREATE_DH_PARAMETERS()加密函数将密钥长度参数,和CPU资源要求的这些功能增加密钥长度增加。一些设施,这可能在应用中经常产生过长的键导致不可接受的CPU使用率。

OpenSSL施加最小密钥长度为1024位的所有密钥。OpenSSL也施加了最大密钥长度为10000位和16384位的RSA密钥,分别为CREATE_ASYMMETRIC_PRIV_KEY(),和最大密钥长度10000位CREATE_DH_PARAMETERS()。如果这些最大值太高,三个环境变量可使MySQL服务器管理员密钥生成设置较低的最大长度,从而限制CPU使用率:

  • MYSQL_OPENSSL_UDF_DSA_BITS_THRESHOLD:最大DSA密钥长度的比特CREATE_ASYMMETRIC_PRIV_KEY()。此变量的最小值和最大值分别为1024和10000。

  • MYSQL_OPENSSL_UDF_RSA_BITS_THRESHOLD:最大的RSA密钥长度的比特CREATE_ASYMMETRIC_PRIV_KEY()。此变量的最小值和最大值分别为1024和16384。

  • MYSQL_OPENSSL_UDF_DH_BITS_THRESHOLD:最大密钥长度的比特CREATE_DH_PARAMETERS()。此变量的最大值和最小值都达到一万。

要使用这些环境变量,设置过程中启动服务器环境。如果设置了,他们的价值观优先于最大密钥长度由OpenSSL。例如,设置一个最大密钥长度4096位RSA密钥CREATE_ASYMMETRIC_PRIV_KEY(),设置这些变量:

export MYSQL_OPENSSL_UDF_DSA_BITS_THRESHOLD=4096export MYSQL_OPENSSL_UDF_RSA_BITS_THRESHOLD=4096

《以辨别Bourne Shell语法。其他的语法为内核牌可能不同。

12.18.3企业加密函数参考

表12.23 MySQL企业加密功能

姓名描述
ASYMMETRIC_DECRYPT()使用私人或公共密钥解密密文
ASYMMETRIC_DERIVE()得到对称密钥的非对称密钥
ASYMMETRIC_ENCRYPT()使用私人或公共密钥加密明文
ASYMMETRIC_SIGN()从消化生成签名
ASYMMETRIC_VERIFY()验证签名匹配消化
CREATE_ASYMMETRIC_PRIV_KEY()创建私钥
CREATE_ASYMMETRIC_PUB_KEY()创建公钥
CREATE_DH_PARAMETERS()生成DH秘密共享
CREATE_DIGEST()从字符串生成文摘

12.18.4 Enterprise enCRIMENT Function Desence

企业加密功能这些一般特征:

  • 对于错误的类型或参数个数不正确的参数,每个函数返回一个错误。

  • 如果参数不适合允许函数执行所请求的操作,它返回NULL0适当。发生这种情况,例如,如果一个函数不支持指定的算法,密钥长度过短或长,或将PEM格式的关键字符串不是有效的关键。(OpenSSL对自己的密钥长度的限制,服务器管理员可以施加额外的限制最大密钥长度的设置环境变量。看到第12.18.2,“企业加密使用的例子”。)

  • 底层SSL库负责随机初始化。

几个函数把一个加密算法参数。下表总结了支持算法的功能。


笔记

虽然你可以使用任何的RSA,DSA创建密钥,或DH加密算法,其他的功能,把关键的争论可能只接受某些类型的键。例如,ASYMMETRIC_ENCRYPT()ASYMMETRIC_DECRYPT()只接受RSA密钥

下面的说明描述企业加密函数调用序列。额外的例子和讨论,看第12.18.2,“企业加密使用的例子”

  • ASYMMETRIC_DECRYPT(algorithm, crypt_str, key_str)

    解密加密的字符串使用给定的算法和密钥字符串和二进制字符串返回明文。如果解密失败,结果是NULL

    key_str必须是PEM格式的有效密钥字符串。成功解密,它必须是公共的或私有的密钥字符串对应的私有或公共密钥字符串的使用ASYMMETRIC_ENCRYPT()产生加密字符串algorithm显示用于创建密钥的加密算法。

    支持algorithm价值观:“RSA”

    一个使用的例子,看描述ASYMMETRIC_ENCRYPT()

  • ASYMMETRIC_DERIVE(pub_key_str, priv_key_str)

    是用一方的私钥和一个公钥和对称密钥,作为一个二进制字符串返回产生的关键。如果密钥导出失败,结果是NULL

    pub_key_strpriv_key_str必须在PEM格式的有效密钥字符串。他们必须使用DH算法创建。

    假设你有两对公共和私人密钥:

    SET @dhp = CREATE_DH_PARAMETERS(1024);
    SET @priv1 = CREATE_ASYMMETRIC_PRIV_KEY('DH', @dhp);
    SET @pub1 = CREATE_ASYMMETRIC_PUB_KEY('DH', @priv1);
    SET @priv2 = CREATE_ASYMMETRIC_PRIV_KEY('DH', @dhp);
    SET @pub2 = CREATE_ASYMMETRIC_PUB_KEY('DH', @priv2);
    

    进一步假设你使用私钥的一对和另一对创建对称密钥的公钥字符串。那么这个对称密钥的身份关系:

    ASYMMETRIC_DERIVE(@pub1, @priv2) = ASYMMETRIC_DERIVE(@pub2, @priv1)
    
  • ASYMMETRIC_ENCRYPT(algorithm, str, key_str)

    加密字符串使用给定的算法和密钥字符串和二进制字符串返回产生的密文。如果加密失败,结果是NULL

    这个str长度不能大于key_str长?11字节

    key_str必须是PEM格式的有效密钥字符串。algorithm显示用于创建密钥的加密算法。

    支持algorithm价值观:“RSA”

    加密字符串,通过私人或公共密钥字符串ASYMMETRIC_ENCRYPT()。恢复原始未加密的字符串,通过加密的字符串ASYMMETRIC_DECRYPT(),随着公共或私人密钥字符串对应的私有或公共密钥用于加密的字符串。

    -- Generate private/public key pairSET @priv = CREATE_ASYMMETRIC_PRIV_KEY('RSA', 1024);SET @pub = CREATE_ASYMMETRIC_PUB_KEY('RSA', @priv);-- Encrypt using private key, decrypt using public keySET @ciphertext = ASYMMETRIC_ENCRYPT('RSA', 'The quick brown fox', @priv);SET @cleartext = ASYMMETRIC_DECRYPT('RSA', @ciphertext, @pub);-- Encrypt using public key, decrypt using private keySET @ciphertext = ASYMMETRIC_ENCRYPT('RSA', 'The quick brown fox', @pub);SET @cleartext = ASYMMETRIC_DECRYPT('RSA', @ciphertext, @priv);

    假设:

    SET @s = a string to be encrypted
    SET @priv = a valid private RSA key string in PEM format
    SET @pub = the corresponding public RSA key string in PEM format
    

    那么这些身份关系保持:

    ASYMMETRIC_DECRYPT('RSA', ASYMMETRIC_ENCRYPT('RSA', @s, @priv), @pub) = @s
    ASYMMETRIC_DECRYPT('RSA', ASYMMETRIC_ENCRYPT('RSA', @s, @pub), @priv) = @s
    
  • ASYMMETRIC_SIGN(algorithm, digest_str, priv_key_str, digest_type)

    标志使用私人密钥字符串摘要字符串,和一个二进制字符串返回签名。如果签约失败,结果是NULL

    digest_str是消化的字符串。它可通过调用CREATE_DIGEST()digest_type显示用于生成摘要字符串摘要算法。

    priv_key_str是用于签名的私钥消化字符串字符串。它必须是PEM格式的有效密钥字符串。algorithm显示用于创建密钥的加密算法。

    支持algorithm价值观:“RSA”'DSA'

    支持digest_type价值观:“sha224”'SHA256'“SHA384”'SHA512'

    一个使用的例子,看描述ASYMMETRIC_VERIFY()

  • ASYMMETRIC_VERIFY(algorithm, digest_str, sig_str, pub_key_str, digest_type)

    验证签名字符串匹配的消化的字符串,并返回1或0是否验证成功或失败。

    digest_str是消化的字符串。它可通过调用CREATE_DIGEST()digest_type显示用于生成摘要字符串摘要算法。

    sig_str是签名字符串。它可通过调用ASYMMETRIC_SIGN()

    pub_key_str是签名者的公钥字符串。它对应的私钥通过ASYMMETRIC_SIGN()生成的签名字符串必须PEM格式的有效密钥字符串。algorithm显示用于创建密钥的加密算法。

    支持algorithm价值观:“RSA”'DSA'

    支持digest_type价值观:“sha224”'SHA256'“SHA384”'SHA512'

    -- Set the encryption algorithm and digest typeSET @algo = 'RSA';SET @dig_type = 'SHA224';-- Create private/public key pairSET @priv = CREATE_ASYMMETRIC_PRIV_KEY(@algo, 1024);SET @pub = CREATE_ASYMMETRIC_PUB_KEY(@algo, @priv);-- Generate digest from stringSET @dig = CREATE_DIGEST(@dig_type, 'The quick brown fox');-- Generate signature for digest and verify signature against digestSET @sig = ASYMMETRIC_SIGN(@algo, @dig, @priv, @dig_type);SET @verf = ASYMMETRIC_VERIFY(@algo, @dig, @sig, @pub, @dig_type);
  • CREATE_ASYMMETRIC_PRIV_KEY(algorithm, {key_len|dh_secret})

    创建一个私有密钥使用的算法和密钥长度或DH的秘密,并为PEM格式的二进制字符串返回的关键。如果密钥生成失败,结果是NULL

    支持algorithm价值观:“RSA”'DSA'“卫生署”

    支持key_len价值观:在比特的最小密钥长度是1024。最大键长度取决于算法:RSA、DSA 10000 16384。这些密钥长度的限制是由OpenSSL的约束。服务器管理员可以施加额外的限制最大密钥长度的设置环境变量。看到第12.18.2,“企业加密使用的例子”

    DH密钥,而密钥长度共享DH秘密通行。创造的秘密,通过密钥长度CREATE_DH_PARAMETERS()

    此示例创建一个2048位DSA密钥,然后导出私钥公钥:

    SET @priv = CREATE_ASYMMETRIC_PRIV_KEY('DSA', 2048);
    SET @pub = CREATE_ASYMMETRIC_PUB_KEY('DSA', @priv);
    

    一个例子显示DH密钥生成,看描述ASYMMETRIC_DERIVE()

    一些一般考虑在选择密钥长度的加密算法:

    • 为私人和公共密钥加密的密钥大小增加强度,但时间以及增加密钥生成。

    • DH密钥的生成需要更长的时间比RSA,RSA密钥。

    • 非对称加密功能比对称函数慢。如果性能是一个重要的因素,功能是使用非常频繁,你最好使用对称加密。例如,考虑使用AES_ENCRYPT()AES_DECRYPT()

  • CREATE_ASYMMETRIC_PUB_KEY(algorithm, priv_key_str)

    导出公钥从给定的密钥使用给定的算法,并在PEM格式的二进制字符串返回的关键。如果密钥导出失败,结果是NULL

    priv_key_str必须是PEM格式的有效密钥字符串。algorithm显示用于创建密钥的加密算法。

    支持algorithm价值观:“RSA”'DSA'“卫生署”

    一个使用的例子,看描述CREATE_ASYMMETRIC_PRIV_KEY()

  • CREATE_DH_PARAMETERS(key_len)

    创建用于生成DH私人/公共密钥对共享秘密和返回一个二进制字符串,可以通过CREATE_ASYMMETRIC_PRIV_KEY()。如果秘密生成失败,结果是空的。

    支持key_len价值观:在比特的最大和最小密钥长度分别为1024和10000。这些密钥长度的限制是由OpenSSL的约束。服务器管理员可以施加额外的限制最大密钥长度的设置环境变量。看到第12.18.2,“企业加密使用的例子”

    一个例子展示了如何使用返回值生成对称密钥,看到的描述ASYMMETRIC_DERIVE()

    SET @dhp = CREATE_DH_PARAMETERS(1024);
  • CREATE_DIGEST(digest_type, str)

    创建一个消化从给定的字符串使用给定的消化型,作为一个二进制字符串返回消化。如果消化生成失败,结果是NULL

    支持digest_type价值观:“sha224”'SHA256'“SHA384”'SHA512'

    SET @dig = CREATE_DIGEST('SHA512', The quick brown fox');

    结果消化系列适用于ASYMMETRIC_SIGN()asymmetric_verify()

12.19骨料(组)功能

12.19.1骨料(组)功能描述

本节介绍了集团(总)函数操作的值集。

表12.25总(组)功能

姓名描述
AVG()返回参数的平均值
BIT_AND()回位,
BIT_OR()回位或
BIT_XOR()返回按位异或
COUNT()返回一个数,返回的行数
COUNT(DISTINCT)返回一个数的不同值的数量
GROUP_CONCAT()返回一个连接字符串
JSON_ARRAYAGG()返回的结果集作为一个单一的JSON数组
JSON_OBJECTAGG()返回的结果集作为一个单一的JSON对象
MAX()返回的最大值
MIN()返回最小值
STD()返回的总体标准偏差
STDDEV()返回的总体标准偏差
STDDEV_POP()返回的总体标准偏差
STDDEV_SAMP()返回的样本标准偏差
SUM()收益之和
VAR_POP()返回的人口标准方差
VAR_SAMP()返回的样本方差
VARIANCE()返回的人口标准方差

除非另有说明,组函数忽略NULL价值观

如果你在一份声明中不包含使用一组函数GROUP BY条款,这相当于在所有行分组。有关更多信息,参见第12.19.3,MySQL处理组”

大多数的聚合函数可以作为窗函数。那些可以用这种方式表明他们的语法描述[over_clause],表示一个可选条款.over_clause描述的是第12.20.2,“窗函数的概念和语法”,其中还包括其他信息,窗函数的用法。

数字参数,方差和标准差函数返回DOUBLE价值。这个SUM()AVG()函数返回一个DECIMAL确切的值参数值(整数或DECIMAL),和DOUBLE近似值的参数值(FLOATDOUBLE

这个SUM()AVG()聚合函数不具有时间价值。(他们将这些值的数字,第一个数字字符。在失去一切)要解决这一问题,转换为数值的单位,进行集合运算,并将回到时间的价值。实例:

选择sec_to_time(sum(time_to_sec(time_col从)))tbl_name;选择from_days(和(to_days(date_col从)))tbl_name

等功能SUM()AVG()期待一个数字参数将参数数量如果必要。为SETENUM价值观,铸造操作导致底层的数值被用。

这个BIT_AND()BIT_OR(),和BIT_XOR()聚合函数进行位操作。MySQL 8之前,所需的位函数和操作符BIGINT(64位整数)参数和返回BIGINT值,所以他们有一个64位的最大范围。非—BIGINT参数转换为BIGINT在此之前执行的操作和截断可能发生。

在MySQL 8中,点函数和运算符允许二进制字符串类型的参数(BINARYVARBINARY,和BLOB类型)和返回值类型一样,使他们能够采取的参数和返回值大于64位的产生。为探讨论证评估和结果类型,位运算,看到介绍性的讨论12.12节,“点函数和操作符”

  • AVG([DISTINCT] expr) [over_clause]

    回报率的平均值expr。这个不同的选项可以用来返回不同的值的平均值expr

    如果没有匹配的行,AVG()退货无效的

    这个函数执行一个窗口功能over_clause是存在的over_clause所述第12.20.2,“窗函数的概念和语法”;它不能用于DISTINCT

    MySQL的&#62;SELECT student_name, AVG(test_score)FROM studentGROUP BY student_name;
  • BIT_AND(expr) [over_clause]

    返回的位AND所有的位expr

    结果类型取决于函数的参数值进行评估,为二进制字符串或数字:

    • 二进制字符串评价时发生的参数值都有一个二进制字符串类型和参数不是一个进制文字,点文字,或NULL字面意义的.数值评价发生否则,参数值转换为无符号64位整数是必要的。

    • 二进制字符串评价产生一个相同长度的二进制字符串作为参数值。如果参数值都有一个长度不等,ER_INVALID_BITWISE_OPERANDS_SIZE错误发生。如果参数的大小超过511字节,一个ER_INVALID_BITWISE_AGGREGATE_OPERANDS_SIZE错误发生。数值评价产生一个64位无符号整数。

    如果没有匹配的行,BIT_AND()返回一个中立的价值(所有位设置为1)具有相同的长度作为参数值。

    NULL值不影响结果,除非所有的值无效的。在这种情况下,结果是一个具有相同的长度作为参数值价值中立。

    有关参数评价和结果类型的更多信息的讨论,看到介绍性的讨论12.12节,“点函数和操作符”

    在MySQL 8.0.12,这个函数执行一个窗口功能over_clause是存在的over_clause所述第12.20.2,“窗函数的概念和语法”

  • BIT_OR(expr) [over_clause]

    返回的位OR所有的位expr

    结果类型取决于函数的参数值进行评估,为二进制字符串或数字:

    • 二进制字符串评价时发生的参数值都有一个二进制字符串类型和参数不是一个进制文字,点文字,或NULL字面意义的.数值评价发生否则,参数值转换为无符号64位整数是必要的。

    • 二进制字符串评价产生一个相同长度的二进制字符串作为参数值。如果参数值都有一个长度不等,ER_INVALID_BITWISE_OPERANDS_SIZE错误发生。如果参数的大小超过511字节,一个ER_INVALID_BITWISE_AGGREGATE_OPERANDS_SIZE错误发生。数值评价产生一个64位无符号整数。

    如果没有匹配的行,BIT_OR()返回一个中立的价值(所有位设置为0)具有相同的长度作为参数值。

    NULL值不影响结果,除非所有的值无效的。在这种情况下,结果是一个具有相同的长度作为参数值价值中立。

    有关参数评价和结果类型的更多信息的讨论,看到介绍性的讨论12.12节,“点函数和操作符”

    在MySQL 8.0.12,这个函数执行一个窗口功能over_clause是存在的over_clause所述第12.20.2,“窗函数的概念和语法”

  • BIT_XOR(expr) [over_clause]

    返回的位XOR所有的位expr

    结果类型取决于函数的参数值进行评估,为二进制字符串或数字:

    • 二进制字符串评价时发生的参数值都有一个二进制字符串类型和参数不是一个进制文字,点文字,或NULL字面意义的.数值评价发生否则,参数值转换为无符号64位整数是必要的。

    • 二进制字符串评价产生一个相同长度的二进制字符串作为参数值。如果参数值都有一个长度不等,ER_INVALID_BITWISE_OPERANDS_SIZE错误发生。如果参数的大小超过511字节,一个ER_INVALID_BITWISE_AGGREGATE_OPERANDS_SIZE错误发生。数值评价产生一个64位无符号整数。

    如果没有匹配的行,BIT_XOR()返回一个中立的价值(所有位设置为0)具有相同的长度作为参数值。

    NULL值不影响结果,除非所有的值无效的。在这种情况下,结果是一个具有相同的长度作为参数值价值中立。

    有关参数评价和结果类型的更多信息的讨论,看到介绍性的讨论12.12节,“点函数和操作符”

    在MySQL 8.0.12,这个函数执行一个窗口功能over_clause是存在的over_clause所述第12.20.2,“窗函数的概念和语法”

  • COUNT(expr) [over_clause]

    返回非数—NULLexpr在检索一行SELECT声明。其结果是一个BIGINT价值

    如果没有匹配的行,COUNT()退货

    这个函数执行一个窗口功能over_clause是存在的over_clause所述第12.20.2,“窗函数的概念和语法”

    mysql> SELECT student.student_name,COUNT(*)
           FROM student,course
           WHERE student.student_id=course.student_id
           GROUP BY student_name;
    

    COUNT(*)稍有不同,它返回检索出的行数,是否含有无效的价值观

    事务存储引擎等InnoDB,存储一个确切的行数是有问题的。多个事务可以在同一时间发生,每一个可能影响计数。

    InnoDB不保持在一个表中的行数可能会因为内部事务看见同时行不同的号码。因此,SELECT COUNT(*)陈述只算行到当前事务可见。

    世纪之mysql 8.0.13,SELECT COUNT(*) FROM tbl_name查询性能InnoDB表是优化单线程的工作量如果没有这些额外的条款WHERE

    InnoDB过程select count(*)通过可用的最小二指标除非索引或优化器提示指示优化器使用不同的指标报表。如果一个次要指标是不存在的,InnoDB过程select count(*)通过扫描聚集索引表

    处理SELECT COUNT(*)报表需要一些时间,如果指数记录不完全的缓冲池中。一个更快的计数,创建一个计数器表让你的应用更新,根据插入和删除它。然而,这种方法不很好的情况下,成千上万的并发事务启动升级相同的计数器表。如果一个近似的行数是足够的,使用SHOW TABLE STATUS

    InnoDB处理select count(*)SELECT COUNT(1)以同样的方式操作。没有性能差异。

    MyISAM桌子,COUNT(*)优化迅速返回如果SELECT从一个表中检索检索,没有其他列,并没有哪里的条款。例如:

    mysql> SELECT COUNT(*) FROM student;
    

    该算法只适用于MyISAM表,因为一个确切的行计数存储该存储引擎,可以很快的。数(1)只有受到同样的优化如果第一列定义为NOT NULL

  • COUNT(DISTINCT expr,[expr...])

    返回一个数的行数与不同的非—NULLexpr价值观

    如果没有匹配的行,COUNT(DISTINCT)退货

    mysql> SELECT COUNT(DISTINCT results) FROM student;
    

    在MySQL,你可以得到不同的表达组合,不数包含NULL通过给一个表达式列表。在标准的SQL,你会做一个级联的所有表达式里面COUNT(DISTINCT ...)

  • GROUP_CONCAT(expr)

    这个函数返回一个字符串,结果与级联非—NULL从一组值。它返回无效的if there are不是NULL价值观。完整的语法如下:

    group_concat([明显]expr【,expr[…]以{unsigned_integer|col_name|exprasc desc | } [的],col_name(分离器)str_val])
    MySQL的&#62;SELECT student_name,GROUP_CONCAT(test_score)FROM studentGROUP BY student_name;

    mysql> SELECT student_name,
             GROUP_CONCAT(DISTINCT test_score
                          ORDER BY test_score DESC SEPARATOR ' ')
           FROM student
           GROUP BY student_name;
    

    在MySQL,你可以得到表达组合的连接值。为了消除重复的值,使用DISTINCT条款.在结果值排序,使用顺序条款.要以相反的顺序排序,添加DESC(降)关键字你排序的列的名称顺序条款.默认是升序;这可能是显式指定的使用ASC关键词在一组数值之间的默认分隔符是逗号()。指定一个显式分离器,使用SEPARATOR其次是字符串值,应插入之间的群体价值观。完全消除隔膜,指定分离器”

    结果被截断的最大长度是由group_concat_max_len系统变量,它的默认值为1024。该值可设定较高,虽然返回值的最大长度的值是有效的约束max_allowed_packet。语法变化的价值group_concat_max_len在运行时,如下,其中val是一个无符号整数:

    SET [GLOBAL | SESSION] group_concat_max_len =val

    返回值是一个二进制或二进制字符串,这取决于参数的二进制或二进制字符串。结果类型TEXTBLOB除非group_concat_max_len小于或等于512,在这种情况下,结果类型是VARCHARVARBINARY

    参见CONCAT()CONCAT_WS()12.5节,“字符串函数”

  • JSON_ARRAYAGG(col_or_expr)

    聚集的结果集作为一个单一的JSON数组的元素构成的行。在这个数组元素的顺序是不确定的。在一列或计算结果为单个值的表达式的函数的行为。退货无效的如果结果不包含行,或在发生错误。

    mysql> SELECT o_id, attribute, value FROM t3;
    +------+-----------+-------+
    | o_id | attribute | value |
    +------+-----------+-------+
    |    2 | color     | red   |
    |    2 | fabric    | silk  |
    |    3 | color     | green |
    |    3 | shape     | square|
    +------+-----------+-------+
    4 rows in set (0.00 sec)
    
    mysql> SELECT o_id, JSON_ARRAYAGG(attribute) AS attributes 
         > FROM t3 GROUP BY o_id;
    +------+---------------------+
    | o_id | attributes          |
    +------+---------------------+
    |    2 | ["color", "fabric"] |
    |    3 | ["color", "shape"]  |
    +------+---------------------+
    2 rows in set (0.00 sec)
    
  • JSON_OBJECTAGG(key, value)

    以两列名称或表达式作为参数,这些作为键和第二作为价值第一,并返回一个包含键值对JSON对象。退货NULL如果结果不包含行,或在发生错误。如果任何关键的名字是发生错误无效的或参数个数不等于2

    mysql> SELECT o_id, attribute, value FROM t3;
    +------+-----------+-------+
    | o_id | attribute | value |
    +------+-----------+-------+
    |    2 | color     | red   |
    |    2 | fabric    | silk  |
    |    3 | color     | green |
    |    3 | shape     | square|
    +------+-----------+-------+
    4 rows in set (0.00 sec)
    
    mysql> SELECT o_id, JSON_OBJECTAGG(attribute, value) FROM t3 GROUP BY o_id;
    +------+----------------------------------------+
    | o_id | JSON_OBJECTAGG(attribute, name)        |
    +------+----------------------------------------+
    |    2 | {"color": "red", "fabric": "silk"}     |
    |    3 | {"color": "green", "shape": "square"}  |
    +------+----------------------------------------+
    1 row in set (0.00 sec)
    
  • MAX([DISTINCT] expr) [over_clause]

    返回最大值exprMAX()可能需要一个字符串参数;在这种情况下,它返回的字符串最大值。看到第8.3.1,“MySQL如何使用索引”。这个DISTINCT关键词可以找到不同的值最大expr,然而,这产生的结果相同的省略不同的

    如果没有匹配的行,MAX()退货无效的

    这个函数执行一个窗口功能over_clause是存在的over_clause所述第12.20.2,“窗函数的概念和语法”;它不能用于DISTINCT

    MySQL的&#62;SELECT student_name, MIN(test_score), MAX(test_score)FROM studentGROUP BY student_name;

    MAX()目前,MySQL的比较ENUMSET列的字符串值而不是集合中的字符串的相对位置。这不同于如何顺序比较

  • MIN([DISTINCT] expr) [over_clause]

    返回最小值exprMIN()可能需要一个字符串参数;在这种情况下,它返回的字符串值的最小值。看到第8.3.1,“MySQL如何使用索引”。这个DISTINCT关键词可以找到不同的值最小expr,然而,这产生的结果相同的省略不同的

    如果没有匹配的行,MIN()退货无效的

    这个函数执行一个窗口功能over_clause是存在的over_clause所述第12.20.2,“窗函数的概念和语法”;它不能用于DISTINCT

    MySQL的&#62;SELECT student_name, MIN(test_score), MAX(test_score)FROM studentGROUP BY student_name;

    MIN()目前,MySQL的比较ENUMSET列的字符串值而不是集合中的字符串的相对位置。这不同于如何顺序比较

  • STD(expr) [over_clause]

    返回人口标准偏差exprSTD()是一个标准的SQL函数的同义词STDDEV_POP(),提供一个MySQL扩展。

    如果没有匹配的行,STD()退货无效的

    这个函数执行一个窗口功能over_clause是存在的over_clause所述第12.20.2,“窗函数的概念和语法”

  • STDDEV(expr) [over_clause]

    返回人口标准偏差exprSTDDEV()是一个标准的SQL函数的同义词STDDEV_POP()提供兼容性,Oracle。

    如果没有匹配的行,STDDEV()退货无效的

    这个函数执行一个窗口功能over_clause是存在的over_clause所述第12.20.2,“窗函数的概念和语法”

  • STDDEV_POP(expr) [over_clause]

    返回人口标准偏差expr(平方根VAR_POP()页:1你也可以使用STD()STDDEV()这是等效的,但不是标准的SQL。

    如果没有匹配的行,STDDEV_POP()退货无效的

    这个函数执行一个窗口功能over_clause是存在的over_clause所述第12.20.2,“窗函数的概念和语法”

  • STDDEV_SAMP(expr) [over_clause]

    返回的样本标准偏差expr(平方根VAR_SAMP()

    如果没有匹配的行,STDDEV_SAMP()退货无效的

    这个函数执行一个窗口功能over_clause是存在的over_clause所述第12.20.2,“窗函数的概念和语法”

  • SUM([DISTINCT] expr) [over_clause]

    收益的总和expr。如果返回无行,SUM()退货无效的。这个DISTINCT关键词可以用来总结只有独特的价值expr

    如果没有匹配的行,SUM()退货无效的

    这个函数执行一个窗口功能over_clause是存在的over_clause所述第12.20.2,“窗函数的概念和语法”;它不能用于DISTINCT

  • VAR_POP(expr) [over_clause]

    返回人口标准方差expr。它认为行作为整个群体,而不是作为一个样本,那么它的行数作为分母。你也可以使用VARIANCE()这是等价的,但不是标准的SQL。

    如果没有匹配的行,VAR_POP()退货无效的

    这个函数执行一个窗口功能over_clause是存在的over_clause所述第12.20.2,“窗函数的概念和语法”

  • VAR_SAMP(expr) [over_clause]

    返回的样本方差expr。即,分母是行数减一。

    如果没有匹配的行,VAR_SAMP()退货无效的

    这个函数执行一个窗口功能over_clause是存在的over_clause所述第12.20.2,“窗函数的概念和语法”

  • VARIANCE(expr) [over_clause]

    返回人口标准方差exprVARIANCE()是一个标准的SQL函数的同义词VAR_POP(),提供一个MySQL扩展。

    如果没有匹配的行,VARIANCE()退货无效的

    这个函数执行一个窗口功能over_clause是存在的over_clause所述第12.20.2,“窗函数的概念和语法”

12.19.2集团的编辑修改器

这个GROUP BY条款允许与汇总改性剂使汇总输出包括额外的行,代表上级(即超总量)简易操作。ROLLUP从而使你回答问题在多层次的分析与一个单一的查询。例如,汇总可以用来支持OLAP(在线分析处理)操作。

假设一个salescountry产品,和profit记录销售利润柱:

Create Table Sales(Year Int,Country Varchar(20),Product Varchar(32),Profit Int);

表内容每年总结,用一个简单的GROUP BY这样地:

MySQL的&#62;SELECT year, SUM(profit) AS profitFROM salesGROUP BY year;------ -------- |年|利润| ------ -------- | 2000 | 4525 | | 2001 | 3010 | ------ --------

输出显示总(总)每年的利润。也确定总利润总结以上所有年,你必须将自己的个人价值观或运行其他查询。或者你可以使用ROLLUP,它提供了两个层次的分析与一个单一的查询。添加一个与汇总改性剂的GROUP BY条款会导致查询产生的另一个(超总量)行显示在所有的年份值总计:

MySQL的&#62;SELECT year, SUM(profit) AS profitFROM salesGROUP BY year WITH ROLLUP;------ -------- |年|利润| ------ -------- | 2000 | 4525 | | 2001 | 3010 | |空| 7535 | ------ --------

这个NULL中的价值列标识总计超聚合线

ROLLUP有一个更复杂的效果,当有多个专栏在这种情况下,每次有一个变化值在任何但最后一组列,查询产生一个额外的超级汇总行。

例如,没有ROLLUP的一个总结,特价表的基础上year国家,和product也许是这样的,在输出指示汇总值只有在年/国/产品水平分析:

MySQL的&#62;SELECT year, country, product, SUM(profit) AS profitFROM salesGROUP BY year, country, product;------ --------- ------------ -------- |年|国|产品|利润| ------ --------- ------------ -------- | 2000 |芬兰|计算机| 1500 | | 2000 |芬兰|电话| 100 | | 2000 |印度|计算器| 150 | | 2000 |印度|计算机| 1200 | | 2000 |美国|计算器| 75 | | 2000 |美国|计算机| 1500 | | 2001 |芬兰|电话| 10 | | 2001 |美国|计算器| 50 | | 2001 |美国|计算机| 2700 | | 2001 |美国|电视| 250 | ------ --------- ------------ --------

ROLLUP添加,查询产生一些额外的行:

MySQL的&#62;SELECT year, country, product, SUM(profit) AS profitFROM salesGROUP BY year, country, product WITH ROLLUP;------ --------- ------------ -------- |年|国|产品|利润| ------ --------- ------------ -------- | 2000 |芬兰|计算机| 1500 | | 2000 |芬兰|电话| 100 | | 2000 |芬兰|空| 1600 | | 2000 |印度|计算器| 150 | | 2000 |印度|计算机| 1200 | | 2000 |印度|空| 1350 | | 2000 |美国|计算器| 75 | | 2000 |美国|计算机| 1500 | | 2000 |美国|空| 1575 | | 2000 |空|空| 4525 | | 2001 |芬兰|电话| 10 | | 2001 |芬兰|空| 10 | | 2001 |美国|计算器| 50 | | 2001 |美国|计算机| 2700 | | 2001 |美国|电视| 250 | | 2001 |美国|空| 3000 | | 2001 |空|空| 3010 | |空|空|空| 7535 | ------ --------- ------------ --------

现在的输出包括汇总信息在分析的4个层次,不只是一个:

  • 下面的每一套产品行某一年的国家,一个额外的超级汇总行显示所有产品的总。这些行有product栏目设置无效的

  • 以下每一组行中的某一年,一个额外的超级汇总行显示所有国家和产品的总。这些行有country产品栏目设置NULL

  • 最后,在所有其他行,额外的超级汇总行显示所有年,总计国家和产品。这行的year国家,和products栏目设置无效的

此前,MySQL不允许使用DISTINCT顺序在一个查询中有一个WITH ROLLUP选项这种限制是在MySQL 8.0.12后来取消。(错误# 87450,错误# 86311,错误# 26640100,错误# 26073513)

GROUP BY ... WITH ROLLUP查询,whether to test无效的在结果值代表超级聚合值的GROUPING()功能是可用于在选择列表,条款,and(as of MySQL 8.0.12)ORDER BY条款.例如,GROUPING(year)返回1时无效的year列出现在超级合计行,否则。同样,GROUPING(country)GROUPING(product)超总回报1无效的中的值country产品列,分别:

mysql> SELECT
         year, country, product, SUM(profit) AS profit,
         GROUPING(year) AS grp_year,
         GROUPING(country) AS grp_country,
         GROUPING(product) AS grp_product
       FROM sales
       GROUP BY year, country, product WITH ROLLUP;
+------+---------+------------+--------+----------+-------------+-------------+
| year | country | product    | profit | grp_year | grp_country | grp_product |
+------+---------+------------+--------+----------+-------------+-------------+
| 2000 | Finland | Computer   |   1500 |        0 |           0 |           0 |
| 2000 | Finland | Phone      |    100 |        0 |           0 |           0 |
| 2000 | Finland | NULL       |   1600 |        0 |           0 |           1 |
| 2000 | India   | Calculator |    150 |        0 |           0 |           0 |
| 2000 | India   | Computer   |   1200 |        0 |           0 |           0 |
| 2000 | India   | NULL       |   1350 |        0 |           0 |           1 |
| 2000 | USA     | Calculator |     75 |        0 |           0 |           0 |
| 2000 | USA     | Computer   |   1500 |        0 |           0 |           0 |
| 2000 | USA     | NULL       |   1575 |        0 |           0 |           1 |
| 2000 | NULL    | NULL       |   4525 |        0 |           1 |           1 |
| 2001 | Finland | Phone      |     10 |        0 |           0 |           0 |
| 2001 | Finland | NULL       |     10 |        0 |           0 |           1 |
| 2001 | USA     | Calculator |     50 |        0 |           0 |           0 |
| 2001 | USA     | Computer   |   2700 |        0 |           0 |           0 |
| 2001 | USA     | TV         |    250 |        0 |           0 |           0 |
| 2001 | USA     | NULL       |   3000 |        0 |           0 |           1 |
| 2001 | NULL    | NULL       |   3010 |        0 |           1 |           1 |
| NULL | NULL    | NULL       |   7535 |        1 |           1 |           1 |
+------+---------+------------+--------+----------+-------------+-------------+

不显示GROUPING()结果直接,你可以使用GROUPING()用标签的超级集合无效的价值观:

mysql> SELECT
         IF(GROUPING(year), 'All years', year) AS year,
         IF(GROUPING(country), 'All countries', country) AS country,
         IF(GROUPING(product), 'All products', product) AS product,
         SUM(profit) AS profit
       FROM sales
       GROUP BY year, country, product WITH ROLLUP;
+-----------+---------------+--------------+--------+
| year      | country       | product      | profit |
+-----------+---------------+--------------+--------+
| 2000      | Finland       | Computer     |   1500 |
| 2000      | Finland       | Phone        |    100 |
| 2000      | Finland       | All products |   1600 |
| 2000      | India         | Calculator   |    150 |
| 2000      | India         | Computer     |   1200 |
| 2000      | India         | All products |   1350 |
| 2000      | USA           | Calculator   |     75 |
| 2000      | USA           | Computer     |   1500 |
| 2000      | USA           | All products |   1575 |
| 2000      | All countries | All products |   4525 |
| 2001      | Finland       | Phone        |     10 |
| 2001      | Finland       | All products |     10 |
| 2001      | USA           | Calculator   |     50 |
| 2001      | USA           | Computer     |   2700 |
| 2001      | USA           | TV           |    250 |
| 2001      | USA           | All products |   3000 |
| 2001      | All countries | All products |   3010 |
| All years | All countries | All products |   7535 |
+-----------+---------------+--------------+--------+

多个表达式参数,GROUPING()返回一个结果代表一位掩码的结合每个表达式的结果,有相应的结果,最右边的表达式的最低阶。例如,GROUPING(year, country, product)这样的评价:

结果分组(product分组的结果是()country) << 1+ result for GROUPING(year) << 2

这样的一个结果GROUPING()是非零,如果表达的是一个超级集合无效的,所以你只能返回超级合计行和过滤规则分组的行像这样:

mysql> SELECT year, country, product, SUM(profit) AS profit
       FROM sales
       GROUP BY year, country, product WITH ROLLUP
       HAVING GROUPING(year, country, product) <> 0;
+------+---------+---------+--------+
| year | country | product | profit |
+------+---------+---------+--------+
| 2000 | Finland | NULL    |   1600 |
| 2000 | India   | NULL    |   1350 |
| 2000 | USA     | NULL    |   1575 |
| 2000 | NULL    | NULL    |   4525 |
| 2001 | Finland | NULL    |     10 |
| 2001 | USA     | NULL    |   3000 |
| 2001 | NULL    | NULL    |   3010 |
| NULL | NULL    | NULL    |   7535 |
+------+---------+---------+--------+

这个sales表中没有无效的值,所以NULL中的值汇总结果代表总价值超。当数据集包含NULL价值观,汇总摘要可以包含NULL价值观不仅在超级合计行,而且在普通分组的行。GROUPING()使这些有区别。假设表T1包含一个简单的数据集分组因素的一组量值,其中NULL表明什么其他未知

mysql> SELECT * FROM t1;
+------+-------+----------+
| name | size  | quantity |
+------+-------+----------+
| ball | small |       10 |
| ball | large |       20 |
| ball | NULL  |        5 |
| hoop | small |       15 |
| hoop | large |        5 |
| hoop | NULL  |        3 |
+------+-------+----------+

一个简单的ROLLUP操作产生的结果,它是不那么容易区分无效的值超聚合的行NULL在普通分组的行值:

MySQL的&#62;SELECT name, size, SUM(quantity) AS quantityFROM t1GROUP BY name, size WITH ROLLUP;------ ------- ---------- |名字|大小|数量| ------ ------- ---------- |球|空| 5 | |球|大| 20 | |球|小| 10 | |球|空| 35 | |箍|空| 3 | |箍|大| 5 | |箍|小| 15 | |箍|空| 23 | |空|空| 58 | ------ ------- ----------

使用GROUPING()用标签的超级集合无效的值,使结果更容易解释:

mysql> SELECT
         IF(GROUPING(name) = 1, 'All items', name) AS name,
         IF(GROUPING(size) = 1, 'All sizes', size) AS size,
         SUM(quantity) AS quantity
       FROM t1
       GROUP BY name, size WITH ROLLUP;
+-----------+-----------+----------+
| name      | size      | quantity |
+-----------+-----------+----------+
| ball      | NULL      |        5 |
| ball      | large     |       20 |
| ball      | small     |       10 |
| ball      | All sizes |       35 |
| hoop      | NULL      |        3 |
| hoop      | large     |        5 |
| hoop      | small     |       15 |
| hoop      | All sizes |       23 |
| All items | All sizes |       58 |
+-----------+-----------+----------+

其他注意事项汇总时使用

下列讨论一些特定行为的MySQL实现ROLLUP

MySQL 8.0.12之前,当你使用ROLLUP,你也不能使用顺序子句排序的结果。换句话说,ROLLUP顺序在MySQL相互排斥。然而,你仍然在排序顺序控制。在限制,防止使用工作ROLLUP顺序实现分组结果的具体排序,生成分组的结果集作为一个派生表和申请ORDER BY它。例如:

MySQL的&#62;SELECT * FROM(SELECT year, SUM(profit) AS profitFROM sales GROUP BY year WITH ROLLUP) AS dtORDER BY year DESC;------ -------- |年|利润| ------ -------- | 2001 | 3010 | | 2000 | 4525 | |空| 7535 | ------ --------

世纪之mysql 8.0.12,ORDER BY汇总可以一起使用,使使用ORDER BYGROUPING()为了实现某个特定的排序顺序分组结果。例如:

MySQL的&#62;SELECT year, SUM(profit) AS profitFROM salesGROUP BY year WITH ROLLUPORDER BY GROUPING(year) DESC;------ -------- |年|利润| ------ -------- |空| 7535 | | 2000 | 4525 | | 2001 | 3010 | ------ --------

在这两种情况下,超级汇总的行排序的计算行,和他们的位置取决于排序(最后为升序排序,在排序的开始)。

LIMIT可以用来限制行数返回给客户端。极限应用后ROLLUP,所以限制适用于对额外添加的行汇总。。。。。。。例如:

mysql> SELECT year, country, product, SUM(profit) AS profit
       FROM sales
       GROUP BY year, country, product WITH ROLLUP
       LIMIT 5;
+------+---------+------------+--------+
| year | country | product    | profit |
+------+---------+------------+--------+
| 2000 | Finland | Computer   |   1500 |
| 2000 | Finland | Phone      |    100 |
| 2000 | Finland | NULL       |   1600 |
| 2000 | India   | Calculator |    150 |
| 2000 | India   | Computer   |   1200 |
+------+---------+------------+--------+

使用LIMIT汇总可能产生的结果是难以解释的,因为那里是了解超级合计行背景。

这个NULL在每个超级合计行指标时产生的行发送到客户端。服务器看列在以下条款最左边的一个变化值。在设置一个名称相匹配的那些名字,结果任何列,它的值设置为NULL。(如果你指定的列的位置,分组列服务器标识列的设置无效的的位置。)

因为NULL在超级合计行值放入结果集中在查询处理中如此晚的阶段,你可以测试他们无效的只有在选择列表中的值或HAVING条款.你不能测试他们无效的在加入条件或值WHERE子句确定哪些行选择。例如,您不能添加当产品是空的的查询来消除输出所有但超级合计行。

这个NULL价值观出现无效的在客户端可以测试,如使用MySQL客户端编程接口。然而,在这一点上,你不能分辨一NULL是一个常规的组合值或超总价值。

MySQL扩展允许一列不出现在GROUP BY单是在选择列表中指定。(关于非聚合的列信息,看到第12.19.3,MySQL处理组”。)在这种情况下,服务器可以自由选择从这个非汇总列在总结行任何价值,这包括额外的行添加WITH ROLLUP。例如,在下面的查询,国家是一个非聚合的列不出现在GROUP BY列表和值选择此列是不确定的:

MySQL的&#62;SELECT year, country, SUM(profit) AS profitFROM salesGROUP BY year WITH ROLLUP;------ --------- -------- |年|国|利润| ------ --------- -------- | 2000 |印度| 4525 | | 2001 |美国| 3010 | |空|美国| 7535 | ------ --------- --------

这种行为是允许的,ONLY_FULL_GROUP_BYSQL模式未启用。如果这种模式被启用,服务器将拒绝查询违法,因为国家不列入GROUP BY条款.与ONLY_FULL_GROUP_BY启用后,你仍然可以执行查询用any_value()不确定值的列的功能:

mysql> SELECT year, ANY_VALUE(country) AS country, SUM(profit) AS profit
       FROM sales
       GROUP BY year WITH ROLLUP;
+------+---------+--------+
| year | country | profit |
+------+---------+--------+
| 2000 | India   |   4525 |
| 2001 | USA     |   3010 |
| NULL | USA     |   7535 |
+------+---------+--------+

12.19.3 MySQL处理组

SQL92早不允许查询的选择列表,HAVING条件,或顺序列表是指非汇总,未命名的列GROUP BY条款.例如,该查询是非法的标准SQL92因为非汇总姓名选择列表中的列不出现在GROUP BY

SELECT o.custid, c.name, MAX(o.payment)  FROM orders AS o, customers AS c  WHERE o.custid = c.custid  GROUP BY o.custid;

对SQL92被合法的查询,name列必须省略选择列表或指定的条款.

SQL99后来允许这种nonaggregates每可选功能T301如果他们的功能依赖于GROUP BY列:如果这种关系之间存在姓名custid,查询是合法的。这就比如是这样的,,是custId主键customers

MySQL实现功能相关检测。如果ONLY_FULL_GROUP_BYSQL模式启用(这是默认的),MySQL拒绝查询的选择列表,条件,或ORDER BY列表是指非汇总,既不指定列中的条款和功能取决于他们。

如果ONLY_FULL_GROUP_BY是残疾人,MySQL扩展标准SQL的使用允许选择列表,HAVING条件,或顺序单指非汇总列即使列不函数依赖GROUP BY专栏这会导致MySQL接受前面的查询。在这种情况下,服务器可以自由选择从每个组中的任何值,所以除非他们是相同的,选择的值是不确定的,这可能不是你想要的。此外,从每个组中选择的值不受添加顺序条款.结果集排序后的值被选择时,和ORDER BY不影响它的价值在每一组中的服务器选择。禁用ONLY_FULL_GROUP_BY是很有用,当你知道,由于数据的一些属性,在每个非汇总列在未命名的所有值是相同的每个组

你可以达到同样的效果,不禁用ONLY_FULL_GROUP_BY通过使用ANY_VALUE()指非汇总列

下面的讨论演示功能的依赖,错误消息MySQL时产生函数依赖是不存在的,并导致MySQL接受函数相关的缺失的查询方式。

该查询可能无效ONLY_FULL_GROUP_BY使由于非汇总地址选择列表中的列是不点名的GROUP BY条款:

选择的名称,地址,最大(年龄)T组的名字;

查询有效,如果name是一个主要的关键T或是一个独特的NOT NULL专栏在这种情况下,MySQL确认所选列的功能依赖于一个分组的列。例如,如果姓名是一个主键,其价值决定价值address因为每个组只有一个值的主键,因此只有一行。作为一个结果,有没有随机性选择地址在一组值,没有必要拒绝查询。

如果查询是无效的name是不是一个主要的关键T或一个独特的NOT NULL专栏在这种情况下,没有函数依赖可以推断,发生了一个错误:

MySQL的&#62;SELECT name, address, MAX(age) FROM t GROUP BY name;ERROR 1055 (42000): Expression #2 of SELECT list is not in GROUPBY clause and contains nonaggregated column 'mydb.t.address' whichis not functionally dependent on columns in GROUP BY clause; thisis incompatible with sql_mode=only_full_group_by

如果你知道,对于一个给定的数据看,每个name事实上,唯一确定的价值地址价值,address函数依赖是有效的姓名。告诉MySQL接受查询,您可以使用ANY_VALUE()功能:

选择的名字,any_value(地址)、马克斯(年龄)T组的名字;

另外,禁用ONLY_FULL_GROUP_BY

前面的例子是相当简单的,然而。特别是,它不太可能你会在某个主键列因为每一组只包含一行。对于额外的例子演示的功能依赖于更复杂的查询,看第12.19.4,”功能依赖检测”

如果一个查询的聚合函数和无GROUP BY条款,它不能选择列表中的列有非汇总,条件,或ORDER BY列表ONLY_FULL_GROUP_BY启用:

MySQL的&#62;SELECT name, MAX(age) FROM t;ERROR 1140 (42000): In aggregated query without GROUP BY, expression#1 of SELECT list contains nonaggregated column 'mydb.t.name'; thisis incompatible with sql_mode=only_full_group_by

没有GROUP BY,有一个组,它是不确定的,姓名选择对群体价值。在这里,太,ANY_VALUE()可以使用,如果它是无形的,姓名MySQL的选择价值:

SELECT ANY_VALUE(name), MAX(age) FROM t;

ONLY_FULL_GROUP_BY也会影响查询处理,使用不同的ORDER BY。考虑一个表的情况下T三列c1C2,和c3包含这些行:

C1、C2 c31 A3 B1(C 2 2 4

假设我们执行以下查询,期待的结果是有序的c3

选择不同的C1,C2,C3 T;

命令的结果,必须首先消除重复。但这样做,我们应该把第一排或第三?这种任意选择的保留值的影响c3,这反过来又影响排序使其任意以及。为了避免这个问题,查询,不同的ORDER BY如果任何被拒绝无效顺序表达不满足这些条件中的至少一个:

  • 选择列表中的表达式等于一

  • 所有列引用的表达和归属地查询所选择的表的SELECT列表元素

另一个MySQL扩展SQL允许引用的标准HAVING在选择列表中的别名表达式子句。例如,下面的查询返回姓名只有一次在表产生的价值orders

SELECT name, COUNT(name) FROM orders  GROUP BY name  HAVING COUNT(name) = 1;

MySQL扩展允许在别名的使用HAVING对于聚合列条款:

SELECT name, COUNT(name) AS c FROM orders  GROUP BY name  HAVING c = 1;

标准SQL只允许列的表达GROUP BY条款,所以这样一个语句是无效的原因楼(价值/ 100)是noncolumn表达:

SELECT id, FLOOR(value/100)
  FROM tbl_name
  GROUP BY id, FLOOR(value/100);

MySQL扩展了标准SQL允许noncolumn表达GROUP BY条款并考虑前面的声明有效。

标准的SQL也不允许别名GROUP BY条款.MySQL扩展了标准SQL允许别名,所以另一种方式来编写查询语句如下:

选择ID、地板(价值/ 100)为Val从tbl_name集团通过ID,价值;

别名val考虑在列的表达条款.

在presence的noncolumn expression在GROUP BY子句,MySQL承认在选择列表中的表达和表达之间的平等。这意味着,ONLY_FULL_GROUP_BYSQL模式启用,查询包含组ID,地板(价值100)因为同样是有效的FLOOR()表达出现在选择列表。然而,MySQL不认功能依赖noncolumn表达式,所以下面的查询无效ONLY_FULL_GROUP_BY启用,尽管第三个选择是一个简单的公式表达身份证件柱和FLOOR()中的表达条款:

SELECT id, FLOOR(value/100), id+FLOOR(value/100)
  FROM tbl_name
  GROUP BY id, FLOOR(value/100);

一种方法是使用派生表:

SELECT id, F, id+F
  FROM
    (SELECT id, FLOOR(value/100) AS F
     FROM tbl_name
     GROUP BY id, FLOOR(value/100)) AS dt;

12.19.4检测功能的依赖

下面的讨论提供了一些如何在MySQL检测函数依赖的例子。本实例使用这个符号:

{X} -> {Y}

明白这Xuniquely determinesY这也意味着Y函数依赖X

本实例使用world数据库,可以下载从MySQL的文档页面。你可以找到有关如何在同一页上安装数据库。

函数依赖来自钥匙

下面的查询选择,对于每一个国家,一个计数的口语:

SELECT co.Name, COUNT(*)
FROM countrylanguage cl, country co
WHERE cl.CountryCode = co.Code
GROUP BY co.Code;

co.Code是一个主要的关键有限公司,所以所有列co的功能依赖于它,就用这个符号表示:

co.code { } { }>有限公司

因此,co.name函数依赖柱和查询有效

UNIQUE指数在不为空列可以被用来代替一个主键和相同的功能依赖将。(因为这不是真的UNIQUE索引允许无效的因为它允许多个值NULL在这种情况下,唯一的值丢失。)

函数依赖来自多个列的键和fromequalities

这个查询选择,对于每一个国家,一个列表中的所有语言,有多少人说他们:

SELECT co.Name, cl.Language,
cl.Percentage * co.Population / 100.0 AS SpokenBy
FROM countrylanguage cl, country co
WHERE cl.CountryCode = co.Code
GROUP BY cl.CountryCode, cl.Language;

对(cl.CountryCodeCL语言)12柱复合主键cl,使柱对唯一确定的所有列

{cl.CountryCode, cl.Language} -> {cl.*}

此外,由于在平等WHERE条款:

cl.countrycode } { } { co.code &#62;

而且,因为co.Code是关键有限公司

{co.Code} -> {co.*}

唯一确定关系是可传递的,因此:

{cl.CountryCode, cl.Language} -> {cl.*,co.*}

作为一个结果,查询有效。

如前面的例子,一个UNIQUE关键在不为空列可以被用来代替一个主键。

一个INNER JOIN条件可以用来代替哪里。相同的函数依赖的应用:

SELECT co.Name, cl.Language,
cl.Percentage * co.Population/100.0 AS SpokenBy
FROM countrylanguage cl INNER JOIN country co
ON cl.CountryCode = co.Code
GROUP BY cl.CountryCode, cl.Language;

函数依赖的特殊情况

而在一个平等的测试WHERE条件或内部联接条件是对称的,在外部联接条件相等测试是没有的,因为表中扮演不同的角色。

假设参考完整性被意外打破,有一排countrylanguage没有相应的行国家。考虑相同的查询在前一个例子,但与LEFT JOIN

SELECT co.Name, cl.Language,cl.Percentage * co.Population/100.0 AS SpokenByFROM countrylanguage cl LEFT JOIN country coON cl.CountryCode = co.CodeGROUP BY cl.CountryCode, cl.Language;

对于一个给定的值cl.CountryCode,价值公司代码在加入的结果是发现一个匹配行(由cl.CountryCode)或是无效的补充如果没有匹配(也由cl.CountryCode)。在每一种情况下,这种关系适用:

cl.countrycode } { } { co.code &#62;

cl.CountryCode本身的功能依赖于{cl.countrycodecl.Language}这是主键

如果在连接结果co.Code无效的-补充,co.Name同样是。如果公司代码是不是NULL补充,然后因为公司代码是一个主要的关键,它决定了co.Name。因此,在所有的情况下:

co.code } { } { co.name &#62;

其中产量:

{cl.CountryCode, cl.Language} -> {cl.*,co.*}

作为一个结果,查询有效。

然而,假设表交换,在这个查询:

SELECT co.Name, cl.Language,
cl.Percentage * co.Population/100.0 AS SpokenBy
FROM country co LEFT JOIN countrylanguage cl
ON cl.CountryCode = co.Code
GROUP BY cl.CountryCode, cl.Language;

现在这种关系呢申请

{cl.CountryCode, cl.Language} -> {cl.*,co.*}

事实上,所有的NULL补行了将一组(他们都GROUP BY列等于无效的),在这个群体的价值co.Name可以改变。查询是无效的和MySQL拒绝它。

在外连接函数依赖是这样连接是否属于行列式列的左侧或右侧LEFT JOIN。函数依赖的决心变得更加复杂,如果有嵌套的外连接或连接条件,不完全是平等的比较。

函数依赖和观点

假如在国家观产生他们的代码,他们的名字的大写字母,有多少种不同的官方语言,他们有:

CREATE VIEW Country2 AS
SELECT co.Code, UPPER(co.Name) AS UpperName,
COUNT(cl.Language) AS OfficialLanguages
FROM country AS co JOIN countrylanguage AS cl
ON cl.CountryCode = co.Code
WHERE cl.isOfficial = 'T'
GROUP BY co.Code;

这个定义是有效的因为:

{co.Code} -> {co.*}

在查看结果,第一选择的列co.Code,这也是集团列从而决定所有其他选定的表达式:

country2.code } { } { country2 &#62;。

MySQL的了解并利用这一信息,描述如下。

此查询显示的国家,有多少种不同的官方语言,他们,和他们有多少城市,通过加入观与city

SELECT co2.Code, co2.UpperName, co2.OfficialLanguages,COUNT(*) AS CitiesFROM country2 AS co2 JOIN city ciON ci.CountryCode = co2.CodeGROUP BY co2.Code;

这个查询是有效的,如先前看到的:

{co2.Code} -> {co2.*}

MySQL是能够发现一个函数依赖的结果期用以验证查询使用视图。同样,如果country2是一个派生表(或公用表表达式),如:

SELECT co2.Code, co2.UpperName, co2.OfficialLanguages,COUNT(*) AS CitiesFROM( SELECT co.Code, UPPER(co.Name) AS UpperName, COUNT(cl.Language) AS OfficialLanguages FROM country AS co JOIN countrylanguage AS cl ON cl.CountryCode=co.Code WHERE cl.isOfficial='T' GROUP BY co.Code) AS co2JOIN city ci ON ci.CountryCode = co2.CodeGROUP BY co2.Code;

函数依赖的组合

MySQL是能够结合上述所有类型的函数依赖(关键的基础,基于平等视角)来验证更复杂的查询。

12.20窗函数

MySQL支持窗口的功能,为每一列的查询,使用该行相关行执行计算。下面的章节将讨论如何使用窗函数的描述,包括OVER窗口条款.第一部分提供了聚合窗口功能说明。的总窗口功能的说明,见第12.19.1,“总(集团)功能描述

关于优化和窗函数的信息,参见第8.2.1.19,窗口函数优化”

说明12.20.1 window function

本节介绍了非聚合窗口功能,为每一列的查询,使用该行相关行执行计算。大多数的聚合函数也可以作为窗口功能;看第12.19.1,“总(集团)功能描述

窗函数的使用信息和例子,和这样的术语的定义OVER条款,窗,隔墙,框架,和同伴,看到第12.20.2,“窗函数的概念和语法”

表12.26窗函数

姓名描述
CUME_DIST()累积分布值
DENSE_RANK()在分区当前行秩,无间隙
FIRST_VALUE()从窗口第一行的参数值
LAG()价值的争论从行滞后电流排在分区
LAST_VALUE()从窗框上排参数值
LEAD()价值的争论从行领导目前行内的分区
NTH_VALUE()从第n排窗口框架的参数值
NTILE()在分区的当前行的桶数。
PERCENT_RANK()百分比排名的价值
RANK()在分区的当前行的排名,与空白
ROW_NUMBER()在分区的当前行数

在下面的功能说明,over_clause代表条款中描述的第12.20.2,“窗函数的概念和语法”。。。。。。。一些窗口函数A证null_treatment子句指定如何处理无效的值时,计算结果。这一条款是可选的。这是SQL标准的一部分,但是MySQL实现只允许RESPECT NULLS(这是默认值)。这意味着,无效的值是考虑在计算结果IGNORE NULLS解析,但产生一个错误。

  • CUME_DIST()over_clause

    返回一组值的范围内的值的累积分布;即分区值的百分比小于或等于当前行的值。这代表行之前或与目前排在窗口排序的窗口分割的窗口分割的总行数节点数。返回值的范围从0到1。

    这个函数应该用ORDER BY分类分区的行成所需的秩序。没有顺序行,所有的同行和有价值N/N= 1, whereN是分区的一部分

    over_clause所述第12.20.2,“窗函数的概念和语法”

    下面的查询显示,在设定的值val列的所以,_(区)每一行的值,以及由类似的百分比排名值返回PERCENT_RANK()功能。供参考,查询也显示行数使用ROW_NUMBER()

    MySQL的&#62;SELECTval,ROW_NUMBER()   OVER w AS 'row_number',CUME_DIST()    OVER w AS 'cume_dist',PERCENT_RANK() OVER w AS 'percent_rank'FROM numbersWINDOW w AS (ORDER BY val);------ ------------ -------------------- -------------- | Val | row_number | cume_dist | percent_rank | ------ ------------ -------------------- -------------- | 1 | 1 | 0.2222222222222222 | 0 | | 1 | 2 | 0.2222222222222222 | 0 | | 2 |三| 0.3333333333333333 | 0.25 | |三|四| 0.6666666666666666 | 375 | |三|五| 0.6666666666666666 | 375 | |三|六| 0.6666666666666666 | 375 | |四| 7 | 0.8888888888888888 | 0.75% | |四| 8 | 0.8888888888888888 | 0.75% | |五| 9 | 1 | 1 | ------ ------------ -------------------- --------------
  • DENSE_RANK()over_clause

    在分区返回当前行的排名,没有缝隙。同行都认为联系和接收相同的秩。此函数将连续排名对等组;结果是,组的大小大于一个不产生不连续的阶数。例如,看RANK()功能描述

    这个函数应该用ORDER BY分类分区的行成所需的秩序。没有顺序所有行的同行

    over_clause所述第12.20.2,“窗函数的概念和语法”

  • FIRST_VALUE(expr)null_treatment]over_clause

    返回值exprfrom the first of the window帧行。

    over_clause所述第12.20.2,“窗函数的概念和语法”null_treatment是在介绍描述

    下面的查询演示FIRST_VALUE()LAST_VALUE(),和两个实例NTH_VALUE()

    MySQL的&#62;SELECTtime, subject, val,FIRST_VALUE(val)  OVER w AS 'first',LAST_VALUE(val)   OVER w AS 'last',NTH_VALUE(val, 2) OVER w AS 'second',NTH_VALUE(val, 4) OVER w AS 'fourth'FROM observationsWINDOW w AS (PARTITION BY subject ORDER BY timeROWS UNBOUNDED PRECEDING);---------- --------- ------ ------- ------ -------- -------- |时间|主体| Val |第一|最后|二|四| ---------- --------- ------ ------- ------ -------- -------- | 07:00:00 | st113 |十|十|十|空|空| | 07:15:00 | st113 | 9十9 | | | 9 |空| | 07:30:00 | st113 | 25 |十| 25 | 9 |空| | 07:45:00 | st113 | 20 |十| 20 | 9 | 20 | | 07:00:00 | xh458 | 0 0 0 | | |空|空| | 07:15:00 | xh458 |十| 0 |十|十|空| | 07:30:00 | xh458 | 5 0 | |五|十|空| | 07:45:00 | xh458 | 30 | 0 | 30 |十| 30 | | 08:00:00 | xh458 | 25 | 0 | 25 |十| 30 | ---------- --------- ------ ------- ------ -------- --------

    每个函数使用排在目前的框架,其中,每个窗口定义所示,从第一行到当前行扩展分区。对于NTH_VALUE()称,当前帧并不总是包括所请求的行;在这种情况下,返回值是无效的

  • LAG(expr [, N[, default]])null_treatment]over_clause

    返回值expr从行的滞后(先于)当前行N在分区的行。如果没有这样的行,返回值是default。例如,如果N三,返回值是default在前两行。如果Ndefault失踪,默认是1无效的,分别

    N必须是文字的非负整数。如果N0,expr评估当前行

    over_clause所述第12.20.2,“窗函数的概念和语法”null_treatment是在介绍描述

    LAG()(和类似的LEAD()功能)经常被用来计算差异的行。下面的查询显示了一组时间点观察,对每一个的LAG()LEAD()从相邻的行的值,以及当前和相邻行之间的差异:

    MySQL的&#62;SELECTt, val,LAG(val)        OVER w AS 'lag',LEAD(val)       OVER w AS 'lead',val - LAG(val)  OVER w AS 'lag diff',val - LEAD(val) OVER w AS 'lead diff'FROM seriesWINDOW w AS (ORDER BY t);选择------ ------ ------选择------------- | T | Val |躺躺|铅铅| diff | diff | ------------------ ------ ------ ------选择------------- | 12:00 | 100 125 | | |零零| 25 | | 13:00 | 125 | 100 | 132 | 25 | 7 | | 14:00:00 | 132 | 145 125 | | 7 | 13 15 | | 00:00:00 | 132 140 145 | | | 13 | 5 | | 16:00 | | 145 140 150 | | | 5 10 | | 17:00 | | | 140 150 | | 200 10 18 50 | | 00:00:00 | 200 150 50 | | | |零零| ------------------ ------ ------ ------选择-------------

    在本例中,该LAG()LEAD()电话使用默认的Ndefault值的1无效的,分别

    第一行显示时会发生什么,没有以前的行LAG():该函数返回defaultvalue(在这情况下,无效的)。最后一行显示了同样的事情时,没有下一行LEAD()

    LAG()LEAD()也可以计算出比差异。考虑到该数据集,其中包含斐波那契数列的第几号:

    MySQL的&#62;SELECT n FROM fib ORDER BY n;??????| N | | 1 | | | | 1 2 3 5 | | | | | | 8 |???

    下面的查询显示LAG()LEAD()相邻的当前行的列值。它还使用这些功能添加到当前行值从前面和后面的行的值。的作用是产生在斐波那契数列的一个号码,和下一号后:

    MySQL的&#62;SELECTn,LAG(n, 1, 0)      OVER w AS 'lag',LEAD(n, 1, 0)     OVER w AS 'lead',n + LAG(n, 1, 0)  OVER w AS 'next_n',n + LEAD(n, 1, 0) OVER w AS 'next_next_n'FROM fibWINDOW w AS (ORDER BY n);------ ------ ------ -------- ------------- | N |滞后|铅| next_n | next_next_n | ------ ------ ------ -------- ------------- | 1 | 0 | 1 | 1 | 2 | | 1 | 1 | 2 | 2 | 3 | | 2 | 1 | 3 | 3 | 5 | | 3 | 2 | | | 5 5 8 | | 5 | 3 | 8 | 8 | 13 | | 8 | 5 | 0 | 13 | 8 | ------ ------ ------ -------- -------------

    生成Fibonacci数的初始设定的方法之一是使用递归公用表表达式。例如,看斐波那契数列的生成

  • LAST_VALUE(expr)null_treatment]over_clause

    返回值exprfrom the last of the window帧行。

    over_clause所述第12.20.2,“窗函数的概念和语法”null_treatment是在介绍描述

    例如,看FIRST_VALUE()功能描述

  • LEAD(expr [, N[, default]])null_treatment]over_clause

    返回值expr从领导的行(如下)当前行N在分区的行。如果没有这样的行,返回值是default。例如,如果N三,返回值是default在过去的两排。如果Ndefault失踪,默认是1无效的,分别

    N必须是文字的非负整数。如果N0,expr评估当前行

    over_clause所述第12.20.2,“窗函数的概念和语法”null_treatment是在介绍描述

    例如,看LAG()功能描述

  • NTH_VALUE(expr, N)from_first_last] [null_treatment]over_clause

    返回值exprN-窗户框的行。如果没有这样的行,返回值是无效的

    N必须是文字的正整数

    from_first_last是SQL标准的一部分,但是MySQL实现只允许从第一(这是默认值)。这意味着,在窗口的第一行开始计算。FROM LAST解析,但产生一个错误。为了获得相同的效果从去年(在窗口的最后一行开始计算),使用ORDER BY要以相反的顺序排序

    over_clause所述第12.20.2,“窗函数的概念和语法”null_treatment是在介绍描述

    例如,看FIRST_VALUE()功能描述

  • NTILE(N)over_clause

    将一个分区N组(桶),将每一行中的分区的桶数,并返回其分区内的当前行的桶数。例如,如果N4、ntile()将行插入4桶。如果N100,ntile()分排为100桶

    N必须是文字的正整数。桶数返回值的范围从1到N

    这个函数应该用ORDER BY分类分区的行成所需的秩序。

    over_clause所述第12.20.2,“窗函数的概念和语法”

    下面的查询显示,在设定的值val柱,从分排成两或四组的百分位值。供参考,查询也显示行数使用ROW_NUMBER()

    MySQL的&#62;SELECTval,ROW_NUMBER() OVER w AS 'row_number',NTILE(2)     OVER w AS 'ntile2',NTILE(4)     OVER w AS 'ntile4'FROM numbersWINDOW w AS (ORDER BY val);------ ------------ -------- -------- | Val | row_number | ntile2 | ntile4 | ------ ------------ -------- -------- | 1 | 1 | 1 | 1 | | 1 | 2 | 1 | 1 | | 2 | 3 | 1 | 1 | | 3 | 4 | 1 | 2 | | 3 | 5 | 1 | 2 | | 3 | 6 | 2 | 3 | | 4 | 7 | 2 | 3 | | 4 | 8 | 2 | 4 | | 5 | 9 | 2 | 4 | ------ ------------ -------- --------
  • PERCENT_RANK()over_clause

    返回的百分比分配值小于当前行的值,剔除最高值。返回值的范围从0到1代表行的相对排名,计算该公式的计算结果,在rank是行秩和rows是分区的行数:

    rank- 1)/(rows- 1)

    这个函数应该用ORDER BY分类分区的行成所需的秩序。没有顺序所有行的同行

    over_clause所述第12.20.2,“窗函数的概念和语法”

    例如,看CUME_DIST()功能描述

  • RANK()over_clause

    在分区返回当前行的排名,与空白。同行都认为联系和接收相同的秩。这个函数不连续分配的行列,同侪团体,如果尺寸大于存在一组;结果是不连续的阶数。

    这个函数应该用ORDER BY分类分区的行成所需的秩序。没有顺序所有行的同行

    over_clause所述第12.20.2,“窗函数的概念和语法”

    下面的查询显示之间的差异RANK(),生产队伍的差距,和DENSE_RANK()生产行列,无间隙。查询显示在一组值的每一个成员的等级值瓦尔列,其中包含一些重复。RANK()指定节点(副本)同级别的价值,和未来更大的价值有一个等级的节点数减一高。DENSE_RANK()也将同行同级别的价值,但下一个更高的价值等级的一个更大的。供参考,查询也显示行数使用ROW_NUMBER()

    MySQL的&#62;SELECTval,ROW_NUMBER() OVER w AS 'row_number',RANK()       OVER w AS 'rank',DENSE_RANK() OVER w AS 'dense_rank'FROM numbersWINDOW w AS (ORDER BY val);------ ------------------ ------ ------------------ | Val |行_秩秩数| |密集_ | ------ ------------------ ------ ------------------ | | | 1 1 1 1 1 | | | | | 1 2 1 2 3 | | | | | | 2 3 3 4 4 | | | | | 3 3 4 5 | | | | | | | 3 6 3 3 4 | | | | | | 7 7 4 4 4 | | | | | | 7 8 4 5 9 | | | | | | 9 5 | ------ ------------------。------------------
  • ROW_NUMBER()over_clause

    返回在分区的当前行数。行数从1到分区的行数范围。

    ORDER BY影响订单中的行编号。没有顺序意大利,行是不确定的。

    ROW_NUMBER()同行不同行数分配。指定节点的值相同,使用RANK()DENSE_RANK()。例如,看RANK()功能描述

    over_clause所述第12.20.2,“窗函数的概念和语法”

12.20.2窗函数的概念和语法

本节介绍了如何使用窗函数。实例使用相同的销售信息数据集在讨论发现GROUPING()功能第12.19.2,“集团通过修改”

mysql> SELECT * FROM sales ORDER BY country, year, product;
+------+---------+------------+--------+
| year | country | product    | profit |
+------+---------+------------+--------+
| 2000 | Finland | Computer   |   1500 |
| 2000 | Finland | Phone      |    100 |
| 2001 | Finland | Phone      |     10 |
| 2000 | India   | Calculator |     75 |
| 2000 | India   | Calculator |     75 |
| 2000 | India   | Computer   |   1200 |
| 2000 | USA     | Calculator |     75 |
| 2000 | USA     | Computer   |   1500 |
| 2001 | USA     | Calculator |     50 |
| 2001 | USA     | Computer   |   1500 |
| 2001 | USA     | Computer   |   1200 |
| 2001 | USA     | TV         |    150 |
| 2001 | USA     | TV         |    100 |
+------+---------+------------+--------+

窗函数执行一个总喜欢在一组查询行操作。然而,尽管总的手术组查询行成一个单一的结果行,窗函数产生的结果为每个查询的行:

  • 行的功能评价时称为当前行。

  • 目前排在功能评价的相关查询行发生包括当前行的窗口。

例如,利用销售信息表,这两个查询执行聚合操作产生的所有行作为一个集团,一个单一的全球每个国家的总和,和分组:

mysql> SELECT SUM(profit) AS total_profit
       FROM sales;
+--------------+
| total_profit |
+--------------+
|         7535 |
+--------------+
mysql> SELECT country, SUM(profit) AS country_profit
       FROM sales
       GROUP BY country
       ORDER BY country;
+---------+----------------+
| country | country_profit |
+---------+----------------+
| Finland |           1610 |
| India   |           1350 |
| USA     |           4575 |
+---------+----------------+

相比之下,窗口操作不崩溃,查询行组一个输出行。相反,它们产生的结果为每一行。像前面的查询,以下查询使用SUM()但这一次,作为一个窗口函数:

MySQL的&#62;SELECTyear, country, product, profit,SUM(profit) OVER() AS total_profit,SUM(profit) OVER(PARTITION BY country) AS country_profitFROM salesORDER BY country, year, product, profit;------ --------- ------------ -------- -------------- ---------------- |年|国|产品|利润| total_profit | country_profit | ------ --------- ------------ -------- -------------- ---------------- | 2000 |芬兰|计算机| 1500 | 7535 | 1610年| | 2000 |芬兰|电话|百| 7535 | 1610年| | 2001年|芬兰|电话|十| 7535 | 1610年| | 2000 |印度|计算器| 75 | 7535 | 1350 | | 2000 |印度|计算器| 75 | 7535 | 1350 | | 2000 |印度|计算机| 1200 | 7535 | 1350 | | 2000 |美国|计算器| 75 | 7535 |四五七五| | 2000 |美国|计算机| 1500 | 7535 |四五七五| | 2001年|美国|计算器|五十| 7535 |四五七五| | 2001年|美国|计算机| 1200 | 7535 |四五七五| | 2001年|美国|计算机| 1500 | 7535 |四五七五| | 2001年美国||电视|百| 7535 |四五七五| | 2001年|美国|电视| 150 | 7535 |四五七五| ------ --------- ------------ -------- -------------- ----------------

查询中的每个窗口的操作是由包含一个标志OVER子句指定如何分区查询行分组处理通过窗函数:

  • 第一OVER条款是空的,它把查询行整个设置为一个分区。窗函数从而产生一个全球性的总和,但这样做的每一行。

  • 第二OVER条款分区行国,生产每分区总和(每个国家)。该函数产生的总和为每个分区的行。

窗函数仅在选择列表中的允许ORDER BY条款.查询结果的行是从条款,后WHERE,和HAVING处理,和窗口执行之前发生顺序LIMIT,和选择不同的

这个OVER条款是许多聚合函数允许的,因此可以作为窗口或nonwindow功能,取决于条款的存在或不存在:

AVG()
BIT_AND()
BIT_OR()
BIT_XOR()
COUNT()
MAX()
MIN()
STDDEV_POP(), STDDEV(), STD()
STDDEV_SAMP()
SUM()
VAR_POP(), VARIANCE()
VAR_SAMP()

有关每个聚合函数的详细信息,参见第12.19.1,“总(集团)功能描述

MySQL也支持非聚合函数,仅作为窗函数。对于这些,这OVER条款是强制性的:

cume_dist() dense_rank() first_value() lag() last_value() lead() nth_value() ntile() percent_rank() rank() row_number()

有关每个聚合函数的详细信息,参见第12.20.1,”窗口的功能描述

作为其中的一个非聚合窗口函数的一个例子,这个查询使用ROW_NUMBER(),产生的行数每行内的分区。在这种情况下,每个国家的行编号。默认情况下,分区的行是无序的和行的数量是不确定的。分类分区的行,包括顺序窗口内定义条款。该查询使用无序和有序的分区(row_num1_ num2行列)来说明之间的差异,包括省略ORDER BY

MySQL的&#62;SELECTyear, country, product, profit,ROW_NUMBER() OVER(PARTITION BY country) AS row_num1,ROW_NUMBER() OVER(PARTITION BY country ORDER BY year, product) AS row_num2FROM sales;------ --------- ------------ -------- ---------- ---------- |年|国|产品|利润| row_num1 | row_num2 | ------ --------- ------------ -------- ---------- ---------- | 2000 |芬兰|计算机| 1500 | 2 | 1 | | 2000 |芬兰|电话| 100 | 1 | 2 | | 2001 |芬兰|电话| 10 | 3 | 3 | | 2000 |印度|计算器| 75 | 2 | 1 | | 2000 |印度|计算器| 75 | 3 | 2 | | 2000 |印度|计算机| 1200 | 1 | 3 | | 2000 |美国|计算器| 75 | 5 | 1 | | 2000 |美国|计算机| | | 1500 4 2 | | 2001 |美国|计算器| 50 | 2 | 3 | | 2001 |美国|计算机| 1500 | 3 | 4 | | 2001 |美国|计算机| 1200 | 7 | 5 | | 2001 |美国|电视| 150 | 1 | 6 | | 2001 |美国|电视| 100 | 6 | 7 | ------ --------- ------------—------- ---------- ----------

如前所述,使用窗函数(或治疗聚合函数作为窗函数),包括OVER以下条款的函数调用。这个条款有两种形式:

over_clause:
    {OVER (window_spec) | OVER window_name}

无论形式如何窗口函数处理查询的行。他们在窗口是否是直接定义的不同OVER条款,或对已命名的窗口查询中的其他地方定义的提供:

  • 在第一种情况下,窗口规范直接出现在OVER的条款,between the圆括号。

  • 在第二例,window_name是一个由一个窗口规范名称窗口查询中的其他条款。详情见第12.20.4,”命名的窗口”

OVER (window_spec)语法规范,窗口有几个部分,所有可选:

window_spec:[window_name] [partition_clause] [order_clause] [frame_clause]

如果OVER()是空的,窗户是由所有查询的行和窗函数计算结果使用的所有行。否则,该条款在括号中确定哪些查询行用于函数的计算结果和它们是如何划分和有序:

  • window_name:一个定义的窗口的名称窗口查询中的其他条款。如果window_name单独出现在条款,它完全定义窗口。如果分区,订购,或框架条款给出修改指定窗口的解释。详情见第12.20.4,”命名的窗口”

  • partition_clauseA分区条款说明如何将查询行分组。对于一个给定的排窗函数的结果是基于包含数据行的行。如果PARTITION BY省略,只有一个分区中包含的所有查询行。

    笔记

    窗口的功能分区与分区表。关于表分区的信息,参见22章,分区

    partition_clause这个语法:

    partition_clause:分区expr【,expr]…

    标准SQL需要PARTITION BY其次是列名仅。MySQL扩展是允许表达的,不只是列名称。例如,如果一个表包含TIMESTAMP命名列TS标准SQL允许,PARTITION BY ts但不分区按小时(TS),而MySQL允许

  • order_clause:一个顺序条款说明如何在各分区的行进行排序。相等的分区的行ORDER BY条款被认为是同行。如果顺序省略,隔行是无序的,没有处理订单暗示,所有分区的行同行。

    order_clause这个语法:

    order_clause:订单expr[说明] [ | ASC,expr| desc〔AUC〕…

    每个ORDER BY表达也可以通过ASCDESC指示排序方向。默认值是ASC如果没有指明方向NULL价值观排序第一为升序按降序排序,最后。

    一个ORDER BY在一个窗口定义适用于个别分区。排序集合成一个整体的结果,包括顺序在query顶级水平。

  • frame_clause:一个框架是当前分区的一个子集和框架条款指定如何定义的子集。框架条款有许多小节自己。详情见第12.20.3,”窗口的功能框架规范”

12.20.3窗函数框架规范

一个用窗函数的定义可以包括窗口框架条款。一个框架是当前分区的一个子集和框架条款指定如何定义的子集。

框架是相对于当前行的确定,使机架移动分区内根据当前行的位置在其分区。实例:

  • 通过定义一个框架是从分区中的所有行的开始到当前行,你可以计算每行的运行总计。

  • 通过定义一个框架扩展N在当前行的两边排,你可以计算移动平均数。

下面的查询演示移动帧计算运行总计每组时间内使用命令level值,以及滚动平均值计算从当前行的行之前和之后它立刻:

MySQL的&#62;SELECTtime, subject, val,SUM(val) OVER (PARTITION BY subject ORDER BY timeROWS UNBOUNDED PRECEDING)AS running_total,AVG(val) OVER (PARTITION BY subject ORDER BY timeROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING)AS running_averageFROM observations;---------- --------- ------ --------------- ----------------- |时间|主体| Val | running_total | running_average | ---------- --------- ------ --------------- ----------------- | 07:00:00 | st113 | 10 | 10 | 9.5000 | | 07:15:00 | st113 | 9 | 19 | 14.6667 | | 07:30:00 | st113 | 25 | 44 | 18 | | 07:45:00 | st113 | | | 20 64 22.5000 | | 07:00:00 | xh458 | 0 | 0 | 5 | | 07:15:00 | xh458 | 10 | 10 | 5 | | 07:30:00 | xh458 | 5 | 15 | 15 | | 07:45:00 | xh458 | 30 | 45 | 20 | | 08:00:00 | xh458 | 25 | 70 | 27.5000 | ---------- --------- ------ --------------- -----------------

对于running_average柱,没有框排前面的第一个或最后一。在这些情况下,AVG()计算列是平均

聚合函数作为窗函数操作在当前的排架行,这些非聚合窗口功能一样:

FIRST_VALUE()
LAST_VALUE()
NTH_VALUE()

标准SQL指定窗口的功能操作在整个分区应该没有框架条款。MySQL允许这样的功能而忽略了它的框架条款。这些函数使用整个分区即使框中指定:

CUME_DIST()
DENSE_RANK()
LAG()
LEAD()
NTILE()
PERCENT_RANK()
RANK()
ROW_NUMBER()

框架条款,如果有,这个语法:

frame_clause:
    frame_units frame_extent

frame_units:
    {ROWS | RANGE}

在一个框架条款的情况下,默认的框架取决于是否ORDER BY子句,在本节后面介绍。

这个frame_units值表示的关系类型之间的当前行和排架:

  • ROWS:框架是由开始和结束行位置定义。偏移行数从当前行数差异。

  • RANGE:框架是由行内的值范围。偏移量是从当前行中的列值的差异值。

这个frame_extent值表示开始和结束点的框架。你可以指定帧的开始(在这种情况下,当前行是隐式结束)或使用之间指定帧的端点:

frame_extent:
    {frame_start | frame_between}

frame_between:
    BETWEEN frame_start AND frame_end

frame_start, frame_end: {
    CURRENT ROW
  | UNBOUNDED PRECEDING
  | UNBOUNDED FOLLOWING
  | expr PRECEDING
  | expr FOLLOWING
}

BETWEEN语法,frame_start必须不晚于frame_end

允许的frame_startframe_end这些意义价值:

  • CURRENT ROW:for,结合当前行。为RANGE,绑定的是当前行的同行。

  • UNBOUNDED PRECEDING:界是第一个分区的行。

  • UNBOUNDED FOLLOWING:绑定的最后一个分区的行。

  • expr PRECEDING:for,界expr在当前行的行。为范围,绑定的值等于当前行值减去行expr如果当前行的值;无效的,绑定的是行同行

    expr PRECEDING(和expr以下),expr可以是一个参数标记(使用在一份准备好的声明),一个非负的数字文字,或时间间隔的形式INTERVAL val unit。为区间表达,val指定非负区间值,并unit是一个关键字表示单位的价值应该解释。(关于允许细节units说明符,看到的描述DATE_ADD()功能12.7节,“戴特和时间函数”。)

    RANGE一个数字或时间expr要求顺序一个数字或时间表达,分别。

    例有效expr PRECEDINGexpr以下指标:

    10 precedinginterval 5天preceding5 followinginterval的2:30的minute_second以下
  • expr FOLLOWING:for,界expr当前行后的行。为范围,绑定的值等于当前值加上一排排expr如果当前行的值;无效的,绑定的是行同行

    允许的值expr,看到的描述expr前面的

下面的查询演示FIRST_VALUE()LAST_VALUE(),和两个实例NTH_VALUE()

MySQL的&#62;SELECTtime, subject, val,FIRST_VALUE(val)  OVER w AS 'first',LAST_VALUE(val)   OVER w AS 'last',NTH_VALUE(val, 2) OVER w AS 'second',NTH_VALUE(val, 4) OVER w AS 'fourth'FROM observationsWINDOW w AS (PARTITION BY subject ORDER BY timeROWS UNBOUNDED PRECEDING);---------- --------- ------ ------- ------ -------- -------- |时间|主体| Val |第一|最后|二|四| ---------- --------- ------ ------- ------ -------- -------- | 07:00:00 | st113 |十|十|十|空|空| | 07:15:00 | st113 | 9十9 | | | 9 |空| | 07:30:00 | st113 | 25 |十| 25 | 9 |空| | 07:45:00 | st113 | 20 |十| 20 | 9 | 20 | | 07:00:00 | xh458 | 0 0 0 | | |空|空| | 07:15:00 | xh458 |十| 0 |十|十|空| | 07:30:00 | xh458 | 5 0 | |五|十|空| | 07:45:00 | xh458 | 30 | 0 | 30 |十| 30 | | 08:00:00 | xh458 | 25 | 0 | 25 |十| 30 | ---------- --------- ------ ------- ------ -------- --------

每个函数使用排在目前的框架,其中,每个窗口定义所示,从第一行到当前行扩展分区。对于NTH_VALUE()称,当前帧并不总是包括所请求的行;在这种情况下,返回值是无效的

在一个框架条款的情况下,默认的框架取决于是否ORDER BY条款是存在的:

  • ORDER BY:默认的框架包括行从分区开始到当前行,包括所有节点的当前行(行等于当前行根据顺序条款)。默认值是相当于这个框架规范:

    RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
    
  • 没有ORDER BY:默认的框架包括所有分区的行(因为没有顺序,所有分区排辈)。默认值是相当于这个框架规范:

    RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
    

因为默认的框架取决于是否存在差异ORDER BY,添加顺序一个查询中获得确定性的结果可能会改变结果。(例如,所产生的价值SUM()可能会改变。)获得相同的结果,但要求每顺序,可无论是否提供了明确的框架规范ORDER BY是存在的

一个框架规范的意义可以不明显的当前行的值时NULL。如果是这样,这些例子说明了如何应用各种框架规范:

  • ORDER BY X ASC RANGE BETWEEN 10 FOLLOWING AND 15 FOLLOWING

    帧开始NULL停在无效的,因此只包括行值NULL

  • ORDER BY X ASC RANGE BETWEEN 10 FOLLOWING AND UNBOUNDED FOLLOWING

    帧开始NULL停止分区末端。因为一个ASC抽签NULL价值第一,框架是整个分区。

  • ORDER BY X DESC RANGE BETWEEN 10 FOLLOWING AND UNBOUNDED FOLLOWING

    帧开始NULL停止分区末端。因为一个desc抽签NULL价值观上,框架是唯一的无效的价值观

  • ORDER BY X ASC RANGE BETWEEN 10 PRECEDING AND UNBOUNDED FOLLOWING

    帧开始NULL停止分区末端。因为一个ASC抽签NULL价值第一,框架是整个分区。

  • ORDER BY X ASC RANGE BETWEEN 10 PRECEDING AND 10 FOLLOWING

    帧开始NULL停在无效的,因此只包括行值NULL

  • ORDER BY X ASC RANGE BETWEEN 10 PRECEDING AND 1 PRECEDING

    帧开始NULL停在无效的,因此只包括行值NULL

  • ORDER BY X ASC RANGE BETWEEN UNBOUNDED PRECEDING AND 10 FOLLOWING

    框架在列值的分区和停止的开始NULL。因为一个ASC排序提出NULL价值第一,框架是唯一的无效的价值观

12.20.4命名为Windows

Windows可以被定义和命名,是指他们OVER条款.为此,使用窗口条款.如果在一个查询当前的WINDOW条款下的位置之间的ORDER BY条款,具有这种语法:

窗口window_name为(window_spec)[,window_name为(window_spec)]…

每个窗口定义,window_name是窗口的名称,和window_spec是同一类型的窗口规范给定的圆括号之间条款,如第12.20.2,“窗函数的概念和语法”

window_spec:
    [window_name] [partition_clause] [order_clause] [frame_clause]

WINDOW子句用于查询在多条款,否则定义相同的窗口。相反,你可以定义窗口一次,给它一个名字,并在名字的引用OVER条款.考虑这个查询,它定义了同一窗口多次:

选择在瓦尔,row_number()(顺序由Val)为“row_number &#39;,rank()超过(以val)为“等级”,在dense_rank()(顺序由Val)为“dense_rank&#39;from数;

查询可以使用更简单的使用WINDOW定义窗口一次,指的是窗口的名字在条款:

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

一个名叫窗口也使得它更容易通过窗口定义看到查询结果的影响。你只需要修改窗口中定义WINDOW条款条款定义

如果一个OVER子句使用window_name…)而不是window_name指定的窗口,可以通过添加其他条款的修改。例如,该查询定义了一个窗口,包括分区,并使用顺序OVER条款以不同的方式修改窗口:

选择不同的一年,国家,first_value(年)在(W为年ASC)为先,first_value(年)在(W为年DESC)作为从saleswindow W(分国家);

一个OVER子句只能属性添加到指定窗口,不修改。如果指定的窗口定义包含一个分区,订购,或框架属性的条款,指的是窗口的名称不能包括财产或同一种错误发生:

  • 这个结构是允许的因为窗口定义和引用OVER条款不包含属性的一种:

    在(W为国家)…窗口w(分国家)
  • 这个建筑是不允许的因为OVER子句指定分区一个名叫窗口已经PARTITION BY

    在(W分区年)…窗口w(分国家)

一个名为窗口的定义本身就可以开始了window_name。在这种情况下,向前和向后的引用是允许的,但不是周期:

  • 这是允许的;它包含了正向和反向引用但没有周期:

    WINDOW w1 AS (w2), w2 AS (), w3 AS (w1)
    
  • 这是不允许的因为它包含一个周期:

    WINDOW w1 AS (w2), w2 AS (w3), w3 AS (w1)
    

12.20.5窗函数的限制

SQL标准规定了约束的窗函数,它们不能用于UPDATEDELETE报表更新行。在子查询中使用这些报表等功能(选择行)是允许的。

MySQL不支持这些窗口的功能特点:

  • DISTINCTfor window功能汇总表。

  • 嵌套的窗函数

  • 动态帧的终点取决于当前行的值。

解析器承认这些窗口结构,但不支持:

  • 这个GROUPS框架单元说明符是解析的,而产生的错误。只有RANGE支持

  • 这个EXCLUDE框架规范条款进行解析,但产生一个错误。

  • IGNORE NULLS解析,但产生一个错误。只有尊敬的空值支持

  • FROM LAST解析,但产生一个错误。只有从第一支持

12.21内部功能

表12.27内部功能

姓名描述
CAN_ACCESS_COLUMN()仅供内部使用
CAN_ACCESS_DATABASE()仅供内部使用
CAN_ACCESS_TABLE()仅供内部使用
CAN_ACCESS_VIEW()仅供内部使用
GET_DD_COLUMN_PRIVILEGES()仅供内部使用
GET_DD_CREATE_OPTIONS()仅供内部使用
GET_DD_INDEX_SUB_PART_LENGTH()仅供内部使用
INTERNAL_AUTO_INCREMENT()仅供内部使用
INTERNAL_AVG_ROW_LENGTH()仅供内部使用
INTERNAL_CHECK_TIME()仅供内部使用
INTERNAL_CHECKSUM()仅供内部使用
INTERNAL_DATA_FREE()仅供内部使用
INTERNAL_DATA_LENGTH()仅供内部使用
INTERNAL_DD_CHAR_LENGTH()仅供内部使用
INTERNAL_GET_COMMENT_OR_ERROR()仅供内部使用
INTERNAL_GET_VIEW_WARNING_OR_ERROR()仅供内部使用
INTERNAL_INDEX_COLUMN_CARDINALITY()仅供内部使用
INTERNAL_INDEX_LENGTH()仅供内部使用
INTERNAL_KEYS_DISABLED()仅供内部使用
INTERNAL_MAX_DATA_LENGTH()仅供内部使用
INTERNAL_TABLE_ROWS()仅供内部使用
INTERNAL_UPDATE_TIME()仅供内部使用

本节中列出的功能仅供内部使用的服务器。试图通过用户调用在一个错误的结果。

12.22多功能

表12.28各种功能

姓名描述
ANY_VALUE()抑制only_full_group_by价值排斥
BIN_TO_UUID()字符串转换成二进制的UUID
DEFAULT()返回一个表的列的默认值
GET_LOCK()得到指定的锁
GROUPING()区分超聚合汇总行常规行
INET_ATON()返回一个IP地址的数值
INET_NTOA()返回一个数值的IP地址
INET6_ATON()返回一个IPv6地址的数值
INET6_NTOA()返回一个数值的IPv6地址
IS_FREE_LOCK()是否指定的锁是免费的
IS_IPV4()无论实参是一个IPv4地址
IS_IPV4_COMPAT()无论实参是一个兼容IPv4的地址
IS_IPV4_MAPPED()无论实参是一个IPv4映射地址
IS_IPV6()无论实参是一个IPv6地址
IS_USED_LOCK()是否指定锁使用;如果真的返回连接标识符
IS_UUID()无论参数是一个有效的UUID
MASTER_POS_WAIT()等到奴隶已经阅读并应用所有更新到指定位置
NAME_CONST()原因列有名字
RAND()返回一个随机浮点值
RELEASE_ALL_LOCKS()释放所有的电流叫锁
RELEASE_LOCK()释放指定的锁
SLEEP()睡一秒数
UUID()返回一个通用唯一标识符(UUID)
UUID_SHORT()返回一个整型值的通用标识符
UUID_TO_BIN()转换为二进制串UUID
VALUES()将插入过程中使用的值

  • ANY_VALUE(arg)

    此功能是有用的GROUP BY查询时ONLY_FULL_GROUP_BYSQL模式启用为例,当MySQL拒绝查询,你知道是有效的,MySQL不能确定原因。函数返回值类型作为返回值和参数的类型相同,但功能不检查的结果ONLY_FULL_GROUP_BYSQL模式

    例如,如果name是一种非索引列,以下查询失败ONLY_FULL_GROUP_BY启用:

    MySQL的&#62;SELECT name, address, MAX(age) FROM t GROUP BY name;ERROR 1055 (42000): Expression #2 of SELECT list is not in GROUPBY clause and contains nonaggregated column 'mydb.t.address' whichis not functionally dependent on columns in GROUP BY clause; thisis incompatible with sql_mode=only_full_group_by

    故障发生的原因address是一个非聚合的列,不名栏目和功能依赖他们。作为一个结果,这address行内的每一个值姓名组是不确定的。有多种方法使MySQL接受查询:

    • 修改表使name主键或唯一不为空专栏这使得MySQL来确定address函数依赖姓名这是,address是唯一确定的姓名。(这种技术是不适用的话NULL必须允许一个有效的姓名值。)

    • 使用ANY_VALUE()地址

      SELECT name, ANY_VALUE(address), MAX(age) FROM t GROUP BY name;
      

      在这种情况下,MySQL忽略不确定性address值在每个姓名组和接受查询。这也许你根本不在乎它价值的非聚合的列可以被选择为每个组。ANY_VALUE()不是一个聚合函数,不同的函数如SUM()COUNT()。它的作用是抑制试验的不确定性。

    • 禁用ONLY_FULL_GROUP_BY。这相当于使用ANY_VALUE()ONLY_FULL_GROUP_BY启用,在以前的项目描述。

    ANY_VALUE()也有用功能依赖存在但MySQL不能确定柱间。下面的查询是有效的因为年龄的功能依赖于分组列age-1,但MySQL不能告诉和拒绝查询ONLY_FULL_GROUP_BY启用:

    选择年龄从岁年龄组;

    导致MySQL接受查询,使用ANY_VALUE()

    选择any_value(年龄)T组的年龄;

    ANY_VALUE()可用于查询汇总功能的缺失条款:

    mysql> SELECT name, MAX(age) FROM t;
    ERROR 1140 (42000): In aggregated query without GROUP BY, expression
    #1 of SELECT list contains nonaggregated column 'mydb.t.name'; this
    is incompatible with sql_mode=only_full_group_by
    

    没有GROUP BY,有一个组,它是不确定的,姓名选择对群体价值ANY_VALUE()告诉MySQL接受查询:

    选择any_value(的名字),马克斯(年龄)T;

    这可能是由于一些财产,一个给定的数据集,你知道一个选定的非聚合的列是有效的函数依赖GROUP BY专栏例如,应用程序可以执行一列相对于另一个唯一性。在这种情况下,使用ANY_VALUE()为了有效的功能与柱可能有意义。

    额外的讨论,见第12.19.3,MySQL处理组”

  • BIN_TO_UUID(binary_uuid)BIN_TO_UUID(binary_uuid, swap_flag)

    BIN_TO_UUID()是逆UUID_TO_BIN()。它转换成一个二进制的UUID来串UUID和返回结果。二进制的值应该是一个UUID为VARBINARY(16)价值。返回值是一个UTF8五进制数由短划线分隔的字符串。(关于此格式,详见UUID()功能描述。)如果uuid的说法是无效的,返回值是NULL。如果任何参数无效,发生了一个错误。

    BIN_TO_UUID()以一个或两个参数:

    • 一个参数的形式以二进制的UUID值。UUID值是假定没有时间低和高的部分交换。字符串的结果是在同一顺序的二进制参数。

    • 两论证形式以二进制的UUID值和交换的标志值:

      • 如果swap_flag为0,两论证形式相当于一个参数的形式。字符串的结果是在同一顺序的二进制参数。

      • 如果swap_flag1、UUID值是假设有其时间低和时间高部分交换。这些零件是交换的结果值返回到原来的位置。

    关于时间的一部分交换使用的信息和例子,看UUID_TO_BIN()功能描述

  • DEFAULT(col_name)

    返回一个表的列的默认值。一个错误的结果如果没有默认值的列。

    使用DEFAULT(col_name)指定一个命名列的缺省值是唯一的,有文字的缺省值的列不允许,那有一个默认值的列的表达。

    MySQL的&#62;UPDATE t SET i = DEFAULT(i)+1 WHERE id < 100;
  • FORMAT(X,D)

    格式的数量X一个格式如“#,# # #,# # # # #”。,圆D小数,并以字符串的形式返回结果。详情见12.5节,“字符串函数”

  • GET_LOCK(str,timeout)

    试图获得一个名字的字符串给锁str,使用超时timeout秒。一个负timeout值表示无限超时。锁是独家的。同时通过举办过一届,其他会话无法获得锁的同名。

    退货1如果成功获得锁,如果尝试超时(例如,因为另一个客户以前锁定的名字),或NULL如果发生错误(如运行内存或线程被杀死mysqladmin杀

    锁了GET_LOCK()通过执行显式释放RELEASE_LOCK()或暗示当你的会话终止时(无论是正常或异常)。锁定释放也可能出现另一个电话GET_LOCK()

    • GET_LOCK()采用元数据锁定(MDL)子系统。同时进行多个锁可以获得GET_LOCK()不释放任何现有的锁。对于一个给定的会话获得相同名称的多个锁,它甚至可能。其他会议无法获取锁,名字直到获取会话释放它所有的锁的名字。

      锁收购GET_LOCK()出现在性能模式metadata_locks表这个object_type柱说USER LEVEL LOCKobject_name列指示锁的名字。另外,获取多个锁的性能介绍客户的可能性之间的僵局。当这一切发生的时候,服务器选择一个电话和一个锁请求终止收购ER_USER_LOCK_DEADLOCK误差。这个错误不会导致事务回滚。

    例如,假设你执行这些语句:

    SELECT GET_LOCK('lock1',10);
    SELECT GET_LOCK('lock2',10);
    SELECT RELEASE_LOCK('lock2');
    SELECT RELEASE_LOCK('lock1');
    

    第二GET_LOCK()获得第二锁和RELEASE_LOCK()调用返回一个(成功)。

    MySQL执行最大长度对64字锁的名字。

    锁了GET_LOCK()不释放当事务提交或回滚。

    GET_LOCK()可以用来实现应用程序锁或模拟记录锁。名字是锁在整个服务器上。如果一个名字被锁定在一个会话,GET_LOCK()块由同名锁另一个会话的任何要求。这使客户同意在一个给定的锁名称使用的名称进行合作咨询锁定。但要注意,这也使客户不合作的客户锁定一名集当中,无意或故意,从而防止任何合作客户锁定这个名字。为了降低这种可能性的一种方法是使用数据库特定的或特定于应用程序的锁的名字。例如,使用表格锁的名字db_name.strapp_name.str

    如果多个客户端等待锁,命令他们将获得它是未定义的。应用程序不应假设客户将获得锁以相同的顺序,他们发出的锁请求。

    GET_LOCK()是基于语句的复制不安全。警告如果你使用这个功能的时候登录binlog_format是集声明

    注意安全

    以获取多个命名MySQL 5.7.5锁的能力,为一个单一的语句来获得大量的锁是可能的。例如:

    INSERT INTO ... SELECT GET_LOCK(t1.col_name) FROM t1;
    

    这些陈述可能有一定的不利影响。例如,如果语句失败并回滚的方式通过,获得的锁到故障点仍然存在。如果是有一个行之间插入对应的锁和收购,意图将不会满意。另外,如果锁在一个特定的顺序当然是重要的,要知道结果集的顺序可能有所不同取决于执行计划的优化选择。由于这些原因,它可能是最好的限制应用到一个单一的锁的获取调用每个语句。

    不同的锁接口可作为一个插件服务或一组用户定义的函数。这个接口提供了锁的命名空间和不同的读写锁,与所提供的接口GET_LOCK()和相关功能。详情见第28.3.1,“锁定服务”

  • GROUPING(expr [, expr] ...)

    GROUP BY查询,包括与汇总改性剂的ROLLUP操作产生超总输出行无效的表示所有值的集合。这个GROUPING()功能使您可以区分无效的超级合计行值NULL在普通分组的行值

    GROUPING()只有在选择列表中允许或条款.

    每一个论点GROUPING()必须是一个表达式,表达式中的完全匹配条款.表达不能是位置说明符。每个表达式,GROUPING()生产1如果当前行中的表达式的值是无效的代表一个超级总价值。否则,GROUPING()生产0,指示表达式的值是一个无效的对于普通的结果行或不NULL

    假设表t1包含这些行,哪里无效的表明什么其他未知

    mysql> SELECT * FROM t1;
    +------+-------+----------+
    | name | size  | quantity |
    +------+-------+----------+
    | ball | small |       10 |
    | ball | large |       20 |
    | ball | NULL  |        5 |
    | hoop | small |       15 |
    | hoop | large |        5 |
    | hoop | NULL  |        3 |
    +------+-------+----------+
    

    一个简易的表没有WITH ROLLUP看起来像这样:

    MySQL的&#62;SELECT name, size, SUM(quantity) AS quantityFROM t1GROUP BY name, size;------ ------- ---------- |名字|大小|数量| ------ ------- ---------- |球|小|十| |球|大| 20 | |球|空|五| |箍|小| 15 | |箍|大|五| |箍|空|三| ------ ------- ----------

    结果包含NULL值,但这不代表超级合计行因为查询不包括与汇总

    添加WITH ROLLUP产生超级汇总行包含额外的无效的价值观。然而,没有对比前一个,这是不容易看到的NULL值出现在超级合计行和普通分组的行发生:

    MySQL的&#62;SELECT name, size, SUM(quantity) AS quantityFROM t1GROUP BY name, size WITH ROLLUP;------ ------- ---------- |名字|大小|数量| ------ ------- ---------- |球|空| 5 | |球|大| 20 | |球|小| 10 | |球|空| 35 | |箍|空| 3 | |箍|大| 5 | |箍|小| 15 | |箍|空| 23 | |空|空| 58 | ------ ------- ----------

    区分NULL价值观在超级合计行于普通分组的行,使用GROUPING(),返回1只超级集合无效的价值观:

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

    常见的用法GROUPING()

    • 用标签超级集合NULL价值观:

      MySQL的&#62;SELECTIF(GROUPING(name) = 1, 'All items', name) AS name,IF(GROUPING(size) = 1, 'All sizes', size) AS size,SUM(quantity) AS quantityFROM t1GROUP BY name, size WITH ROLLUP;----------- ----------- ---------- |名字|大小|数量| ----------- ----------- ---------- |球|空| 5 | |球|大| 20 | |球|小| 10 | |球|大小| 35 | |箍|空| 3 | |箍|大| 5 | |箍|小| 15 | |箍|大小| 23 | |所有项目|大小| 58 | ----------- ----------- ----------
    • 过滤规则分组线返回唯一的超级集合线:

      mysql> SELECT name, size, SUM(quantity) AS quantity
             FROM t1
             GROUP BY name, size WITH ROLLUP
             HAVING GROUPING(name) = 1 OR GROUPING(size) = 1;
      +------+------+----------+
      | name | size | quantity |
      +------+------+----------+
      | ball | NULL |       35 |
      | hoop | NULL |       23 |
      | NULL | NULL |       58 |
      +------+------+----------+
      

    GROUPING()允许多个表达式参数。在这种情况下,的GROUPING()返回值是一个位从每个表达式的结果,其中最低阶位对应的结果,最右边的表达式。例如,三个表达式参数,GROUPING(expr1, expr2, expr3)这样的评价:

    结果分组(expr3分组的结果是()expr2) << 1+ result for GROUPING(expr1) << 2

    下面的查询显示GROUPING()单参数结果结合多参数调用产生的位掩码值:

    MySQL的&#62;SELECTname, size, SUM(quantity) AS quantity,GROUPING(name) AS grp_name,GROUPING(size) AS grp_size,GROUPING(name, size) AS grp_allFROM t1GROUP BY name, size WITH ROLLUP;------ ------- ---------- ---------- ---------- --------- |名字|大小|数量| grp_name | grp_size | grp_all | ------ ------- ---------- ---------- ---------- --------- |球|空| 5 | 0 | 0 | 0 | |球|大| 20 | 0 | 0 | 0 | |球|小| 10 0 0 0 | | | | |球|空| 35 | 0 | 1 | 1 | |箍|空| 3 | 0 | 0 | 0 | |箍|大| 5 | 0 | 0 | 0 | |箍|小| 15 | 0 | 0 | 0 | |箍|空| | | | 1 1 0 23 | |空|空| 58 | 1 | 1 | 3 | ------ ------- ---------- ---------- ---------- ---------

    多参数的表达,GROUPING()如果任何表示超聚合值返回非零值。多参数GROUPING()语法提供了一种更简单的方式来写早期的查询仅返回超级合计行,通过使用一个单一的多参数GROUPING()而不是多个单独的参数调用调用:

    MySQL的&#62;SELECT name, size, SUM(quantity) AS quantityFROM t1GROUP BY name, size WITH ROLLUPHAVING GROUPING(name, size) <> 0;------ ------ ---------- |名字|大小|数量| ------ ------ ---------- |球|空| 35 | |箍|空| 23 | |空|空| 58 | ------ ------ ----------

    使用GROUPING()受到这些限制:

    • 不使用子查询GROUP BY表达式为GROUPING()因为匹配参数可能会失败。例如,匹配失败这个查询:

      MySQL的&#62;SELECT GROUPING((SELECT MAX(name) FROM t1))FROM t1GROUP BY (SELECT MAX(name) FROM t1) WITH ROLLUP;错误3580(hy000):论证# 1分组功能不在组
    • GROUP BY文字表达不应该被用在条款GROUPING()争论。由于之间的差异时,优化器评估HAVING但是,匹配成功GROUPING()评价并没有产生预期的结果。考虑此查询:

      SELECT a AS f1, 'w' AS f2FROM tGROUP BY f1, f2 WITH ROLLUPHAVING GROUPING(f2) = 1;

      GROUPING()评价早期的字面常量表达式为条款作为一个整体,返回0。检查查询是否如这是影响,使用EXPLAIN寻找不可能有Extra专栏

    为更多的信息关于WITH ROLLUPGROUPING(),看到第12.19.2,“集团通过修改”

  • INET_ATON(expr)

    鉴于星罗棋布的IPv4网络地址表示为一个字符串,返回一个表示网络字节顺序的地址数值的整数(大端)。INET_ATON()退货无效的如果不了解它的参数

    mysql> SELECT INET_ATON('10.0.5.9');
            -> 167773449
    

    在这个例子中,返回值为10计算×2560×2565×256 9

    INET_ATON()可能或可能不是一个非回报无效的短形式的结果(如IP地址'127.1'作为一个代表“127.0.0.1”)。因为这个,INET_ATON()一个不应该被用于这样的地址。

    笔记

    存储值产生的INET_ATON(),使用int unsigned柱而不是INT,这是签署。如果你使用一个签名栏,对应的IP地址的第一个八位位组大于127无法正确储存。看到第11.2.6,“超出范围和溢出处理”

  • INET_NTOA(expr)

    给定一个数字的IPv4网络地址的网络字节顺序,为一个字符串的连接字符集返回星罗棋布的字符串表示的地址。INET_NTOA()退货无效的如果不了解它的参数

    mysql> SELECT INET_NTOA(167773449);
            -> '10.0.5.9'
    
  • INET6_ATON(expr)

    给定一个IPv6或IPv4网络地址的字符串,返回一个二进制字符串表示网络字节顺序的地址数值(大端)。因为数字格式的IPv6地址的要求比最大的整数类型的多个字节,表示该函数返回的是VARBINARY数据类型:VARBINARY(16)IPv6地址VARBINARY(4)IPv4地址。如果参数不是一个有效的地址,INET6_ATON()退货无效的

    下面的示例使用HEX()显示INET6_ATON()打印形式的结果:

    MySQL的&#62;SELECT HEX(INET6_ATON('fdfe::5a55:caff:fefa:9089'));-> 'FDFE0000000000005A55CAFFFEFA9089'mysql>SELECT HEX(INET6_ATON('10.0.5.9'));这是0a000509→

    INET6_ATON()观察几个约束的有效参数。这些都是在下面的列表以及实例。

    • 尾区ID是不允许的,如fe80::3%1fe80:3% eth0

    • 后面的网络掩码是不被允许的,如2001:45f:3:ba::/64198.51.100.0/24

    • 为代表的IPv4地址的值,只有无类地址支持。有类地址如198.51.1被拒绝。后面的端口号是不允许的,如198.51.100.2:8080。在地址组成的十六进制数是不允许的,如198.0xa0.1.2。不支持八进制数:198.51.010.1作为198.51.10.1,不198.51.8.1。这些限制也适用于IPv4 IPv6,IPv4地址的部分,如IPv4兼容或IPv4映射地址。

    转换一个IPv4地址expr以数字形式表示为INT一个IPv6地址以数字形式表示为一个值VARBINARY值,用这个表达:

    inet6 _阿顿(_ ntoa(核能与新能源技术研究院expr))

    例如:

    mysql> SELECT HEX(INET6_ATON(INET_NTOA(167773449)));
            -> '0A000509'
    
  • INET6_NTOA(expr)

    给定一个IPv6或IPv4网络地址以数字形式表示为一个二进制字符串,字符串的连接字符集返回地址的字符串表示形式。如果参数不是一个有效的地址,INET6_NTOA()退货无效的

    INET6_NTOA()具有这些特性的:

    • 它不使用操作系统的功能进行转换,从而输出字符串是平台独立的。

    • 返回的字符串的最大长度为39(4×8 7)。在此声明:

      CREATE TABLE t AS SELECT INET6_NTOA(expr) AS c1;
      

      结果表将这个定义:

      CREATE TABLE t (c1 VARCHAR(39) CHARACTER SET utf8 DEFAULT NULL);
      
    • 返回的字符串使用小写的IPv6地址的信。

    mysql> SELECT INET6_NTOA(INET6_ATON('fdfe::5a55:caff:fefa:9089'));
            -> 'fdfe::5a55:caff:fefa:9089'
    mysql> SELECT INET6_NTOA(INET6_ATON('10.0.5.9'));
            -> '10.0.5.9'
    
    mysql> SELECT INET6_NTOA(UNHEX('FDFE0000000000005A55CAFFFEFA9089'));
            -> 'fdfe::5a55:caff:fefa:9089'
    mysql> SELECT INET6_NTOA(UNHEX('0A000509'));
            -> '10.0.5.9'
    
  • IS_FREE_LOCK(str)

    -是否认识一个叫“锁”str是免费使用的(即不锁定)。退货如果锁是免费的(没有一个是用锁),0如果锁在使用中,和无效的如果出现错误(如不正确的说法)。

    这个函数是基于语句的复制不安全。警告如果你使用这个功能的时候登录binlog_format是集声明

  • IS_IPV4(expr)

    返回1,如果参数是一个有效的IPv4地址指定为一个字符串,否则为0。

    mysql> SELECT IS_IPV4('10.0.5.9'), IS_IPV4('10.0.5.256');
            -> 1, 0
    

    对于一个给定的参数,如果IS_IPV4()返回1,INET_ATON()(和INET6_ATON())将返回非—无效的。相反的说法是不正确的:在某些情况下,INET_ATON()收益率非—无效的什么时候IS_IPV4()返回0

    通过前面的言论暗示,IS_IPV4()是不是更严格INET_ATON()关于什么构成一个有效的IPv4地址,所以它可能需要执行强对无效值的应用是有用的。另外,使用INET6_ATON()将IPv4地址的内部形式和检查一无效的结果(这表明无效地址)。INET6_ATON()同样是强大的IS_IPV4()检查的IPv4地址

  • IS_IPV4_COMPAT(expr)

    这个函数接受一个IPv6地址以数字形式表示为一个二进制字符串,返回的INET6_ATON()。它返回1,如果参数是一个有效的IPv4兼容的IPv6地址,否则为0。IPv4兼容地址的形式::ipv4_address

    MySQL的&#62;SELECT IS_IPV4_COMPAT(INET6_ATON('::10.0.5.9'));-> 1mysql>SELECT IS_IPV4_COMPAT(INET6_ATON('::ffff:10.0.5.9'));&#62; 0

    一个兼容IPv4地址IPv4部分也可以用十六进制表示。例如,198.51.100.1这种原始的十六进制值:

    MySQL的&#62;SELECT HEX(INET6_ATON('198.51.100.1'));c6336401”- &#62;“

    在IPv4兼容的形式表达,::198.51.100.1相当于C0A8:0001或(不带前导零)::c0a8:1

    MySQL的&#62;SELECT-&#62;  IS_IPV4_COMPAT(INET6_ATON('::198.51.100.1')),-&#62;  IS_IPV4_COMPAT(INET6_ATON('::c0a8:0001')),-&#62;  IS_IPV4_COMPAT(INET6_ATON('::c0a8:1'));&#62; 1,1,1
  • IS_IPV4_MAPPED(expr)

    这个函数接受一个IPv6地址以数字形式表示为一个二进制字符串,返回的INET6_ATON()。它返回-1如果参数是一个有效的IPv4映射的IPv6地址,否则。IPv4映射地址的形式:::::::ffffipv4_address

    MySQL的&#62;SELECT IS_IPV4_MAPPED(INET6_ATON('::10.0.5.9'));-> 0mysql>SELECT IS_IPV4_MAPPED(INET6_ATON('::ffff:10.0.5.9'));-&#62; 1

    IS_IPV4_COMPAT()IPv4部分IPv4映射地址也可以用十六进制表示:

    MySQL的&#62;SELECT-&#62;  IS_IPV4_MAPPED(INET6_ATON('::ffff:198.51.100.1')),-&#62;  IS_IPV4_MAPPED(INET6_ATON('::ffff:c0a8:0001')),-&#62;  IS_IPV4_MAPPED(INET6_ATON('::ffff:c0a8:1'));&#62; 1,1,1
  • IS_IPV6(expr)

    返回1,如果参数是一个有效的IPv6地址指定为一个字符串,否则为0。这个函数不考虑IPv4地址的IPv6地址是有效的。

    mysql> SELECT IS_IPV6('10.0.5.9'), IS_IPV6('::1');
            -> 0, 1
    

    对于一个给定的参数,如果IS_IPV6()返回1,INET6_ATON()将非—无效的

  • IS_USED_LOCK(str)

    -是否认识一个叫“锁”str在使用(即锁定)。如果是这样,则返回持有锁定客户端的会话标识符的连接。否则,它返回无效的

    这个函数是基于语句的复制不安全。警告如果你使用这个功能的时候登录binlog_format是集声明

  • IS_UUID(string_uuid)

    返回1,如果参数是一个有效的字符串格式的UUID,0如果参数不是一个有效的UUID和NULL如果参数是无效的

    有效意味着价值是一个可以解析的格式。那就是,它有正确的长度和只包含允许的字符(十六进制数字在任何lettercase和,任选地,破折号和括号)。这种格式是最常见的:

    aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee
    

    这些其他格式也是允许的:

    aaaaaaaabbbbccccddddeeeeeeeeeeee
    {aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee}
    

    对领域内的价值意义,看UUID()功能描述

    MySQL的&#62;SELECT IS_UUID('6ccd780c-baba-1026-9564-5b8c656024db');------------------------------------------------- | is_uuid(&#39;6ccd780c-baba-1026-9564-5b8c656024db”)| ------------------------------------------------- | 1 | ------------------------------------------------- MySQL &#62;SELECT IS_UUID('6CCD780C-BABA-1026-9564-5B8C656024DB');------------------------------------------------- | is_uuid(&#39;6ccd780c-baba-1026-9564-5b8c656024db”)| ------------------------------------------------- | 1 | ------------------------------------------------- MySQL &#62;SELECT IS_UUID('6ccd780cbaba102695645b8c656024db');--------------------------------------------- | is_uuid(&#39;6ccd780cbaba102695645b8c656024db”)| --------------------------------------------- | 1 | --------------------------------------------- MySQL &#62;SELECT IS_UUID('{6ccd780c-baba-1026-9564-5b8c656024db}');--------------------------------------------------- | is_uuid(“{ }”6ccd780c-baba-1026-9564-5b8c656024db)| --------------------------------------------------- | 1 | --------------------------------------------------- MySQL &#62;SELECT IS_UUID('6ccd780c-baba-1026-9564-5b8c6560');--------------------------------------------- | is_uuid(&#39;6ccd780c-baba-1026-9564-5b8c6560”)| --------------------------------------------- | 0 | --------------------------------------------- MySQL &#62;SELECT IS_UUID(RAND());| ----------------------是_(UUID)的边缘(0)| --------------------- | | ---------------------
  • MASTER_POS_WAIT(log_name,log_pos[,timeout][,channel])

    此功能是有用的主从同步控制。那块直到从阅读和应用所有更新到指定的位置在主日志。返回值是记录事件的奴隶不得不等待提前到指定位置数量。函数返回NULL如果从SQL线程不开始,奴隶的主人信息没有初始化,参数是不正确的,或发生错误。它返回- 1如果超时时间已超过。如果从SQL线程停止时MASTER_POS_WAIT()是等待,函数返回无效的。如果从过去的指定位置,函数立即返回。

    在一个多线程功能的奴隶,等到到期限制设置的slave_checkpoint_groupslave_checkpoint_period系统变量,当检查点操作称为更新的奴隶的地位。根据对系统变量的设置,功能可能因此返回后到达指定位置的时间。

    如果一个timeout指定值,MASTER_POS_WAIT()停止等待的时候timeout秒后timeout必须大于0;10或负timeout意味着没有超时

    可选channel价值可以使你的名字复制通道功能适用于。看到第17.2.3,“复制通道”更多信息

    这个函数是基于语句的复制不安全。警告如果你使用这个功能的时候登录binlog_format是集声明

  • NAME_CONST(name,value)

    返回给定值。使用时,产生一个结果集的列,NAME_CONST()原因列有名字。争论应该是常数。

    MySQL的&#62;SELECT NAME_CONST('myname', 14);“……………………”

    此功能仅供内部使用。服务器使用它的写作从存储的程序包含参考本地程序变量声明时,如23.7节,“二进制日志存储程序”。你可能看到这个功能的输出mysqlbinlog

    你的应用程序,你可以得到完全相同的结果作为例子使用简单的锯齿上面,像这样:

    mysql> SELECT 14 AS myname;
    +--------+
    | myname |
    +--------+
    |     14 |
    +--------+
    1 row in set (0.00 sec)
    

    看到第13.2.10,选择“语法”有关更多信息,列的别名。

  • RELEASE_ALL_LOCKS()

    释放所有的锁为当前会话举行并返回锁释放的数量(0如果没有)

    这个函数是基于语句的复制不安全。警告如果你使用这个功能的时候登录binlog_format是集声明

  • RELEASE_LOCK(str)

    释放锁的字符串命名str这是获得GET_LOCK()。退货如果锁被释放,0如果锁是不是该线程的建立(在这种情况下,锁不释放),和无效的如果指定的锁是不存在的。锁不存在,如果它没有通过一个电话了GET_LOCK()如果它已被释放

    这个DO声明使用方便RELEASE_LOCK()。看到第13.2.3,“语法”

    这个函数是基于语句的复制不安全。警告如果你使用这个功能的时候登录binlog_format是集声明

  • SLEEP(duration)

    睡觉(停顿)为秒数的duration参数,然后返回0。时间可能有一个小数部分。如果参数是无效的或负,SLEEP()产生一个警告,或者一个错误严格的SQL模式。

    睡眠通常返回时(不间断),则返回0:

    mysql> SELECT SLEEP(1000);
    +-------------+
    | SLEEP(1000) |
    +-------------+
    |           0 |
    +-------------+
    

    什么时候SLEEP()是唯一的一个查询,中断调用,则返回1,查询本身没有返回错误。查询是否被杀或倍,这是真的:

    • 这项声明是中断的使用KILL QUERY从另一个会话

      MySQL的&#62;SELECT SLEEP(1000);------------- |睡眠(1000)| ------------- | 1 | -------------
    • 这项声明是由定时中断:

      mysql> SELECT /*+ MAX_EXECUTION_TIME(1) */ SLEEP(1000);
      +-------------+
      | SLEEP(1000) |
      +-------------+
      |           1 |
      +-------------+
      

    什么时候SLEEP()仅仅是一个查询,中断,查询将返回一个错误:

    • 这项声明是中断的使用KILL QUERY从另一个会话

      MySQL的&#62;SELECT 1 FROM t1 WHERE SLEEP(1000);错误1317(70100):查询执行被中断
    • 这项声明是由定时中断:

      mysql> SELECT /*+ MAX_EXECUTION_TIME(1000) */ 1 FROM t1 WHERE SLEEP(1000);
      ERROR 3024 (HY000): Query execution was interrupted, maximum statement
      execution time exceeded
      

    这个函数是基于语句的复制不安全。警告如果你使用这个功能的时候登录binlog_format是集声明

  • UUID()

    返回一个通用唯一标识符(UUID)根据RFC 4122产生,通用唯一标识符(UUID)瓮命名空间http:/ / / / rfc4122.txt是RFC

    一个UUID是设计为一个在时间和空间上的全局唯一。两个电话UUID()预计将产生不同的价值,即使这些调用是在两个独立的设备相互连接进行。

    警告

    虽然UUID()值的目的是独特的,他们不一定不可猜测或不可预知的。如果不可预测性是必需的,UUID值应该产生一些其他的方式。

    UUID()返回一个符合UUID 1版本作为RFC 4122中描述的价值。该值是一个128比特数表示为UTF8在五进制数字的字符串aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee格式:

    • 第一个数字是从低,中产生的,和一个时间戳高部位。高的部分还包括UUID版本号。

    • 第四号的保留时间的唯一性的情况下,时间戳值失单调性(例如,由于日光节约时间)。

    • 第五号是一个IEEE 802节点数,提供了空间的独特性。一个随机数代替如果后者不可用(例如,因为主机没有以太网卡,或是未知如何找到主机上的操作系统接口的硬件地址)。在这种情况下,空间的独特性无法保证。然而,碰撞应该非常低概率

      一个接口的MAC地址是只考虑在FreeBSD和Linux。在其他的操作系统,MySQL的使用一个随机生成的48位数字。

    mysql> SELECT UUID();
            -> '6ccd780c-baba-1026-9564-5b8c656024db'
    

    字符串和二进制的UUID值之间的转换,使用UUID_TO_BIN()BIN_TO_UUID()功能.要检查一个字符串是否是有效的UUID值,使用IS_UUID()功能

    笔记

    UUID()不基于语句的复制工作。

  • UUID_SHORT()

    返回一个通用标识符为64位无符号整数。返回的值UUID_SHORT()不同于128bit的标识符字符串格式返回的UUID()功能和不同的独特性能。价值UUID_SHORT()如果以下条件成立肯定是独一无二的:

    • 这个server_id当前服务器的值是0和255之间,是独一无二的你的主从服务器

    • 你不把你的服务器主机系统之间的时间mysqld重新启动

    • 你调用UUID_SHORT()平均少于1600万次/秒之间mysqld重新启动

    这个UUID_SHORT()返回值是这种建造方式:

    (server_id & 255) << 56+ (server_startup_time_in_seconds << 24)+ incremented_variable++;
    mysql> SELECT UUID_SHORT();
            -> 92395783831158784
    
    笔记

    UUID_SHORT()不基于语句的复制工作。

  • UUID_TO_BIN(string_uuid)UUID_TO_BIN(string_uuid, swap_flag)

    将字符串转换为一个二进制的UUID UUID并返回结果。(TheIS_UUID()功能描述列表允许串UUID格式。)返回二进制UUID是一VARBINARY(16)value。如果uuid argument也无效的,返回值是NULL。如果任何参数无效,发生了一个错误。

    UUID_TO_BIN()以一个或两个参数:

    • 一个参数的形式以一个字符串的UUID值。二进制结果是在同一顺序的字符串参数。

    • 两论证形式以串UUID值和一个标志值:

      • 如果swap_flag0、双参数形式相当于一个参数的形式。二进制结果是在同一顺序的字符串参数。

      • 如果swap_flag1、返回值的格式不同:时间低和高的部分(十六进制数字,第一和第三组)交换。这将更快速变化的部分的权利,如果结果是存储在一个索引列提高索引效率。

    部分时间交换假设1版本使用UUID值,如所产生的UUID()功能。为UUID值通过其他方式不遵循1版格式制作,一部分时间交换提供没有任何好处。关于1版格式的详细信息,参见UUID()功能描述

    假设您有以下串UUID值:

    mysql> SET @uuid = '6ccd780c-baba-1026-9564-5b8c656024db';
    

    将字符串转换为二进制的UUID或没有时间部分交换,使用UUID_TO_BIN()

    MySQL的&#62;SELECT HEX(UUID_TO_BIN(@uuid));---------------------------------- |十六进制(UUID _(@ UUID)是一_)| ---------------------------------- | 6ccd780cbaba102695645b8c656024db | ---------------------------------- MySQL &#62;SELECT HEX(UUID_TO_BIN(@uuid, 0));---------------------------------- |十六进制(UUID _ to _宾(@ UUID,0)| ---------------------------------- | 6ccd780cbaba102695645b8c656024db | ---------------------------------- MySQL &#62;SELECT HEX(UUID_TO_BIN(@uuid, 1));---------------------------------- |十六进制(UUID _对_仓(@ UUID,1))| ---------------------------------- | 1026baba6ccd780c95645b8c656024db | ----------------------------------

    将一个二进制UUID返回UUID_TO_BIN()一个串UUID,使用BIN_TO_UUID()。如果你产生一个二进制的UUID通过调用UUID_TO_BIN()第二论点的一部分交换的时间,你也应该通过的第二个参数1BIN_TO_UUID()对unswap时间时转换回二进制串UUID UUID:

    MySQL的&#62;SELECT BIN_TO_UUID(UUID_TO_BIN(@uuid));-------------------------------------- | bin_to_uuid(uuid_to_bin(@ UUID))| -------------------------------------- | 6ccd780c-baba-1026-9564-5b8c656024db | -------------------------------------- MySQL &#62;SELECT BIN_TO_UUID(UUID_TO_BIN(@uuid,0),0);-------------------------------------- | bin_to_uuid(uuid_to_bin(@ UUID,0),0)| -------------------------------------- | 6ccd780c-baba-1026-9564-5b8c656024db | -------------------------------------- MySQL &#62;SELECT BIN_TO_UUID(UUID_TO_BIN(@uuid,1),1);* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

    如果在两个方向上的转换的时间部分交换是不一样的,原来的UUID不会恢复正常:

    mysql> SELECT BIN_TO_UUID(UUID_TO_BIN(@uuid,0),1);
    +--------------------------------------+
    | BIN_TO_UUID(UUID_TO_BIN(@uuid,0),1)  |
    +--------------------------------------+
    | baba1026-780c-6ccd-9564-5b8c656024db |
    +--------------------------------------+
    mysql> SELECT BIN_TO_UUID(UUID_TO_BIN(@uuid,1),0);
    +--------------------------------------+
    | BIN_TO_UUID(UUID_TO_BIN(@uuid,1),0)  |
    +--------------------------------------+
    | 1026baba-6ccd-780c-9564-5b8c656024db |
    +--------------------------------------+
    
  • VALUES(col_name)

    在一个INSERT ... ON DUPLICATE KEY UPDATE语句,您可以使用值(col_name函数在UPDATE条款是指从列值INSERT的声明部分。换句话说,值(col_nameUPDATE条款是指价值col_name将插入,没有重复键发生冲突。此功能是特别有用的多行插入。这个VALUES()函数只有在有意义的在重复的密钥更新条款INSERT语句并返回无效的否则。看到第13.2.6.2,插入…在重复的密钥更新语法”

    mysql> INSERT INTO table (a,b,c) VALUES (1,2,3),(4,5,6)
        -> ON DUPLICATE KEY UPDATE c=VALUES(a)+VALUES(b);
    

12.23数学精度

MySQL提供了精密的数学支持:数值非常精确的结果处理结果和无效值高度控制。精密的数学是基于这两个特征:

  • SQL模式,控制严格的服务器是接受或拒绝无效数据。

  • 定点算术MySQL库。

这些特点对数字运算的几个问题并提供高度的标准SQL的依从性:

  • 精确计算:确切的值数,计算不引入浮点错误。相反,使用精确的精度。例如,MySQL将号码如.0001作为一个精确值,而不是作为一个近似,并总结这10000次的结果准确,不是一个价值,只是关闭1

  • 定义舍入行为:确切的值数,结果ROUND()取决于它的参数,而不是环境因素如底层C库工程。

  • 平台独立性:精确数值的操作是相同的在不同的平台,如Windows和Unix。

  • 在处理无效的数据控制:溢出,除数为零的检测可以作为误差。例如,你可以把一个值太大,一列为一个错误而不是值截断躺在列的数据类型的范围。同样的,你可以把除数为零而不是作为结果的操作错误NULL。选择哪种方法,采取由服务器的SQL模式设置确定。

下面讨论如何精确数学工作的几个方面,包括旧的应用程序可能不兼容。最后,给出了一些例子,说明如何处理数字运算精确的MySQL。有关控制SQL模式的信息,参见第5.1.10,”服务器的SQL模式”

12.23.1类型的数值

为准确值运算精度数学的范围包括确切的值的数据类型(整数和DECIMAL类型)和精确值,数值型的字面值。近似值的数据类型和数值型的字面值是浮点数处理。

精确的数值常量有整数部分和小数部分,或两者。他们可能会签署。实例:123.4- 5-6.78九点一零

近似值的数字字面值是科学记数法与尾数和指数来表征。一方或双方可能会签署。实例:1.2E31.2e-3-1.2E3-1.2e-3

两个数字,类似可以区别对待。例如,2.34是一个精确值(定点)数,而2.34e0是一个近似值(浮点)数。

这个DECIMAL数据类型是定点式和计算是精确的。在MySQL的DECIMAL有几个同义词:NUMERICDECFIXED。整数类型也有确切的值类型。

这个FLOATDOUBLE数据类型是浮点型和计算是近似。在MySQL,这是同义词的类型FLOATDOUBLEDOUBLE PRECISIONREAL

12.23.2小数数据类型特征

本节讨论的特点DECIMAL数据类型(和它的同义词),特别是关于以下主题:

  • 数字的最大数目

  • 存储格式

  • 存储要求

  • 非标准的MySQL扩展范围上限DECIMAL专栏

一个声明的语法DECIMAL(小数点MD。该参数值的范围如下:

  • M是数字的最大位数(精度)。它有一个范围1到65。

  • D是在小数点的位数(规模)。它有一个范围0-30和不得大于M

最大值为65M意味着计算DECIMAL值精确到65位数字。这65位精度的限制也适用于精确值数值常量,所以这些文字的最大范围不同于之前。

DECIMAL柱是以二进制格式,包9小数位数为四字节存储。对于整数和小数部分的每一个值的存储要求分别确定。每一个九位数需要4个字节,和任何剩余的数字剩下需要一些分数为4字节。剩余的数字存储空间由下表给出。

剩下的数字字节数
1–2
3–4
五–6
7–9

例如,一个DECIMAL(18,9)柱上有九位数的小数点两边,所以整数部分和小数部分各需要4个字节。一decimal(206)列十四位和六位整数分数。需要四个字节的整数位数为九的数字和3的剩余五位字节。六分位数需要3个字节。

DECIMAL列不存储领先 字符或-人物或领导数字。如果你插入+0003.1decimal(5.1)柱,这是存储为3.1。对于负数,文字不存储字符

DECIMAL列不允许值大于范围的列定义隐含。例如,一个十进制(3.0)柱支持范围-999九百九十九。一DECIMAL(M,D)列允许了MD小数点左边的数字

SQL标准要求的精度NUMERIC(M,D)确切地M数字。为(小数点MD,标准要求的精度至少M但是允许更多的数字。在MySQL,(小数点MDnumeric(MD都是一样的,都有一个精密准确M数字

为内部格式的一个完整的解释DECIMAL值,见文件C字符串/小数在MySQL源分布。格式说明(举例)在decimal2bin()功能

12.23.3表达处理

精密的数学,精确值数作为尽可能。例如,数字比较用完全没有价值的变化。严格的SQL模式,为INSERT为一个确切的数据类型的列(DECIMAL或整数),大量插入其精确值是否在列范围。在检索时,该值应为插入相同。(如果严格的SQL模式未启用,截断INSERT是允许的。)

一个数值表达式的处理取决于什么样的值表达式包含:

  • 如果任何近似值的存在,表达的是近似的,使用浮点算法评价。

  • 如果没有近似值,表达式只包含精确值。如果任何确切的值包含小数部分(小数点后的值),计算表达式使用DECIMAL精确的算法具有65位精度。术语确切有什么可以表示二进制的限制。例如,1.0/3.0可以近似用十进制数表示为。333…,但不写为一个确切的数字,所以(1.0/3.0)*3.0不评估准确

  • 否则,表达式只包含整数的值。表达准确、使用整数算术评估具有精度相同BIGINT(64位)

如果一个数值表达式包含任何字符串,它们被转换为双精度浮点值和表达式近似。

插入数字列的SQL模式的影响,由sql_mode系统变量。(See第5.1.10,”服务器的SQL模式”。)下面的讨论提到严格模式(选择的STRICT_ALL_TABLESSTRICT_TRANS_TABLES模式值)和ERROR_FOR_DIVISION_BY_ZERO。打开所有的限制,你可以简单地使用TRADITIONAL模式,包括价值观和严格的模式ERROR_FOR_DIVISION_BY_ZERO

MySQL的&#62;SET sql_mode='TRADITIONAL';

如果一个数插入到精确型柱(DECIMAL或整数),它是插入其精确值是否在列范围。

如果值在小数部分的位数太多了,圆时,将生成一条警告。圆是描述第12.23.4,“舍入行为”

如果值的整数部分的位数太多,太大,处理如下:

  • 如果没有启用严格模式,价值是截断到最近的法律价值和生成一个警告。

  • 如果严格模式已启用,溢出错误。

底流没有检测到,所以下溢处理未定义。

对于插入字符串到数字列,从字符串到数字的转换处理如下如果字符串的数字内容:

  • 一个字符串,不能以数字开头,不能作为一个数,产生一个错误或警告,否则严格模式。这包括空字符串。

  • 一个字符串,开始与一些可以转换,但后面的数字部分被截断。如果截断部分包含以外的任何空间,这就产生了一个错误的严格模式,或警告,否则。

默认情况下,被零除的结果NULL没有警告。通过设置适当的SQL模式,被零除可以限制。

ERROR_FOR_DIVISION_BY_ZEROSQL模式启用,MySQL的不同处理零分:

  • 如果没有启用严格模式,发生了警告。

  • 如果严格模式已启用,将涉及被零除禁止更新,并发生了一个错误。

换句话说,插入和更新涉及执行除法零表达式可以被视为错误,但这需要ERROR_FOR_DIVISION_BY_ZERO除了严格的模式

假设我们有这种说法:

INSERT INTO t SET i = 1/0;

这是什么事情,组合严谨ERROR_FOR_DIVISION_BY_ZERO模式

sql_mode价值结果
''(默认)没有警告,没有错误;i是集无效的
严格的没有警告,没有错误;i是集无效的
ERROR_FOR_DIVISION_BY_ZERO警告,没有错误;i是集无效的
严格,ERROR_FOR_DIVISION_BY_ZERO错误条件;没有插入行。

12.23.4舍入行为

本节讨论数学的精度舍入ROUND()功能和插入列与精确值类型(DECIMAL与整数)

这个ROUND()功能轮不同取决于它的参数是否是精确的或近似:

  • 为准确值数,ROUND()使用圆的一半了规则:一个小数部分的值。5或更大的圆形的到下一个整数如果阳性或到下一个整数如果负。(换句话说,它是圆形的远离零。)一个没有小数部分的值。5向下舍入到下一个整数如果阳性或到下一个整数如果负。

  • 近似值的数字,结果取决于C库。在许多系统中,这意味着ROUND()使用即使舍入到最接近的规则:任何一个小数部分的值被舍入到最近的整数。

下面的示例演示如何绕过不同的精确的和近似值:

mysql> SELECT ROUND(2.5), ROUND(25E-1);
+------------+--------------+
| ROUND(2.5) | ROUND(25E-1) |
+------------+--------------+
| 3          |            2 |
+------------+--------------+

对于插入DECIMAL或整数列,目标是一个精确的数据类型,因此舍入用途圆的一半的距离为零,无论是否被插入的值是精确的或近似:

mysql> CREATE TABLE t (d DECIMAL(10,0));
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO t VALUES(2.5),(2.5E0);
Query OK, 2 rows affected, 2 warnings (0.00 sec)
Records: 2  Duplicates: 0  Warnings: 2

mysql> SELECT d FROM t;
+------+
| d    |
+------+
| 3    |
| 3    |
+------+

12.23.5精密的数学例子

本节提供了一些例子,显示精度数学的查询结果在MySQL。这些例子说明中描述的原则第12.23.3,表达处理”,和第12.23.4,“舍入行为”

例1.。数字是用精确值在可能的:

mysql> SELECT (.1 + .2) = .3;
+----------------+
| (.1 + .2) = .3 |
+----------------+
|              1 |
+----------------+

浮点值,结果是不准确的:

mysql> SELECT (.1E0 + .2E0) = .3E0;
+----------------------+
| (.1E0 + .2E0) = .3E0 |
+----------------------+
|                    0 |
+----------------------+

另一种方式看,在精确和近似值的处理不同的是添加一个小数目,和很多次。考虑下面的存储过程,它增加了.0001一个变量的1000倍。

CREATE PROCEDURE p ()BEGIN  DECLARE i INT DEFAULT 0;  DECLARE d DECIMAL(10,4) DEFAULT 0;  DECLARE f FLOAT DEFAULT 0;  WHILE i < 10000 DO    SET d = d + .0001;    SET f = f + .0001E0;    SET i = i + 1;  END WHILE;  SELECT d, f;END;

两者的总和dF逻辑上应该是1,但这是真的只有小数计算。浮点计算了小错误:

+--------+------------------+
| d      | f                |
+--------+------------------+
| 1.0000 | 0.99999999999991 |
+--------+------------------+

例2。乘法是通过标准的SQL所需的规模进行。这是两个数X1X2有规模S1S2结果是,规模S1 S2

MySQL的&#62;SELECT .01 * .01;----------- |。01。01 | ----------- | 0.0001 | -----------

例3。舍入行为精确值的数字是明确的:

舍入行为(例如,与ROUND()功能)是独立于底层的C库的实现,这意味着结果一致的平台。

  • 舍入的精确值的列(DECIMAL和整数)的精确值的数字使用圆的一半的距离为零规则一个小数部分的值。5或更大的圆形从零到最近的整数,如下所示:

    mysql> SELECT ROUND(2.5), ROUND(-2.5);
    +------------+-------------+
    | ROUND(2.5) | ROUND(-2.5) |
    +------------+-------------+
    | 3          | -3          |
    +------------+-------------+
    
  • 舍入的浮点值使用C库,这在许多系统中使用即使舍入到最接近的规则在这样的系统上的任何小数部分的值舍入到最近的整数:

    mysql> SELECT ROUND(2.5E0), ROUND(-2.5E0);
    +--------------+---------------+
    | ROUND(2.5E0) | ROUND(-2.5E0) |
    +--------------+---------------+
    |            2 |            -2 |
    +--------------+---------------+
    

例4。严格模式,插入一个值超出范围为列会导致错误,而不是截断到法律价值。

当MySQL没有严格的运行模式,截断到法律价值发生:

mysql> SET sql_mode='';
Query OK, 0 rows affected (0.00 sec)

mysql> CREATE TABLE t (i TINYINT);
Query OK, 0 rows affected (0.01 sec)

mysql> INSERT INTO t SET i = 128;
Query OK, 1 row affected, 1 warning (0.00 sec)

mysql> SELECT i FROM t;
+------+
| i    |
+------+
|  127 |
+------+
1 row in set (0.00 sec)

然而,如果严格的模式实际上是发生了一个错误:

mysql> SET sql_mode='STRICT_ALL_TABLES';
Query OK, 0 rows affected (0.00 sec)

mysql> CREATE TABLE t (i TINYINT);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO t SET i = 128;
ERROR 1264 (22003): Out of range value adjusted for column 'i' at row 1

mysql> SELECT i FROM t;
Empty set (0.00 sec)

例5:严格模式和ERROR_FOR_DIVISION_BY_ZERO集,由零导致错误的划分,不是一个结果无效的

在非严格模式,被零除有结果NULL

MySQL的&#62;SET sql_mode='';查询好,为受影响的行(0.01秒)MySQL &#62;CREATE TABLE t (i TINYINT);查询好,为受影响的行(0.001秒)MySQL &#62;INSERT INTO t SET i = 1 / 0;查询行,1行的影响(0秒)MySQL &#62;SELECT i FROM t;------ |我| ------ |空| ------ 1行集(0.03秒)

然而,被零除错误如果是适当的SQL模式的影响:

mysql> SET sql_mode='STRICT_ALL_TABLES,ERROR_FOR_DIVISION_BY_ZERO';
Query OK, 0 rows affected (0.00 sec)

mysql> CREATE TABLE t (i TINYINT);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO t SET i = 1 / 0;
ERROR 1365 (22012): Division by 0

mysql> SELECT i FROM t;
Empty set (0.01 sec)

例6。精确值文字进行精确值。

近似值的文本使用浮点计算的精确值,但文字处理DECIMAL

MySQL的&#62;CREATE TABLE t SELECT 2.5 AS a, 25E-1 AS b;查询行,1行的影响(0.01秒)记录:1份:0警告:0mysql &#62;DESCRIBE t;------- ----------------------- ------ ----- --------- ------- |场|型|空|关键|默认|额外| ------- ----------------------- ------ ----- --------- ------- |一|十进制(2,1)符号|没有| | 0 | | | B |双|没有| | 0 | | ------- ----------------------- ------ ----- --------- ------- 2行集(0.01秒)

例7.。如果参数为聚合函数的精确数字类型,结果也是一个精确数字类型与规模至少的说法。

考虑到这些语句:

mysql> CREATE TABLE t (i INT, d DECIMAL, f FLOAT);
mysql> INSERT INTO t VALUES(1,1,1);
mysql> CREATE TABLE y SELECT AVG(i), AVG(d), AVG(f) FROM t;

其结果是一个双只为浮点参数。确切的类型的参数,结果也是一个确切的类型:

mysql> DESCRIBE y;
+--------+---------------+------+-----+---------+-------+
| Field  | Type          | Null | Key | Default | Extra |
+--------+---------------+------+-----+---------+-------+
| AVG(i) | decimal(14,4) | YES  |     | NULL    |       |
| AVG(d) | decimal(14,4) | YES  |     | NULL    |       |
| AVG(f) | double        | YES  |     | NULL    |       |
+--------+---------------+------+-----+---------+-------+

其结果是一个双只为浮点参数。确切的类型的参数,结果也是一个确切的类型。