Edit on GitHub

sqlglot.dialects.doris

View Source

  1from __future__ import annotations
  2
  3from sqlglot import exp
  4from sqlglot.dialects.dialect import (
  5    approx_count_distinct_sql,
  6    build_timestamp_trunc,
  7    rename_func,
  8    time_format,
  9    unit_to_str,
 10)
 11from sqlglot.dialects.mysql import MySQL
 12
 13
 14def _lag_lead_sql(self, expression: exp.Lag | exp.Lead) -> str:
 15    return self.func(
 16        "LAG" if isinstance(expression, exp.Lag) else "LEAD",
 17        expression.this,
 18        expression.args.get("offset") or exp.Literal.number(1),
 19        expression.args.get("default") or exp.null(),
 20    )
 21
 22
 23class Doris(MySQL):
 24    DATE_FORMAT = "'yyyy-MM-dd'"
 25    DATEINT_FORMAT = "'yyyyMMdd'"
 26    TIME_FORMAT = "'yyyy-MM-dd HH:mm:ss'"
 27
 28    class Parser(MySQL.Parser):
 29        FUNCTIONS = {
 30            **MySQL.Parser.FUNCTIONS,
 31            "COLLECT_SET": exp.ArrayUniqueAgg.from_arg_list,
 32            "DATE_TRUNC": build_timestamp_trunc,
 33            "MONTHS_ADD": exp.AddMonths.from_arg_list,
 34            "REGEXP": exp.RegexpLike.from_arg_list,
 35            "TO_DATE": exp.TsOrDsToDate.from_arg_list,
 36        }
 37
 38        FUNCTION_PARSERS = MySQL.Parser.FUNCTION_PARSERS.copy()
 39        FUNCTION_PARSERS.pop("GROUP_CONCAT")
 40
 41    class Generator(MySQL.Generator):
 42        LAST_DAY_SUPPORTS_DATE_PART = False
 43
 44        TYPE_MAPPING = {
 45            **MySQL.Generator.TYPE_MAPPING,
 46            exp.DataType.Type.TEXT: "STRING",
 47            exp.DataType.Type.TIMESTAMP: "DATETIME",
 48            exp.DataType.Type.TIMESTAMPTZ: "DATETIME",
 49        }
 50
 51        CAST_MAPPING = {}
 52        TIMESTAMP_FUNC_TYPES = set()
 53
 54        TRANSFORMS = {
 55            **MySQL.Generator.TRANSFORMS,
 56            exp.AddMonths: rename_func("MONTHS_ADD"),
 57            exp.ApproxDistinct: approx_count_distinct_sql,
 58            exp.ArgMax: rename_func("MAX_BY"),
 59            exp.ArgMin: rename_func("MIN_BY"),
 60            exp.ArrayAgg: rename_func("COLLECT_LIST"),
 61            exp.ArrayUniqueAgg: rename_func("COLLECT_SET"),
 62            exp.CurrentTimestamp: lambda self, _: self.func("NOW"),
 63            exp.DateTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, unit_to_str(e)),
 64            exp.GroupConcat: lambda self, e: self.func(
 65                "GROUP_CONCAT", e.this, e.args.get("separator") or exp.Literal.string(",")
 66            ),
 67            exp.JSONExtractScalar: lambda self, e: self.func("JSON_EXTRACT", e.this, e.expression),
 68            exp.Lag: _lag_lead_sql,
 69            exp.Lead: _lag_lead_sql,
 70            exp.Map: rename_func("ARRAY_MAP"),
 71            exp.RegexpLike: rename_func("REGEXP"),
 72            exp.RegexpSplit: rename_func("SPLIT_BY_STRING"),
 73            exp.Split: rename_func("SPLIT_BY_STRING"),
 74            exp.StringToArray: rename_func("SPLIT_BY_STRING"),
 75            exp.StrToUnix: lambda self, e: self.func("UNIX_TIMESTAMP", e.this, self.format_time(e)),
 76            exp.TimeStrToDate: rename_func("TO_DATE"),
 77            exp.TsOrDsAdd: lambda self, e: self.func("DATE_ADD", e.this, e.expression),
 78            exp.TsOrDsToDate: lambda self, e: self.func("TO_DATE", e.this),
 79            exp.TimeToUnix: rename_func("UNIX_TIMESTAMP"),
 80            exp.TimestampTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, unit_to_str(e)),
 81            exp.UnixToStr: lambda self, e: self.func(
 82                "FROM_UNIXTIME", e.this, time_format("doris")(self, e)
 83            ),
 84            exp.UnixToTime: rename_func("FROM_UNIXTIME"),
 85        }
 86
 87        # https://github.com/apache/doris/blob/e4f41dbf1ec03f5937fdeba2ee1454a20254015b/fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisLexer.g4#L93
 88        RESERVED_KEYWORDS = {
 89            "account_lock",
 90            "account_unlock",
 91            "add",
 92            "adddate",
 93            "admin",
 94            "after",
 95            "agg_state",
 96            "aggregate",
 97            "alias",
 98            "all",
 99            "alter",
100            "analyze",
101            "analyzed",
102            "and",
103            "anti",
104            "append",
105            "array",
106            "array_range",
107            "as",
108            "asc",
109            "at",
110            "authors",
111            "auto",
112            "auto_increment",
113            "backend",
114            "backends",
115            "backup",
116            "begin",
117            "belong",
118            "between",
119            "bigint",
120            "bin",
121            "binary",
122            "binlog",
123            "bitand",
124            "bitmap",
125            "bitmap_union",
126            "bitor",
127            "bitxor",
128            "blob",
129            "boolean",
130            "brief",
131            "broker",
132            "buckets",
133            "build",
134            "builtin",
135            "bulk",
136            "by",
137            "cached",
138            "call",
139            "cancel",
140            "case",
141            "cast",
142            "catalog",
143            "catalogs",
144            "chain",
145            "char",
146            "character",
147            "charset",
148            "check",
149            "clean",
150            "cluster",
151            "clusters",
152            "collate",
153            "collation",
154            "collect",
155            "column",
156            "columns",
157            "comment",
158            "commit",
159            "committed",
160            "compact",
161            "complete",
162            "config",
163            "connection",
164            "connection_id",
165            "consistent",
166            "constraint",
167            "constraints",
168            "convert",
169            "copy",
170            "count",
171            "create",
172            "creation",
173            "cron",
174            "cross",
175            "cube",
176            "current",
177            "current_catalog",
178            "current_date",
179            "current_time",
180            "current_timestamp",
181            "current_user",
182            "data",
183            "database",
184            "databases",
185            "date",
186            "date_add",
187            "date_ceil",
188            "date_diff",
189            "date_floor",
190            "date_sub",
191            "dateadd",
192            "datediff",
193            "datetime",
194            "datetimev2",
195            "datev2",
196            "datetimev1",
197            "datev1",
198            "day",
199            "days_add",
200            "days_sub",
201            "decimal",
202            "decimalv2",
203            "decimalv3",
204            "decommission",
205            "default",
206            "deferred",
207            "delete",
208            "demand",
209            "desc",
210            "describe",
211            "diagnose",
212            "disk",
213            "distinct",
214            "distinctpc",
215            "distinctpcsa",
216            "distributed",
217            "distribution",
218            "div",
219            "do",
220            "doris_internal_table_id",
221            "double",
222            "drop",
223            "dropp",
224            "dual",
225            "duplicate",
226            "dynamic",
227            "else",
228            "enable",
229            "encryptkey",
230            "encryptkeys",
231            "end",
232            "ends",
233            "engine",
234            "engines",
235            "enter",
236            "errors",
237            "events",
238            "every",
239            "except",
240            "exclude",
241            "execute",
242            "exists",
243            "expired",
244            "explain",
245            "export",
246            "extended",
247            "external",
248            "extract",
249            "failed_login_attempts",
250            "false",
251            "fast",
252            "feature",
253            "fields",
254            "file",
255            "filter",
256            "first",
257            "float",
258            "follower",
259            "following",
260            "for",
261            "foreign",
262            "force",
263            "format",
264            "free",
265            "from",
266            "frontend",
267            "frontends",
268            "full",
269            "function",
270            "functions",
271            "generic",
272            "global",
273            "grant",
274            "grants",
275            "graph",
276            "group",
277            "grouping",
278            "groups",
279            "hash",
280            "having",
281            "hdfs",
282            "help",
283            "histogram",
284            "hll",
285            "hll_union",
286            "hostname",
287            "hour",
288            "hub",
289            "identified",
290            "if",
291            "ignore",
292            "immediate",
293            "in",
294            "incremental",
295            "index",
296            "indexes",
297            "infile",
298            "inner",
299            "insert",
300            "install",
301            "int",
302            "integer",
303            "intermediate",
304            "intersect",
305            "interval",
306            "into",
307            "inverted",
308            "ipv4",
309            "ipv6",
310            "is",
311            "is_not_null_pred",
312            "is_null_pred",
313            "isnull",
314            "isolation",
315            "job",
316            "jobs",
317            "join",
318            "json",
319            "jsonb",
320            "key",
321            "keys",
322            "kill",
323            "label",
324            "largeint",
325            "last",
326            "lateral",
327            "ldap",
328            "ldap_admin_password",
329            "left",
330            "less",
331            "level",
332            "like",
333            "limit",
334            "lines",
335            "link",
336            "list",
337            "load",
338            "local",
339            "localtime",
340            "localtimestamp",
341            "location",
342            "lock",
343            "logical",
344            "low_priority",
345            "manual",
346            "map",
347            "match",
348            "match_all",
349            "match_any",
350            "match_phrase",
351            "match_phrase_edge",
352            "match_phrase_prefix",
353            "match_regexp",
354            "materialized",
355            "max",
356            "maxvalue",
357            "memo",
358            "merge",
359            "migrate",
360            "migrations",
361            "min",
362            "minus",
363            "minute",
364            "modify",
365            "month",
366            "mtmv",
367            "name",
368            "names",
369            "natural",
370            "negative",
371            "never",
372            "next",
373            "ngram_bf",
374            "no",
375            "non_nullable",
376            "not",
377            "null",
378            "nulls",
379            "observer",
380            "of",
381            "offset",
382            "on",
383            "only",
384            "open",
385            "optimized",
386            "or",
387            "order",
388            "outer",
389            "outfile",
390            "over",
391            "overwrite",
392            "parameter",
393            "parsed",
394            "partition",
395            "partitions",
396            "password",
397            "password_expire",
398            "password_history",
399            "password_lock_time",
400            "password_reuse",
401            "path",
402            "pause",
403            "percent",
404            "period",
405            "permissive",
406            "physical",
407            "plan",
408            "process",
409            "plugin",
410            "plugins",
411            "policy",
412            "preceding",
413            "prepare",
414            "primary",
415            "proc",
416            "procedure",
417            "processlist",
418            "profile",
419            "properties",
420            "property",
421            "quantile_state",
422            "quantile_union",
423            "query",
424            "quota",
425            "random",
426            "range",
427            "read",
428            "real",
429            "rebalance",
430            "recover",
431            "recycle",
432            "refresh",
433            "references",
434            "regexp",
435            "release",
436            "rename",
437            "repair",
438            "repeatable",
439            "replace",
440            "replace_if_not_null",
441            "replica",
442            "repositories",
443            "repository",
444            "resource",
445            "resources",
446            "restore",
447            "restrictive",
448            "resume",
449            "returns",
450            "revoke",
451            "rewritten",
452            "right",
453            "rlike",
454            "role",
455            "roles",
456            "rollback",
457            "rollup",
458            "routine",
459            "row",
460            "rows",
461            "s3",
462            "sample",
463            "schedule",
464            "scheduler",
465            "schema",
466            "schemas",
467            "second",
468            "select",
469            "semi",
470            "sequence",
471            "serializable",
472            "session",
473            "set",
474            "sets",
475            "shape",
476            "show",
477            "signed",
478            "skew",
479            "smallint",
480            "snapshot",
481            "soname",
482            "split",
483            "sql_block_rule",
484            "start",
485            "starts",
486            "stats",
487            "status",
488            "stop",
489            "storage",
490            "stream",
491            "streaming",
492            "string",
493            "struct",
494            "subdate",
495            "sum",
496            "superuser",
497            "switch",
498            "sync",
499            "system",
500            "table",
501            "tables",
502            "tablesample",
503            "tablet",
504            "tablets",
505            "task",
506            "tasks",
507            "temporary",
508            "terminated",
509            "text",
510            "than",
511            "then",
512            "time",
513            "timestamp",
514            "timestampadd",
515            "timestampdiff",
516            "tinyint",
517            "to",
518            "transaction",
519            "trash",
520            "tree",
521            "triggers",
522            "trim",
523            "true",
524            "truncate",
525            "type",
526            "type_cast",
527            "types",
528            "unbounded",
529            "uncommitted",
530            "uninstall",
531            "union",
532            "unique",
533            "unlock",
534            "unsigned",
535            "update",
536            "use",
537            "user",
538            "using",
539            "value",
540            "values",
541            "varchar",
542            "variables",
543            "variant",
544            "vault",
545            "verbose",
546            "version",
547            "view",
548            "warnings",
549            "week",
550            "when",
551            "where",
552            "whitelist",
553            "with",
554            "work",
555            "workload",
556            "write",
557            "xor",
558            "year",
559        }

class Doris(sqlglot.dialects.mysql.MySQL): View Source

 24class Doris(MySQL):
 25    DATE_FORMAT = "'yyyy-MM-dd'"
 26    DATEINT_FORMAT = "'yyyyMMdd'"
 27    TIME_FORMAT = "'yyyy-MM-dd HH:mm:ss'"
 28
 29    class Parser(MySQL.Parser):
 30        FUNCTIONS = {
 31            **MySQL.Parser.FUNCTIONS,
 32            "COLLECT_SET": exp.ArrayUniqueAgg.from_arg_list,
 33            "DATE_TRUNC": build_timestamp_trunc,
 34            "MONTHS_ADD": exp.AddMonths.from_arg_list,
 35            "REGEXP": exp.RegexpLike.from_arg_list,
 36            "TO_DATE": exp.TsOrDsToDate.from_arg_list,
 37        }
 38
 39        FUNCTION_PARSERS = MySQL.Parser.FUNCTION_PARSERS.copy()
 40        FUNCTION_PARSERS.pop("GROUP_CONCAT")
 41
 42    class Generator(MySQL.Generator):
 43        LAST_DAY_SUPPORTS_DATE_PART = False
 44
 45        TYPE_MAPPING = {
 46            **MySQL.Generator.TYPE_MAPPING,
 47            exp.DataType.Type.TEXT: "STRING",
 48            exp.DataType.Type.TIMESTAMP: "DATETIME",
 49            exp.DataType.Type.TIMESTAMPTZ: "DATETIME",
 50        }
 51
 52        CAST_MAPPING = {}
 53        TIMESTAMP_FUNC_TYPES = set()
 54
 55        TRANSFORMS = {
 56            **MySQL.Generator.TRANSFORMS,
 57            exp.AddMonths: rename_func("MONTHS_ADD"),
 58            exp.ApproxDistinct: approx_count_distinct_sql,
 59            exp.ArgMax: rename_func("MAX_BY"),
 60            exp.ArgMin: rename_func("MIN_BY"),
 61            exp.ArrayAgg: rename_func("COLLECT_LIST"),
 62            exp.ArrayUniqueAgg: rename_func("COLLECT_SET"),
 63            exp.CurrentTimestamp: lambda self, _: self.func("NOW"),
 64            exp.DateTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, unit_to_str(e)),
 65            exp.GroupConcat: lambda self, e: self.func(
 66                "GROUP_CONCAT", e.this, e.args.get("separator") or exp.Literal.string(",")
 67            ),
 68            exp.JSONExtractScalar: lambda self, e: self.func("JSON_EXTRACT", e.this, e.expression),
 69            exp.Lag: _lag_lead_sql,
 70            exp.Lead: _lag_lead_sql,
 71            exp.Map: rename_func("ARRAY_MAP"),
 72            exp.RegexpLike: rename_func("REGEXP"),
 73            exp.RegexpSplit: rename_func("SPLIT_BY_STRING"),
 74            exp.Split: rename_func("SPLIT_BY_STRING"),
 75            exp.StringToArray: rename_func("SPLIT_BY_STRING"),
 76            exp.StrToUnix: lambda self, e: self.func("UNIX_TIMESTAMP", e.this, self.format_time(e)),
 77            exp.TimeStrToDate: rename_func("TO_DATE"),
 78            exp.TsOrDsAdd: lambda self, e: self.func("DATE_ADD", e.this, e.expression),
 79            exp.TsOrDsToDate: lambda self, e: self.func("TO_DATE", e.this),
 80            exp.TimeToUnix: rename_func("UNIX_TIMESTAMP"),
 81            exp.TimestampTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, unit_to_str(e)),
 82            exp.UnixToStr: lambda self, e: self.func(
 83                "FROM_UNIXTIME", e.this, time_format("doris")(self, e)
 84            ),
 85            exp.UnixToTime: rename_func("FROM_UNIXTIME"),
 86        }
 87
 88        # https://github.com/apache/doris/blob/e4f41dbf1ec03f5937fdeba2ee1454a20254015b/fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisLexer.g4#L93
 89        RESERVED_KEYWORDS = {
 90            "account_lock",
 91            "account_unlock",
 92            "add",
 93            "adddate",
 94            "admin",
 95            "after",
 96            "agg_state",
 97            "aggregate",
 98            "alias",
 99            "all",
100            "alter",
101            "analyze",
102            "analyzed",
103            "and",
104            "anti",
105            "append",
106            "array",
107            "array_range",
108            "as",
109            "asc",
110            "at",
111            "authors",
112            "auto",
113            "auto_increment",
114            "backend",
115            "backends",
116            "backup",
117            "begin",
118            "belong",
119            "between",
120            "bigint",
121            "bin",
122            "binary",
123            "binlog",
124            "bitand",
125            "bitmap",
126            "bitmap_union",
127            "bitor",
128            "bitxor",
129            "blob",
130            "boolean",
131            "brief",
132            "broker",
133            "buckets",
134            "build",
135            "builtin",
136            "bulk",
137            "by",
138            "cached",
139            "call",
140            "cancel",
141            "case",
142            "cast",
143            "catalog",
144            "catalogs",
145            "chain",
146            "char",
147            "character",
148            "charset",
149            "check",
150            "clean",
151            "cluster",
152            "clusters",
153            "collate",
154            "collation",
155            "collect",
156            "column",
157            "columns",
158            "comment",
159            "commit",
160            "committed",
161            "compact",
162            "complete",
163            "config",
164            "connection",
165            "connection_id",
166            "consistent",
167            "constraint",
168            "constraints",
169            "convert",
170            "copy",
171            "count",
172            "create",
173            "creation",
174            "cron",
175            "cross",
176            "cube",
177            "current",
178            "current_catalog",
179            "current_date",
180            "current_time",
181            "current_timestamp",
182            "current_user",
183            "data",
184            "database",
185            "databases",
186            "date",
187            "date_add",
188            "date_ceil",
189            "date_diff",
190            "date_floor",
191            "date_sub",
192            "dateadd",
193            "datediff",
194            "datetime",
195            "datetimev2",
196            "datev2",
197            "datetimev1",
198            "datev1",
199            "day",
200            "days_add",
201            "days_sub",
202            "decimal",
203            "decimalv2",
204            "decimalv3",
205            "decommission",
206            "default",
207            "deferred",
208            "delete",
209            "demand",
210            "desc",
211            "describe",
212            "diagnose",
213            "disk",
214            "distinct",
215            "distinctpc",
216            "distinctpcsa",
217            "distributed",
218            "distribution",
219            "div",
220            "do",
221            "doris_internal_table_id",
222            "double",
223            "drop",
224            "dropp",
225            "dual",
226            "duplicate",
227            "dynamic",
228            "else",
229            "enable",
230            "encryptkey",
231            "encryptkeys",
232            "end",
233            "ends",
234            "engine",
235            "engines",
236            "enter",
237            "errors",
238            "events",
239            "every",
240            "except",
241            "exclude",
242            "execute",
243            "exists",
244            "expired",
245            "explain",
246            "export",
247            "extended",
248            "external",
249            "extract",
250            "failed_login_attempts",
251            "false",
252            "fast",
253            "feature",
254            "fields",
255            "file",
256            "filter",
257            "first",
258            "float",
259            "follower",
260            "following",
261            "for",
262            "foreign",
263            "force",
264            "format",
265            "free",
266            "from",
267            "frontend",
268            "frontends",
269            "full",
270            "function",
271            "functions",
272            "generic",
273            "global",
274            "grant",
275            "grants",
276            "graph",
277            "group",
278            "grouping",
279            "groups",
280            "hash",
281            "having",
282            "hdfs",
283            "help",
284            "histogram",
285            "hll",
286            "hll_union",
287            "hostname",
288            "hour",
289            "hub",
290            "identified",
291            "if",
292            "ignore",
293            "immediate",
294            "in",
295            "incremental",
296            "index",
297            "indexes",
298            "infile",
299            "inner",
300            "insert",
301            "install",
302            "int",
303            "integer",
304            "intermediate",
305            "intersect",
306            "interval",
307            "into",
308            "inverted",
309            "ipv4",
310            "ipv6",
311            "is",
312            "is_not_null_pred",
313            "is_null_pred",
314            "isnull",
315            "isolation",
316            "job",
317            "jobs",
318            "join",
319            "json",
320            "jsonb",
321            "key",
322            "keys",
323            "kill",
324            "label",
325            "largeint",
326            "last",
327            "lateral",
328            "ldap",
329            "ldap_admin_password",
330            "left",
331            "less",
332            "level",
333            "like",
334            "limit",
335            "lines",
336            "link",
337            "list",
338            "load",
339            "local",
340            "localtime",
341            "localtimestamp",
342            "location",
343            "lock",
344            "logical",
345            "low_priority",
346            "manual",
347            "map",
348            "match",
349            "match_all",
350            "match_any",
351            "match_phrase",
352            "match_phrase_edge",
353            "match_phrase_prefix",
354            "match_regexp",
355            "materialized",
356            "max",
357            "maxvalue",
358            "memo",
359            "merge",
360            "migrate",
361            "migrations",
362            "min",
363            "minus",
364            "minute",
365            "modify",
366            "month",
367            "mtmv",
368            "name",
369            "names",
370            "natural",
371            "negative",
372            "never",
373            "next",
374            "ngram_bf",
375            "no",
376            "non_nullable",
377            "not",
378            "null",
379            "nulls",
380            "observer",
381            "of",
382            "offset",
383            "on",
384            "only",
385            "open",
386            "optimized",
387            "or",
388            "order",
389            "outer",
390            "outfile",
391            "over",
392            "overwrite",
393            "parameter",
394            "parsed",
395            "partition",
396            "partitions",
397            "password",
398            "password_expire",
399            "password_history",
400            "password_lock_time",
401            "password_reuse",
402            "path",
403            "pause",
404            "percent",
405            "period",
406            "permissive",
407            "physical",
408            "plan",
409            "process",
410            "plugin",
411            "plugins",
412            "policy",
413            "preceding",
414            "prepare",
415            "primary",
416            "proc",
417            "procedure",
418            "processlist",
419            "profile",
420            "properties",
421            "property",
422            "quantile_state",
423            "quantile_union",
424            "query",
425            "quota",
426            "random",
427            "range",
428            "read",
429            "real",
430            "rebalance",
431            "recover",
432            "recycle",
433            "refresh",
434            "references",
435            "regexp",
436            "release",
437            "rename",
438            "repair",
439            "repeatable",
440            "replace",
441            "replace_if_not_null",
442            "replica",
443            "repositories",
444            "repository",
445            "resource",
446            "resources",
447            "restore",
448            "restrictive",
449            "resume",
450            "returns",
451            "revoke",
452            "rewritten",
453            "right",
454            "rlike",
455            "role",
456            "roles",
457            "rollback",
458            "rollup",
459            "routine",
460            "row",
461            "rows",
462            "s3",
463            "sample",
464            "schedule",
465            "scheduler",
466            "schema",
467            "schemas",
468            "second",
469            "select",
470            "semi",
471            "sequence",
472            "serializable",
473            "session",
474            "set",
475            "sets",
476            "shape",
477            "show",
478            "signed",
479            "skew",
480            "smallint",
481            "snapshot",
482            "soname",
483            "split",
484            "sql_block_rule",
485            "start",
486            "starts",
487            "stats",
488            "status",
489            "stop",
490            "storage",
491            "stream",
492            "streaming",
493            "string",
494            "struct",
495            "subdate",
496            "sum",
497            "superuser",
498            "switch",
499            "sync",
500            "system",
501            "table",
502            "tables",
503            "tablesample",
504            "tablet",
505            "tablets",
506            "task",
507            "tasks",
508            "temporary",
509            "terminated",
510            "text",
511            "than",
512            "then",
513            "time",
514            "timestamp",
515            "timestampadd",
516            "timestampdiff",
517            "tinyint",
518            "to",
519            "transaction",
520            "trash",
521            "tree",
522            "triggers",
523            "trim",
524            "true",
525            "truncate",
526            "type",
527            "type_cast",
528            "types",
529            "unbounded",
530            "uncommitted",
531            "uninstall",
532            "union",
533            "unique",
534            "unlock",
535            "unsigned",
536            "update",
537            "use",
538            "user",
539            "using",
540            "value",
541            "values",
542            "varchar",
543            "variables",
544            "variant",
545            "vault",
546            "verbose",
547            "version",
548            "view",
549            "warnings",
550            "week",
551            "when",
552            "where",
553            "whitelist",
554            "with",
555            "work",
556            "workload",
557            "write",
558            "xor",
559            "year",
560        }

DATE_FORMAT = "'yyyy-MM-dd'"

DATEINT_FORMAT = "'yyyyMMdd'"

TIME_FORMAT = "'yyyy-MM-dd HH:mm:ss'"

SUPPORTS_COLUMN_JOIN_MARKS = False

Whether the old-style outer join (+) syntax is supported.

UNESCAPED_SEQUENCES: Dict[str, str] = {'\\a': '\x07', '\\b': '\x08', '\\f': '\x0c', '\\n': '\n', '\\r': '\r', '\\t': '\t', '\\v': '\x0b', '\\\\': '\\'}

Mapping of an escaped sequence (\n) to its unescaped version ().

tokenizer_class = <class 'sqlglot.tokens.Tokenizer'>

jsonpath_tokenizer_class = <class 'sqlglot.tokens.JSONPathTokenizer'>

parser_class = <class 'Doris.Parser'>

generator_class = <class 'Doris.Generator'>

TIME_TRIE: Dict = {'%': {'M': {0: True}, 'c': {0: True}, 'e': {0: True}, 'h': {0: True}, 'i': {0: True}, 's': {0: True}, 'u': {0: True}, 'k': {0: True}, 'l': {0: True}, 'T': {0: True}, 'W': {0: True}}}

FORMAT_TRIE: Dict = {'%': {'M': {0: True}, 'c': {0: True}, 'e': {0: True}, 'h': {0: True}, 'i': {0: True}, 's': {0: True}, 'u': {0: True}, 'k': {0: True}, 'l': {0: True}, 'T': {0: True}, 'W': {0: True}}}

INVERSE_TIME_MAPPING: Dict[str, str] = {'%B': '%M', '%-m': '%c', '%-d': '%e', '%I': '%h', '%M': '%i', '%S': '%s', '%W': '%u', '%-H': '%k', '%-I': '%l', '%H:%M:%S': '%T', '%a': '%W'}

INVERSE_TIME_TRIE: Dict = {'%': {'B': {0: True}, '-': {'m': {0: True}, 'd': {0: True}, 'H': {0: True}, 'I': {0: True}}, 'I': {0: True}, 'M': {0: True}, 'S': {0: True}, 'W': {0: True}, 'H': {':': {'%': {'M': {':': {'%': {'S': {0: True}}}}}}}, 'a': {0: True}}}

INVERSE_FORMAT_MAPPING: Dict[str, str] = {}

INVERSE_FORMAT_TRIE: Dict = {}

ESCAPED_SEQUENCES: Dict[str, str] = {'\x07': '\\a', '\x08': '\\b', '\x0c': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t', '\x0b': '\\v', '\\': '\\\\'}

QUOTE_START = "'"

QUOTE_END = "'"

IDENTIFIER_START = '`'

IDENTIFIER_END = '`'

BIT_START: Optional[str] = "b'"

BIT_END: Optional[str] = "'"

HEX_START: Optional[str] = "x'"

HEX_END: Optional[str] = "'"

BYTE_START: Optional[str] = None

BYTE_END: Optional[str] = None

UNICODE_START: Optional[str] = None

UNICODE_END: Optional[str] = None

Inherited Members

sqlglot.dialects.dialect.Dialect: Dialect; INDEX_OFFSET; WEEK_OFFSET; UNNEST_COLUMN_ONLY; ALIAS_POST_TABLESAMPLE; TABLESAMPLE_SIZE_IS_PERCENT; STRICT_STRING_CONCAT; COPY_PARAMS_ARE_CSV; NORMALIZE_FUNCTIONS; LOG_BASE_FIRST; NULL_ORDERING; TYPED_DIVISION; CONCAT_COALESCE; HEX_LOWERCASE; FORMAT_MAPPING; PSEUDOCOLUMNS; PREFER_CTE_ALIAS_COLUMN; FORCE_EARLY_ALIAS_REF_EXPANSION; EXPAND_ALIAS_REFS_EARLY_ONLY_IN_GROUP_BY; SUPPORTS_ORDER_BY_ALL; DATE_PART_MAPPING; TYPE_TO_EXPRESSIONS; ANNOTATORS; get_or_raise; format_time; settings; normalize_identifier; case_sensitive; can_identify; quote_identifier; to_json_path; parse; parse_into; generate; transpile; tokenize; tokenizer; jsonpath_tokenizer; parser; generator
sqlglot.dialects.mysql.MySQL: IDENTIFIERS_CAN_START_WITH_DIGIT; NORMALIZATION_STRATEGY; DPIPE_IS_STRING_CONCAT; SUPPORTS_USER_DEFINED_TYPES; SUPPORTS_SEMI_ANTI_JOIN; SAFE_DIVISION; TIME_MAPPING; Tokenizer

class Doris.Parser(sqlglot.dialects.mysql.MySQL.Parser): View Source

29    class Parser(MySQL.Parser):
30        FUNCTIONS = {
31            **MySQL.Parser.FUNCTIONS,
32            "COLLECT_SET": exp.ArrayUniqueAgg.from_arg_list,
33            "DATE_TRUNC": build_timestamp_trunc,
34            "MONTHS_ADD": exp.AddMonths.from_arg_list,
35            "REGEXP": exp.RegexpLike.from_arg_list,
36            "TO_DATE": exp.TsOrDsToDate.from_arg_list,
37        }
38
39        FUNCTION_PARSERS = MySQL.Parser.FUNCTION_PARSERS.copy()
40        FUNCTION_PARSERS.pop("GROUP_CONCAT")

Parser consumes a list of tokens produced by the Tokenizer and produces a parsed syntax tree.

Arguments:

error_level: The desired error level. Default: ErrorLevel.IMMEDIATE
error_message_context: The amount of context to capture from a query string when displaying the error message (in number of characters). Default: 100
max_errors: Maximum number of error messages to include in a raised ParseError. This is only relevant if error_level is ErrorLevel.RAISE. Default: 3

FUNCTIONS = {'ABS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Abs'>>, 'ADD_MONTHS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AddMonths'>>, 'ANONYMOUS_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnonymousAggFunc'>>, 'ANY_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnyValue'>>, 'APPROX_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_COUNT_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxQuantile'>>, 'APPROX_TOP_K': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxTopK'>>, 'ARG_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARGMAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'MAX_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARG_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARGMIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'MIN_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Array'>>, 'ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAgg'>>, 'ARRAY_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAll'>>, 'ARRAY_ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAny'>>, 'ARRAY_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CONSTRUCT_COMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConstructCompact'>>, 'ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContains'>>, 'ARRAY_HAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContains'>>, 'ARRAY_CONTAINS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContainsAll'>>, 'ARRAY_HAS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContainsAll'>>, 'FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_OVERLAPS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayOverlaps'>>, 'ARRAY_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_SORT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySort'>>, 'ARRAY_SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySum'>>, 'ARRAY_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayToString'>>, 'ARRAY_JOIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayToString'>>, 'ARRAY_UNION_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUnionAgg'>>, 'ARRAY_UNIQUE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUniqueAgg'>>, 'AVG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Avg'>>, 'CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Case'>>, 'CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cast'>>, 'CAST_TO_STR_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CastToStrType'>>, 'CBRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cbrt'>>, 'CEIL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CEILING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CHR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Chr'>>, 'CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Chr'>>, 'COALESCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'IFNULL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'NVL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'COLLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Collate'>>, 'COMBINED_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedAggFunc'>>, 'COMBINED_PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedParameterizedAgg'>>, 'CONCAT': <function Parser.<lambda>>, 'CONCAT_WS': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ConnectByRoot'>>, 'CONVERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Convert'>>, 'CORR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Corr'>>, 'COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Count'>>, 'COUNT_IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CountIf'>>, 'COUNTIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CountIf'>>, 'COVAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CovarPop'>>, 'COVAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CovarSamp'>>, 'CURRENT_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDate'>>, 'CURRENT_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDatetime'>>, 'CURRENT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTime'>>, 'CURRENT_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTimestamp'>>, 'CURRENT_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentUser'>>, 'DATE': <function MySQL.Parser.<lambda>>, 'DATE_ADD': <function build_date_delta_with_interval.<locals>._builder>, 'DATEDIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateDiff'>>, 'DATE_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateDiff'>>, 'DATE_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATE_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateStrToDate'>>, 'DATE_SUB': <function build_date_delta_with_interval.<locals>._builder>, 'DATE_TO_DATE_STR': <function Parser.<lambda>>, 'DATE_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateToDi'>>, 'DATE_TRUNC': <function build_timestamp_trunc>, 'DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Datetime'>>, 'DATETIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeAdd'>>, 'DATETIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeDiff'>>, 'DATETIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeSub'>>, 'DATETIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeTrunc'>>, 'DAY': <function MySQL.Parser.<lambda>>, 'DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAYOFMONTH': <function MySQL.Parser.<lambda>>, 'DAY_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAYOFWEEK': <function MySQL.Parser.<lambda>>, 'DAY_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DAYOFYEAR': <function MySQL.Parser.<lambda>>, 'DECODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Decode'>>, 'DI_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DiToDate'>>, 'ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Encode'>>, 'EXP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Exp'>>, 'EXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Explode'>>, 'EXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ExplodeOuter'>>, 'EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Extract'>>, 'FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.First'>>, 'FIRST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FirstValue'>>, 'FLATTEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Flatten'>>, 'FLOOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Floor'>>, 'FROM_BASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase'>>, 'FROM_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase64'>>, 'GAP_FILL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GapFill'>>, 'GENERATE_DATE_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateDateArray'>>, 'GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateSeries'>>, 'GREATEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Greatest'>>, 'GROUP_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GroupConcat'>>, 'HEX': <function build_hex>, 'HLL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Hll'>>, 'IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'IIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'INITCAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Initcap'>>, 'IS_INF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'ISINF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'IS_NAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'ISNAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'J_S_O_N_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArray'>>, 'J_S_O_N_ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayAgg'>>, 'JSON_ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayContains'>>, 'JSONB_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBContains'>>, 'JSONB_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtract'>>, 'JSONB_EXTRACT_SCALAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtractScalar'>>, 'JSON_EXTRACT': <function build_extract_json_with_path.<locals>._builder>, 'JSON_EXTRACT_SCALAR': <function build_extract_json_with_path.<locals>._builder>, 'JSON_FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONFormat'>>, 'J_S_O_N_OBJECT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObject'>>, 'J_S_O_N_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObjectAgg'>>, 'J_S_O_N_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONTable'>>, 'LAG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lag'>>, 'LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Last'>>, 'LAST_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastValue'>>, 'LEAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lead'>>, 'LEAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Least'>>, 'LEFT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Left'>>, 'LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEVENSHTEIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Levenshtein'>>, 'LIST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.List'>>, 'LN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ln'>>, 'LOG': <function build_logarithm>, 'LOGICAL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOLAND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'LOGICAL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOLOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'LOWER': <function build_lower>, 'LCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lower'>>, 'LOWER_HEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LowerHex'>>, 'MD5': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5'>>, 'MD5_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5Digest'>>, 'MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Map'>>, 'MAP_FROM_ENTRIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MapFromEntries'>>, 'MATCH_AGAINST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MatchAgainst'>>, 'MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Max'>>, 'MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Min'>>, 'MONTH': <function MySQL.Parser.<lambda>>, 'MONTHS_BETWEEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MonthsBetween'>>, 'NEXT_VALUE_FOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NextValueFor'>>, 'NTH_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NthValue'>>, 'NULLIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nullif'>>, 'NUMBER_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NumberToStr'>>, 'NVL2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nvl2'>>, 'OBJECT_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ObjectInsert'>>, 'OPEN_J_S_O_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.OpenJSON'>>, 'PAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pad'>>, 'PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParameterizedAgg'>>, 'PARSE_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'JSON_PARSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'PERCENTILE_CONT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileCont'>>, 'PERCENTILE_DISC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileDisc'>>, 'POSEXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Posexplode'>>, 'POSEXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PosexplodeOuter'>>, 'POWER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'POW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'PREDICT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Predict'>>, 'QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quantile'>>, 'QUARTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quarter'>>, 'RAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDOM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Randn'>>, 'RANGE_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RangeN'>>, 'READ_CSV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ReadCSV'>>, 'REDUCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Reduce'>>, 'REGEXP_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpExtract'>>, 'REGEXP_I_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpILike'>>, 'REGEXP_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpLike'>>, 'REGEXP_REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpReplace'>>, 'REGEXP_SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpSplit'>>, 'REPEAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Repeat'>>, 'RIGHT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Right'>>, 'ROUND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Round'>>, 'ROW_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RowNumber'>>, 'SHA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA2'>>, 'SAFE_DIVIDE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SafeDivide'>>, 'SIGN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sign'>>, 'SIGNUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sign'>>, 'SORT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SortArray'>>, 'SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Split'>>, 'SQRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sqrt'>>, 'STANDARD_HASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StandardHash'>>, 'STAR_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StarMap'>>, 'STARTS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STARTSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STDDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stddev'>>, 'STDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stddev'>>, 'STDDEV_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevPop'>>, 'STDDEV_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevSamp'>>, 'STR_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrPosition'>>, 'STR_TO_DATE': <function _str_to_date>, 'STR_TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToMap'>>, 'STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToTime'>>, 'STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToUnix'>>, 'STRING_TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StringToArray'>>, 'SPLIT_BY_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StringToArray'>>, 'STRUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Struct'>>, 'STRUCT_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StructExtract'>>, 'STUFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'SUBSTRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Substring'>>, 'SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sum'>>, 'TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Time'>>, 'TIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeAdd'>>, 'TIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeDiff'>>, 'TIME_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIMEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIME_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToDate'>>, 'TIME_STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToTime'>>, 'TIME_STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToUnix'>>, 'TIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeSub'>>, 'TIME_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToStr'>>, 'TIME_TO_TIME_STR': <function Parser.<lambda>>, 'TIME_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToUnix'>>, 'TIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeTrunc'>>, 'TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Timestamp'>>, 'TIMESTAMP_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampAdd'>>, 'TIMESTAMPDIFF': <function build_date_delta.<locals>._builder>, 'TIMESTAMP_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampDiff'>>, 'TIMESTAMP_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMPFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMP_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampSub'>>, 'TIMESTAMP_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampTrunc'>>, 'TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToArray'>>, 'TO_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToBase64'>>, 'TO_CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToChar'>>, 'TO_DAYS': <function MySQL.Parser.<lambda>>, 'TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToMap'>>, 'TO_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToNumber'>>, 'TRANSFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Transform'>>, 'TRIM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Trim'>>, 'TRY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Try'>>, 'TRY_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TryCast'>>, 'TS_OR_DI_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDiToDi'>>, 'TS_OR_DS_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsAdd'>>, 'TS_OR_DS_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsDiff'>>, 'TS_OR_DS_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToDate'>>, 'TS_OR_DS_TO_DATE_STR': <function Parser.<lambda>>, 'TS_OR_DS_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTime'>>, 'TS_OR_DS_TO_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTimestamp'>>, 'UNHEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Unhex'>>, 'UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixDate'>>, 'UNIX_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToStr'>>, 'UNIX_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTime'>>, 'UNIX_TO_TIME_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTimeStr'>>, 'UNNEST': <function Parser.<lambda>>, 'UPPER': <function build_upper>, 'UCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Upper'>>, 'VAR_MAP': <function build_var_map>, 'VARIANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'VAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'WEEK': <function MySQL.Parser.<lambda>>, 'WEEK_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'WEEKOFYEAR': <function MySQL.Parser.<lambda>>, 'WHEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.When'>>, 'X_M_L_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.XMLTable'>>, 'XOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Xor'>>, 'YEAR': <function MySQL.Parser.<lambda>>, 'GLOB': <function Parser.<lambda>>, 'JSON_EXTRACT_PATH_TEXT': <function build_extract_json_with_path.<locals>._builder>, 'LIKE': <function build_like>, 'LOG2': <function Parser.<lambda>>, 'LOG10': <function Parser.<lambda>>, 'LPAD': <function Parser.<lambda>>, 'LEFTPAD': <function Parser.<lambda>>, 'MOD': <function build_mod>, 'RPAD': <function Parser.<lambda>>, 'RIGHTPAD': <function Parser.<lambda>>, 'SCOPE_RESOLUTION': <function Parser.<lambda>>, 'TO_HEX': <function build_hex>, 'DATE_FORMAT': <function build_formatted_time.<locals>._builder>, 'INSTR': <function MySQL.Parser.<lambda>>, 'FROM_UNIXTIME': <function build_formatted_time.<locals>._builder>, 'ISNULL': <function isnull_to_is_null>, 'LOCATE': <function locate_to_strposition>, 'MAKETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'MONTHNAME': <function MySQL.Parser.<lambda>>, 'COLLECT_SET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUniqueAgg'>>, 'MONTHS_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AddMonths'>>, 'REGEXP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpLike'>>, 'TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToDate'>>}

FUNCTION_PARSERS = {'CAST': <function Parser.<lambda>>, 'CONVERT': <function Parser.<lambda>>, 'DECODE': <function Parser.<lambda>>, 'EXTRACT': <function Parser.<lambda>>, 'GAP_FILL': <function Parser.<lambda>>, 'JSON_OBJECT': <function Parser.<lambda>>, 'JSON_OBJECTAGG': <function Parser.<lambda>>, 'JSON_TABLE': <function Parser.<lambda>>, 'MATCH': <function Parser.<lambda>>, 'OPENJSON': <function Parser.<lambda>>, 'POSITION': <function Parser.<lambda>>, 'PREDICT': <function Parser.<lambda>>, 'SAFE_CAST': <function Parser.<lambda>>, 'STRING_AGG': <function Parser.<lambda>>, 'SUBSTRING': <function Parser.<lambda>>, 'TRIM': <function Parser.<lambda>>, 'TRY_CAST': <function Parser.<lambda>>, 'TRY_CONVERT': <function Parser.<lambda>>, 'CHAR': <function MySQL.Parser.<lambda>>, 'VALUES': <function MySQL.Parser.<lambda>>}

TABLE_ALIAS_TOKENS = {<TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.FINAL: 'FINAL'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.TAG: 'TAG'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.TIME: 'TIME'>, <TokenType.COPY: 'COPY'>, <TokenType.DELETE: 'DELETE'>, <TokenType.INT256: 'INT256'>, <TokenType.TRUE: 'TRUE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.ANTI: 'ANTI'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.FILTER: 'FILTER'>, <TokenType.CACHE: 'CACHE'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.ROWS: 'ROWS'>, <TokenType.NESTED: 'NESTED'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.KEEP: 'KEEP'>, <TokenType.CASE: 'CASE'>, <TokenType.KILL: 'KILL'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.UINT128: 'UINT128'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.IPV6: 'IPV6'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.BINARY: 'BINARY'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.ROW: 'ROW'>, <TokenType.TEXT: 'TEXT'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.INDEX: 'INDEX'>, <TokenType.IPV4: 'IPV4'>, <TokenType.INT128: 'INT128'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.TABLE: 'TABLE'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.LIST: 'LIST'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.ALL: 'ALL'>, <TokenType.MAP: 'MAP'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.NULL: 'NULL'>, <TokenType.SEMI: 'SEMI'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.MONEY: 'MONEY'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.VIEW: 'VIEW'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.NEXT: 'NEXT'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.SUPER: 'SUPER'>, <TokenType.END: 'END'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.CHAR: 'CHAR'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.UINT: 'UINT'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TOP: 'TOP'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.SOME: 'SOME'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.DESC: 'DESC'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.RANGE: 'RANGE'>, <TokenType.FIRST: 'FIRST'>, <TokenType.UUID: 'UUID'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.MERGE: 'MERGE'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.VAR: 'VAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.NAME: 'NAME'>, <TokenType.JSON: 'JSON'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.IS: 'IS'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.YEAR: 'YEAR'>, <TokenType.XML: 'XML'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.DATE32: 'DATE32'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.JSONB: 'JSONB'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.BIT: 'BIT'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.LOAD: 'LOAD'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.UINT256: 'UINT256'>, <TokenType.DIV: 'DIV'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.SHOW: 'SHOW'>, <TokenType.ASC: 'ASC'>, <TokenType.INT: 'INT'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.INET: 'INET'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.ANY: 'ANY'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.FALSE: 'FALSE'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.ENUM: 'ENUM'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.SET: 'SET'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.DATE: 'DATE'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.PROCEDURE: 'PROCEDURE'>}

SHOW_TRIE: Dict = {'BINARY': {'LOGS': {0: True}}, 'MASTER': {'LOGS': {0: True}, 'STATUS': {0: True}}, 'BINLOG': {'EVENTS': {0: True}}, 'CHARACTER': {'SET': {0: True}}, 'CHARSET': {0: True}, 'COLLATION': {0: True}, 'FULL': {'COLUMNS': {0: True}, 'PROCESSLIST': {0: True}, 'TABLES': {0: True}}, 'COLUMNS': {0: True}, 'CREATE': {'DATABASE': {0: True}, 'EVENT': {0: True}, 'FUNCTION': {0: True}, 'PROCEDURE': {0: True}, 'TABLE': {0: True}, 'TRIGGER': {0: True}, 'VIEW': {0: True}}, 'DATABASES': {0: True}, 'SCHEMAS': {0: True}, 'ENGINE': {0: True}, 'STORAGE': {'ENGINES': {0: True}}, 'ENGINES': {0: True}, 'ERRORS': {0: True}, 'EVENTS': {0: True}, 'FUNCTION': {'CODE': {0: True}, 'STATUS': {0: True}}, 'GRANTS': {0: True}, 'INDEX': {0: True}, 'OPEN': {'TABLES': {0: True}}, 'PLUGINS': {0: True}, 'PROCEDURE': {'CODE': {0: True}, 'STATUS': {0: True}}, 'PRIVILEGES': {0: True}, 'PROCESSLIST': {0: True}, 'PROFILE': {0: True}, 'PROFILES': {0: True}, 'RELAYLOG': {'EVENTS': {0: True}}, 'REPLICAS': {0: True}, 'SLAVE': {'HOSTS': {0: True}, 'STATUS': {0: True}}, 'REPLICA': {'STATUS': {0: True}}, 'GLOBAL': {'STATUS': {0: True}, 'VARIABLES': {0: True}}, 'SESSION': {'STATUS': {0: True}, 'VARIABLES': {0: True}}, 'STATUS': {0: True}, 'TABLE': {'STATUS': {0: True}}, 'TABLES': {0: True}, 'TRIGGERS': {0: True}, 'VARIABLES': {0: True}, 'WARNINGS': {0: True}}

SET_TRIE: Dict = {'GLOBAL': {0: True}, 'LOCAL': {0: True}, 'SESSION': {0: True}, 'TRANSACTION': {0: True}, 'PERSIST': {0: True}, 'PERSIST_ONLY': {0: True}, 'CHARACTER': {'SET': {0: True}}, 'CHARSET': {0: True}, 'NAMES': {0: True}}

Inherited Members

sqlglot.parser.Parser: Parser; NO_PAREN_FUNCTIONS; STRUCT_TYPE_TOKENS; NESTED_TYPE_TOKENS; AGGREGATE_TYPE_TOKENS; SIGNED_TO_UNSIGNED_TYPE_TOKEN; SUBQUERY_PREDICATES; RESERVED_TOKENS; DB_CREATABLES; CREATABLES; ID_VAR_TOKENS; INTERVAL_VARS; ALIAS_TOKENS; ARRAY_CONSTRUCTORS; COMMENT_TABLE_ALIAS_TOKENS; UPDATE_ALIAS_TOKENS; TRIM_TYPES; ASSIGNMENT; EQUALITY; COMPARISON; BITWISE; TERM; FACTOR; EXPONENT; TIMES; TIMESTAMPS; SET_OPERATIONS; JOIN_METHODS; JOIN_SIDES; JOIN_KINDS; JOIN_HINTS; LAMBDAS; COLUMN_OPERATORS; EXPRESSION_PARSERS; UNARY_PARSERS; STRING_PARSERS; NUMERIC_PARSERS; PRIMARY_PARSERS; PLACEHOLDER_PARSERS; ALTER_ALTER_PARSERS; NO_PAREN_FUNCTION_PARSERS; INVALID_FUNC_NAME_TOKENS; FUNCTIONS_WITH_ALIASED_ARGS; KEY_VALUE_DEFINITIONS; QUERY_MODIFIER_PARSERS; TYPE_LITERAL_PARSERS; TYPE_CONVERTERS; DDL_SELECT_TOKENS; PRE_VOLATILE_TOKENS; TRANSACTION_KIND; TRANSACTION_CHARACTERISTICS; CONFLICT_ACTIONS; CREATE_SEQUENCE; ISOLATED_LOADING_OPTIONS; USABLES; CAST_ACTIONS; SCHEMA_BINDING_OPTIONS; KEY_CONSTRAINT_OPTIONS; INSERT_ALTERNATIVES; CLONE_KEYWORDS; HISTORICAL_DATA_PREFIX; HISTORICAL_DATA_KIND; OPCLASS_FOLLOW_KEYWORDS; OPTYPE_FOLLOW_TOKENS; TABLE_INDEX_HINT_TOKENS; VIEW_ATTRIBUTES; WINDOW_ALIAS_TOKENS; WINDOW_BEFORE_PAREN_TOKENS; WINDOW_SIDES; JSON_KEY_VALUE_SEPARATOR_TOKENS; FETCH_TOKENS; ADD_CONSTRAINT_TOKENS; DISTINCT_TOKENS; NULL_TOKENS; UNNEST_OFFSET_ALIAS_TOKENS; SELECT_START_TOKENS; COPY_INTO_VARLEN_OPTIONS; STRICT_CAST; PREFIXED_PIVOT_COLUMNS; IDENTIFY_PIVOT_STRINGS; ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN; TABLESAMPLE_CSV; DEFAULT_SAMPLING_METHOD; SET_REQUIRES_ASSIGNMENT_DELIMITER; TRIM_PATTERN_FIRST; MODIFIERS_ATTACHED_TO_SET_OP; SET_OP_MODIFIERS; NO_PAREN_IF_COMMANDS; JSON_ARROWS_REQUIRE_JSON_TYPE; COLON_IS_VARIANT_EXTRACT; SUPPORTS_IMPLICIT_UNNEST; INTERVAL_SPANS; error_level; error_message_context; max_errors; dialect; reset; parse; parse_into; check_errors; raise_error; expression; validate_expression; errors; sql
sqlglot.dialects.mysql.MySQL.Parser: FUNC_TOKENS; CONJUNCTION; DISJUNCTION; RANGE_PARSERS; STATEMENT_PARSERS; SHOW_PARSERS; PROPERTY_PARSERS; SET_PARSERS; CONSTRAINT_PARSERS; ALTER_PARSERS; SCHEMA_UNNAMED_CONSTRAINTS; PROFILE_TYPES; TYPE_TOKENS; ENUM_TYPE_TOKENS; LOG_DEFAULTS_TO_LN; STRING_ALIASES; VALUES_FOLLOWED_BY_PAREN; SUPPORTS_PARTITION_SELECTION

class Doris.Generator(sqlglot.dialects.mysql.MySQL.Generator): View Source

 42    class Generator(MySQL.Generator):
 43        LAST_DAY_SUPPORTS_DATE_PART = False
 44
 45        TYPE_MAPPING = {
 46            **MySQL.Generator.TYPE_MAPPING,
 47            exp.DataType.Type.TEXT: "STRING",
 48            exp.DataType.Type.TIMESTAMP: "DATETIME",
 49            exp.DataType.Type.TIMESTAMPTZ: "DATETIME",
 50        }
 51
 52        CAST_MAPPING = {}
 53        TIMESTAMP_FUNC_TYPES = set()
 54
 55        TRANSFORMS = {
 56            **MySQL.Generator.TRANSFORMS,
 57            exp.AddMonths: rename_func("MONTHS_ADD"),
 58            exp.ApproxDistinct: approx_count_distinct_sql,
 59            exp.ArgMax: rename_func("MAX_BY"),
 60            exp.ArgMin: rename_func("MIN_BY"),
 61            exp.ArrayAgg: rename_func("COLLECT_LIST"),
 62            exp.ArrayUniqueAgg: rename_func("COLLECT_SET"),
 63            exp.CurrentTimestamp: lambda self, _: self.func("NOW"),
 64            exp.DateTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, unit_to_str(e)),
 65            exp.GroupConcat: lambda self, e: self.func(
 66                "GROUP_CONCAT", e.this, e.args.get("separator") or exp.Literal.string(",")
 67            ),
 68            exp.JSONExtractScalar: lambda self, e: self.func("JSON_EXTRACT", e.this, e.expression),
 69            exp.Lag: _lag_lead_sql,
 70            exp.Lead: _lag_lead_sql,
 71            exp.Map: rename_func("ARRAY_MAP"),
 72            exp.RegexpLike: rename_func("REGEXP"),
 73            exp.RegexpSplit: rename_func("SPLIT_BY_STRING"),
 74            exp.Split: rename_func("SPLIT_BY_STRING"),
 75            exp.StringToArray: rename_func("SPLIT_BY_STRING"),
 76            exp.StrToUnix: lambda self, e: self.func("UNIX_TIMESTAMP", e.this, self.format_time(e)),
 77            exp.TimeStrToDate: rename_func("TO_DATE"),
 78            exp.TsOrDsAdd: lambda self, e: self.func("DATE_ADD", e.this, e.expression),
 79            exp.TsOrDsToDate: lambda self, e: self.func("TO_DATE", e.this),
 80            exp.TimeToUnix: rename_func("UNIX_TIMESTAMP"),
 81            exp.TimestampTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, unit_to_str(e)),
 82            exp.UnixToStr: lambda self, e: self.func(
 83                "FROM_UNIXTIME", e.this, time_format("doris")(self, e)
 84            ),
 85            exp.UnixToTime: rename_func("FROM_UNIXTIME"),
 86        }
 87
 88        # https://github.com/apache/doris/blob/e4f41dbf1ec03f5937fdeba2ee1454a20254015b/fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisLexer.g4#L93
 89        RESERVED_KEYWORDS = {
 90            "account_lock",
 91            "account_unlock",
 92            "add",
 93            "adddate",
 94            "admin",
 95            "after",
 96            "agg_state",
 97            "aggregate",
 98            "alias",
 99            "all",
100            "alter",
101            "analyze",
102            "analyzed",
103            "and",
104            "anti",
105            "append",
106            "array",
107            "array_range",
108            "as",
109            "asc",
110            "at",
111            "authors",
112            "auto",
113            "auto_increment",
114            "backend",
115            "backends",
116            "backup",
117            "begin",
118            "belong",
119            "between",
120            "bigint",
121            "bin",
122            "binary",
123            "binlog",
124            "bitand",
125            "bitmap",
126            "bitmap_union",
127            "bitor",
128            "bitxor",
129            "blob",
130            "boolean",
131            "brief",
132            "broker",
133            "buckets",
134            "build",
135            "builtin",
136            "bulk",
137            "by",
138            "cached",
139            "call",
140            "cancel",
141            "case",
142            "cast",
143            "catalog",
144            "catalogs",
145            "chain",
146            "char",
147            "character",
148            "charset",
149            "check",
150            "clean",
151            "cluster",
152            "clusters",
153            "collate",
154            "collation",
155            "collect",
156            "column",
157            "columns",
158            "comment",
159            "commit",
160            "committed",
161            "compact",
162            "complete",
163            "config",
164            "connection",
165            "connection_id",
166            "consistent",
167            "constraint",
168            "constraints",
169            "convert",
170            "copy",
171            "count",
172            "create",
173            "creation",
174            "cron",
175            "cross",
176            "cube",
177            "current",
178            "current_catalog",
179            "current_date",
180            "current_time",
181            "current_timestamp",
182            "current_user",
183            "data",
184            "database",
185            "databases",
186            "date",
187            "date_add",
188            "date_ceil",
189            "date_diff",
190            "date_floor",
191            "date_sub",
192            "dateadd",
193            "datediff",
194            "datetime",
195            "datetimev2",
196            "datev2",
197            "datetimev1",
198            "datev1",
199            "day",
200            "days_add",
201            "days_sub",
202            "decimal",
203            "decimalv2",
204            "decimalv3",
205            "decommission",
206            "default",
207            "deferred",
208            "delete",
209            "demand",
210            "desc",
211            "describe",
212            "diagnose",
213            "disk",
214            "distinct",
215            "distinctpc",
216            "distinctpcsa",
217            "distributed",
218            "distribution",
219            "div",
220            "do",
221            "doris_internal_table_id",
222            "double",
223            "drop",
224            "dropp",
225            "dual",
226            "duplicate",
227            "dynamic",
228            "else",
229            "enable",
230            "encryptkey",
231            "encryptkeys",
232            "end",
233            "ends",
234            "engine",
235            "engines",
236            "enter",
237            "errors",
238            "events",
239            "every",
240            "except",
241            "exclude",
242            "execute",
243            "exists",
244            "expired",
245            "explain",
246            "export",
247            "extended",
248            "external",
249            "extract",
250            "failed_login_attempts",
251            "false",
252            "fast",
253            "feature",
254            "fields",
255            "file",
256            "filter",
257            "first",
258            "float",
259            "follower",
260            "following",
261            "for",
262            "foreign",
263            "force",
264            "format",
265            "free",
266            "from",
267            "frontend",
268            "frontends",
269            "full",
270            "function",
271            "functions",
272            "generic",
273            "global",
274            "grant",
275            "grants",
276            "graph",
277            "group",
278            "grouping",
279            "groups",
280            "hash",
281            "having",
282            "hdfs",
283            "help",
284            "histogram",
285            "hll",
286            "hll_union",
287            "hostname",
288            "hour",
289            "hub",
290            "identified",
291            "if",
292            "ignore",
293            "immediate",
294            "in",
295            "incremental",
296            "index",
297            "indexes",
298            "infile",
299            "inner",
300            "insert",
301            "install",
302            "int",
303            "integer",
304            "intermediate",
305            "intersect",
306            "interval",
307            "into",
308            "inverted",
309            "ipv4",
310            "ipv6",
311            "is",
312            "is_not_null_pred",
313            "is_null_pred",
314            "isnull",
315            "isolation",
316            "job",
317            "jobs",
318            "join",
319            "json",
320            "jsonb",
321            "key",
322            "keys",
323            "kill",
324            "label",
325            "largeint",
326            "last",
327            "lateral",
328            "ldap",
329            "ldap_admin_password",
330            "left",
331            "less",
332            "level",
333            "like",
334            "limit",
335            "lines",
336            "link",
337            "list",
338            "load",
339            "local",
340            "localtime",
341            "localtimestamp",
342            "location",
343            "lock",
344            "logical",
345            "low_priority",
346            "manual",
347            "map",
348            "match",
349            "match_all",
350            "match_any",
351            "match_phrase",
352            "match_phrase_edge",
353            "match_phrase_prefix",
354            "match_regexp",
355            "materialized",
356            "max",
357            "maxvalue",
358            "memo",
359            "merge",
360            "migrate",
361            "migrations",
362            "min",
363            "minus",
364            "minute",
365            "modify",
366            "month",
367            "mtmv",
368            "name",
369            "names",
370            "natural",
371            "negative",
372            "never",
373            "next",
374            "ngram_bf",
375            "no",
376            "non_nullable",
377            "not",
378            "null",
379            "nulls",
380            "observer",
381            "of",
382            "offset",
383            "on",
384            "only",
385            "open",
386            "optimized",
387            "or",
388            "order",
389            "outer",
390            "outfile",
391            "over",
392            "overwrite",
393            "parameter",
394            "parsed",
395            "partition",
396            "partitions",
397            "password",
398            "password_expire",
399            "password_history",
400            "password_lock_time",
401            "password_reuse",
402            "path",
403            "pause",
404            "percent",
405            "period",
406            "permissive",
407            "physical",
408            "plan",
409            "process",
410            "plugin",
411            "plugins",
412            "policy",
413            "preceding",
414            "prepare",
415            "primary",
416            "proc",
417            "procedure",
418            "processlist",
419            "profile",
420            "properties",
421            "property",
422            "quantile_state",
423            "quantile_union",
424            "query",
425            "quota",
426            "random",
427            "range",
428            "read",
429            "real",
430            "rebalance",
431            "recover",
432            "recycle",
433            "refresh",
434            "references",
435            "regexp",
436            "release",
437            "rename",
438            "repair",
439            "repeatable",
440            "replace",
441            "replace_if_not_null",
442            "replica",
443            "repositories",
444            "repository",
445            "resource",
446            "resources",
447            "restore",
448            "restrictive",
449            "resume",
450            "returns",
451            "revoke",
452            "rewritten",
453            "right",
454            "rlike",
455            "role",
456            "roles",
457            "rollback",
458            "rollup",
459            "routine",
460            "row",
461            "rows",
462            "s3",
463            "sample",
464            "schedule",
465            "scheduler",
466            "schema",
467            "schemas",
468            "second",
469            "select",
470            "semi",
471            "sequence",
472            "serializable",
473            "session",
474            "set",
475            "sets",
476            "shape",
477            "show",
478            "signed",
479            "skew",
480            "smallint",
481            "snapshot",
482            "soname",
483            "split",
484            "sql_block_rule",
485            "start",
486            "starts",
487            "stats",
488            "status",
489            "stop",
490            "storage",
491            "stream",
492            "streaming",
493            "string",
494            "struct",
495            "subdate",
496            "sum",
497            "superuser",
498            "switch",
499            "sync",
500            "system",
501            "table",
502            "tables",
503            "tablesample",
504            "tablet",
505            "tablets",
506            "task",
507            "tasks",
508            "temporary",
509            "terminated",
510            "text",
511            "than",
512            "then",
513            "time",
514            "timestamp",
515            "timestampadd",
516            "timestampdiff",
517            "tinyint",
518            "to",
519            "transaction",
520            "trash",
521            "tree",
522            "triggers",
523            "trim",
524            "true",
525            "truncate",
526            "type",
527            "type_cast",
528            "types",
529            "unbounded",
530            "uncommitted",
531            "uninstall",
532            "union",
533            "unique",
534            "unlock",
535            "unsigned",
536            "update",
537            "use",
538            "user",
539            "using",
540            "value",
541            "values",
542            "varchar",
543            "variables",
544            "variant",
545            "vault",
546            "verbose",
547            "version",
548            "view",
549            "warnings",
550            "week",
551            "when",
552            "where",
553            "whitelist",
554            "with",
555            "work",
556            "workload",
557            "write",
558            "xor",
559            "year",
560        }

Generator converts a given syntax tree to the corresponding SQL string.

Arguments:

pretty: Whether to format the produced SQL string. Default: False.
identify: Determines when an identifier should be quoted. Possible values are: False (default): Never quote, except in cases where it's mandatory by the dialect. True or 'always': Always quote. 'safe': Only quote identifiers that are case insensitive.
normalize: Whether to normalize identifiers to lowercase. Default: False.
pad: The pad size in a formatted string. For example, this affects the indentation of a projection in a query, relative to its nesting level. Default: 2.
indent: The indentation size in a formatted string. For example, this affects the indentation of subqueries and filters under a WHERE clause. Default: 2.
normalize_functions: How to normalize function names. Possible values are: "upper" or True (default): Convert names to uppercase. "lower": Convert names to lowercase. False: Disables function name normalization.
unsupported_level: Determines the generator's behavior when it encounters unsupported expressions. Default ErrorLevel.WARN.
max_unsupported: Maximum number of unsupported messages to include in a raised UnsupportedError. This is only relevant if unsupported_level is ErrorLevel.RAISE. Default: 3
leading_comma: Whether the comma is leading or trailing in select expressions. This is only relevant when generating in pretty mode. Default: False
max_text_width: The max number of characters in a segment before creating new lines in pretty mode. The default is on the smaller end because the length only represents a segment and not the true line length. Default: 80
comments: Whether to preserve comments in the output SQL code. Default: True

LAST_DAY_SUPPORTS_DATE_PART = False

TYPE_MAPPING = {<Type.NCHAR: 'NCHAR'>: 'CHAR', <Type.NVARCHAR: 'NVARCHAR'>: 'VARCHAR', <Type.INET: 'INET'>: 'INET', <Type.ROWVERSION: 'ROWVERSION'>: 'VARBINARY', <Type.UBIGINT: 'UBIGINT'>: 'BIGINT', <Type.UINT: 'UINT'>: 'INT', <Type.UMEDIUMINT: 'UMEDIUMINT'>: 'MEDIUMINT', <Type.USMALLINT: 'USMALLINT'>: 'SMALLINT', <Type.UTINYINT: 'UTINYINT'>: 'TINYINT', <Type.UDECIMAL: 'UDECIMAL'>: 'DECIMAL', <Type.TIMESTAMP: 'TIMESTAMP'>: 'DATETIME', <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>: 'DATETIME', <Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>: 'TIMESTAMP', <Type.TEXT: 'TEXT'>: 'STRING'}

CAST_MAPPING = {}

TIMESTAMP_FUNC_TYPES = set()

TRANSFORMS = {<class 'sqlglot.expressions.JSONPathFilter'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathKey'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathRecursive'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathRoot'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathScript'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathSelector'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathSlice'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathSubscript'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathUnion'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathWildcard'>: <function <lambda>>, <class 'sqlglot.expressions.AllowedValuesProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.AutoRefreshProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.BackupProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CaseSpecificColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ClusteredColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CollateColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CommentColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ConnectByRoot'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CopyGrantsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DateFormatColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DefaultColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DynamicProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EncodeColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EphemeralColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExcludeColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExecuteAsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExternalProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.GlobalProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.HeapProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.IcebergProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InheritsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InlineLengthColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.IntervalSpan'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.JSONExtract'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.JSONExtractScalar'>: <function Doris.Generator.<lambda>>, <class 'sqlglot.expressions.LanguageProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LocationProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LogProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.MaterializedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NonClusteredColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NoPrimaryIndexProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NotForReplicationColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnCommitProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnUpdateColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OutputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.PathColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ProjectionPolicyColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.RemoteWithConnectionModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ReturnsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SampleProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SecureProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SetConfigProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SetProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SettingsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SharingProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SqlReadWriteProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SqlSecurityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StabilityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StrictProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TemporaryProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TagColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TitleColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Timestamp'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ToMap'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ToTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransformModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransientProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UppercaseColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UnloggedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VarMap'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ViewAttributeProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VolatileProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithJournalTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithSchemaBindingProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithOperator'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ArrayAgg'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.CurrentDate'>: <function no_paren_current_date_sql>, <class 'sqlglot.expressions.DateDiff'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.DateAdd'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.DateStrToDate'>: <function datestrtodate_sql>, <class 'sqlglot.expressions.DateSub'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.DateTrunc'>: <function Doris.Generator.<lambda>>, <class 'sqlglot.expressions.Day'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.DayOfMonth'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.DayOfWeek'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.DayOfYear'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.GroupConcat'>: <function Doris.Generator.<lambda>>, <class 'sqlglot.expressions.ILike'>: <function no_ilike_sql>, <class 'sqlglot.expressions.Max'>: <function max_or_greatest>, <class 'sqlglot.expressions.Min'>: <function min_or_least>, <class 'sqlglot.expressions.Month'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.NullSafeEQ'>: <function MySQL.Generator.<lambda>>, <class 'sqlglot.expressions.NullSafeNEQ'>: <function MySQL.Generator.<lambda>>, <class 'sqlglot.expressions.Pivot'>: <function no_pivot_sql>, <class 'sqlglot.expressions.Select'>: <function preprocess.<locals>._to_sql>, <class 'sqlglot.expressions.StrPosition'>: <function strposition_to_locate_sql>, <class 'sqlglot.expressions.StrToDate'>: <function _str_to_date_sql>, <class 'sqlglot.expressions.StrToTime'>: <function _str_to_date_sql>, <class 'sqlglot.expressions.Stuff'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TableSample'>: <function no_tablesample_sql>, <class 'sqlglot.expressions.TimeFromParts'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TimestampAdd'>: <function date_add_interval_sql.<locals>.func>, <class 'sqlglot.expressions.TimestampDiff'>: <function MySQL.Generator.<lambda>>, <class 'sqlglot.expressions.TimestampSub'>: <function date_add_interval_sql.<locals>.func>, <class 'sqlglot.expressions.TimeStrToUnix'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TimeStrToTime'>: <function MySQL.Generator.<lambda>>, <class 'sqlglot.expressions.TimeToStr'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.Trim'>: <function _trim_sql>, <class 'sqlglot.expressions.TryCast'>: <function no_trycast_sql>, <class 'sqlglot.expressions.TsOrDsAdd'>: <function Doris.Generator.<lambda>>, <class 'sqlglot.expressions.TsOrDsDiff'>: <function MySQL.Generator.<lambda>>, <class 'sqlglot.expressions.TsOrDsToDate'>: <function Doris.Generator.<lambda>>, <class 'sqlglot.expressions.UnixToTime'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Week'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.WeekOfYear'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.Year'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.AddMonths'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ApproxDistinct'>: <function approx_count_distinct_sql>, <class 'sqlglot.expressions.ArgMax'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ArgMin'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ArrayUniqueAgg'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.CurrentTimestamp'>: <function Doris.Generator.<lambda>>, <class 'sqlglot.expressions.Lag'>: <function _lag_lead_sql>, <class 'sqlglot.expressions.Lead'>: <function _lag_lead_sql>, <class 'sqlglot.expressions.Map'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.RegexpLike'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.RegexpSplit'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Split'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.StringToArray'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.StrToUnix'>: <function Doris.Generator.<lambda>>, <class 'sqlglot.expressions.TimeStrToDate'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TimeToUnix'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TimestampTrunc'>: <function Doris.Generator.<lambda>>, <class 'sqlglot.expressions.UnixToStr'>: <function Doris.Generator.<lambda>>}

RESERVED_KEYWORDS = {'datetimev2', 'partitions', 'tablets', 'dynamic', 'ipv6', 'foreign', 'else', 'json', 'boolean', 'procedure', 'min', 'having', 'explain', 'join', 'lines', 'name', 'stream', 'like', 'task', 'where', 'blob', 'map', 'restrictive', 'year', 'binary', 'match_all', 'terminated', 'frontends', 'intermediate', 'type', 'datetime', 'describe', 'physical', 'link', 'every', 'int', 'level', 'never', 'sql_block_rule', 'datev2', 'signed', 'ends', 'external', 'regexp', 'switch', 'hub', 'tables', 'convert', 'global', 'varchar', 'dual', 'triggers', 'bitand', 'when', 'shape', 'current_user', 'graph', 'sum', 'day', 'comment', 'events', 'right', 'list', 'merge', 'warnings', 'call', 'end', 'release', 'engine', 'bitmap', 'than', 'clusters', 'memo', 'errors', 'admin', 'build', 'hll_union', 'indexes', 'types', 'drop', 'smallint', 'keys', 'interval', 'uninstall', 'deferred', 'localtimestamp', 'verbose', 'date_ceil', 'doris_internal_table_id', 'days_add', 'grouping', 'limit', 'prepare', 'resource', 'key', 'begin', 'negative', 'tinyint', 'load', 'match_phrase', 'sequence', 'password_reuse', 'div', 'array', 'minute', 'update', 'chain', 'profile', 'split', 's3', 'is_null_pred', 'decimalv2', 'no', 'query', 'integer', 'unsigned', 'following', 'path', 'backend', 'inner', 'current_date', 'columns', 'storage', 'extended', 'anti', 'except', 'ignore', 'restore', 'distinct', 'localtime', 'current_time', 'consistent', 'date_sub', 'distinctpcsa', 'recover', 'distinctpc', 'period', 'date_add', 'xor', 'commit', 'outfile', 'force', 'complete', 'aggregate', 'over', 'bitxor', 'real', 'materialized', 'skew', 'trash', 'ipv4', 'cluster', 'databases', 'data', 'encryptkey', 'overwrite', 'false', 'cached', 'using', 'range', 'nulls', 'timestampadd', 'char', 'optimized', 'connection', 'insert', 'is_not_null_pred', 'follower', 'engines', 'tablesample', 'rollup', 'observer', 'for', 'buckets', 'version', 'collation', 'tasks', 'plugins', 'help', 'status', 'largeint', 'days_sub', 'if', 'on', 'start', 'group', 'full', 'natural', 'brief', 'snapshot', 'unbounded', 'rebalance', 'tablet', 'system', 'distribution', 'whitelist', 'only', 'datediff', 'references', 'migrations', 'date', 'from', 'session', 'auto_increment', 'broker', 'week', 'between', 'check', 'modify', 'plan', 'infile', 'cast', 'repair', 'select', 'time', 'isolation', 'jobs', 'function', 'date_floor', 'transaction', 'datetimev1', 'month', 'quota', 'count', 'ngram_bf', 'constraint', 'first', 'decimal', 'recycle', 'lock', 'plugin', 'roles', 'cron', 'grants', 'bulk', 'demand', 'streaming', 'lateral', 'bitmap_union', 'true', 'adddate', 'union', 'extract', 'disk', 'float', 'serializable', 'scheduler', 'compact', 'is', 'preceding', 'distributed', 'committed', 'job', 'rows', 'default', 'uncommitted', 'decimalv3', 'policy', 'with', 'decommission', 'type_cast', 'intersect', 'kill', 'subdate', 'groups', 'routine', 'truncate', 'current_timestamp', 'logical', 'then', 'dateadd', 'schedule', 'by', 'table', 'stats', 'analyze', 'hostname', 'asc', 'replace_if_not_null', 'after', 'row', 'parsed', 'read', 'character', 'soname', 'offset', 'alter', 'low_priority', 'format', 'copy', 'properties', 'variant', 'starts', 'random', 'authors', 'match_any', 'bitor', 'left', 'isnull', 'match_phrase_edge', 'write', 'hour', 'free', 'replica', 'immediate', 'current_catalog', 'max', 'into', 'hll', 'password_lock_time', 'tree', 'minus', 'to', 'stop', 'feature', 'processlist', 'rename', 'identified', 'outer', 'datev1', 'case', 'value', 'order', 'use', 'double', 'parameter', 'values', 'schemas', 'exists', 'proc', 'revoke', 'open', 'sets', 'hash', 'cross', 'fields', 'date_diff', 'exclude', 'match', 'file', 'user', 'schema', 'charset', 'repository', 'dropp', 'non_nullable', 'config', 'bin', 'ldap', 'all', 'connection_id', 'superuser', 'creation', 'match_regexp', 'unlock', 'workload', 'account_unlock', 'string', 'index', 'binlog', 'fast', 'collect', 'column', 'backup', 'returns', 'resources', 'backends', 'view', 'rlike', 'work', 'and', 'agg_state', 'null', 'belong', 'add', 'migrate', 'password_expire', 'property', 'bigint', 'repeatable', 'label', 'current', 'do', 'percent', 'permissive', 'histogram', 'manual', 'catalog', 'failed_login_attempts', 'temporary', 'maxvalue', 'execute', 'analyzed', 'duplicate', 'next', 'last', 'of', 'set', 'database', 'or', 'semi', 'sample', 'ldap_admin_password', 'resume', 'constraints', 'as', 'enter', 'trim', 'desc', 'variables', 'show', 'unique', 'repositories', 'process', 'timestampdiff', 'filter', 'auto', 'pause', 'primary', 'clean', 'create', 'catalogs', 'in', 'builtin', 'encryptkeys', 'refresh', 'names', 'password', 'at', 'enable', 'account_lock', 'grant', 'diagnose', 'alias', 'functions', 'install', 'export', 'quantile_state', 'role', 'password_history', 'cube', 'partition', 'incremental', 'expired', 'frontend', 'struct', 'text', 'less', 'sync', 'hdfs', 'vault', 'jsonb', 'match_phrase_prefix', 'collate', 'replace', 'not', 'quantile_union', 'rewritten', 'delete', 'rollback', 'mtmv', 'array_range', 'local', 'second', 'timestamp', 'cancel', 'location', 'append', 'inverted', 'generic'}

SELECT_KINDS: Tuple[str, ...] = ()

TRY_SUPPORTED = False

SUPPORTS_UESCAPE = False

AFTER_HAVING_MODIFIER_TRANSFORMS = {'windows': <function Generator.<lambda>>, 'qualify': <function Generator.<lambda>>}

Inherited Members

sqlglot.generator.Generator: Generator; IGNORE_NULLS_IN_FUNC; EXPLICIT_SET_OP; CREATE_FUNCTION_RETURN_AS; MATCHED_BY_SOURCE; SINGLE_STRING_INTERVAL; RENAME_TABLE_WITH_DB; GROUPINGS_SEP; INDEX_ON; QUERY_HINTS; IS_BOOL_ALLOWED; LIMIT_IS_TOP; RETURNING_END; EXTRACT_ALLOWS_QUOTES; TZ_TO_WITH_TIME_ZONE; ALTER_TABLE_INCLUDE_COLUMN_KEYWORD; UNNEST_WITH_ORDINALITY; AGGREGATE_FILTER_SUPPORTED; SEMI_ANTI_JOIN_WITH_SIDE; COMPUTED_COLUMN_WITH_TYPE; SUPPORTS_TABLE_COPY; TABLESAMPLE_REQUIRES_PARENS; TABLESAMPLE_SIZE_IS_ROWS; TABLESAMPLE_KEYWORDS; TABLESAMPLE_WITH_METHOD; TABLESAMPLE_SEED_KEYWORD; COLLATE_IS_FUNC; DATA_TYPE_SPECIFIERS_ALLOWED; ENSURE_BOOLS; CTE_RECURSIVE_KEYWORD_REQUIRED; SUPPORTS_SINGLE_ARG_CONCAT; SUPPORTS_TABLE_ALIAS_COLUMNS; UNPIVOT_ALIASES_ARE_IDENTIFIERS; INSERT_OVERWRITE; SUPPORTS_SELECT_INTO; SUPPORTS_UNLOGGED_TABLES; SUPPORTS_CREATE_TABLE_LIKE; LIKE_PROPERTY_INSIDE_SCHEMA; MULTI_ARG_DISTINCT; JSON_PATH_SINGLE_QUOTE_ESCAPE; SUPPORTED_JSON_PATH_PARTS; CAN_IMPLEMENT_ARRAY_ANY; SET_OP_MODIFIERS; COPY_PARAMS_ARE_WRAPPED; COPY_PARAMS_EQ_REQUIRED; COPY_HAS_INTO_KEYWORD; STAR_EXCEPT; HEX_FUNC; WITH_PROPERTIES_PREFIX; QUOTE_JSON_PATH; TIME_PART_SINGULARS; TOKEN_MAPPING; STRUCT_DELIMITER; PARAMETER_TOKEN; NAMED_PLACEHOLDER_TOKEN; WITH_SEPARATED_COMMENTS; EXCLUDE_COMMENTS; UNWRAPPED_INTERVAL_VALUES; PARAMETERIZABLE_TEXT_TYPES; EXPRESSIONS_WITHOUT_NESTED_CTES; SENTINEL_LINE_BREAK; pretty; identify; normalize; pad; unsupported_level; max_unsupported; leading_comma; max_text_width; comments; dialect; normalize_functions; unsupported_messages; generate; preprocess; unsupported; sep; seg; pad_comment; maybe_comment; wrap; no_identify; normalize_func; indent; sql; uncache_sql; cache_sql; characterset_sql; column_parts; column_sql; columnposition_sql; columndef_sql; columnconstraint_sql; computedcolumnconstraint_sql; autoincrementcolumnconstraint_sql; compresscolumnconstraint_sql; generatedasidentitycolumnconstraint_sql; generatedasrowcolumnconstraint_sql; periodforsystemtimeconstraint_sql; notnullcolumnconstraint_sql; transformcolumnconstraint_sql; primarykeycolumnconstraint_sql; uniquecolumnconstraint_sql; createable_sql; create_sql; sequenceproperties_sql; clone_sql; describe_sql; heredoc_sql; prepend_ctes; with_sql; cte_sql; tablealias_sql; bitstring_sql; hexstring_sql; bytestring_sql; unicodestring_sql; rawstring_sql; datatypeparam_sql; directory_sql; delete_sql; drop_sql; except_sql; except_op; fetch_sql; filter_sql; hint_sql; indexparameters_sql; index_sql; identifier_sql; hex_sql; lowerhex_sql; inputoutputformat_sql; national_sql; partition_sql; properties_sql; root_properties; properties; with_properties; locate_properties; property_name; property_sql; likeproperty_sql; fallbackproperty_sql; journalproperty_sql; freespaceproperty_sql; checksumproperty_sql; mergeblockratioproperty_sql; datablocksizeproperty_sql; blockcompressionproperty_sql; isolatedloadingproperty_sql; partitionboundspec_sql; partitionedofproperty_sql; lockingproperty_sql; withdataproperty_sql; withsystemversioningproperty_sql; insert_sql; intersect_sql; intersect_op; introducer_sql; kill_sql; pseudotype_sql; objectidentifier_sql; onconflict_sql; returning_sql; rowformatdelimitedproperty_sql; withtablehint_sql; indextablehint_sql; historicaldata_sql; table_parts; table_sql; tablesample_sql; pivot_sql; version_sql; tuple_sql; update_sql; values_sql; var_sql; into_sql; from_sql; group_sql; having_sql; connect_sql; prior_sql; join_sql; lambda_sql; lateral_op; lateral_sql; limit_sql; offset_sql; setitem_sql; set_sql; pragma_sql; lock_sql; literal_sql; escape_str; loaddata_sql; null_sql; boolean_sql; order_sql; withfill_sql; cluster_sql; distribute_sql; sort_sql; ordered_sql; matchrecognizemeasure_sql; matchrecognize_sql; query_modifiers; options_modifier; queryoption_sql; offset_limit_modifiers; after_limit_modifiers; select_sql; schema_sql; schema_columns_sql; star_sql; parameter_sql; sessionparameter_sql; placeholder_sql; subquery_sql; qualify_sql; set_operations; union_sql; union_op; unnest_sql; prewhere_sql; where_sql; window_sql; partition_by_sql; windowspec_sql; withingroup_sql; between_sql; bracket_offset_expressions; bracket_sql; all_sql; any_sql; exists_sql; case_sql; constraint_sql; nextvaluefor_sql; trim_sql; convert_concat_args; concat_sql; concatws_sql; check_sql; foreignkey_sql; primarykey_sql; if_sql; matchagainst_sql; jsonkeyvalue_sql; jsonpath_sql; json_path_part; formatjson_sql; jsonobject_sql; jsonobjectagg_sql; jsonarray_sql; jsonarrayagg_sql; jsoncolumndef_sql; jsonschema_sql; jsontable_sql; openjsoncolumndef_sql; openjson_sql; in_sql; in_unnest_op; interval_sql; return_sql; reference_sql; anonymous_sql; paren_sql; neg_sql; not_sql; alias_sql; pivotalias_sql; aliases_sql; atindex_sql; attimezone_sql; fromtimezone_sql; add_sql; and_sql; or_sql; xor_sql; connector_sql; bitwiseand_sql; bitwiseleftshift_sql; bitwisenot_sql; bitwiseor_sql; bitwiserightshift_sql; bitwisexor_sql; currentdate_sql; currenttimestamp_sql; collate_sql; command_sql; comment_sql; mergetreettlaction_sql; mergetreettl_sql; transaction_sql; commit_sql; rollback_sql; alterdiststyle_sql; altersortkey_sql; renametable_sql; renamecolumn_sql; alterset_sql; altertable_sql; add_column_sql; droppartition_sql; addconstraint_sql; distinct_sql; ignorenulls_sql; respectnulls_sql; havingmax_sql; intdiv_sql; div_sql; overlaps_sql; distance_sql; dot_sql; eq_sql; propertyeq_sql; escape_sql; glob_sql; gt_sql; gte_sql; ilike_sql; ilikeany_sql; is_sql; like_sql; likeany_sql; similarto_sql; lt_sql; lte_sql; mod_sql; mul_sql; neq_sql; nullsafeeq_sql; nullsafeneq_sql; slice_sql; sub_sql; trycast_sql; try_sql; log_sql; use_sql; binary; function_fallback_sql; func; format_args; too_wide; format_time; expressions; op_expressions; naked_property; tag_sql; token_sql; userdefinedfunction_sql; joinhint_sql; kwarg_sql; when_sql; merge_sql; tochar_sql; tonumber_sql; dictproperty_sql; dictrange_sql; dictsubproperty_sql; oncluster_sql; clusteredbyproperty_sql; anyvalue_sql; querytransform_sql; indexconstraintoption_sql; checkcolumnconstraint_sql; indexcolumnconstraint_sql; nvl2_sql; comprehension_sql; columnprefix_sql; opclass_sql; predict_sql; forin_sql; refresh_sql; operator_sql; toarray_sql; tsordstotime_sql; tsordstotimestamp_sql; tsordstodate_sql; unixdate_sql; lastday_sql; dateadd_sql; arrayany_sql; generateseries_sql; struct_sql; partitionrange_sql; truncatetable_sql; convert_sql; copyparameter_sql; credentials_sql; copy_sql; semicolon_sql; datadeletionproperty_sql; maskingpolicycolumnconstraint_sql; gapfill_sql; scope_resolution; scoperesolution_sql; parsejson_sql; length_sql; rand_sql; strtodate_sql; strtotime_sql; changes_sql; pad_sql
sqlglot.dialects.mysql.MySQL.Generator: INTERVAL_ALLOWS_PLURAL_FORM; LOCKING_READS_SUPPORTED; NULL_ORDERING_SUPPORTED; JOIN_HINTS; TABLE_HINTS; DUPLICATE_KEY_UPDATE_WITH_SET; QUERY_HINT_SEP; VALUES_AS_TABLE; NVL2_SUPPORTED; JSON_TYPE_REQUIRED_FOR_EXTRACTION; JSON_PATH_BRACKETED_KEY_SUPPORTED; JSON_KEY_VALUE_PAIR_SEP; SUPPORTS_TO_NUMBER; PARSE_JSON_NAME; PAD_FILL_PATTERN_IS_REQUIRED; WRAP_DERIVED_VALUES; UNSIGNED_TYPE_MAPPING; TIMESTAMP_TYPE_MAPPING; PROPERTIES_LOCATION; LIMIT_FETCH; LIMIT_ONLY_LITERALS; CHAR_CAST_MAPPING; SIGNED_CAST_MAPPING; array_sql; arraycontainsall_sql; dpipe_sql; extract_sql; datatype_sql; jsonarraycontains_sql; cast_sql; show_sql; altercolumn_sql; chr_sql; timestamptrunc_sql