1. 引言

1.1. 编写目的

LightDB 在语法、用法上和MySQL存在差异，本附录从数据类型、函数类型、SQL语法几个方面，介绍LigthDB的MySQL的兼容特性。

1.2. 预期读者

数据库管理员开发工程师测试工程师技术支持工程师

1.3. 参考文献

《LightDB-X参考手册》、《MySQL 8.0 Reference Manual》、《MySQL 5.7 Reference Manual》

2. GUC参数

2.1. lightdb_syntax_compatible_type

含义：: 该参数显示了当前实例安装时指定的兼容模式，当创建库时不指定兼容模式，则创建出来的库兼容模式即遵循该参数。
参数：: 实例级别，有效值为oracle、mysql、off，lightdb安装时默认值为off（即postgres模式）；

示例：

lightdb@testdb1=# show lightdb_syntax_compatible_type ;
 lightdb_syntax_compatible_type
--------------------------------
 Oracle
(1 row)

lightdb@testdb1=#
lightdb@testdb1=# create database db1;
NOTICE:  auto create user "db1" success
CREATE DATABASE
lightdb@testdb1=#
lightdb@testdb1=# \c db1
You are now connected to database "db1" as user "lightdb".
compatible type: oracle

2.2. lightdb_dblevel_syntax_compatible_type

含义：: 该参数显示了当前库的兼容模式，通过在创建库时指定参数LIGHTDB_SYNTAX_COMPATIBLE_TYPE来设置兼容模式。不同兼容模式的库可以在同一实例下共存。
参数：: 库级别，有效值为oracle、mysql、off。

示例：

lightdb@testdb1=# show lightdb_dblevel_syntax_compatible_type ;
 lightdb_dblevel_syntax_compatible_type
----------------------------------------
 MySql
(1 row)

lightdb@testdb1=#
lightdb@testdb1=# create database db2 with LIGHTDB_SYNTAX_COMPATIBLE_TYPE = oracle;
NOTICE:  auto create user "db2" success
CREATE DATABASE
lightdb@testdb1=#
lightdb@testdb1=# \c db2
You are now connected to database "db2" as user "lightdb".
compatible type: oracle
lightdb@db2=#
lightdb@db2=# show lightdb_dblevel_syntax_compatible_type ;
 lightdb_dblevel_syntax_compatible_type
----------------------------------------
 Oracle
(1 row)

2.3. lightdb_ascii_zero_store_value

含义：: 当兼容模式被设置为oracle或mysql，且该参数设置为非零ASCII码值, ASCII 码值 E’0’ 以及 CHR(0) 的值等于 ASCII 码值 lightdb_ascii_zero_store_value，如果通过JDBC的绑定参数与服务端交互，文本类型的参数中ASCII码值 ‘0’ 由 ASCII 码值 lightdb_ascii_zero_store_value 在服务器端被替换，libpq同样场景下，值替换发生在libpq这一端。注意，如果ASCII码值 ‘0’ 由 ASCII 码值 lightdb_ascii_zero_store_value替换，替换后此值在系统中的行为与 ASCII 码值 lightdb_ascii_zero_store_value 相同，比如，比较操作，concat函数调用，length函数调用，等其它接受字符输入参数的函数。

参数：

库级别，取值范围为0到32，包含0，32，数据库创建时指定，创建成功后不能被修改；

示例：

create database oradb with lightdb_ascii_zero_store_value 20 lightdb_syntax_compatible_type 'oracle';

lightdb@oradb=# create table t00(a char(1), b char(2));
CREATE TABLE
lightdb@oradb=# insert into t00(a,b) values(E'\0',E'\0');
INSERT 0 1
lightdb@oradb=# insert into t00(a,b) values(chr(0),chr(0));
INSERT 0 1
lightdb@oradb=#
lightdb@oradb=# select * from t00;
  a   |   b
------+-------
 \x14 | \x14
 \x14 | \x14
(2 rows)

lightdb@oradb=# select * from t00 where a=E'\0';
  a   |   b
------+-------
 \x14 | \x14
 \x14 | \x14
(2 rows)

lightdb@oradb=# UPDATE t00 SET b='a' where a=E'\0' LIMIT 1;
UPDATE 1
lightdb@oradb=# select * from t00;
  a   |   b
------+-------
 \x14 | \x14
 \x14 | a
(2 rows)

lightdb@oradb=# delete from t00 where a=E'\0';
DELETE 2
lightdb@oradb=# select * from t00;
 a | b
---+---
(0 rows)

2.4. lightdb_auto_incre_null_mysql_compatible

含义：: 该参数为了兼容mysql以下行为：当mysql的表列是auto_increment并且没有null约束，它允许向该列显式插入null值，并将使用自动生成的值作为列值；
参数：: 会话级别，true/on（兼容mysql行为），false/off（与pg行为一致），默认值为off；

示例：

lightdb@testdb1=# show lightdb_auto_incre_null_mysql_compatible ;
 lightdb_auto_incre_null_mysql_compatible
------------------------------------------
 off
(1 row)

lightdb@testdb1=#
lightdb@testdb1=# create table test(a serial primary key,b int not null default 0,v text not null default 'abc', v1 text);
CREATE TABLE
lightdb@testdb1=#
lightdb@testdb1=# insert into test (a) values(null);
ERROR:  null value in column "a" of relation "test" violates not-null constraint
DETAIL:  Failing row contains (null, 0, abc, null).
lightdb@testdb1=#
lightdb@testdb1=# set lightdb_auto_incre_null_mysql_compatible = on;
SET
lightdb@testdb1=#
lightdb@testdb1=# insert into test (a) values(null);
INSERT 0 1
lightdb@testdb1=#
lightdb@testdb1=# select * from test;
 a | b |  v  | v1
---+---+-----+----
 1 | 0 | abc |
(1 row)

2.5. lightdb_mysql_lower_case_table_names

含义：: 兼容mysql中lower_case_table_names功能，用于控制是否开启表名大小写敏感特性，通过在创建库时指定参数LIGHTDB_MYSQL_LOWER_CASE_TABLE_NAMES进行设置；
参数：: 库级别，1/true/on（关闭大小写敏感特性），0/false/off（开启大小写敏感特性），默认值为on；

示例：

lightdb@testdb1=# create database test_mysql with LIGHTDB_SYNTAX_COMPATIBLE_TYPE=mysql LIGHTDB_MYSQL_LOWER_CASE_TABLE_NAMES=0;
CREATE DATABASE
lightdb@testdb1=# \c test_mysql
You are now connected to database "test_mysql" as user "lightdb".
compatible type: mysql
lightdb@test_mysql=#
lightdb@test_mysql=# show lightdb_mysql_lower_case_table_names ;
 lightdb_mysql_lower_case_table_names
--------------------------------------
 off
(1 row)

lightdb@test_mysql=#
lightdb@test_mysql=# create table T5 (id int);
CREATE TABLE
lightdb@test_mysql=#
lightdb@test_mysql=# select * from T5;
 id
----
(0 rows)

lightdb@test_mysql=#
lightdb@test_mysql=# select * from t5;
ERROR:  relation "t5" does not exist
LINE 1: select * from t5;

2.6. lightdb_sql_mode

含义：兼容msyql的sql_mode，取值包括

no_zero_date，uppercase_identifier，默认值为空。
no_zero_date：严格匹配日期和格式，不匹配的返回null

示例：

lightdb@testdb1=# show lightdb_sql_mode ;
 lightdb_sql_mode
------------------

(1 row)

lightdb@testdb1=#
lightdb@testdb1=# SELECT str_to_date('9','%d');
  str_to_date
---------------
 0001-01-09 BC
(1 row)

lightdb@testdb1=#
lightdb@testdb1=# select str_to_date('August,5', '%M,%e,%Y');
  str_to_date
---------------
 0001-08-05 BC
(1 row)

lightdb@testdb1=#
lightdb@testdb1=# set lightdb_sql_mode to 'no_zero_date';
SET
lightdb@testdb1=#
lightdb@testdb1=# SELECT str_to_date('9','%d');
 str_to_date
-------------

(1 row)

lightdb@testdb1=#
lightdb@testdb1=# select str_to_date('August,5', '%M,%e,%Y');
 str_to_date
-------------

(1 row)

2.7. uppercase_identifier

查询列时大小写不敏感、显示列时大小写敏感；

示例：

# 指定数据库级实例模式为mysql模式
create database test_mysql_mode with lightdb_syntax_compatible_type mysql;
\c test_mysql_mode;

create table test_case_1(identifier1 varchar(10));

select * from test_case_1;
identifier1
-------------
(0 rows)

select IDentifier1 from test_case_1;
IDentifier1
-------------
(0 rows)

select identifier1 as IDentifier1 from test_case_1;
IDentifier1
-------------
(0 rows)

2.8. lightdb_only_full_group_by

含义：

兼容mysql的only_full_group_by，用于控制SELECT DISTINCT…ORDER BY语法是否与ONLY_FULL_GROUP_BY以外的msyql语法兼容；

参数：会话级别，on/true（postgres行为），off/false（mysql默认行为），默认值为on;

示例：

#默认情况下，lightdb将报告SELECT DISTINCT...ORDER BY语法中不一致列的错误：
select distinct a from test_distinct_order_tb1 order by d;
        ERROR:  for SELECT DISTINCT, ORDER BY expressions must appear in select list
        LINE 1: select distinct a from test_distinct_order_tb1 order by d;

#只有在MySQL兼容模式和lightdb_only_full_group_by设置off时，上述SQL才能正常执行：
set lightdb_only_full_group_by = off;
        SET
                select distinct a from test_distinct_order_tb1 order by d;
         a
        ---
         3
         1
         2
        (3 rows)

3. 数据类型

下表根据MySQL的数据类型，对数值类型、日期和时间类型、字符串（字符和字节）类型、空间类型和 JSON 数据类型的兼容性情况，进行概览展示。

数据类型概览
类型	MySQL	LightDB	兼容性	说明
数值型
1	TINYINT	smallint	支持	2字节小范围整数 -32768 to +32767
2	SMALLINT	smallint	支持	2字节小范围整数 -32768 to +32767
3	MEDIUMINT		不支持
4	INT	integer	支持	4字节整数的范围 -2147483648 to +2147483647
5	BIGINT	bigint	支持	8字节大范围整数 -9223372036854775808 to +9223372036854775807
6	DECIMAL[(M[,D])]	numeric[(m[,d])]	支持	可变用户指定精度，精确最高小数点前131072位，以及小数点后16383位
7	DEC[(M[,D])]	numeric[(m[,d])]	支持	可变用户指定精度，精确最高小数点前131072位，以及小数点后16383位
8	FLOAT(p)	real	支持	4字节可变精度，不精确 6位十进制精度
9	FLOAT(M,D)		不支持
10	FLOAT	double precision	支持	8字节可变精度，不精确 15位十进制精度
11	REAL(M,D)		不支持
12	REAL	real	支持	4字节可变精度，不精确 6位十进制精度
13	DOUBLE[(M,D)]		不支持
14	DOUBLE PRECISION(M,D)		不支持
15	DOUBLE PRECISION	double precision	支持	double precision 8字节可变精度，不精确 15位十进制精度
位串类型
1	BIT(M)	bit(m)	支持	二进制存储
2	BINARY[(M)]		不支持
3	VARBINARY(M)		不支持
日期时间类型
1	DATE	date	支持	4字节日期（没有一天中的时间）最小值：4713 BC 最大值：5874897 AD 解析度：1日
2	TIME[(fsp)]	time(fsp) without time zone	支持	8字节包括日期和时间，有时区最小值：4713 BC 最大值：294276 AD = 解析度：1微秒
3	DATETIME[(fsp)]		不支持
4	DATETIME	datetime	支持	8字节包括日期和时间（无时区）最小值：4713 BC 最大值：294276 AD 解析度：1微秒
4	TIMESTAMP[(fsp)]	timestamp(fsp) without time zone	支持	8字节包括日期和时间，有时区最小值：4713 BC 最大值：294276 AD 解析度：1微秒
5	YEAR[(fsp)]		不支持
字符串类型
1	CHAR(N)	character(n)	支持	有限制的变长
2	VARCHAR(N)	character varying(n)	支持	有限制的变长
3	SET(’value1’,’value2’,…)		不支持
4	ENUM(’value1’,’value2’,…)	enum(’value1’,’value2’,…)	支持	枚举类型可以使用CREATE TYPE命令创建。create type mood as eunm (‘sad’, ‘ok’, ‘happy’);
5	TINYTEXT		不支持
6	TEXT	text	支持	无限变长。最大长度10485760字节。
7	MEDIUMTEXT		不支持
8	LONGTEXT	longtext	支持	LONGTEXT是TEXT的别名
9	TINYBLOB		不支持
10	BLOB	bytea	支持	二进制大对象类型
11	MEDIUMBLOB		不支持
12	LONGBLOB		不支持
空间数据类型
1	GEOMETRY		不支持
2	POINT	point	支持	16字节平面上的点
3	LINESTRING		不支持
4	POLYGON	polygon	支持	40+16n字节多边形（类似于封闭路径）
JSON类型
1	JSON	json	支持	存储json数据

3.1. 数值型

3.1.1. TINYINT

类型说明：一个非常小的整数。在LightDB内部以smallint类型进行存储。2字节小范围整数 -32768 to +32767

lightdb@mysqltest=# create table a(id TINYINT);
CREATE TABLE
lightdb@mysqltest=# \d a
          Table "public.a"
Column |   Type   | Collation | Nullable | Default
--------+----------+-----------+----------+---------
id     | smallint |           |          |

3.1.2. SMALLINT

类型说明：一个小的整数。LightDB内部以smallint类型进行存储。2字节小范围整数 -32768 to +32767

lightdb@mysqltest=# create table a(id SMALLINT);
CREATE TABLE
lightdb@mysqltest=# \d a
          Table "public.a"
Column |   Type   | Collation | Nullable | Default
--------+----------+-----------+----------+---------
id     | smallint |           |          |

3.1.3. INT

类型说明：整数类型。LightDB内部以integer类型进行存储。4字节整数的范围 -2147483648 to +2147483647

lightdb@mysqltest=# create table a(id INT);
CREATE TABLE
lightdb@mysqltest=# \d a
         Table "public.a"
Column |  Type   | Collation | Nullable | Default
--------+---------+-----------+----------+---------
id     | integer |           |          |

3.1.4. BIGINT

类型说明：大整数类型。LightDB内部以bigint类型进行存储。8字节大范围整数 -9223372036854775808 to +9223372036854775807

lightdb@mysqltest=# create table a(id BIGINT);
CREATE TABLE
lightdb@mysqltest=#
lightdb@mysqltest=# \d a
         Table "public.a"
Column |  Type  | Collation | Nullable | Default
--------+--------+-----------+----------+---------
id     | bigint |           |          |

3.1.5. DECIMAL[(M[,D])]

类型说明：用于在数据库中存储精确的数值。我们经常将DECIMAL数据类型用于保留准确精确度的列，例如会计系统中的货币数据。可变大小用户指定精度，精确最高小数点前131072位，以及小数点后16383位

lightdb@mysqltest=# create table a(id DECIMAL(5,3));
CREATE TABLE
lightdb@mysqltest=# \d a
            Table "public.a"
Column |     Type     | Collation | Nullable | Default
--------+--------------+-----------+----------+---------
id     | numeric(5,3) |           |          |

3.1.6. DEC[(M[,D])]

类型说明：和DECIMAL[(M[,D])] 一致。

lightdb@mysqltest=# create table a(id DEC(5,3));
CREATE TABLE
lightdb@mysqltest=# \d a
            Table "public.a"
Column |     Type     | Collation | Nullable | Default
--------+--------------+-----------+----------+---------
id     | numeric(5,3) |           |          |

3.1.7. FLOAT(p)

类型说明：表示近似数值数据值。4字节可变精度，不精确 6位十进制精度。

lightdb@mysqltest=# create table a(id FLOAT(5));
CREATE TABLE
lightdb@mysqltest=# \d a
        Table "public.a"
Column | Type | Collation | Nullable | Default
--------+------+-----------+----------+---------
id     | real |           |          |

3.1.8. FLOAT

类型说明：表示近似数值数据值。8字节可变精度，不精确 15位十进制精度。

lightdb@mysqltest=# \d a
              Table "public.a"
Column |       Type       | Collation | Nullable | Default
--------+------------------+-----------+----------+---------
id     | double precision |           |          |

3.1.9. REAL

类型说明：表示近似数值数据值。4字节可变精度，不精确 6位十进制精度。

lightdb@mysqltest=# create table a(id REAL);
CREATE TABLE
lightdb@mysqltest=# \d a
        Table "public.a"
Column | Type | Collation | Nullable | Default
--------+------+-----------+----------+---------
id     | real |           |          |

3.1.10. DOUBLE PRECISION

类型说明：表示近似数值数据值。8字节可变精度，不精确 15位十进制精度。

lightdb@mysqltest=# create table a(id DOUBLE PRECISION);
CREATE TABLE
lightdb@mysqltest=# \d a
              Table "public.a"
Column |       Type       | Collation | Nullable | Default
--------+------------------+-----------+----------+---------
id     | double precision |           |          |

3.2. 位串类型

3.2.1. BIT(M)

类型说明：用于存储位值，位串就是一串 1 和 0 的串。BIT类型的数据必须准确匹配长度n; 试图存储短些或者长一些的位串都是错误的。

lightdb@mysqltest=# CREATE TABLE a (a BIT(3), b BIT(5));
INSERT INTO a VALUES(B'101',B'10001');

lightdb@mysqltest=# SELECT * from a;
a  |   b
-----+-------
101 | 10001
(1 row)

3.3. 日期时间类型

3.3.1. DATE

类型说明：任何标点符号都可以用作日期部分之间的分隔符。类似’YYYY-MM-DD’’YY-MM-DD’’2012-12-31’’2012/12/31’’2012^12^31’’2012@12@31’。4字节日期（没有一天中的时间）最小值：4713 BC 最大值：5874897 AD 解析度：1日

lightdb@mysqltest=#  SELECT DATE'2012@12@31';
        date
------------
2012-12-31
(1 row)

3.3.2. TIME[(fsp)]

类型说明：接受一个可选的精度值 fsp，这个精度值声明在秒域中小数点之后保留的位数。缺省情况下，在精度上没有明确的边界。fsp允许的范围是从 0 到 6,如果省略，则默认精度为 0。8字节包括日期和时间，有时区最小值：4713 BC 最大值：294276 AD 解析度：1微秒

CREATE TABLE a(c TIME(2));
INSERT INTO a VALUES('17:51:04.777');
lightdb@mysqltest=# SELECT * FROM a;
        c
-------------
17:51:04.78
(1 row)

3.3.3. DATETIME

类型说明：接受一个可选的精度值 fsp，这个精度值声明在秒域中小数点之后保留的位数。缺省情况下，在精度上没有明确的边界。fsp允许的范围是从 0 到 6,如果省略，则默认精度为 0。8字节包括日期和时间（无时区）最小值：4713 BC 最大值：294276 AD 解析度：1微秒

lightdb@mysqltest=# CREATE TABLE a(c TIME(2));
lightdb@mysqltest=# INSERT INTO a VALUES('17:51:04.777');
lightdb@mysqltest=# SELECT * FROM a;
        c
-------------
17:51:04.78
(1 row)

3.3.4. TIMESTAMP[(fsp)]

类型说明：接受一个可选的精度值 fsp，这个精度值声明在秒域中小数点之后保留的位数。缺省情况下，在精度上没有明确的边界。fsp允许的范围是从 0 到 6,如果省略，则默认精度为 0。8字节包括日期和时间，有时区最小值：4713 BC 最大值：294276 AD 解析度：1微秒

lightdb@mysqltest=# CREATE TABLE a(c TIMESTAMP(2));
lightdb@mysqltest=# INSERT INTO a VALUES('2018-09-08 17:51:04.777');
lightdb@mysqltest=# SELECT *FROM a;
   c
------------------------
2018-09-08 17:51:04.78
(1 row)

3.4. 字符串类型

3.4.1. CHAR(N)

类型说明：N是一个正整数。有限制地变长，可以存储最多n个字符长的串。

lightdb@mysqltest=# CREATE TABLE a(c char(4));
CREATE TABLE
lightdb@mysqltest=# \d a
            Table "public.a"
Column |     Type     | Collation | Nullable | Default
--------+--------------+-----------+----------+---------
c      | character(4) |           |          |

3.4.2. VARCHAR(N)

类型说明：N是一个正整数。有限制地变长，可以存储最多n个字符长的串。

lightdb@mysqltest=# CREATE TABLE a(c VARCHAR(4));
CREATE TABLE
lightdb@mysqltest=# \d a
                Table "public.a"
Column |         Type         | Collation | Nullable | Default
--------+----------------------+-----------+----------+---------
c      | character varying(4) |           |          |

3.4.3. ENUM(’value1’,’value2’,…)

类型说明：枚举类型可以使用CREATE TYPE命令创建。

#创建enum类型
    lightdb@mysqltest=# CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy');
    CREATE TYPE

    #建表，插入数据
    lightdb@mysqltest=# CREATE TABLE person (
name text,
current_mood mood
    );
    lightdb@mysqltest=# INSERT INTO person VALUES ('Moe', 'happy');
    SELECT * FROM person WHERE current_mood = 'happy';
    lightdb@mysqltest=# SELECT * FROM person WHERE current_mood = 'happy';
    name | current_mood
    ------+--------------
    Moe  | happy
    (1 row)

3.4.4. TEXT

类型说明：无限变长。最大长度支持10485760字节。

lightdb@mysqltest=# CREATE TABLE a(c TEXT);
CREATE TABLE
lightdb@mysqltest=# \d a
        Table "public.a"
Column | Type | Collation | Nullable | Default
--------+------+-----------+----------+---------
c      | text |           |          |

3.4.5. LONGTEXT

类型说明：LONGTEXT是TEXT的别名。

lightdb@mysqltest=# CREATE TABLE a(c LONGTEXT);
CREATE TABLE
lightdb@mysqltest=# \d a
          Table "public.a"
Column |   Type   | Collation | Nullable | Default
--------+----------+-----------+----------+---------
c      | longtext |           |          |

3.4.6. BLOB

类型说明：适用于存贮非文本的字节流数据（如程序、图象、影音等）。

    CREATE TABLE image (title text, raster lo);

    CREATE TRIGGER t_raster BEFORE UPDATE OR DELETE ON image
FOR EACH ROW EXECUTE FUNCTION lo_manage(raster);

3.5. 空间数据类型

3.5.1. POINT

类型说明：点是几何类型的基本二维构造块。用(x,y)语法描述point类型的值：

lightdb@mysqltest=# CREATE TABLE test_point(p POINT,t TEXT);
CREATE TABLE
lightdb@mysqltest=# INSERT INTO test_point VALUES(POINT(1,1),'第一个点');

lightdb@mysqltest=# select * from test_point;
        p   |    t
 -------+----------
 (1,1) | 第一个点
 (1 row)

3.5.2. POLYGON

类型说明： 1.多边形由一系列点代表（多边形的顶点）。多边形和封闭路径很像，但是存储方式不一样而且有自己的一套支持例程。 2.polygon类型的值用下列语法声明：如( ( x1 , y1 ) , … , ( xn , yn ) )、( x1 , y1 ) , … , ( xn , yn )、( x1 , y1 , … , xn , yn )、x1 , y1 , … , xn , yn

lightdb@mysqltest=# CREATE TABLE test_polygon(po POLYGON,t TEXT);
CREATE TABLE
lightdb@mysqltest=# INSERT INTO test_polygon VALUES(POLYGON '((0,0),(1,1),(2,0))','多边形');

lightdb@mysqltest=# SELECT * FROM test_polygon;
 po          |   t
---------------------+--------
((0,0),(1,1),(2,0)) | 多边形
(1 row)

3.6. JSON类型

3.6.1. JSON

类型说明：JSON 数据类型是用来存储 JSON（JavaScript Object Notation）数据的。这种数据也可以被存储为text，但是 JSON 数据类型的优势在于能强制要求每个被存储的值符合 JSON 规则。

lightdb@mysqltest=# SELECT '{"bar": "baz", "balance": 7.77, "active": false}'::json;
               json
--------------------------------------------------
{"bar": "baz", "balance": 7.77, "active": false}
(1 row)

4. 运算符类型

下表根据MySQL的运算符类型，对算数运算符、比较运算符、逻辑运算符、赋值运算符、位运算符和JSON运算符的兼容性情况，进行概览展示。

运算符列表概览
MySQL函数	LightDB函数	兼容性	说明	备注
算数运算符
乘法*	乘法*	支持	乘法运算符
加法+	加法+	支持	加法运算符
减法-	减法-	支持	减号运算符
符号-	符号-	支持	更改参数的符号
/	/	支持	分数运算符
%	%	支持	模运算符
DIV		不支持	整数除法
MOD		不支持	模运算符
比较运算符
>	>	支持	大于运算符
>=	>=	支持	大于或等于运算符
<	<	支持	小于操作符
<>，！=	<>，！=	支持	不相等的运算符
<=	<=	支持	小于或等于运算符
=	=	支持	相等运算符
BETWEEN … AND …	BETWEEN … AND …	支持	值是否在值范围内
IN()	IN()	支持	值是否在一组值中
IS	IS	支持	根据布尔值测试值
IS NOT	IS NOT	支持	根据布尔值测试值
IS NOT NULL	IS NOT NULL	支持	NOT NULL 值测试
IS NULL	IS NULL	支持	NULL 值测试
LIKE	LIKE	支持	简单的模式匹配
NOT BETWEEN … AND …	NOT BETWEEN … AND …	支持	值是否不在值范围内
NOT IN()	NOT IN()	支持	值是否不在一组值中
NOT LIKE	NOT LIKE	支持	否定简单的模式匹配
SOUNDS LIKE		不支持	比较sounds
<=>		不支持	安全等于运算符。严格比较两个NULL值是否相等
逻辑运算符
AND	AND	支持	逻辑 AND
NOT	NOT	支持	否定值
OR	OR	支持	逻辑 OR
\|\|	\|\|	支持	逻辑 \|\|	非标准运算符。8.0.17废弃
XOR		不支持	逻辑异或
&&		不支持	逻辑&&
!		不支持	否定值
赋值运算符
:=	:=	支持	赋值
=	=	支持	赋值（作为 SET 语句的一部分，或作为 UPDATE 语句中子句的一部分）SET
位运算符
&	&	支持	按位 AND
>>	>>	支持	右移
<<	<<	支持	左移
^	^	支持	按位异或
位\|	位\|	支持	按位 OR
~	~	支持	按位反转
JSON运算符
->	->	支持	评估路径后从JSON列返回值;等同于 JSON_EXTRACT（）。
->>	->>	支持	评估路径并取消引用后从 JSON 列返回值结果;等价于 JSON_UNQUOTE（JSON_EXTRACT（））。
MEMBER OF()		不支持	如果第一个操作数与 JSON 的任何元素匹配，则返回 true （1）数组作为第二个操作数传递，否则返回 false （0）
其他
BINARY		不支持	将字符串转换为二进制字符串
NOT REGEXP		不支持	REGEXP 的否定
REGEXP		不支持	字符串是否与正则表达式匹配
RLIKE		不支持	字符串是否与正则表达式匹配

4.1. 算数运算符

算数运算符列表概览
MySQL函数	LightDB函数	兼容性	说明
算数运算符
乘法 *	乘法 *	支持	乘法运算符
加法 +	加法 +	支持	加法运算符
减法 -	减法 -	支持	减号运算符
符号 -	符号 -	支持	更改参数的符号
/	/	支持	分数运算符
%	%	支持	模运算符
DIV		不支持	整数除法
MOD		不支持	模运算符

类型说明：算术运算符适用于数字。

加法 +

lightdb@mysqltest=# SELECT 3+5;
      ?column?
     ----------
                     8
     (1 row)

减法 -

lightdb@mysqltest=# SELECT 3-5;
 ?column?
----------
           -2
(1 row)

乘法 *

lightdb@mysqltest=# SELECT 3*5;
 ?column?
----------
           15
(1 row)

分数 /

lightdb@mysqltest=# SELECT 3/5;
                ?column?
------------------------
 0.60000000000000000000
(1 row)

求余 %

lightdb@mysqltest=# SELECT 5 % 3;
 ?column?
----------
                2
(1 row)

4.2. 比较运算符

比较运算符列表概览
MySQL函数	LightDB函数	兼容性	说明
比较运算符
>	>	支持	大于运算符
>=	>=	支持	大于或等于运算符
<	<	支持	小于操作符
<>，！=	<>，！=	支持	不相等的运算符
<=	<=	支持	小于或等于运算符
=	=	支持	相等运算符
BETWEEN … AND …	BETWEEN … AND …	支持	值是否在值范围内
IN()	IN()	支持	值是否在一组值中
IS	IS	支持	根据布尔值测试值
IS NOT	IS NOT	支持	根据布尔值测试值
IS NOT NULL	IS NOT NULL	支持	NOT NULL 值测试
IS NULL	IS NULL	支持	NULL 值测试
LIKE	LIKE	支持	简单的模式匹配
NOT BETWEEN … AND …	NOT BETWEEN … AND …	支持	值是否不在值范围内
NOT IN()	NOT IN()	支持	值是否不在一组值中
NOT LIKE	NOT LIKE	支持	否定简单的模式匹配
SOUNDS LIKE		不支持	比较sounds
<=>		不支持	安全等于运算符。严格比较两个NULL值是否相等

4.3. 逻辑运算符

逻辑运算符列表概览
MySQL函数	LightDB函数	兼容性	说明	备注
逻辑运算符
AND	AND	支持	逻辑 AND
NOT	NOT	支持	否定值
OR	OR	支持	逻辑 OR
\|\|	\|\|	支持	逻辑 \|\|	非标准运算符。8.0.17废弃
XOR		不支持	逻辑异或
&&		不支持	逻辑&&
!		不支持	否定值

类型说明：逻辑运算符，AND OR NOT,举例如下。

boolean AND boolean → boolean
boolean OR boolean → boolean
NOT boolean → boolean

SQL使用三值的逻辑系统，包括真、假和null，null表示“未知”。观察下面的真值表：

a	b	a AND b	a OR b
TRUE	TRUE	TRUE	TRUE
TRUE	FALSE	FALSE	TRUE
TRUE	NULL	NULL	TRUE
FALSE	FALSE	FALSE	FALSE
FALSE	NULL	FALSE	NULL
NULL	NULL	NULL	NULL

a	NOT a
TRUE	FALSE
FALSE	TRUE
NULL	NULL

4.4. 赋值运算符

赋值运算符列表概览
MySQL函数	LightDB函数	兼容性	说明
赋值运算符
:=	:=	支持	赋值
=	=	支持	赋值（作为 SET 语句的一部分，或作为 UPDATE 语句中子句的一部分）SET

4.5. 位运算符

位运算符列表概览
MySQL函数	LightDB函数	兼容性	说明
位运算符
&	&	支持	按位 AND
>>	>>	支持	右移
<<	<<	支持	左移
^	^	支持	按位异或
位\|	位\|	支持	按位 OR
~	~	支持	按位反转

4.6. JSON运算符

JSON运算符列表概览
MySQL函数	LightDB函数	兼容性	说明
JSON运算符
->	->	支持	评估路径后从JSON列返回值;等同于 JSON_EXTRACT（）。
->>	->>	支持	评估路径并取消引用后从 JSON 列返回值结果;等价于 JSON_UNQUOTE（JSON_EXTRACT（））。
MEMBER OF()		不支持	如果第一个操作数与 JSON 的任何元素匹配，则返回 true （1）数组作为第二个操作数传递，否则返回 false （0）

5. 函数类型

5.1. 流控函数

流控函数列表概览
MySQL函数	LightDB函数	兼容性	说明
流控制函数
CASE	简单CASE表达式	支持	Case operator
	搜索CASE 表达式	支持
IF()	IF(expr1,expr2,expr3)	支持	If/else construct
IFNULL()	IFNULL（expr1,expr2）	支持	Null if/else construct
NULLIF()	NULLIF(expression_1, expression_2)	支持	Return NULL if expr1 = expr2

5.1.1. CASE

函数作用：CASE 表达式的作用就是为 SQL 语句增加类似于 IF-THEN-ELSE 的逻辑处理功能，可以根据不同的条件返回不同的结果。

语法：

简单CASE表达式: CASE value WHEN compare_value THEN result [WHEN compare_value THEN result ...] [ELSE result] END

搜索CASE 表达式：CASE WHEN condition THEN result [WHEN condition THEN result ...] [ELSE result] END

一般规则：

简单CASE表达式：首先计算表达式（value）的值，然后依次与 WHEN 列表中的值(compare_value1，compare_value2, …)值进行比较，找到第一个匹配的值，然后返回对应 THEN 列表中的结果（result1，result2，…）；如果没有找到匹配的值，返回 ELSE 中的默认值；如果没有指定 ELSE，返回 NULL。
搜索CASE表达式：按照顺序依次计算 WHEN 子句中的条件（condition1, condition2, …），找到第一个结果为真的分支，返回相应的结果；如果没有任何条件为真，返回 ELSE 中的默认值；如果此时没有指定 ELSE，返回空值。

示例：

#简单CASE表达式
lightdb@mysqltest=# SELECT CASE 1 WHEN 1 THEN 'one' WHEN 2 THEN 'two' ELSE 'more' END;
case
------
one
(1 row)

#搜索CASE表达式
lightdb@mysqltest=# SELECT CASE WHEN 1>0 THEN 'true' ELSE 'false' END;
case
------
true
(1 row)

5.1.2. IF()

函数作用：条件判断函数，根据不同的条件返回相应的结果。

语法：

IF(expr1,expr2,expr3)

一般规则：

如果expr1的值为true，则返回expr2的值，如果expr1的值为false，则返回expr3的值
如果 expr2 或 expr3 生成字符串，则 result 是一个字符串。
如果 expr2 和 expr3 都是字符串，则 result 区分大小写，如果任一字符串是区分大小写。
如果 expr2 或 expr3 生成浮点数值，则结果为浮点值。
如果 expr2 或 expr3 生成一个整数，则 result 是一个整数。

示例：

lightdb@mysqltest=# SELECT IF(1>2,2,3);
if
----
3
(1 row)

lightdb@mysqltest=# SELECT IF(1<2,'yEs','No');
if
-----
yEs
(1 row)

5.1.3. IFNULL()

函数作用：空值条件判断函数，根据不同的条件返回相应的结果。

语法：

IFNULL（expr1,expr2）

一般规则：

假如expr1不为 NULL，则 IFNULL() 的返回值为 expr1; 否则其返回值为 expr2

示例：

lightdb@mysqltest=# SELECT IFNULL(1,0);
ifnull
--------
        1
(1 row)

lightdb@mysqltest=# SELECT IFNULL(NULL,10);
ifnull
--------
        10
(1 row)

5.1.4. NULLIF()

函数作用：条件判断函数，根据不同的条件返回相应的结果。

语法：

NULLIF(expression_1, expression_2)

一般规则：

NULLIF 函数包含 2 个参数，如果第一个参数等于第二个参数，返回 NULL；否则，返回第一个参数的值。

示例：

lightdb@mysqltest=# SELECT NULLIF(1,1);
nullif
--------

(1 row)

lightdb@mysqltest=# SELECT NULLIF(1,2);
nullif
--------
        1
(1 row)

5.2. 数值函数

数值函数列表概览
MySQL函数	LightDB函数	兼容性	说明
数值函数
ABS()	abs(x)	支持	返回绝对值
ACOS()	acos(x)	支持	返回反余弦
ASIN()	asin(x)	支持	返回反正弦波
ATAN()	atan(x)	支持	返回圆弧正切
ATAN2（）， ATAN（）	atan2（x，y）， atan(x)	ATAN2（X，Y）支持； ATAN（X,Y）不支持	返回两个参数的弧切线
CEIL()	ceil(x)	支持	返回不小于参数的最小整数值
CEILING()	ceiling(x)	支持	返回不小于参数的最小整数值
CONV()	conv(n,from_base,to_base)	支持	在不同数字基数之间转换数字
COS()	cos(x)	支持	返回余弦
COT()	cot(x)	支持	返回余切
CRC32()		不支持	计算循环冗余校验值
DEGREES()	degrees(x)	支持	将弧度转换为度数
DIV		不支持	整数除法
EXP()	exp(x)	支持	返回 e 的值（以自然对数） X 的幂
FLOOR()	floor(x)	支持	返回不大于参数的最大整数值
LN()	ln(x)	支持	返回参数的自然对数
LOG()	log(x)	支持	返回第一个参数的自然对数
LOG10()	log10(x)	支持	返回参数的以 10 为底的对数
LOG2()	log2(x)	支持	返回参数的以 2 为底的对数
MOD()	mod(n,m)	支持	返回余数
PI()	pi()	支持	返回 pi 的值
POW()	pow(x，y)	支持	返回指定参数的幂
POWER()	power(x，y)	支持	返回指定参数的幂
RADIANS()	radians(x)	支持	返回参数转换为弧度
RAND()	rand(x)	支持	返回随机浮点值
ROUND()	round(x)、round(x，d)	支持	返回四舍五入的值
SIGN()	sign(x)	支持	返回参数的符号
SIN()	sin(x)	支持	返回参数的正弦值
SQRT()	sqrt(x)	支持	返回参数的平方根
TAN()	tan(x)	支持	返回参数的正切值
TRUNCATE()	truncate(x)	支持	截断到指定的小数位数

5.2.1. ABS()

函数作用：ABS(X) 返回X的绝对值。

语法：

ABS(bigint) RETURN bigint
ABS(double precision) RETURN double precision
ABS(integer) RETURN integer
ABS(numeric) RETURN numeric
ABS(real) RETURN real
ABS(smallint) RETURN smallint

示例：

lightdb@mysqltest=#  SELECT ABS(-32);
abs
-----
32
(1 row)

5.2.2. ACOS()

函数作用：ACOS(X) 返回X的反余弦。

语法：

ACOS(double precision) RETURN double precision

示例：

lightdb@mysqltest=# SELECT ACOS(1);
acos
------
        0
(1 row)

lightdb@mysqltest=#  SELECT ACOS(1.0001);
ERROR:  input is out of range

lightdb@mysqltest=#  SELECT ACOS(0);
acos
--------------------
1.5707963267948966
(1 row)

5.2.3. ASIN()

函数作用：ASIN(X) 返回 X 的反正弦值。

语法：

ASIN(double precision) RETURN double precision

示例：

lightdb@mysqltest=# SELECT ASIN(0.2);
                asin
--------------------
0.2013579207903308
(1 row)

5.2.4. ATAN()

函数作用：ATAN(X) 返回 X 的弧正切值。

语法：

ATAN(double precision) RETURN double precision

示例：

lightdb@mysqltest=# SELECT ATAN(2);
                atan
--------------------
 1.1071487177940904
(1 row)

lightdb@mysqltest=# SELECT ATAN(-2);
                atan
---------------------
 -1.1071487177940904
(1 row)

5.2.5. ATAN2()

函数作用：ATAN2(Y,X) 返回两个变量 X 和 Y 的反正切值。

语法：

ATAN2(double precision) RETURN double precision

示例：

lightdb@mysqltest=#  SELECT ATAN2(PI(),0);
           atan2
--------------------
 1.5707963267948966
(1 row)

5.2.6. CEILING()

函数作用：CEILING(X) 返回不小于 X 的最小整数值。CEIL（）是 CEILING（）的同义词。详见CEIL(X) 。

5.2.7. CEIL(X)

函数作用：CEIL(X) 返回不小于 X 的最小整数值。

语法：

CEIL(double precision) RETURN double precision
CEIL(numeric) RETURN numeric

示例：

lightdb@mysqltest=# SELECT CEILING(1.23);
 ceiling
---------
           2
(1 row)

lightdb@mysqltest=# SELECT CEILING(-1.23);
 ceiling
---------
          -1
(1 row)

5.2.8. CONV()

函数作用：不同进制之间转换数字,返回一个数字 N 的字符串表示形式。

语法：

CONV(N,from_base,to_base)   RETURN text

一般规则：

在不同的进制之间转换数字。
将数字N从进制from_base转换为进制to_base并返回字符串表示形式。如果任何参数为NULL，则返回NULL。参数N被解释为整数，但可以指定为整数或字符串。
最小进制为2，最大进制为36。如果from_base是负数，则N被视为带符号数。否则，N被视为无符号数。CONV()使用64位精度。

示例：

lightdb@mysqltest=# select CONV('123456', 10, 16);
 conv
-------
 1E240
(1 row)

5.2.9. COS()

函数作用：COS(X) 返回 X 的余弦值，其中 X 以弧度表示。

语法：

COS(double precision) RETURN double precision

示例：

lightdb@mysqltest=# SELECT COS(PI());
 cos
-----
  -1
(1 row)

5.2.10. COT()

函数作用：COT(X) 返回 X 的余切值。

语法：

COT(double precision) RETURN double precision

示例：

lightdb@mysqltest=# SELECT COT(12);
                 cot
---------------------
 -1.5726734063976893
(1 row)

lightdb@mysqltest=# SELECT COT(0);
   cot
----------
 Infinity
(1 row)

5.2.11. DEGREES()

函数作用：DEGREES(X) 返回X转换后从弧度到度数。

语法：

DEGREES(double precision) RETURN double precision

示例：

lightdb@mysqltest=# SELECT DEGREES(PI());
 degrees
---------
         180
(1 row)

lightdb@mysqltest=#  SELECT DEGREES(PI() / 2);
 degrees
---------
          90
(1 row)

5.2.12. EXP()

函数作用：EXP(X) 返回 e 的值（以自然对数）X 的幂。

语法：

EXP(double precision) RETURN double precision
EXP(numeric) RETURN numeric

示例：

lightdb@mysqltest=# SELECT EXP(2);
           exp
------------------
 7.38905609893065
(1 row)

lightdb@mysqltest=# SELECT EXP(-2);
                exp
--------------------
 0.1353352832366127
(1 row)

lightdb@mysqltest=# SELECT EXP(0);
 exp
-----
   1
(1 row)

5.2.13. FLOOR()

函数作用：FLOOR(X) 返回不大于 X 的最大整数值。

语法：

FLOOR(double precision) RETURN double precision
FLOOR(numeric) RETURN numeric

示例：

lightdb@mysqltest=# SELECT FLOOR(1.23), FLOOR(-1.23);
 floor | floor
-------+-------
         1 |    -2
(1 row)

5.2.14. LN()

函数作用：LN(X) 返回 X 的自然对数。

语法：

LN(double precision) RETURN double precision
LN(numeric) RETURN numeric

示例：

lightdb@mysqltest=# SELECT LN(2);
                 ln
--------------------
 0.6931471805599453
(1 row)

lightdb@mysqltest=# SELECT LN(-2);
ERROR:  cannot take logarithm of a negative number

5.2.15. LOG()

函数作用：LOG(X) 是LN(X)的同义词。详见LN(X).

5.2.16. LOG2(X)

函数作用：LOG2(X) 返回的以 2 为底的对数。

语法：

LOG2(numeric) RETURN numeric

示例：

lightdb@mysqltest=# SELECT LOG2(65536);
                log2
--------------------
 16.000000000000000
(1 row)

lightdb@mysqltest=# SELECT LOG2(-100);
 log2
------

(1 row)

5.2.17. LOG10

函数作用：LOG10(X) 返回 X 的以 10 为底的对数。

语法：

LOG10(double precision) RETURN double precision
LOG10(numeric) RETURN numeric

示例：

lightdb@mysqltest=# SELECT LOG10(2);
           log10
--------------------
 0.3010299956639812
(1 row)

lightdb@mysqltest=# SELECT LOG10(100);
 log10
-------
         2
(1 row)

lightdb@mysqltest=# SELECT LOG10(-100);
 log10
-------

(1 row)

5.2.18. MOD()

函数作用：MOD（N，M）模运算。返回 N 除以 M 的余数。

语法：

MOD(bigint,bigint) RETURN bigint
MOD(integer,integer) RETURN integer
MOD(numeric,numeric) RETURN numeric
MOD(smallint,smallint) RETURN smallint

示例：

lightdb@mysqltest=# SELECT MOD(234, 10);
 mod
-----
   4
(1 row)

5.2.19. PI()

函数作用：PI() 返回 π （pi）的双精度值。

语法：

PI() RETURN double precision

示例：

lightdb@mysqltest=# SELECT PI();
                pi
-------------------
 3.141592653589793
(1 row)

5.2.20. POW()

函数作用：POW(X,Y) 返回 X 的值Y次幂。

语法：

LOG10(double precision) RETURN double precision
LOG10(numeric) RETURN numeric

示例：

lightdb@mysqltest=# SELECT POW(2,2);
 pow
-----
   4
(1 row)

lightdb@mysqltest=# SELECT POW(2,-2);
 pow
------
 0.25
(1 row)

5.2.21. POWER()

函数作用：POWER(X,Y) 这是 POW（X,Y）的同义词。详见POW(X,Y)。

5.2.22. RADIANS()

函数作用：RADIANS(X) 返回X从度数到弧度的值。

语法：

RADIANS(double precision) RETURN double precision

示例：

lightdb@mysqltest=# SELECT RADIANS(90);
          radians
--------------------
 1.5707963267948966
(1 row)

5.2.23. RAND()

函数作用：RAND([N]) 返回范围在0和1.0之间的随机浮点值v。

语法：

RAND(double precision) RETURN double precision

一般规则：

使用常量初始化参数时，种子在语句准备好之后，在执行之前仅初始化一次。
使用非常量初始化参数（例如列名）时，种子将在每次调用RAND()时使用值进行初始化。
这种行为的一个影响是，对于相同的参数值，RAND(N)每次返回相同的值，从而产生一系列可重复的列值。
在WHERE子句中使用RAND()会对每一行（从单个表中选择时）或每一行组合（从多张表连接时）进行求值。

示例：

lightdb@mysqltest=# select RAND(123);
                rand
---------------------
 0.05425240159967615
(1 row)

5.2.24. ROUND()

函数作用：ROUND(X), 返回X四舍五入后的值；ROUND(X,D) 返回将参数 X 四舍五入到小数点后 D 位.

语法：

ROUND(double precision) RETURN double precision
ROUND(numeric) RETURN numeric
ROUND(numeric,integer) RETURN numeric

一般规则：

如果未指定，则 D 默认为 0。
D 可以是负数，导致 D 数字值 X 的小数点左边变为零。

示例：

lightdb@mysqltest=# SELECT ROUND(-1.58);
 round
-------
        -2
(1 row)

lightdb@mysqltest=# SELECT ROUND(1.298, 1);
 round
-------
   1.3
(1 row)

lightdb@mysqltest=# SELECT ROUND(23.298, -1);
 round
-------
        20
(1 row)

5.2.25. SIGN()

函数作用：SIGN(X), 返回参数的符号，具体取决于 X 是负数、零还是正数。

语法：

SIGN(double precision) RETURN double precision
SIGN(numeric) RETURN numeric

示例：

lightdb@mysqltest=# SELECT SIGN(-32);
 sign
------
   -1
(1 row)

lightdb@mysqltest=# SELECT SIGN(0);
 sign
------
        0
(1 row)

lightdb@mysqltest=# SELECT SIGN(234);
 sign
------
        1
(1 row)

5.2.26. SIN()

函数作用：SIN(X) 返回 X 的正弦值，其中 X 以弧度表示。

语法：

SIN(double precision) RETURN double precision

示例：

lightdb@mysqltest=# SELECT SIN(PI());
                  sin
------------------------
 1.2246467991473532e-16
(1 row)

lightdb@mysqltest=# SELECT ROUND(SIN(PI()));
 round
-------
         0
(1 row)

5.2.27. SQRT()

函数作用：SQRT(X) 返回非负数 X 的平方根。

语法：

SQRT(double precision) RETURN double precision
SQRT(numeric) RETURN numeric

示例：

lightdb@mysqltest=# SELECT SQRT(4);
 sqrt
------
        2
(1 row)

lightdb@mysqltest=# SELECT SQRT(20);
           sqrt
------------------
 4.47213595499958
(1 row)

5.2.28. TAN()

函数作用：TAN(X) 返回 X 的正切值，其中 X 以弧度表示。

语法：

TAN(double precision) RETURN double precision

示例：

lightdb@mysqltest=# SELECT TAN(PI());
                   tan
-------------------------
 -1.2246467991473532e-16
(1 row)

lightdb@mysqltest=# SELECT TAN(PI()+1);
                tan
--------------------
 1.5574077246549018
(1 row)

5.2.29. TRUNCATE()

函数作用：TRUNCATE(X,D) 返回被截断的数字 X 到小数点后 D 位。

语法：

TRUNCATE(SMALLINT X,INTEGER D) returns INTEGER
TRUNCATE(INTEGER X,INTEGER D) returns INTEGER
TRUNCATE(BIGINT X,INTEGER D) returns BIGINT
TRUNCATE(DOUBLE PRECISION X,INTEGER D) returns DOUBLE PRECISION
TRUNCATE(NUMERIC,INTEGER D) returns NUMERIC

一般规则：

返回截取到小数点后D位的数字X。
如果D为0，则结果没有小数点或小数部分。
D可以是负数，使值X的小数点左侧的D位数字变为零。

示例：

lightdb@mysqltest=# SELECT TRUNCATE(-1.999,1);
 truncate
----------
         -1.9
(1 row)

lightdb@mysqltest=# SELECT TRUNCATE(1.223,1);
 truncate
----------
          1.2
(1 row)

lightdb@mysqltest=# SELECT TRUNCATE(122,-2);
 truncate
----------
          100
(1 row)

5.3. 日期时间函数

日期时间函数列表概览
MySQL函数	LightDB函数	兼容性	说明
日期时间函数
ADDDATE()		不支持	将时间值（间隔）添加到日期值
ADDTIME()		不支持	添加时间
CONVERT_TZ()		不支持	从一个时区转换到另一个时区
CURDATE()		不支持	返回当前日期
CURRENT_DATE（）	CURRENT_DATE()	支持	CURDATE（）的同义词
CURRENT_DATE	CURRENT_DATE	支持
CURRENT_TIME（）	CURRENT_TIME(fsp)	支持	CURTIME（）的同义词
CURRENT_TIME	CURRENT_TIME	支持
CURRENT_TIMESTAMP（）	CURRENT_TIMESTAMP(fsp)	支持	NOW（）的同义词
CURRENT_TIMESTAMP	CURRENT_TIMESTAMP	支持
CURTIME()		不支持	返回当前时间
DATE()	DATE(expr1 timestamp) RETURN date	支持	提取日期或日期时间表达式的日期部分
	DATE(expr1 timestamptz) RETURN date	支持
DATE_ADD()	DATE_ADD(expr1 timestamptz, expr2 interval) RETURN date	支持	将时间值（间隔）添加到日期值
	DATE_ADD(expr1 text, expr2 interval) RETURN date	支持
DATE_FORMAT()	DATE_FORMAT(expr1 timestamp, expr2 text) RETURN text	支持	指定日期格式
	DATE_FORMAT(expr1 timestamptz, expr2 text) RETURN text	支持
	DATE_FORMAT(expr1 text, expr2 text) RETURN text	支持
DATE_SUB()	DATE_SUB(expr1 timestamptz, expr2 interval) RETURN date	支持	从日期中减去时间值（间隔）
	DATE_SUB(expr1 text, expr2 interval) RETURN date 返回 expr1	支持
DATEDIFF()	DATEDIFF(expr1 timestamp,expr2 timestamp)	支持	减去两个日期
	DATEDIFF(expr1 text,expr2 text)	支持
DAY()	DAY(expr1 text) RETURN int2	支持	DAYOFMONTH（）的同义词
	DAY(expr1 timestamptz) RETURN int4	支持
DAYNAME()		不支持	返回工作日的名称
DAYOFMONTH()		不支持	返回月份中的某一天（0-31）
DAYOFWEEK()	DAYOFWEEK(expr1 text) RETURN int4	支持	返回参数的工作日索引
	DAYOFWEEK(expr1 timestamptz) RETURN int4	支持
DAYOFYEAR()		不支持	返回一年中的某一天（1-366）
EXTRACT()		不支持	提取日期的一部分
FROM_DAYS()		不支持	将日期数字转换为日期
FROM_UNIXTIME()	FROM_UNIXTIME(expr1 text) RETURN timesta	支持	将 Unix 时间戳格式化为日期
	FROM_UNIXTIME(expr1 int8) RETURN timestamp	支持
	FROM_UNIXTIME(expr1 text, expr2 text) RETURN text	支持
	FROM_UNIXTIME(expr1 int8, expr2 text) RETURN text	支持
GET_FORMAT()		不支持	返回日期格式字符串
HOUR()		不支持	提取小时
LAST_DAY		不支持	返回参数的月份的最后一天
LOCALTIME（），本地时间		不支持	NOW（）的同义词
LOCALTIMESTAMP和LOCALTIMESTAMP（）		不支持	NOW（）的同义词
MAKEDATE()		不支持	从年份和年份中的某一天创建日期
MAKETIME()		不支持	从小时、分钟、秒创建时间
MICROSECOND()		不支持	从参数返回微秒
MINUTE()		不支持	从参数中返回分钟
MONTH()		不支持	返回从过去的日期开始的月份
MONTHNAME()		不支持	返回月份的名称
NOW()	NOW() RETURN timestamp	支持	返回当前日期和时间
PERIOD_ADD()		不支持	给期间添加特定的月数
PERIOD_DIFF()		不支持	返回期间之间的月数
QUARTER()		不支持	从日期参数返回季度
SEC_TO_TIME()	SEC_TO_TIME(p_secs int)	支持	将秒转换为“hh：mm：ss”格式
SECOND()		不支持	返回第二个（0-59）
STR_TO_DATE()	STR_TO_DATE(datetime_str text, datetime_format text) RETURN datetime	支持	将字符串转换为日期
	STR_TO_DATE(date_str text, date_format text) RETURN date	支持
	STR_TO_DATE(time_str text, time_format text) RETURN time	支持
SUBDATE()		不支持	使用三个参数调用时 DATE_SUB（）的同义词
SUBTIME()		不支持	减去时间
SYSDATE()	SYSDATE() RETURNS timestamp(0)	支持	返回函数的执行时间
TIME()		不支持	提取传递的表达式的时间部分
TIME_FORMAT()		不支持	格式化为时间
TIME_TO_SEC()	TIME_TO_SEC(p_time time) RETURNS int	支持	返回转换为秒的参数
TIMEDIFF()	TIMEDIFF(p_date1 timestamptz, p_date2 timestamptz) RETURNS interval	支持	减去时间
TIMESTAMP()		不支持	使用单个参数时，此函数返回日期或日期时间表达;有两个参数，参数的总和
TIMESTAMPADD()		不支持	向日期时间表达式添加间隔
TIMESTAMPDIFF()	timestampdiff( p_unit text, p_ts1 timestamptz, p_ts2 timestamptz) RETURNS bigint	支持	从日期时间表达式中减去一个时间间隔
TO_DAYS()	to_days(p_date timestamp) RETURNS bigint	支持	返回转换为天的日期参数
	to_days(p_date timestamptz) RETURNS bigint	支持
	to_days( p_date text) RETURNS bigint	支持
	to_days( p_date text, p_format text) RETURNS bigint	支持
	to_days(p_date bigint) RETURNS bigint	支持
TO_SECONDS()	to_seconds(p_date timestamp) RETURNS bigint	支持	返回转换为秒的日期或日期时间参数，因为 0年级
	to_seconds(p_date timestamptz) RETURNS bigint	支持
UNIX_TIMESTAMP()	UNIX_TIMESTAMP() RETURN int8	支持	返回 Unix 时间戳
	UNIX_TIMESTAMP(expr1 timestamptz) RETURN int8	支持
	UNIX_TIMESTAMP(expr1 text) RETURN int8	支持
UTC_DATE()		不支持	返回当前 UTC 日期
UTC_TIME()		不支持	返回当前 UTC 时间
UTC_TIMESTAMP()		不支持	返回当前 UTC 日期和时间
WEEK()		不支持	返回周数
WEEKDAY()		不支持	返回工作日索引
WEEKOFYEAR()	WEEKOFYEAR(expr1 timestamptz) RETURN int4	支持	返回日期的日历周（1-53）
	WEEKOFYEAR(expr1 text) RETURN int4	支持
YEAR()	YEAR(expr1 timestamptz) RETURN int4	支持	返回年份
	YEAR(expr1 text) RETURN int4	支持
YEARWEEK()		不支持	返回年份和星期

5.3.1. CURRENT_DATE[()]

函数作用：获取当前日期。

语法：

CURRENT_DATE RETURN date
CURRENT_DATE() RETURN date

一般规则：

返回一个DATE代表当前日期的值，将当前日期按照“YYYY-MM-DD”格式的值返回。

示例：

lightdb@mysqltest=# SELECT CURRENT_DATE;
 current_date
--------------
 2023-12-05
(1 row)

lightdb@mysqltest=# SELECT CURRENT_DATE();
 current_date
--------------
 2023-12-05
(1 row)

5.3.2. CURRENT_TIME[(fsp)]

函数作用：获取当前时间。

语法：

CURRENT_TIME RETURN time
CURRENT_TIME(fsp) RETURN time

一般规则：

将当前时间以“HH:MM:SS”的格式返回。
fsp 参数指定给指定从 0 到 6 的小数秒精度，返回值包括该数字中的小数秒部分。

示例：

lightdb@mysqltest=# SELECT CURRENT_TIME;
   current_time
-------------------
 11:05:00.44728+08
(1 row)

lightdb@mysqltest=# SELECT CURRENT_TIME(4);
   current_time
------------------
 11:07:13.3102+08
(1 row)

5.3.3. CURRENT_TIMESTAMP[(fsp)]

函数作用：获取当前时间和日期值。

语法：

CURRENT_TIMESTAMP RETURN timestamp
CURRENT_TIMESTAMP(fsp) RETURN timestamp

一般规则：

将当前日期和时间，以“YYYY-MM-DD HH:MM:SS”形式返回。
fsp 参数指定给指定从 0 到 6 的小数秒精度，返回值包括该数字中的小数秒部分。

示例：

lightdb@mysqltest=# SELECT CURRENT_TIMESTAMP;
           current_timestamp
-------------------------------
 2023-12-05 11:10:10.832746+08
(1 row)

lightdb@mysqltest=# SELECT CURRENT_TIMESTAMP(4);
          current_timestamp
-----------------------------
 2023-12-05 11:11:58.8471+08
(1 row)

5.3.4. DATE()

函数作用：提取日期或日期时间表达式的日期部分。

语法：

DATE(expr1 timestamp) RETURN date
DATE(expr1 timestamptz) RETURN date

一般规则：

获取expr1的日期部分。

示例：

lightdb@mysqltest=# SELECT DATE('2023-11-24 01:02:03');
        date
------------
 2023-11-24
(1 row)

5.3.5. DATE_ADD()

函数作用：提将时间值（间隔）添加到日期值。

语法：

DATE_ADD(expr1 timestamptz, expr2 interval) RETURN date
DATE_ADD(expr1 text, expr2 interval) RETURN date

一般规则：

返回添加间隔（年/月/日）到 expr1 日期参数后的日期类型;
第二个参数 expr2 仅支持间隔（年/月/日）。

示例：

lightdb@mysqltest=# select DATE_ADD('20231124', interval 1 day);
  date_add
------------
 2023-11-25
(1 row)

5.3.6. DATE_FORMAT()

函数作用：日期格式显示。

语法：

DATE_FORMAT(expr1 timestamp, expr2 text) RETURN text
DATE_FORMAT(expr1 timestamptz, expr2 text) RETURN text
DATE_FORMAT(expr1 text, expr2 text) RETURN text

一般规则：

返回expr1时间参数，在expr2格式中显示和输出。

示例：

lightdb@mysqltest=# select DATE_FORMAT('20231123 11:59:59','%Y/%m/%d %h,%i,%s');
         date_format
---------------------
 2023/11/23 11,59,59
(1 row)

5.3.7. DATE_SUB()

函数作用：日期减法。

语法：

DATE_SUB(expr1 timestamptz, expr2 interval) RETURN date
DATE_SUB(expr1 text, expr2 interval) RETURN date 返回 expr1

一般规则：日期参数减去间隔（年/月/日）后的日期类型第二个参数 expr2 只支持间隔（年/月/日）

返回 expr1 日期参数减去间隔（年/月/日）后的日期类型；
返回 expr1 日期参数减去间隔（年/月/日）后的日期类型。

示例：

lightdb@mysqltest=# select DATE_SUB('20231124', interval 1 day);
  date_sub
------------
 2023-11-23
(1 row)

5.3.8. DATEDIFF()

函数作用：减去两个日期。

语法：

DATEDIFF(expr1 timestamp,expr2 timestamp)
DATEDIFF(expr1 text,expr2 text)

一般规则：

expr1 − expr2 表示从一天到另一天的天数。expr1 和 expr2 是日期或日期时间表达式。计算中仅使用这些值的日期部分。
如果任一参数为 NULL，则返回 NULL。

示例：

lightdb@mysqltest=# SELECT DATEDIFF('2007-12-31 23:59:59','2007-12-30');
 datediff
----------
                1
(1 row)

5.3.9. DAY()

函数作用：返回月份日期。

语法：

DAY(expr1 text) RETURN int2
DAY(expr1 timestamptz) RETURN int4

一般规则：

返回给定 expr1 日期的月份部分
仅支持月和日参数，例如“0101”、“0704”。

示例：

lightdb@mysqltest=# select DAY('2023/12/01');
 day
-----
   1
(1 row)

5.3.10. DAYOFWEEK()

函数作用：返回星期几。

语法：

DAYOFWEEK(expr1 text) RETURN int4
DAYOFWEEK(expr1 timestamptz) RETURN int4

一般规则：

根据 expr1 日期参数返回星期几。返回值为 1 ~ 7，星期日为 1。
至少包括完整的时间格式，例如 20200202、200202。不支持少于 6 位的参数。

示例：

lightdb@mysqltest=# SELECT DAYOFWEEK(20231001);
 dayofweek
-----------
                 1
(1 row)

5.3.11. FROM_UNIXTIME()

函数作用：根据 UNIX 时间戳返回时间格式。

语法：

FROM_UNIXTIME(expr1 text) RETURN timestamp
FROM_UNIXTIME(expr1 int8) RETURN timestamp
FROM_UNIXTIME(expr1 text, expr2 text) RETURN text
FROM_UNIXTIME(expr1 int8, expr2 text) RETURN text

一般规则：

根据 expr1 参数的 UNIX 时间戳返回时间格式。日期格式可以根据 expr2 参数进行指定。

示例：

lightdb@mysqltest=# SELECT FROM_UNIXTIME(20231124);
        from_unixtime
---------------------
 1970-08-23 11:45:24
(1 row)

lightdb@mysqltest=# SELECT FROM_UNIXTIME(20231124,'%Y/%m/%d %h,%i,%s');
        from_unixtime
---------------------
 1970/08/23 11,45,24
(1 row)

5.3.12. DAYOFWEEK()

函数作用：返回星期几。

语法：

DAYOFWEEK(expr1 text) RETURN int4
DAYOFWEEK(expr1 timestamptz) RETURN int4

一般规则：

根据 expr1 日期参数返回星期几。返回值为 1 ~ 7，星期日为 1。
至少包括完整的时间格式，例如 20200202、200202。不支持少于 6 位的参数。

示例：

lightdb@mysqltest=# SELECT DAYOFWEEK(20231001);
 dayofweek
-----------
                 1
(1 row)

5.3.13. NOW()

函数作用：返回当前的时间时间戳。

语法：

NOW() RETURN timestamp

一般规则：

以‘YYYY-MM-DD hh:mm:ss’进行展示。

示例：

lightdb@mysqltest=# SELECT NOW();
                          now
-------------------------------
 2023-11-24 17:09:05.204102+08
(1 row)

5.3.14. SEC_TO_TIME()

函数作用：将秒转换为“hh:mm:ss”格式。

语法：

SEC_TO_TIME(p_secs int) RETURNS interval

一般规则：

返回将秒参数转换为小时、分钟和秒的时间值。
结果的范围受到 TIME 数据类型的限制。如果参数对应于超出该范围的值，则会发出警告。

示例：

lightdb@mysqltest=# SELECT SEC_TO_TIME(80590);
 sec_to_time
-------------
 22:23:10
(1 row)

5.3.15. STR_TO_DATE()

函数作用：将字符串转换为时间值。它接受一个字符串 str 和一个格式字符串 format。如果格式字符串包含日期和时间部分，STR_TO_DATE() 返回一个 DATETIME 值。如果字符串仅包含日期或时间部分，则返回 DATE 或 TIME 值。如果从 str 中提取的日期、时间或日期时间值是非法的，STR_TO_DATE() 将返回错误。

语法：

STR_TO_DATE(datetime_str text, datetime_format text) RETURN datetime
STR_TO_DATE(date_str text, date_format text) RETURN date
STR_TO_DATE(time_str text, time_format text) RETURN time

一般规则：

将字符串参数 str 和格式参数 format 转换为时间值。
如果启用了 NO_ZERO_DATE SQL 模式，则不允许使用零日期。在这种情况下，STR_TO_DATE() 返回 NULL。

示例：

lightdb@mysqltest=# select STR_TO_DATE('2022/09/10 11,13,13', '%Y/%m/%d %h,%i,%s');
         str_to_date
---------------------
 2022-09-10 11:13:13
(1 row)

#如果启用了 NO_ZERO_DATE SQL 模式，则不允许使用零日期。在这种情况下，STR_TO_DATE() 返回 NULL。
lightdb@mysqltest=# set lightdb_sql_mode = 'no_zero_date';
SET
lightdb@mysqltest=# select STR_TO_DATE('2022/09/0', '%Y/%m/%d');
 str_to_date
-------------

(1 row)

5.3.16. STR_TO_DATE()

函数作用：将字符串转换为时间值。它接受一个字符串 str 和一个格式字符串 format。如果格式字符串包含日期和时间部分，STR_TO_DATE() 返回一个 DATETIME 值。如果字符串仅包含日期或时间部分，则返回 DATE 或 TIME 值。如果从 str 中提取的日期、时间或日期时间值是非法的，STR_TO_DATE() 将返回错误。

语法：

STR_TO_DATE(datetime_str text, datetime_format text) RETURN datetime
STR_TO_DATE(date_str text, date_format text) RETURN date
STR_TO_DATE(time_str text, time_format text) RETURN time

一般规则：

将字符串参数 str 和格式参数 format 转换为时间值。
如果启用了 NO_ZERO_DATE SQL 模式，则不允许使用零日期。在这种情况下，STR_TO_DATE() 返回 NULL。

示例：

lightdb@mysqltest=# select STR_TO_DATE('2022/09/10 11,13,13', '%Y/%m/%d %h,%i,%s');
         str_to_date
---------------------
 2022-09-10 11:13:13
(1 row)

#如果启用了 NO_ZERO_DATE SQL 模式，则不允许使用零日期。在这种情况下，STR_TO_DATE() 返回 NULL。
lightdb@mysqltest=# set lightdb_sql_mode = 'no_zero_date';
SET
lightdb@mysqltest=# select STR_TO_DATE('2022/09/0', '%Y/%m/%d');
 str_to_date
-------------

(1 row)

5.3.17. SYSDATE()

函数作用：返回函数执行时的时间。

语法：

SYSDATE() RETURNS timestamp(0)

一般规则：

返回的时间是函数执行时的时间，是不确定的。
返回的时间受当前时区设置影响。
自版本23.2开始支持此函数。

示例：

lightdb@mysqltest=# SELECT SYSDATE();
           sysdate
---------------------
 2023-11-24 17:26:22
(1 row)

5.3.18. TIME_TO_SEC()

函数作用：将参数转换为秒并返回。

语法：

TIME_TO_SEC(p_time time) RETURNS int

一般规则：

返回转换为秒的时间参数。

示例：

lightdb@mysqltest=# SELECT TIME_TO_SEC('23:59:59');
 time_to_sec
-------------
           86399
(1 row)

5.3.19. TIMEDIFF()

函数作用：计算时间差。

语法：

TIMEDIFF(p_date1 timestamptz, p_date2 timestamptz) RETURNS interval

一般规则：

TIMEDIFF() 将两个时间表达式相减并返回一个时间值。expr1 和 expr2 都必须是时间或日期时间表达式，并且类型必须相同。
TIMEDIFF() 返回的结果范围限制在 TIME 值允许的范围内。或者，您可以使用 TIMESTAMPDIFF() 和 UNIX_TIMESTAMP() 这两个函数，两者都返回整数值。

示例：

lightdb@mysqltest=# SELECT TIMEDIFF('2023-11-24 00:00:00', '2023-11-24 00:00:00.000001');
         timediff
------------------
 -00:00:00.000001
(1 row)

5.3.20. TIMESTAMPDIFF()

函数作用：从日期时间表达式中减去一个时间间隔。。

语法：

timestampdiff( p_unit text, p_ts1  timestamptz, p_ts2  timestamptz) RETURNS bigint

一般规则：

返回 datetime_expr2 − datetime_expr1 的值，其中 datetime_expr1 和 datetime_expr2 是日期或日期时间表达式。
其中一个表达式可以是日期，另一个可以是日期时间。必要时，日期值将被视为时间部分为’00:00:00’的日期时间。
结果的单位（整数）由单位参数给出。单位的合法值与 TIMESTAMPADD() 函数的描述中所列相同。

示例：

lightdb@mysqltest=# select TIMESTAMPDIFF('MICROSECOND', '1911-11-11 11:23:45.123456'::timestamp, '2021-12-12 12:12:12.654321'::timestamp);
  timestampdiff
------------------
 3474060507530865
(1 row)

5.3.21. TO_DAYS()

函数作用：返回将日期参数转换为天数的结果。

语法：

to_days(p_date timestamp) RETURNS bigint
to_days(p_date timestamptz) RETURNS bigint
to_days( p_date text) RETURNS bigint
to_days( p_date text, p_format text) RETURNS bigint
to_days(p_date bigint) RETURNS bigint

一般规则：

给定一个日期 date，返回一个日期编号（自公元 0 年以来的天数）。
TO_DAYS() 不适用于格里高利历实行之前的日期（1582年），因为它没有考虑到更改日历时丢失的天数。对于 1582 年之前（以及其他地区可能的更晚年份）的日期，此函数的结果不可靠。

示例：

lightdb@mysqltest=# select TO_DAYS('2011-11-11');
 to_days
---------
  734817
(1 row)

5.3.22. TO_SECONDS()

函数作用：返回将日期或日期时间参数转换为自公元 0 年以来的秒数。

语法：

to_seconds(p_date timestamp) RETURNS bigint
to_seconds(p_date timestamptz) RETURNS bigint

一般规则：

给定日期或日期时间表达式 expr，返回自公元 0 年以来的秒数。如果 expr 不是有效的日期或日期时间值，则返回 NULL。
与 TO_DAYS() 一样，TO_SECONDS() 不适用于格里高利历实行之前的日期（1582年），因为它没有考虑到更改日历时丢失的天数。对于 1582 年之前（以及其他地区可能的更晚年份）的日期，此函数的结果不可靠。

示例：

lightdb@mysqltest=# select TO_SECONDS('2023-11-29'::timestamp);
 to_seconds
-------------
 63868435200
(1 row)

5.3.23. UNIX_TIMESTAMP()

函数作用：返回根据时间格式的 UNIX 时间戳。

语法：

UNIX_TIMESTAMP() RETURN int8
UNIX_TIMESTAMP(expr1 timestamptz) RETURN int8
UNIX_TIMESTAMP(expr1 text) RETURN int8

一般规则：

根据 expr1 参数的时间格式返回 UNIX 时间戳。如果没有参数，则返回当前 UNIX 时间戳。
expr1 参数至少包含完整的日志格式，例如 20200101。

示例：

lightdb@mysqltest=# select UNIX_TIMESTAMP(20200101);
 unix_timestamp
----------------
         1577808000
(1 row)

lightdb@mysqltest=# select UNIX_TIMESTAMP();
 unix_timestamp
----------------
         1700820474
(1 row)

5.3.24. WEEKOFYEAR()

函数作用：根据时间返回当年的周数。

语法：

WEEKOFYEAR(expr1 timestamptz) RETURN int4
WEEKOFYEAR(expr1 text) RETURN int4

一般规则：

根据时间表达式参数expr1，返回当年的周数。
至少包括完整的时间格式，例如20200202、200202。不支持少于6位的参数。

示例：

lightdb@mysqltest=# select WEEKOFYEAR('20230910');
 weekofyear
------------
                 36
(1 row)

5.3.25. YEAR()

函数作用：返回日期的年份。

语法：

YEAR(expr1 timestamptz) RETURN int4
YEAR(expr1 text) RETURN int4

一般规则：

返回根据expr1参数日期计算出的年份。
支持完整的年、月、日时间参数，例如“20200101”和“200101”。不支持仅包括月和日参数，例如“0101”和“0704”。

示例：

lightdb@mysqltest=# select WEEKOFYEAR('20230910');
 weekofyear
------------
                 36
(1 row)

5.4. 字符串函数

字符串函数列表概览
MySQL函数	LightDB函数	兼容性	说明
字符串函数
ASCII()	ASCII(str text) RETURN INTEGER	支持	返回字符串最左侧字符的ASCII代码值
BIN()		不支持	返回一个字符串，其中包含数字的二进制表示形式
BIT_LENGTH()	BIT_LENGTH(b bit) RETURN INTEGER	支持	参数的返回长度（以位为单位）
	BIT_LENGTH(b bytea) RETURN INTEGER	支持
	BIT_LENGTH(str text) RETURN INTEGER	支持
CHAR()		不支持	返回传递的每个整数的字符
CHAR_LENGTH()	CHAR_LENGTH(c character) RETURN integer	支持	返回参数中的字符数
	CHAR_LENGTH(str text) RETURN integer
CHARACTER_LENGTH()		支持	CHAR_LENGTH（）的同义词
CONCAT()	CONCAT(str1, str2,…) RETURN text	支持	返回串联字符串
CONCAT_WS()	CONCAT_WS(separator, string1, string2, …, stringN) RETURN text	支持	返回与分隔符连接
ELT()	ELT(str_pos int, VARIADIC strlist text[]) RETURNS text	支持	返回索引号处的字符串
EXPORT_SET()		不支持	返回一个字符串，以便对于值位中设置的每个位，您获取一个 ON 字符串，对于每个未设置的位，您都会得到一个 OFF 字符串
FIELD()	field(str text, VARIADIC strlist text[]) RETURNS bigint	支持	第一个参数在后续参数中的索引（位置）
	field(str numeric, VARIADIC strlist numeric[]) RETURNS bigint	支持
FIND_IN_SET()	FIND_IN_SET(str “any”,strlist TEXT) returns INTEGER	支持	第一个参数在第二个参数中的索引（位置）
FORMAT()	函数存在，但实现的函数不一致	不支持	返回格式化为指定小数位数的数字
FROM_BASE64()	FROM_BASE64(p_str text) RETURNS text	支持	解码 base64 编码的字符串并返回结果
HEX()		不支持	十进制或字符串值的十六进制表示形式
INSERT()	INSERT(p_source text, p_pos bigint, p_len bigint, p_replacement text) RETURNS text	支持	在指定位置插入子字符串，最多插入指定数量的子字符串字符
INSTR()	instr(str text, patt text) RETURNS int	支持	返回子字符串第一次出现的索引
LCASE()	lcase(p_source text) RETURNS text	支持	LOWER（）的同义词
LEFT()	LEFT(p_source text, len integer) RETURNS text	支持	返回指定的最左边的字符数
LENGTH()	LENGTH(str text) RETURN integer	支持	返回字符串的长度（以字节为单位）
LOAD_FILE()		不支持	加载命名文件
LOCATE()	LOCATE(substr TEXT,str TEXT) returns INTEGER	支持	返回子字符串第一次出现的位置
	LOCATE(substr TEXT,str TEXT,POS INTEGER) returns INTEGER
LOWER()	LOWER(str text) returns text	支持	以小写形式返回参数
LPAD()	LPAD(str,len,padstr) RETURN text	支持	返回字符串参数，用指定的字符串左填充
LTRIM()	LTRIM(str text) RETURN text	支持	删除前导空格
MAKE_SET()		不支持	返回一组逗号分隔的字符串，这些字符串具有位中的相应位集
MATCH()		不支持	执行全文搜索
MID()	MID(p_source text, p_pos bigint, p_len bigint) RETURNS text	支持	返回从指定位置开始的子字符串
NOT LIKE		不支持	否定简单的模式匹配
NOT REGEXP		不支持	REGEXP 的否定
OCT()		不支持	返回一个字符串，其中包含数字的八进制表示形式
OCTET_LENGTH()	同义词	支持	LENGTH（）的同义词
ORD()		不支持	返回参数最左边字符的字符代码
POSITION()	同义词	支持	LOCATE（）的同义词
QUOTE()		不支持	转义参数以在 SQL 语句中使用
REGEXP		不支持	字符串是否与正则表达式匹配
REGEXP_INSTR()		不支持	子字符串匹配正则表达式的起始索引
REGEXP_LIKE()		不支持	字符串是否与正则表达式匹配
REGEXP_REPLACE()	REGEXP_REPLACE(expr text, pat text, repl text) RETURNS text	支持	替换与正则表达式匹配的子字符串
REGEXP_SUBSTR()		不支持	返回匹配正则表达式的子字符串
REPEAT()	REPEAT(expr text,count integer) RETURN text	支持	将字符串重复指定的次数
REPLACE()	REPLACE(expr text,from_str text,to_str text) RETURN text	支持	替换指定字符串的匹配项
REVERSE()	REVERSE(expr text) RETURN text	支持	反转字符串中的字符
RIGHT()	RIGHT(expr text,len integer) RETURN text	支持	返回指定的最右边字符数
RLIKE		不支持	字符串是否与正则表达式匹配
RPAD()	RPAD(expr text,len integer,padstr text) RETURN TEXT	支持	将字符串追加指定的次数
RTRIM()	RTRIM(expr text) RETURN text	支持	删除尾随空格
SOUNDEX()		不支持	返回 soundex 字符串
SOUNDS LIKE		不支持	soundex like
SPACE()	SPACE(p_num int) RETURNS text	支持	返回指定空格数的字符串
STRCMP()	STRCMP(p1 text, p2 text) RETURNS int	支持	比较两个字符串
SUBSTR()	SUBSTR(str text, pos int) RETURNS text	支持	按指定返回子字符串
	SUBSTR(str text, pos int, len int) RETURNS text
SUBSTRING()	SUBSTRING(str text, pos int) RETURNS text	支持	按指定返回子字符串
	SUBSTRING(str text, pos int, len int) RETURNS text
SUBSTRING_INDEX()		不支持	从指定数量的分隔符的出现次数
TO_BASE64()	to_base64(p_str text) RETURNS text	支持	返回转换为 base-64 字符串的参数
TRIM()		不支持	删除前导空格和尾随空格
UCASE()	UCASE(p_source text) RETURNS text	支持	UPPER（）的同义词
UNHEX()		不支持	返回一个字符串，其中包含数字的十六进制表示形式
UPPER()	UPPER(p_source text) RETURNS text	支持	转换为大写
WEIGHT_STRING()		不支持	返回字符串的权重字符串

5.4.1. ASCII()

函数作用：返回字符串最左侧字符的ASCII代码值。

语法：

ASCII(str text) RETURN INTEGER

一般规则：

函数用于返回字符串最左侧字符的ASCII代码值
如果str是空字符串，则返回0；如果str是NULL，返回NULL。

示例：

lightdb@mysqltest=# SELECT ASCII('2');
 ascii
-------
        50
(1 row)

lightdb@mysqltest=# SELECT ASCII(2);
 ascii
-------
        50
(1 row)

lightdb@mysqltest=# SELECT ASCII('2K');
 ascii
-------
        50
(1 row)

5.4.2. BIT_LENGTH()

函数作用：以bit为单位来返回字符串长度。

语法：

BIT_LENGTH(b bit) RETURN INTEGER
BIT_LENGTH(b bytea) RETURN INTEGER
BIT_LENGTH(str text) RETURN INTEGER

一般规则：

函数用于返回字符串最左侧字符的ASCII代码值
如果str是空字符串，则返回0；如果str是NULL，返回NULL。

示例：

lightdb@mysqltest=# SELECT BIT_LENGTH(B'10');
 bit_length
------------
                  2
(1 row)

lightdb@mysqltest=# SELECT BIT_LENGTH(B'10');
 bit_length
------------
                  2
(1 row)

lightdb@mysqltest=# SELECT  BIT_LENGTH('12345');
 bit_length
------------
                 40
(1 row)

5.4.3. CHAR_LENGTH()

函数作用：返回给定参数的长度。

语法：

CHAR_LENGTH(c character) RETURN integer
CHAR_LENGTH(str text) RETURN integer

一般规则：

CHAR_LENGTH()函数返回给定字符串的长度；
函数返回的字符的个数，而不是字节的个数；
如果str是空字符串，则返回0；如果str是NULL，返回NULL。

示例：

lightdb@mysqltest=# SELECT CHAR_LENGTH('12345');
 char_length
-------------
                   5
(1 row)

lightdb@mysqltest=# SELECT CHAR_LENGTH(NULL);
 char_length
-------------

(1 row)

5.4.4. CHARACTER_LENGTH

函数作用：CHAR_LENGTH（）的同义词。详见CHAR_LENGTH()。

5.4.5. CONCAT()

函数作用：将多个字符串连接成一个字符串。

语法：

CONCAT(str1, str2,...) RETURN text

一般规则：

返回结果为连接参数产生的字符串。

示例：

lightdb@mysqltest=# SELECT CONCAT('123','456');
 concat
--------
 123456
(1 row)

lightdb@mysqltest=# SELECT CONCAT('123','','456');
 concat
--------
 123456
(1 row)

5.4.6. CONCAT_WS()

函数作用：将多个字符串连接成一个字符串。

语法：

CONCAT_WS(separator, VARIADIC strlist text[]) RETURN text

一般规则：

用来通过指定的分隔符按顺序拼接指定的 2 个或多个字符串，并返回拼接后的字符串；
如果只有1个参与拼接的字符串参数，则原样返回此字符串；
如果拼接的参数中一个为NULL , 函数会忽略值。

示例：

lightdb@mysqltest=# SELECT CONCAT('123','456');
 concat
--------
 123456
(1 row)

lightdb@mysqltest=# SELECT CONCAT('123','','456');
 concat
--------
 123456
(1 row)

5.4.7. ELT()

函数作用：返回索引号处的字符串。

语法：

ELT(str_pos int, VARIADIC strlist text[]) RETURNS text

一般规则：

ELT()返回字符串列表中的第str_pos个元素：如果str_pos = 1，则为str1，如果str_pos = 2，则为str2，以此类推。
如果N小于1或大于参数个数，则返回NULL。
ELT() 是 FIELD() 的补充函数。

示例：

lightdb@mysqltest=# select ELT( 2, 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
 elt
-----
 Bb
(1 row)

5.4.8. FIELD()

函数作用：第一个参数在后续参数中的位置（索引）。

语法：

field(str text, VARIADIC strlist text[]) RETURNS bigint
field(str numeric, VARIADIC strlist numeric[]) RETURNS bigint

一般规则：

返回字符串 str 在字符串列表 str1, str2, str3, … 中的索引（位置）。如果 str 未找到，则返回 0。
如果 FIELD() 的所有参数都是字符串，则将它们作为字符串进行比较。如果所有参数都是数字，则将它们作为数字进行比较。否则，将参数作为双精度数进行比较。
如果 str 是 NULL，则返回值为 0，因为 NULL 与任何值都不相等。FIELD() 是 ELT() 的补充函数

示例：

lightdb@mysqltest=# select field('Bb', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
 field
-------
         2
(1 row)

5.4.9. FIND_IN_SET()

函数作用：第一个参数在第二个参数中的位置（索引）。

语法：

FIND_IN_SET(str "any",strlist TEXT) returns INTEGER

一般规则：

如果字符串 str 在由 N 个子字符串组成的字符串列表 strlist 中，则返回 1 到 N 的值。 strlist 是由逗号字符分隔的子字符串组成的字符串。
如果 str 不在 strlist 中或 strlist 是空字符串，则返回 0。
如果任一参数为 NULL，则返回 NULL。如果第一个参数包含逗号 (,) 字符，则此函数不正常工作。
如果第一个参数不是字符串类型，则第一个参数将被转换为字符串类型。换句话说，find_in_set(n,strlist) 等效于 find_in_set(n::text,strlist)
返回值的数据类型为整数。

示例：

lightdb@mysqltest=# SELECT FIND_IN_SET('b','a,b,c,d');
 find_in_set
-------------
                   2
(1 row)

5.4.10. FROM_BASE64()

函数作用：解码 base64 编码的字符串并返回结果。

语法：

FROM_BASE64(p_str text) RETURNS text

一般规则：

接受一个使用 TO_BASE64() 使用的 base-64 编码规则编码的字符串，并将解码后的结果作为二进制字符串返回。
如果参数为 NULL 或不是有效的 base-64 字符串，则结果为 NULL。
有关编码和解码规则的详细信息，请参见 TO_BASE64() 的描述。

示例：

lightdb@mysqltest=# select from_base64('YWJj');
 from_base64
-------------
 abc
(1 row)

5.4.11. INSERT()

函数作用：在指定位置插入子字符串，直到指定的字符数。

语法：

INSERT(p_source text, p_pos bigint, p_len bigint, p_replacement text) RETURNS text

一般规则：

返回字符串str，将从位置pos开始并长度为len的子字符串替换为newstr。
如果pos不在字符串的长度范围内，则返回原始字符串。如果len不在其余字符串的长度范围内，则从位置pos替换其余字符串。
如果任何参数为NULL，则返回NULL。

示例：

lightdb@mysqltest=# select INSERT('Quadratic', 3, 4, 'What');
  insert
-----------
 QuWhattic
(1 row)

5.4.12. INSTR()

函数作用：获取子字符串的第一次出现的位置。

语法：

INSTR(str text, patt text) RETURNS int

一般规则：

从1开始，在字符串str中获取子字符串patt的第一次出现的位置。
如果未找到，则返回0。

示例：

lightdb@mysqltest=# select INSTR('abc124deff4de', '4de');
 instr
-------
         6
(1 row)

5.4.13. INSTR()

函数作用：获取子字符串的第一次出现的位置。

语法：

INSTR(str text, patt text) RETURNS int

一般规则：

从1开始，在字符串str中获取子字符串patt的第一次出现的位置。
如果未找到，则返回0。

示例：

lightdb@mysqltest=# select INSTR('abc124deff4de', '4de');
 instr
-------
         6
(1 row)

5.4.14. LCASE()

函数作用：LOWER（）的同义词。

语法：

LCASE(p_source text) RETURNS text

一般规则：

LCASE()是LOWER()的同义词。
根据当前字符集映射，将字符串str中的所有字符更改为小写。默认为utf8mb4。

示例：

lightdb@mysqltest=# select LCASE('QuadRatic');
   lcase
-----------
 quadratic
(1 row)

5.4.15. LEFT()

函数作用：返回具有指定长度的字符串左边部分。

语法：

LEFT(p_source text, len integer) RETURNS text

一般规则：

LEFT()函数返回str字符串中最左边的长度字符。如果str或length参数为NULL，则返回NULL值。
如果length为0或为负，则LEFT函数返回一个空字符串。如果length大于str字符串的长度，则LEFT函数返回整个str字符串。

示例：

lightdb@mysqltest=# SELECT LEFT('MySQL LEFT', 5);
 left
-------
 MySQL
(1 row)

lightdb@mysqltest=# SELECT LEFT('MySQL LEFT', 1000);
        left
------------
 MySQL LEFT
(1 row)

lightdb@mysqltest=# SELECT LEFT('MySQL LEFT', NULL);.
 left
------

(1 row)

5.4.16. LENGTH()

函数作用：返回字符串的长度，以字节为单位。

语法：

LENGTH(str text) RETURN integer

一般规则：

用来计算指定字符串的长度的。
如果字符串为空，则返回0。

示例：

lightdb@mysqltest=#  SELECT LENGTH('text');
 length
--------
          4
(1 row)

lightdb@mysqltest=#  SELECT LENGTH('');
 length
--------
          0
(1 row)

5.4.17. LOCATE()

函数作用：返回字符串第一次出现的位置。

语法：

LOCATE(substr TEXT,str TEXT) returns INTEGER
LOCATE(substr TEXT,str TEXT,POS INTEGER) returns INTEGER

一般规则：

第一种语法返回字符串str中子字符串substr的第一次出现的位置。
第二种语法返回字符串str中子字符串substr在位置pos开始的第一次出现的位置。
如果在str中没有找到substr，则返回0。
如果任何参数为NULL，则返回NULL。

示例：

lightdb@mysqltest=# SELECT LOCATE('bar', 'foobarbar', 5);
 locate
--------
          7
(1 row)

5.4.18. LOWER()

函数作用：返回字符串的小写值。

语法：

LOWER(str text) returns text

一般规则：

函数的返回值是一个字符串，它是将原始字符串中的所有字符都转换为小写字母后得到的结果。
如果str位NULL，则返回空。

示例：

lightdb@mysqltest=# SELECT LOWER('QUADRATICALLY');
         lower
---------------
 quadratically
(1 row)

5.4.19. LPAD()

函数作用：返回一个左边被填充过的字符串。

语法：

LPAD(str,len,padstr) RETURN text

一般规则：

返回字符串str，左填充用字符串padstr填补到len字符长度。
如果str为大于len长，返回值被缩短至len个字符(即，不能超过 len 长)。

示例：

lightdb@mysqltest=# SELECT LPAD('hi',4,'??');
 lpad
------
 ??hi
(1 row)

5.4.20. LTRIM()

函数作用：去掉字符串开始处的空格。

语法：

LTRIM(str text) RETURN text

一般规则：

如果字符串为空，则返回空。

示例：

lightdb@mysqltest=# SELECT LTRIM('  barbar');
 ltrim
--------
 barbar
(1 row)

5.4.21. MID()

函数作用：从指定位置开始返回一个子字符串。

语法：

MID(p_source text, p_pos bigint, p_len bigint) RETURNS text

一般规则：

不带 len 参数的形式从字符串 str 的位置 pos 开始返回一个子字符串。带有 len 参数的形式从字符串 str 的位置 pos 开始返回一个长度为 len 的子字符串。
pos 也可以使用负值。在这种情况下，子字符串的开头是距离字符串末尾 pos 个字符，而不是开头。负值可以用于此函数的任何形式中的 pos。对于 pos 的值为 0，返回一个空字符串。

示例：

lightdb@mysqltest=# SELECT MID('Hongye', 2, 4);
 mid
------
 ongy
(1 row)

5.4.22. OCTET_LENGTH()

函数作用：LENGTH（）的同义词。详见LENGTH（）函数。

5.4.23. REGEXP_REPLACE()

函数作用：使用正则表达式来查找和替换字符串。

语法：

REGEXP_REPLACE(expr text, pat text, repl text) RETURNS text

一般规则：

函数将字符串expr中匹配模式pat的子串替换为repl并返回替换结果。
若expr、pat或repl为NULL，函数返回NULL。

示例：

lightdb@mysqltest=# SELECT REGEXP_REPLACE('a b c', 'b', 'X');
 regexp_replace
----------------
 a X c
(1 row)

5.4.24. REGEXP_REPLACE()

函数作用：使用正则表达式来查找和替换字符串。

语法：

REGEXP_REPLACE(expr text, pat text, repl text) RETURNS text

一般规则：

函数将字符串expr中匹配模式pat的子串替换为repl并返回替换结果。其中pat为正则表达式。
若expr、pat或repl为NULL，函数返回NULL。

示例：

lightdb@mysqltest=# SELECT REGEXP_REPLACE('a b c', 'b', 'X');
 regexp_replace
----------------
 a X c
(1 row)

5.4.25. REPEAT()

函数作用：返回一个字符串，该字符串由字符串 str 重复计数次数组成。。

语法：

REPEAT(expr text,count integer) RETURN text

一般规则：

如果 count 小于 1，则返回空字符串。
如果 expr为空或 count 为0 ，则返回空。

示例：

lightdb@mysqltest=# SELECT REPEAT('MySQL', 3);
         repeat
-----------------
 MySQLMySQLMySQL
(1 row)

5.4.26. REPLACE()

函数作用：替换指定字符串的特定字符串。

语法：

REPLACE(expr text,from_str text,to_str text) RETURN text

一般规则：

在字符串 expr 中所有出现的字符串 from_str 均被 to_str替换，然后返回这个字符串.

示例：

lightdb@mysqltest=# SELECT REPLACE('www.mysql.com', 'w', 'Ww');
         replace
------------------
 WwWwWw.mysql.com
(1 row)

5.4.27. REVERSE()

函数作用：将字符串中的字符顺序进行反转。

语法：

REVERSE(expr text) RETURN text

一般规则：

如果expr为空，则返回空.

示例：

lightdb@mysqltest=# SELECT REVERSE('abc');
 reverse
---------
 cba
(1 row)

lightdb@mysqltest=# SELECT REVERSE('');
 reverse
---------

(1 row)

5.4.28. RIGHT()

函数作用：返回最右边指定长度的字符串。

语法：

RIGHT(expr text,len integer) RETURN text

一般规则：

RIGHT()函数会将expr中右侧的len个字符返回（len从1开始计算）
如果expr为NULL，无论len为何值都返回NULL。

示例：

lightdb@mysqltest=# SELECT RIGHT('foobarbar', 4);
 right
-------
 rbar
(1 row)

5.4.29. RPAD()

函数作用：将字符串填充或添加到原始字符串的右侧。

语法：

RPAD(expr text,len integer,padstr text) RETURN TEXT

一般规则：

expr:要填充的实际字符串。如果原始字符串的长度大于len参数，否则不会进行填充。
len:这是右填充后最后一个字符串的长度。
padstr:要添加到原始expr右侧的字符串。

示例：

lightdb@mysqltest=# SELECT RPAD('hi',5,'?');
 rpad
-------
 hi???
(1 row)

lightdb@mysqltest=# SELECT RPAD('hi',1,'?');
 rpad
------
 h
(1 row)

5.4.30. RTRIM()

函数作用：从字符串中删除尾随空格。

语法：

RTRIM(expr text) RETURN text

一般规则：

截断所有尾随空格后，它将返回一个字符串。

示例：

lightdb@mysqltest=# SELECT RTRIM('barbar   ');
 rtrim
--------
 barbar
(1 row)

5.4.31. SPACE()

函数作用：返回指定数量空格的字符串。

语法：

SPACE(p_num int) RETURNS text

一般规则：

返回由 p_num 个空格字符组成的字符串。

示例：

lightdb@mysqltest=# SELECT CONCAT('123', SPACE(3), '456') AS full_name;
 full_name
-----------
 123   456
(1 row)

5.4.32. STRCMP()

函数作用：返回指定数量空格的字符串。

语法：

STRCMP(p1 text, p2 text) RETURNS int

一般规则：

STRCMP() 返回 0 表示两个字符串相同，返回 -1 表示第一个参数小于第二个参数按照当前的排序顺序，返回 1 表示其他情况。

示例：

lightdb@mysqltest=# select strcmp('text', 'text2');
 strcmp
--------
         -1
(1 row)

5.4.33. SUBSTR()

函数作用：根据指定要求返回子字符串。

语法：

SUBSTR(str text, pos int) RETURNS text
SUBSTR(str text, pos int, len int) RETURNS text

一般规则：

不带 len 参数的形式返回从字符串 str 中位置 pos 开始的子字符串。带有 len 参数的形式返回从字符串 str 中位置 pos 开始长度为 len 的子字符串。
pos 参数也可以使用负数。在这种情况下，子字符串的开始位置是距离字符串结尾 pos 个字符，而不是开头。pos 参数可以在此函数的任何形式中使用负值。当 pos 参数为 0 时，返回空字符串。
此函数支持多字节字符集。如果任何参数为 NULL，则返回 NULL。
如果 len 小于 1，则结果为空字符串。
如果 pos 和 len 都接受数字类型，则也是可以的。如果输入的小数部分小于 0.5，则将其四舍五入为整数部分。否则，将正数的四舍五入为输入值加上 0.5 的下限，将负数的四舍五入为输入值减去 0.5 的下限。

示例：

lightdb@mysqltest=# select substr('abc',-2,2);
substr
--------
bc
(1 row)

5.4.34. SUBSTR()

函数作用：根据指定要求返回子字符串。

语法：

SUBSTR(str text, pos int) RETURNS text
SUBSTR(str text, pos int, len int) RETURNS text

一般规则：

不带 len 参数的形式返回从字符串 str 中位置 pos 开始的子字符串。带有 len 参数的形式返回从字符串 str 中位置 pos 开始长度为 len 的子字符串。
pos 参数也可以使用负数。在这种情况下，子字符串的开始位置是距离字符串结尾 pos 个字符，而不是开头。pos 参数可以在此函数的任何形式中使用负值。当 pos 参数为 0 时，返回空字符串。
此函数支持多字节字符集。如果任何参数为 NULL，则返回 NULL。
如果 len 小于 1，则结果为空字符串。
如果 pos 和 len 都接受数字类型，则也是可以的。如果输入的小数部分小于 0.5，则将其四舍五入为整数部分。否则，将正数的四舍五入为输入值加上 0.5 的下限，将负数的四舍五入为输入值减去 0.5 的下限。

示例：

lightdb@mysqltest=# select substr('abc',-2,2);
substr
--------
bc
(1 row)

5.4.35. SUBSTRING()

函数作用：根据指定要求返回子字符串。

语法：

SUBSTRING(str text, pos int) RETURNS text
SUBSTRING(str text, pos int, len int) RETURNS text

一般规则：

substring 是 substr 的同义词。

示例：

lightdb@mysqltest=# select SUBSTRING('abc',-2,2);
substring
-----------
bc
(1 row)

5.4.36. TO_BASE64()

函数作用：将参数转换为 base-64 字符串并返回。

语法：

to_base64(p_str text) RETURNS text

一般规则：

将字符串参数转换为 base-64 编码形式，并返回一个使用连接字符集和排序规则的字符字符串作为结果。
如果参数不是字符串，则在进行转换之前将其转换为字符串。如果参数为 NULL，则结果为 NULL。
使用 FROM_BASE64() 函数可以解码 base-64 编码字符串。

示例：

lightdb@mysqltest=# select TO_BASE64('abc');
to_base64
-----------
YWJj
(1 row)

5.4.37. UCASE()

函数作用：UPPER() 的同义词。

语法：

UCASE(p_source text) RETURNS text

一般规则：

将字符串 str 中的所有字符根据当前字符集映射更改为大写。默认字符集为 utf8mb4。

示例：

lightdb@mysqltest=# select UCASE('QuadRatic');
ucase
-----------
QUADRATIC
(1 row)

5.4.38. UPPER()

函数作用：UCASE() 的同义词。

语法：

UPPER(p_source text) RETURNS text

一般规则：

将字符串 p_source 中的所有字符根据当前字符集映射更改为大写。默认字符集为 utf8mb4。

示例：

lightdb@mysqltest=# select UPPER('QuadRatic');
upper
-----------
QUADRATIC
(1 row)

5.5. 强制转换函数

强制转换函数列表概览
MySQL函数	LightDB函数	兼容性	说明
强制转换函数
CAST()	CAST(value AS datatype)，datatype支持DATE、DATETIME、TIME、CHAR、SIGNED、UNSIGNED、DECIMAL	支持	将值强制转换为特定类型
CONVERT()		·不支持	将值强制转换为特定类型

5.5.1. CAST()

函数作用：CAST 函数是 SQL 中的一种类型转换函数，它用于将一个数据类型转换为另一个数据类型。

语法：

CAST(value AS datatype)

一般规则：

value: 要转换的值 datatype: 要转换成的数据类型
datatype参数类型如下：

参数类型（持续更新）
值	描述
DATE	将value转换成’YYYY-MM-DD’格式
DATETIME	将value转换成’YYYY-MM-DD HH：MM：SS’格式
TIME	将value转换成’HH：MM：SS’格式
CHAR	将value转换成CHAR(固定长度的字符串)格式
SIGNED	将value转换成INT(有符号的整数)格式
UNSIGNED	将value转换成INT(无符号的整数)格式
DECIMAL	将value转换成FLOAT(浮点数)格式
BINARY	将value转换成二进制格式

示例：

#1.将值转换为DATE类型
lightdb@mysqltest=# SELECT CAST('2023-11-24' AS DATE);
        date
------------
 2023-11-24
(1 row)

#2.将值转换为DATETIME数据类型
lightdb@mysqltest=# SELECT CAST('2023-11-24' AS DATETIME);
          timestamp
---------------------
 2023-11-24 00:00:00
(1 row)

#3.将值转换为TIME数据类型
lightdb@mysqltest=# SELECT CAST('2023-11-25 14:06:10' AS TIME);
   time
----------
 14:06:10
(1 row)

#4.将值转换为CHAR数据类型
lightdb@mysqltest=# SELECT CONCAT('Hello LightDB',CAST(123 AS CHAR));
         concat
----------------
 Hello LightDB1
(1 row)

#5.将值转换为SIGNED数据类型
lightdb@mysqltest=# SELECT CAST(2023.4 AS SIGNED);
 signed
--------
   2023
(1 row)

#6.将值转换为UNSIGNED数据类型
lightdb@mysqltest=# SELECT CAST(2023.4 AS SIGNED);
 unsigned
--------
   2023
(1 row)

#7.将值转换为DECIMAL数据类型
lightdb@mysqltest=# SELECT CAST('1234.123' AS DECIMAL(10,2));
 numeric
---------
 1234.12
(1 row)

5.6. XML函数

XML函数列表概览
MySQL函数	兼容性	说明
XML函数
ExtractValue()	不支持	使用 XPath 表示法从 XML 字符串中提取值
UpdateXML()	不支持	返回替换的 XML 片段

5.7. 位函数

位函数列表概览
MySQL函数	LightDB函数	兼容性	说明
位函数
BIT_COUNT()		不支持	返回设置的位数
BIT_AND()	BIT_AND(expr bigint) RETURN bigint	支持	按位返回 AND
	BIT_AND(expr bit) RETURN bit	支持
	BIT_AND(expr integer) RETURN integer	支持
	BIT_AND(expr smallint) RETURN smallint	支持
BIT_OR()	BIT_OR(expr bigint) RETURN bigint	支持	按位返回 OR
	BIT_OR(expr bit) RETURN bit	支持
	BIT_OR(expr bit) RETURN bit	支持
	BIT_OR(expr smallint) RETURN smallint	支持
BIT_XOR()		不支持	按位返回异或

5.7.1. BIT_AND()

函数作用：对所有的非 null 输入值执行”按位与”运算。

语法：

BIT_AND(expr bigint) RETURN bigint
BIT_AND(expr bit) RETURN bit
BIT_AND(expr integer) RETURN integer
BIT_AND(expr smallint) RETURN smallint

一般规则：

按位与处理两个长度相同的二进制数，两个相应的二进位都为 1，该位的结果值才为 1，否则为 0。
返回值的类型与输入参数的类型相同，它返回对所有的非 null 输入值执行”按位与”运算的结果。
返回 NULL情况：所有的输入的值为 null。

示例：

lightdb@mysqltest=# SELECT BIT_AND(x) FROM (SELECT 4 x UNION SELECT 5 x UNION SELECT 6 x ) t;
 bit_and
---------
           4
(1 row)

5.7.2. BIT_OR()

函数作用：对所有的非 null 输入值执行”按位或”运算。

语法：

BIT_OR(expr bigint) RETURN bigint
BIT_OR(expr bit) RETURN bit
BIT_OR(expr bit) RETURN bit
BIT_OR(expr smallint) RETURN smallint

一般规则：

按位或处理两个长度相同的二进制数，两个相应的二进位都为 0，该位的结果值为 0，否则为 1。
返回值的类型与输入参数的类型相同，它返回对所有的非 null 输入值执行”按位或”运算的结果。
返回 NULL情况：所有的输入的值为 null。

示例：

lightdb@mysqltest=# SELECT BIT_OR(x) FROM (SELECT 4 x UNION SELECT 5 x UNION SELECT 6 x ) t;
 bit_or
--------
          7
(1 row)

5.8. 加密与压缩函数

加密与压缩函数列表概览
MySQL函数	LightDB函数	兼容性	说明
加密与压缩函数
AES_DECRYPT()		不支持	使用 AES 解密
AES_ENCRYPT()		不支持	使用 AES 加密
COMPRESS()	COMPRESS(string_to_compress text) RETURN bytea	支持	以二进制字符串形式返回结果
MD5()	MD5(expr text) RETURN text	支持	计算 MD5 校验和
	MD5(expr bytea) RETURN text	支持
RANDOM_BYTES()		不支持	返回一个随机字节向量
SHA1（）、SHA（）		不支持	计算 SHA-1 160 位校验和
SHA2()		不支持	计算 SHA-2 校验和
STATEMENT_DIGEST()		不支持	计算语句摘要哈希值
STATEMENT_DIGEST_TEXT()		不支持	计算规范化语句摘要
UNCOMPRESS()	UNCOMPRESS(string_to_uncompress bytea) RETURN text	支持	解压缩压缩的字符串
UNCOMPRESSED_LENGTH()		不支持	返回压缩前字符串的长度
VALIDATE_PASSWORD_STRENGTH()		不支持	确定密码的强度

5.8.1. COMPRESS()

函数作用：压缩字符串并将结果作为二进制字符串返回。

语法：

COMPRESS(string_to_compress text) RETURN bytea

一般规则：

如果string_to_compress为空，则返回0。
压缩字符串可以是使用 UNCOMPRESS()解压缩。

示例：

lightdb@mysqltest=# SELECT LENGTH(COMPRESS(REPEAT('a',1000)));
 length
--------
         21
(1 row)

lightdb@mysqltest=# SELECT LENGTH(COMPRESS(''));
 length
--------
          0
(1 row)

lightdb@mysqltest=# SELECT LENGTH(COMPRESS('a'));
 length
--------
         13
(1 row)

5.8.2. MD5()

函数作用：计算字符串的 MD5 128 位校验和。

语法：

MD5(expr text) RETURN text
MD5(expr bytea) RETURN text

一般规则：

返回值以 32 个十六进制数字的字符串形式返回。

示例：

lightdb@mysqltest=# SELECT MD5('testing');
                           md5
----------------------------------
 ae2b1fca515949e5d54fb22b8ed95575
(1 row)

lightdb@mysqltest=# SELECT MD5(E'\x012345');
       md5
----------------------------------
 9fbe399f7663399866f5e7a0eef36e97
(1 row)

5.8.3. UNCOMPRESSCOMPRESS()

函数作用：压缩字符串并将结果作为二进制字符串返回。

语法：

UNCOMPRESS(string_to_uncompress bytea) RETURN text

一般规则：

如果string_to_uncompress为空，则返回空。
如果string_to_uncompress不是COMPRESS()的压缩值，则返回空。

示例：

lightdb@mysqltest=# SELECT UNCOMPRESS(COMPRESS('any string'));
 uncompress
------------
 any string
(1 row)

lightdb@mysqltest=# SELECT UNCOMPRESS('any string');
 uncompress
------------

(1 row)

5.9. 信息函数

信息函数列表概览
MySQL函数	LightDB函数	兼容性	说明
信息函数		不支持
BENCHMARK()		不支持	重复执行表达式
CHARSET()		不支持	返回参数的字符集
COERCIBILITY()		不支持	返回字符串参数的排序规则强制值
COLLATION()		不支持	返回字符串参数的排序规则
CONNECTION_ID()		不支持	返回连接的连接 ID（线程 ID）
CURRENT_ROLE()		不支持	返回当前活动角色
CURRENT_USER（）， CURRENT_USER	CURRENT_USER	支持	经过身份验证的用户名和主机名
DATABASE()	DATABASE()。返回schema，类似与mysql的库名	支持	返回默认（当前）数据库名称
FOUND_ROWS()		不支持	对于带有 LIMIT 子句的 SELECT，行数为如果没有 LIMIT 子句，则返回
ICU_VERSION()		不支持	ICU 库版本
LAST_INSERT_ID()		不支持	最后一个 INSERT 的 AUTOINCREMENT 列的值
ROLES_GRAPHML()		不支持	返回表示内存角色子图的 GraphML 文档
ROW_COUNT()		不支持	更新的行数
SCHEMA()		不支持	DATABASE（）的同义词
SESSION_USER()	SESSION_USER()	支持	USER（）的同义词
SYSTEM_USER()		不支持	USER（）的同义词
USER()		不支持	客户端提供的用户名和主机名
VERSION()		支持	返回指示MySQL服务器版本的字符串

5.9.1. CURRENT_USER

函数作用：返回当前用户(当前执行上下文的用户)的名称。

语法：

CURRENT_USER  RETURN name

一般规则：

CURRENT_USER 无需任何参数；
要获取当前执行上下文的用户，可使用带有 current_user 的 SELECT 语句：

示例：

lightdb@mysqltest=# select current_user;
 current_user
--------------
 lightdb
(1 row)

5.9.2. DATABASE()

函数作用：返回当前数据库的名称。

语法：

DATABASE()  RETURN text

一般规则：

MySQL的数据库对应LightDB的Schema；
在LightDB中，调用该函数返回Schema名称；

示例：

lightdb@mysqltest=# SELECT DATABASE();
 database
----------
 public
(1 row)

5.9.3. SESSION_USER

函数作用：返回当前当前会话的用户名。

语法：

SESSION_USER  RETURN name

一般规则：

SESSION_USER 无需任何参数；
要获取当前会话的用户名，可使用带有 SESSION_USER 的 SELECT 语句：

示例：

lightdb@mysqltest=# SELECT SESSION_USER;
 session_user
--------------
 lightdb
(1 row)

5.9.4. VERSION()

函数作用：函数返回当前 PostgreSQL 服务器的版本信息。

语法：

VERSION()  RETURN text

一般规则：

函数无需带任何参数；
返回一个描述当前 PostgreSQL 服务器的版本信息的字符串；

示例：

lightdb@mysqltest=# SELECT VERSION();
                                                                                                version
-----------------------------------------------------------------------------------------------------------
 LightDB 13.8-23.3 on x86_64-pc-linux-gnu, compiled by gcc (GCC) 4.8.5 20150623 (Red Hat 4.8.5-44), 64-bit
(1 row)

5.10. 空间分析函数

空间分析函数列表概览
MySQL函数	LightDB函数	兼容性	说明	备注
空间分析函数
GeomCollection()		不支持	从几何图形构造几何图形集合
GeometryCollection()		不支持	从几何图形构造几何图形集合
LineString()		不支持	从 Point 值构造 LineString
MBRContains()		不支持	一个几何图形的 MBR 是否包含另一个几何图形的 MBR
MBRCoveredBy()		不支持	一个MBR是否被另一个MBR覆盖
MBRCovers()		不支持	一个MBR是否覆盖另一个MBR
MBRDisjoint()		不支持	两个几何形状的MBR是否不相交
MBREquals()		不支持	两个几何形状的MBR是否相等
MBRIntersects()		不支持	两个几何形状的 MBR 是否相交
MBROverlaps()		不支持	两个几何形状的MBR是否重叠
MBRTouches()		不支持	两种几何形状的MBR是否接触
MBRWithin()		不支持	一个几何形状的 MBR 是否在另一个几何形状的 MBR 范围内
MultiLineString()		不支持	从 LineString 值构造 MultiLineString
MultiPoint()		不支持	从点值构造 MultiPoint
MultiPolygon()		不支持	从多边形值构造 MultiPolygon
Point()	POINT(double precision, double precision) RETURN point	支持	从坐标构造点
	POINT(box) RETURN point	支持
	POINT(circle) RETURN point	支持
	POINT(lseg) RETURN point	支持
	POINT(polygon) RETURN point	支持
Polygon()	POLYGON(box) RETURN polygon	支持	从 LineString 参数构造多边形
	POLYGON(circle) RETURN polygon	支持
	POLYGON(integer,circle) RETURN polygon	支持
	POLYGON(path) RETURN polygon	支持
ST_Area()		不支持	返回多边形或多多边形区域
ST_AsBinary（）， ST_AsWKB（）		不支持	将内部几何格式转换为 WKB
ST_AsGeoJSON()		不支持	从几何体生成 GeoJSON 对象
ST_AsText（）， ST_AsWKT（）		不支持	从内部几何格式转换为 WKT
ST_Buffer()		不支持	返回与几何图形相距给定距离内的点的几何图形
ST_Buffer_Strategy()		不支持	ST_Buffer（）的 produce 策略选项
ST_Centroid()		不支持	将质心作为点返回
ST_Collect()		不支持	将空间值聚合到集合中	8.0.24
ST_Contains()		不支持	一个几何图形是否包含另一个几何图形
ST_ConvexHull()		不支持	几何形状的返回凸包
ST_Crosses()		不支持	一个几何图形是否与另一个几何图形相交
ST_Difference()		不支持	两个几何形状的返回点集差异
ST_Dimension()		不支持	几何尺寸
ST_Disjoint()		不支持	一个几何图形是否与另一个几何图形不相交
ST_Distance()		不支持	一个几何图形与另一个几何图形的距离
ST_Distance_Sphere()		不支持	两个几何形状之间的最小地球距离
ST_EndPoint()		不支持	LineString 的终结点
ST_Envelope()		不支持	返回几何形状的 MBR
ST_Equals()		不支持	一个几何图形是否等于另一个几何图形
ST_ExteriorRing()		不支持	多边形的返回外环
ST_FrechetDistance()		不支持	一个几何体与另一个几何体的离散 Fréchet 距离	8.0.23
ST_GeoHash()		不支持	生成 geohash 值
ST_GeomCollFromText（）， ST_GeometryCollectionFromText（）， ST_GeomCollFromTxt（）		不支持	从 WKT 返回几何图形集合
ST_GeomCollFromWKB（）， ST_GeometryCollectionFromWKB（）		不支持	从 WKB 返回几何图形集合
ST_GeometryN()		不支持	从几何集合中返回第 N 个几何图形
ST_GeometryType()		不支持	返回几何类型的名称
ST_GeomFromGeoJSON()		不支持	从 GeoJSON 对象生成几何图形
ST_GeomFromText（）， ST_GeometryFromText（）		不支持	从 WKT 返回几何图形
ST_GeomFromWKB（）， ST_GeometryFromWKB（）		不支持	从 WKB 返回几何图形
ST_HausdorffDistance()		不支持	一个几何图形与另一个几何图形的离散豪斯多夫距离	8.0.23
ST_InteriorRingN()		不支持	返回多边形的第 N 个内环
ST_Intersection()		不支持	两个几何图形的返回点集相交
ST_Intersects()		不支持	一个几何图形是否与另一个几何图形相交
ST_IsClosed()		不支持	几何图形是否闭合且简单
ST_IsEmpty()		不支持	几何图形是否为空
ST_IsSimple()		不支持	几何图形是否简单
ST_IsValid()		不支持	几何图形是否有效
ST_LatFromGeoHash()		不支持	从 geohash 值返回纬度
ST_Latitude()		不支持	点的返回纬度	8.0.12
ST_Length()		不支持	LineString 的返回长度
ST_LineFromText（）， ST_LineStringFromText（）		不支持	从 WKT 构造 LineString
ST_LineFromWKB（）， ST_LineStringFromWKB（）		不支持	从 WKB 构造 LineString
ST_LineInterpolatePoint()		不支持	沿 LineString 的给定百分比的点	8.0.24
ST_LineInterpolatePoints()		不支持	沿 LineString 的给定百分比的点数	8.0.24
ST_LongFromGeoHash()		不支持	从 geohash 值返回经度
ST_Longitude()		不支持	返回点的经度	8.0.12
ST_MakeEnvelope()		不支持	围绕两点的矩形
ST_MLineFromText（）， ST_MultiLineStringFromText（）		不支持	从 WKT 构造 MultiLineString
ST_MLineFromWKB（）， ST_MultiLineStringFromWKB（）		不支持	从 WKB 构造 MultiLineString
ST_MPointFromText（）， ST_MultiPointFromText（）		不支持	从 WKT 构造 MultiPoint
ST_MPointFromWKB（）， ST_MultiPointFromWKB（）		不支持	从 WKB 构造 MultiPoint
ST_MPolyFromText（）， ST_MultiPolygonFromText（）		不支持	从 WKT 构造 MultiPolygon
ST_MPolyFromWKB（）， ST_MultiPolygonFromWKB（）		不支持	从 WKB 构造 MultiPolygon
ST_NumGeometries()		不支持	返回几何集合中的几何数
ST_NumInteriorRing（）， ST_NumInteriorRings（）		不支持	多边形中内环的返回数
ST_NumPoints()		不支持	返回 LineString 中的点数
ST_Overlaps()		不支持	一个几何图形是否与另一个几何图形重叠
ST_PointAtDistance()		不支持	沿 LineString 的给定距离的点	8.0.24
ST_PointFromGeoHash()		不支持	将 geohash 值转换为 POINT 值
ST_PointFromText()		不支持	WKT 的构造点
ST_PointFromWKB()		不支持	来自 WKB 的构造点
ST_PointN()		不支持	从 LineString 返回第 N 个点
ST_PolyFromText（）， ST_PolygonFromText（）		不支持	从 WKT 构建多边形
ST_PolyFromWKB（）， ST_PolygonFromWKB（）		不支持	从 WKB 构造多边形
ST_Simplify()		不支持	返回简化的几何图形
ST_SRID()		不支持	返回几何的空间参考系 ID
ST_StartPoint()		不支持	LineString 的起点
ST_SwapXY()		不支持	交换了 X/Y 坐标的返回参数
ST_SymDifference()		不支持	返回点集两个几何形状的对称差
ST_Touches()		不支持	一个几何图形是否与另一个几何图形接触
ST_Transform()		不支持	变换几何图形的坐标	8.0.13
ST_Union()		不支持	两个几何图形的返回点集并集
ST_Validate()		不支持	返回经过验证的几何图形
ST_Within()		不支持	一个几何图形是否在另一个几何图形中
ST_X()		不支持	返回点的 X 坐标
ST_Y()		不支持	返回点的 Y 坐标

5.10.1. POINT()

函数作用：根据参数指定的坐标构造一个点并返回。

语法：

POINT(double precision, double precision) RETURN point
POINT(box) RETURN point
POINT(circle) RETURN point
POINT(lseg) RETURN point
POINT(polygon) RETURN point

一般规则：

函数返回由参数指定的图形的中心点。
图形支持点、线段、矩形、圆、多边形；

示例：

lightdb@mysqltest=# SELECT POINT(1.25, -2.86);
        point
--------------
 (1.25,-2.86)
(1 row)

lightdb@mysqltest=# SELECT POINT(BOX'(2,2),(1,1)');
   point
-----------
 (1.5,1.5)
(1 row)

lightdb@mysqltest=# SELECT POINT(CIRCLE '<(1,2),3>');
 point
-------
 (1,2)
(1 row)

lightdb@mysqltest=# SELECT POINT(LSEG '[(1,1),(2,2)]');
   point
-----------
 (1.5,1.5)
(1 row)

lightdb@mysqltest=# SELECT POINT(POLYGON '(-1,1),(1,1),(1,-1),(-1,-1)');
 point
-------
 (0,0)
(1 row)

5.10.2. Polygon()

函数作用：根据参数指定图像转变成一个多边形。

语法：

POLYGON(box)  RETURN polygon
POLYGON(circle)  RETURN polygon
POLYGON(integer,circle)  RETURN polygon
POLYGON(path)  RETURN polygon

一般规则：

函数返回一个指定参数的多边形；
参数值支持矩形、圆形、闭合路径；

示例：

#下面的语句示例展示了使用 LightDB polygon(box) 函数将矩形 box '(1,1),(-1,-1)' 转为多边形。
lightdb@mysqltest=# SELECT POLYGON(BOX '(1,1),(-1,-1)');
                        polygon
-------------------------------
 ((-1,-1),(-1,1),(1,1),(1,-1))
(1 row)

#下面的语句示例展示了使用 LightDB polygon(box) 函数将矩形 box '(1,1),(-1,-1)' 转为多边形。
lightdb@mysqltest=# SELECT POLYGON(CIRCLE '<(0,0),2>');
                polygon
-------------------------------------------------------------------------------------------------------------------------------
 ((-2,0),(-1.7320508075688774,0.9999999999999999),(-1.0000000000000002,1.7320508075688772),(-1.2246467991473532e-16,2),(0.99999
99999999996,1.7320508075688774),(1.732050807568877,1.0000000000000007),(2,2.4492935982947064e-16),(1.7320508075688776,-0.999999
9999999994),(1.0000000000000009,-1.7320508075688767),(3.6739403974420594e-16,-2),(-0.9999999999999987,-1.732050807568878),(-1.7
320508075688767,-1.0000000000000009))
(1 row)

#下面的语句示例展示了如何使用LightDB POLYGON(circle) 函数将圆形 circle '<(0,0),2>' 转为多边形。
lightdb@mysqltest=# SELECT POLYGON(3, CIRCLE '<(0,0),2>');
                                                                                  polygon
-------------------------------------------------------------------------------------------
 ((-2,0),(0.9999999999999996,1.7320508075688774),(1.0000000000000009,-1.7320508075688767))
(1 row)

#下面的语句示例展示了如何使用LightDB POLYGON(path) 函数将闭合的路径 PATH '((2,2),(1,1),(3,0),(4,0))' 转为多边形。
lightdb@mysqltest=# SELECT POLYGON(PATH '((2,2),(1,1),(3,0),(4,0))');
                  polygon
---------------------------
 ((2,2),(1,1),(3,0),(4,0))
(1 row)

5.11. JSON函数

JSON函数列表概览
MySQL函数	LightDB函数	兼容性	说明	备注
JSON函数
JSON_ARRAY()	JSON_ARRAY([val[, val] …])	支持	创建 JSON 数组
JSON_ARRAY_APPEND()		不支持	将数据追加到 JSON 文档
JSON_ARRAY_INSERT()		不支持	插入到 JSON 数组中
JSON_CONTAINS()	JSON_CONTAINS(target, candidate[, path]) RETURNS bool	支持	JSON 文档是否包含路径中的特定对象
JSON_CONTAINS_PATH()	JSON_CONTAINS_PATH(json_doc, one_or_all, path[, path] …) RETURNS bool	支持	JSON 文档是否包含路径中的任何数据
JSON_DEPTH()		不支持	JSON 文档的最大深度
JSON_EXTRACT()	JSON_EXTRACT(json_doc, path[, path] …) RETURNS jsonb	支持	从 JSON 文档返回数据
JSON_INSERT()	JSON_INSERT(json_doc, path, val[, path, val] …) RETURNS jsonb	支持	将数据插入 JSON 文档
JSON_KEYS()		不支持	JSON 文档中的键数组
JSON_LENGTH()		不支持	JSON文档中的元素数
JSON_MERGE()		不支持	合并 JSON 文档，保留重复的键。荒废的 JSON_MERGE_PRESERVE（）的同义词
JSON_MERGE_PATCH()		不支持	合并 JSON 文档，替换重复键的值
JSON_MERGE_PRESERVE()		不支持	合并 JSON 文档，保留重复的键
JSON_OBJECT()	JSON_OBJECT([key, val[, key, val] …]) RETURNS jsonb	支持	创建 JSON 对象
JSON_OVERLAPS()		不支持	比较两个 JSON 文档，如果这些文档有任何 TRUE（1），则返回 TRUE （0）键值对或数组元素相同，否则为 FALSE （<>）	8.0.17
JSON_PRETTY()	JSON_PRETTY(json_val) RETURNS text	支持	以人类可读的格式打印 JSON 文档
JSON_QUOTE()		不支持	引用 JSON 文档
JSON_REMOVE()	JSON_REMOVE(json_doc, path[, path] …) RETURNS jsonb	支持	从 JSON 文档中删除数据
JSON_REPLACE()	JSON_REPLACE(json_doc, path, val[, path, val] …) RETURNS jsonb	支持	替换 JSON 文档中的值
JSON_SCHEMA_VALID()		不支持	根据 JSON 模式验证 JSON 文档;如果出现以下情况，则返回 TRUE/1 document 根据架构进行验证，如果没有，则为 FALSE/0	8.0.17
JSON_SCHEMA_VALIDATION_REPORT()		不支持	根据 JSON 模式验证 JSON 文档;以 JSON 格式返回报告验证结果的格式，包括成功或失败，以及失败原因	8.0.17
JSON_SEARCH()		不支持	JSON 文档中值的路径
JSON_SET()	JSON_SET(json_doc, path, val[, path, val] …) RETURNS jsonb	支持	将数据插入 JSON 文档
JSON_STORAGE_FREE()		不支持	JSON 列值的二进制表示形式中的释放空间以下部分更新
JSON_STORAGE_SIZE()		不支持	用于存储 JSON 文档的二进制表示形式的空间
JSON_TABLE()		不支持	将 JSON 表达式中的数据作为关系表返回
JSON_TYPE()		不支持	JSON 值的类型
JSON_UNQUOTE()		不支持	取消对 JSON 值的引用
JSON_VALID()		不支持	JSON值是否有效
JSON_VALUE()		不支持	从路径指向的位置的 JSON 文档中提取值提供;将此值返回为 VARCHAR（512）或指定类型	8.0.21
MEMBER OF()		不支持	如果第一个操作数与 JSON 的任何元素匹配，则返回 true （1）数组作为第二个操作数传递，否则返回 false （0）	8.0.17

5.11.1. JSON_ARRAY()

函数作用：计算（可能是空的）值列表并返回 JSON 包含这些值的数组。

语法：

JSON_ARRAY([val[, val] …]) RETURNS jsonb

一般规则：

返回 JSON 数组，数据类型为 jsonb。

示例：

lightdb@mysqltest=# SELECT JSON_ARRAY(1, 2, 3, 4, 5) AS jsonArray;
        jsonarray
-----------------
[1, 2, 3, 4, 5]
(1 row)

5.11.2. JSON_CONTAINS_PATH()

函数作用：判断 JSON 文档是否包含指定的一个或多个 JSON 路径，返回 true 或 false。

语法：: JSON_CONTAINS_PATH(json_doc, one_or_all, path[, path] …) RETURNS bool

一般规则：

如果 JSON 路径均不存在，则返回 false。否则根据 one_or_all 参数确定返回值。 ‘one’ : 如果任意一个 JSON 路径存在，则返回 true。否则 false。 ‘all’ : 如果所有的 JSON 路径都存在，则返回 true。否则 false;
如果 JSON 文档或 JSON 路径是非法的值或 one_or_all 参数不是 ‘one’ 或 ‘all’，则提示错误。
如果为了检测某个路径是否存在于 JSON 文档中，请使用 JSON_CONTAINS()。

示例：

lightdb@mysqltest=# SELECT JSON_CONTAINS_PATH('{"a": 111, "b": 222, "c": {"d": 4444}}', 'one', '$.a', '$.z');
json_contains_path
--------------------
t
(1 row)

lightdb@mysqltest=# SELECT JSON_CONTAINS_PATH('{"a": 111, "b": 222, "c": {"d": 4444}}', 'one', '$.d');
json_contains_path
--------------------
f
(1 row)

lightdb@mysqltest=# SELECT JSON_CONTAINS_PATH('{"a": 111, "b": 222, "c": {"d": 4444}}', 'all', '$a', '$.b', '$.c');
json_contains_path
--------------------
t
(1 row)

lightdb@mysqltest=# SELECT JSON_CONTAINS_PATH('{"a": 111, "b": 222, "c": {"d": 4444}}', 'all', '$a', '$.b', '$.d');
json_contains_path
--------------------
f
(1 row)

5.11.3. JSON_EXTRACT()

函数作用：从json文档里抽取数据。

语法：: JSON_EXTRACT(json_doc, path[, path] …) RETURNS jsonb

一般规则：

返回所有通过 JSON 路径选择出的值，数据类型为 jsonb。如果返回的值有多个，则这些值会按选择的顺序构成一个数组。否则返回单个值。
如果任意参数为 NULL，或者 JSON 未选中，则返回 NULL。
如果 JSON 文档或 JSON 路径是非法的值，则提示错误。

示例：

lightdb@mysqltest=# select json_extract('{"name": "John", "age": 30, "city": "New York"}','$.city');
json_extract
--------------
"New York"
(1 row)

5.11.4. JSON_INSERT()

函数作用：向 JSON 文档中插入数据，返回修改后的结果。

语法：: JSON_INSERT(json_doc, path, val[, path, val] …) RETURNS jsonb

一般规则：

向 JSON 文档中插入数据，返回修改后的结果。如果任意参数为 NULL，则返回 NULL。
如果 JSON 文档是非法的值，或 JSON 路径是非法的值，或 JSON 路径包含 * 或 ** 通配符，则提示错误。
如果 JSON 路径存在，则该函数什么也不做，直接返回原值。否则先插入数据并返回修改后的结果。

示例：

  lightdb@mysqltest=# SELECT JSON_INSERT('{ "a": 1, "b": [2, 3]}', '$.a', 10);
json_insert
  -----------------------
  {"a": 1, "b": [2, 3]}
  (1 row)

  lightdb@mysqltest=#  SELECT JSON_INSERT('{ "a": 1, "b": [2, 3]}', '$.c', 200);
     json_insert
  ---------------------------------
  {"a": 1, "b": [2, 3], "c": 200}
  (1 row)

5.11.5. JSON_OBJECT()

函数作用：生成一个包含指定K-V对的json object。

语法：: JSON_OBJECT([key, val[, key, val] …]) RETURNS jsonb

一般规则：

返回 JSON 对象，数据类型为 jsonb。
如果键的值为 NULL 或参数个数为奇数，则提示错误。

示例：

lightdb@mysqltest=# SELECT JSON_OBJECT('name', 'John', 'age', 30, 'city', 'New York') AS jsonObject;
           jsonobject
-------------------------------------------------
{"age": 30, "city": "New York", "name": "John"}
(1 row)

5.11.6. JSON_PRETTY()

函数作用：描述格式化 JSON 文档。

语法：

JSON_PRETTY(json_val) RETURNS text

一般规则：

返回值类型为 text；
无意义的空格和换行符不会影响输出结果。
对于参数为 NULL，则函数返回 NULL。如果参数是非法值，则提示错误。

示例：

lightdb@mysqltest=# SELECT JSON_PRETTY('{"a":{"b":{"z":1},"c":[5,{"z":2}],"z":3}, "z":4}');
        json_pretty
------------------------
{                     +
        "a": {            +
                "b": {        +
                        "z": 1    +
                },            +
                "c": [        +
                        5,        +
                        {         +
                                "z": 2+
                        }         +
                ],            +
                "z": 3        +
        },                +
        "z": 4            +
}
(1 row)

5.11.7. JSON_REMOVE()

函数作用：JSON 文档中删除数据，返回修改后的结果。

语法：: JSON_REMOVE(json_doc, path[, path] …) RETURNS jsonb

一般规则：

从 JSON 文档中删除数据，返回修改后的结果。如果任意参数为 NULL，则返回 NULL。
如果 JSON 文档是非法的值，或 JSON 路径是非法的值，或 JSON 路径为 $，或 JSON 路径包含 * 或 ** 通配符，则提示错误;
如果指定的 JSON 路径不存在，函数不会提示错误，而是直接返回原 JSON 文档；

示例：

lightdb@mysqltest=# SELECT JSON_REMOVE('{"a": 1, "b": [1,2,3], "c": {"d": 4}}', '$.c.d');
    json_remove
-----------------------------------
{"a": 1, "b": [1, 2, 3], "c": {}}
(1 row)

5.11.8. JSON_REPLACE()

函数作用：替换 JSON 文档的数据，返回修改后的结果。

语法：: JSON_REPLACE(json_doc, path, val[, path, val] …) RETURNS jsonb

一般规则：

替换 JSON 文档的数据，返回修改后的结果。如果任意参数为 NULL，则返回 NULL;
如果 JSON 文档是非法的值，或 JSON 路径是非法的值，或 JSON 路径包含 * 或 ** 通配符，则提示错误;
如果 JSON 路径不存在，则该函数什么也不做，直接返回原值。否则先替换数据并返回修改后的结果;

示例：

lightdb@mysqltest=# select json_extract('{"name": "John", "age": 30, "city": "New York"}','$.city');
json_extract
--------------
"New York"
(1 row)

5.11.9. JSON_SET()

函数作用：替换 JSON 向 JSON 文档中插入数据或替换 JSON 文档的数据，返回修改后的结果。

语法：: JSON_SET(json_doc, path, val[, path, val] …) RETURNS jsonb

一般规则：

向 JSON 文档中插入数据或替换 JSON 文档的数据，返回修改后的结果。如果任意参数为 NULL，则返回 NULL;
如果 JSON 文档是非法的值，或 JSON 路径是非法的值，或 JSON 路径包含 * 或 ** 通配符，则提示错误;
如果 JSON 路径存在，先替换数据并返回修改后的结果。如果 JSON 路径不存在，则先插入数据并返回修改后的结果。

示例：

 lightdb@mysqltest=# SELECT JSON_SET('{ "a": 1, "b": [2, 3]}', '$.a', 10);
 json_set
 ------------------------
 {"a": 10, "b": [2, 3]}
 (1 row)

 lightdb@mysqltest=# SELECT JSON_SET('{ "a": 1, "b": [2, 3]}', '$.c', '[true, false]');
           json_set
 ---------------------------------------------
 {"a": 1, "b": [2, 3], "c": "[true, false]"}
 (1 row)

 lightdb@mysqltest=# SELECT JSON_SET('{ "a": 1, "b": [2, 3]}', '$.b.z', 4);
json_set
 -----------------------
 {"a": 1, "b": [2, 3]}
 (1 row)

5.11.10. JSON_CONTAINS()

函数作用：查询json文档是否在指定path包含指定的数据，包含则返回true，否则返回false。

语法：: JSON_CONTAINS(target, candidate[, path]) RETURNS bool

一般规则：

如果 JSON 文档或 JSON 路径是非法的值，则提示错误。
如果为了检测某个值是否存在于 JSON 文档中，请使用 JSON_CONTAINS_PATH()。

示例：

lightdb@mysqltest=# SELECT JSON_CONTAINS('{"name": "John", "age": 30, "city": "New York"}', '"John"', '$.name') AS containsJohn,JSON_CONTAINS('{"name": "John", "age": 30, "city": "New York"}', '30', '$.age') AS containsAge30;
containsjohn | containsage30
--------------+---------------
t            | t
(1 row)

5.12. 聚合函数

聚合函数列表概览
MySQL函数	LightDB函数	兼容性	说明
聚合函数
AVG()	AVG(expr bigint) RETURN numeric	支持	返回参数的平均值
	AVG(expr double precision) RETURN double precision	支持
	AVG(expr double integer) RETURN double numeric	支持
	AVG(expr double interval) RETURN double interval	支持
	AVG(expr double numeric) RETURN double numeric	支持
COUNT()	COUNT(expr) RETURN bigint	支持	返回返回的行数计数
COUNT(DISTINCT)	COUNT(DISTINCT expr) RETURN bigint	支持	返回多个不同值的计数
GROUP_CONCAT()	GROUP_CONCAT( [DISTINCT] column_name1 [ORDER BY {unsigned_integer \| column_name2 \| expr} [ASC \| DESC] [SEPARATOR delimiter TEXT]) returns TEXT	支持	返回串联字符串
JSON_ARRAYAGG()		不支持	以单个 JSON 数组的形式返回结果集
JSON_OBJECTAGG()		不支持	将结果集作为单个 JSON 对象返回
MAX()	支持21种数据类型比较，详见后续	支持	返回最大值
MIN()	支持21种数据类型比较，详见后续	支持	返回最小值
STD()		不支持	返回总体标准差
STDDEV()	支持类型5种，和AVG（）一致	支持	返回总体标准差
STDDEV_POP()	支持类型5种，和AVG（）一致	支持	返回总体标准差
STDDEV_SAMP()	支持类型5种，和AVG（）一致	支持	返回样本标准差
SUM()	支持8中类型，详见后续	支持	返回总和
VAR_POP()	支持类型5种，和AVG（）一致	支持	返回总体标准方差
VAR_SAMP()	支持类型5种，和AVG（）一致	支持	返回样本方差
VARIANCE()	支持类型5种，和AVG（）一致	支持	返回总体标准方差

5.12.1. AVG()

函数作用：返回平均值。

语法：

AVG(expr bigint)  RETURN numeric
AVG(expr double precision)  RETURN double precision
AVG(expr double integer)  RETURN double numeric
AVG(expr double interval)  RETURN double interval
AVG(expr double numeric)  RETURN double numeric
AVG(expr double smallint)  RETURN double numeric

一般规则：

函数返回一个分组中的所有指定的值的平均值；
如果expr为空，则返回空；

示例：

#建立一个员工信息表，统计工资平均值
CREATE TABLE EMP
(
        EMPNO INT NOT NULL,
        ENAME VARCHAR(10),
        JOB VARCHAR(9),
        MGR INT,
        HIREDATE DATE,
        SAL DECIMAL(7, 2),
        COMM DECIMAL(7, 2),
        DEPTNO INT
);

#插入员工信息
INSERT INTO EMP VALUES (7369, 'SMITH', 'CLERK', 7902, TO_DATE('17-DEC-1980', 'DD-MON-YYYY'), 800, NULL, 20);
INSERT INTO EMP VALUES (7499, 'ALLEN', 'SALESMAN', 7698, TO_DATE('20-FEB-1981', 'DD-MON-YYYY'), 1600, 300, 30);
INSERT INTO EMP VALUES (7521, 'WARD', 'SALESMAN', 7698, TO_DATE('22-FEB-1981', 'DD-MON-YYYY'), 1250, 500, 30);
INSERT INTO EMP VALUES (7566, 'JONES', 'MANAGER', 7839, TO_DATE('2-APR-1981', 'DD-MON-YYYY'), 2975, NULL, 20);
INSERT INTO EMP VALUES (7654, 'MARTIN', 'SALESMAN', 7698, TO_DATE('28-SEP-1981', 'DD-MON-YYYY'), 1250, 1400, 30);
INSERT INTO EMP VALUES (7698, 'BLAKE', 'MANAGER', 7839, TO_DATE('1-MAY-1981', 'DD-MON-YYYY'), 2850, NULL, 30);
INSERT INTO EMP VALUES (7782, 'CLARK', 'MANAGER', 7839, TO_DATE('9-JUN-1981', 'DD-MON-YYYY'), 2450, NULL, 10);
INSERT INTO EMP VALUES (7788, 'SCOTT', 'ANALYST', 7566, TO_DATE('09-DEC-1982', 'DD-MON-YYYY'), 3000, NULL, 20);
INSERT INTO EMP VALUES (7839, 'KING', 'PRESIDENT', NULL, TO_DATE('17-NOV-1981', 'DD-MON-YYYY'), 5000, NULL, 10);
INSERT INTO EMP VALUES (7844, 'TURNER', 'SALESMAN', 7698, TO_DATE('8-SEP-1981', 'DD-MON-YYYY'), 1500, 0, 30);
INSERT INTO EMP VALUES (7876, 'ADAMS', 'CLERK', 7788, TO_DATE('12-JAN-1983', 'DD-MON-YYYY'), 1100, NULL, 20);
INSERT INTO EMP VALUES (7900, 'JAMES', 'CLERK', 7698, TO_DATE('3-DEC-1981', 'DD-MON-YYYY'), 950, NULL, 30);
INSERT INTO EMP VALUES (7902, 'FORD', 'ANALYST', 7566, TO_DATE('3-DEC-1981', 'DD-MON-YYYY'), 3000, NULL, 20);
INSERT INTO EMP VALUES (7934, 'MILLER', 'CLERK', 7782, TO_DATE('23-JAN-1982', 'DD-MON-YYYY'), 1300, NULL, 10);

#求销售员工的平均工资
lightdb@mysqltest=# SELECT AVG(SAL) FROM EMP WHERE EMP.JOB='SALESMAN';
                  avg
-----------------------
 1400.0000000000000000
(1 row)

5.12.2. COUNT()

函数作用：统计一个分组中的所有指定的值的数量并返回。

语法：

COUNT([DISTINCT] expr) RETURN bigint

一般规则：

函数返回一个分组中的所有行的数量；
COUNT(*) 函数返回一个分组中的所有行的数量；

示例：

#EMP表数据，见AVG()。
    lightdb@mysqltest=# SELECT COUNT(*) FROM EMP WHERE EMP.JOB='SALESMAN';
     count
    -------
             4
    (1 row)

    lightdb@mysqltest=# SELECT COUNT(sal) FROM EMP WHERE EMP.JOB='SALESMAN';
     count
    -------
             4
    (1 row)

    lightdb@mysqltest=# SELECT COUNT(DISTINCT SAL) FROM EMP WHERE EMP.JOB='SALESMAN';
     count
    -------
             3
    (1 row)

5.12.3. GROUP_CONCAT()

函数作用：返回字符串值的连接，以分隔符为分隔符。

语法：

GROUP_CONCAT( [DISTINCT] column_name1 [ORDER BY {unsigned_integer | column_name2 | expr} [ASC | DESC] [SEPARATOR delimiter TEXT]) returns TEXT

一般规则：

此函数从组中返回一个具有连接的非NULL值的字符串结果。
如果没有非NULL值，则返回NULL。
要对结果中的值进行排序，请使用ORDER BY子句。要按相反的顺序排序，请在ORDER BY子句中按排序列的名称添加DESC（降序）关键字。默认为升序。可以使用ASC关键字明确指定。
要消除重复值，请使用DISTINCT子句。
默认情况下，组中值之间的分隔符是逗号（,）。要明确指定分隔符，请使用SEPARATOR后跟应在组值之间插入的字符串文字值。要完全消除分隔符，请指定SEPARATOR’’。

示例：

#返回以':'为分隔符的表t中列col1的值的结果。
lightdb@mysqltest=# select GROUP_CONCAT(col1 separator ':') from (values('BBBB',1),('AAAA',1),('CCCC',2)) as t(col1 ,col2) group by col2;
 group_concat
--------------
 BBBB:AAAA
 CCCC
(2 rows)

5.12.4. MAX()

函数作用：返回表中任意列数据最大值。

语法：

MAX(anyarray) RETUN anyarray
MAX(anyenum) RETUN anyenum
MAX(bigint) RETUN bigint
MAX(character) RETUN character
MAX(date) RETUN date
MAX(double precision) RETUN double precision
MAX(inet) RETUN inet
MAX(integer) RETUN integer
MAX(interval) RETUN interval
MAX(money) RETUN money
MAX(numeric) RETUN numeric
MAX(oid) RETUN oid
MAX(pg_lsn) RETUN pg_lsn
MAX(real) RETUN real
MAX(smallint) RETUN smallint
MAX(text) RETUN text
MAX(tid) RETUN tid
MAX(timestamp without time zone) RETUN timestamp without time zone
MAX(timestamp with time zone ) RETUN timestamp with time zone
MAX(time without time zone ) RETUN time without time zone
MAX(time with time zone) RETUN time with time zone

一般规则：

函数返回一个分组中的所有指定的值中的最大值。
支持的列的类型包含array、enum、bigint、date等共计21种类型

示例：

#求销售员工工资中最高的工资
lightdb@mysqltest=# SELECT MAX(SAL) FROM EMP WHERE EMP.JOB='SALESMAN';
   max
---------
 1600.00
(1 row)

5.12.5. MIN()

函数作用：返回表中任意列数据最大值。

语法：

MIN(anyarray) RETUN anyarray
MIN(anyenum) RETUN anyenum
MIN(bigint) RETUN bigint
MIN(character) RETUN character
MIN(date) RETUN date
MIN(double precision) RETUN double precision
MIN(inet) RETUN inet
MIN(integer) RETUN integer
MIN(interval) RETUN interval
MIN(money) RETUN money
MIN(numeric) RETUN numeric
MIN(oid) RETUN oid
MIN(pg_lsn) RETUN pg_lsn
MIN(real) RETUN real
MIN(smallint) RETUN smallint
MIN(text) RETUN text
MIN(tid) RETUN tid
MIN(timestamp without time zone) RETUN timestamp without time zone
MIN(timestamp with time zone ) RETUN timestamp with time zone
MIN(time without time zone ) RETUN time without time zone
MIN(time with time zone) RETUN time with time zone

一般规则：

函数返回一个分组中的所有指定的值中的最小值。
支持的列的类型包含array、enum、bigint、date等共计21种类型

示例：

#求销售员工工资中最低的工资
lightdb@mysqltest=# SELECT MIN(sal) FROM EMP WHERE EMP.JOB='SALESMAN';
   min
---------
 1250.00
(1 row)

5.12.6. STDDEV()

函数作用：获取样本标准差。

语法：

STDDEV(bigint) RETUN numeric
STDDEV(double precision) RETUN double precision
STDDEV(integer) RETUN numeric
STDDEV(numeric) RETUN numeric
STDDEV(real) RETUN double precision
STDDEV(smallint) RETUN numeric

一般规则：

函数返回所有非 null 输入值的样本标准差。
STDDEV() 函数只处理那些非 null 的值。也就是说, null 值会被STDDEV()函数忽略。
支持的列的类型包含bigint、double precision、integer、numeric、real、smallint类型.详见上面列举的类型。

示例：

#求销售员工的月工资的标准差
lightdb@mysqltest=# SELECT STDDEV(SAL) FROM EMP WHERE EMP.JOB='SALESMAN';
          stddev
------------------
 177.951304200522
(1 row)

5.12.7. STDDEV_POP()

函数作用：获取样本总体标准差。

语法：

STDDEV_POP(bigint) RETUN numeric
STDDEV_POP(double precision) RETUN double precision
STDDEV_POP(integer) RETUN numeric
STDDEV_POP(numeric) RETUN numeric
STDDEV_POP(real) RETUN double precision
STDDEV_POP(smallint) RETUN numeric

一般规则：

函数返回所有非 null 输入值的样本标准差。
STDDEV_POP() 函数只处理那些非 null 的值。也就是说, null STDDEV_POP()函数忽略。
支持的列的类型包含bigint、double precision、integer、numeric、real、smallint类型.详见上面列举的类型。

示例：

#求销售员工的月工资的总体标准差
lightdb@mysqltest=# SELECT STDDEV_POP(SAL) FROM EMP WHERE EMP.JOB='SALESMAN';
        stddev_pop
------------------
 154.110350074224
(1 row)

5.12.8. STDDEV_SAMP()

函数作用：获取样本总体标准差。

语法：

STDDEV_SAMP(bigint) RETUN numeric
STDDEV_SAMP(double precision) RETUN double precision
STDDEV_SAMP(integer) RETUN numeric
STDDEV_SAMP(numeric) RETUN numeric
STDDEV_SAMP(real) RETUN double precision
STDDEV_SAMP(smallint) RETUN numeric

一般规则：

函数返回所有非 null 输入值的样本标准差。
STDDEV_SAMP() 函数只处理那些非 null 的值。也就是说, null 值会被STDDEV_SAMP()函数忽略。
支持的列的类型包含bigint、double precision、integer、numeric、real、smallint类型.详见上面列举的类型。

示例：

#求销售员工的月工资的总体标准差
lightdb@mysqltest=# SELECT STDDEV_SAMP(SAL) FROM EMP WHERE EMP.JOB='SALESMAN';
   stddev_samp
------------------
 177.951304200522
(1 row)

5.12.9. SUM()

函数作用：返回一个分组中的所有指定的值的总和并返回。

语法：

SUM(bigint) RETUN numeric
SUM(double precision) RETUN double precision
SUM(integer) RETUN bigint
SUM(interval) RETUN interval
SUM(money) RETUN money
SUM(numeric) RETUN numeric
SUM(real) RETUN real
SUM(smallint) RETUN bigint

一般规则：

函数返回一个分组中的所有指定的值的总和。
支持的列的类型包含bigint、double precision、integer等共计8种类型.详见上面列举的类型。

示例：

#求销售员工的月工资总额
lightdb@mysqltest=# SELECT SUM(sal) FROM EMP WHERE EMP.JOB='SALESMAN';
   sum
---------
 5600.00
(1 row)

5.12.10. VAR_POP()

函数作用：计算所有非 null 输入值的总体方差（总体标准差的平方）。

语法：

VAR_POP(bigint) RETUN numeric
VAR_POP(double precision) RETUN double precision
VAR_POP(integer) RETUN numeric
VAR_POP(numeric) RETUN numeric
VAR_POP(real) RETUN double precision
VAR_POP(smallint) RETUN numeric

一般规则：

函数返回所有非 null 输入值的总体方差（总体标准差的平方）。
VAR_POP() 函数只处理那些非 null 的值。也就是说, null VAR_POP()函数忽略。
支持的列的类型包含bigint、double precision、integer、numeric、real、smallint类型.详见上面列举的类型。

示例：

#求销售员工的月工资的总体方差
lightdb@mysqltest=# SELECT VAR_POP(SAL) FROM EMP WHERE EMP.JOB='SALESMAN';
          var_pop
--------------------
 23750.000000000000
(1 row)

5.12.11. VAR_SAMP()

函数作用：计算所有非 null 输入值的样本方差（样本标准差的平方）。

语法：

VAR_SAMP(bigint) RETUN numeric
VAR_SAMP(double precision) RETUN double precision
VAR_SAMP(integer) RETUN numeric
VAR_SAMP(numeric) RETUN numeric
VAR_SAMP(real) RETUN double precision
VAR_SAMP(smallint) RETUN numeric

一般规则：

函数返回所有非 null 输入值的样本方差。
VAR_SAMP() 函数只处理那些非 null 的值。也就是说, null VAR_SAMP()函数忽略。
支持的列的类型包含bigint、double precision、integer、numeric、real、smallint类型.详见上面列举的类型。

示例：

#求销售员工的月工资的样本方差
lightdb@mysqltest=# SELECT VAR_SAMP(SAL) FROM EMP WHERE EMP.JOB='SALESMAN';
          var_samp
--------------------
 31666.666666666667
(1 row)

5.12.12. VARIANCE()

函数作用：计算所有非 null 输入值的样本方差（样本标准差的平方）,VAR_SAMP()的别名。语法、示例详见VAR_SAMP()。

语法：

VAR_SAMP(bigint) RETUN numeric
VAR_SAMP(double precision) RETUN double precision
VAR_SAMP(integer) RETUN numeric
VAR_SAMP(numeric) RETUN numeric
VAR_SAMP(real) RETUN double precision
VAR_SAMP(smallint) RETUN numeric

一般规则：

函数返回所有非 null 输入值的样本方差。
VAR_SAMP() 函数只处理那些非 null 的值。也就是说, null VAR_SAMP()函数忽略。
支持的列的类型包含bigint、double precision、integer、numeric、real、smallint类型.详见上面列举的类型。

示例：

#求销售员工的月工资的样本方差
lightdb@mysqltest=# SELECT VAR_SAMP(SAL) FROM EMP WHERE EMP.JOB='SALESMAN';
          var_samp
--------------------
 31666.666666666667
(1 row)

5.13. 窗口函数

窗口函数列表概览
MySQL函数	兼容性	说明
窗口函数
CUME_DIST()	支持	累计分布值
DENSE_RANK()	支持	当前行在其分区中的排名，无间隙
FIRST_VALUE()	支持	窗口框架第一行的参数值
LAG()	支持	分区中滞后当前行的参数值
LAST_VALUE()	支持	窗口框架最后一行的参数值
LEAD()	支持	分区中当前行的参数值
NTH_VALUE()	支持	窗口框架第 N 行的参数值
NTILE()	支持	其分区中当前行的存储桶编号。
PERCENT_RANK()	支持	百分比排名值
RANK()	支持	当前行在其分区中的排名，有间隙
ROW_NUMBER()	支持	其分区中的当前行数

5.13.1. CUME_DIST()

函数作用：返回当前行的累积分布，即从第一行到与当前行值相同的最后一行的行数在分区内的总行数中的占比。

语法：

CUME_DIST()
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

一般规则：

partition_column_list: 参与分区的列的列表。order_column_list:参与排序的列的列表;
函数返回一个大于 0 并且小于等于 1 的值;
函数的返回值的计算公司为：（当前行之前的行数 + 与当前行值相同的行数）/ 分区内的总行数;

示例：

#数据准备，创建学生成绩表student_grade 以存储学生的班级和成绩
CREATE TABLE student_grade (
  id SERIAL PRIMARY KEY,
  name VARCHAR(50) NOT NULL,
  class CHAR(1) NOT NULL,
  subject VARCHAR(20) NOT NULL,
  grade INT NOT NULL
);

#插入一批学生数据
INSERT INTO student_grade
  (name, class, subject, grade)
VALUES
  ('Tim', 'A', 'Math', 9),
  ('Tom', 'A', 'Math', 7),
  ('Jim', 'A', 'Math', 8),
  ('Tim', 'A', 'English', 7),
  ('Tom', 'A', 'English', 8),
  ('Jim', 'A', 'English', 7),
  ('Lucy', 'B', 'Math', 8),
  ('Jody', 'B', 'Math', 6),
  ('Susy', 'B', 'Math', 9),
  ('Lucy', 'B', 'English', 6),
  ('Jody', 'B', 'English', 7),
  ('Susy', 'B', 'English', 8);

#LightDB CUME_DIST() 函数按科目分组计算每个学生的成绩在每组中的累积分布：
SELECT *,
  cume_dist() OVER (
        PARTITION BY subject
        ORDER BY grade
  )
FROM student_grade;

lightdb@mysqltest=#

         id | name | class | subject | grade |      cume_dist
----+------+-------+---------+-------+---------------------
 10 | Lucy | B     | English |     6 | 0.16666666666666666
 11 | Jody | B     | English |     7 |  0.6666666666666666
  6 | Jim  | A     | English |     7 |  0.6666666666666666
  4 | Tim  | A     | English |     7 |  0.6666666666666666
  5 | Tom  | A     | English |     8 |                   1
 12 | Susy | B     | English |     8 |                   1
  8 | Jody | B     | Math    |     6 | 0.16666666666666666
  2 | Tom  | A     | Math    |     7 |  0.3333333333333333
  7 | Lucy | B     | Math    |     8 |  0.6666666666666666
  3 | Jim  | A     | Math    |     8 |  0.6666666666666666
  9 | Susy | B     | Math    |     9 |                   1
  1 | Tim  | A     | Math    |     9 |                   1
(12 rows)

5.13.2. DENSE_RANK()

函数作用：返回当前行所在的分区内的排名，从 1 开始，但没有间隔。

语法：

DENSE_RANK()
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

一般规则：

partition_column_list: 参与分区的列的列表。order_column_list:参与排序的列的列表。
相同的值具有相同的排名，但是下一个不同的值的排名按顺序增加。比如，如果有 2 个第一名，那么第三位的排名是 2。

示例：

#数据准备，创建学生成绩表student_grade 以存储学生的班级和成绩,详见CUME_DIST()，不做赘述。

#LightDB DENSE_RANK() 函数查看在每个科目中每个学生按照成绩从高到低的排名：
SELECT *,
  dense_rank() OVER (
        PARTITION BY subject
        ORDER BY grade DESC
  ),
  rank() OVER (
        PARTITION BY subject
        ORDER BY grade DESC
  )
FROM student_grade;

lightdb@mysqltest=#
 id | name | class | subject | grade | dense_rank | rank
----+------+-------+---------+-------+------------+------
 12 | Susy | B     | English |     8 |          1 |    1
  5 | Tom  | A     | English |     8 |          1 |    1
 11 | Jody | B     | English |     7 |          2 |    3
  4 | Tim  | A     | English |     7 |          2 |    3
  6 | Jim  | A     | English |     7 |          2 |    3
 10 | Lucy | B     | English |     6 |          3 |    6
  1 | Tim  | A     | Math    |     9 |          1 |    1
  9 | Susy | B     | Math    |     9 |          1 |    1
  7 | Lucy | B     | Math    |     8 |          2 |    3
  3 | Jim  | A     | Math    |     8 |          2 |    3
  2 | Tom  | A     | Math    |     7 |          3 |    5
  8 | Jody | B     | Math    |     6 |          4 |    6
(12 rows)

5.13.3. FIRST_VALUE()

函数作用：从当前行关联的窗口框架的第一行中返回评估的值。

语法：

FIRST_VALUE(expr)
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

一般规则：

partition_column_list: 参与分区的列的列表。order_column_list:参与排序的列的列表。

示例：

#数据准备，创建学生成绩表student_grade 以存储学生的班级和成绩,详见CUME_DIST()，不做赘述。

#LightDB FIRST_VALUE() 函数查看在每个科目中每个学生按照成绩从高到低的排序号和每个科目中的最好成绩：
SELECT
  *,
  first_value(grade) OVER (
        PARTITION BY subject
        ORDER BY grade DESC
        RANGE BETWEEN
          UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
  ) first_grade
FROM student_grade;

lightdb@mysqltest=#
 id | name | class | subject | grade | first_grade
----+------+-------+---------+-------+-------------
 12 | Susy | B     | English |     8 |           8
  5 | Tom  | A     | English |     8 |           8
 11 | Jody | B     | English |     7 |           8
  4 | Tim  | A     | English |     7 |           8
  6 | Jim  | A     | English |     7 |           8
 10 | Lucy | B     | English |     6 |           8
  1 | Tim  | A     | Math    |     9 |           9
  9 | Susy | B     | Math    |     9 |           9
  7 | Lucy | B     | Math    |     8 |           9
  3 | Jim  | A     | Math    |     8 |           9
  2 | Tom  | A     | Math    |     7 |           9
  8 | Jody | B     | Math    |     6 |           9
(12 rows)

5.13.4. LAG()

函数作用：返回来自当前行所在的分区内当前行之前的指定行之内的行的值。

语法：

LAG(expr[, offset[, default]])
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

一般规则：

必须项 partition_column_list: 参与分区的列的列表。order_column_list:参与排序的列的列表。expr：必需的。它可以是一个列名或者表达式。
可选参数：offset 可选的。相对于当前行的偏移的行数。默认值为 1。default 可选的。它可以是一个列名或者表达式。

示例：

#数据准备，创建tax_revenue 表以存储每季度的税收收益
CREATE TABLE tax_revenue (
  id SERIAL PRIMARY KEY,
  year CHAR(4) NOT NULL,
  quarter CHAR(1) NOT NULL,
  revenue INT NOT NULL
);

#插入一批数据
INSERT INTO tax_revenue
  (year, quarter, revenue)
VALUES
  ('2022', '1', 3515),
  ('2022', '2', 3678),
  ('2022', '3', 4203),
  ('2022', '4', 3924),
  ('2023', '1', 3102),
  ('2023', '2', 3293),
  ('2023', '3', 3602),
  ('2023', '4', 2901);

#LightDB LAG() 函数，在每行中添加 next_quarter_revenue 列以比较当前季度和下一季度的收益：
SELECT *,
  lag(revenue, 1) OVER (
        PARTITION BY year
        ORDER BY quarter DESC
  ) next_quarter_revenue
FROM tax_revenue;

lightdb@mysqltest=#
 id | year | quarter | revenue | next_quarter_revenue
----+------+---------+---------+----------------------
  4 | 2022 | 4       |    3924 |
  3 | 2022 | 3       |    4203 |                 3924
  2 | 2022 | 2       |    3678 |                 4203
  1 | 2022 | 1       |    3515 |                 3678
  8 | 2023 | 4       |    2901 |
  7 | 2023 | 3       |    3602 |                 2901
  6 | 2023 | 2       |    3293 |                 3602
  5 | 2023 | 1       |    3102 |                 3293
(8 rows)

5.13.5. LAST_VALUE()

函数作用：从当前行关联的窗口框架的最后一行中返回评估的值。

语法：

LAST_VALUE(expr)
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

一般规则：

partition_column_list: 参与分区的列的列表。order_column_list:参与排序的列的列表。

示例：

#数据准备，创建学生成绩表student_grade 以存储学生的班级和成绩,详见CUME_DIST()，不做赘述。

#LightDB LAST_VALUE() 函数查看在每个科目中每个学生按照成绩从高到低的排序号和每个科目中的最好成绩：
SELECT
  *,
  last_value(grade) OVER (
        PARTITION BY subject
        ORDER BY grade DESC
        RANGE BETWEEN
          UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
  ) last_grade
FROM student_grade;

lightdb@mysqltest=#
 id | name | class | subject | grade | last_grade
----+------+-------+---------+-------+------------
 12 | Susy | B     | English |     8 |          6
  5 | Tom  | A     | English |     8 |          6
 11 | Jody | B     | English |     7 |          6
  4 | Tim  | A     | English |     7 |          6
  6 | Jim  | A     | English |     7 |          6
 10 | Lucy | B     | English |     6 |          6
  1 | Tim  | A     | Math    |     9 |          6
  9 | Susy | B     | Math    |     9 |          6
  7 | Lucy | B     | Math    |     8 |          6
  3 | Jim  | A     | Math    |     8 |          6
  2 | Tom  | A     | Math    |     7 |          6
  8 | Jody | B     | Math    |     6 |          6
(12 rows)

5.13.6. LEAD()

函数作用：返回来自当前行所在的分区内当前行之后的指定行之内的值。

语法：

LEAD(expr[, offset[, default]])
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

一般规则：

必须项 partition_column_list: 参与分区的列的列表。order_column_list:参与排序的列的列表。expr：必需的。它可以是一个列名或者表达式。
offset 可选的。相对于当前行的偏移的行数。默认值为 1。

示例：

#数据准备，创建tax_revenue 表以存储每季度的税收收益, 详见LAG（）函数，不再赘述。
ntile(buckets)
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

#LightDB NTILE() 函数，在每行中添加 last_quarter_revenue 列以比较当前季度和上一季度的收益：
SELECT *,
  lead(revenue, 1) OVER (
        PARTITION BY year
        ORDER BY quarter DESC
  ) last_quarter_revenue
FROM tax_revenue;

lightdb@mysqltest=#
 id | year | quarter | revenue | last_quarter_revenue
----+------+---------+---------+----------------------
  4 | 2022 | 4       |    3924 |                 4203
  3 | 2022 | 3       |    4203 |                 3678
  2 | 2022 | 2       |    3678 |                 3515
  1 | 2022 | 1       |    3515 |
  8 | 2023 | 4       |    2901 |                 3602
  7 | 2023 | 3       |    3602 |                 3293
  6 | 2023 | 2       |    3293 |                 3102
  5 | 2023 | 1       |    3102 |
(8 rows)

5.13.7. NTH_VALUE()

函数作用：从当前行关联的窗口框架的指定的一行中返回评估的值。

语法：

NTH_VALUE(expr, n)
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

一般规则：

必须项 partition_column_list: 参与分区的列的列表。order_column_list:参与排序的列的列表。expr：必需的。它可以是一个列名或者表达式。
可选参数：offset 可选的。相对于当前行的偏移的行数。默认值为 1。default 可选的。它可以是一个列名或者表达式。
如果指定的行不存在，此函数将返回。nth_value()NULL
nth_value(expr, 1) 等效于 first_value(expr)。

示例：

#数据准备，创建学生成绩表student_grade 以存储学生的班级和成绩,详见CUME_DIST()，不做赘述。

#LightDB NTH_VALUE() 函数,查看在每个科目中每个学生按照成绩从高到低的排序号和每个科目中的最好成绩：
SELECT
  *,
  nth_value(grade, 1) OVER (
        PARTITION BY subject
        ORDER BY grade DESC
        RANGE BETWEEN
          UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
  ) first_grade
FROM student_grade;

lightdb@mysqltest=#
 id | name | class | subject | grade | first_grade
----+------+-------+---------+-------+-------------
 12 | Susy | B     | English |     8 |           8
  5 | Tom  | A     | English |     8 |           8
 11 | Jody | B     | English |     7 |           8
  4 | Tim  | A     | English |     7 |           8
  6 | Jim  | A     | English |     7 |           8
 10 | Lucy | B     | English |     6 |           8
  1 | Tim  | A     | Math    |     9 |           9
  9 | Susy | B     | Math    |     9 |           9
  7 | Lucy | B     | Math    |     8 |           9
  3 | Jim  | A     | Math    |     8 |           9
  2 | Tom  | A     | Math    |     7 |           9
  8 | Jody | B     | Math    |     6 |           9
(12 rows)

5.13.8. NTILE()

函数作用：将当前行所在的分区内的所有行尽可能平均的分成指定数量的区间，并返回当前行所在的区间编号。。

语法：

NTILE(buckets)
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

一般规则：

必须项 partition_column_list: 参与分区的列的列表。order_column_list:参与排序的列的列表。expr：必需的。它可以是一个列名或者表达式。
每个区间， PostgreSQL 称之为一个排名桶。 NTILE() 根据指定排序为每个桶指设定排名。

示例：

#数据准备，创建tax_revenue 表以存储每季度的税收收益, 详见LAG（）函数，不再赘述。
ntile(buckets)
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

#LightDB NTILE() 函数，将每年的收益按照升序分成 2 桶：：
SELECT *,
  ntile(2) OVER (
        PARTITION BY year
        ORDER BY revenue
  )
FROM tax_revenue;

lightdb@mysqltest=#
 id | year | quarter | revenue | ntile
----+------+---------+---------+-------
  1 | 2022 | 1       |    3515 |     1
  2 | 2022 | 2       |    3678 |     1
  4 | 2022 | 4       |    3924 |     2
  3 | 2022 | 3       |    4203 |     2
  8 | 2023 | 4       |    2901 |     1
  5 | 2023 | 1       |    3102 |     1
  6 | 2023 | 2       |    3293 |     2
  7 | 2023 | 3       |    3602 |     2
(8 rows)

5.13.9. PERCENT_RANK()

函数作用：返回当前行所在的分区内的相对排名，也就是 (rank() - 1) / (分区总行数 - 1)。

语法：

PERCENT_RANK()
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

一般规则：

必须项 partition_column_list: 参与分区的列的列表。order_column_list:参与排序的列的列表。expr：必需的。它可以是一个列名或者表达式。
percent_rank() 函数返回一个介于 0 和 1 (包含) 之间的数，表示当前行所在的分区内的相对排名，其计算公式为是 (rank() - 1) / (分区总行数 - 1)。

示例：

#数据准备，创建学生成绩表student_grade 以存储学生的班级和成绩,详见CUME_DIST()，不做赘述。

#LightDB PERCENT_RANK() 函数,查看在每个科目中每个学生按照成绩从高到低的相对排名：
SELECT *,
  rank() OVER (
        PARTITION BY subject
        ORDER BY grade DESC
  ),
  percent_rank() OVER (
        PARTITION BY subject
        ORDER BY grade DESC
  )
FROM student_grade;

lightdb@mysqltest=#
 id | name | class | subject | grade | first_grade
----+------+-------+---------+-------+-------------
 12 | Susy | B     | English |     8 |           8
  5 | Tom  | A     | English |     8 |           8
 11 | Jody | B     | English |     7 |           8
  4 | Tim  | A     | English |     7 |           8
  6 | Jim  | A     | English |     7 |           8
 10 | Lucy | B     | English |     6 |           8
  1 | Tim  | A     | Math    |     9 |           9
  9 | Susy | B     | Math    |     9 |           9
  7 | Lucy | B     | Math    |     8 |           9
  3 | Jim  | A     | Math    |     8 |           9
  2 | Tom  | A     | Math    |     7 |           9
  8 | Jody | B     | Math    |     6 |           9
(12 rows)

5.13.10. RANK()

函数作用：返回当前行所在的分区内的排名，从 1 开始，但有间隔。

语法：

PERCENT_RANK()
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

一般规则：

必须项 partition_column_list: 参与分区的列的列表。order_column_list:参与排序的列的列表。expr：必需的。它可以是一个列名或者表达式。
相同的值具有相同的排名，但是下一个不同的值的排名采用 row_number() 编号。比如，如果有 2 个第一名，那么第三位的排名是 3。这与 dense_rank() 函数是不同的。

示例：

#数据准备，创建学生成绩表student_grade 以存储学生的班级和成绩,详见CUME_DIST()，不做赘述。

#LightDB RANK() 函数,查看在每个科目中每个学生按照成绩从高到低的排名：
SELECT *,
  rank() OVER (
        PARTITION BY subject
        ORDER BY grade DESC
  ),
  dense_rank() OVER (
        PARTITION BY subject
        ORDER BY grade DESC
  )
FROM student_grade;

lightdb@mysqltest=#
 id | name | class | subject | grade | rank | dense_rank
----+------+-------+---------+-------+------+------------
 12 | Susy | B     | English |     8 |    1 |          1
  5 | Tom  | A     | English |     8 |    1 |          1
 11 | Jody | B     | English |     7 |    3 |          2
  4 | Tim  | A     | English |     7 |    3 |          2
  6 | Jim  | A     | English |     7 |    3 |          2
 10 | Lucy | B     | English |     6 |    6 |          3
  1 | Tim  | A     | Math    |     9 |    1 |          1
  9 | Susy | B     | Math    |     9 |    1 |          1
  7 | Lucy | B     | Math    |     8 |    3 |          2
  3 | Jim  | A     | Math    |     8 |    3 |          2
  2 | Tom  | A     | Math    |     7 |    5 |          3
  8 | Jody | B     | Math    |     6 |    6 |          4
(12 rows)

5.13.11. ROW_NUMBER()

函数作用：返返回当前行所在的分区内的序号。

语法：

ROW_NUMBER()
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

一般规则：

必须项 partition_column_list: 参与分区的列的列表。order_column_list:参与排序的列的列表。expr：必需的。它可以是一个列名或者表达式。
ROW_NUMBER() 函数返回当前行所在的分区内的序号，从 1 开始。

示例：

#数据准备，创建学生成绩表student_grade 以存储学生的班级和成绩,详见CUME_DIST()，不做赘述。

#LightDB ROW_NUMBER() 函数,查看在每个科目中每个学生按照成绩从高到低的排序号：
SELECT *,
  row_number() OVER (
        PARTITION BY subject
        ORDER BY grade DESC
  )
FROM student_grade;

lightdb@mysqltest=#
 id | name | class | subject | grade | row_number
----+------+-------+---------+-------+------------
 12 | Susy | B     | English |     8 |          1
  5 | Tom  | A     | English |     8 |          2
 11 | Jody | B     | English |     7 |          3
  4 | Tim  | A     | English |     7 |          4
  6 | Jim  | A     | English |     7 |          5
 10 | Lucy | B     | English |     6 |          6
  1 | Tim  | A     | Math    |     9 |          1
  9 | Susy | B     | Math    |     9 |          2
  7 | Lucy | B     | Math    |     8 |          3
  3 | Jim  | A     | Math    |     8 |          4
  2 | Tom  | A     | Math    |     7 |          5
  8 | Jody | B     | Math    |     6 |          6
(12 rows)

5.14. 其他函数

其他函数列表概览
MySQL函数	LightDB函数	兼容性	说明
其他函数
ANY_VALUE()	ANY_VALUE(anyelement)	支持	抑制ONLY_FULL_GROUP_BY值拒绝
BIN_TO_UUID()	bin_to_uuid(p_uuid bytea, swap_flag int4 default 0) RETURNS uuid	支持	将二进制 UUID 转换为字符串
DEFAULT()			返回表列的默认值
GROUPING()			将超级聚合 ROLLUP 行与常规行区分开来
INET_ATON()			返回 IP 地址的数值
INET_NTOA()			从数值返回 IP 地址
INET6_ATON()			返回 IPv6 地址的数值
INET6_NTOA()			从数值返回 IPv6 地址
IS_IPV4()			参数是否为 IPv4 地址
IS_IPV4_COMPAT()			参数是否为 IPv4 兼容地址
IS_IPV4_MAPPED()			参数是否为 IPv4 映射地址
IS_IPV6()			参数是否为 IPv6 地址
IS_UUID()			参数是否为有效的 UUID
NAME_CONST()			使列具有给定的名称
SLEEP()			睡眠几秒钟
UUID()	UUID() RETURN uuid	支持	返回通用唯一标识符（UUID）
UUID_SHORT()			返回整数值通用标识符
UUID_TO_BIN()	bin_to_uuid(p_uuid bytea, swap_flag int4 default 0) RETURNS uuid	支持	将字符串 UUID 转换为二进制
VALUES()			定义在 INSERT 期间要使用的值

5.14.1. ANY_VALUE()

函数作用：为了与MySQL模式兼容，仅在BY模式下的分组行为语法。。

语法：

ANY_VALUE(anyelement)

一般规则：

此函数对于启用ONLY_FULL_GROUP_BY SQL模式的MySQL兼容GROUP BY查询非常有用，对于MySQL拒绝您知道有效的查询的情况，因为MySQL无法确定，任何值函数将返回导致歧义的第一行。函数返回值和类型与其参数的返回值和类型相同。
请注意，此行为仅是与MySQL兼容的非标准语法。它用于确保在LightDB中的执行不会报告错误，但无法保证结果与MySQL完全一致。不建议使用此功能。请使用标准语法格式。

示例：

#在以下示例中，如果id是一个非索引列，则以下查询将失败：
lightdb@mysqltest=# SELECT ENAME,JOB,MAX(sal) FROM EMP GROUP BY DEPTNO;
ERROR:  column "emp.ename" must appear in the GROUP BY clause or be used in an aggregate function
LINE 1: SELECT ENAME,JOB,MAX(sal) FROM EMP GROUP BY DEPTNO;

#使用ANY_VALUE()来引用co1和co2：
lightdb@mysqltest=# SELECT ANY_VALUE(ENAME),ANY_VALUE(JOB),MAX(sal) FROM EMP GROUP BY DEPTNO;
 any_value | any_value |   max
-----------+-----------+---------
 ALLEN     | SALESMAN  | 2850.00
 CLARK     | MANAGER   | 5000.00
 SMITH     | CLERK     | 3000.00
(3 rows)

5.14.2. BIN_TO_UUID()

函数作用：将二进制UUID转换为字符串。

语法：

bin_to_uuid(p_uuid bytea, swap_flag int4 default 0) RETURNS uuid

一般规则：

BIN_TO_UUID()是UUID_TO_BIN()的反函数。它将二进制UUID转换为字符串UUID并返回结果。二进制值应为VARBINARY(16)值的UUID。
返回值是由连字符分隔的五个十六进制数字组成的utf8字符串。（有关此格式的详细信息，请参见UUID()函数描述。）如果UUID参数为NULL，则返回值为NULL。如果任何参数无效，则会发生错误。

示例：

#将二进制UUID“\x0768a47dd355372b4926ee668b6cb443”转换为字符串“0768a47d-d355-372b-4926-ee668b6cb443”。
lightdb@mysqltest=# SELECT BIN_TO_UUID('\x0768a47dd355372b4926ee668b6cb443');
                         bin_to_uuid
--------------------------------------
 0768a47d-d355-372b-4926-ee668b6cb443
(1 row)

5.14.3. UUID()

函数作用：生成全局唯一标识符。

语法：

UUID() RETURN uuid

一般规则：

UUID是一种128位的标识符，通常由32个字符组成。

示例：

lightdb@mysqltest=# SELECT UUID();
                                 uuid
--------------------------------------
 445973cf-e375-4258-b166-36dd854640a6
(1 row)

5.14.4. UUID_TO_BIN()

函数作用：将二进制UUID转换为字符串。

语法：

bin_to_uuid(p_uuid bytea, swap_flag int4 default 0) RETURNS uuid

一般规则：

BIN_TO_UUID()是UUID_TO_BIN()的反函数。它将二进制UUID转换为字符串UUID并返回结果。二进制值应为VARBINARY(16)值的UUID。
返回值是由连字符分隔的五个十六进制数字组成的utf8字符串。（有关此格式的详细信息，请参见UUID()函数描述。）如果UUID参数为NULL，则返回值为NULL。如果任何参数无效，则会发生错误。

示例：

#将二进制UUID“\x0768a47dd355372b4926ee668b6cb443”转换为字符串“0768a47d-d355-372b-4926-ee668b6cb443”。
lightdb@mysqltest=# SELECT BIN_TO_UUID('\x0768a47dd355372b4926ee668b6cb443');
                         bin_to_uuid
--------------------------------------
 0768a47d-d355-372b-4926-ee668b6cb443
(1 row)

6. SQL语句类型

6.1. DDL语句

DDL语句列表概览
MySQL语句	LightDB语句	兼容性	说明
DDL语句
ALTER DATABASE语句	ALTER SCHEMA	支持	MySQL中的DATABASE对应LightDB的SCHEMA
ALTER EVENT 语句		不支持
ALTER FUNCTION 语句		不支持
ALTER INSTANCE 语句		不支持
ALTER LOGFILE GROUP 语句		不支持
ALTER PROCEDURE 语句		不支持
ALTER SERVER 语句		不支持
ALTER TABLE 语句		支持
ALTER TABLESPACE 语句		部分支持
ALTER VIEW 语句		支持
CREATE DATABASE 语句	CREATE SCHEMA	支持	MySQL中的DATABASE对应LightDB的SCHEMA
CREATE EVENT 语句		不支持
CREATE FUNCTION 语句		不支持
CREATE INDEX 语句		支持
CREATE LOGFILE GROUP 语句		不支持
CREATE PROCEDURE 和 CREATE FUNCTION 语句		不支持
CREATE SERVER 语句		不支持
CREATE SPATIAL REFERENCE SYSTEM 语句		不支持
CREATE TABLE 语句		支持
CREATE TABLESPACE 语句		部分支持
CREATE TRIGGER 语句		不支持
CREATE VIEW 语句		支持
DROP DATABASE 语句	DROP SCHEMA	支持	MySQL中的DATABASE对应LightDB的SCHEMA
DROP EVENT 语句		不支持
DROP FUNCTION 语句		不支持
DROP INDEX 语句		支持
DROP LOGFILE GROUP 语句		不支持
DROP PROCEDURE 和 DROP FUNCTION 语句		不支持
DROP SERVER 语句		不支持
DROP SPATIAL REFERENCE SYSTEM 声明		不支持
DROP TABLE 语句		支持
DROP TABLESPACE 语句		部分支持
DROP TRIGGER 语句		不支持
DROP VIEW 语句		支持
RENAME TABLE 语句		不支持
TRUNCATE TABLE 语句		支持

6.1.1. MysQL ddl语法(key索引,comment等)兼容

兼容mysql ddl 包括``,key索引，comment注释，collate关键字，字符集声明，engine。支持create/insert/update/delete操作。

示例：

lightdb@mysqltest=# CREATE TABLE `lt_test_mysql_ddl` (
lightdb@mysqltest(#   `name` char(64) COLLATE utf8_bin NOT NULL DEFAULT '',
lightdb@mysqltest(#   `ret` tinyint(1) NOT NULL DEFAULT '0',
lightdb@mysqltest(#   `dl` char(128) COLLATE utf8_bin NOT NULL DEFAULT '',
lightdb@mysqltest(#   -- `type` enum('function','aggregate') CHARACTER SET utf8 NOT NULL,
lightdb@mysqltest(#   PRIMARY KEY (`name`)
lightdb@mysqltest(# ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='User defined functions';
CREATE TABLE

6.1.2. ALTER DATABASE

MySQL中，ALTER DATABASE 语句可以更改数据库的总体属性。 ALTER SCHEMA是ALTER DATABASE的同义词。但在LightDB中，ALTER SCHEMA和功能和MySQL的ALTER DATABASE是一致的。下面以LightDB的ALTER SCHEMA进行说明。

语法：

ALTER SCHEMA name RENAME TO new_name
ALTER SCHEMA name OWNER TO { new_owner | CURRENT_USER | SESSION_USER }

描述：

ALTER SCHEMA更改一个模式的定义。
要使用ALTER SCHEMA，你必须拥有该模式。要重命名一个模式，你还必须拥有该数据库的CREATE特权。要更改拥有者，你还必须是新拥有角色的一个直接或者间接成员，并且该角色必须具有该数据库上的 CREATE特权（注意超级用户自动拥有所有这些特权）。

参数：

name
一个现有模式的名称。
new_name
该模式的新名称。新名称不能以pg_开始，因为这些名称被保留用于系统模式。
new_owner
该模式的新拥有者。

示例：

lightdb@mysqltest=# CREATE SCHEMA test_schema;
CREATE SCHEMA

lightdb@mysqltest=# ALTER schema test_schema RENAME TO test_sc;
ALTER SCHEMA

6.1.3. ALTER TABLE

在 LightDB 中，当我们创建好一个表之后，可能会由于业务变更或者其他原因需要修改它的结构。通过ALTER TABLE 语句修改表的定义：

语法：

ALTER TABLE name action;

描述：

其中的action表示要执行的操作。
常见的修改操作包括:添加字段、删除字段、添加约束、删除约束、修改字段默认值、修改字段数据类型、重命名字段、重命名表

示例1-添加字段：

#为表添加一个字段的语句如下：
ALTER TABLE table_name ADD COLUMN column_name data_type column_constraint;

示例2-删除字段：

#为表删除一个字段的语句如下：
ALTER TABLE table_name DROP COLUMN column_name;

示例3-添加约束：

#添加约束时通常使用表级约束语法，语句如下：
ALTER TABLE table_name ADD table_constraint;

示例4-删除约束：

#删除约束的语句如下：
ALTER TABLE table_name DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ];

示例5-修改字段默认值：

#如果想要为某个字段设置或者修改默认值，可以使用以下语句：
ALTER TABLE table_name DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ];

示例6-修改字段数据类型：

#通常来说，可以将字段的数据类型修改为兼容的类型：
ALTER TABLE table_name ALTER COLUMN column_name TYPE new_data_type;

6.1.4. ALTER支持AUTO_INCREMENT

增加带AUTO_INCREMENT属性字段的表，字段支持smallint、integer（int）、bigint类型。

示例：

lightdb@mysqltest=# create table t2(id int NOT NULL, name text);
CREATE TABLE
lightdb@mysqltest=# alter table t2 add auto_increment(id);
ALTER TABLE
lightdb@mysqltest=# \d t2
                      Table "public.t2"
Column |  Type   | Collation | Nullable |           Default
--------+---------+-----------+----------+------------------------------
id     | integer |           | not null | generated always as identity
name   | text    |

6.1.5. ALTER TABLESPACE

修改一个表空间：

语法：

ALTER TABLESPACE _name_ RENAME TO _new_name_
ALTER TABLESPACE _name_ OWNER TO _new_owner_
ALTER TABLESPACE _name_ SET ( _tablespace_option_ = _value_ [, ... ] )
ALTER TABLESPACE _name_ RESET ( _tablespace_option_ [, ... ] )

描述：

要使用ALTER TABLESPACE，你必须是该表空间的所有者。
要修改所有者，你还必须是新的所有角色的直接或间接成员。不过，超级用户自动获得这些权限

参数：

_name_
一个现有的表空间的名称。
_new_name_
表空间的新名字。新名字不能以pg_开头，因为这样的名字保留给系统表空间使用了。
_new_owner_
表空间的新所有者。
_tablespace_option_
可以设置或者重置的表空间参数。目前，可以设置的参数是seq_page_cost和random_page_cost。

示例1-表空间重命名：

#把表空间index_space重命名为fast_raid：
ALTER TABLESPACE index_space RENAME TO fast_raid;;

示例2-改变表空间index_space的所有者：

#所有者改为mary：
ALTER TABLESPACE index_space OWNER TO mary;

6.1.6. ALTER VIEW

更改视图定义。

语法：

ALTER VIEW [ IF EXISTS ] _name_ ALTER [ COLUMN ] _column_name_ SET DEFAULT _expression_
ALTER VIEW [ IF EXISTS ] _name_ ALTER [ COLUMN ] _column_name_ DROP DEFAULT
ALTER VIEW [ IF EXISTS ] _name_ OWNER TO _new_owner_
ALTER VIEW [ IF EXISTS ] _name_ RENAME TO _new_name_
ALTER VIEW [ IF EXISTS ] _name_ SET SCHEMA _new_schema_
ALTER VIEW [ IF EXISTS ] _name_ SET ( _view_option_name_ [= _view_option_value_] [, ... ] )
ALTER VIEW [ IF EXISTS ] _name_ RESET ( _view_option_name_ [, ... ] )

描述：

ALTER VIEW更改视图的各种辅助属性。
你必须是视图的所有者才可以使用ALTER VIEW。

参数：

_name_
一个已有视图的名称(可以有模式修饰) 。
IF EXISTS
使用这个选项，如果视图不存在时不会产生错误，仅有会有一个提示信息。
SET/DROP DEFAULT
这种形式设置或删除一个列的缺省值。当INSERT 和UPDATE命令的对象是视图时，使用这个选项时可以在视图相关的规则和触发器启动前，设置视图列的缺省值。视图列的缺省值也会优先于视图相关联表的列缺省值生效。
_new_owner_
视图新所有者的用户名称。
_new_name_
视图的新名称。
_new_schema_
视图的新模式。
_view_option_name_
将要设置或复位的选项名称。
_view_option_value_
视图选项的新值。

示例：

#对一个可更新视图增加缺省列：
CREATE TABLE base_table (id int, ts timestamptz);
CREATE VIEW a_view AS SELECT * FROM base_table;
ALTER VIEW a_view ALTER COLUMN ts SET DEFAULT now();
INSERT INTO base_table(id) VALUES(1);  -- ts 现在是空值
INSERT INTO a_view(id) VALUES(2);  -- ts 现在是当前时间

6.1.7. CREATE TABLE

在 LightDB 中，使用 CREATE TABLE 语句创建一个新表：

语法：

CREATE TABLE table_name
(
        column_name data_type column_constraint,
        column_name data_type,
        ...,
        table_constraint
);

描述：

指定了新表table_name的名称。

参数：

column_name
字段的名称。
data_type
字段类型。
column_constraint
是可选的字段约束；多个字段使用逗号进行分隔。
table_constraint
是可选的表级约束。

示例：

CREATE TABLE emp (
  empno    NUMBER(4) CONSTRAINT pk_emp PRIMARY KEY,
  ename    VARCHAR2(10),
  job      VARCHAR2(9),
  mgr      NUMBER(4),
  hiredate DATE,
  sal      NUMBER(7,2),
  comm     NUMBER(7,2),
  deptno   NUMBER(2)
);

lightdb@mysqltest=#
 CREATE TABLE

6.1.8. CREATE TABLE 支持AUTO_INCREMENT

创建带AUTO_INCREMENT属性字段的表，增加带AUTO_INCREMENT属性字段的表，字段支持smallint、integer（int）、bigint类型。

示例：

lightdb@mysqltest=# create table t1(id int auto_increment, name text);
CREATE TABLE
lightdb@mysqltest=# insert into t1(name) values('mm');
INSERT 0 1
lightdb@mysqltest=# insert into t1(name) values('nn');
INSERT 0 1
lightdb@mysqltest=#  select *from t1;
 id | name
----+------
  1 | mm
  2 | nn
(2 rows)

6.1.9. CREATE TABLE 支持COMMENT

注释的添加，是通过在定义表或列的时候在末尾加上 COMMENT 关键字来实现的。

示例：

lightdb@mysqltest=# CREATE TABLE employees (
lightdb@mysqltest(#     id INT AUTO_INCREMENT PRIMARY KEY,
lightdb@mysqltest(#     first_name VARCHAR(50) NOT NULL COMMENT '员工名',
lightdb@mysqltest(#     last_name VARCHAR(50) NOT NULL COMMENT '员工姓',
lightdb@mysqltest(#     email VARCHAR(100) NOT NULL UNIQUE COMMENT '员工电子邮件地址',
lightdb@mysqltest(#     birth_date DATE NOT NULL COMMENT '员工出生日期',
lightdb@mysqltest(#     hire_date DATE NOT NULL COMMENT '员工入职日期',
lightdb@mysqltest(#     department_id INT COMMENT '员工所属部门ID'
lightdb@mysqltest(# ) COMMENT='员工信息表';
CREATE TABLE

6.1.10. CREATE DATABASE

MySQL中，CREATE DATABASE 使用给定名称创建数据库。 CREATE SCHEMA是CREATE DATABASE的同义词。但在LightDB中，CREATE SCHEMA和功能和MySQL的CREATE DATABASE是一致的。下面以LightDB的CREATE SCHEMA进行说明。

语法：

CREATE SCHEMA schema_name [ AUTHORIZATION role_specification ] [ schema_element [ ... ] ]
CREATE SCHEMA AUTHORIZATION role_specification [ schema_element [ ... ] ]
CREATE SCHEMA IF NOT EXISTS schema_name [ AUTHORIZATION role_specification ]
CREATE SCHEMA IF NOT EXISTS AUTHORIZATION role_specification

#其中 role_specification 可以是：
        user_name
| CURRENT_USER
| SESSION_USER

描述：

CREATE SCHEMA输入一个新模式到当前数据库中。该模式名必须与当前数据库中任何现有模式的名称不同。

参数：

schema_name
要创建的一个模式名。如果省略， user_name将被用作模式名。该名称不能以pg_开始，因为这样的名称是用作系统模式的
user_name
将拥有新模式的用户的角色名。如果省略，默认为执行该命令的用户。要创建由另一个角色拥有的角色，你必须是那个角色的一个直接或者间接成员，或者是一个超级用户。
schema_element
要在该模式中创建的对象的定义 SQL 语句。当前，只有CREATE TABLE、CREATE VIEW、CREATE INDEX、CREATE SEQUENCE、CREATE TRIGGER以及GRANT被接受为 CREATE SCHEMA中的子句。其他类型的对象可以在模式被创建之后用单独的命令创建。
IF NOT EXISTS
如果一个具有同名的模式已经存在，则什么也不做（不过发出一个提示）。使用这个选项时不能包括 schema_element子命令。

示例：

lightdb@mysqltest=# CREATE SCHEMA IF NOT EXISTS test_schema;
CREATE SCHEMA

lightdb@mysqltest=# \dn test_schema
List of schemas
Name     |  Owner
-------------+---------
 test_schema | lightdb
(1 row)

6.1.11. CREATE INDEX

在 LightDB 中，使用 CREATE INDEX 语句创建一个新表：

语法：

CREATE INDEX index_name ON table_name
[USING method]
(column_name [ASC | DESC] [NULLS FIRST | NULLS LAST]);

描述：

CREATE INDEX 在一个指定表或者物化视图的指定列上创建一个索引,索引主要用来提高数据库的效率(尽管不合理的使用将导致较慢的效率);
索引的键字是用列名来声明的,或者在括号里面写一个表达式 .如果索引支持多列索引,我们也可以指定多个字段.

参数：

index_name
是索引的名称。
table_name
是表的名称。
method
表示索引的类型，例如 btree、hash、gist、spgist、gin 或者 brin。默认为 btree；
column_name
是字段名，ASC 表示升序排序（默认值），DESC 表示降序索引；
NULLS FIRST 和 NULLS LAST
表示索引中空值的排列顺序，升序索引时默认为 NULLS LAST 。降序索引时默认为 NULLS FIRST。

示例：

lightdb@mysqltest=# create index test_index ON products(price);
CREATE INDEX

6.1.12. CREATE TABLESPACE

定义一个新的表空间。

语法：

CREATE TABLESPACE _tablespace_name_ [ OWNER _user_name_ ] LOCATION '_directory_'

描述：

表空间允许超级用户在文件系统中定义一个可选的位置，这个位置可以存放代表数据库对象的数据文件(比如表和索引)。
一个用户，如果有合适的权限，就可以把CREATE DATABASE, CREATE TABLE, CREATE INDEX, ADD CONSTRAINT 之一传递给_tablespace_name，这样就让这些对象的数据文件存储在指定的表空间里。

参数：

_tablespace_name_
要创建的表空间的名字。这个名字不能以pg_开头，因为这些名字是保留给系统表空间使用的。
_user_name_
将拥有这个表空间的用户名。如果省略，缺省为执行此命令的用户名。只有超级用户可以创建表空间，但是他们可以把表空间的所有者授予非超级用户。
_directory_

示例：

CREATE TABLESPACE dbspace LOCATION '/data/dbs';

6.1.13. CREATE VIEW

定义一个新视图。

语法：

    CREATE [ OR REPLACE ] [ TEMP | TEMPORARY ] [ RECURSIVE ] VIEW _name_ [ ( _column_name_ [, ...] ) ]
[ WITH ( _view_option_name_ [= _view_option_value_] [, ... ] ) ]
AS _query_

描述：

CREATE VIEW定义一个查询的视图。这个视图不是物理上实际存在的，并且在该视图每次被引用的时候都会运行一次查询。
CREATE OR REPLACE VIEW类似，不过如果一个同名的视图已经存在，那么将替换它。

参数：

TEMPORARY 或 TEMP
如果声明了这个子句，那么视图就以临时视图的方式创建。临时视图在当前会话结束的时候将被自动删除。当前会话中，在临时视图存在的期间，将无法看到现有的同名关系，除非用模式修饰的名字引用它们。如果视图引用的任何基础表是临时的，那么视图将被创建为临时的 (不管是否声明了TEMPORARY)。
RECURSIVE
创建一个递归的视图
_name_
所要创建的视图名称(可以有模式修饰)。
_column_name_
一个可选的名字列表，用作视图的字段名。如果没有给出，字段名取自查询。
_query_
一个将为视图提供行和列的SELECT 或VALUES语句。

示例：

CREATE VIEW vista AS SELECT 'Hello World';

6.1.14. DROP DATABASE

MySQL中，DROP DATABASE 删除指定数据库。 DROP SCHEMA是DROP DATABASE的同义词。但在LightDB中，DROP SCHEMA和功能和MySQL的DROP DATABASE是一致的。下面以LightDB的DROP SCHEMA进行说明。

语法：

DROP SCHEMA [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]

描述：

如果该模式不存在则不要抛出一个错误，而是发出一个提示。
一个模式只能由其拥有者或一个超级用户删除。注意即使拥有者不拥有该模式中的某些对象，也能删除该模式（以及所有含有的对象）。

参数：

IF EXISTS
如果该模式不存在则不要抛出一个错误，而是发出一个提示。
name
一个模式的名称。
CASCADE
自动删除包含在该模式中的对象（表、函数等），然后删除所有依赖于那些对象的对象。
RESTRICT
如果该模式含有任何对象，则拒绝删除它。这是默认值。

示例：

DROP SCHEMA mystuff;

6.1.15. DROP INDEX

移除一个索引。

语法：

DROP INDEX [ CONCURRENTLY ] [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]

描述：

DROP INDEX从数据库系统中移除一个已有的索引。要执行这个命令你必须是该索引的拥有者。

参数：

CONCURRENTLY
删除索引并且不阻塞在索引基表上的并发选择、插入、更新和删除操作。一个普通的DROP INDEX会要求该表上的排他锁，这样会阻塞其他访问直至索引删除完成。通过这个选项，该命令会等待直至冲突事务完成。在使用这个选项时有一些需要注意的事情。只能指定一个索引名称，并且不支持CASCADE选项（因此，一个支持UNIQUE或者 PRIMARY KEY约束的索引不能以这种方式删除）。还有，常规的DROP INDEX命令可以在一个事务块内执行，而 DROP INDEX CONCURRENTLY不能。对于临时表，DROP INDEX始终是非并发的，因为没有其他会话可以访问它们，而且丢弃非并发索引更加便宜。
IF EXISTS
如果该索引不存在则不要抛出一个错误，而是发出一个提示。
name
要移除的索引的名称（可以是模式限定的）。
CASCADE
自动删除依赖于该索引的对象，然后删除所有依赖于那些对象的对象（见第 5.14 节）。
RESTRICT
如果有任何对象依赖于该索引，则拒绝删除它。这是默认值。

示例：

DROP INDEX title_idx;

6.1.16. DROP TABLE

在 LightDB 中，使用 DROP TABLE 语句创建一个新表：

语法：

DROP TABLE [ IF EXISTS ] _name_ [, ...] [ CASCADE | RESTRICT ]

描述：

从数据库中删除表或视图。只有表的者、模式所有者和超级用户才能删除一个表。要清空而不是删除表，请使用 DELETE或TRUNCATE。
总是删除目标表上现有的任何索引、规则、触发器、约束。但是，要删除一个有视图或者其它表用外键约束引用的表，必须声明CASCADE。
CASCADE将删除引用的视图，但是如果是外键约束，那么就只删除外键约束，而不是另外一个表。

参数：

IF EXISTS
如果指定的表不存在，那么发出一个 notice 而不是抛出一个错误。
_name_
要删除的现存表的名字(可以有模式修饰)。
CASCADE
要删除的现存表的名字(可以有模式修饰)。
RESTRICT
是可选的字段约束；多个字段使用逗号进行分隔。

示例：

lightdb@mysqltest=# create index test_index ON products(price);
CREATE INDEX

6.1.17. DROP TABLESPACE

删除一个表空间。

语法：

DROP SCHEMA [ IF EXISTS ] name [, ...] [ RESTRICT ]

描述：

一个表空间只能由其所有者或者超级用户删除。
在删除一个表空间之前，表空间里面不能有任何数据库对象。即使当前数据库里面已经没有任何对象在使用这个表空间了，也有可能有其它的数据库对象存留在这个表空间里。同样，如果在任何活动会话的 temp_tablespaces中列出了该表空间， DROP可能会因为临时文件存在于该表空间中而失败。

参数：

IF EXISTS
如果指定的表空间不存在，那么发出一个 notice 而不是抛出一个错误。
_name_
表空间名字。

示例：

#从系统表里删除表空间
DROP TABLESPACE mystuff;

6.1.18. DROP VIEW

删除一个视图。

语法：

DROP VIEW [ IF EXISTS ] _name_ [, ...] [ CASCADE | RESTRICT ]

描述：

从数据库中删除一个现存的视图。执行这条命令必须是视图的所有者。

参数：

IF EXISTS
如果指定的视图不存在，那么发出一个 notice 而不是抛出一个错误。
_name_
要删除的视图名称(可以有模式修饰)。
CASCADE
级联删除依赖此视图的对象(比如其它视图)。
RESTRICT
如果有依赖对象存在，则拒绝删除此视图。这个是缺省。

示例：

#下面命令将删除kinds视图：
DROP VIEW kinds;

6.1.19. TRUNCATE TABLE

TRUNCATE TABLE 用于删除表的数据，但不删除表结构。

语法：

    TRUNCATE [ TABLE ] [ ONLY ] _name_ [ * ] [, ... ]
[ RESTART IDENTITY | CONTINUE IDENTITY ] [ CASCADE | RESTRICT ]

描述：

TRUNCATE快速地从一堆表中删除所有行。它和在每个表上进行无条件的 DELETE有同样的效果，不过因为它不做表扫描，因而快得多。另外，它快速回收磁盘空间，而不是请求一个随后的操作。在大表上最有用。

参数：

_name_
要清空的表名字(可以有模式修饰)。如果在表名前声明了，那么只有那个表会被清空。如果没有声明ONLYONLY，这个表以及其所有子表（若有）会被清空。可选地,可以在表名后声明以明确指定包括子表。*
RESTART IDENTITY
截断表中的序列字段的序列值将被重置。
CONTINUE IDENTITY
不要改变序列的值。此为缺省。
CASCADE
级联清空所有在该表上有外键引用的表，或者由于而被添加到组中的表。CASCADE
RESTRICT
如果有外键引用数据并且引用表没有在命令行中列出，则拒绝清空。这是缺省。

示例：

lightdb@mysqltest=# SELECT * FROM new_products;
 product_no | name | price
------------+------+-------
                  1 | 123  |    34
(1 row)

lightdb@mysqltest=# TRUNCATE TABLE new_products;
TRUNCATE TABLE

lightdb@mysqltest=# SELECT * FROM new_products;
 product_no | name | price
------------+------+-------
(0 rows)

6.2. DML语句

DML语句列表概览
MySQL语句	兼容性	说明
DML语句
CALL 语句	支持	调用一个存储过程
DELETE 语句	支持	从表中删除行信息
DO语句	不支持	LightDB用于执行匿名块，MySQL执行一个SELECT表达式
EXCEPT 子句	支持	对两个结果集做减法。
HANDLER 语句	不支持	HANDLER语句提供对 table 存储引擎接口的直接访问。它可用于InnoDB和MyISAMtable。
IMPORT TABLE 语句	不支持	IMPORT TABLE 语句根据 .sdi（序列化字典信息）元数据文件中包含的信息导入 MyISAM 表。
INSERT…SELECT 语句	支持	将一个表中的数据插入到另一个表中
INSERT…ON DUPLICATE KEY UPDATE 语句	支持	向表中插入一条记录时，如果UNIQUE KEY（唯一索引）或PRIMARY KEY已存在，则更新记录，否则插入一条记录
INSERT 支持自增序列NULL插入	支持	支持自增序列NULL插入
INSERT ignore	支持	使用IGNORE关键字可以导致服务器将某些类型的错误降级，并生成警告而不是错误
INSERT 指定位置插入字符串	支持	在指定位置插入子字符串，直到指定的字符数。
INSERT DELAYED语句	不支持	MySQL 5.6 中已弃用；在 MySQL 5.7 中，不支持DELAYED
INTERSECT 子句	支持	计算两个结果集的交集
LOAD DATA 语句	不支持	LOAD DATA 语句读取行以非常高的速度从文本文件到表格。
LOAD XML 语句	不支持	LOAD XML语句将数据从 XML 文件读取到 table 中
带括号的查询表达式	支持
REPLACE 语句	支持	如果 table 中的旧行与PRIMARY KEY或UNIQUE索引的新行具有相同的值，则在插入新行之前删除该旧行。
SELECT … INTO语句	支持	从一个表的数据复制到另外一个表
JOIN 子句	支持	表关联子句
子查询	支持	子查询是另一个语句中的SELECT语句。
TABLE 语句	支持	TABLE是MySQL中引入的DML语句 8.0.19，返回命名表的行和列。
UPDATE 语句	支持	UPDATE 是一个 DML 语句，修改表中的行。
UNION 语句	支持	UNION 将将多个查询块合并为单个结果集
VALUES 语句	不支持	语法不一样
WITH（通用表达式）	支持

6.2.1. CALL 语句

调用一个过程

语法：

CALL name ( [ argument ] [, ...] )

描述：

CALL执行一个过程。
如果过程有任何输出参数，则会返回一个结果行，返回这些参数的值。

参数：

name
过程的名称（可以被方案限定）。
argument
过程调用的一个输入参数。

示例：

CALL do_db_maintenance();

6.2.2. DELETE 语句

删除一个表的行

语法：

        [ WITH [ RECURSIVE ] with_query [, ...] ]
DELETE FROM [ ONLY ] table_name [ * ] [ [ AS ] alias ]
        [ USING using_list ]
        [ WHERE condition | WHERE CURRENT OF cursor_name ]
        [ RETURNING * | output_expression [ [ AS ] output_name ] [, ...] ]

描述：

DELETE从指定表中删除满足子句的行。如果子句没有出现，效果将会是删除表中的所有行。结果是一个合法的空表。
有两种方式可以使用数据库中其他表中包含的信息来删除一个表的行：使用子选择或者在子句中指定额外的表。哪种技术更合适取决于特定的环境。可选的子句导致基于实际被删除的每一行计算并且返回值。任何使用被删除表列或者中提到的其他表的列的表达式都可以被计算。列表的语法和的输出列表语法相同。
要从表中删除行，你必须具有其上的特权，以及子句中任何表以及其值在condition中被读取的表上的特权。

参数：

with_query
WITH子句允许你指定一个或者多个子查询，在查询中可以用子查询的名字来引用它们。
table_name
要从其中删除行的表名（可以是模式限定的）。如果在表名前指定，只会从提到的表中删除匹配的行。如果没有指定，还会删除该表的任何继承表中的匹配行。可选地，可以在表名后面指定来显式指定要包括继承表。
alias
目标表的一个别名。提供别名时，它会完全隐藏该表的真实名称。例如，对于，语句的剩余部分都会用而不是来引用该表。
using_list
一个表表达式的列表，它允许在条件中出现来自其他表的列。这和语句的FROM 子句中指定的表列表相似。例如，可以指定表的别名。除非想要进行自连接，否则不要在using_list 再写上目标表。
condition
一个返回类型值的表达式。只有让这个表达式返回的行才将被删除。
cursor_name
要在情况中使用的游标的名称。最近一次从这个游标中取出的行将被删除。该游标必须是的目标表上的非分组查询。注意不能在使用的同时指定一个布尔条件。
output_expression
在每一行被删除后，会被计算并且返回的表达式。该表达式可以使用table_name 以及中的表的任何列。写成可以返回所有列。
output_name
被返回列的名称。

示例：

#删除足有电影，但音乐剧除外
DELETE FROM films WHERE kind <> 'Musical';

#清空表
DELETE FROM films;

6.2.3. EXCEPT子句

EXCEPT 操作符用于返回出现在第一个查询结果中，但不在第二个查询结果中的数据：

语法：

SELECT column1, column2
        FROM table1
EXCEPT [DISTINCT | ALL]
SELECT col1, col2
        FROM table2;

描述：

DISTINCT 表示将合并后的结果集进行去重；ALL 表示保留结果集中的重复记录；如果省略，默认为 DISTINCT。

示例：

#第1个查询结果中没有数字1；第二个查询结果中保留了一个数字1。
lightdb@mysqltest=# SELECT * FROM (values(1),(1),(2)) t1(n) EXCEPT SELECT * FROM (values(1),(3)) t2(n);
 n
---
 2
(1 row)

lightdb@mysqltest=# SELECT * FROM (values(1),(1),(2)) t1(n) EXCEPT ALL SELECT * FROM (values(1),(3)) t2(n);
 n
---
 1
 2
(2 rows)

6.2.4. HANDLER 语句

不支持

6.2.5. IMPORT TABLE 语句

不支持

6.2.6. INSERT…SELECT 语句

将一个表中的数据插入到另一个表中

语法：

Insert into Table2(field1,field2,…) select value1,value2,… from Table1

描述：

要求目标表Table2必须存在，由于目标表Table2已经存在，所以我们除了插入源表Table1的字段外，还可以插入常量。

示例：

lightdb@mysqltest=# create table tb100(id integer,name character varying);
CREATE TABLE
lightdb@mysqltest=# create table tb101(id integer,name character varying);
CREATE TABLE
lightdb@mysqltest=# insert into tb100 select generate_series(1,10),'aa';
INSERT 0 10

lightdb@mysqltest=# insert into tb101 select * from tb100 where id<5;
INSERT 0 4
lightdb@mysqltest=# select * from tb101;
 id | name
----+------
  1 | aa
  2 | aa
  3 | aa
  4 | aa
(4 rows)

6.2.7. INSERT…ON DUPLICATE KEY UPDATE 语句

on duplicate key update的作用是说存在重复数据则更新，不存在则插入。

示例：

lightdb@mysqltest=# create table test(
a int not null primary key,
b int not null unique,
c int not null
);
CREATE TABLE

lightdb@mysqltest=# insert into test values(1,1,1), (2,2,2);
INSERT 0 2
lightdb@mysqltest=# insert into test values(1,2,3) on duplicate key update c = c + 1;
INSERT 0 1

lightdb@mysqltest=# select *from test;
a | b | c
---+---+---
2 | 2 | 2
1 | 1 | 2
(2 rows)

6.2.8. INSERT 支持自增序列NULL插入

在MySQL中可以通过AUTO_INCREMENT关键字，实现列数据自增。一般用于单表的唯一标识列（常见的有主键）。每张表最多只能有一个自增列。Mysql的自增列支持null，当自增列插入NULL时，将设置为下一个序列值，一般就是当前最大值+1（效果等同于default）。

示例：

lightdb@mysqltest=# CREATE TABLE worker_node(id int NOT NULL AUTO_INCREMENT, host_name varchar(64) NOT NULL);
CREATE TABLE
lightdb@mysqltest=# insert into worker_node (host_name) values('hello');
INSERT 0 1
lightdb@mysqltest=# insert into worker_node values(null, 'world');
INSERT 0 1

lightdb@mysqltest=# select * from worker_node;
id | host_name
----+-----------
1 | hello
2 | world
(2 rows)

6.2.9. INSERT ignore

在MySQL兼容模式下，使用IGNORE关键字可以导致服务器将某些类型的错误降级，并生成警告而不是错误。对于多行语句，将错误降级为警告可能会使某些行得以处理。否则，使用IGNORE关键字将导致语句跳过当前行而不是中止执行。对于不可忽略的错误，无论是否使用IGNORE关键字，都会导致错误发生。

示例：

lightdb@mysqltest=# CREATE TABLE test (i INT NOT NULL PRIMARY KEY, name text);
CREATE TABLE
lightdb@mysqltest=# INSERT INTO test values(1,'xiao wang'),(2,'xiao gang'),(3,'xiao ming');
INSERT 0 3

lightdb@mysqltest=# INSERT IGNORE INTO test values(3,'xiao hong');
WARNING:  duplicate key value violates unique constraint "test_pkey"
DETAIL:  Key (i)=(3) already exists.
INSERT 0 0

6.2.10. INSERT 指定位置插入字符串

在指定位置插入子字符串，直到指定的字符数。

语法：

insert(p_source text, p_pos bigint, p_len bigint, p_replacement text) RETURNS text 1

一般规则：

返回字符串str，将从位置pos开始并长度为len的子字符串替换为newstr。
如果pos不在字符串的长度范围内，则返回原始字符串。如果len不在其余字符串的长度范围内，则从位置pos替换其余字符串。
如果任何参数为NULL，则返回NULL。

示例：

lightdb@mysqltest=# select insert('Quadratic', 3, 4, 'What');
insert
-----------
QuWhattic
(1 row)

6.2.11. INSERT DELAYED语句

不支持

6.2.12. INTERSECT 子句

INTERSECT 操作符用于返回两个查询结果中的共同部分，即同时出现在第一个查询结果和第二个查询结果中的数据：

语法：

SELECT column1, column2
        FROM table1
INTERSECT [DISTINCT | ALL]
SELECT col1, col2
        FROM table2;

描述：

DISTINCT 表示将合并后的结果集进行去重；ALL 表示保留结果集中的重复记录；如果省略，默认为 DISTINCT。

示例：

#第一个查询结果中只有一个数字 1；第二个查询虽然使用了 ALL 选项，结果也只有一个 1；第三个查询结果中有两个 1。
lightdb@mysqltest=# SELECT * FROM (values(1),(2)) t1(n) intersect SELECT * FROM (values(1),(3)) t2(n);
 n
---
 1
(1 row)

lightdb@mysqltest=# SELECT * FROM (values(1),(1),(2)) t1(n) intersect all SELECT * FROM (values(1),(3)) t2(n);
 n
---
 1
(1 row)

lightdb@mysqltest=# SELECT * FROM (values(1),(1),(2)) t1(n) intersect all SELECT * FROM (values(1),(1),(3)) t2(n);
 n
---
 1
 1
(2 rows)

6.2.13. LOAD DATA 语句

不支持

6.2.14. LOAD XML 语句

不支持

6.2.15. 带括号的查询表达式

支持

6.2.16. REPLACE 语句

在MySQL数据库中，replace与insert类似，但是REPLACE在插入数据之前，如果新行的主键值或唯一索引列值与旧行相同，则会先删除旧行，再插入新行。否则就等价于insert into。它是MySQL的专属语法，是对SQL标准的扩展。

语法：

    REPLACE [LOW_PRIORITY | DELAYED]
[INTO] tbl_name
[PARTITION (partition_name [, partition_name] ...)]
[(col_name [, col_name] ...)]
{VALUES | VALUE} (value_list) [, (value_list)] ...

描述：

示例：

lightdb@mysqltest=# create table test ( col1 int not null, col2 char(16) unique, col3 int, col4 int, primary key(col1) );
CREATE TABLE

lightdb@mysqltest=# insert into test values(1,'STR 1'), (2, 'STR 2'), (3, 'STR 3'), (4, 'STR 4'), (6, 'STR 6');
INSERT 0 5

lightdb@mysqltest=# replace into test values (1, 'STR M');
INSERT 0 1

lightdb@mysqltest=# select * from test;
col1 |       col2       | col3 | col4
------+------------------+------+------
2 | STR 2            |      |
3 | STR 3            |      |
4 | STR 4            |      |
6 | STR 6            |      |
1 | STR M            |      |
(5 rows)

6.2.17. SELECT … INTO语句

将一个表中的数据插入到另一个表中

语法：

SELECT vale1, value2 into Table2 from Table1

描述：

要求目标表Table2必须存在，由于目标表Table2已经存在，所以我们除了插入源表Table1的字段外，还可以插入常量。

示例：

lightdb@mysqltest=# create table tb100(id integer,name character varying);
CREATE TABLE

lightdb@mysqltest=#  select * into tb101 from tb100 where id<5;
SELECT 4
lightdb@mysqltest=# select * from tb101;
 id | name
----+------
  1 | aa
  2 | aa
  3 | aa
  4 | aa
(4 rows)

6.2.18. JOIN子句

LightDB中的连接语句，包括交叉连接、内连接、自然连接、左连接、右连接、全连接。JOIN 语句用于将数据库中的两个表或者多个表连接起来。

语法：LightDB支持以下类型的连接

交叉连接 (CROSS JOIN)
内联接 (INNER JOIN)
自然连接 (NATURAL JOIN)
左连接/左外连接 (LEFT [OUTER] JOIN)
右连接/右外连接 (RIGHT [OUTER] JOIN)
全连接/全外连接 (RIGHT [OUTER] JOIN)

示例（以表内连接为例）：

#使用下面的 SQL 语句创建表 student 和 student_score ：
CREATE TABLE student (
  student_id INTEGER NOT NULL,
  name varchar(45) NOT NULL,
  PRIMARY KEY (student_id)
);

CREATE TABLE student_score (
  student_id INTEGER NOT NULL,
  subject varchar(45) NOT NULL,
  score INTEGER NOT NULL
);

#分别在两个表中插入数据：
INSERT INTO
  student (student_id, name)
VALUES
  (1,'Tim'),(2,'Jim'),(3,'Lucy');

INSERT INTO
  student_score (student_id, subject, score)
VALUES
  (1,'English',90),
  (1,'Math',80),
  (2,'English',85),
  (5,'English',92);

#以下 SQL 语句将 student 表和 student_score 表内连接，以查找有效的学生成绩信息：
SELECT
  student.*,
  student_score.*
FROM
  student
  INNER JOIN student_score
  ON student.student_id = student_score.student_id;

lightdb@mysqltest=#
 student_id | name | student_id | subject | score
------------+------+------------+---------+-------
                  1 | Tim  |          1 | English |    90
                  1 | Tim  |          1 | Math    |    80
                  2 | Jim  |          2 | English |    85
(3 rows)

6.2.19. 子查询

支持

6.2.20. TABLE 语句

TABLE是MySQL中引入的DML语句 8.0.19，返回命名表的行和列。

语法：

TABLE table_name [ORDER BY column_name] [LIMIT number [OFFSET number]]

描述：

该语句在某些方面类似于 SELECT。鉴于存在一个表中，有以下两条语句产生相同的输出。

示例：

lightdb@mysqltest=# CREATE TABLE t(id1 int, id2 int);
CREATE TABLE
lightdb@mysqltest=# INSERT INTO t VALUES(1,2),(6,7),(9,5),(10,-4),(11,-1),(13,3),(14,6);
INSERT 0 7
lightdb@mysqltest=# TABLE t;
id1 | id2
-----+-----
   1 |   2
   6 |   7
   9 |   5
  10 |  -4
  11 |  -1
  13 |   3
  14 |   6
(7 rows)

lightdb@mysqltest=# TABLE t ORDER BY id2;
 id1 | id2
-----+-----
  10 |  -4
  11 |  -1
   1 |   2
  13 |   3
   9 |   5
  14 |   6
   6 |   7
(7 rows)

6.2.21. UPDATE 语句

UPDATE 是一个 DML 语句，修改表中的行。

语法：

[ WITH [ RECURSIVE ] _with_query_ [, ...] ]
UPDATE [ ONLY ] _table_name_ [ * ] [ [ AS ] _alias_ ]
        SET { _column_name_ = { _expression_ | DEFAULT } |
                  ( _column_name_ [, ...] ) = ( { _expression_ | DEFAULT } [, ...] ) } [, ...]
        [ FROM _from_list_ ]
        [ WHERE _condition_ | WHERE CURRENT OF _cursor_name_ ]
        [ RETURNING * | _output_expression_ [ [ AS ] _output_name_ ] [, ...] ]

描述：

UPDATE改变满足条件的所有行中指定的字段值。只在SET子句中出现需要修改的行，没有出现的其他字段保持它们原来的数值。使用同一数据库里其它表的信息来更新一个表有两种方法：使用子查询，或者在FROM子句里声明另外一个表。哪个方法更好取决于具体的环境。
可选的RETURNING子句将导致UPDATE基于每个被更新的行计算返回值。任何使用表的字段的表达式或FROM中使用的其他表的字段都可以用于计算。计算的时候使用刚刚被更新过的字段新值。RETURNING 列表的语法与SELECT的输出列表相同。
你必须对表或至少在列出的要被更新的字段上有UPDATE权限，同样在expressions 或condition条件里提到的任何字段上也要有SELECT权限。

参数：

_with_query_
WITH子句允许声明一个或多个可以在UPDATE 查询中通过名字引用的子查询。参阅Section 7.8 和 SELECT获取详细信息。
_table_name_
要更新的表的名称(可以有模式修饰)。如果在表名前声明了ONLY，那么只在该表中更新匹配的行。如果没有声明ONLY，那么该表的任何继承表内的匹配行也要更新。可选的，可以在表名后面声明*以明确表明包含后代表。
_alias_
目标表的别名。如果指定了别名，那么它将完全遮盖表的本名。例如，给定 UPDATE foo AS f之后，剩余的UPDATE 语句必须用f而不是foo引用这个表。
_column_name_
表_table_name_中的字段名。必要时，字段名可以用子域名或者数组下标修饰。不要在指定字段名的时候加上表名字。比如UPDATE tab SET tab.col = 1就是错误的。
_expression_
给字段赋值的表达式。表达式可以使用这个或其它字段更新前的旧值。
DEFAULT
把字段设置为它的缺省值，如果没有缺省表达式，那么就是 NULL。
_from_list_
一个表表达式的列表，允许来自其它表中的字段出现在WHERE条件里和更新表达式中。这个类似于可以在一个SELECT语句的FROM 子句子句里声明表列表。请注意目标表绝对不能出现在_from_list_里，除非你是在使用一个自连接(此时它必须以_from_list_的别名出现)。
_condition_
一个返回boolean结果的表达式。只有这个表达式返回true的行才会被更新。
_cursor_name_
在WHERE CURRENT OF条件下使用的游标的名称。要更新的行是最近从该游标中抓去的行。该游标必须是一个UPDATE目标表中的非分组查询。请注意WHERE CURRENT OF 不能与布尔条件一起声明。参阅DECLARE获取更多关于通过 WHERE CURRENT OF使用游标的信息。
_output_expression_
在所有需要更新的行都被更新之后，UPDATE命令用于计算返回值的表达式。这个表达式可以使用任何table_name命名的表以及FROM中列出的表的字段。写上*表示返回所有字段。
_output_name_
字段的返回名称。

示例：

#把表films里的字段kind里的词 Drama用Dramatic代替：
DELETE FROM films WHERE kind <> 'Musical';

#调整表weather中的某行的温度并把该行的降水量设置为缺省值：
UPDATE weather SET temp_lo = temp_lo+1, temp_hi = temp_lo+15, prcp = DEFAULT
WHERE city = 'San Francisco' AND date = '2003-07-03';

#调整表weather中的某行的温度并把该行的降水量设置为缺省值：
UPDATE weather SET temp_lo = temp_lo+1, temp_hi = temp_lo+15, prcp = DEFAULT
WHERE city = 'San Francisco' AND date = '2003-07-03';

6.2.22. UNION 语句

UNION 操作符用于将两个查询结果合并成一个结果集，返回出现在第一个查询或者出现在第二个查询中的数据。

语法：

SELECT column1, column2
        FROM table1
UNION [DISTINCT | ALL]
SELECT col1, col2
        FROM table2;

描述：

DISTINCT 表示将合并后的结果集进行去重；ALL 表示保留结果集中的重复记录；如果省略，默认为 DISTINCT。

示例：

#第一个查询结果中只有一个数字 1，第二个查询结果中保留了重复的数字 1。
lightdb@mysqltest=# SELECT * FROM (values(1),(2)) t1(n) union SELECT * FROM (values(1),(3)) t2(n);
 n
---
 1
 2
 3
(3 rows)

lightdb@mysqltest=# SELECT * FROM (values(1),(2)) t1(n) union all SELECT * FROM (values(1),(3)) t2(n);
 n
---
 1
 2
 1
 3
(4 rows)

6.2.23. VALUES 语句

不支持

6.2.24. WITH（通用表表达式）

支持

6.3. 事务语句和锁定语句

事务语句和锁定语句列表概览
MySQL语句	兼容性	说明
事务语句和锁定语句
START TRANSACTION、COMMIT 和 ROLLBACK 语句	支持	开启、提交、回滚一个事务
SAVEPOINT、ROLLBACK TO SAVEPOINT 和 RELEASE SAVEPOINT 语句	支持	SAVEPOINT语句：这个语句用于在一个事务中设置一个命名的savepoint； ROLLBACK TO SAVEPOINT语句：这个语句用于将事务回滚到指定的savepoint； RELEASE SAVEPOINT语句：这个语句用于从当前事务的savepoints集合中删除指定的savepoint；
LOCK INSTANCE FOR BACKUP 和 UNLOCK INSTANCE 语句	不支持	备份锁的获取和释放。
LOCK TABLES 和 UNLOCK TABLES 语句	不支持	表锁的获取和释放。LightDB的语法是LOCK TABLE，和MySQL不一致
SET TRANSACTION 语句	支持	设置当前事务的特性
XA 事务	不支持

6.3.1. START TRANSACTION

开启一个事务块

语法：

START TRANSACTION [ transaction_mode [, ...] ]

其中 transaction_mode 是下列之一：

        ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
        READ WRITE | READ ONLY
        [ NOT ] DEFERRABLE

描述：

这个命令开始一个新的事务块。如果指定了隔离级别、读写模式或者可延迟模式，新的事务将会具有这些特性，就像执行了 SET TRANSACTION一样。
这和 BEGIN命令一样。

参数：可用的事务特性是事务隔离级别、事务访问模式（读/写或只读）以及可延迟模式。一个事务的隔离级别决定当其他事务并行运行时该事务能看见什么数据：

READ COMMITTED
一个语句只能看到在它开始前提交的行。这是默认值。
REPEATABLE READ
当前事务的所有语句只能看到这个事务中执行的第一个查询或者数据修改语句之前提交的行。
SERIALIZABLE
当前事务的所有语句只能看到这个事务中执行的第一个查询或者数据修改语句之前提交的行。如果并发的可序列化事务间的读写模式可能导致一种那些事务串行（一次一个）执行时不可能出现的情况，其中之一将会被回滚并且得到一个 serialization_failure错误。

示例：

#一个开启事务，ROLLBACK事务的例子
lightdb@mysqltest=# CREATE TABLE custmers(name VARCHAR(20),email VARCHAR(20));
CREATE TABLE
lightdb@mysqltest=# START TRANSACTION;
START TRANSACTION

lightdb@mysqltest=*# INSERT INTO custmers (name, email) VALUES ('John Doe', 'johndoe@example.com');
INSERT 0 1
lightdb@mysqltest=*# SELECT *FROM custmers;
   name   |        email
----------+---------------------
 John Doe | johndoe@example.com
(1 row)

lightdb@mysqltest=*# ROLLBACK;
ROLLBACK

lightdb@mysqltest=# SELECT * FROM custmers;
 name | email
------+-------
(0 rows)

#一个开启事务，COMMIT事务的例子
lightdb@mysqltest=# CREATE TABLE custmers(name VARCHAR(20),email VARCHAR(20));
CREATE TABLE
lightdb@mysqltest=# START TRANSACTION;
START TRANSACTION

lightdb@mysqltest=*# INSERT INTO custmers (name, email) VALUES ('John Doe', 'johndoe@example.com');
INSERT 0 1

lightdb@mysqltest=*# commit;
COMMIT
lightdb@mysqltest=*# SELECT *FROM custmers;
name   |        email
----------+---------------------
John Doe | johndoe@example.com
(1 row)

6.3.2. ROLLBACK

中止当前事务

语法：

ROLLBACK [ WORK | TRANSACTION ] [ AND [ NO ] CHAIN ]

描述：

WORK TRANSACTION
可选关键词，没有效果。
AND CHAIN
如果指定了AND CHAIN，则立即启动与刚刚完成事务具有相同事务特征（参见 SET TRANSACTION）的新事务。否则，不会启动任何新事务。

示例：

#参考START TRANSACTION例子

6.3.3. COMMIT

提交当前事务

语法：

COMMIT [ WORK | TRANSACTION ] [ AND [ NO ] CHAIN ]

描述：

WORK TRANSACTION
可选关键词，没有效果。
AND CHAIN
如果指定了AND CHAIN，则立即启动与刚刚完成事务具有相同事务特征（参见 SET TRANSACTION）的新事务。否则，不会启动任何新事务。

示例：

#参考START TRANSACTION例子

6.3.4. ROLLBACK

中止当前事务

语法：

ROLLBACK [ WORK | TRANSACTION ] [ AND [ NO ] CHAIN ]

描述：

WORK TRANSACTION
可选关键词，没有效果。
AND CHAIN
如果指定了AND CHAIN，则立即启动与刚刚完成事务具有相同事务特征（参见 SET TRANSACTION）的新事务。否则，不会启动任何新事务。

示例：

#参考START TRANSACTION例子

6.3.5. START TRANSACTION

设置当前事务的特性

语法：

SET TRANSACTION transaction_mode [, ...]
SET TRANSACTION SNAPSHOT snapshot_id
SET SESSION CHARACTERISTICS AS TRANSACTION transaction_mode [, ...]

其中 transaction_mode 是下列之一：

        ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
        READ WRITE | READ ONLY
        [ NOT ] DEFERRABLE

描述：

SET TRANSACTION命令设置当前会话的特性。SET SESSION CHARACTERISTICS设置一个会话后续事务的默认事务特性。在个体事务中可以用 SET TRANSACTION覆盖这些默认值；
可用的事务特性是事务隔离级别、事务访问模式（读/写或只读）以及可延迟模式。此外，可以选择一个快照，不过只能用于当前事务而不能作为会话默认值；
一个事务的隔离级别决定当其他事务并行运行时该事务能看见什么数据；

参数：

READ COMMITTED
一个语句只能看到在它开始前提交的行。这是默认值。
REPEATABLE READ
当前事务的所有语句只能看到这个事务中执行的第一个查询或者数据修改语句之前提交的行。
SERIALIZABLE
当前事务的所有语句只能看到这个事务中执行的第一个查询或者数据修改语句之前提交的行。如果并发的可序列化事务间的读写模式可能导致一种那些事务串行（一次一个）执行时不可能出现的情况，其中之一将会被回滚并且得到一个 serialization_failure错误。

其他说明：

SQL 标准定义了一种额外的级别：READ UNCOMMITTED。在 PostgreSQL中READ UNCOMMITTED被视作 READ COMMITTED。
一个事务执行了第一个查询或者数据修改语句（ SELECT、 INSERT、DELETE、 UPDATE、FETCH或 COPY）之后就无法更改事务隔离级别。更多有关事务隔离级别和并发控制的信息可见第 13 章。
事务的访问模式决定该事务是否为读/写或者只读。读/写是默认值。当一个事务为只读时，如果 SQL 命令 INSERT、UPDATE、 DELETE和COPY FROM 要写的表不是一个临时表，则它们不被允许。不允许 CREATE、ALTER以及 DROP命令。不允许COMMENT、 GRANT、REVOKE、 TRUNCATE。如果EXPLAIN ANALYZE 和EXECUTE要执行的命令是上述命令之一，则它们也不被允许。这是一种高层的只读概念，它不能阻止所有对磁盘的写入。
只有事务也是SERIALIZABLE以及 READ ONLY时，DEFERRABLE 事务属性才会有效。当一个事务的所有这三个属性都被选择时，该事务在第一次获取其快照时可能会阻塞，在那之后它运行时就不会有 SERIALIZABLE事务的开销并且不会有任何牺牲或者被一次序列化失败取消的风险。这种模式很适合于长时间运行的报表或者备份。
SET TRANSACTION SNAPSHOT命令允许新的事务使用与一个现有事务相同的快照运行。已经存在的事务必须已经把它的快照用pg_export_snapshot函数（见第 9.26.5 节）导出。该函数会返回一个快照标识符，SET TRANSACTION SNAPSHOT需要被给定一个快照标识符来指定要导入的快照。在这个命令中该标识符必须被写成一个字符串，例如 ‘000003A1-1’。 SET TRANSACTION SNAPSHOT只能在一个事务的开始执行，并且要在该事务的第一个查询或者数据修改语句（ SELECT、 INSERT、DELETE、 UPDATE、FETCH或 COPY）之前执行。此外，该事务必须已经被设置为SERIALIZABLE或者 REPEATABLE READ隔离级别（否则，该快照将被立刻抛弃，因为READ COMMITTED模式会为每一个命令取一个新快照）。如果导入事务使用了SERIALIZABLE隔离级别，那么导入快照的事务必须也使用该隔离级别。还有，一个非只读可序列化事务不能导入来自只读事务的快照。

示例：

#要用一个已经存在的事务的同一快照开始一个新事务，首先要从该现有 事务导出快照。这将会返回快照标识符，例如：
lightdb@mysqltest=# BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ;
BEGIN
lightdb@mysqltest=*# SELECT pg_export_snapshot();
 pg_export_snapshot
---------------------
 00000006-00004E2C-1
(1 row)

#然后在一个新开始的事务的开头把该快照标识符用在一个 SET TRANSACTION SNAPSHOT命令中：
BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ;
SET TRANSACTION SNAPSHOT '00000006-00004E2C-1';

6.3.6. SAVEPOINT语句

在当前事务中定义一个新的保存点

语法：

SAVEPOINT savepoint_name

描述：

SAVEPOINT在当前事务中建立一个新保存点。
SAVEPOINT是事务内的一种特殊标记，它允许所有在它被建立之后执行的命令被回滚，把该事务的状态恢复到它处于保存点时的样子。

参数：

savepoint_name
给新保存点的名字。

其他说明：

使用ROLLBACK TO SAVEPOINT回滚到一个保存点。使用RELEASE SAVEPOINT销毁一个保存点，但保持在它被建立之后执行的命令的效果。
保存点只能在一个事务块内建立。可以在一个事务内定义多个保存点。

示例：

#要建立一个保存点并且后来撤销在它建立之后执行的所有命令的效果：
lightdb@mysqltest=# BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ;
BEGIN
lightdb@mysqltest=*# SELECT pg_export_snapshot();
 pg_export_snapshot
---------------------
 00000006-00004E2C-1
(1 row)

#建立一个保存点并且后来撤销在它建立之后执行的所有命令的效果，下面的事务将插入值 1 和 3，但不会插入 2。
lightdb@mysqltest=# CREATE TABLE table1(id int);
CREATE TABLE

lightdb@mysqltest=# BEGIN;
BEGIN
lightdb@mysqltest=*#INSERT INTO table1 VALUES (1);
lightdb@mysqltest=*#SAVEPOINT my_savepoint;
lightdb@mysqltest=*#INSERT INTO table1 VALUES (2);
lightdb@mysqltest=*#ROLLBACK TO SAVEPOINT my_savepoint;
lightdb@mysqltest=*#INSERT INTO table1 VALUES (3);
lightdb@mysqltest=*# COMMIT;

lightdb@mysqltest=# SELECT * FROM table1;
 id
----
  1
  3
(2 rows)

.. code:: shell

#建立并且稍后销毁一个保存点。
lightdb@mysqltest=# BEGIN;
BEGIN

lightdb@mysqltest=*#INSERT INTO table1 VALUES (3);
lightdb@mysqltest=*#SAVEPOINT my_savepoint;
lightdb@mysqltest=*#INSERT INTO table1 VALUES (4);
lightdb@mysqltest=*#RELEASE SAVEPOINT my_savepoint;
lightdb@mysqltest=*#COMMIT;
COMMIT

lightdb@mysqltest=#SELECT * FROM table1;
 id
----
  1
  3
  3
  4
(4 rows)

6.3.7. ROLLBACK TO SAVEPOINT语句

回滚到一个保存点

语法：

ROLLBACK [ WORK | TRANSACTION ] TO [ SAVEPOINT ] savepoint_name

描述：

回滚在该保存点被建立之后执行的所有命令。该保存点保持有效并且可以在以后再次回滚到它（如果需要）。
ROLLBACK TO SAVEPOINT隐式地销毁在所提及的保存点之后建立的所有保存点。

参数：

savepoint_name
要回滚到的保存点。

其他说明：

使用RELEASE SAVEPOINT销毁一个保存点而不抛弃在它建立之后被执行的命令的效果。
指定一个没有被建立的保存点是一种错误。
相对于保存点，游标有一点非事务的行为。在保存点被回滚时，任何在该保存点内被打开的游标将会被关闭。如果一个先前打开的游标在一个保存点内被 FETCH或MOVE命令所影响，而该该保存点后来又被回滚，那么该游标将保持FETCH使它指向的位置（也就是说由FETCH导致的游标动作不会被回滚）。回滚也不能撤销关闭一个游标。不过，其他由游标查询导致的副作用（例如被该查询所调用的易变函数的副作用）可以被回滚，只要它们发生在一个后来被回滚的保存点期间。如果一个游标的执行导致事务中止，它会被置于一种不能被执行的状态，这样当事务被用ROLLBACK TO SAVEPOINT恢复后，该游标也不再能被使用。

示例：

#例子参考SAVEPOINT语句

6.3.8. RELEASE SAVEPOINT语句

销毁一个之前定义的保存点

语法：

RELEASE [ SAVEPOINT ] savepoint_name

描述：

RELEASE SAVEPOINT销毁在当前事务中之前定义的一个保存点。
销毁一个保存点会使得它不能再作为一个回滚点，但是它没有其他用户可见的行为。它不会撤销在该保存点被建立之后执行的命令的效果（要这样做，可见ROLLBACK TO SAVEPOINT）。当不再需要一个保存点时销毁它允许系统在事务结束之前回收一些资源。
RELEASE SAVEPOINT也会销毁所有在该保存点建立之后建立的保存点。

参数：

savepoint_name
要回滚到的保存点。

其他说明：

指定一个不是之前定义的保存点名称是错误。
当事务处于中止状态时不能释放保存点。
如果多个保存点具有相同的名称，只有最近被定义的那个会被释放。

示例：

#例子参考SAVEPOINT语句

6.3.9. LOCK INSTANCE FOR BACKUP 和 UNLOCK INSTANCE 语句

不支持

6.3.10. LOCK TABLES 和 UNLOCK TABLES 语句

不支持

6.3.11. XA 事务

不支持

6.4. Replication语句

Replication语句列表概览
MySQL语句	兼容性	说明	备注
Replication语句
PURGE BINARY LOGS 语句	不支持	删除索引文件中列出的、在指定日志文件名或日期之前的所有二进制日志文件	用于控制源服务器的 SQL 语句
RESET MASTER语句	不支持	删除所有的binglog日志文件，并将日志索引文件清空，重新开始所有新的日志文件
SET sql_log_bin语句	不支持	变量控制是否为当前会话启用到二进制日志的日志记录(假定二进制日志本身已启用)。
CHANGE MASTER TO …语句	不支持	用于改变复制从服务器的连接参数，使其连接到新的源服务器并从源服务器读取数据。	用于控制副本服务器的 SQL 语句（MySQL 8.0.23及以后被弃用）
CHANGE REPLICATION FILTER 语句	不支持	在复制从服务器上设置一个或多个复制过滤规则
CHANGE REPLICATION SOURCE TO语句	不支持	用于改变复制从服务器连接和从源服务器读取数据的参数，同时也更新复制元数据存储库的内容。
RESET REPLICA 语句	不支持	使复制从服务器清除其在源服务器的二进制日志中的位置。
RESET SLAVE 语句	不支持	使复制从服务器清除其在源服务器的二进制日志中的位置。	8.0.22及以后被弃用
START REPLICA 语句	不支持	用于启动复制线程，可以同时或分别启动。
START SLAVE 语句	不支持	用于启动复制线程，可以同时或分别启动。	8.0.22及以后被弃用
STOP REPLICA 语句	不支持	停止MySQL复制线程的
STOP SLAVE 语句	不支持	停止MySQL复制线程的	8.0.22及以后被弃用
START GROUP_REPLICATION语句	不支持	启动MySQL Group Replication技术	用于控制组复制的 SQL 语句
STOP GROUP_REPLICATION语句	不支持	停止MySQL Group Replication技术

6.4.1. PURGE BINARY LOGS 语句

不支持

6.4.2. RESET MASTER语句

不支持

6.4.3. SET sql_log_bin语句

不支持

6.4.4. CHANGE MASTER TO …语句

不支持

6.4.5. CHANGE REPLICATION FILTER 语句

不支持

6.4.6. CHANGE REPLICATION SOURCE TO语句

不支持

6.4.7. RESET REPLICA 语句

不支持

6.4.8. RESET SLAVE 语句

不支持

6.4.9. START REPLICA 语句

不支持

6.4.10. START SLAVE 语句

不支持

6.4.11. STOP REPLICA 语句

不支持

6.4.12. STOP SLAVE 语句

不支持

6.4.13. START GROUP_REPLICATION语句

不支持

6.4.14. STOP GROUP_REPLICATION语句

不支持

6.5. 复合语句

复合语句列表概览
MySQL语句	兼容性	说明	备注
复合语句
BEGIN … END Compound	支持	BEGIN…END语法在存储程序（存储过程、函数、触发器和事件）中应用
DECLARE 语句	支持	用于声明局部变量、条件和处理程序，以及游标。
CASE语句	支持	为 SQL 语句增加类似于 IF-THEN-ELSE 的逻辑处理功能，可以根据不同的条件返回不同的结果
IF语句	支持	IF-THEN-ELSE 的逻辑处理功能
ITERATE语句	不支持	ITERATE 理解为 CONTINUE，意思为再次循环
LEAVE 语句	支持	跳出语句
LOOP语句	支持	循环语句
REPEAT语句	不支持	在满足特定条件的情况下重复执行一段代码块。
RETURN语句	支持	用于终止存储函数（或存储过程）的执行，并返回一个值给调用者
WHILE 语句	支持	WHILE语句是一种”当”型循环，即当满足某个条件时，会重复执行某个操作。在此之前，该操作会被重复执行。
Cursor CLOSE 语句	支持	关闭游标	Cursor
Cursor DECLARE 语句	支持	声明游标
Cursor FETCH 语句	支持	用于从与指定游标关联的SELECT语句中获取下一行。
Cursor OPEN 语句	支持	打开游标
CONDITION 语句	支持	情况语句	Condition Handling
HANDLER 语句	不支持
GET DIAGNOSTICS 语句	支持	用于获取前面执行的 SQL 语句的相关信息
RESIGNAL语句	不支持	在存储的程序(例如存储过程，存储函数，触发器)中向调用者返回错误或警告条
SIGNAL语句	不支持	在存储的程序(例如存储过程，存储函数，触发器或事件)中向调用者返回错误或警告条

6.5.1. BEGIN … END语句

BEGIN…END在存储程序（存储过程、函数、触发器）进行使用。

语法：

PL/pgSQL是一种块结构的语言。一个函数体的完整文本必须是一个块。一个块被定义为：

[ <<label>> ]
[ DECLARE
        declarations ]
BEGIN
        statements
END [ label ];

描述：

在一个块中的每一个声明和每一个语句都由一个分号终止。如上所示，出现在另一个块中的块必须有一个分号在END之后。不过最后一个结束函数体的END不需要一个分号。
如果你想要标识一个块以便在一个EXIT语句中使用或者标识在该块中声明的变量名，那么label是你唯一需要的。如果一个标签在END之后被给定，它必须匹配在块开始处的标签。
所有的关键词都是大小写无关的。除非被双引号引用，标识符会被隐式地转换为小写形式，就像它们在普通 SQL 命令中。
PL/pgSQL代码中的注释和普通 SQL 中的一样。一个双连字符（–）开始一段注释，它延伸到该行的末尾。一个/开始一段块注释，它会延伸到匹配/出现的位置。块注释可以嵌套。
一个块的语句节中的任何语句可以是一个子块。子块可以被用来逻辑分组或者将变量局部化为语句的一个小组。在子块的持续期间，在一个子块中声明的变量会掩盖外层块中相同名称的变量。但是如果你用块的标签限定外层变量的名字，你仍然可以访问它们。例如：

参数：

CREATE FUNCTION somefunc() RETURNS integer AS $$
<< outerblock >>
DECLARE
        quantity integer := 30;
BEGIN
        RAISE NOTICE 'Quantity here is %', quantity;  -- Prints 30
        quantity := 50;
        --
        -- 创建一个子块
        --
        DECLARE
                quantity integer := 80;
        BEGIN
                RAISE NOTICE 'Quantity here is %', quantity;  -- Prints 80
                RAISE NOTICE 'Outer quantity here is %', outerblock.quantity;  -- Prints 50
        END;

        RAISE NOTICE 'Quantity here is %', quantity;  -- Prints 50

        RETURN quantity;
END;
$$ LANGUAGE plpgsql;

6.5.2. DECLARE语句

在 PostgreSQL 中，DECLARE 语句用于声明变量、游标。

语法一：声明变量：

DECLARE
        variable_name data_type;
        variable_name data_type := value;
        ...

示例：

DECLARE
        customer_id INT := 1001;
        customer_name VARCHAR := 'John Doe';
BEGIN
        -- 在这里使用变量进行操作
        INSERT INTO customers (id, name) VALUES (customer_id, customer_name);
END;

语法二：声明游标：

DECLARE name [ BINARY ] [ INSENSITIVE ] [ [ NO ] SCROLL ]
        CURSOR [ { WITH | WITHOUT } HOLD ] FOR query

描述：

DECLARE允许用户创建游标，游标可以被用来在大型查询暂停时检索少量的行。游标被创建后，可以用FETCH从中取得行。
关键词BINARY、 INSENSITIVE和SCROLL 可以以任意顺序出现。

参数：

name
要创建的游标的名称。
BINARY
让游标返回二进制数据而不是返回文本格式数据。
INSENSITIVE
指示从游标中检索数据的过程不受游标创建之后在其底层表上发生的更新的影响。在PostgreSQL中，这是默认的行为。因此这个关键词没有实际效果，仅仅被用于兼容 SQL 标准。
SCROLL、NO SCROLL
SCROLL指定游标可以用非顺序（例如，反向）的方式从中检索行。根据查询的执行计划的复杂度，指定 SCROLL可能导致查询执行时间上的性能损失。 NO SCROLL指定游标不能以非顺序的方式从中检索行。默认是允许在某些情况下滚动，但这和指定 SCROLL不完全相同。详情请见注解。
WITH HOLD、WITHOUT HOLD
WITH HOLD指定该游标在创建它的事务提交之后还能被继续使用。WITHOUT HOLD指定该游标不能在创建它的事务之外使用。如果两者都没有指定，则默认为 WITHOUT HOLD。
query
用于提供该游标返回的行的SELECT或者 VALUES命令。

示例：

DECLARE
        customer_cursor CURSOR FOR SELECT id, name FROM customers;
BEGIN
        -- 在这里使用游标进行操作
        FETCH ALL FROM customer_cursor;
END;

6.5.3. CASE语句

参考本文档流控函数CASE的用法。

6.5.4. IF-THEN语句

if语句根据布尔表达式的结果确定要执行哪些语句，在PL/pgSQL中提供三种形式的的语句。

语法一（if then）：

if condition then
        statements;
end if;

描述：

如果为 true，则语句会执行中的语句。如果的计算结果为，则控制权将传递到部分之后的下一条语句。
condition if statements condition false END if。condition是一个布尔表达式，计算结果为 true 或 false。statements可以是一个或多个语句，如果为 true，它们将会被执行。它可以是任何有效的语句，甚至是另一个语句。conditionif

示例：

参见if then else例子。

语法二（if then else）：

if condition then
        statements;
else
        alternative-statements;
end if;

描述： * 如果的计算结果为 true，则语句执行分支中的语句;否则，执行另一个分支中的语句。

示例：

IF score > 60 THEN
        UPDATE students SET status = 'Pass' WHERE id = 1;
ELSE
        UPDATE students SET status = 'Fail' WHERE id = 1;
END IF;

语法三（if then elseif）-暂不支持：

if condition_1 then
        statement_1;
elseif condition_2 then
        statement_2
...
elseif condition_n then
        statement_n;
else
        else-statement;
end if;

6.5.5. ITERATE语句

不支持

6.5.6. LEAVE 语句

支持

6.5.7. LOOP语句

支持

6.5.8. REPEAT语句

不支持

6.5.9. RETURN语句

支持

6.5.10. WHILE 语句

支持

6.5.11. Cursor CLOSE 语句

支持

6.5.12. Cursor DECLARE 语句

支持

6.5.13. Cursor FETCH 语句

支持

6.5.14. Cursor OPEN 语句

支持

6.5.15. CONDITION 语句

支持

6.5.16. HANDLER 语句

不支持

6.5.17. GET DIAGNOSTICS 语句

支持

6.5.18. RESIGNAL语句

不支持

6.5.19. SIGNAL语句

不支持

6.6. Prepared语句

Prepared语句列表概览
MySQL语句	LightDB语句	兼容性	说明
Prepared语句
PREPARE…FROM 语句	PREPARE…AS	不支持	创建一个预备语句。
EXECUTE语句	EXECUTE _name_ [ ( _parameter_ [, …] ) ]	不支持	执行一个预备语句
DEALLOCATE PREPARE 语句	DEALLOCATE [ PREPARE ] { _name_ \| ALL }	不支持	释放创建的预备语句。

6.6.1. PREPARE 语句

不支持

6.6.2. EXECUTE语句

不支持

6.6.3. DEALLOCATE PREPARE 语句

不支持

6.7. 数据库管理语句

数据库管理语句列表概览
MySQL语句	兼容性	说明	备注
数据库管理语句
ALTER USER 语句	不支持	更改一个数据库账户	账户管理
CREATE ROLE 语句	不支持	创建数据库角色
CREATE USER 语句	不支持	创建新的数据库帐户。两者语法不一致。
DROP ROLE 语句	不支持	删除一个或多个角色（权限的命名集合）
DROP USER 语句	不支持	删除一个或多个MySQL帐户及其权限
GRANT语句	不支持	分配用户帐户和角色的权限和角色
RENAME USER 语句	不支持	重命名现有数据库帐户
REVOKE 语句	不支持	使系统管理员撤消权限和角色，可以从用户帐户和角色中撤消
SET DEFAULT ROLE 语句	不支持	定义默认情况下要在帐户中激活哪些帐户角色会话
SET PASSWORD 语句	不支持	将密码分配给数据库用户帐户
SET ROLE 语句	不支持	修改当前用户在当前会话中的有效权限指定其授予的哪些角色处于活动状态
ALTER RESOURCE GROUP 语句	不支持	更改现有资源组的可修改属性	资源组管理语句
CREATE RESOURCE GROUP 语句	不支持	创建一个新的资源组并分配其初始属性值。
DROP RESOURCE GROUP 语句	不支持	删除资源组
SET RESOURCE GROUP 语句	不支持	分配线程到资源组
ANALYZE TABLE 语句	不支持	此命令会对表进行统计和分析	表维护语句
CHECK TABLE 语句	不支持	检查表或错误表。CHECK TABLE 还可以检查视图是否存在问题
CHECKSUM TABLE 语句	不支持	内容的校验和的表
OPTIMIZE TABLE 语句	不支持	重新组织了表数据和关联索引数据的物理存储，以减少存储空间，提高访问时的I/O效率表
REPAIR TABLE 语句	不支持	修复一个可能损坏的表，仅适用于某些存储引擎。
CLONE 语句	不支持	在本地或从远程 MySQL 服务器实例克隆数据	clone语句
SET…FOR 语句	不支持	给变量赋值的语句	SET语句
SET CHARACTER SET 语句	不支持	为当前连接设置默认字符集
SET NAMES语句	不支持	将三个会话系统变量character_set_client，character_set_connection和character_set_results设置为给定的字符集。
SHOW BINARY LOGS 语句	不支持	显示二进制日志	show语句
SHOW BINLOG EVENTS 语句	不支持	显示二进制日志中的事件
SHOW CHARACTER SET 语句	不支持	显示字符集语句显示所有可用的字符集
SHOW COLLATION 语句	不支持	此语句列出服务器支持的排序规则。
SHOW COLUMNS 语句	不支持	显示信息关于给定表中的列。
SHOW CREATE DATABASE 语句	不支持	显示用于创建命名数据库的 CREATE DATABASE 语句
SHOW CREATE EVENT 语句	不支持	显示 CREATE EVENT 语句需要重新创建给定事件
SHOW CREATE FUNCTION 语句	不支持	返回确切的字符串可用于重新创建命名存储过程
SHOW CREATE PROCEDURE 语句	不支持	返回确切的字符串可用于重新创建命名函数过程
SHOW CREATE TABLE 语句	不支持	显示 CREATE TABLE 语句创建命名表。
SHOW CREATE TRIGGER 语句	不支持	显示 CREATE 创建命名触发器的 TRIGGER 语句
SHOW CREATE USER 语句	不支持	显示 CREATE 创建指定用户的 USER 语句
SHOW CREATE VIEW 语句	不支持	显示 CREATE 创建命名视图的 VIEW 语句。
SHOW DATABASES 语句	不支持	SHOW DATABASES 列出了服务器主机上的数据库。
SHOW ENGINE语句	不支持	显示正在运行有关存储引擎的信息。
SHOW ENGINES 语句	不支持	显示状态有关服务器存储引擎的信息。
SHOW ERRORS 语句	不支持	SHOW ERRORS 是诊断类似于 SHOW 的语句警告，只不过它只显示以下信息：错误，而不是错误、警告和注释。
SHOW EVENTS 语句	不支持	此语句显示有关事件管理器事件的信息
SHOW FUNCTION CODE 语句	不支持	此语句类似于 SHOW PROCEDURE CODE，但用于存储函数。
SHOW FUNCTION STATUS 语句	不支持	此语句类似于 SHOW PROCEDURE STATUS，但对于存储函数。
SHOW GRANTS声明	不支持	以 GRANT 语句的形式分配给数据库用户帐户或角色，该语句必须执行以复制权限和角色分配。
SHOW INDEX 语句	不支持	SHOW INDEX 返回表 index 信息。
SHOW MASTER STATUS 语句	不支持	语句提供有关二进制日志的状态信息源服务器的文件。
SHOW OPEN TABLES 语句	不支持	列举在表缓存中当前被打开的非TEMPORARY表
SHOW PLUGINS 语句	不支持	SHOW PLUGINS 显示信息关于服务器插件。
SHOW PRIVILEGES 语句	不支持	SHOW PRIVILEGES 显示 MySQL服务器支持的系统权限。
SHOW PROCEDURE CODE 语句	不支持	显示命名的内部实现的表示形式存储过程。
SHOW PROCEDURE STATUS 语句	不支持	它返回存储过程的存储过程的特征。
SHOW PROCESSLIST 语句	不支持	查看线程
SHOW PROFILE 语句	不支持	用来分析当前查询SQL语句执行的资源消耗情况的工具,可用于 SQL 调优的测量
SHOW PROFILES 语句	不支持	用来分析当前查询SQL语句执行的资源消耗情况的工具,可用于 SQL 调优的测量
SHOW RELAYLOG EVENTS 语句	不支持	显示副本的中继日志中的事件。
SHOW REPLICAS 语句	不支持	显示当前在源中注册的副本的列表。
SHOW SLAVE \| REPLICA STATUS 语句	不支持	显示当前在源中注册的副本的列表。
SHOW STATUS 语句	不支持	SHOW STATUS 提供服务器状态信息
SHOW TABLE STATUS 语句	不支持	提供了有关每个非TEMPORARY表的很多信息
SHOW TABLES 语句	不支持	显示当前数据库中所有表的名称。
SHOW TRIGGERS 语句	不支持	显示当前数据库中所有触发器的名称。
SHOW VARIABLES 语句	不支持	列出触发器当前为数据库中的表定义
SHOW WARNINGS 语句	不支持	显示有关条件的信息的语句（错误、警告和注释）导致的当前会话中的语句。
BINLOG 语句	不支持	BINLOG 是内部使用的陈述。它由 mysqlbinlog 程序生成，作为二进制日志文件。
CACHE INDEX 语句	不支持	CACHE INDEX 语句分配表索引到特定缓存。它仅适用于表，包括分区表。
FLUSH语句	不支持	FLUSH语句是用于清除或重新加载各种内部缓存、刷新表或获取锁的SQL命令。
KILL语句	不支持	终止线程
LOAD INDEX INTO CACHE语句	不支持	用于将表索引预加载到通过显式CACHE INDEX语句指定的键缓存中，否则将预加载到默认键缓存中。
RESET语句	不支持	清除各种服务器操作的状态。
RESET PERSIST 语句	不支持	RESET PERSIST 删除持久化数据中选项文件中的全局系统变量设置的目录。
RESTART 语句	不支持	停止并重新启动服务器
SHUTDOWN 语句	不支持	停止服务器

6.7.1. ALTER USER 语句

不支持

6.7.2. CREATE ROLE 语句

不支持

6.7.3. CREATE USER 语句

不支持

6.7.4. DROP ROLE 语句

不支持

6.7.5. DROP USER 语句

不支持

6.7.6. GRANT语句

不支持

6.7.7. RENAME USER 语句

不支持

6.7.8. REVOKE 语句

不支持

6.7.9. SET DEFAULT ROLE 语句

不支持

6.7.10. SET PASSWORD 语句

不支持

6.7.11. SET ROLE 语句

不支持

6.7.12. ALTER RESOURCE GROUP 语句

不支持

6.7.13. CREATE RESOURCE GROUP 语句

不支持

6.7.14. DROP RESOURCE GROUP 语句

不支持

6.7.15. SET RESOURCE GROUP 语句

不支持

6.7.16. ANALYZE TABLE 语句

不支持

6.7.17. CHECK TABLE 语句

不支持

6.7.18. CHECKSUM TABLE 语句

不支持

6.7.19. OPTIMIZE TABLE 语句

不支持

6.7.20. REPAIR TABLE 语句

不支持

6.7.21. CLONE 语句

不支持

6.7.22. SET…FOR 语句

不支持

6.7.23. SET CHARACTER SET 语句

不支持

6.7.24. SET NAMES语句

不支持

6.7.25. SHOW BINARY LOGS 语句

不支持

6.7.26. SHOW BINLOG EVENTS 语句

不支持

6.7.27. SHOW CHARACTER SET 语句

不支持

6.7.28. SHOW COLLATION 语句

不支持

6.7.29. SHOW COLUMNS 语句

不支持

6.7.30. SHOW CREATE DATABASE 语句

不支持

6.7.31. SHOW CREATE EVENT 语句

不支持

6.7.32. SHOW CREATE FUNCTION 语句

不支持

6.7.33. SHOW CREATE PROCEDURE 语句

不支持

6.7.34. SHOW CREATE TABLE 语句

不支持

6.7.35. SHOW CREATE TRIGGER 语句

不支持

6.7.36. SHOW CREATE USER 语句

不支持

6.7.37. SHOW CREATE VIEW 语句

不支持

6.7.38. SHOW DATABASES 语句

不支持

6.7.39. SHOW ENGINE语句

不支持

6.7.40. SHOW ENGINES 语句

不支持

6.7.41. SHOW ERRORS 语句

不支持

6.7.42. SHOW EVENTS 语句

不支持

6.7.43. SHOW FUNCTION CODE 语句

不支持

6.7.44. SHOW FUNCTION STATUS 语句

不支持

6.7.45. SHOW GRANTS声明

不支持

6.7.46. SHOW INDEX 语句

不支持

6.7.47. SHOW MASTER STATUS 语句

不支持

6.7.48. SHOW OPEN TABLES 语句

不支持

6.7.49. SHOW PLUGINS 语句

不支持

6.7.50. SHOW PRIVILEGES 语句

不支持

6.7.51. SHOW PROCEDURE CODE 语句

不支持

6.7.52. SHOW PROCEDURE STATUS 语句

不支持

6.7.53. SHOW PROCESSLIST 语句

不支持

6.7.54. SHOW PROFILE 语句

不支持

6.7.55. SHOW PROFILES 语句

不支持

6.7.56. SHOW RELAYLOG EVENTS 语句

不支持

6.7.57. SHOW REPLICAS 语句

不支持

6.7.58. SHOW SLAVE | REPLICA STATUS 语句

不支持

6.7.59. SHOW REPLICA STATUS 语句

不支持

6.7.60. SHOW SLAVE | REPLICA STATUS 语句

不支持

6.7.61. SHOW STATUS 语句

不支持

6.7.62. SHOW TABLE STATUS 语句

不支持

6.7.63. SHOW TABLES 语句

不支持

6.7.64. SHOW TRIGGERS 语句

不支持

6.7.65. SHOW VARIABLES 语句

不支持

6.7.66. SHOW WARNINGS 语句

不支持

6.7.67. BINLOG 语句

不支持

6.7.68. CACHE INDEX 语句

不支持

6.7.69. FLUSH语句

不支持

6.7.70. KILL语句

不支持

6.7.71. LOAD INDEX INTO CACHE语句

不支持

6.7.72. RESET语句

不支持

6.7.73. RESET PERSIST 语句

不支持

6.7.74. RESTART 语句

不支持

6.7.75. SHUTDOWN 语句

不支持

6.8. Utility语句

Utility语句列表概览
MySQL语句	兼容性	说明
Utility语句
DESCRIBE 语句	不支持	DESCRIBE 和 EXPLAIN 语句是同义词。在实践中，DESCRIBE 关键字是更常用于获取有关表结构的信息，而 EXPLAIN 用于获取查询执行计划（即对MySQL如何执行查询）。
EXPLAIN 语句	部分兼容	DESCRIBE 和 EXPLAIN 语句是同义词。
HELP语句	不支持	HELP 语句联机返回 MySQL参考手册中的信息。
USE语句	不支持	USE语句告诉MySQL 使用命名数据库作为的默认（当前）数据库

6.8.1. DESCRIBE 语句

不支持

6.8.2. EXPLAIN 语句

显示一个语句的执行计划。

语法：

EXPLAIN [ ( option [, ...] ) ] statement
EXPLAIN [ ANALYZE ] [ VERBOSE ] statement

#这里 option可以是：
ANALYZE [ boolean ]
VERBOSE [ boolean ]
COSTS [ boolean ]
BUFFERS [ boolean ]
TIMING [ boolean ]
SUMMARY [ boolean ]
FORMAT { TEXT | XML | JSON | YAML }

描述：

这个命令显示PostgreSQL计划器为提供的语句所生成的执行计划。该执行计划会显示将怎样扫描语句中引用的表 — 普通的顺序扫描、索引扫描等等 — 以及在引用多个表时使用何种连接算法来把来自每个输入表的行连接在一起。
显示中最重要的部分是估计出的语句执行代价，它是计划器对于该语句要运行多久的猜测（以任意的代价单位度量，但是习惯上表示取磁盘页面的次数）。事实上会显示两个数字：在第一行能被返回前的启动代价，以及返回所有行的总代价。对于大部分查询来说总代价是最重要的，但是在一些情景中（如EXISTS中的子查询），计划器将选择更小的启动代价来代替最小的总代价（因为执行器将在得到一行后停止）。此外，如果你用一个LIMIT子句限制返回行的数量，计划器会在终端代价之间做出适当的插值来估计到底哪个计划是真正代价最低的。
ANALYZE选项导致该语句被实际执行，而不仅仅是被计划。那么实际的运行时间统计会被显示出来，包括在每个计划结点上花费的总时间（以毫秒计）以及它实际返回的行数。这对观察计划器的估计是否与实际相近很有用。

重要：

记住当使用了ANALYZE选项时语句会被实际执行。尽管EXPLAIN将丢弃SELECT所返回的任何输出，照例该语句的其他副作用还是会发生。如果你希望在INSERT、UPDATE、DELETE、CREATE TABLE AS或者EXECUTE上使用EXPLAIN ANALYZE而不希望它们影响你的数据，可以使用下面的方法：

BEGIN;
EXPLAIN ANALYZE ...;
ROLLBACK;

只有ANALYZE和VERBOSE选项能被指定，并且必须按照上述的顺序，不要把选项列表放在圆括号内。在PostgreSQL 9.0 之前，只支持没有圆括号的语法。我们期望所有新的选项将只在圆括号语法中支持。

参数：

ANALYZE
执行命令并且显示实际的运行时间和其他统计信息。这个参数默认被设置为FALSE。
VERBOSE
显示关于计划的额外信息。特别是：计划树中每个结点的输出列列表、模式限定的表和函数名、总是把表达式中的变量标上它们的范围表别名，以及总是打印统计信息被显示的每个触发器的名称。这个参数默认被设置为FALSE。
COSTS
包括每一个计划结点的估计启动和总代价，以及估计的行数和每行的宽度。这个参数默认被设置为TRUE。
BUFFERS
包括缓冲区使用的信息。特别是：共享块命中、读取、标记为脏和写入的次数、本地块命中、读取、标记为脏和写入的次数、以及临时块读取和写入的次数。一次命中表示避免了一次读取，因为需要的块已经在缓存中找到了。共享块包含着来自于常规表和索引的数据，本地块包含着来自于临时表和索引的数据，而临时块包含着在排序、哈希、物化计划结点和类似情况中使用的短期工作数据。脏块的数量表示被这个查询改变的之前未被修改块的数量，而写入块的数量表示这个后台在查询处理期间从缓存中替换出去的脏块的数量。为一个较高层结点显示的块数包括它的所有子结点所用到的块数。在文本格式中，只会打印非零值。只有当ANALYZE也被启用时，这个参数才能使用。它的默认被设置为FALSE。
TIMING
在输出中包括实际启动时间以及在每个结点中花掉的时间。反复读取系统时钟的负荷在某些系统上会显著地拖慢查询，因此在只需要实际的行计数而不是实际时间时，把这个参数设置为FALSE可能会有用。即便用这个选项关闭结点层的计时，整个语句的运行时间也总是会被度量。只有当ANALYZE也被启用时，这个参数才能使用。它的默认被设置为TRUE。
SUMMARY
在查询计划之后包含摘要信息（例如，总计的时间信息）。当使用ANALYZE 时默认包含摘要信息，但默认情况下不包含摘要信息，但可以使用此选项启用摘要信息。使用EXPLAIN EXECUTE中的计划时间包括从缓存中获取计划所需的时间以及重新计划所需的时间（如有必要）。
FORMAT
指定输出格式，可以是 TEXT、XML、JSON 或者 YAML。非文本输出包含和文本输出格式相同的信息，但是更容易被程序解析。这个参数默认被设置为TEXT。
boolean
指定被选中的选项是否应该被打开或关闭。可以写TRUE、ON或1来启用选项，写FALSE、OFF或0禁用它。boolean值也能被忽略，在这种情况下会假定值为TRUE。
statement
你想查看其执行计划的任何SELECT、INSERT、UPDATE、DELETE、VALUES、EXECUTE、DECLARE、CREATE TABLE AS或者CREATE MATERIALIZED VIEW AS语句。

示例：

lightdb@mysqltest=# EXPLAIN SELECT * FROM foo;
                                          QUERY PLAN
-------------------------------------------------------
 Seq Scan on foo  (cost=0.00..18.40 rows=840 width=69)
(1 row)

lightdb@mysqltest=# EXPLAIN (FORMAT JSON) SELECT * FROM foo;
   QUERY PLAN
--------------------------------
 [                             +
   {                           +
         "Plan": {                 +
           "Node Type": "Seq Scan",+
           "Parallel Aware": false,+
           "Relation Name": "foo", +
           "Alias": "foo",         +
           "Startup Cost": 0.00,   +
           "Total Cost": 18.40,    +
           "Plan Rows": 840,       +
           "Plan Width": 69        +
         }                         +
   }                           +
 ]
(1 row)

6.8.3. HELP语句

不支持

6.8.4. USE语句

不支持