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        ALTER_SET_TYPE = "TYPE"
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.BLOB: "VARBYTE",
170            exp.DataType.Type.INT: "INTEGER",
171            exp.DataType.Type.TIMETZ: "TIME",
172            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
173            exp.DataType.Type.VARBINARY: "VARBYTE",
174            exp.DataType.Type.ROWVERSION: "VARBYTE",
175        }
176
177        TRANSFORMS = {
178            **Postgres.Generator.TRANSFORMS,
179            exp.ArrayConcat: lambda self, e: self.arrayconcat_sql(e, name="ARRAY_CONCAT"),
180            exp.Concat: concat_to_dpipe_sql,
181            exp.ConcatWs: concat_ws_to_dpipe_sql,
182            exp.ApproxDistinct: lambda self,
183            e: f"APPROXIMATE COUNT(DISTINCT {self.sql(e, 'this')})",
184            exp.CurrentTimestamp: lambda self, e: (
185                "SYSDATE" if e.args.get("sysdate") else "GETDATE()"
186            ),
187            exp.DateAdd: date_delta_sql("DATEADD"),
188            exp.DateDiff: date_delta_sql("DATEDIFF"),
189            exp.DistKeyProperty: lambda self, e: self.func("DISTKEY", e.this),
190            exp.DistStyleProperty: lambda self, e: self.naked_property(e),
191            exp.Explode: lambda self, e: self.explode_sql(e),
192            exp.FromBase: rename_func("STRTOL"),
193            exp.GeneratedAsIdentityColumnConstraint: generatedasidentitycolumnconstraint_sql,
194            exp.JSONExtract: json_extract_segments("JSON_EXTRACT_PATH_TEXT"),
195            exp.JSONExtractScalar: json_extract_segments("JSON_EXTRACT_PATH_TEXT"),
196            exp.GroupConcat: rename_func("LISTAGG"),
197            exp.Hex: lambda self, e: self.func("UPPER", self.func("TO_HEX", self.sql(e, "this"))),
198            exp.Select: transforms.preprocess(
199                [
200                    transforms.eliminate_distinct_on,
201                    transforms.eliminate_semi_and_anti_joins,
202                    transforms.unqualify_unnest,
203                    transforms.unnest_generate_date_array_using_recursive_cte,
204                ]
205            ),
206            exp.SortKeyProperty: lambda self,
207            e: f"{'COMPOUND ' if e.args['compound'] else ''}SORTKEY({self.format_args(*e.this)})",
208            exp.StartsWith: lambda self,
209            e: f"{self.sql(e.this)} LIKE {self.sql(e.expression)} || '%'",
210            exp.StringToArray: rename_func("SPLIT_TO_ARRAY"),
211            exp.TableSample: no_tablesample_sql,
212            exp.TsOrDsAdd: date_delta_sql("DATEADD"),
213            exp.TsOrDsDiff: date_delta_sql("DATEDIFF"),
214            exp.UnixToTime: lambda self,
215            e: f"(TIMESTAMP 'epoch' + {self.sql(e.this)} * INTERVAL '1 SECOND')",
216        }
217
218        # Postgres maps exp.Pivot to no_pivot_sql, but Redshift support pivots
219        TRANSFORMS.pop(exp.Pivot)
220
221        # Postgres doesn't support JSON_PARSE, but Redshift does
222        TRANSFORMS.pop(exp.ParseJSON)
223
224        # Redshift supports these functions
225        TRANSFORMS.pop(exp.AnyValue)
226        TRANSFORMS.pop(exp.LastDay)
227        TRANSFORMS.pop(exp.SHA2)
228
229        RESERVED_KEYWORDS = {
230            "aes128",
231            "aes256",
232            "all",
233            "allowoverwrite",
234            "analyse",
235            "analyze",
236            "and",
237            "any",
238            "array",
239            "as",
240            "asc",
241            "authorization",
242            "az64",
243            "backup",
244            "between",
245            "binary",
246            "blanksasnull",
247            "both",
248            "bytedict",
249            "bzip2",
250            "case",
251            "cast",
252            "check",
253            "collate",
254            "column",
255            "constraint",
256            "create",
257            "credentials",
258            "cross",
259            "current_date",
260            "current_time",
261            "current_timestamp",
262            "current_user",
263            "current_user_id",
264            "default",
265            "deferrable",
266            "deflate",
267            "defrag",
268            "delta",
269            "delta32k",
270            "desc",
271            "disable",
272            "distinct",
273            "do",
274            "else",
275            "emptyasnull",
276            "enable",
277            "encode",
278            "encrypt     ",
279            "encryption",
280            "end",
281            "except",
282            "explicit",
283            "false",
284            "for",
285            "foreign",
286            "freeze",
287            "from",
288            "full",
289            "globaldict256",
290            "globaldict64k",
291            "grant",
292            "group",
293            "gzip",
294            "having",
295            "identity",
296            "ignore",
297            "ilike",
298            "in",
299            "initially",
300            "inner",
301            "intersect",
302            "interval",
303            "into",
304            "is",
305            "isnull",
306            "join",
307            "leading",
308            "left",
309            "like",
310            "limit",
311            "localtime",
312            "localtimestamp",
313            "lun",
314            "luns",
315            "lzo",
316            "lzop",
317            "minus",
318            "mostly16",
319            "mostly32",
320            "mostly8",
321            "natural",
322            "new",
323            "not",
324            "notnull",
325            "null",
326            "nulls",
327            "off",
328            "offline",
329            "offset",
330            "oid",
331            "old",
332            "on",
333            "only",
334            "open",
335            "or",
336            "order",
337            "outer",
338            "overlaps",
339            "parallel",
340            "partition",
341            "percent",
342            "permissions",
343            "pivot",
344            "placing",
345            "primary",
346            "raw",
347            "readratio",
348            "recover",
349            "references",
350            "rejectlog",
351            "resort",
352            "respect",
353            "restore",
354            "right",
355            "select",
356            "session_user",
357            "similar",
358            "snapshot",
359            "some",
360            "sysdate",
361            "system",
362            "table",
363            "tag",
364            "tdes",
365            "text255",
366            "text32k",
367            "then",
368            "timestamp",
369            "to",
370            "top",
371            "trailing",
372            "true",
373            "truncatecolumns",
374            "type",
375            "union",
376            "unique",
377            "unnest",
378            "unpivot",
379            "user",
380            "using",
381            "verbose",
382            "wallet",
383            "when",
384            "where",
385            "with",
386            "without",
387        }
388
389        def unnest_sql(self, expression: exp.Unnest) -> str:
390            args = expression.expressions
391            num_args = len(args)
392
393            if num_args != 1:
394                self.unsupported(f"Unsupported number of arguments in UNNEST: {num_args}")
395                return ""
396
397            if isinstance(expression.find_ancestor(exp.From, exp.Join, exp.Select), exp.Select):
398                self.unsupported("Unsupported UNNEST when not used in FROM/JOIN clauses")
399                return ""
400
401            arg = self.sql(seq_get(args, 0))
402
403            alias = self.expressions(expression.args.get("alias"), key="columns", flat=True)
404            return f"{arg} AS {alias}" if alias else arg
405
406        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
407            if expression.is_type(exp.DataType.Type.JSON):
408                # Redshift doesn't support a JSON type, so casting to it is treated as a noop
409                return self.sql(expression, "this")
410
411            return super().cast_sql(expression, safe_prefix=safe_prefix)
412
413        def datatype_sql(self, expression: exp.DataType) -> str:
414            """
415            Redshift converts the `TEXT` data type to `VARCHAR(255)` by default when people more generally mean
416            VARCHAR of max length which is `VARCHAR(max)` in Redshift. Therefore if we get a `TEXT` data type
417            without precision we convert it to `VARCHAR(max)` and if it does have precision then we just convert
418            `TEXT` to `VARCHAR`.
419            """
420            if expression.is_type("text"):
421                expression.set("this", exp.DataType.Type.VARCHAR)
422                precision = expression.args.get("expressions")
423
424                if not precision:
425                    expression.append("expressions", exp.var("MAX"))
426
427            return super().datatype_sql(expression)
428
429        def alterset_sql(self, expression: exp.AlterSet) -> str:
430            exprs = self.expressions(expression, flat=True)
431            exprs = f" TABLE PROPERTIES ({exprs})" if exprs else ""
432            location = self.sql(expression, "location")
433            location = f" LOCATION {location}" if location else ""
434            file_format = self.expressions(expression, key="file_format", flat=True, sep=" ")
435            file_format = f" FILE FORMAT {file_format}" if file_format else ""
436
437            return f"SET{exprs}{location}{file_format}"
438
439        def array_sql(self, expression: exp.Array) -> str:
440            if expression.args.get("bracket_notation"):
441                return super().array_sql(expression)
442
443            return rename_func("ARRAY")(self, expression)
444
445        def explode_sql(self, expression: exp.Explode) -> str:
446            self.unsupported("Unsupported EXPLODE() function")
447            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        ALTER_SET_TYPE = "TYPE"
163
164        # Redshift doesn't have `WITH` as part of their with_properties so we remove it
165        WITH_PROPERTIES_PREFIX = " "
166
167        TYPE_MAPPING = {
168            **Postgres.Generator.TYPE_MAPPING,
169            exp.DataType.Type.BINARY: "VARBYTE",
170            exp.DataType.Type.BLOB: "VARBYTE",
171            exp.DataType.Type.INT: "INTEGER",
172            exp.DataType.Type.TIMETZ: "TIME",
173            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
174            exp.DataType.Type.VARBINARY: "VARBYTE",
175            exp.DataType.Type.ROWVERSION: "VARBYTE",
176        }
177
178        TRANSFORMS = {
179            **Postgres.Generator.TRANSFORMS,
180            exp.ArrayConcat: lambda self, e: self.arrayconcat_sql(e, name="ARRAY_CONCAT"),
181            exp.Concat: concat_to_dpipe_sql,
182            exp.ConcatWs: concat_ws_to_dpipe_sql,
183            exp.ApproxDistinct: lambda self,
184            e: f"APPROXIMATE COUNT(DISTINCT {self.sql(e, 'this')})",
185            exp.CurrentTimestamp: lambda self, e: (
186                "SYSDATE" if e.args.get("sysdate") else "GETDATE()"
187            ),
188            exp.DateAdd: date_delta_sql("DATEADD"),
189            exp.DateDiff: date_delta_sql("DATEDIFF"),
190            exp.DistKeyProperty: lambda self, e: self.func("DISTKEY", e.this),
191            exp.DistStyleProperty: lambda self, e: self.naked_property(e),
192            exp.Explode: lambda self, e: self.explode_sql(e),
193            exp.FromBase: rename_func("STRTOL"),
194            exp.GeneratedAsIdentityColumnConstraint: generatedasidentitycolumnconstraint_sql,
195            exp.JSONExtract: json_extract_segments("JSON_EXTRACT_PATH_TEXT"),
196            exp.JSONExtractScalar: json_extract_segments("JSON_EXTRACT_PATH_TEXT"),
197            exp.GroupConcat: rename_func("LISTAGG"),
198            exp.Hex: lambda self, e: self.func("UPPER", self.func("TO_HEX", self.sql(e, "this"))),
199            exp.Select: transforms.preprocess(
200                [
201                    transforms.eliminate_distinct_on,
202                    transforms.eliminate_semi_and_anti_joins,
203                    transforms.unqualify_unnest,
204                    transforms.unnest_generate_date_array_using_recursive_cte,
205                ]
206            ),
207            exp.SortKeyProperty: lambda self,
208            e: f"{'COMPOUND ' if e.args['compound'] else ''}SORTKEY({self.format_args(*e.this)})",
209            exp.StartsWith: lambda self,
210            e: f"{self.sql(e.this)} LIKE {self.sql(e.expression)} || '%'",
211            exp.StringToArray: rename_func("SPLIT_TO_ARRAY"),
212            exp.TableSample: no_tablesample_sql,
213            exp.TsOrDsAdd: date_delta_sql("DATEADD"),
214            exp.TsOrDsDiff: date_delta_sql("DATEDIFF"),
215            exp.UnixToTime: lambda self,
216            e: f"(TIMESTAMP 'epoch' + {self.sql(e.this)} * INTERVAL '1 SECOND')",
217        }
218
219        # Postgres maps exp.Pivot to no_pivot_sql, but Redshift support pivots
220        TRANSFORMS.pop(exp.Pivot)
221
222        # Postgres doesn't support JSON_PARSE, but Redshift does
223        TRANSFORMS.pop(exp.ParseJSON)
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 ""

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', 'D': '%u', 'dd': '%d', 'DD': '%d', 'ddd': '%j', 'DDD': '%j', 'FMDD': '%-d', 'FMDDD': '%-j', 'FMHH12': '%-I', 'FMHH24': '%-H', 'FMMI': '%-M', 'FMMM': '%-m', 'FMSS': '%-S', 'HH12': '%I', 'HH24': '%H', 'mi': '%M', 'MI': '%M', 'mm': '%m', 'MM': '%m', 'OF': '%z', 'ss': '%S', 'SS': '%S', 'TMDay': '%A', 'TMDy': '%a', 'TMMon': '%b', 'TMMonth': '%B', 'TZ': '%Z', 'US': '%f', 'ww': '%U', 'WW': '%U', 'yy': '%y', 'YY': '%y', 'yyyy': '%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}}}, '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}}, 'M': {'I': {0: True}, 'M': {0: True}, 'O': {'N': {0: True}}}, 'O': {'F': {0: True}}, 's': {'s': {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}}, 'W': {'W': {0: True}}, 'y': {'y': {0: True, 'y': {'y': {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}}}, '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}}, 'M': {'I': {0: True}, 'M': {0: True}, 'O': {'N': {0: True}}}, 'O': {'F': {0: True}}, 's': {'s': {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}}, 'W': {'W': {0: True}}, 'y': {'y': {0: True, 'y': {'y': {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.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>>, 'AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.And'>>, '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_SCHEMA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentSchema'>>, '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>, 'DATE_BIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateBin'>>, '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_ASCII': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsAscii'>>, '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_B_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBObjectAgg'>>, 'J_S_O_N_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONCast'>>, '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': <function Postgres.Parser.<lambda>>, 'LEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'CHAR_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'CHARACTER_LENGTH': <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'>>, 'OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Or'>>, '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'>>, 'UNICODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Unicode'>>, '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'>>, 'XMLELEMENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.XMLElement'>>, '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>>, '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>>, 'STRPOS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrPosition'>>, 'CHARINDEX': <function Parser.<lambda>>, 'INSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrPosition'>>, 'LOCATE': <function Parser.<lambda>>, 'TO_HEX': <function build_hex>, 'ASCII': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Unicode'>>, '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>, 'JSON_OBJECT_AGG': <function Postgres.Parser.<lambda>>, 'JSONB_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBObjectAgg'>>, '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>>, 'APPROXIMATE': <function Redshift.Parser.<lambda>>, 'SYSDATE': <function Redshift.Parser.<lambda>>}

SUPPORTS_IMPLICIT_UNNEST = True

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

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

SHOW_TRIE: Dict = {}

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

Inherited Members

sqlglot.parser.Parser: Parser; 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; ALIAS_TOKENS; COLON_PLACEHOLDER_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; ANALYZE_STYLES; ANALYZE_EXPRESSION_PARSERS; PARTITION_KEYWORDS; AMBIGUOUS_ALIAS_TOKENS; OPERATION_MODIFIERS; RECURSIVE_CTE_SEARCH_KIND; MODIFIABLES; 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; OPTIONAL_ALIAS_TOKEN_CTE; error_level; error_message_context; max_errors; dialect; reset; parse; parse_into; check_errors; raise_error; expression; validate_expression; parse_set_operation; errors; sql
sqlglot.dialects.postgres.Postgres.Parser: PROPERTY_PARSERS; NO_PAREN_FUNCTIONS; 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_SCHEMA': <TokenType.CURRENT_SCHEMA: 'CURRENT_SCHEMA'>, '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'>, 'NAMESPACE': <TokenType.NAMESPACE: 'NAMESPACE'>, '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'>, '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'>, 'INT128': <TokenType.INT128: 'INT128'>, 'INT256': <TokenType.INT256: 'INT256'>, 'LONG': <TokenType.BIGINT: 'BIGINT'>, 'BIGINT': <TokenType.BIGINT: 'BIGINT'>, 'INT8': <TokenType.BIGINT: 'BIGINT'>, 'UINT': <TokenType.UINT: 'UINT'>, 'UINT128': <TokenType.UINT128: 'UINT128'>, 'UINT256': <TokenType.UINT256: 'UINT256'>, '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.ANALYZE: 'ANALYZE'>, '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; use_rs_tokenizer; 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