参考指南

原文链接：https://calcite.apache.org/docs/reference.html

该页面描述了 Calcite 的默认 SQL 解析器识别的 SQL 方言。

语法

SQL 语法采用了 BNF 风格。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214

statement:
      setStatement
  |   resetStatement
  |   explain
  |   describe
  |   insert
  |   update
  |   merge
  |   delete
  |   query

statementList:
      statement [ ';' statement ]* [ ';' ]

setStatement:
      [ ALTER { SYSTEM | SESSION } ] SET identifier '=' expression

resetStatement:
      [ ALTER { SYSTEM | SESSION } ] RESET identifier
  |   [ ALTER { SYSTEM | SESSION } ] RESET ALL

explain:
      EXPLAIN PLAN
      [ WITH TYPE | WITH IMPLEMENTATION | WITHOUT IMPLEMENTATION ]
      [ EXCLUDING ATTRIBUTES | INCLUDING [ ALL ] ATTRIBUTES ]
      [ AS JSON | AS XML | AS DOT ]
      FOR { query | insert | update | merge | delete }

describe:
      DESCRIBE DATABASE databaseName
  |   DESCRIBE CATALOG [ databaseName . ] catalogName
  |   DESCRIBE SCHEMA [ [ databaseName . ] catalogName ] . schemaName
  |   DESCRIBE [ TABLE ] [ [ [ databaseName . ] catalogName . ] schemaName . ] tableName [ columnName ]
  |   DESCRIBE [ STATEMENT ] { query | insert | update | merge | delete }

insert:
      { INSERT | UPSERT } INTO tablePrimary
      [ '(' column [, column ]* ')' ]
      query

update:
      UPDATE tablePrimary
      SET assign [, assign ]*
      [ WHERE booleanExpression ]

assign:
      identifier '=' expression

merge:
      MERGE INTO tablePrimary [ [ AS ] alias ]
      USING tablePrimary
      ON booleanExpression
      [ WHEN MATCHED THEN UPDATE SET assign [, assign ]* ]
      [ WHEN NOT MATCHED THEN INSERT VALUES '(' value [ , value ]* ')' ]

delete:
      DELETE FROM tablePrimary [ [ AS ] alias ]
      [ WHERE booleanExpression ]

query:
      values
  |   WITH [ RECURSIVE ] withItem [ , withItem ]* query
  |   {
          select
      |   selectWithoutFrom
      |   query UNION [ ALL | DISTINCT ] query
      |   query EXCEPT [ ALL | DISTINCT ] query
      |   query MINUS [ ALL | DISTINCT ] query
      |   query INTERSECT [ ALL | DISTINCT ] query
      }
      [ ORDER BY orderItem [, orderItem ]* ]
      [ LIMIT [ start, ] { count | ALL } ]
      [ OFFSET start { ROW | ROWS } ]
      [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ]

withItem:
      name
      [ '(' column [, column ]* ')' ]
      AS '(' query ')'

orderItem:
      expression [ ASC | DESC ] [ NULLS FIRST | NULLS LAST ]

select:
      SELECT [ hintComment ] [ STREAM ] [ ALL | DISTINCT ]
          { * | projectItem [, projectItem ]* }
      FROM tableExpression
      [ WHERE booleanExpression ]
      [ GROUP BY [ ALL | DISTINCT ] { groupItem [, groupItem ]* } ]
      [ HAVING booleanExpression ]
      [ WINDOW windowName AS windowSpec [, windowName AS windowSpec ]* ]
      [ QUALIFY booleanExpression ]

selectWithoutFrom:
      SELECT [ ALL | DISTINCT ]
          { * | projectItem [, projectItem ]* }

projectItem:
      expression [ [ AS ] columnAlias ]
  |   tableAlias . *

tableExpression:
      tableReference [, tableReference ]*
  |   tableExpression [ NATURAL ] [ { LEFT | RIGHT | FULL } [ OUTER ] ] JOIN tableExpression [ joinCondition ]
  |   tableExpression CROSS JOIN tableExpression
  |   tableExpression [ CROSS | OUTER ] APPLY tableExpression

joinCondition:
      ON booleanExpression
  |   USING '(' column [, column ]* ')'

tableReference:
      tablePrimary
      [ FOR SYSTEM_TIME AS OF expression ]
      [ pivot ]
      [ unpivot ]
      [ matchRecognize ]
      [ [ AS ] alias [ '(' columnAlias [, columnAlias ]* ')' ] ]

tablePrimary:
      [ [ catalogName . ] schemaName . ] tableName
      '(' TABLE [ [ catalogName . ] schemaName . ] tableName ')'
  |   tablePrimary [ hintComment ] [ EXTEND ] '(' columnDecl [, columnDecl ]* ')'
  |   [ LATERAL ] '(' query ')'
  |   UNNEST '(' expression ')' [ WITH ORDINALITY ]
  |   [ LATERAL ] TABLE '(' [ SPECIFIC ] functionName '(' expression [, expression ]* ')' ')'

columnDecl:
      column type [ NOT NULL ]

hint:
      hintName
  |   hintName '(' hintOptions ')'

hintOptions:
      hintKVOption [, hintKVOption ]*
  |   optionName [, optionName ]*
  |   optionValue [, optionValue ]*

hintKVOption:
      optionName '=' stringLiteral
  |   stringLiteral '=' stringLiteral

optionValue:
      stringLiteral
  |   numericLiteral

columnOrList:
      column
  |   '(' column [, column ]* ')'

exprOrList:
      expr
  |   '(' expr [, expr ]* ')'

pivot:
      PIVOT '('
      pivotAgg [, pivotAgg ]*
      FOR pivotList
      IN '(' pivotExpr [, pivotExpr ]* ')'
      ')'

pivotAgg:
      agg '(' [ ALL | DISTINCT ] value [, value ]* ')'
      [ [ AS ] alias ]

pivotList:
      columnOrList

pivotExpr:
      exprOrList [ [ AS ] alias ]

unpivot:
      UNPIVOT [ INCLUDING NULLS | EXCLUDING NULLS ] '('
      unpivotMeasureList
      FOR unpivotAxisList
      IN '(' unpivotValue [, unpivotValue ]* ')'
      ')'

unpivotMeasureList:
      columnOrList

unpivotAxisList:
      columnOrList

unpivotValue:
      column [ AS literal ]
  |   '(' column [, column ]* ')' [ AS '(' literal [, literal ]* ')' ]

values:
      { VALUES | VALUE } expression [, expression ]*

groupItem:
      expression
  |   '(' ')'
  |   '(' expression [, expression ]* ')'
  |   CUBE '(' expression [, expression ]* ')'
  |   ROLLUP '(' expression [, expression ]* ')'
  |   GROUPING SETS '(' groupItem [, groupItem ]* ')'

window:
      windowName
  |   windowSpec

windowSpec:
      '('
      [ windowName ]
      [ ORDER BY orderItem [, orderItem ]* ]
      [ PARTITION BY expression [, expression ]* ]
      [
          RANGE numericOrIntervalExpression { PRECEDING | FOLLOWING }
      |   ROWS numericExpression { PRECEDING | FOLLOWING }
      ]
      ')'

在 insert 中，如果 INSERT 或 UPSERT 语句未指定目标列列表，则查询必须具有与目标表相同的列数，某些一致性级别除外。

在 merge 中，至少必须存在 WHEN MATCHED 和 WHEN NOT MATCHED 子句之一。

tablePrimary 只能在某些一致性级别中包含 EXTEND 子句；在这些相同的一致性级别中，insert 中的任何列都可以由 columnDecl 替换，这与将其包含在 EXTEND 子句中具有类似的效果。

在 orderItem 中，如果 expression 是正整数 n，则表示 SELECT 子句中的第 n 项。

在查询中，count 和 start 可以分别是无符号整数字面量或值为整数的动态参数。

聚合查询是在 SELECT 子句中包含 GROUP BY 或 HAVING 子句，或包含聚合函数的查询。在聚合查询的 SELECT、HAVING 和 ORDER BY 子句中，所有表达式必须是当前组内的常量（即：由 GROUP BY 子句定义的分组常量或常量）、或者是聚合函数，或者是常量和聚合函数的组合。聚合和分组函数只能出现在聚合查询中，并且只能出现在 SELECT、HAVING 或 ORDER BY 子句中。

标量子查询是指用作表达式的子查询。如果子查询没有返回行，则值为 NULL，如果它返回多于一行，则会报错。

IN、EXISTS、UNIQUE 和标量子查询，可以出现在任何可以出现表达式的位置（例如 JOIN 的 SELECT 子句、WHERE 子句、ON 子句，或作为聚合函数的参数）。

IN、EXISTS、UNIQUE 或标量子查询可以是相关的，即：它可以引用一个封闭查询中 FROM 子句的表。

GROUP BY DISTINCT 删除重复的分组集（例如：GROUP BY DISTINCT GROUPING SETS ((a), (a, b), (a)) 等价于 GROUP BY GROUPING SETS ((a), (a, b))），GROUP BY ALL 和 GROUP BY 是等价的。

selectWithoutFrom 等价于 VALUES，但它不是标准 SQL，并且仅在某些一致性级别中允许使用。

MINUS 等价于 EXCEPT，但不是标准 SQL，仅在某些一致性级别中允许使用。

CROSS APPLY 和 OUTER APPLY 仅允许在某些一致性级别中使用。

LIMIT start, count 等价于 LIMIT count OFFSET start，但仅在某些一致性级别中允许使用。

在某些一致性级别中，OFFSET start 可能发生在 LIMIT count 之前。

VALUE 与 VALUES 等效，但不是标准 SQL，并且仅在某些一致性级别中允许使用。

关键字

以下是 SQL 关键字的列表。保留的关键字使用粗体展示。

A, ABS, ABSENT, ABSOLUTE, ACTION, ADA, ADD, ADMIN, AFTER, ALL, ALLOCATE, ALLOW, ALTER, ALWAYS, AND, ANY, APPLY, ARE, ARRAY, ARRAY_AGG, ARRAY_CONCAT_AGG, ARRAY_MAX_CARDINALITY, AS, ASC, ASENSITIVE, ASSERTION, ASSIGNMENT, ASYMMETRIC, AT, ATOMIC, ATTRIBUTE, ATTRIBUTES, AUTHORIZATION, AVG, BEFORE, BEGIN, BEGIN_FRAME, BEGIN_PARTITION, BERNOULLI, BETWEEN, BIGINT, BINARY, BIT, BLOB, BOOLEAN, BOTH, BREADTH, BY, C, CALL, CALLED, CARDINALITY, CASCADE, CASCADED, CASE, CAST, CATALOG, CATALOG_NAME, CEIL, CEILING, CENTURY, CHAIN, CHAR, CHARACTER, CHARACTERISTICS, CHARACTERS, CHARACTER_LENGTH, CHARACTER_SET_CATALOG, CHARACTER_SET_NAME, CHARACTER_SET_SCHEMA, CHAR_LENGTH, CHECK, CLASSIFIER, CLASS_ORIGIN, CLOB, CLOSE, COALESCE, COBOL, COLLATE, COLLATION, COLLATION_CATALOG, COLLATION_NAME, COLLATION_SCHEMA, COLLECT, COLUMN, COLUMN_NAME, COMMAND_FUNCTION, COMMAND_FUNCTION_CODE, COMMIT, COMMITTED, CONDITION, CONDITIONAL, CONDITION_NUMBER, CONNECT, CONNECTION, CONNECTION_NAME, CONSTRAINT, CONSTRAINTS, CONSTRAINT_CATALOG, CONSTRAINT_NAME, CONSTRAINT_SCHEMA, CONSTRUCTOR, CONTAINS, CONTAINS_SUBSTR, CONTINUE, CONVERT, CORR, CORRESPONDING, COUNT, COVAR_POP, COVAR_SAMP, CREATE, CROSS, CUBE, CUME_DIST, CURRENT, CURRENT_CATALOG, CURRENT_DATE, CURRENT_DEFAULT_TRANSFORM_GROUP, CURRENT_PATH, CURRENT_ROLE, CURRENT_ROW, CURRENT_SCHEMA, CURRENT_TIME, CURRENT_TIMESTAMP, CURRENT_TRANSFORM_GROUP_FOR_TYPE, CURRENT_USER, CURSOR, CURSOR_NAME, CYCLE, DATA, DATABASE, DATE, DATETIME, DATETIME_DIFF, DATETIME_INTERVAL_CODE, DATETIME_INTERVAL_PRECISION, DATETIME_TRUNC, DATE_DIFF, DATE_TRUNC, DAY, DAYOFWEEK, DAYOFYEAR, DAYS, DEALLOCATE, DEC, DECADE, DECIMAL, DECLARE, DEFAULT, DEFAULTS, DEFERRABLE, DEFERRED, DEFINE, DEFINED, DEFINER, DEGREE, DELETE, DENSE_RANK, DEPTH, DEREF, DERIVED, DESC, DESCRIBE, DESCRIPTION, DESCRIPTOR, DETERMINISTIC, DIAGNOSTICS, DISALLOW, DISCONNECT, DISPATCH, DISTINCT, DOMAIN, DOT, DOUBLE, DOW, DOY, DROP, DYNAMIC, DYNAMIC_FUNCTION, DYNAMIC_FUNCTION_CODE, EACH, ELEMENT, ELSE, EMPTY, ENCODING, END, END-EXEC, END_FRAME, END_PARTITION, EPOCH, EQUALS, ERROR, ESCAPE, EVERY, EXCEPT, EXCEPTION, EXCLUDE, EXCLUDING, EXEC, EXECUTE, EXISTS, EXP, EXPLAIN, EXTEND, EXTERNAL, EXTRACT, FALSE, FETCH, FILTER, FINAL, FIRST, FIRST_VALUE, FLOAT, FLOOR, FOLLOWING, FOR, FOREIGN, FORMAT, FORTRAN, FOUND, FRAC_SECOND, FRAME_ROW, FREE, FRIDAY, FROM, FULL, FUNCTION, FUSION, G, GENERAL, GENERATED, GEOMETRY, GET, GLOBAL, GO, GOTO, GRANT, GRANTED, GROUP, GROUPING, GROUPS, GROUP_CONCAT, HAVING, HIERARCHY, HOLD, HOP, HOUR, HOURS, IDENTITY, IGNORE, ILIKE, IMMEDIATE, IMMEDIATELY, IMPLEMENTATION, IMPORT, IN, INCLUDE, INCLUDING, INCREMENT, INDICATOR, INITIAL, INITIALLY, INNER, INOUT, INPUT, INSENSITIVE, INSERT, INSTANCE, INSTANTIABLE, INT, INTEGER, INTERSECT, INTERSECTION, INTERVAL, INTO, INVOKER, IS, ISODOW, ISOLATION, ISOYEAR, JAVA, JOIN, JSON, JSON_ARRAY, JSON_ARRAYAGG, JSON_EXISTS, JSON_OBJECT, JSON_OBJECTAGG, JSON_QUERY, JSON_SCOPE, JSON_VALUE, K, KEY, KEY_MEMBER, KEY_TYPE, LABEL, LAG, LANGUAGE, LARGE, LAST, LAST_VALUE, LATERAL, LEAD, LEADING, LEFT, LENGTH, LEVEL, LIBRARY, LIKE, LIKE_REGEX, LIMIT, LN, LOCAL, LOCALTIME, LOCALTIMESTAMP, LOCATOR, LOWER, M, MAP, MATCH, MATCHED, MATCHES, MATCH_NUMBER, MATCH_RECOGNIZE, MAX, MAXVALUE, MEASURES, MEMBER, MERGE, MESSAGE_LENGTH, MESSAGE_OCTET_LENGTH, MESSAGE_TEXT, METHOD, MICROSECOND, MILLENNIUM, MILLISECOND, MIN, MINUS, MINUTE, MINUTES, MINVALUE, MOD, MODIFIES, MODULE, MONDAY, MONTH, MONTHS, MORE, MULTISET, MUMPS, NAME, NAMES, NANOSECOND, NATIONAL, NATURAL, NCHAR, NCLOB, NESTING, NEW, NEXT, NO, NONE, NORMALIZE, NORMALIZED, NOT, NTH_VALUE, NTILE, NULL, NULLABLE, NULLIF, NULLS, NUMBER, NUMERIC, OBJECT, OCCURRENCES_REGEX, OCTETS, OCTET_LENGTH, OF, OFFSET, OLD, OMIT, ON, ONE, ONLY, OPEN, OPTION, OPTIONS, OR, ORDER, ORDERING, ORDINAL, ORDINALITY, OTHERS, OUT, OUTER, OUTPUT, OVER, OVERLAPS, OVERLAY, OVERRIDING, PAD, PARAMETER, PARAMETER_MODE, PARAMETER_NAME, PARAMETER_ORDINAL_POSITION, PARAMETER_SPECIFIC_CATALOG, PARAMETER_SPECIFIC_NAME, PARAMETER_SPECIFIC_SCHEMA, PARTIAL, PARTITION, PASCAL, PASSING, PASSTHROUGH, PAST, PATH, PATTERN, PER, PERCENT, PERCENTILE_CONT, PERCENTILE_DISC, PERCENT_RANK, PERIOD, PERMUTE, PIVOT, PLACING, PLAN, PLI, PORTION, POSITION, POSITION_REGEX, POWER, PRECEDES, PRECEDING, PRECISION, PREPARE, PRESERVE, PREV, PRIMARY, PRIOR, PRIVILEGES, PROCEDURE, PUBLIC, QUALIFY, QUARTER, QUARTERS, RANGE, RANK, READ, READS, REAL, RECURSIVE, REF, REFERENCES, REFERENCING, REGR_AVGX, REGR_AVGY, REGR_COUNT, REGR_INTERCEPT, REGR_R2, REGR_SLOPE, REGR_SXX, REGR_SXY, REGR_SYY, RELATIVE, RELEASE, REPEATABLE, REPLACE, RESET, RESPECT, RESTART, RESTRICT, RESULT, RETURN, RETURNED_CARDINALITY, RETURNED_LENGTH, RETURNED_OCTET_LENGTH, RETURNED_SQLSTATE, RETURNING, RETURNS, REVOKE, RIGHT, RLIKE, ROLE, ROLLBACK, ROLLUP, ROUTINE, ROUTINE_CATALOG, ROUTINE_NAME, ROUTINE_SCHEMA, ROW, ROWS, ROW_COUNT, ROW_NUMBER, RUNNING, SAFE_CAST, SAFE_OFFSET, SAFE_ORDINAL, SATURDAY, SAVEPOINT, SCALAR, SCALE, SCHEMA, SCHEMA_NAME, SCOPE, SCOPE_CATALOGS, SCOPE_NAME, SCOPE_SCHEMA, SCROLL, SEARCH, SECOND, SECONDS, SECTION, SECURITY, SEEK, SELECT, SELF, SENSITIVE, SEPARATOR, SEQUENCE, SERIALIZABLE, SERVER, SERVER_NAME, SESSION, SESSION_USER, SET, SETS, SHOW, SIMILAR, SIMPLE, SIZE, SKIP, SMALLINT, SOME, SOURCE, SPACE, SPECIFIC, SPECIFICTYPE, SPECIFIC_NAME, SQL, SQLEXCEPTION, SQLSTATE, SQLWARNING, SQL_BIGINT, SQL_BINARY, SQL_BIT, SQL_BLOB, SQL_BOOLEAN, SQL_CHAR, SQL_CLOB, SQL_DATE, SQL_DECIMAL, SQL_DOUBLE, SQL_FLOAT, SQL_INTEGER, SQL_INTERVAL_DAY, SQL_INTERVAL_DAY_TO_HOUR, SQL_INTERVAL_DAY_TO_MINUTE, SQL_INTERVAL_DAY_TO_SECOND, SQL_INTERVAL_HOUR, SQL_INTERVAL_HOUR_TO_MINUTE, SQL_INTERVAL_HOUR_TO_SECOND, SQL_INTERVAL_MINUTE, SQL_INTERVAL_MINUTE_TO_SECOND, SQL_INTERVAL_MONTH, SQL_INTERVAL_SECOND, SQL_INTERVAL_YEAR, SQL_INTERVAL_YEAR_TO_MONTH, SQL_LONGVARBINARY, SQL_LONGVARCHAR, SQL_LONGVARNCHAR, SQL_NCHAR, SQL_NCLOB, SQL_NUMERIC, SQL_NVARCHAR, SQL_REAL, SQL_SMALLINT, SQL_TIME, SQL_TIMESTAMP, SQL_TINYINT, SQL_TSI_DAY, SQL_TSI_FRAC_SECOND, SQL_TSI_HOUR, SQL_TSI_MICROSECOND, SQL_TSI_MINUTE, SQL_TSI_MONTH, SQL_TSI_QUARTER, SQL_TSI_SECOND, SQL_TSI_WEEK, SQL_TSI_YEAR, SQL_VARBINARY, SQL_VARCHAR, SQRT, START, STATE, STATEMENT, STATIC, STDDEV_POP, STDDEV_SAMP, STREAM, STRING_AGG, STRUCTURE, STYLE, SUBCLASS_ORIGIN, SUBMULTISET, SUBSET, SUBSTITUTE, SUBSTRING, SUBSTRING_REGEX, SUCCEEDS, SUM, SUNDAY, SYMMETRIC, SYSTEM, SYSTEM_TIME, SYSTEM_USER, TABLE, TABLESAMPLE, TABLE_NAME, TEMPORARY, THEN, THURSDAY, TIES, TIME, TIMESTAMP, TIMESTAMPADD, TIMESTAMPDIFF, TIMESTAMP_DIFF, TIMESTAMP_TRUNC, TIMEZONE_HOUR, TIMEZONE_MINUTE, TIME_DIFF, TIME_TRUNC, TINYINT, TO, TOP_LEVEL_COUNT, TRAILING, TRANSACTION, TRANSACTIONS_ACTIVE, TRANSACTIONS_COMMITTED, TRANSACTIONS_ROLLED_BACK, TRANSFORM, TRANSFORMS, TRANSLATE, TRANSLATE_REGEX, TRANSLATION, TREAT, TRIGGER, TRIGGER_CATALOG, TRIGGER_NAME, TRIGGER_SCHEMA, TRIM, TRIM_ARRAY, TRUE, TRUNCATE, TRY_CAST, TUESDAY, TUMBLE, TYPE, UESCAPE, UNBOUNDED, UNCOMMITTED, UNCONDITIONAL, UNDER, UNION, UNIQUE, UNKNOWN, UNNAMED, UNNEST, UNPIVOT, UPDATE, UPPER, UPSERT, USAGE, USER, USER_DEFINED_TYPE_CATALOG, USER_DEFINED_TYPE_CODE, USER_DEFINED_TYPE_NAME, USER_DEFINED_TYPE_SCHEMA, USING, UTF16, UTF32, UTF8, VALUE, VALUES, VALUE_OF, VARBINARY, VARCHAR, VARYING, VAR_POP, VAR_SAMP, VERSION, VERSIONING, VIEW, WEDNESDAY, WEEK, WEEKS, WHEN, WHENEVER, WHERE, WIDTH_BUCKET, WINDOW, WITH, WITHIN, WITHOUT, WORK, WRAPPER, WRITE, XML, YEAR, YEARS, ZONE.

标识符

标识符是 SQL 查询中使用的表、列和其他元数据元素的名称。

不带引号的标识符（例如 emp）必须以字母开头，并且只能包含字母、数字和下划线。它们被隐式转换为大写。

带引号的标识符，例如 "Employee Name" ，以双引号开头和结尾。它们几乎可以包含任何字符，包括空格和其他标点符号。如果你希望在标识符中包含双引号，请使用另一个双引号对其进行转义，例如："An employee called ""Fred""."。

在 Calcite 中，将标识符与引用对象的名称匹配是区分大小写的。但请记住，未加引号的标识符在匹配之前会隐式转换为大写，并且如果它引用的对象是使用未加引号的标识符作为其名称创建的，则其名称也将转换为大写。

数据类型

标量类型

timeUnit 包含了以下可选值：

1
2

timeUnit:
  MILLENNIUM | CENTURY | DECADE | YEAR | QUARTER | MONTH | WEEK | DOY | DOW | DAY | HOUR | MINUTE | SECOND | EPOCH

注意：

• DATE、TIME 和 TIMESTAMP 没有时区。对于这些类型，甚至没有隐式时区，例如 UTC（如 Java 中）或本地时区。由用户或应用程序提供时区。反过来，TIMESTAMP WITH LOCAL TIME ZONE 不会在内部存储时区，但它将依赖于提供的时区来提供正确的语义。
• 仅在某些一致性级别中才允许使用几何类型。
• 间隔字面量只能使用时间单位 YEAR、QUARTER、MONTH、WEEK、DAY、HOUR、MINUTE 和 SECOND。在某些一致性级别中，我们还允许使用复数形式：YEARS、QUARTERS、MONTHS、WEEKS、DAYS、HOURS、MINUTES 和 SECONDS。

非标量类型

注意：

• 每个 ROW 列类型，都可以有一个可选的 [ NULL | NOT NULL ] 后缀，用来声明此列类型是否可为空，默认值是不可为空。

空间类型

空间数据使用字符串（众所周知的 text (WKT) 编码）或者二进制字符串进行表示（众所周知的 binary (WKB) 编码）。

在要使用字面量的地方，应用 ST_GeomFromText 函数，例如 ST_GeomFromText('POINT (30 10)') 。

运算符和函数

运算符优先级

运算符优先级和结合性，从高到低。

注意：:: 、 <=> 是特定于方言的，但为了完整性起见在此表中显示。

比较运算符

1
2
3
4
5
6
7
8

comp:
      =
  |   <>
  |   >
  |   >=
  |   <
  |   <=
  |   <=>

逻辑运算符

算术运算符和函数

字符串运算符和函数

未实现：

• SUBSTRING(string FROM regexp FOR regexp)

二进制字符串运算符和函数

日期/时间函数

在标准 SQL 中，对 niladic 函数（例如 CURRENT_DATE）的调用不接受括号。在某些一致性级别中，可以接受带括号的调用（例如 CURRENT_DATE()）。

未实现：

• CEIL(interval)
• FLOOR(interval)
• + interval
• - interval
• interval + interval
• interval - interval
• interval / interval

系统函数

条件函数和运算符

类型转换

通常，表达式不能包含不同数据类型的值。例如，表达式不能将 5 乘以 10，然后添加 JULIAN。但是，Calcite 支持将值从一种数据类型隐式和显式转换为另一种数据类型。

隐式和显式类型转换

Calcite 建议你指定显式转换，而不是依赖隐式或自动转换，原因如下：

• 使用显式数据类型转换函数时，SQL 语句更容易理解；
• 隐式数据类型转换可能会对性能产生负面影响，尤其是当列值的数据类型转换为常量数据类型而不是与之相反时；
• 隐式转换取决于它发生的上下文，并且在每种情况下可能不会以相同的方式工作。例如，从日期时间值到 VARCHAR 值的隐式转换可能会返回意外的格式。

隐式转换的算法可能会在 Calcite 版本之间发生变化，显式转换的行为更可预测。

显式类型转换

将字符串转换为 BINARY 或 VARBINARY 类型会生成字符串字符集中字符串编码的字节列表。如果字符串的字符无法使用其字符集表示，则会产生运行时错误。

支持的数据类型语法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

type:
      typeName
      [ collectionsTypeName ]*

typeName:
      sqlTypeName
  |   rowTypeName
  |   compoundIdentifier

sqlTypeName:
      char [ precision ] [ charSet ]
  |   varchar [ precision ] [ charSet ]
  |   DATE
  |   time
  |   timestamp
  |   GEOMETRY
  |   decimal [ precision [, scale] ]
  |   BOOLEAN
  |   integer
  |   BINARY [ precision ]
  |   varbinary [ precision ]
  |   TINYINT
  |   SMALLINT
  |   BIGINT
  |   REAL
  |   double
  |   FLOAT
  |   ANY [ precision [, scale] ]

collectionsTypeName:
      ARRAY | MULTISET

rowTypeName:
      ROW '('
      fieldName1 fieldType1 [ NULL | NOT NULL ]
      [ , fieldName2 fieldType2 [ NULL | NOT NULL ] ]*
      ')'

char:
      CHARACTER | CHAR

varchar:
      char VARYING | VARCHAR

decimal:
      DECIMAL | DEC | NUMERIC

integer:
      INTEGER | INT

varbinary:
      BINARY VARYING | VARBINARY

double:
      DOUBLE [ PRECISION ]

time:
      TIME [ precision ] [ timeZone ]

timestamp:
      TIMESTAMP [ precision ] [ timeZone ]

charSet:
      CHARACTER SET charSetName

timeZone:
      WITHOUT TIME ZONE
  |   WITH LOCAL TIME ZONE

隐式类型转换

当这种转换有意义时，Calcite 会自动将值从一种数据类型转换为另一种数据类型。下表是 Calcite 类型转换矩阵，该表显示了所有可能的转换，而不考虑转换的上下文。管理这些细节的规则遵循该表。

i：隐式转换 / e：显式转换 / x：不允许

转化条件和策略

• 集合运算（UNION、EXCEPT、INTERSECT）：比较各分支行的数据类型，找出各字段对的公共类型；
• 二进制算术表达式（+、-、&、^、/、%）：将字符串操作数提升为另一个数字操作数的数据类型；
• 二进制比较（=、<、<=、<>、>、>=）：如果操作数为 STRING 和 TIMESTAMP，则提升为 TIMESTAMP；使 1 = true 和 0 = false 始终计算为 TRUE；如果有数字类型操作数，则为两个操作数找到共同的类型。
• IN 子查询：比较 LHS 和 RHS 的类型，找出共同的类型；如果是结构体类型，则为每个字段找到更宽的类型；
• IN 表达式列表：比较每个表达式以找到共同类型；
• CASE WHEN 表达式或 COALESCE：找到 THEN 和 ELSE 操作数的共同更宽类型；
• 字符 + INTERVAL 或字符 - INTERVAL ：将字符提升为 TIMESTAMP；
• 内置函数：查找检查器中注册的类型系列，如果检查器规则允许，则查找系列默认类型；
• 用户定义函数（UDF）：根据 eval() 方法声明的参数类型进行强制转换；
• INSERT 和 UPDATE：如果两个字段的类型名称或精度（比例）不同，则将源字段强制转换为对应的目标表字段的类型。

注意：

以下情况的隐式类型强制将被忽略：

• 其中一个类型是 ANY；
• CHARACTER 类型中的类型强制始终被忽略，即从 CHAR(20) 到 VARCHAR(30)；
• 从一个数字到另一个具有更高优先级的类型强制将被忽略，即从 INT 到 LONG。

寻找相同类型的策略

• 如果操作符有预期的数据类型，则直接将其作为所需类型。（例如，UDF 会有 eval() 方法，该方法有反射参数类型）；
• 如果没有预期的数据类型，但已注册数据类型系列，则尝试将参数强制转换为系列的默认数据类型，即 String 系列将具有 VARCHAR 类型；
• 如果既未指定预期的数据类型也未指定系列，则尝试找到节点类型中最紧密的公共类型，即 INTEGER 和 DOUBLE 将返回 DOUBLE，这种情况下数字精度不会丢失；
• 如果没有找到最紧密的公共类型，则尝试找到更宽的类型，即 VARCHAR 和 INTEGER 将返回 INTEGER，在将小数扩展为小数时，我们允许一些精度损失，或者提升为 VARCHAR 类型。

值构造函数

查询值构造函数

集合函数

另请参阅：UNNEST 关系运算符将集合转换为关系。

时间段谓词

其中 period1 和 period2 是时间段表达式：

1
2
3
4
5

period:
      (datetime, datetime)
  |   (datetime, interval)
  |   PERIOD (datetime, datetime)
  |   PERIOD (datetime, interval)

JDBC 函数转义

数字

字符串

日期/时间

系统

转换

聚合函数

语法：

1
2
3
4
5
6

aggregateCall:
      agg '(' [ ALL | DISTINCT ] value [, value ]* ')'
      [ WITHIN DISTINCT '(' expression [, expression ]* ')' ]
      [ WITHIN GROUP '(' ORDER BY orderItem [, orderItem ]* ')' ]
      [ FILTER '(' WHERE condition ')' ]
  |   agg '(' '*' ')' [ FILTER (WHERE condition) ]

其中 agg 是下表中的运算符之一，或者是用户定义的聚合函数。

如果存在 FILTER，则聚合函数仅考虑条件计算结果为 TRUE 的行。

如果存在 DISTINCT，则重复的参数值在传递给聚合函数之前会被消除。

如果存在 WITHIN DISTINCT，则在传递给聚合函数之前，参数值在指定键的每个值内都会有所不同。

如果存在 WITHIN GROUP，则聚合函数会在聚合值之前根据 WITHIN GROUP 内的 ORDER BY 子句对输入行进行排序。WITHIN GROUP 仅允许用于假设集合函数（RANK、DENSE_RANK、PERCENT_RANK 和 CUME_DIST）、逆分布函数（PERCENTILE_CONT 和 PERCENTILE_DISC）和集合函数（COLLECT 和 LISTAGG）。

未实现的：

• REGR_AVGX(numeric1, numeric2)
• REGR_AVGY(numeric1, numeric2)
• REGR_INTERCEPT(numeric1, numeric2)
• REGR_R2(numeric1, numeric2)
• REGR_SLOPE(numeric1, numeric2)
• REGR_SXY(numeric1, numeric2)

有序集聚合函数

语法与 aggregateCall 相同，但需要 WITHIN GROUP。

例如下面的：

• 分数 是 0 到 1 之间的数字文字（包括 0 和 1），代表百分比；

窗口函数

语法：

1
2
3
4
5
6
7
8
9

windowedAggregateCall:
      agg '(' [ ALL | DISTINCT ] value [, value ]* ')'
      [ RESPECT NULLS | IGNORE NULLS ]
      [ WITHIN GROUP '(' ORDER BY orderItem [, orderItem ]* ')' ]
      [ FILTER '(' WHERE condition ')' ]
      OVER window
  |   agg '(' '*' ')'
      [ FILTER  '(' WHERE condition ')' ]
      OVER window

其中 agg 是下表中的运算符之一，或者是用户定义的聚合函数。

DISTINCT、FILTER 和 WITHIN GROUP 与聚合函数的描述一致。

注意：

• 你可以为 FIRST_VALUE、LAST_VALUE、NTH_VALUE、LEAD 和 LAG 函数指定空处理（IGNORE NULLS、RESPECT NULLS）。语法由解析器处理，但只有 RESPECT NULLS 在运行时实现。

未实现：

• COUNT(DISTINCT value [, value ]*) OVER window
• APPROX_COUNT_DISTINCT(value [, value ]*) OVER window
• PERCENT_RANK(value) OVER window
• CUME_DIST(value) OVER window

分组函数

描述符

表函数

表函数出现在 FROM 子句中。

表函数可能具有通用表参数（即，创建表函数时未声明任何行类型），并且结果的行类型可能取决于输入表的行类型。此外，输入表按三个特征分类。第一个特征是语义。输入表具有行语义或集合语义，如下所示：

• 行语义意味着表函数的结果依赖于逐行；
• 集合语义意味着函数的结果取决于数据的分区方式。

第二个特性仅适用于具有集合语义的输入表，即即使输入表为空，表函数是否可以生成结果行。

• 如果表函数可以在空输入时生成结果行，则该表被称为空时保留；
• 另一种选择是空时修剪，这意味着如果输入表为空，结果将被修剪掉。

第三个特征是输入表是否支持传递列。传递列是一种机制，允许表函数将输入行的每一列复制到输出行的列中。

具有集合语义的输入表可以按一列或多列进行分区。具有集合语义的输入表可以按一列或多列进行排序。

注意：

• 具有行语义的输入表可能未被分区或排序；
• 多态表函数可能有多个输入表。但是，最多只有一个输入表可以具有行语义。

TUMBLE

在流式查询中，TUMBLE 根据时间戳列为关系的每一行分配一个窗口。分配的窗口由其开始和结束指定。所有分配的窗口都具有相同的长度，这就是为什么翻转有时被称为“固定窗口”。TUMBLE 表函数的第一个参数是通用表参数。输入表具有行语义并支持传递列。

下面是一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13

SELECT * FROM TABLE(
  TUMBLE(
    TABLE orders,
    DESCRIPTOR(rowtime),
    INTERVAL '1' MINUTE));

-- or with the named params
-- note: the DATA param must be the first
SELECT * FROM TABLE(
  TUMBLE(
    DATA => TABLE orders,
    TIMECOL => DESCRIPTOR(rowtime),
    SIZE => INTERVAL '1' MINUTE));

将一分钟范围的滚动窗口应用于订单表中的行。rowtime 是订单表的水印列，用于告知数据是否完整。

HOP

在流式查询中，HOP 会分配覆盖大小间隔内的行的窗口，并根据时间戳列移动每个滑动窗口。分配的窗口可能会重叠，因此有时跳跃被称为滑动窗口。HOP 表函数的第一个参数是通用表参数。输入表具有行语义并支持传递列。

下面是一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

SELECT * FROM TABLE(
  HOP(
    TABLE orders,
    DESCRIPTOR(rowtime),
    INTERVAL '2' MINUTE,
    INTERVAL '5' MINUTE));

-- or with the named params
-- note: the DATA param must be the first
SELECT * FROM TABLE(
  HOP(
    DATA => TABLE orders,
    TIMECOL => DESCRIPTOR(rowtime),
    SLIDE => INTERVAL '2' MINUTE,
    SIZE => INTERVAL '5' MINUTE));

对订单表的行应用 5 分钟间隔大小的跳跃，每 2 分钟移动一次。rowtime 是订单表的水印列，用于指示数据的完整性。

SESSION

在流式查询中，SESSION 根据日期时间分配覆盖行的窗口。在会话窗口内，行之间的距离小于间隔。会话窗口按键应用。SESSION 表函数的第一个参数是通用表参数。输入表具有设置语义并支持传递列。此外，如果输入表为空，SESSION 表函数将不会生成结果行。

下面是一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13

SELECT * FROM TABLE(
  SESSION(
    TABLE orders PARTITION BY product,
    DESCRIPTOR(rowtime),
    INTERVAL '20' MINUTE));

-- or with the named params
-- note: the DATA param must be the first
SELECT * FROM TABLE(
  SESSION(
    DATA => TABLE orders PARTITION BY product,
    TIMECOL => DESCRIPTOR(rowtime),
    SIZE => INTERVAL '20' MINUTE));

对订单表中的行应用具有 20 分钟非活动间隔的会话。rowtime 是订单表中带水印的列，用于指示数据的完整性。会话按产品应用。

注意：Tumble、Hop 和 Session 窗口表函数将原始表中的每一行分配给一个窗口。输出表具有与原始表相同的所有列，以及两个附加列 window_start 和 window_end，分别表示窗口间隔的开始和结束。

分组窗口函数

警告：分组窗口函数已被弃用。

分组窗口函数出现在 GROUP BY 子句中，并定义一个表示包含多行的窗口的键值。

在某些窗口函数中，一行可能属于多个窗口。例如，如果使用 HOP(t, INTERVAL '2' HOUR, INTERVAL '1' HOUR) 对查询进行分组，则带有时间戳 10:15:00 的行将同时出现在 10:00 - 11:00 和 11:00 - 12:00 总计中。

分组辅助函数

分组辅助函数允许您访问由分组窗口函数定义的窗口的属性。

空间函数

在以下内容中：

• geom 是一个 GEOMETRY；
• geomCollection 是一个 GEOMETRYCOLLECTION；
• point 是一个 POINT；
• lineString 是一个 LINESTRING；
• iMatrix 是 DE-9IM 交叉矩阵；
• distance、tolerance、segmentLengthFraction、offsetDistance 都是 double 类型；
• dimension、quadSegs、srid、zoom 是整数类型；
• layerType是一个字符串；
• gml 是包含地理标记语言 (GML) 的字符串；
• wkt 是包含 众所周知的文本 (WKT) 的字符串；
• wkb 是包含 众所周知的二进制 (WKB) 的二进制字符串。

在 C（代表兼容性）列中，o 表示该函数实现了 SQL 的 OpenGIS 简单功能实现规范，版本 1.2.1；p 表示该函数是 OpenGIS 的 PostGIS 扩展；h 表示该函数是 H2GIS 扩展。

TODO

几何转换函数（2D）

未实现：

• ST_GoogleMapLink(geom [, layerType [, zoom ]]) GEOMETRY → Google map link
• ST_OSMMapLink(geom [, marker ]) GEOMETRY → OSM map link

几何转换函数（3D）

几何创建函数（2D）

未实现：

• ST_RingBuffer(geom, distance, bufferCount [, endCapStyle [, doDifference]]) 返回以 geom 为中心且缓冲区大小不断增加的 MULTIPOLYGON 缓冲区。

几何创建函数（3D）

未实现：

• ST Extrude(from, height [, flag]) 挤出几何图形；
• ST_Geometry Shadow(geom_point, height) 计算 geom 的阴影足迹；
• ST_GeometryShadow(geom, azimuth, elevation, height [, unify ]) 计算 geom 的阴影覆盖范围。

几何属性（2D）

未实现：

• ST_CompactnessRatio(polygon) 返回 polygon 面积除以其周长等于其周长的圆的面积的平方根；
• ST_Explode(query [, field Name]) 将查询的 field Name 列中的GEOMETRY COLLECTIONs分解为多个几何图形；
• ST_IsValidDetail(geom [, selfTouchValid ]) 返回有效细节作为对象数组；
• ST_IsValidReason(geom [, selfTouchValid ]) 返回文本说明 geom 是否有效，如果无效，则说明原因。

几何属性（3D）

几何谓词

未实现：

• ST_OrderingEquals(geom1, geom2) 返回 geom1 是否等于 geom2 以及它们的坐标和组件几何图形以相同的顺序列出。

几何运算符（2D）

以下函数组合了 2D 几何图形。

另请参考：ST_Union 聚合函数。

仿射变换函数（3D 和 2D）

以下函数可变换 2D 几何图形。

未实现：

• ST_Scale(geom, xFactor, yFactor [, zFactor ]) 通过将纵坐标乘以指定的比例因子来缩放 geom；
• ST_Translate(geom, x, y, [, z]) 平移 geom。

几何编辑功能（2D）

以下函数可修改 2D 几何图形。

未实现：

• ST_CollectionExtract(geom, dimension) 过滤 geom，返回具有给定 dimension (1 = point, 2 = line-string, 3 = polygon) 的成员的多重几何图形。

几何编辑功能（3D）

以下函数可修改 3D 几何图形。

未实现：

• ST_Interpolate3DLine(geom) 返回带有 z 值插值的 geom，如果它不是线串或 MULTILINESTRING，则返回 null；
• ST_MultiplyZ(geom, zFactor) 返回 geom 的 z 值乘以 zFactor；
• ST_Reverse3DLine(geom [, sortOrder ]) 可能会根据其第一个和最后一个坐标的 z 值反转 geom；
• ST_UpdateZ(geom, newZ [, updateCondition ]) 更新 geom 的 z 值；
• ST_ZUpdateLineExtremities(geom, startZ, endZ [, interpolate ]) 更新 geom 的起始和终止 z 值。

几何测量功能（2D）

以下函数测量几何形状。

几何测量功能（3D）

未实现：

• ST_3DArea(geom) 返回多边形的三维面积；
• ST_3DLength(geom) 返回线串的 3D 长度；
• ST_3DPerimeter(geom) 返回多边形或MULTIPOLYGON的三维周长；
• ST_SunPosition(point [, timestamp ]) 计算 point 和 timestamp 处的太阳位置（现在默认）。

几何处理功能（2D）

以下函数处理几何图形。

未实现：

• ST_LineIntersector(geom1, geom2) 将 geom1 （线串）与 geom2 分割；
• ST_LineMerge(geom) 合并线性组件的集合以形成最大长度的线串；
• ST_MakeValid(geom [, retainGeomDim [, retainDuplicateCoord [, retainCoordDim]]]) 使 geom 有效；
• ST_RingSideBuffer(geom, distance, bufferCount [, endCapStyle [, doDifference]]) 计算一侧的环形缓冲区；
• ST_SideBuffer(geom, distance [, bufferStyle ]) 计算一侧的单个缓冲区。

几何投影函数

由于 EPSG 数据集的使用条款有限制，因此它与 Proj4J 分开发布。为了使用 Apache Calcite 中的投影函数，用户必须在其依赖项中包含 EPSG 数据集。

三角函数

未实现：

• ST_Azimuth(point1, point2) 返回从 point1 到 point2 的线段的方位角。

地形函数

未实现：

• ST_TriangleAspect(geom) 返回三角形的纵横比；
• ST_TriangleContouring(query [, z1, z2, z3 ][, varArgs ]*) 将三角形按类别分割成更小的三角形；
• ST_TriangleDirection(geom) 计算三角形的最陡上升方向并将其以线串形式返回；
• ST_TriangleSlope(geom) 以百分比形式计算三角形的斜率；
• ST_Voronoi(geom [, outDimension [, envelopePolygon ]]) 创建 Voronoi 图。

三角测量函数

未实现：

• ST_Tessellate(polygon) 使用自适应三角形对多边形 (可能是 MULTIPOLYGON) 进行镶嵌。

几何聚合函数

JSON 函数

在以下内容中：

• jsonValue 是包含 JSON 值的字符串；
• path 是包含 JSON 路径表达式的字符串；path 的开头应指定模式标志 strict 或 lax。

查询函数

注意：

• ON ERROR 和 ON EMPTY 子句定义当抛出错误或即将返回空值时函数的回退行为；
• ARRAY WRAPPER 子句定义如何在 JSON_QUERY 函数中表示 JSON 数组结果。以下示例比较了包装器行为。

示例数据：

1

{"a": "[1,2]", "b": [1,2], "c": "hi"}

比较：

未实现：

• JSON_TABLE

构造函数

1
2
3
4
5
6
7
8
9
10

jsonKeyVal:
      [ KEY ] name VALUE value [ FORMAT JSON ]
  |   name : value [ FORMAT JSON ]

jsonVal:
      value [ FORMAT JSON ]

nullBehavior:
      NULL ON NULL
  |   ABSENT ON NULL

注意：

• 标志 FORMAT JSON 表示值被格式化为 JSON 字符串。当使用 FORMAT JSON 时，该值应该从 JSON 字符串解析为 SQL 结构化值；
• ON NULL 子句定义 JSON 输出如何表示空值。JSON_OBJECT 和 JSON_OBJECTAGG 的默认空行为是 NULL ON NULL，而对于 JSON_ARRAY 和 JSON_ARRAYAGG，则为 ABSENT ON NULL；
• 如果提供了 ORDER BY 子句，JSON_ARRAYAGG 会在执行聚合之前将输入行按指定顺序排序。

比较运算符

特定方言运算符

以下运算符不在 SQL 标准中，并且未在 Calcite 的默认运算符表中启用。仅当您的会话启用了额外的运算符表时，它们才可用于查询。

要启用操作员表，请设置 fun 连接字符串参数。

“C”（兼容性）列包含值：

• ‘*’ 代表所有库，
• ‘b’ 代表 Google BigQuery（连接字符串中为 ‘fun=bigquery’），
• ‘c’ 代表 Apache Calcite（连接字符串中为 ‘fun=calcite’），
• ‘h’ 代表 Apache Hive（连接字符串中为 ‘fun=hive’），
• ‘m’ 代表 MySQL（连接字符串中为 ‘fun=mysql’），
• ‘q’ 代表 Microsoft SQL Server（连接字符串中为 ‘fun=mssql’），
• ‘o’ 代表 Oracle（连接字符串中为 ‘fun=oracle’），
• ‘p’ 代表 PostgreSQL（连接字符串中为 ‘fun=postgresql’），
• ‘s’ 代表 Apache Spark（连接字符串中为 ‘fun=spark’）。

一个操作符名称可能对应多种SQL方言，但语义不同。

• BigQuery 的类型系统对类型和函数使用了容易混淆的不同名称：

• BigQuery 的 DATETIME 类型表示本地日期时间，与 Calcite 的 TIMESTAMP 类型相对应；

• BigQuery 的 TIMESTAMP 类型表示瞬间，与 Calcite 的 TIMESTAMP WITH LOCAL TIME ZONE 类型相对应；

• timestampLtz 参数（例如 DATE(timestampLtz) 中的参数）具有 Calcite 类型 TIMESTAMP WITH LOCAL TIME ZONE；

• TIMESTAMP(string) 函数旨在与 BigQuery 函数兼容，返回 Calcite TIMESTAMP WITH LOCAL TIME ZONE；

• 类似地，DATETIME(string) 返回 Calcite TIMESTAMP。

注意：

• Calcite 没有 Redshift 库，因此改用 Postgres 库。函数 DATEADD、DATEDIFF 在 Redshift 中实现，而不是 Postgres，但它们仍然出现在 Calcite 的 Postgres 库中；

• 函数 DATEADD、DATEDIFF、DATE_PART 需要 Babel 解析器；

• 如果参数为 null，则 JSON_TYPE / JSON_DEPTH / JSON_PRETTY / JSON_STORAGE_SIZE 返回 null；

• 如果第一个参数为 null，则 JSON_LENGTH / JSON_KEYS / JSON_REMOVE 返回 null；

• JSON_TYPE 通常返回一个大写字符串标志，指示 JSON 输入的类型。目前支持的类型标志有：

  • INTEGER
  • STRING
  • FLOAT
  • DOUBLE
  • LONG
  • BOOLEAN
  • DATE
  • OBJECT
  • ARRAY
  • NULL

• JSON_DEPTH 定义 JSON 值的深度如下：

  • 空数组、空对象或标量值的深度为 1；
  • 仅包含深度为 1 的元素的非空数组或仅包含深度为 1 的成员值的非空对象深度为 2；
  • 否则，JSON 文档的深度大于 2。

• JSON_LENGTH 定义 JSON 值的长度如下：

  • 标量值的长度为 1；
  • 数组或对象的长度是其包含的元素数。

特定方言的聚合函数。

用法示例：

JSON_TYPE 示例

SQL

1
2
3
4
5
6

SELECT JSON_TYPE(v) AS c1,
  JSON_TYPE(JSON_VALUE(v, 'lax $.b' ERROR ON ERROR)) AS c2,
  JSON_TYPE(JSON_VALUE(v, 'strict $.a[0]' ERROR ON ERROR)) AS c3,
  JSON_TYPE(JSON_VALUE(v, 'strict $.a[1]' ERROR ON ERROR)) AS c4
FROM (VALUES ('{"a": [10, true],"b": "[10, true]"}')) AS t(v)
LIMIT 10;

结果

JSON_DEPTH 示例

SQL

1
2
3
4
5
6

SELECT JSON_DEPTH(v) AS c1,
  JSON_DEPTH(JSON_VALUE(v, 'lax $.b' ERROR ON ERROR)) AS c2,
  JSON_DEPTH(JSON_VALUE(v, 'strict $.a[0]' ERROR ON ERROR)) AS c3,
  JSON_DEPTH(JSON_VALUE(v, 'strict $.a[1]' ERROR ON ERROR)) AS c4
FROM (VALUES ('{"a": [10, true],"b": "[10, true]"}')) AS t(v)
LIMIT 10;

结果

JSON_LENGTH 示例

SQL

1
2
3
4
5
6

SELECT JSON_LENGTH(v) AS c1,
  JSON_LENGTH(v, 'lax $.a') AS c2,
  JSON_LENGTH(v, 'strict $.a[0]') AS c3,
  JSON_LENGTH(v, 'strict $.a[1]') AS c4
FROM (VALUES ('{"a": [10, true]}')) AS t(v)
LIMIT 10;

结果

JSON_INSERT 示例

SQL

1
2
3
4

SELECT JSON_INSERT(v, '$.a', 10, '$.c', '[1]') AS c1,
  JSON_INSERT(v, '$', 10, '$.c', '[1]') AS c2
FROM (VALUES ('{"a": [10, true]}')) AS t(v)
LIMIT 10;

结果

JSON_KEYS 示例

SQL

1
2
3
4
5
6
7

SELECT JSON_KEYS(v) AS c1,
  JSON_KEYS(v, 'lax $.a') AS c2,
  JSON_KEYS(v, 'lax $.b') AS c2,
  JSON_KEYS(v, 'strict $.a[0]') AS c3,
  JSON_KEYS(v, 'strict $.a[1]') AS c4
FROM (VALUES ('{"a": [10, true],"b": {"c": 30}}')) AS t(v)
LIMIT 10;

结果

JSON_REMOVE 示例

SQL

1
2
3

SELECT JSON_REMOVE(v, '$[1]') AS c1
FROM (VALUES ('["a", ["b", "c"], "d"]')) AS t(v)
LIMIT 10;

结果

JSON_REPLACE 示例

SQL

1
2
3
4
5

SELECT
JSON_REPLACE(v, '$.a', 10, '$.c', '[1]') AS c1,
JSON_REPLACE(v, '$', 10, '$.c', '[1]') AS c2
FROM (VALUES ('{\"a\": 1,\"b\":[2]}')) AS t(v)
limit 10;

结果

JSON_SET 示例

SQL

1
2
3
4
5

SELECT
JSON_SET(v, '$.a', 10, '$.c', '[1]') AS c1,
JSON_SET(v, '$', 10, '$.c', '[1]') AS c2
FROM (VALUES ('{\"a\": 1,\"b\":[2]}')) AS t(v)
limit 10;

结果

JSON_STORAGE_SIZE 示例

SQL

1
2
3
4
5
6

SELECT
JSON_STORAGE_SIZE('[100, \"sakila\", [1, 3, 5], 425.05]') AS c1,
JSON_STORAGE_SIZE('{\"a\": 10, \"b\": \"a\", \"c\": \"[1, 3, 5, 7]\"}') AS c2,
JSON_STORAGE_SIZE('{\"a\": 10, \"b\": \"xyz\", \"c\": \"[1, 3, 5, 7]\"}') AS c3,
JSON_STORAGE_SIZE('[100, \"json\", [[10, 20, 30], 3, 5], 425.05]') AS c4
limit 10;

结果

解码示例

SQL

1
2
3
4
5
6

SELECT DECODE(f1, 1, 'aa', 2, 'bb', 3, 'cc', 4, 'dd', 'ee') as c1,
  DECODE(f2, 1, 'aa', 2, 'bb', 3, 'cc', 4, 'dd', 'ee') as c2,
  DECODE(f3, 1, 'aa', 2, 'bb', 3, 'cc', 4, 'dd', 'ee') as c3,
  DECODE(f4, 1, 'aa', 2, 'bb', 3, 'cc', 4, 'dd', 'ee') as c4,
  DECODE(f5, 1, 'aa', 2, 'bb', 3, 'cc', 4, 'dd', 'ee') as c5
FROM (VALUES (1, 2, 3, 4, 5)) AS t(f1, f2, f3, f4, f5);