Edit on GitHub

sqlglot.dialects.redshift

View Source

  1from __future__ import annotations
  2
  3import typing as t
  4
  5from sqlglot import exp, transforms
  6from sqlglot.dialects.dialect import (
  7    NormalizationStrategy,
  8    concat_to_dpipe_sql,
  9    concat_ws_to_dpipe_sql,
 10    date_delta_sql,
 11    generatedasidentitycolumnconstraint_sql,
 12    json_extract_segments,
 13    no_tablesample_sql,
 14    rename_func,
 15    map_date_part,
 16)
 17from sqlglot.dialects.postgres import Postgres
 18from sqlglot.helper import seq_get
 19from sqlglot.tokens import TokenType
 20from sqlglot.parser import build_convert_timezone
 21
 22if t.TYPE_CHECKING:
 23    from sqlglot._typing import E
 24
 25
 26def _build_date_delta(expr_type: t.Type[E]) -> t.Callable[[t.List], E]:
 27    def _builder(args: t.List) -> E:
 28        expr = expr_type(
 29            this=seq_get(args, 2),
 30            expression=seq_get(args, 1),
 31            unit=map_date_part(seq_get(args, 0)),
 32        )
 33        if expr_type is exp.TsOrDsAdd:
 34            expr.set("return_type", exp.DataType.build("TIMESTAMP"))
 35
 36        return expr
 37
 38    return _builder
 39
 40
 41class Redshift(Postgres):
 42    # https://docs.aws.amazon.com/redshift/latest/dg/r_names.html
 43    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
 44
 45    SUPPORTS_USER_DEFINED_TYPES = False
 46    INDEX_OFFSET = 0
 47    COPY_PARAMS_ARE_CSV = False
 48    HEX_LOWERCASE = True
 49    HAS_DISTINCT_ARRAY_CONSTRUCTORS = True
 50
 51    # ref: https://docs.aws.amazon.com/redshift/latest/dg/r_FORMAT_strings.html
 52    TIME_FORMAT = "'YYYY-MM-DD HH24:MI:SS'"
 53    TIME_MAPPING = {**Postgres.TIME_MAPPING, "MON": "%b", "HH24": "%H", "HH": "%I"}
 54
 55    class Parser(Postgres.Parser):
 56        FUNCTIONS = {
 57            **Postgres.Parser.FUNCTIONS,
 58            "ADD_MONTHS": lambda args: exp.TsOrDsAdd(
 59                this=seq_get(args, 0),
 60                expression=seq_get(args, 1),
 61                unit=exp.var("month"),
 62                return_type=exp.DataType.build("TIMESTAMP"),
 63            ),
 64            "CONVERT_TIMEZONE": lambda args: build_convert_timezone(args, "UTC"),
 65            "DATEADD": _build_date_delta(exp.TsOrDsAdd),
 66            "DATE_ADD": _build_date_delta(exp.TsOrDsAdd),
 67            "DATEDIFF": _build_date_delta(exp.TsOrDsDiff),
 68            "DATE_DIFF": _build_date_delta(exp.TsOrDsDiff),
 69            "GETDATE": exp.CurrentTimestamp.from_arg_list,
 70            "LISTAGG": exp.GroupConcat.from_arg_list,
 71            "SPLIT_TO_ARRAY": lambda args: exp.StringToArray(
 72                this=seq_get(args, 0), expression=seq_get(args, 1) or exp.Literal.string(",")
 73            ),
 74            "STRTOL": exp.FromBase.from_arg_list,
 75        }
 76
 77        NO_PAREN_FUNCTION_PARSERS = {
 78            **Postgres.Parser.NO_PAREN_FUNCTION_PARSERS,
 79            "APPROXIMATE": lambda self: self._parse_approximate_count(),
 80            "SYSDATE": lambda self: self.expression(exp.CurrentTimestamp, sysdate=True),
 81        }
 82
 83        SUPPORTS_IMPLICIT_UNNEST = True
 84
 85        def _parse_table(
 86            self,
 87            schema: bool = False,
 88            joins: bool = False,
 89            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
 90            parse_bracket: bool = False,
 91            is_db_reference: bool = False,
 92            parse_partition: bool = False,
 93        ) -> t.Optional[exp.Expression]:
 94            # Redshift supports UNPIVOTing SUPER objects, e.g. `UNPIVOT foo.obj[0] AS val AT attr`
 95            unpivot = self._match(TokenType.UNPIVOT)
 96            table = super()._parse_table(
 97                schema=schema,
 98                joins=joins,
 99                alias_tokens=alias_tokens,
100                parse_bracket=parse_bracket,
101                is_db_reference=is_db_reference,
102            )
103
104            return self.expression(exp.Pivot, this=table, unpivot=True) if unpivot else table
105
106        def _parse_convert(
107            self, strict: bool, safe: t.Optional[bool] = None
108        ) -> t.Optional[exp.Expression]:
109            to = self._parse_types()
110            self._match(TokenType.COMMA)
111            this = self._parse_bitwise()
112            return self.expression(exp.TryCast, this=this, to=to, safe=safe)
113
114        def _parse_approximate_count(self) -> t.Optional[exp.ApproxDistinct]:
115            index = self._index - 1
116            func = self._parse_function()
117
118            if isinstance(func, exp.Count) and isinstance(func.this, exp.Distinct):
119                return self.expression(exp.ApproxDistinct, this=seq_get(func.this.expressions, 0))
120            self._retreat(index)
121            return None
122
123    class Tokenizer(Postgres.Tokenizer):
124        BIT_STRINGS = []
125        HEX_STRINGS = []
126        STRING_ESCAPES = ["\\", "'"]
127
128        KEYWORDS = {
129            **Postgres.Tokenizer.KEYWORDS,
130            "(+)": TokenType.JOIN_MARKER,
131            "HLLSKETCH": TokenType.HLLSKETCH,
132            "MINUS": TokenType.EXCEPT,
133            "SUPER": TokenType.SUPER,
134            "TOP": TokenType.TOP,
135            "UNLOAD": TokenType.COMMAND,
136            "VARBYTE": TokenType.VARBINARY,
137            "BINARY VARYING": TokenType.VARBINARY,
138        }
139        KEYWORDS.pop("VALUES")
140
141        # Redshift allows # to appear as a table identifier prefix
142        SINGLE_TOKENS = Postgres.Tokenizer.SINGLE_TOKENS.copy()
143        SINGLE_TOKENS.pop("#")
144
145    class Generator(Postgres.Generator):
146        LOCKING_READS_SUPPORTED = False
147        QUERY_HINTS = False
148        VALUES_AS_TABLE = False
149        TZ_TO_WITH_TIME_ZONE = True
150        NVL2_SUPPORTED = True
151        LAST_DAY_SUPPORTS_DATE_PART = False
152        CAN_IMPLEMENT_ARRAY_ANY = False
153        MULTI_ARG_DISTINCT = True
154        COPY_PARAMS_ARE_WRAPPED = False
155        HEX_FUNC = "TO_HEX"
156        PARSE_JSON_NAME = "JSON_PARSE"
157        ARRAY_CONCAT_IS_VAR_LEN = False
158        SUPPORTS_CONVERT_TIMEZONE = True
159        EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE = False
160        SUPPORTS_MEDIAN = True
161
162        # Redshift doesn't have `WITH` as part of their with_properties so we remove it
163        WITH_PROPERTIES_PREFIX = " "
164
165        TYPE_MAPPING = {
166            **Postgres.Generator.TYPE_MAPPING,
167            exp.DataType.Type.BINARY: "VARBYTE",
168            exp.DataType.Type.INT: "INTEGER",
169            exp.DataType.Type.TIMETZ: "TIME",
170            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
171            exp.DataType.Type.VARBINARY: "VARBYTE",
172            exp.DataType.Type.ROWVERSION: "VARBYTE",
173        }
174
175        TRANSFORMS = {
176            **Postgres.Generator.TRANSFORMS,
177            exp.ArrayConcat: lambda self, e: self.arrayconcat_sql(e, name="ARRAY_CONCAT"),
178            exp.Concat: concat_to_dpipe_sql,
179            exp.ConcatWs: concat_ws_to_dpipe_sql,
180            exp.ApproxDistinct: lambda self,
181            e: f"APPROXIMATE COUNT(DISTINCT {self.sql(e, 'this')})",
182            exp.CurrentTimestamp: lambda self, e: (
183                "SYSDATE" if e.args.get("sysdate") else "GETDATE()"
184            ),
185            exp.DateAdd: date_delta_sql("DATEADD"),
186            exp.DateDiff: date_delta_sql("DATEDIFF"),
187            exp.DistKeyProperty: lambda self, e: self.func("DISTKEY", e.this),
188            exp.DistStyleProperty: lambda self, e: self.naked_property(e),
189            exp.Explode: lambda self, e: self.explode_sql(e),
190            exp.FromBase: rename_func("STRTOL"),
191            exp.GeneratedAsIdentityColumnConstraint: generatedasidentitycolumnconstraint_sql,
192            exp.JSONExtract: json_extract_segments("JSON_EXTRACT_PATH_TEXT"),
193            exp.JSONExtractScalar: json_extract_segments("JSON_EXTRACT_PATH_TEXT"),
194            exp.GroupConcat: rename_func("LISTAGG"),
195            exp.Hex: lambda self, e: self.func("UPPER", self.func("TO_HEX", self.sql(e, "this"))),
196            exp.Select: transforms.preprocess(
197                [
198                    transforms.eliminate_distinct_on,
199                    transforms.eliminate_semi_and_anti_joins,
200                    transforms.unqualify_unnest,
201                    transforms.unnest_generate_date_array_using_recursive_cte,
202                ]
203            ),
204            exp.SortKeyProperty: lambda self,
205            e: f"{'COMPOUND ' if e.args['compound'] else ''}SORTKEY({self.format_args(*e.this)})",
206            exp.StartsWith: lambda self,
207            e: f"{self.sql(e.this)} LIKE {self.sql(e.expression)} || '%'",
208            exp.StringToArray: rename_func("SPLIT_TO_ARRAY"),
209            exp.TableSample: no_tablesample_sql,
210            exp.TsOrDsAdd: date_delta_sql("DATEADD"),
211            exp.TsOrDsDiff: date_delta_sql("DATEDIFF"),
212            exp.UnixToTime: lambda self,
213            e: f"(TIMESTAMP 'epoch' + {self.sql(e.this)} * INTERVAL '1 SECOND')",
214        }
215
216        # Postgres maps exp.Pivot to no_pivot_sql, but Redshift support pivots
217        TRANSFORMS.pop(exp.Pivot)
218
219        # Postgres doesn't support JSON_PARSE, but Redshift does
220        TRANSFORMS.pop(exp.ParseJSON)
221
222        # Redshift uses the POW | POWER (expr1, expr2) syntax instead of expr1 ^ expr2 (postgres)
223        TRANSFORMS.pop(exp.Pow)
224
225        # Redshift supports these functions
226        TRANSFORMS.pop(exp.AnyValue)
227        TRANSFORMS.pop(exp.LastDay)
228        TRANSFORMS.pop(exp.SHA2)
229
230        RESERVED_KEYWORDS = {
231            "aes128",
232            "aes256",
233            "all",
234            "allowoverwrite",
235            "analyse",
236            "analyze",
237            "and",
238            "any",
239            "array",
240            "as",
241            "asc",
242            "authorization",
243            "az64",
244            "backup",
245            "between",
246            "binary",
247            "blanksasnull",
248            "both",
249            "bytedict",
250            "bzip2",
251            "case",
252            "cast",
253            "check",
254            "collate",
255            "column",
256            "constraint",
257            "create",
258            "credentials",
259            "cross",
260            "current_date",
261            "current_time",
262            "current_timestamp",
263            "current_user",
264            "current_user_id",
265            "default",
266            "deferrable",
267            "deflate",
268            "defrag",
269            "delta",
270            "delta32k",
271            "desc",
272            "disable",
273            "distinct",
274            "do",
275            "else",
276            "emptyasnull",
277            "enable",
278            "encode",
279            "encrypt     ",
280            "encryption",
281            "end",
282            "except",
283            "explicit",
284            "false",
285            "for",
286            "foreign",
287            "freeze",
288            "from",
289            "full",
290            "globaldict256",
291            "globaldict64k",
292            "grant",
293            "group",
294            "gzip",
295            "having",
296            "identity",
297            "ignore",
298            "ilike",
299            "in",
300            "initially",
301            "inner",
302            "intersect",
303            "interval",
304            "into",
305            "is",
306            "isnull",
307            "join",
308            "leading",
309            "left",
310            "like",
311            "limit",
312            "localtime",
313            "localtimestamp",
314            "lun",
315            "luns",
316            "lzo",
317            "lzop",
318            "minus",
319            "mostly16",
320            "mostly32",
321            "mostly8",
322            "natural",
323            "new",
324            "not",
325            "notnull",
326            "null",
327            "nulls",
328            "off",
329            "offline",
330            "offset",
331            "oid",
332            "old",
333            "on",
334            "only",
335            "open",
336            "or",
337            "order",
338            "outer",
339            "overlaps",
340            "parallel",
341            "partition",
342            "percent",
343            "permissions",
344            "pivot",
345            "placing",
346            "primary",
347            "raw",
348            "readratio",
349            "recover",
350            "references",
351            "rejectlog",
352            "resort",
353            "respect",
354            "restore",
355            "right",
356            "select",
357            "session_user",
358            "similar",
359            "snapshot",
360            "some",
361            "sysdate",
362            "system",
363            "table",
364            "tag",
365            "tdes",
366            "text255",
367            "text32k",
368            "then",
369            "timestamp",
370            "to",
371            "top",
372            "trailing",
373            "true",
374            "truncatecolumns",
375            "type",
376            "union",
377            "unique",
378            "unnest",
379            "unpivot",
380            "user",
381            "using",
382            "verbose",
383            "wallet",
384            "when",
385            "where",
386            "with",
387            "without",
388        }
389
390        def unnest_sql(self, expression: exp.Unnest) -> str:
391            args = expression.expressions
392            num_args = len(args)
393
394            if num_args != 1:
395                self.unsupported(f"Unsupported number of arguments in UNNEST: {num_args}")
396                return ""
397
398            if isinstance(expression.find_ancestor(exp.From, exp.Join, exp.Select), exp.Select):
399                self.unsupported("Unsupported UNNEST when not used in FROM/JOIN clauses")
400                return ""
401
402            arg = self.sql(seq_get(args, 0))
403
404            alias = self.expressions(expression.args.get("alias"), key="columns", flat=True)
405            return f"{arg} AS {alias}" if alias else arg
406
407        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
408            if expression.is_type(exp.DataType.Type.JSON):
409                # Redshift doesn't support a JSON type, so casting to it is treated as a noop
410                return self.sql(expression, "this")
411
412            return super().cast_sql(expression, safe_prefix=safe_prefix)
413
414        def datatype_sql(self, expression: exp.DataType) -> str:
415            """
416            Redshift converts the `TEXT` data type to `VARCHAR(255)` by default when people more generally mean
417            VARCHAR of max length which is `VARCHAR(max)` in Redshift. Therefore if we get a `TEXT` data type
418            without precision we convert it to `VARCHAR(max)` and if it does have precision then we just convert
419            `TEXT` to `VARCHAR`.
420            """
421            if expression.is_type("text"):
422                expression.set("this", exp.DataType.Type.VARCHAR)
423                precision = expression.args.get("expressions")
424
425                if not precision:
426                    expression.append("expressions", exp.var("MAX"))
427
428            return super().datatype_sql(expression)
429
430        def alterset_sql(self, expression: exp.AlterSet) -> str:
431            exprs = self.expressions(expression, flat=True)
432            exprs = f" TABLE PROPERTIES ({exprs})" if exprs else ""
433            location = self.sql(expression, "location")
434            location = f" LOCATION {location}" if location else ""
435            file_format = self.expressions(expression, key="file_format", flat=True, sep=" ")
436            file_format = f" FILE FORMAT {file_format}" if file_format else ""
437
438            return f"SET{exprs}{location}{file_format}"
439
440        def array_sql(self, expression: exp.Array) -> str:
441            if expression.args.get("bracket_notation"):
442                return super().array_sql(expression)
443
444            return rename_func("ARRAY")(self, expression)
445
446        def explode_sql(self, expression: exp.Explode) -> str:
447            self.unsupported("Unsupported EXPLODE() function")
448            return ""

class Redshift(sqlglot.dialects.postgres.Postgres): View Source

 42class Redshift(Postgres):
 43    # https://docs.aws.amazon.com/redshift/latest/dg/r_names.html
 44    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
 45
 46    SUPPORTS_USER_DEFINED_TYPES = False
 47    INDEX_OFFSET = 0
 48    COPY_PARAMS_ARE_CSV = False
 49    HEX_LOWERCASE = True
 50    HAS_DISTINCT_ARRAY_CONSTRUCTORS = True
 51
 52    # ref: https://docs.aws.amazon.com/redshift/latest/dg/r_FORMAT_strings.html
 53    TIME_FORMAT = "'YYYY-MM-DD HH24:MI:SS'"
 54    TIME_MAPPING = {**Postgres.TIME_MAPPING, "MON": "%b", "HH24": "%H", "HH": "%I"}
 55
 56    class Parser(Postgres.Parser):
 57        FUNCTIONS = {
 58            **Postgres.Parser.FUNCTIONS,
 59            "ADD_MONTHS": lambda args: exp.TsOrDsAdd(
 60                this=seq_get(args, 0),
 61                expression=seq_get(args, 1),
 62                unit=exp.var("month"),
 63                return_type=exp.DataType.build("TIMESTAMP"),
 64            ),
 65            "CONVERT_TIMEZONE": lambda args: build_convert_timezone(args, "UTC"),
 66            "DATEADD": _build_date_delta(exp.TsOrDsAdd),
 67            "DATE_ADD": _build_date_delta(exp.TsOrDsAdd),
 68            "DATEDIFF": _build_date_delta(exp.TsOrDsDiff),
 69            "DATE_DIFF": _build_date_delta(exp.TsOrDsDiff),
 70            "GETDATE": exp.CurrentTimestamp.from_arg_list,
 71            "LISTAGG": exp.GroupConcat.from_arg_list,
 72            "SPLIT_TO_ARRAY": lambda args: exp.StringToArray(
 73                this=seq_get(args, 0), expression=seq_get(args, 1) or exp.Literal.string(",")
 74            ),
 75            "STRTOL": exp.FromBase.from_arg_list,
 76        }
 77
 78        NO_PAREN_FUNCTION_PARSERS = {
 79            **Postgres.Parser.NO_PAREN_FUNCTION_PARSERS,
 80            "APPROXIMATE": lambda self: self._parse_approximate_count(),
 81            "SYSDATE": lambda self: self.expression(exp.CurrentTimestamp, sysdate=True),
 82        }
 83
 84        SUPPORTS_IMPLICIT_UNNEST = True
 85
 86        def _parse_table(
 87            self,
 88            schema: bool = False,
 89            joins: bool = False,
 90            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
 91            parse_bracket: bool = False,
 92            is_db_reference: bool = False,
 93            parse_partition: bool = False,
 94        ) -> t.Optional[exp.Expression]:
 95            # Redshift supports UNPIVOTing SUPER objects, e.g. `UNPIVOT foo.obj[0] AS val AT attr`
 96            unpivot = self._match(TokenType.UNPIVOT)
 97            table = super()._parse_table(
 98                schema=schema,
 99                joins=joins,
100                alias_tokens=alias_tokens,
101                parse_bracket=parse_bracket,
102                is_db_reference=is_db_reference,
103            )
104
105            return self.expression(exp.Pivot, this=table, unpivot=True) if unpivot else table
106
107        def _parse_convert(
108            self, strict: bool, safe: t.Optional[bool] = None
109        ) -> t.Optional[exp.Expression]:
110            to = self._parse_types()
111            self._match(TokenType.COMMA)
112            this = self._parse_bitwise()
113            return self.expression(exp.TryCast, this=this, to=to, safe=safe)
114
115        def _parse_approximate_count(self) -> t.Optional[exp.ApproxDistinct]:
116            index = self._index - 1
117            func = self._parse_function()
118
119            if isinstance(func, exp.Count) and isinstance(func.this, exp.Distinct):
120                return self.expression(exp.ApproxDistinct, this=seq_get(func.this.expressions, 0))
121            self._retreat(index)
122            return None
123
124    class Tokenizer(Postgres.Tokenizer):
125        BIT_STRINGS = []
126        HEX_STRINGS = []
127        STRING_ESCAPES = ["\\", "'"]
128
129        KEYWORDS = {
130            **Postgres.Tokenizer.KEYWORDS,
131            "(+)": TokenType.JOIN_MARKER,
132            "HLLSKETCH": TokenType.HLLSKETCH,
133            "MINUS": TokenType.EXCEPT,
134            "SUPER": TokenType.SUPER,
135            "TOP": TokenType.TOP,
136            "UNLOAD": TokenType.COMMAND,
137            "VARBYTE": TokenType.VARBINARY,
138            "BINARY VARYING": TokenType.VARBINARY,
139        }
140        KEYWORDS.pop("VALUES")
141
142        # Redshift allows # to appear as a table identifier prefix
143        SINGLE_TOKENS = Postgres.Tokenizer.SINGLE_TOKENS.copy()
144        SINGLE_TOKENS.pop("#")
145
146    class Generator(Postgres.Generator):
147        LOCKING_READS_SUPPORTED = False
148        QUERY_HINTS = False
149        VALUES_AS_TABLE = False
150        TZ_TO_WITH_TIME_ZONE = True
151        NVL2_SUPPORTED = True
152        LAST_DAY_SUPPORTS_DATE_PART = False
153        CAN_IMPLEMENT_ARRAY_ANY = False
154        MULTI_ARG_DISTINCT = True
155        COPY_PARAMS_ARE_WRAPPED = False
156        HEX_FUNC = "TO_HEX"
157        PARSE_JSON_NAME = "JSON_PARSE"
158        ARRAY_CONCAT_IS_VAR_LEN = False
159        SUPPORTS_CONVERT_TIMEZONE = True
160        EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE = False
161        SUPPORTS_MEDIAN = True
162
163        # Redshift doesn't have `WITH` as part of their with_properties so we remove it
164        WITH_PROPERTIES_PREFIX = " "
165
166        TYPE_MAPPING = {
167            **Postgres.Generator.TYPE_MAPPING,
168            exp.DataType.Type.BINARY: "VARBYTE",
169            exp.DataType.Type.INT: "INTEGER",
170            exp.DataType.Type.TIMETZ: "TIME",
171            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
172            exp.DataType.Type.VARBINARY: "VARBYTE",
173            exp.DataType.Type.ROWVERSION: "VARBYTE",
174        }
175
176        TRANSFORMS = {
177            **Postgres.Generator.TRANSFORMS,
178            exp.ArrayConcat: lambda self, e: self.arrayconcat_sql(e, name="ARRAY_CONCAT"),
179            exp.Concat: concat_to_dpipe_sql,
180            exp.ConcatWs: concat_ws_to_dpipe_sql,
181            exp.ApproxDistinct: lambda self,
182            e: f"APPROXIMATE COUNT(DISTINCT {self.sql(e, 'this')})",
183            exp.CurrentTimestamp: lambda self, e: (
184                "SYSDATE" if e.args.get("sysdate") else "GETDATE()"
185            ),
186            exp.DateAdd: date_delta_sql("DATEADD"),
187            exp.DateDiff: date_delta_sql("DATEDIFF"),
188            exp.DistKeyProperty: lambda self, e: self.func("DISTKEY", e.this),
189            exp.DistStyleProperty: lambda self, e: self.naked_property(e),
190            exp.Explode: lambda self, e: self.explode_sql(e),
191            exp.FromBase: rename_func("STRTOL"),
192            exp.GeneratedAsIdentityColumnConstraint: generatedasidentitycolumnconstraint_sql,
193            exp.JSONExtract: json_extract_segments("JSON_EXTRACT_PATH_TEXT"),
194            exp.JSONExtractScalar: json_extract_segments("JSON_EXTRACT_PATH_TEXT"),
195            exp.GroupConcat: rename_func("LISTAGG"),
196            exp.Hex: lambda self, e: self.func("UPPER", self.func("TO_HEX", self.sql(e, "this"))),
197            exp.Select: transforms.preprocess(
198                [
199                    transforms.eliminate_distinct_on,
200                    transforms.eliminate_semi_and_anti_joins,
201                    transforms.unqualify_unnest,
202                    transforms.unnest_generate_date_array_using_recursive_cte,
203                ]
204            ),
205            exp.SortKeyProperty: lambda self,
206            e: f"{'COMPOUND ' if e.args['compound'] else ''}SORTKEY({self.format_args(*e.this)})",
207            exp.StartsWith: lambda self,
208            e: f"{self.sql(e.this)} LIKE {self.sql(e.expression)} || '%'",
209            exp.StringToArray: rename_func("SPLIT_TO_ARRAY"),
210            exp.TableSample: no_tablesample_sql,
211            exp.TsOrDsAdd: date_delta_sql("DATEADD"),
212            exp.TsOrDsDiff: date_delta_sql("DATEDIFF"),
213            exp.UnixToTime: lambda self,
214            e: f"(TIMESTAMP 'epoch' + {self.sql(e.this)} * INTERVAL '1 SECOND')",
215        }
216
217        # Postgres maps exp.Pivot to no_pivot_sql, but Redshift support pivots
218        TRANSFORMS.pop(exp.Pivot)
219
220        # Postgres doesn't support JSON_PARSE, but Redshift does
221        TRANSFORMS.pop(exp.ParseJSON)
222
223        # Redshift uses the POW | POWER (expr1, expr2) syntax instead of expr1 ^ expr2 (postgres)
224        TRANSFORMS.pop(exp.Pow)
225
226        # Redshift supports these functions
227        TRANSFORMS.pop(exp.AnyValue)
228        TRANSFORMS.pop(exp.LastDay)
229        TRANSFORMS.pop(exp.SHA2)
230
231        RESERVED_KEYWORDS = {
232            "aes128",
233            "aes256",
234            "all",
235            "allowoverwrite",
236            "analyse",
237            "analyze",
238            "and",
239            "any",
240            "array",
241            "as",
242            "asc",
243            "authorization",
244            "az64",
245            "backup",
246            "between",
247            "binary",
248            "blanksasnull",
249            "both",
250            "bytedict",
251            "bzip2",
252            "case",
253            "cast",
254            "check",
255            "collate",
256            "column",
257            "constraint",
258            "create",
259            "credentials",
260            "cross",
261            "current_date",
262            "current_time",
263            "current_timestamp",
264            "current_user",
265            "current_user_id",
266            "default",
267            "deferrable",
268            "deflate",
269            "defrag",
270            "delta",
271            "delta32k",
272            "desc",
273            "disable",
274            "distinct",
275            "do",
276            "else",
277            "emptyasnull",
278            "enable",
279            "encode",
280            "encrypt     ",
281            "encryption",
282            "end",
283            "except",
284            "explicit",
285            "false",
286            "for",
287            "foreign",
288            "freeze",
289            "from",
290            "full",
291            "globaldict256",
292            "globaldict64k",
293            "grant",
294            "group",
295            "gzip",
296            "having",
297            "identity",
298            "ignore",
299            "ilike",
300            "in",
301            "initially",
302            "inner",
303            "intersect",
304            "interval",
305            "into",
306            "is",
307            "isnull",
308            "join",
309            "leading",
310            "left",
311            "like",
312            "limit",
313            "localtime",
314            "localtimestamp",
315            "lun",
316            "luns",
317            "lzo",
318            "lzop",
319            "minus",
320            "mostly16",
321            "mostly32",
322            "mostly8",
323            "natural",
324            "new",
325            "not",
326            "notnull",
327            "null",
328            "nulls",
329            "off",
330            "offline",
331            "offset",
332            "oid",
333            "old",
334            "on",
335            "only",
336            "open",
337            "or",
338            "order",
339            "outer",
340            "overlaps",
341            "parallel",
342            "partition",
343            "percent",
344            "permissions",
345            "pivot",
346            "placing",
347            "primary",
348            "raw",
349            "readratio",
350            "recover",
351            "references",
352            "rejectlog",
353            "resort",
354            "respect",
355            "restore",
356            "right",
357            "select",
358            "session_user",
359            "similar",
360            "snapshot",
361            "some",
362            "sysdate",
363            "system",
364            "table",
365            "tag",
366            "tdes",
367            "text255",
368            "text32k",
369            "then",
370            "timestamp",
371            "to",
372            "top",
373            "trailing",
374            "true",
375            "truncatecolumns",
376            "type",
377            "union",
378            "unique",
379            "unnest",
380            "unpivot",
381            "user",
382            "using",
383            "verbose",
384            "wallet",
385            "when",
386            "where",
387            "with",
388            "without",
389        }
390
391        def unnest_sql(self, expression: exp.Unnest) -> str:
392            args = expression.expressions
393            num_args = len(args)
394
395            if num_args != 1:
396                self.unsupported(f"Unsupported number of arguments in UNNEST: {num_args}")
397                return ""
398
399            if isinstance(expression.find_ancestor(exp.From, exp.Join, exp.Select), exp.Select):
400                self.unsupported("Unsupported UNNEST when not used in FROM/JOIN clauses")
401                return ""
402
403            arg = self.sql(seq_get(args, 0))
404
405            alias = self.expressions(expression.args.get("alias"), key="columns", flat=True)
406            return f"{arg} AS {alias}" if alias else arg
407
408        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
409            if expression.is_type(exp.DataType.Type.JSON):
410                # Redshift doesn't support a JSON type, so casting to it is treated as a noop
411                return self.sql(expression, "this")
412
413            return super().cast_sql(expression, safe_prefix=safe_prefix)
414
415        def datatype_sql(self, expression: exp.DataType) -> str:
416            """
417            Redshift converts the `TEXT` data type to `VARCHAR(255)` by default when people more generally mean
418            VARCHAR of max length which is `VARCHAR(max)` in Redshift. Therefore if we get a `TEXT` data type
419            without precision we convert it to `VARCHAR(max)` and if it does have precision then we just convert
420            `TEXT` to `VARCHAR`.
421            """
422            if expression.is_type("text"):
423                expression.set("this", exp.DataType.Type.VARCHAR)
424                precision = expression.args.get("expressions")
425
426                if not precision:
427                    expression.append("expressions", exp.var("MAX"))
428
429            return super().datatype_sql(expression)
430
431        def alterset_sql(self, expression: exp.AlterSet) -> str:
432            exprs = self.expressions(expression, flat=True)
433            exprs = f" TABLE PROPERTIES ({exprs})" if exprs else ""
434            location = self.sql(expression, "location")
435            location = f" LOCATION {location}" if location else ""
436            file_format = self.expressions(expression, key="file_format", flat=True, sep=" ")
437            file_format = f" FILE FORMAT {file_format}" if file_format else ""
438
439            return f"SET{exprs}{location}{file_format}"
440
441        def array_sql(self, expression: exp.Array) -> str:
442            if expression.args.get("bracket_notation"):
443                return super().array_sql(expression)
444
445            return rename_func("ARRAY")(self, expression)
446
447        def explode_sql(self, expression: exp.Explode) -> str:
448            self.unsupported("Unsupported EXPLODE() function")
449            return ""

NORMALIZATION_STRATEGY = <NormalizationStrategy.CASE_INSENSITIVE: 'CASE_INSENSITIVE'>

Specifies the strategy according to which identifiers should be normalized.

SUPPORTS_USER_DEFINED_TYPES = False

Whether user-defined data types are supported.

INDEX_OFFSET = 0

The base index offset for arrays.

COPY_PARAMS_ARE_CSV = False

Whether COPY statement parameters are separated by comma or whitespace

HEX_LOWERCASE = True

Whether the HEX function returns a lowercase hexadecimal string.

HAS_DISTINCT_ARRAY_CONSTRUCTORS = True

Whether the ARRAY constructor is context-sensitive, i.e in Redshift ARRAY[1, 2, 3] != ARRAY(1, 2, 3) as the former is of type INT[] vs the latter which is SUPER

TIME_FORMAT = "'YYYY-MM-DD HH24:MI:SS'"

TIME_MAPPING: Dict[str, str] = {'AM': '%p', 'PM': '%p', 'D': '%u', 'DD': '%d', 'DDD': '%j', 'FMDD': '%-d', 'FMDDD': '%-j', 'FMHH12': '%-I', 'FMHH24': '%-H', 'FMMI': '%-M', 'FMMM': '%-m', 'FMSS': '%-S', 'HH12': '%I', 'HH24': '%H', 'MI': '%M', 'MM': '%m', 'OF': '%z', 'SS': '%S', 'TMDay': '%A', 'TMDy': '%a', 'TMMon': '%b', 'TMMonth': '%B', 'TZ': '%Z', 'US': '%f', 'WW': '%U', 'YY': '%y', 'YYYY': '%Y', 'MON': '%b', 'HH': '%I'}

Associates this dialect's time formats with their equivalent Python strftime formats.

SUPPORTS_COLUMN_JOIN_MARKS = True

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 'Redshift.Tokenizer'>

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

parser_class = <class 'Redshift.Parser'>

generator_class = <class 'Redshift.Generator'>

TIME_TRIE: Dict = {'A': {'M': {0: True}}, 'P': {'M': {0: True}}, 'D': {0: True, 'D': {0: True, 'D': {0: True}}}, 'F': {'M': {'D': {'D': {0: True, 'D': {0: True}}}, 'H': {'H': {'1': {'2': {0: True}}, '2': {'4': {0: True}}}}, 'M': {'I': {0: True}, 'M': {0: True}}, 'S': {'S': {0: True}}}}, 'H': {'H': {'1': {'2': {0: True}}, '2': {'4': {0: True}}, 0: True}}, 'M': {'I': {0: True}, 'M': {0: True}, 'O': {'N': {0: True}}}, 'O': {'F': {0: True}}, 'S': {'S': {0: True}}, 'T': {'M': {'D': {'a': {'y': {0: True}}, 'y': {0: True}}, 'M': {'o': {'n': {0: True, 't': {'h': {0: True}}}}}}, 'Z': {0: True}}, 'U': {'S': {0: True}}, 'W': {'W': {0: True}}, 'Y': {'Y': {0: True, 'Y': {'Y': {0: True}}}}}

FORMAT_TRIE: Dict = {'A': {'M': {0: True}}, 'P': {'M': {0: True}}, 'D': {0: True, 'D': {0: True, 'D': {0: True}}}, 'F': {'M': {'D': {'D': {0: True, 'D': {0: True}}}, 'H': {'H': {'1': {'2': {0: True}}, '2': {'4': {0: True}}}}, 'M': {'I': {0: True}, 'M': {0: True}}, 'S': {'S': {0: True}}}}, 'H': {'H': {'1': {'2': {0: True}}, '2': {'4': {0: True}}, 0: True}}, 'M': {'I': {0: True}, 'M': {0: True}, 'O': {'N': {0: True}}}, 'O': {'F': {0: True}}, 'S': {'S': {0: True}}, 'T': {'M': {'D': {'a': {'y': {0: True}}, 'y': {0: True}}, 'M': {'o': {'n': {0: True, 't': {'h': {0: True}}}}}}, 'Z': {0: True}}, 'U': {'S': {0: True}}, 'W': {'W': {0: True}}, 'Y': {'Y': {0: True, 'Y': {'Y': {0: True}}}}}

INVERSE_TIME_MAPPING: Dict[str, str] = {'%p': 'PM', '%u': 'D', '%d': 'DD', '%j': 'DDD', '%-d': 'FMDD', '%-j': 'FMDDD', '%-I': 'FMHH12', '%-H': 'FMHH24', '%-M': 'FMMI', '%-m': 'FMMM', '%-S': 'FMSS', '%I': 'HH', '%H': 'HH24', '%M': 'MI', '%m': 'MM', '%z': 'OF', '%S': 'SS', '%A': 'TMDay', '%a': 'TMDy', '%b': 'MON', '%B': 'TMMonth', '%Z': 'TZ', '%f': 'US', '%U': 'WW', '%y': 'YY', '%Y': 'YYYY'}

INVERSE_TIME_TRIE: Dict = {'%': {'p': {0: True}, 'u': {0: True}, 'd': {0: True}, 'j': {0: True}, '-': {'d': {0: True}, 'j': {0: True}, 'I': {0: True}, 'H': {0: True}, 'M': {0: True}, 'm': {0: True}, 'S': {0: True}}, 'I': {0: True}, 'H': {0: True}, 'M': {0: True}, 'm': {0: True}, 'z': {0: True}, 'S': {0: True}, 'A': {0: True}, 'a': {0: True}, 'b': {0: True}, 'B': {0: True}, 'Z': {0: True}, 'f': {0: True}, 'U': {0: True}, 'y': {0: True}, 'Y': {0: True}}}

INVERSE_FORMAT_MAPPING: Dict[str, str] = {}

INVERSE_FORMAT_TRIE: Dict = {}

INVERSE_CREATABLE_KIND_MAPPING: dict[str, str] = {}

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] = None

BIT_END: Optional[str] = None

HEX_START: Optional[str] = None

HEX_END: Optional[str] = None

BYTE_START: Optional[str] = "e'"

BYTE_END: Optional[str] = "'"

UNICODE_START: Optional[str] = None

UNICODE_END: Optional[str] = None

Inherited Members

sqlglot.dialects.dialect.Dialect: Dialect; WEEK_OFFSET; UNNEST_COLUMN_ONLY; ALIAS_POST_TABLESAMPLE; IDENTIFIERS_CAN_START_WITH_DIGIT; DPIPE_IS_STRING_CONCAT; STRICT_STRING_CONCAT; SUPPORTS_SEMI_ANTI_JOIN; NORMALIZE_FUNCTIONS; PRESERVE_ORIGINAL_NAMES; LOG_BASE_FIRST; SAFE_DIVISION; DATE_FORMAT; DATEINT_FORMAT; FORMAT_MAPPING; PSEUDOCOLUMNS; PREFER_CTE_ALIAS_COLUMN; FORCE_EARLY_ALIAS_REF_EXPANSION; EXPAND_ALIAS_REFS_EARLY_ONLY_IN_GROUP_BY; SUPPORTS_ORDER_BY_ALL; SUPPORTS_FIXED_SIZE_ARRAYS; STRICT_JSON_PATH_SYNTAX; ON_CONDITION_EMPTY_BEFORE_ERROR; ARRAY_AGG_INCLUDES_NULLS; PROMOTE_TO_INFERRED_DATETIME_TYPE; SUPPORTS_VALUES_DEFAULT; REGEXP_EXTRACT_DEFAULT_GROUP; SET_OP_DISTINCT_BY_DEFAULT; CREATABLE_KIND_MAPPING; 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.postgres.Postgres: TYPED_DIVISION; CONCAT_COALESCE; NULL_ORDERING; TABLESAMPLE_SIZE_IS_PERCENT

class Redshift.Parser(sqlglot.dialects.postgres.Postgres.Parser): View Source

 56    class Parser(Postgres.Parser):
 57        FUNCTIONS = {
 58            **Postgres.Parser.FUNCTIONS,
 59            "ADD_MONTHS": lambda args: exp.TsOrDsAdd(
 60                this=seq_get(args, 0),
 61                expression=seq_get(args, 1),
 62                unit=exp.var("month"),
 63                return_type=exp.DataType.build("TIMESTAMP"),
 64            ),
 65            "CONVERT_TIMEZONE": lambda args: build_convert_timezone(args, "UTC"),
 66            "DATEADD": _build_date_delta(exp.TsOrDsAdd),
 67            "DATE_ADD": _build_date_delta(exp.TsOrDsAdd),
 68            "DATEDIFF": _build_date_delta(exp.TsOrDsDiff),
 69            "DATE_DIFF": _build_date_delta(exp.TsOrDsDiff),
 70            "GETDATE": exp.CurrentTimestamp.from_arg_list,
 71            "LISTAGG": exp.GroupConcat.from_arg_list,
 72            "SPLIT_TO_ARRAY": lambda args: exp.StringToArray(
 73                this=seq_get(args, 0), expression=seq_get(args, 1) or exp.Literal.string(",")
 74            ),
 75            "STRTOL": exp.FromBase.from_arg_list,
 76        }
 77
 78        NO_PAREN_FUNCTION_PARSERS = {
 79            **Postgres.Parser.NO_PAREN_FUNCTION_PARSERS,
 80            "APPROXIMATE": lambda self: self._parse_approximate_count(),
 81            "SYSDATE": lambda self: self.expression(exp.CurrentTimestamp, sysdate=True),
 82        }
 83
 84        SUPPORTS_IMPLICIT_UNNEST = True
 85
 86        def _parse_table(
 87            self,
 88            schema: bool = False,
 89            joins: bool = False,
 90            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
 91            parse_bracket: bool = False,
 92            is_db_reference: bool = False,
 93            parse_partition: bool = False,
 94        ) -> t.Optional[exp.Expression]:
 95            # Redshift supports UNPIVOTing SUPER objects, e.g. `UNPIVOT foo.obj[0] AS val AT attr`
 96            unpivot = self._match(TokenType.UNPIVOT)
 97            table = super()._parse_table(
 98                schema=schema,
 99                joins=joins,
100                alias_tokens=alias_tokens,
101                parse_bracket=parse_bracket,
102                is_db_reference=is_db_reference,
103            )
104
105            return self.expression(exp.Pivot, this=table, unpivot=True) if unpivot else table
106
107        def _parse_convert(
108            self, strict: bool, safe: t.Optional[bool] = None
109        ) -> t.Optional[exp.Expression]:
110            to = self._parse_types()
111            self._match(TokenType.COMMA)
112            this = self._parse_bitwise()
113            return self.expression(exp.TryCast, this=this, to=to, safe=safe)
114
115        def _parse_approximate_count(self) -> t.Optional[exp.ApproxDistinct]:
116            index = self._index - 1
117            func = self._parse_function()
118
119            if isinstance(func, exp.Count) and isinstance(func.this, exp.Distinct):
120                return self.expression(exp.ApproxDistinct, this=seq_get(func.this.expressions, 0))
121            self._retreat(index)
122            return None

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': <function Redshift.Parser.<lambda>>, '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'>>, 'APPLY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Apply'>>, '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': <function Parser.<lambda>>, 'ARRAY_AGG': <function Parser.<lambda>>, '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': <function Parser.<lambda>>, 'CHAR': <function Parser.<lambda>>, 'COALESCE': <function build_coalesce>, 'IFNULL': <function build_coalesce>, 'NVL': <function build_coalesce>, 'COLLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Collate'>>, 'COLUMNS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Columns'>>, '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'>>, 'CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Contains'>>, 'CONVERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Convert'>>, 'CONVERT_TIMEZONE': <function Redshift.Parser.<lambda>>, 'CORR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Corr'>>, 'COUNT': <function Parser.<lambda>>, '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': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Date'>>, 'DATE_ADD': <function _build_date_delta.<locals>._builder>, 'DATEDIFF': <function _build_date_delta.<locals>._builder>, 'DATE_DIFF': <function _build_date_delta.<locals>._builder>, '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': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateSub'>>, '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': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Day'>>, 'DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAYOFMONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAY_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAYOFWEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAYOFWEEK_ISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeekIso'>>, 'ISODOW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeekIso'>>, 'DAY_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DAYOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, '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'>>, 'EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Exists'>>, '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'>>, 'EXPLODING_GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ExplodingGenerateSeries'>>, 'EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Extract'>>, 'FEATURES_AT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FeaturesAtTime'>>, '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'>>, 'FROM_ISO8601_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromISO8601Timestamp'>>, 'GAP_FILL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GapFill'>>, 'GENERATE_DATE_ARRAY': <function Parser.<lambda>>, 'GENERATE_SERIES': <function _build_generate_series>, 'GENERATE_TIMESTAMP_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateTimestampArray'>>, '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'>>, 'INLINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Inline'>>, 'INT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Int64'>>, '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_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExists'>>, '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'>>, 'J_S_O_N_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONExists'>>, 'JSON_EXTRACT': <function build_extract_json_with_path.<locals>._builder>, 'JSON_EXTRACT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONExtractArray'>>, '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'>>, 'J_S_O_N_VALUE_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONValueArray'>>, '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'>>, 'MAKE_INTERVAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MakeInterval'>>, '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'>>, 'MEDIAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Median'>>, 'MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Min'>>, 'MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Month'>>, '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'>>, 'NORMALIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Normalize'>>, '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'>>, 'OVERLAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Overlay'>>, '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_EXTRACT_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpExtractAll'>>, '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': <function _build_regexp_replace>, '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'>>, 'SPLIT_PART': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SplitPart'>>, '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': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToDate'>>, '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': <bound method Func.from_arg_list of <class 'sqlglot.expressions.String'>>, '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'>>, 'SUBSTR': <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': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampDiff'>>, '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': <function build_formatted_time.<locals>._builder>, 'TO_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToDays'>>, 'TO_DOUBLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToDouble'>>, '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_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToDatetime'>>, '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_SECONDS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixSeconds'>>, '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': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Explode'>>, 'UPPER': <function build_upper>, 'UCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Upper'>>, 'UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, 'GEN_RANDOM_UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, 'GENERATE_UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, 'UUID_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, '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': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Week'>>, 'WEEK_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'WEEKOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, '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': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Year'>>, 'ARRAYAGG': <function Parser.<lambda>>, 'GLOB': <function Parser.<lambda>>, 'INSTR': <function Parser.<lambda>>, 'JSON_EXTRACT_PATH_TEXT': <function build_json_extract_path.<locals>._builder>, 'LIKE': <function build_like>, 'LOG2': <function Parser.<lambda>>, 'LOG10': <function Parser.<lambda>>, 'LPAD': <function Parser.<lambda>>, 'LEFTPAD': <function Parser.<lambda>>, 'LTRIM': <function Parser.<lambda>>, 'MOD': <function build_mod>, 'RIGHTPAD': <function Parser.<lambda>>, 'RPAD': <function Parser.<lambda>>, 'RTRIM': <function Parser.<lambda>>, 'SCOPE_RESOLUTION': <function Parser.<lambda>>, 'TO_HEX': <function build_hex>, 'DIV': <function Postgres.Parser.<lambda>>, 'JSON_EXTRACT_PATH': <function build_json_extract_path.<locals>._builder>, 'MAKE_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'MAKE_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'NOW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTimestamp'>>, 'TO_DATE': <function build_formatted_time.<locals>._builder>, 'TO_TIMESTAMP': <function _build_to_timestamp>, 'SHA256': <function Postgres.Parser.<lambda>>, 'SHA384': <function Postgres.Parser.<lambda>>, 'SHA512': <function Postgres.Parser.<lambda>>, 'LEVENSHTEIN_LESS_EQUAL': <function _build_levenshtein_less_equal>, 'DATEADD': <function _build_date_delta.<locals>._builder>, 'GETDATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTimestamp'>>, 'LISTAGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GroupConcat'>>, 'SPLIT_TO_ARRAY': <function Redshift.Parser.<lambda>>, 'STRTOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase'>>}

NO_PAREN_FUNCTION_PARSERS = {'ANY': <function Parser.<lambda>>, 'CASE': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <function Parser.<lambda>>, 'IF': <function Parser.<lambda>>, 'NEXT': <function Parser.<lambda>>, 'APPROXIMATE': <function Redshift.Parser.<lambda>>, 'SYSDATE': <function Redshift.Parser.<lambda>>}

SUPPORTS_IMPLICIT_UNNEST = True

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

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

SHOW_TRIE: Dict = {}

SET_TRIE: Dict = {'GLOBAL': {0: True}, 'LOCAL': {0: True}, 'SESSION': {0: True}, 'TRANSACTION': {0: True}}

Inherited Members

sqlglot.parser.Parser: Parser; NO_PAREN_FUNCTIONS; STRUCT_TYPE_TOKENS; NESTED_TYPE_TOKENS; ENUM_TYPE_TOKENS; AGGREGATE_TYPE_TOKENS; TYPE_TOKENS; SIGNED_TO_UNSIGNED_TYPE_TOKEN; SUBQUERY_PREDICATES; RESERVED_TOKENS; DB_CREATABLES; CREATABLES; ALTERABLES; INTERVAL_VARS; ALIAS_TOKENS; ARRAY_CONSTRUCTORS; COMMENT_TABLE_ALIAS_TOKENS; UPDATE_ALIAS_TOKENS; TRIM_TYPES; FUNC_TOKENS; CONJUNCTION; ASSIGNMENT; DISJUNCTION; EQUALITY; COMPARISON; TERM; FACTOR; TIMES; TIMESTAMPS; SET_OPERATIONS; JOIN_METHODS; JOIN_SIDES; JOIN_KINDS; JOIN_HINTS; LAMBDAS; EXPRESSION_PARSERS; UNARY_PARSERS; STRING_PARSERS; NUMERIC_PARSERS; PRIMARY_PARSERS; PLACEHOLDER_PARSERS; CONSTRAINT_PARSERS; ALTER_PARSERS; ALTER_ALTER_PARSERS; SCHEMA_UNNAMED_CONSTRAINTS; INVALID_FUNC_NAME_TOKENS; FUNCTIONS_WITH_ALIASED_ARGS; KEY_VALUE_DEFINITIONS; QUERY_MODIFIER_PARSERS; SET_PARSERS; SHOW_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; PROCEDURE_OPTIONS; EXECUTE_AS_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; IS_JSON_PREDICATE_KIND; ODBC_DATETIME_LITERALS; ON_CONDITION_TOKENS; PRIVILEGE_FOLLOW_TOKENS; DESCRIBE_STYLES; OPERATION_MODIFIERS; STRICT_CAST; PREFIXED_PIVOT_COLUMNS; IDENTIFY_PIVOT_STRINGS; LOG_DEFAULTS_TO_LN; ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN; TABLESAMPLE_CSV; DEFAULT_SAMPLING_METHOD; SET_REQUIRES_ASSIGNMENT_DELIMITER; TRIM_PATTERN_FIRST; STRING_ALIASES; MODIFIERS_ATTACHED_TO_SET_OP; SET_OP_MODIFIERS; NO_PAREN_IF_COMMANDS; COLON_IS_VARIANT_EXTRACT; VALUES_FOLLOWED_BY_PAREN; INTERVAL_SPANS; SUPPORTS_PARTITION_SELECTION; WRAPPED_TRANSFORM_COLUMN_CONSTRAINT; error_level; error_message_context; max_errors; dialect; reset; parse; parse_into; check_errors; raise_error; expression; validate_expression; errors; sql
sqlglot.dialects.postgres.Postgres.Parser: PROPERTY_PARSERS; FUNCTION_PARSERS; BITWISE; EXPONENT; RANGE_PARSERS; STATEMENT_PARSERS; JSON_ARROWS_REQUIRE_JSON_TYPE; COLUMN_OPERATORS

class Redshift.Tokenizer(sqlglot.dialects.postgres.Postgres.Tokenizer): View Source

124    class Tokenizer(Postgres.Tokenizer):
125        BIT_STRINGS = []
126        HEX_STRINGS = []
127        STRING_ESCAPES = ["\\", "'"]
128
129        KEYWORDS = {
130            **Postgres.Tokenizer.KEYWORDS,
131            "(+)": TokenType.JOIN_MARKER,
132            "HLLSKETCH": TokenType.HLLSKETCH,
133            "MINUS": TokenType.EXCEPT,
134            "SUPER": TokenType.SUPER,
135            "TOP": TokenType.TOP,
136            "UNLOAD": TokenType.COMMAND,
137            "VARBYTE": TokenType.VARBINARY,
138            "BINARY VARYING": TokenType.VARBINARY,
139        }
140        KEYWORDS.pop("VALUES")
141
142        # Redshift allows # to appear as a table identifier prefix
143        SINGLE_TOKENS = Postgres.Tokenizer.SINGLE_TOKENS.copy()
144        SINGLE_TOKENS.pop("#")

BIT_STRINGS = []

HEX_STRINGS = []

STRING_ESCAPES = ['\\', "'"]

KEYWORDS = {'{%': <TokenType.BLOCK_START: 'BLOCK_START'>, '{%+': <TokenType.BLOCK_START: 'BLOCK_START'>, '{%-': <TokenType.BLOCK_START: 'BLOCK_START'>, '%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '+%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '-%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '{{+': <TokenType.BLOCK_START: 'BLOCK_START'>, '{{-': <TokenType.BLOCK_START: 'BLOCK_START'>, '+}}': <TokenType.BLOCK_END: 'BLOCK_END'>, '-}}': <TokenType.BLOCK_END: 'BLOCK_END'>, '==': <TokenType.EQ: 'EQ'>, '::': <TokenType.DCOLON: 'DCOLON'>, '||': <TokenType.DPIPE: 'DPIPE'>, '>=': <TokenType.GTE: 'GTE'>, '<=': <TokenType.LTE: 'LTE'>, '<>': <TokenType.NEQ: 'NEQ'>, '!=': <TokenType.NEQ: 'NEQ'>, ':=': <TokenType.COLON_EQ: 'COLON_EQ'>, '<=>': <TokenType.NULLSAFE_EQ: 'NULLSAFE_EQ'>, '->': <TokenType.ARROW: 'ARROW'>, '->>': <TokenType.DARROW: 'DARROW'>, '=>': <TokenType.FARROW: 'FARROW'>, '#>': <TokenType.HASH_ARROW: 'HASH_ARROW'>, '#>>': <TokenType.DHASH_ARROW: 'DHASH_ARROW'>, '<->': <TokenType.LR_ARROW: 'LR_ARROW'>, '&&': <TokenType.DAMP: 'DAMP'>, '??': <TokenType.DQMARK: 'DQMARK'>, '~~~': <TokenType.GLOB: 'GLOB'>, '~~': <TokenType.LIKE: 'LIKE'>, '~~*': <TokenType.ILIKE: 'ILIKE'>, '~*': <TokenType.IRLIKE: 'IRLIKE'>, 'ALL': <TokenType.ALL: 'ALL'>, 'ALWAYS': <TokenType.ALWAYS: 'ALWAYS'>, 'AND': <TokenType.AND: 'AND'>, 'ANTI': <TokenType.ANTI: 'ANTI'>, 'ANY': <TokenType.ANY: 'ANY'>, 'ASC': <TokenType.ASC: 'ASC'>, 'AS': <TokenType.ALIAS: 'ALIAS'>, 'ASOF': <TokenType.ASOF: 'ASOF'>, 'AUTOINCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'AUTO_INCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'BEGIN': <TokenType.COMMAND: 'COMMAND'>, 'BETWEEN': <TokenType.BETWEEN: 'BETWEEN'>, 'CACHE': <TokenType.CACHE: 'CACHE'>, 'UNCACHE': <TokenType.UNCACHE: 'UNCACHE'>, 'CASE': <TokenType.CASE: 'CASE'>, 'CHARACTER SET': <TokenType.CHARACTER_SET: 'CHARACTER_SET'>, 'CLUSTER BY': <TokenType.CLUSTER_BY: 'CLUSTER_BY'>, 'COLLATE': <TokenType.COLLATE: 'COLLATE'>, 'COLUMN': <TokenType.COLUMN: 'COLUMN'>, 'COMMIT': <TokenType.COMMIT: 'COMMIT'>, 'CONNECT BY': <TokenType.CONNECT_BY: 'CONNECT_BY'>, 'CONSTRAINT': <TokenType.CONSTRAINT: 'CONSTRAINT'>, 'COPY': <TokenType.COPY: 'COPY'>, 'CREATE': <TokenType.CREATE: 'CREATE'>, 'CROSS': <TokenType.CROSS: 'CROSS'>, 'CUBE': <TokenType.CUBE: 'CUBE'>, 'CURRENT_DATE': <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, 'CURRENT_TIME': <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, 'CURRENT_TIMESTAMP': <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, 'CURRENT_USER': <TokenType.CURRENT_USER: 'CURRENT_USER'>, 'DATABASE': <TokenType.DATABASE: 'DATABASE'>, 'DEFAULT': <TokenType.DEFAULT: 'DEFAULT'>, 'DELETE': <TokenType.DELETE: 'DELETE'>, 'DESC': <TokenType.DESC: 'DESC'>, 'DESCRIBE': <TokenType.DESCRIBE: 'DESCRIBE'>, 'DISTINCT': <TokenType.DISTINCT: 'DISTINCT'>, 'DISTRIBUTE BY': <TokenType.DISTRIBUTE_BY: 'DISTRIBUTE_BY'>, 'DROP': <TokenType.DROP: 'DROP'>, 'ELSE': <TokenType.ELSE: 'ELSE'>, 'END': <TokenType.END: 'END'>, 'ENUM': <TokenType.ENUM: 'ENUM'>, 'ESCAPE': <TokenType.ESCAPE: 'ESCAPE'>, 'EXCEPT': <TokenType.EXCEPT: 'EXCEPT'>, 'EXECUTE': <TokenType.EXECUTE: 'EXECUTE'>, 'EXISTS': <TokenType.EXISTS: 'EXISTS'>, 'FALSE': <TokenType.FALSE: 'FALSE'>, 'FETCH': <TokenType.FETCH: 'FETCH'>, 'FILTER': <TokenType.FILTER: 'FILTER'>, 'FIRST': <TokenType.FIRST: 'FIRST'>, 'FULL': <TokenType.FULL: 'FULL'>, 'FUNCTION': <TokenType.FUNCTION: 'FUNCTION'>, 'FOR': <TokenType.FOR: 'FOR'>, 'FOREIGN KEY': <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, 'FORMAT': <TokenType.FORMAT: 'FORMAT'>, 'FROM': <TokenType.FROM: 'FROM'>, 'GEOGRAPHY': <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, 'GEOMETRY': <TokenType.GEOMETRY: 'GEOMETRY'>, 'GLOB': <TokenType.GLOB: 'GLOB'>, 'GROUP BY': <TokenType.GROUP_BY: 'GROUP_BY'>, 'GROUPING SETS': <TokenType.GROUPING_SETS: 'GROUPING_SETS'>, 'HAVING': <TokenType.HAVING: 'HAVING'>, 'ILIKE': <TokenType.ILIKE: 'ILIKE'>, 'IN': <TokenType.IN: 'IN'>, 'INDEX': <TokenType.INDEX: 'INDEX'>, 'INET': <TokenType.INET: 'INET'>, 'INNER': <TokenType.INNER: 'INNER'>, 'INSERT': <TokenType.INSERT: 'INSERT'>, 'INTERVAL': <TokenType.INTERVAL: 'INTERVAL'>, 'INTERSECT': <TokenType.INTERSECT: 'INTERSECT'>, 'INTO': <TokenType.INTO: 'INTO'>, 'IS': <TokenType.IS: 'IS'>, 'ISNULL': <TokenType.ISNULL: 'ISNULL'>, 'JOIN': <TokenType.JOIN: 'JOIN'>, 'KEEP': <TokenType.KEEP: 'KEEP'>, 'KILL': <TokenType.KILL: 'KILL'>, 'LATERAL': <TokenType.LATERAL: 'LATERAL'>, 'LEFT': <TokenType.LEFT: 'LEFT'>, 'LIKE': <TokenType.LIKE: 'LIKE'>, 'LIMIT': <TokenType.LIMIT: 'LIMIT'>, 'LOAD': <TokenType.LOAD: 'LOAD'>, 'LOCK': <TokenType.LOCK: 'LOCK'>, 'MERGE': <TokenType.MERGE: 'MERGE'>, 'NATURAL': <TokenType.NATURAL: 'NATURAL'>, 'NEXT': <TokenType.NEXT: 'NEXT'>, 'NOT': <TokenType.NOT: 'NOT'>, 'NOTNULL': <TokenType.NOTNULL: 'NOTNULL'>, 'NULL': <TokenType.NULL: 'NULL'>, 'OBJECT': <TokenType.OBJECT: 'OBJECT'>, 'OFFSET': <TokenType.OFFSET: 'OFFSET'>, 'ON': <TokenType.ON: 'ON'>, 'OR': <TokenType.OR: 'OR'>, 'XOR': <TokenType.XOR: 'XOR'>, 'ORDER BY': <TokenType.ORDER_BY: 'ORDER_BY'>, 'ORDINALITY': <TokenType.ORDINALITY: 'ORDINALITY'>, 'OUTER': <TokenType.OUTER: 'OUTER'>, 'OVER': <TokenType.OVER: 'OVER'>, 'OVERLAPS': <TokenType.OVERLAPS: 'OVERLAPS'>, 'OVERWRITE': <TokenType.OVERWRITE: 'OVERWRITE'>, 'PARTITION': <TokenType.PARTITION: 'PARTITION'>, 'PARTITION BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED_BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PERCENT': <TokenType.PERCENT: 'PERCENT'>, 'PIVOT': <TokenType.PIVOT: 'PIVOT'>, 'PRAGMA': <TokenType.PRAGMA: 'PRAGMA'>, 'PRIMARY KEY': <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, 'PROCEDURE': <TokenType.PROCEDURE: 'PROCEDURE'>, 'QUALIFY': <TokenType.QUALIFY: 'QUALIFY'>, 'RANGE': <TokenType.RANGE: 'RANGE'>, 'RECURSIVE': <TokenType.RECURSIVE: 'RECURSIVE'>, 'REGEXP': <TokenType.RLIKE: 'RLIKE'>, 'RENAME': <TokenType.RENAME: 'RENAME'>, 'REPLACE': <TokenType.REPLACE: 'REPLACE'>, 'RETURNING': <TokenType.RETURNING: 'RETURNING'>, 'REFERENCES': <TokenType.REFERENCES: 'REFERENCES'>, 'RIGHT': <TokenType.RIGHT: 'RIGHT'>, 'RLIKE': <TokenType.RLIKE: 'RLIKE'>, 'ROLLBACK': <TokenType.ROLLBACK: 'ROLLBACK'>, 'ROLLUP': <TokenType.ROLLUP: 'ROLLUP'>, 'ROW': <TokenType.ROW: 'ROW'>, 'ROWS': <TokenType.ROWS: 'ROWS'>, 'SCHEMA': <TokenType.SCHEMA: 'SCHEMA'>, 'SELECT': <TokenType.SELECT: 'SELECT'>, 'SEMI': <TokenType.SEMI: 'SEMI'>, 'SET': <TokenType.SET: 'SET'>, 'SETTINGS': <TokenType.SETTINGS: 'SETTINGS'>, 'SHOW': <TokenType.SHOW: 'SHOW'>, 'SIMILAR TO': <TokenType.SIMILAR_TO: 'SIMILAR_TO'>, 'SOME': <TokenType.SOME: 'SOME'>, 'SORT BY': <TokenType.SORT_BY: 'SORT_BY'>, 'START WITH': <TokenType.START_WITH: 'START_WITH'>, 'STRAIGHT_JOIN': <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, 'TABLE': <TokenType.TABLE: 'TABLE'>, 'TABLESAMPLE': <TokenType.TABLE_SAMPLE: 'TABLE_SAMPLE'>, 'TEMP': <TokenType.TEMPORARY: 'TEMPORARY'>, 'TEMPORARY': <TokenType.TEMPORARY: 'TEMPORARY'>, 'THEN': <TokenType.THEN: 'THEN'>, 'TRUE': <TokenType.TRUE: 'TRUE'>, 'TRUNCATE': <TokenType.TRUNCATE: 'TRUNCATE'>, 'UNION': <TokenType.UNION: 'UNION'>, 'UNKNOWN': <TokenType.UNKNOWN: 'UNKNOWN'>, 'UNNEST': <TokenType.UNNEST: 'UNNEST'>, 'UNPIVOT': <TokenType.UNPIVOT: 'UNPIVOT'>, 'UPDATE': <TokenType.UPDATE: 'UPDATE'>, 'USE': <TokenType.USE: 'USE'>, 'USING': <TokenType.USING: 'USING'>, 'UUID': <TokenType.UUID: 'UUID'>, 'VIEW': <TokenType.VIEW: 'VIEW'>, 'VOLATILE': <TokenType.VOLATILE: 'VOLATILE'>, 'WHEN': <TokenType.WHEN: 'WHEN'>, 'WHERE': <TokenType.WHERE: 'WHERE'>, 'WINDOW': <TokenType.WINDOW: 'WINDOW'>, 'WITH': <TokenType.WITH: 'WITH'>, 'APPLY': <TokenType.APPLY: 'APPLY'>, 'ARRAY': <TokenType.ARRAY: 'ARRAY'>, 'BIT': <TokenType.BIT: 'BIT'>, 'BOOL': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BOOLEAN': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BYTE': <TokenType.TINYINT: 'TINYINT'>, 'MEDIUMINT': <TokenType.MEDIUMINT: 'MEDIUMINT'>, 'INT1': <TokenType.TINYINT: 'TINYINT'>, 'TINYINT': <TokenType.TINYINT: 'TINYINT'>, 'INT16': <TokenType.SMALLINT: 'SMALLINT'>, 'SHORT': <TokenType.SMALLINT: 'SMALLINT'>, 'SMALLINT': <TokenType.SMALLINT: 'SMALLINT'>, 'INT128': <TokenType.INT128: 'INT128'>, 'HUGEINT': <TokenType.INT128: 'INT128'>, 'UHUGEINT': <TokenType.UINT128: 'UINT128'>, 'INT2': <TokenType.SMALLINT: 'SMALLINT'>, 'INTEGER': <TokenType.INT: 'INT'>, 'INT': <TokenType.INT: 'INT'>, 'INT4': <TokenType.INT: 'INT'>, 'INT32': <TokenType.INT: 'INT'>, 'INT64': <TokenType.BIGINT: 'BIGINT'>, 'LONG': <TokenType.BIGINT: 'BIGINT'>, 'BIGINT': <TokenType.BIGINT: 'BIGINT'>, 'INT8': <TokenType.BIGINT: 'BIGINT'>, 'UINT': <TokenType.UINT: 'UINT'>, 'DEC': <TokenType.DECIMAL: 'DECIMAL'>, 'DECIMAL': <TokenType.DECIMAL: 'DECIMAL'>, 'DECIMAL32': <TokenType.DECIMAL32: 'DECIMAL32'>, 'DECIMAL64': <TokenType.DECIMAL64: 'DECIMAL64'>, 'DECIMAL128': <TokenType.DECIMAL128: 'DECIMAL128'>, 'DECIMAL256': <TokenType.DECIMAL256: 'DECIMAL256'>, 'BIGDECIMAL': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, 'BIGNUMERIC': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, 'LIST': <TokenType.LIST: 'LIST'>, 'MAP': <TokenType.MAP: 'MAP'>, 'NULLABLE': <TokenType.NULLABLE: 'NULLABLE'>, 'NUMBER': <TokenType.DECIMAL: 'DECIMAL'>, 'NUMERIC': <TokenType.DECIMAL: 'DECIMAL'>, 'FIXED': <TokenType.DECIMAL: 'DECIMAL'>, 'REAL': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT': <TokenType.DOUBLE: 'DOUBLE'>, 'FLOAT4': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT8': <TokenType.DOUBLE: 'DOUBLE'>, 'DOUBLE': <TokenType.DOUBLE: 'DOUBLE'>, 'DOUBLE PRECISION': <TokenType.DOUBLE: 'DOUBLE'>, 'JSON': <TokenType.JSON: 'JSON'>, 'JSONB': <TokenType.JSONB: 'JSONB'>, 'CHAR': <TokenType.CHAR: 'CHAR'>, 'CHARACTER': <TokenType.CHAR: 'CHAR'>, 'NCHAR': <TokenType.NCHAR: 'NCHAR'>, 'VARCHAR': <TokenType.VARCHAR: 'VARCHAR'>, 'VARCHAR2': <TokenType.VARCHAR: 'VARCHAR'>, 'NVARCHAR': <TokenType.NVARCHAR: 'NVARCHAR'>, 'NVARCHAR2': <TokenType.NVARCHAR: 'NVARCHAR'>, 'BPCHAR': <TokenType.BPCHAR: 'BPCHAR'>, 'STR': <TokenType.TEXT: 'TEXT'>, 'STRING': <TokenType.TEXT: 'TEXT'>, 'TEXT': <TokenType.TEXT: 'TEXT'>, 'LONGTEXT': <TokenType.LONGTEXT: 'LONGTEXT'>, 'MEDIUMTEXT': <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, 'TINYTEXT': <TokenType.TINYTEXT: 'TINYTEXT'>, 'CLOB': <TokenType.TEXT: 'TEXT'>, 'LONGVARCHAR': <TokenType.TEXT: 'TEXT'>, 'BINARY': <TokenType.BINARY: 'BINARY'>, 'BLOB': <TokenType.VARBINARY: 'VARBINARY'>, 'LONGBLOB': <TokenType.LONGBLOB: 'LONGBLOB'>, 'MEDIUMBLOB': <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, 'TINYBLOB': <TokenType.TINYBLOB: 'TINYBLOB'>, 'BYTEA': <TokenType.VARBINARY: 'VARBINARY'>, 'VARBINARY': <TokenType.VARBINARY: 'VARBINARY'>, 'TIME': <TokenType.TIME: 'TIME'>, 'TIMETZ': <TokenType.TIMETZ: 'TIMETZ'>, 'TIMESTAMP': <TokenType.TIMESTAMP: 'TIMESTAMP'>, 'TIMESTAMPTZ': <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, 'TIMESTAMPLTZ': <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, 'TIMESTAMP_LTZ': <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, 'TIMESTAMPNTZ': <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, 'TIMESTAMP_NTZ': <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, 'DATE': <TokenType.DATE: 'DATE'>, 'DATETIME': <TokenType.DATETIME: 'DATETIME'>, 'INT4RANGE': <TokenType.INT4RANGE: 'INT4RANGE'>, 'INT4MULTIRANGE': <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, 'INT8RANGE': <TokenType.INT8RANGE: 'INT8RANGE'>, 'INT8MULTIRANGE': <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, 'NUMRANGE': <TokenType.NUMRANGE: 'NUMRANGE'>, 'NUMMULTIRANGE': <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, 'TSRANGE': <TokenType.TSRANGE: 'TSRANGE'>, 'TSMULTIRANGE': <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, 'TSTZRANGE': <TokenType.TSTZRANGE: 'TSTZRANGE'>, 'TSTZMULTIRANGE': <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, 'DATERANGE': <TokenType.DATERANGE: 'DATERANGE'>, 'DATEMULTIRANGE': <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, 'UNIQUE': <TokenType.UNIQUE: 'UNIQUE'>, 'VECTOR': <TokenType.VECTOR: 'VECTOR'>, 'STRUCT': <TokenType.STRUCT: 'STRUCT'>, 'SEQUENCE': <TokenType.SEQUENCE: 'SEQUENCE'>, 'VARIANT': <TokenType.VARIANT: 'VARIANT'>, 'ALTER': <TokenType.ALTER: 'ALTER'>, 'ANALYZE': <TokenType.COMMAND: 'COMMAND'>, 'CALL': <TokenType.COMMAND: 'COMMAND'>, 'COMMENT': <TokenType.COMMENT: 'COMMENT'>, 'EXPLAIN': <TokenType.COMMAND: 'COMMAND'>, 'GRANT': <TokenType.GRANT: 'GRANT'>, 'OPTIMIZE': <TokenType.COMMAND: 'COMMAND'>, 'PREPARE': <TokenType.COMMAND: 'COMMAND'>, 'VACUUM': <TokenType.COMMAND: 'COMMAND'>, 'USER-DEFINED': <TokenType.USERDEFINED: 'USERDEFINED'>, 'FOR VERSION': <TokenType.VERSION_SNAPSHOT: 'VERSION_SNAPSHOT'>, 'FOR TIMESTAMP': <TokenType.TIMESTAMP_SNAPSHOT: 'TIMESTAMP_SNAPSHOT'>, '~': <TokenType.RLIKE: 'RLIKE'>, '@@': <TokenType.DAT: 'DAT'>, '@>': <TokenType.AT_GT: 'AT_GT'>, '<@': <TokenType.LT_AT: 'LT_AT'>, '|/': <TokenType.PIPE_SLASH: 'PIPE_SLASH'>, '||/': <TokenType.DPIPE_SLASH: 'DPIPE_SLASH'>, 'BEGIN TRANSACTION': <TokenType.BEGIN: 'BEGIN'>, 'BIGSERIAL': <TokenType.BIGSERIAL: 'BIGSERIAL'>, 'CHARACTER VARYING': <TokenType.VARCHAR: 'VARCHAR'>, 'CONSTRAINT TRIGGER': <TokenType.COMMAND: 'COMMAND'>, 'CSTRING': <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, 'DECLARE': <TokenType.COMMAND: 'COMMAND'>, 'DO': <TokenType.COMMAND: 'COMMAND'>, 'EXEC': <TokenType.COMMAND: 'COMMAND'>, 'HSTORE': <TokenType.HSTORE: 'HSTORE'>, 'MONEY': <TokenType.MONEY: 'MONEY'>, 'NAME': <TokenType.NAME: 'NAME'>, 'OID': <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, 'ONLY': <TokenType.ONLY: 'ONLY'>, 'OPERATOR': <TokenType.OPERATOR: 'OPERATOR'>, 'REFRESH': <TokenType.COMMAND: 'COMMAND'>, 'REINDEX': <TokenType.COMMAND: 'COMMAND'>, 'RESET': <TokenType.COMMAND: 'COMMAND'>, 'REVOKE': <TokenType.COMMAND: 'COMMAND'>, 'SERIAL': <TokenType.SERIAL: 'SERIAL'>, 'SMALLSERIAL': <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, 'REGCLASS': <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, 'REGCOLLATION': <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, 'REGCONFIG': <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, 'REGDICTIONARY': <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, 'REGNAMESPACE': <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, 'REGOPER': <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, 'REGOPERATOR': <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, 'REGPROC': <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, 'REGPROCEDURE': <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, 'REGROLE': <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, 'REGTYPE': <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, '(+)': <TokenType.JOIN_MARKER: 'JOIN_MARKER'>, 'HLLSKETCH': <TokenType.HLLSKETCH: 'HLLSKETCH'>, 'MINUS': <TokenType.EXCEPT: 'EXCEPT'>, 'SUPER': <TokenType.SUPER: 'SUPER'>, 'TOP': <TokenType.TOP: 'TOP'>, 'UNLOAD': <TokenType.COMMAND: 'COMMAND'>, 'VARBYTE': <TokenType.VARBINARY: 'VARBINARY'>, 'BINARY VARYING': <TokenType.VARBINARY: 'VARBINARY'>}

SINGLE_TOKENS = {'(': <TokenType.L_PAREN: 'L_PAREN'>, ')': <TokenType.R_PAREN: 'R_PAREN'>, '[': <TokenType.L_BRACKET: 'L_BRACKET'>, ']': <TokenType.R_BRACKET: 'R_BRACKET'>, '{': <TokenType.L_BRACE: 'L_BRACE'>, '}': <TokenType.R_BRACE: 'R_BRACE'>, '&': <TokenType.AMP: 'AMP'>, '^': <TokenType.CARET: 'CARET'>, ':': <TokenType.COLON: 'COLON'>, ',': <TokenType.COMMA: 'COMMA'>, '.': <TokenType.DOT: 'DOT'>, '-': <TokenType.DASH: 'DASH'>, '=': <TokenType.EQ: 'EQ'>, '>': <TokenType.GT: 'GT'>, '<': <TokenType.LT: 'LT'>, '%': <TokenType.MOD: 'MOD'>, '!': <TokenType.NOT: 'NOT'>, '|': <TokenType.PIPE: 'PIPE'>, '+': <TokenType.PLUS: 'PLUS'>, ';': <TokenType.SEMICOLON: 'SEMICOLON'>, '/': <TokenType.SLASH: 'SLASH'>, '\\': <TokenType.BACKSLASH: 'BACKSLASH'>, '*': <TokenType.STAR: 'STAR'>, '~': <TokenType.TILDA: 'TILDA'>, '?': <TokenType.PLACEHOLDER: 'PLACEHOLDER'>, '@': <TokenType.PARAMETER: 'PARAMETER'>, "'": <TokenType.UNKNOWN: 'UNKNOWN'>, '`': <TokenType.UNKNOWN: 'UNKNOWN'>, '"': <TokenType.UNKNOWN: 'UNKNOWN'>, '$': <TokenType.HEREDOC_STRING: 'HEREDOC_STRING'>}

Inherited Members

sqlglot.tokens.Tokenizer: Tokenizer; RAW_STRINGS; UNICODE_STRINGS; IDENTIFIERS; QUOTES; IDENTIFIER_ESCAPES; STRING_ESCAPES_ALLOWED_IN_RAW_STRINGS; NESTED_COMMENTS; HINT_START; TOKENS_PRECEDING_HINT; WHITE_SPACE; COMMANDS; COMMAND_PREFIX_TOKENS; NUMERIC_LITERALS; COMMENTS; dialect; reset; tokenize; tokenize_rs; size; sql; tokens
sqlglot.dialects.postgres.Postgres.Tokenizer: BYTE_STRINGS; HEREDOC_STRINGS; HEREDOC_TAG_IS_IDENTIFIER; HEREDOC_STRING_ALTERNATIVE; VAR_SINGLE_TOKENS