参考指南

原文链接：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:
      =
  |   <>
  |   >
  |   >=
  |   <
  |   <=
  |   <=>

逻辑运算符

算术运算符和函数

字符串运算符和函数

TODO

Not implemented:

• SUBSTRING(string FROM regexp FOR regexp)

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

日期/时间函数

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

未实现：

• CEIL(间隔)
• 楼层（间隔）
• + 间隔
• - 间隔
• 间隔+间隔
• 间隔-间隔
• 间隔/间隔

系统函数

条件函数和运算符

类型转换

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

隐式和显式类型转换

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

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

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

显式类型转换

支持的数据类型语法：

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

隐式类型转换

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

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

转化背景和策略

• Set operation (UNION, EXCEPT, INTERSECT): compare every branch row data type and find the common type of each fields pair;
• Binary arithmetic expression (+, -, &, ^, /, %): promote string operand to data type of the other numeric operand;
• Binary comparison (=, <, <=, <>, >, >=): if operands are STRING and TIMESTAMP, promote to TIMESTAMP; make 1 = true and 0 = false always evaluate to TRUE; if there is numeric type operand, find common type for both operands.
• IN sub-query: compare type of LHS and RHS, and find the common type; if it is struct type, find wider type for every field;
• IN expression list: compare every expression to find the common type;
• CASE WHEN expression or COALESCE: find the common wider type of the THEN and ELSE operands;
• Character + INTERVAL or character - INTERVAL: promote character to TIMESTAMP;
• Built-in function: look up the type families registered in the checker, find the family default type if checker rules allow it;
• User-defined function (UDF): coerce based on the declared argument types of the eval() method;
• INSERT and UPDATE: coerce a source field to counterpart target table field’s type if the two fields differ with type name or precision(scale).

Note:

Implicit type coercion of following cases are ignored:

• One of the type is ANY;
• Type coercion within CHARACTER types are always ignored, i.e. from CHAR(20) to VARCHAR(30);
• Type coercion from a numeric to another with higher precedence is ignored, i.e. from INT to LONG.

寻找共同类型的策略

• If the operator has expected data types, just take them as the desired one. (e.g. the UDF would have eval() method which has reflection argument types);
• If there is no expected data type but the data type families are registered, try to coerce the arguments to the family’s default data type, i.e. the String family will have a VARCHAR type;
• If neither expected data type nor families are specified, try to find the tightest common type of the node types, i.e. INTEGER and DOUBLE will return DOUBLE, the numeric precision does not lose for this case;
• If no tightest common type is found, try to find a wider type, i.e. VARCHAR and INTEGER will return INTEGER, we allow some precision loss when widening decimal to fractional, or promote to VARCHAR type.

值构造函数

集合函数

See also: the UNNEST relational operator converts a collection to a relation.

句点谓词

Where period1 and period2 are period expressions:

1
2
3
4
5

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

JDBC 函数转义

数字

字符串

日期/时间

系统

转换

聚合函数

Syntax:

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存在，则聚合函数在聚合值之前根据ORDER BY内部子句对输入行进行排序WITHIN GROUP。WITHIN GROUP仅允许用于假设集合函数 ( RANK、 DENSE_RANK和)、逆分布函数 (PERCENT_RANK和)和集合函数 ( 和)。CUME_DIST``PERCENTILE_CONT``PERCENTILE_DISC``COLLECT``LISTAGG

Not implemented:

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

有序集聚合函数

The syntax is as for aggregateCall, except that WITHIN GROUP is required.

In the following:

• fraction is a numeric literal between 0 and 1, inclusive, and represents a percentage

窗口函数

Syntax:

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如聚合函数所述。

笔记：

• You may specify null treatment (IGNORE NULLS, RESPECT NULLS) for FIRST_VALUE, LAST_VALUE, NTH_VALUE, LEAD and LAG functions. The syntax handled by the parser, but only RESPECT NULLS is implemented at runtime.

Not implemented:

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

分组函数

描述符

表函数

Table functions occur in the FROM clause.

Table functions may have generic table parameters (i.e., no row type is declared when the table function is created), and the row type of the result might depend on the row type(s) of the input tables. Besides, input tables are classified by three characteristics. The first characteristic is semantics. Input tables have either row semantics or set semantics, as follows:

• Row semantics means that the result of the table function depends on a row-by-row basis.
• Set semantics means that the outcome of the function depends on how the data is partitioned.

The second characteristic, which applies only to input tables with set semantics, is whether the table function can generate a result row even if the input table is empty.

• If the table function can generate a result row on empty input, the table is said to be “keep when empty”.
• The alternative is called “prune when empty”, meaning that the result would be pruned out if the input table is empty.

The third characteristic is whether the input table supports pass-through columns or not. Pass-through columns is a mechanism enabling the table function to copy every column of an input row into columns of an output row.

The input tables with set semantics may be partitioned on one or more columns. The input tables with set semantics may be ordered on one or more columns.

Note:

• The input tables with row semantics may not be partitioned or ordered.
• A polymorphic table function may have multiple input tables. However, at most one input table could have row semantics.

TUMBLE

In streaming queries, TUMBLE assigns a window for each row of a relation based on a timestamp column. An assigned window is specified by its beginning and ending. All assigned windows have the same length, and that’s why tumbling sometimes is named as “fixed windowing”. The first parameter of the TUMBLE table function is a generic table parameter. The input table has row semantics and supports pass-through columns.

这是一个例子：

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));

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

跳

在流式查询中，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 分钟间隔大小的跳跃orders ，并每 2 分钟移动一次。rowtime是表顺序的带水印的列，表明数据的完整性。

会议

在流式查询中，SESSION 分配基于datetime覆盖行的窗口。在会话窗口内，行的距离小于间隔。会话窗口适用于每个键。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 分钟非活动间隙的会话orders。 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是几何；
• geomCollection是一个 GEOMETRYCOLLECTION；
• 点是一个点；
• lineString是一个 LINESTRING；
• iMatrix是DE-9IM 交集矩阵；
• distance、tolerance、segmentLengthFraction、offsetDistance均为 double 类型；
• 维度、quadSegs、srid、zoom都是整数类型；
• LayerType为字符串；
• gml是包含地理标记语言（GML）的字符串；
• wkt是包含众所周知文本（WKT）的字符串；
• wkb是包含众所周知的二进制 (WKB) 的二进制字符串。

在“C”（“兼容性”）列中，“o”表示该函数实现了 OpenGIS Simple Features Implementing Specific for SQL 版本 1.2.1；“p”表示该函数是 PostGIS对OpenGIS的扩展；“h”表示该函数是 H2GIS扩展。

几何转换函数（2D）

Not implemented:

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

Geometry conversion functions (3D)

Geometry creation functions (2D)

Not implemented:

• ST_RingBuffer(geom, distance, bufferCount [, endCapStyle [, doDifference]]) Returns a MULTIPOLYGON of buffers centered at geom and of increasing buffer size

Geometry creation functions (3D)

Not implemented:

• ST_Extrude(geom, height [, flag]) Extrudes a GEOMETRY
• ST_GeometryShadow(geom, point, height) Computes the shadow footprint of geom
• ST_GeometryShadow(geom, azimuth, altitude, height [, unify ]) Computes the shadow footprint of geom

Geometry properties (2D)

Not implemented:

• ST_CompactnessRatio(polygon) Returns the square root of polygon’s area divided by the area of the circle with circumference equal to its perimeter
• ST_Explode(query [, fieldName]) Explodes the GEOMETRYCOLLECTIONs in the fieldName column of a query into multiple geometries
• ST_IsValidDetail(geom [, selfTouchValid ]) Returns a valid detail as an array of objects
• ST_IsValidReason(geom [, selfTouchValid ]) Returns text stating whether geom is valid, and if not valid, a reason why

Geometry properties (3D)

Geometry predicates

未实现：

• 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 ，返回具有给定**维度的那些成员的多几何图形（1 = 点，2 = 线串，3 = 多边形）

几何编辑功能（3D）

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

未实现：

• ST_Interpolate3DLine(geom) 返回带有 z 值插值的geom，如果不是线串或多行字符串，则返回 null
• ST_MultiplyZ(geom, zFactor) 返回z 值乘以zFactor的**geom
• 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) 返回多边形的 3D 面积
• ST_3DLength(geom) 返回线串的 3D 长度
• ST_3DPerimeter(geom) 返回多边形或 MULTIPOLYGON 的 3D 周长
• ST_SunPosition(point [, timestamp ]) 计算点和时间戳处的太阳位置（现在默认）

几何处理功能（2D）

以下函数处理几何形状。

未实现：

• ST_LineIntersector(geom1, geom2) 将geom1（线串）与geom2分割
• ST_LineMerge(geom) 合并线性分量的集合以形成最大长度的线串
• ST_MakeValid(geom [,preserveGeomDim[,preserveDuplicateCoord[,preserveCoordDim]]]) 使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 路径表达式的字符串；模式标志strictorlax应该在路径的开头指定。

查询功能

笔记：

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

示例数据：

1

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

比较：

未实现：

• JSON_TABLE

Constructor Functions

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

Note:

• The flag FORMAT JSON indicates the value is formatted as JSON character string. When FORMAT JSON is used, the value should be de-parse from JSON character string to a SQL structured value.
• ON NULL clause defines how the JSON output represents null values. The default null behavior of JSON_OBJECT and JSON_OBJECTAGG is NULL ON NULL, and for JSON_ARRAY and JSON_ARRAYAGG it is ABSENT ON NULL.
• If ORDER BY clause is provided, JSON_ARRAYAGG sorts the input rows into the specified order before performing aggregation.

Comparison Operators

Dialect-specific Operators

The following operators are not in the SQL standard, and are not enabled in Calcite’s default operator table. They are only available for use in queries if your session has enabled an extra operator table.

To enable an operator table, set the fun connect string parameter.

The ‘C’ (compatibility) column contains value:

• ‘*’ for all libraries,
• ‘b’ for Google BigQuery (‘fun=bigquery’ in the connect string),
• ‘c’ for Apache Calcite (‘fun=calcite’ in the connect string),
• ‘h’ for Apache Hive (‘fun=hive’ in the connect string),
• ‘m’ for MySQL (‘fun=mysql’ in the connect string),
• ‘q’ for Microsoft SQL Server (‘fun=mssql’ in the connect string),
• ‘o’ for Oracle (‘fun=oracle’ in the connect string),
• ‘p’ for PostgreSQL (‘fun=postgresql’ in the connect string),
• ’s’ for Apache Spark (‘fun=spark’ in the connect string).

One operator name may correspond to multiple SQL dialects, but with different semantics.

BigQuery’s type system uses confusingly different names for types and functions:

• BigQuery’s DATETIME type represents a local date time, and corresponds to Calcite’s TIMESTAMP type;
• BigQuery’s TIMESTAMP type represents an instant, and corresponds to Calcite’s TIMESTAMP WITH LOCAL TIME ZONE type;
• The timestampLtz parameter, for instance in DATE(timestampLtz), has Calcite type TIMESTAMP WITH LOCAL TIME ZONE;
• The TIMESTAMP(string) function, designed to be compatible the BigQuery function, return a Calcite TIMESTAMP WITH LOCAL TIME ZONE;
• Similarly, DATETIME(string) returns a Calcite TIMESTAMP.

笔记：

• Calcite 没有 Redshift 库，因此使用 Postgres 库。这些函数DATEADD是DATEDIFF在 Redshift 而不是 Postgres 中实现的，但仍然出现在 Calcite 的 Postgres 库中

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

• JSON_TYPE///如果参数为null则JSON_DEPTH返回JSON_PRETTYnullJSON_STORAGE_SIZE

• JSON_LENGTH//如果第一个参数为null则返回JSON_KEYSnullJSON_REMOVE

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

  • 整数
  • 细绳
  • 漂浮
  • 双倍的
  • 长的
  • 布尔值
  • 日期
  • 目的
  • 大批
  • 无效的

• 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);

结果

翻译示例

SQL

1
2
3
4
5

SELECT TRANSLATE('Aa*Bb*Cc''D*d', ' */''%', '_') as c1,
  TRANSLATE('Aa/Bb/Cc''D/d', ' */''%', '_') as c2,
  TRANSLATE('Aa Bb Cc''D d', ' */''%', '_') as c3,
  TRANSLATE('Aa%Bb%Cc''D%d', ' */''%', '_') as c4
FROM (VALUES (true)) AS t(f0);

结果

用户定义函数

方解石是可延伸的。您可以使用用户代码定义每种函数。对于每种函数，通常有多种定义函数的方法，从方便到高效。

要实现标量函数，有 3 个选项：

• 创建一个具有公共静态方法的类eval，并注册该类；
• 创建一个具有公共非静态eval方法和不带参数的公共构造函数的类，并注册该类；
• 创建一个具有一个或多个公共静态方法的类，并注册每个类/方法组合。

要实现聚合函数，有两种选择：

• 创建一个具有 public static 和方法的类init，add并result注册该类；
• 创建一个具有公共非静态 和 方法的类init，以及一个不带参数的公共构造函数，并注册该类。

merge（可选）向类添加公共方法；这允许 Calcite 生成合并小计的代码。

（可选）让您的类实现 SqlSplittableAggFunction 接口；这使得 Calcite 可以跨多个聚合阶段分解函数，从汇总表中汇总，并通过连接推送它。

要实现表函数，有 3 个选项：

• eval创建一个具有返回 ScannableTable 或 QueryableTable的静态方法的类，并注册该类；
• eval创建一个具有返回 ScannableTable 或 QueryableTable的非静态方法的类，并注册该类；
• 创建一个具有一个或多个返回 ScannableTable 或 QueryableTable的公共静态方法的类，并注册每个类/方法组合。

要实现表宏，有 3 个选项：

• eval创建一个具有返回 TranslatableTable 的静态方法的类，并注册该类；
• eval创建一个具有返回 TranslatableTable 的非静态方法的类，并注册该类；
• 创建一个具有一个或多个返回 TranslatableTable 的公共静态方法的类，并注册每个类/方法组合。

Calcite 从实现函数的 Java 方法的参数和返回类型推导出函数的参数类型和结果类型。此外，您可以使用参数注释指定每个参数的名称和可选性 。

使用命名参数和可选参数调用函数

通常，当您调用函数时，需要按顺序指定其所有参数。但如果函数有很多参数，特别是如果您想随着时间的推移添加更多参数，这可能会成为问题。

为了解决这个问题，SQL 标准允许您按名称传递参数，并定义可选参数（即，具有默认值，如果未指定则使用默认值）。

假设您有一个 function f，声明如下伪语法：

1
2
3
4
5
6

FUNCTION f(
  INTEGER a,
  INTEGER b DEFAULT NULL,
  INTEGER c,
  INTEGER d DEFAULT NULL,
  INTEGER e DEFAULT NULL) RETURNS INTEGER

该函数的所有参数都有名称和parameters，并且 有默认值b，因此都是可选的。（在方解石中，是可选参数唯一允许的默认值； 将来可能会改变。）

当调用带有可选参数的函数时，可以省略列表末尾的可选参数，或者DEFAULT 对任何可选参数使用关键字。这里有些例子：

• f(1, 2, 3, 4, 5)按顺序为每个参数提供一个值；
• f(1, 2, 3, 4)省略e，获取其默认值NULL;
• f(1, DEFAULT, 3)省略d和e，并指定使用默认值b;
• f(1, DEFAULT, 3, DEFAULT, DEFAULT)和前面的例子效果一样；
• f(1, 2)不合法，因为c不是可选的；
• f(1, 2, DEFAULT, 4)不合法，因为c不是可选的。

您可以使用语法按名称指定参数=>。如果一个参数被命名，那么它们都必须被命名。参数可以是任何其他参数，但不得多次指定任何参数，并且您需要为每个参数提供一个不可选的值。这里有些例子：

• f(c => 3, d => 1, a => 0)相当于f(0, NULL, 3, 1, NULL)；
• f(c => 3, d => 1)不合法，因为您尚未指定 的值 a并且a不是可选的。

SQL Hint

提示是给优化器的指令。在编写SQL时，您可能会知道优化器未知的数据信息。提示使您能够做出通常由优化器做出的决策。

• 规划器执行者：没有完美的规划器，因此实现提示以允许用户更好地控制执行是有意义的。例如：“永远不要将此子查询与其他子查询合并”( /*+ no_merge */)；“将这些表视为前导表”( /*+ leading */) 以影响连接顺序等；
• 附加元数据/统计信息：一些统计信息，例如“扫描的表索引”或“某些洗牌键的倾斜信息”对于查询来说是动态的，用提示配置它们会非常方便，因为我们来自规划器的规划元数据非常方便通常不太准确；
• 算子资源限制：在很多情况下，我们会给执行算子一个默认的资源配置，即最小并行度、内存（资源消耗 UDF）、特殊资源要求（GPU 或 SSD 磁盘）……对资源进行分析会非常灵活每个查询都有提示（不是作业）。

句法

方解石支持两个位置的提示：

• 查询提示：关键字后SELECT；
• 表提示：位于引用的表名称之后。

例如：

1
2
3
4
5
6
7

SELECT /*+ hint1, hint2(a=1, b=2) */
...
FROM
  tableName /*+ hint3(5, 'x') */
JOIN
  tableName /*+ hint4(c=id), hint5 */
...

语法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

hintComment:
      '/*+' hint [, hint ]* '*/'

hint:
      hintName
  |   hintName '(' optionKey '=' optionVal [, optionKey '=' optionVal ]* ')'
  |   hintName '(' hintOption [, hintOption ]* ')'

optionKey:
      simpleIdentifier
  |   stringLiteral

optionVal:
      stringLiteral

hintOption:
      simpleIdentifier
   |  numericLiteral
   |  stringLiteral

它在方解石中处于实验阶段，尚未完全实施，我们已实施的是：

• 解析器支持上述语法；
• RelHint代表一个提示项；
• 在 sql-to-rel 转换和规划器规划期间传播提示的机制。

我们还没有添加任何内置提示项，如果我们认为提示足够稳定，我们会引入更多。

MATCH_识别

MATCH_RECOGNIZE是一个 SQL 扩展，用于识别复杂事件处理 (CEP) 中的事件序列。

它在方解石中处于实验阶段，但尚未完全实施。

句法

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