Edit on GitHub

sqlglot.parsers.tsql

View Source

  1from __future__ import annotations
  2
  3import datetime
  4import re
  5import typing as t
  6
  7from sqlglot import exp, parser
  8from sqlglot.dialects.dialect import (
  9    Dialect,
 10    build_date_delta,
 11    map_date_part,
 12)
 13from sqlglot.helper import seq_get
 14from sqlglot.parser import build_coalesce
 15from sqlglot.time import format_time
 16from sqlglot.tokens import TokenType
 17
 18if t.TYPE_CHECKING:
 19    from sqlglot._typing import E
 20    from collections.abc import Collection
 21
 22FULL_FORMAT_TIME_MAPPING = {
 23    "weekday": "%A",
 24    "dw": "%A",
 25    "w": "%A",
 26    "month": "%B",
 27    "mm": "%B",
 28    "m": "%B",
 29}
 30
 31DATE_DELTA_INTERVAL = {
 32    "year": "year",
 33    "yyyy": "year",
 34    "yy": "year",
 35    "quarter": "quarter",
 36    "qq": "quarter",
 37    "q": "quarter",
 38    "month": "month",
 39    "mm": "month",
 40    "m": "month",
 41    "week": "week",
 42    "ww": "week",
 43    "wk": "week",
 44    "day": "day",
 45    "dd": "day",
 46    "d": "day",
 47}
 48
 49DATE_FMT_RE = re.compile("([dD]{1,2})|([mM]{1,2})|([yY]{1,4})|([hH]{1,2})|([sS]{1,2})|([fF]{2,7})")
 50
 51# N = Numeric, C=Currency
 52TRANSPILE_SAFE_NUMBER_FMT = {"N", "C"}
 53
 54DEFAULT_START_DATE = datetime.date(1900, 1, 1)
 55
 56# Unsupported options:
 57# - OPTIMIZE FOR ( @variable_name { UNKNOWN | = <literal_constant> } [ , ...n ] )
 58# - TABLE HINT
 59OPTIONS: parser.OPTIONS_TYPE = {
 60    **dict.fromkeys(
 61        (
 62            "DISABLE_OPTIMIZED_PLAN_FORCING",
 63            "FAST",
 64            "IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX",
 65            "LABEL",
 66            "MAXDOP",
 67            "MAXRECURSION",
 68            "MAX_GRANT_PERCENT",
 69            "MIN_GRANT_PERCENT",
 70            "NO_PERFORMANCE_SPOOL",
 71            "QUERYTRACEON",
 72            "RECOMPILE",
 73        ),
 74        tuple(),
 75    ),
 76    "CONCAT": ("UNION",),
 77    "DISABLE": ("EXTERNALPUSHDOWN", "SCALEOUTEXECUTION"),
 78    "EXPAND": ("VIEWS",),
 79    "FORCE": ("EXTERNALPUSHDOWN", "ORDER", "SCALEOUTEXECUTION"),
 80    "HASH": ("GROUP", "JOIN", "UNION"),
 81    "KEEP": ("PLAN",),
 82    "KEEPFIXED": ("PLAN",),
 83    "LOOP": ("JOIN",),
 84    "MERGE": ("JOIN", "UNION"),
 85    "OPTIMIZE": (("FOR", "UNKNOWN"),),
 86    "ORDER": ("GROUP",),
 87    "PARAMETERIZATION": ("FORCED", "SIMPLE"),
 88    "ROBUST": ("PLAN",),
 89    "USE": ("PLAN",),
 90}
 91
 92
 93FOR_XML_OPTIONS: parser.OPTIONS_TYPE = {
 94    **dict.fromkeys(
 95        (
 96            "AUTO",
 97            "EXPLICIT",
 98            "TYPE",
 99        ),
100        tuple(),
101    ),
102    "ELEMENTS": (
103        "XSINIL",
104        "ABSENT",
105    ),
106    "BINARY": ("BASE64",),
107}
108
109
110# FOR JSON { AUTO | PATH } [, ROOT [ ( 'name' ) ] ] [, INCLUDE_NULL_VALUES ]
111#                          [, WITHOUT_ARRAY_WRAPPER ]
112# https://learn.microsoft.com/en-us/sql/relational-databases/json/format-query-results-as-json-with-for-json-sql-server
113FOR_JSON_OPTIONS: parser.OPTIONS_TYPE = dict.fromkeys(
114    (
115        "AUTO",
116        "PATH",
117        "INCLUDE_NULL_VALUES",
118        "WITHOUT_ARRAY_WRAPPER",
119    ),
120    tuple(),
121)
122
123
124OPTIONS_THAT_REQUIRE_EQUAL = ("MAX_GRANT_PERCENT", "MIN_GRANT_PERCENT", "LABEL")
125
126
127def _build_formatted_time(
128    exp_class: type[E], full_format_mapping: bool | None = None
129) -> t.Callable[[list], E]:
130    def _builder(args: list) -> E:
131        fmt = seq_get(args, 0)
132        if isinstance(fmt, exp.Expr):
133            from sqlglot.dialects.tsql import TSQL
134
135            fmt = exp.Literal.string(
136                format_time(
137                    fmt.name.lower(),
138                    (
139                        {**TSQL.TIME_MAPPING, **FULL_FORMAT_TIME_MAPPING}
140                        if full_format_mapping
141                        else TSQL.TIME_MAPPING
142                    ),
143                )
144            )
145
146        this = seq_get(args, 1)
147        if isinstance(this, exp.Expr):
148            this = exp.cast(this, exp.DType.DATETIME2)
149
150        return exp_class(this=this, format=fmt)
151
152    return _builder
153
154
155def _build_format(args: list) -> exp.NumberToStr | exp.TimeToStr:
156    this = seq_get(args, 0)
157    fmt = seq_get(args, 1)
158    culture = seq_get(args, 2)
159
160    number_fmt = fmt and (fmt.name in TRANSPILE_SAFE_NUMBER_FMT or not DATE_FMT_RE.search(fmt.name))
161
162    if number_fmt:
163        return exp.NumberToStr(this=this, format=fmt, culture=culture)
164
165    if fmt:
166        from sqlglot.dialects.tsql import TSQL
167
168        fmt = exp.Literal.string(
169            format_time(fmt.name, TSQL.FORMAT_TIME_MAPPING)
170            if len(fmt.name) == 1
171            else format_time(fmt.name, TSQL.TIME_MAPPING)
172        )
173
174    return exp.TimeToStr(this=this, format=fmt, culture=culture)
175
176
177def _build_eomonth(args: list) -> exp.LastDay:
178    date = exp.TsOrDsToDate(this=seq_get(args, 0))
179    month_lag = seq_get(args, 1)
180
181    if month_lag is None:
182        this: exp.Expr = date
183    else:
184        unit = DATE_DELTA_INTERVAL.get("month")
185        this = exp.DateAdd(this=date, expression=month_lag, unit=unit and exp.var(unit))
186
187    return exp.LastDay(this=this)
188
189
190def _build_hashbytes(args: list) -> exp.Expr:
191    kind, data = args
192    kind = kind.name.upper() if kind.is_string else ""
193
194    if kind == "MD5":
195        args.pop(0)
196        return exp.MD5(this=data)
197    if kind in ("SHA", "SHA1"):
198        args.pop(0)
199        return exp.SHA(this=data)
200    if kind == "SHA2_256":
201        return exp.SHA2(this=data, length=exp.Literal.number(256))
202    if kind == "SHA2_512":
203        return exp.SHA2(this=data, length=exp.Literal.number(512))
204
205    return exp.func("HASHBYTES", *args)
206
207
208def _build_date_delta(
209    exp_class: type[E], unit_mapping: dict[str, str] | None = None, big_int: bool = False
210) -> t.Callable[[list], E]:
211    def _builder(args: list) -> E:
212        unit = seq_get(args, 0)
213        if unit and unit_mapping:
214            unit = exp.var(unit_mapping.get(unit.name.lower(), unit.name))
215
216        start_date = seq_get(args, 1)
217        if start_date and start_date.is_number:
218            # Numeric types are valid DATETIME values
219            if start_date.is_int:
220                adds = DEFAULT_START_DATE + datetime.timedelta(days=start_date.to_py())
221                start_date = exp.Literal.string(adds.strftime("%F"))
222            else:
223                # We currently don't handle float values, i.e. they're not converted to equivalent DATETIMEs.
224                # This is not a problem when generating T-SQL code, it is when transpiling to other dialects.
225                return exp_class(
226                    this=seq_get(args, 2), expression=start_date, unit=unit, big_int=big_int
227                )
228
229        return exp_class(
230            this=exp.TimeStrToTime(this=seq_get(args, 2)),
231            expression=exp.TimeStrToTime(this=start_date),
232            unit=unit,
233            big_int=big_int,
234        )
235
236    return _builder
237
238
239# https://learn.microsoft.com/en-us/sql/t-sql/functions/datetimefromparts-transact-sql?view=sql-server-ver16#syntax
240def _build_datetimefromparts(args: list) -> exp.TimestampFromParts:
241    return exp.TimestampFromParts(
242        year=seq_get(args, 0),
243        month=seq_get(args, 1),
244        day=seq_get(args, 2),
245        hour=seq_get(args, 3),
246        min=seq_get(args, 4),
247        sec=seq_get(args, 5),
248        milli=seq_get(args, 6),
249    )
250
251
252# https://learn.microsoft.com/en-us/sql/t-sql/functions/timefromparts-transact-sql?view=sql-server-ver16#syntax
253def _build_timefromparts(args: list) -> exp.TimeFromParts:
254    return exp.TimeFromParts(
255        hour=seq_get(args, 0),
256        min=seq_get(args, 1),
257        sec=seq_get(args, 2),
258        fractions=seq_get(args, 3),
259        precision=seq_get(args, 4),
260    )
261
262
263def _build_with_arg_as_text(
264    klass: type[exp.Expr],
265) -> t.Callable[[list[exp.Expr]], exp.Expr]:
266    def _parse(args: list[exp.Expr]) -> exp.Expr:
267        this = seq_get(args, 0)
268
269        if this and not this.is_string:
270            this = exp.cast(this, exp.DType.TEXT)
271
272        expression = seq_get(args, 1)
273        kwargs = {"this": this}
274
275        if expression:
276            kwargs["expression"] = expression
277
278        return klass(**kwargs)
279
280    return _parse
281
282
283# https://learn.microsoft.com/en-us/sql/t-sql/functions/parsename-transact-sql?view=sql-server-ver16
284def _build_parsename(args: list) -> exp.SplitPart | exp.Anonymous:
285    # PARSENAME(...) will be stored into exp.SplitPart if:
286    # - All args are literals
287    # - The part index (2nd arg) is <= 4 (max valid value, otherwise TSQL returns NULL)
288    if len(args) == 2 and all(isinstance(arg, exp.Literal) for arg in args):
289        this = args[0]
290        part_index = args[1]
291        split_count = len(this.name.split("."))
292        if split_count <= 4:
293            return exp.SplitPart(
294                this=this,
295                delimiter=exp.Literal.string("."),
296                part_index=exp.Literal.number(split_count + 1 - part_index.to_py()),
297            )
298
299    return exp.Anonymous(this="PARSENAME", expressions=args)
300
301
302def _build_json_query(args: list, dialect: Dialect) -> exp.JSONExtract:
303    if len(args) == 1:
304        # The default value for path is '$'. As a result, if you don't provide a
305        # value for path, JSON_QUERY returns the input expression.
306        args.append(exp.Literal.string("$"))
307
308    json_extract = parser.build_extract_json_with_path(exp.JSONExtract)(args, dialect)
309    json_extract.set("json_query", True)
310    return json_extract
311
312
313def _build_datetrunc(args: list) -> exp.TimestampTrunc:
314    unit = seq_get(args, 0)
315    this = seq_get(args, 1)
316
317    if this and this.is_string:
318        this = exp.cast(this, exp.DType.DATETIME2)
319
320    return exp.TimestampTrunc(this=this, unit=unit)
321
322
323class TSQLParser(parser.Parser):
324    BARE_TABLE_HINTS = {
325        "NOLOCK",
326        "READUNCOMMITTED",
327        "UPDLOCK",
328        "REPEATABLEREAD",
329        "SERIALIZABLE",
330        "READCOMMITTED",
331        "TABLOCK",
332        "TABLOCKX",
333        "PAGLOCK",
334        "ROWLOCK",
335        "NOWAIT",
336        "READPAST",
337        "XLOCK",
338        "SNAPSHOT",
339        "NOEXPAND",
340    }
341
342    SET_REQUIRES_ASSIGNMENT_DELIMITER = False
343    LOG_DEFAULTS_TO_LN = True
344    STRING_ALIASES = True
345    NO_PAREN_IF_COMMANDS = False
346    UNPIVOT_VALUE_COLUMNS_FIRST = True
347
348    NO_PAREN_FUNCTIONS = {
349        **parser.Parser.NO_PAREN_FUNCTIONS,
350        TokenType.SESSION_USER: exp.SessionUser,
351    }
352
353    QUERY_MODIFIER_PARSERS = {
354        **parser.Parser.QUERY_MODIFIER_PARSERS,
355        TokenType.OPTION: lambda self: ("options", self._parse_options()),
356        TokenType.FOR: lambda self: ("for_", self._parse_for()),
357    }
358
359    # T-SQL does not allow BEGIN to be used as an identifier
360    ID_VAR_TOKENS = (parser.Parser.ID_VAR_TOKENS | {TokenType.RETURNING}) - {TokenType.BEGIN}
361    ALIAS_TOKENS = (parser.Parser.ALIAS_TOKENS | {TokenType.RETURNING}) - {TokenType.BEGIN}
362    TABLE_ALIAS_TOKENS = (parser.Parser.TABLE_ALIAS_TOKENS | {TokenType.ANTI, TokenType.SEMI}) - {
363        TokenType.BEGIN
364    }
365    COMMENT_TABLE_ALIAS_TOKENS = parser.Parser.COMMENT_TABLE_ALIAS_TOKENS - {TokenType.BEGIN}
366    UPDATE_ALIAS_TOKENS = parser.Parser.UPDATE_ALIAS_TOKENS - {TokenType.BEGIN}
367
368    FUNCTIONS = {
369        **parser.Parser.FUNCTIONS,
370        "ATN2": exp.Atan2.from_arg_list,
371        "CHARINDEX": lambda args: exp.StrPosition(
372            this=seq_get(args, 1),
373            substr=seq_get(args, 0),
374            position=seq_get(args, 2),
375        ),
376        "COUNT": lambda args: exp.Count(this=seq_get(args, 0), expressions=args[1:], big_int=False),
377        "COUNT_BIG": lambda args: exp.Count(
378            this=seq_get(args, 0), expressions=args[1:], big_int=True
379        ),
380        "DATEADD": build_date_delta(exp.DateAdd, unit_mapping=DATE_DELTA_INTERVAL),
381        "DATEDIFF": _build_date_delta(exp.DateDiff, unit_mapping=DATE_DELTA_INTERVAL),
382        "DATEDIFF_BIG": _build_date_delta(
383            exp.DateDiff, unit_mapping=DATE_DELTA_INTERVAL, big_int=True
384        ),
385        "DATENAME": _build_formatted_time(exp.TimeToStr, full_format_mapping=True),
386        "DATETIMEFROMPARTS": _build_datetimefromparts,
387        "DAY": lambda args: exp.Day(
388            this=exp.TsOrDsToDate(
389                this=seq_get(args, 0), default_date=exp.Literal.string("1900-01-01")
390            )
391        ),
392        "EOMONTH": _build_eomonth,
393        "FORMAT": _build_format,
394        "GETDATE": exp.CurrentTimestamp.from_arg_list,
395        "HASHBYTES": _build_hashbytes,
396        "ISNULL": lambda args: build_coalesce(args=args, is_null=True),
397        "JSON_QUERY": _build_json_query,
398        "JSON_VALUE": parser.build_extract_json_with_path(exp.JSONExtractScalar),
399        "LEN": _build_with_arg_as_text(exp.Length),
400        "LEFT": _build_with_arg_as_text(exp.Left),
401        "MONTH": lambda args: exp.Month(
402            this=exp.TsOrDsToDate(
403                this=seq_get(args, 0), default_date=exp.Literal.string("1900-01-01")
404            )
405        ),
406        "NEWID": exp.Uuid.from_arg_list,
407        "RIGHT": _build_with_arg_as_text(exp.Right),
408        "PARSENAME": _build_parsename,
409        "REPLICATE": exp.Repeat.from_arg_list,
410        "SCHEMA_NAME": exp.CurrentSchema.from_arg_list,
411        "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),
412        "SYSDATETIME": exp.CurrentTimestamp.from_arg_list,
413        "SUSER_NAME": exp.CurrentUser.from_arg_list,
414        "SUSER_SNAME": exp.CurrentUser.from_arg_list,
415        "SYSDATETIMEOFFSET": exp.CurrentTimestampLTZ.from_arg_list,
416        "SYSTEM_USER": exp.CurrentUser.from_arg_list,
417        "TIMEFROMPARTS": _build_timefromparts,
418        "DATETRUNC": _build_datetrunc,
419        "YEAR": lambda args: exp.Year(
420            this=exp.TsOrDsToDate(
421                this=seq_get(args, 0), default_date=exp.Literal.string("1900-01-01")
422            )
423        ),
424    }
425
426    JOIN_HINTS = {"LOOP", "HASH", "MERGE", "REMOTE"}
427
428    PROCEDURE_OPTIONS = dict.fromkeys(
429        ("ENCRYPTION", "RECOMPILE", "SCHEMABINDING", "NATIVE_COMPILATION", "EXECUTE"), tuple()
430    )
431
432    COLUMN_DEFINITION_MODES: t.ClassVar = {"OUT", "OUTPUT", "READONLY"}
433
434    RETURNS_TABLE_TOKENS: t.ClassVar = parser.Parser.ID_VAR_TOKENS - {
435        TokenType.TABLE,
436        *parser.Parser.TYPE_TOKENS,
437    }
438
439    STATEMENT_PARSERS = {
440        **parser.Parser.STATEMENT_PARSERS,
441        TokenType.EXECUTE: lambda self: self._parse_execute(),
442    }
443
444    RANGE_PARSERS = {
445        **parser.Parser.RANGE_PARSERS,
446        TokenType.DCOLON: lambda self, this: self.expression(
447            exp.ScopeResolution(
448                this=this, expression=self._parse_function() or self._parse_var(any_token=True)
449            )
450        ),
451    }
452
453    NO_PAREN_FUNCTION_PARSERS = {
454        **parser.Parser.NO_PAREN_FUNCTION_PARSERS,
455        "NEXT": lambda self: self._parse_next_value_for(),
456    }
457
458    FUNCTION_PARSERS = {
459        **parser.Parser.FUNCTION_PARSERS,
460        "JSON_ARRAYAGG": lambda self: self.expression(
461            exp.JSONArrayAgg(
462                this=self._parse_bitwise(),
463                order=self._parse_order(),
464                null_handling=self._parse_on_handling("NULL", "NULL", "ABSENT"),
465            )
466        ),
467        "DATEPART": lambda self: self._parse_datepart(),
468    }
469
470    # The DCOLON (::) operator serves as a scope resolution (exp.ScopeResolution) operator in T-SQL
471    COLUMN_OPERATORS = {
472        **parser.Parser.COLUMN_OPERATORS,
473        TokenType.DCOLON: lambda self, this, to: (
474            self.expression(exp.Cast(this=this, to=to))
475            if isinstance(to, exp.DataType) and to.this != exp.DType.USERDEFINED
476            else self.expression(exp.ScopeResolution(this=this, expression=to))
477        ),
478    }
479
480    SET_OP_MODIFIERS = {"order", "limit", "offset", "options", "for_"}
481
482    ODBC_DATETIME_LITERALS = {
483        "d": exp.Date,
484        "t": exp.Time,
485        "ts": exp.Timestamp,
486    }
487
488    def _parse_execute(self) -> exp.Execute:
489        return_status = None
490        index = self._index
491        if self._match(TokenType.PARAMETER):
492            param = self._parse_parameter()
493            if self._match(TokenType.EQ):
494                return_status = param
495            else:
496                self._retreat(index)
497
498        execute = self.expression(
499            exp.Execute(
500                this=self._parse_table(schema=True),
501                expressions=self._parse_csv(self._parse_expression),
502                return_status=return_status,
503            )
504        )
505
506        if execute.name.lower() == "sp_executesql":
507            execute = self.expression(exp.ExecuteSql(**execute.args))
508
509        return execute
510
511    def _parse_datepart(self) -> exp.Extract:
512        this = self._parse_var(tokens=[TokenType.IDENTIFIER])
513        expression = self._match(TokenType.COMMA) and self._parse_bitwise()
514        name = map_date_part(this, self.dialect)
515
516        return self.expression(exp.Extract(this=name, expression=expression))
517
518    def _parse_alter_table_set(self) -> exp.AlterSet:
519        return self._parse_wrapped(super()._parse_alter_table_set)
520
521    def _parse_wrapped_select(self, table: bool = False) -> exp.Expr | None:
522        if self._match(TokenType.MERGE):
523            comments = self._prev_comments
524            merge = self._parse_merge()
525            merge.add_comments(comments, prepend=True)
526            return merge
527
528        return super()._parse_wrapped_select(table=table)
529
530    def _parse_dcolon(self) -> exp.Expr | None:
531        # We want to use _parse_types() if the first token after :: is a known type,
532        # otherwise we could parse something like x::varchar(max) into a function
533        if self._match_set(self.TYPE_TOKENS, advance=False):
534            return self._parse_types()
535
536        return self._parse_function() or self._parse_types()
537
538    def _parse_options(self) -> list[exp.Expr] | None:
539        if not self._match(TokenType.OPTION):
540            return None
541
542        def _parse_option() -> exp.Expr | None:
543            option = self._parse_var_from_options(OPTIONS)
544            if not option:
545                return None
546
547            self._match(TokenType.EQ)
548            return self.expression(
549                exp.QueryOption(this=option, expression=self._parse_primary_or_var())
550            )
551
552        return self._parse_wrapped_csv(_parse_option)
553
554    def _parse_key_value_option(self) -> exp.XMLKeyValueOption:
555        this = self._parse_primary_or_var()
556        if self._match(TokenType.L_PAREN, advance=False):
557            expression = self._parse_wrapped(self._parse_string)
558        else:
559            expression = None
560
561        return exp.XMLKeyValueOption(this=this, expression=expression)
562
563    def _parse_for_clause_option(self, options: parser.OPTIONS_TYPE) -> exp.Expr | None:
564        return self.expression(
565            exp.QueryOption(
566                this=self._parse_var_from_options(options, raise_unmatched=False)
567                or self._parse_key_value_option()
568            )
569        )
570
571    def _parse_for(self) -> exp.ForClause | None:
572        if self._match_pair(TokenType.FOR, TokenType.XML):
573            return self.expression(
574                exp.ForClause(
575                    kind="XML",
576                    expressions=self._parse_csv(
577                        lambda: self._parse_for_clause_option(FOR_XML_OPTIONS)
578                    ),
579                )
580            )
581
582        if self._match_pair(TokenType.FOR, TokenType.JSON):
583            return self.expression(
584                exp.ForClause(
585                    kind="JSON",
586                    expressions=self._parse_csv(
587                        lambda: self._parse_for_clause_option(FOR_JSON_OPTIONS)
588                    ),
589                )
590            )
591
592        # FOR BROWSE — bare keyword, no options. BROWSE has no dedicated TokenType.
593        if self._match_text_seq("FOR", "BROWSE"):
594            return self.expression(exp.ForClause(kind="BROWSE"))
595
596        return None
597
598    def _parse_projections(
599        self,
600    ) -> tuple[list[exp.Expr], list[exp.Expr] | None]:
601        """
602        T-SQL supports the syntax alias = expression in the SELECT's projection list,
603        so we transform all parsed Selects to convert their EQ projections into Aliases.
604
605        See: https://learn.microsoft.com/en-us/sql/t-sql/queries/select-clause-transact-sql?view=sql-server-ver16#syntax
606        """
607        projections, _ = super()._parse_projections()
608        return [
609            (
610                exp.alias_(projection.expression, projection.this.this, copy=False)
611                if isinstance(projection, exp.EQ) and isinstance(projection.this, exp.Column)
612                else projection
613            )
614            for projection in projections
615        ], None
616
617    def _parse_commit_or_rollback(self) -> exp.Commit | exp.Rollback:
618        """Applies to SQL Server and Azure SQL Database
619        COMMIT [ { TRAN | TRANSACTION }
620            [ transaction_name | @tran_name_variable ] ]
621            [ WITH ( DELAYED_DURABILITY = { OFF | ON } ) ]
622
623        ROLLBACK { TRAN | TRANSACTION }
624            [ transaction_name | @tran_name_variable
625            | savepoint_name | @savepoint_variable ]
626        """
627        rollback = self._prev.token_type == TokenType.ROLLBACK
628
629        self._match_texts(("TRAN", "TRANSACTION"))
630        this = self._parse_id_var()
631
632        if rollback:
633            return self.expression(exp.Rollback(this=this))
634
635        durability = None
636        if self._match_pair(TokenType.WITH, TokenType.L_PAREN):
637            self._match_text_seq("DELAYED_DURABILITY")
638            self._match(TokenType.EQ)
639
640            if self._match_text_seq("OFF"):
641                durability = False
642            else:
643                self._match(TokenType.ON)
644                durability = True
645
646            self._match_r_paren()
647
648        return self.expression(exp.Commit(this=this, durability=durability))
649
650    def _parse_transaction(self) -> exp.Transaction | exp.Command:
651        """Applies to SQL Server and Azure SQL Database
652        BEGIN { TRAN | TRANSACTION }
653        [ { transaction_name | @tran_name_variable }
654        [ WITH MARK [ 'description' ] ]
655        ]
656        """
657        if self._match_texts(("TRAN", "TRANSACTION")):
658            transaction = self.expression(exp.Transaction(this=self._parse_id_var()))
659            if self._match_text_seq("WITH", "MARK"):
660                transaction.set("mark", self._parse_string())
661
662            return transaction
663
664        return self._parse_as_command(self._prev)
665
666    def _parse_returns(self) -> exp.ReturnsProperty:
667        table = self._parse_id_var(any_token=False, tokens=self.RETURNS_TABLE_TOKENS)
668        returns = super()._parse_returns()
669        returns.set("table", table)
670        return returns
671
672    def _parse_convert(self, strict: bool, safe: bool | None = None) -> exp.Expr | None:
673        this = self._parse_types()
674        self._match(TokenType.COMMA)
675        args = [this, *self._parse_csv(self._parse_assignment)]
676        convert = exp.Convert.from_arg_list(args)
677        convert.set("safe", safe)
678        return convert
679
680    def _parse_column_def(
681        self, this: exp.Expr | None, computed_column: bool = True
682    ) -> exp.Expr | None:
683        this = super()._parse_column_def(this=this, computed_column=computed_column)
684        if not this:
685            return None
686        if self._match(TokenType.EQ):
687            this.set("default", self._parse_disjunction())
688        if self._match_texts(self.COLUMN_DEFINITION_MODES):
689            this.set("output", self._prev.text)
690        return this
691
692    def _parse_user_defined_function(self, kind: TokenType | None = None) -> exp.Expr | None:
693        this = super()._parse_user_defined_function(kind=kind)
694
695        if kind == TokenType.FUNCTION or isinstance(this, exp.UserDefinedFunction):
696            return this
697
698        if kind == TokenType.PROCEDURE and this:
699            expressions = this.expressions
700            if not (
701                expressions or self._match_set((TokenType.ALIAS, TokenType.WITH), advance=False)
702            ):
703                expressions = self._parse_csv(self._parse_function_parameter)
704
705            return self.expression(
706                exp.StoredProcedure(
707                    this=this if isinstance(this, exp.Table) else this.this,
708                    expressions=expressions,
709                    wrapped=this.args.get("wrapped"),
710                )
711            )
712
713        return self.expression(exp.UserDefinedFunction(this=this))
714
715    def _parse_into(self) -> exp.Into | None:
716        into = super()._parse_into()
717
718        table = isinstance(into, exp.Into) and into.find(exp.Table)
719        if isinstance(table, exp.Table):
720            table_identifier = table.this
721            if table_identifier.args.get("temporary"):
722                # Promote the temporary property from the Identifier to the Into expression
723                t.cast(exp.Into, into).set("temporary", True)
724
725        return into
726
727    def _parse_id_var(
728        self,
729        any_token: bool = True,
730        tokens: Collection[TokenType] | None = None,
731    ) -> exp.Expr | None:
732        is_temporary = self._match(TokenType.HASH)
733        is_global = is_temporary and self._match(TokenType.HASH)
734
735        this = super()._parse_id_var(any_token=any_token, tokens=tokens)
736        if this:
737            if is_global:
738                this.set("global_", True)
739            elif is_temporary:
740                this.set("temporary", True)
741
742        return this
743
744    def _parse_table_part(self, schema: bool = False) -> exp.Expr | None:
745        # Schema mode already skips function parsing; otherwise, '(' may start a bare table hint.
746        if not schema and self._next.token_type == TokenType.L_PAREN:
747            index = self._index
748            self._advance(2)
749            is_hint = self._match_texts(self.BARE_TABLE_HINTS) and self._match(TokenType.R_PAREN)
750            self._retreat(index)
751
752            if is_hint and (this := self._parse_id_var(any_token=False)):
753                return this
754
755        return super()._parse_table_part(schema=schema)
756
757    def _parse_table(
758        self,
759        schema: bool = False,
760        joins: bool = False,
761        alias_tokens: Collection[TokenType] | None = None,
762        parse_bracket: bool = False,
763        is_db_reference: bool = False,
764        parse_partition: bool = False,
765        consume_pipe: bool = False,
766    ) -> exp.Expr | None:
767        table = super()._parse_table(
768            schema=schema,
769            joins=joins,
770            alias_tokens=alias_tokens,
771            parse_bracket=parse_bracket,
772            is_db_reference=is_db_reference,
773            parse_partition=parse_partition,
774            consume_pipe=consume_pipe,
775        )
776        if (
777            isinstance(table, exp.Table)
778            and not table.args.get("hints")
779            and (alias := table.args.get("alias"))
780            and len(alias.columns) == 1
781            and isinstance(hint := alias.columns[0], exp.Identifier)
782            and not hint.quoted
783            and hint.name.upper() in self.BARE_TABLE_HINTS
784            and all(isinstance(part, exp.Identifier) for part in table.parts)
785        ):
786            var = exp.var(hint.name)
787            var.add_comments(hint.pop_comments())
788            alias.set("columns", None)
789            if not alias.this:
790                table.add_comments(alias.pop_comments())
791                table.set("alias", self._parse_table_alias(alias_tokens=alias_tokens))
792            table.set("hints", [exp.WithTableHint(expressions=[var])])
793
794        return table
795
796    def _parse_table_parts(
797        self,
798        schema: bool = False,
799        is_db_reference: bool = False,
800        wildcard: bool = False,
801        fast: bool = False,
802    ) -> exp.Table | exp.Dot | None:
803        table = super()._parse_table_parts(
804            schema=schema,
805            is_db_reference=is_db_reference,
806            wildcard=wildcard,
807            fast=fast,
808        )
809        if (
810            isinstance(table, exp.Table)
811            and isinstance(table.this, exp.Identifier)
812            and (table_name := table.name).startswith("#")
813        ):
814            if table_name.startswith("##"):
815                table.this.set("this", table_name[2:])
816                table.this.set("global_", True)
817            else:
818                table.this.set("this", table_name[1:])
819                table.this.set("temporary", True)
820
821        return table
822
823    def _parse_create(self) -> exp.Create | exp.Command:
824        create = super()._parse_create()
825
826        if isinstance(create, exp.Create):
827            table = create.this.this if isinstance(create.this, exp.Schema) else create.this
828            if isinstance(table, exp.Table) and table.this and table.this.args.get("temporary"):
829                if not create.args.get("properties"):
830                    create.set("properties", exp.Properties(expressions=[]))
831
832                create.args["properties"].append("expressions", exp.TemporaryProperty())
833
834        return create
835
836    def _parse_if(self) -> exp.Expr | None:
837        this = self._parse_condition()
838        true = self._parse_block()
839
840        false = self._match(TokenType.ELSE) and self._parse_block()
841
842        return self.expression(exp.IfBlock(this=this, true=true, false=false))
843
844    def _parse_unique(self) -> exp.UniqueColumnConstraint:
845        if self._match_texts(("CLUSTERED", "NONCLUSTERED")):
846            this = self.CONSTRAINT_PARSERS[self._prev.text.upper()](self)
847        else:
848            this = self._parse_schema(self._parse_id_var(any_token=False))
849
850        return self.expression(exp.UniqueColumnConstraint(this=this))
851
852    def _parse_update(self) -> exp.Update:
853        expression = super()._parse_update()
854        expression.set("options", self._parse_options())
855        return expression
856
857    def _parse_partition(self) -> exp.Partition | None:
858        if not self._match_text_seq("WITH", "(", "PARTITIONS"):
859            return None
860
861        def parse_range():
862            low = self._parse_bitwise()
863            high = self._parse_bitwise() if self._match_text_seq("TO") else None
864
865            return self.expression(exp.PartitionRange(this=low, expression=high)) if high else low
866
867        partition = self.expression(exp.Partition(expressions=self._parse_wrapped_csv(parse_range)))
868
869        self._match_r_paren()
870
871        return partition
872
873    def _parse_alter_table_alter(self) -> exp.Expr | None:
874        expression = super()._parse_alter_table_alter()
875
876        if expression is not None:
877            collation = expression.args.get("collate")
878            if isinstance(collation, exp.Column) and isinstance(collation.this, exp.Identifier):
879                identifier = collation.this
880                collation.set("this", exp.Var(this=identifier.name))
881
882            if expression.args.get("dtype"):
883                if self._match_pair(TokenType.NOT, TokenType.NULL):
884                    expression.set("allow_null", False)
885                elif self._match(TokenType.NULL):
886                    expression.set("allow_null", True)
887
888        return expression
889
890    def _parse_primary_key_part(self) -> exp.Expr | None:
891        return self._parse_ordered()

FULL_FORMAT_TIME_MAPPING = {'weekday': '%A', 'dw': '%A', 'w': '%A', 'month': '%B', 'mm': '%B', 'm': '%B'}

DATE_DELTA_INTERVAL = {'year': 'year', 'yyyy': 'year', 'yy': 'year', 'quarter': 'quarter', 'qq': 'quarter', 'q': 'quarter', 'month': 'month', 'mm': 'month', 'm': 'month', 'week': 'week', 'ww': 'week', 'wk': 'week', 'day': 'day', 'dd': 'day', 'd': 'day'}

DATE_FMT_RE = re.compile('([dD]{1,2})|([mM]{1,2})|([yY]{1,4})|([hH]{1,2})|([sS]{1,2})|([fF]{2,7})')

TRANSPILE_SAFE_NUMBER_FMT = {'N', 'C'}

DEFAULT_START_DATE = datetime.date(1900, 1, 1)

OPTIONS: dict[str, Sequence[typing.Union[Sequence[str], str]]] = {'DISABLE_OPTIMIZED_PLAN_FORCING': (), 'FAST': (), 'IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX': (), 'LABEL': (), 'MAXDOP': (), 'MAXRECURSION': (), 'MAX_GRANT_PERCENT': (), 'MIN_GRANT_PERCENT': (), 'NO_PERFORMANCE_SPOOL': (), 'QUERYTRACEON': (), 'RECOMPILE': (), 'CONCAT': ('UNION',), 'DISABLE': ('EXTERNALPUSHDOWN', 'SCALEOUTEXECUTION'), 'EXPAND': ('VIEWS',), 'FORCE': ('EXTERNALPUSHDOWN', 'ORDER', 'SCALEOUTEXECUTION'), 'HASH': ('GROUP', 'JOIN', 'UNION'), 'KEEP': ('PLAN',), 'KEEPFIXED': ('PLAN',), 'LOOP': ('JOIN',), 'MERGE': ('JOIN', 'UNION'), 'OPTIMIZE': (('FOR', 'UNKNOWN'),), 'ORDER': ('GROUP',), 'PARAMETERIZATION': ('FORCED', 'SIMPLE'), 'ROBUST': ('PLAN',), 'USE': ('PLAN',)}

FOR_XML_OPTIONS: dict[str, Sequence[typing.Union[Sequence[str], str]]] = {'AUTO': (), 'EXPLICIT': (), 'TYPE': (), 'ELEMENTS': ('XSINIL', 'ABSENT'), 'BINARY': ('BASE64',)}

FOR_JSON_OPTIONS: dict[str, Sequence[typing.Union[Sequence[str], str]]] = {'AUTO': (), 'PATH': (), 'INCLUDE_NULL_VALUES': (), 'WITHOUT_ARRAY_WRAPPER': ()}

OPTIONS_THAT_REQUIRE_EQUAL = ('MAX_GRANT_PERCENT', 'MIN_GRANT_PERCENT', 'LABEL')

class TSQLParser(sqlglot.parser.Parser): View Source

324class TSQLParser(parser.Parser):
325    BARE_TABLE_HINTS = {
326        "NOLOCK",
327        "READUNCOMMITTED",
328        "UPDLOCK",
329        "REPEATABLEREAD",
330        "SERIALIZABLE",
331        "READCOMMITTED",
332        "TABLOCK",
333        "TABLOCKX",
334        "PAGLOCK",
335        "ROWLOCK",
336        "NOWAIT",
337        "READPAST",
338        "XLOCK",
339        "SNAPSHOT",
340        "NOEXPAND",
341    }
342
343    SET_REQUIRES_ASSIGNMENT_DELIMITER = False
344    LOG_DEFAULTS_TO_LN = True
345    STRING_ALIASES = True
346    NO_PAREN_IF_COMMANDS = False
347    UNPIVOT_VALUE_COLUMNS_FIRST = True
348
349    NO_PAREN_FUNCTIONS = {
350        **parser.Parser.NO_PAREN_FUNCTIONS,
351        TokenType.SESSION_USER: exp.SessionUser,
352    }
353
354    QUERY_MODIFIER_PARSERS = {
355        **parser.Parser.QUERY_MODIFIER_PARSERS,
356        TokenType.OPTION: lambda self: ("options", self._parse_options()),
357        TokenType.FOR: lambda self: ("for_", self._parse_for()),
358    }
359
360    # T-SQL does not allow BEGIN to be used as an identifier
361    ID_VAR_TOKENS = (parser.Parser.ID_VAR_TOKENS | {TokenType.RETURNING}) - {TokenType.BEGIN}
362    ALIAS_TOKENS = (parser.Parser.ALIAS_TOKENS | {TokenType.RETURNING}) - {TokenType.BEGIN}
363    TABLE_ALIAS_TOKENS = (parser.Parser.TABLE_ALIAS_TOKENS | {TokenType.ANTI, TokenType.SEMI}) - {
364        TokenType.BEGIN
365    }
366    COMMENT_TABLE_ALIAS_TOKENS = parser.Parser.COMMENT_TABLE_ALIAS_TOKENS - {TokenType.BEGIN}
367    UPDATE_ALIAS_TOKENS = parser.Parser.UPDATE_ALIAS_TOKENS - {TokenType.BEGIN}
368
369    FUNCTIONS = {
370        **parser.Parser.FUNCTIONS,
371        "ATN2": exp.Atan2.from_arg_list,
372        "CHARINDEX": lambda args: exp.StrPosition(
373            this=seq_get(args, 1),
374            substr=seq_get(args, 0),
375            position=seq_get(args, 2),
376        ),
377        "COUNT": lambda args: exp.Count(this=seq_get(args, 0), expressions=args[1:], big_int=False),
378        "COUNT_BIG": lambda args: exp.Count(
379            this=seq_get(args, 0), expressions=args[1:], big_int=True
380        ),
381        "DATEADD": build_date_delta(exp.DateAdd, unit_mapping=DATE_DELTA_INTERVAL),
382        "DATEDIFF": _build_date_delta(exp.DateDiff, unit_mapping=DATE_DELTA_INTERVAL),
383        "DATEDIFF_BIG": _build_date_delta(
384            exp.DateDiff, unit_mapping=DATE_DELTA_INTERVAL, big_int=True
385        ),
386        "DATENAME": _build_formatted_time(exp.TimeToStr, full_format_mapping=True),
387        "DATETIMEFROMPARTS": _build_datetimefromparts,
388        "DAY": lambda args: exp.Day(
389            this=exp.TsOrDsToDate(
390                this=seq_get(args, 0), default_date=exp.Literal.string("1900-01-01")
391            )
392        ),
393        "EOMONTH": _build_eomonth,
394        "FORMAT": _build_format,
395        "GETDATE": exp.CurrentTimestamp.from_arg_list,
396        "HASHBYTES": _build_hashbytes,
397        "ISNULL": lambda args: build_coalesce(args=args, is_null=True),
398        "JSON_QUERY": _build_json_query,
399        "JSON_VALUE": parser.build_extract_json_with_path(exp.JSONExtractScalar),
400        "LEN": _build_with_arg_as_text(exp.Length),
401        "LEFT": _build_with_arg_as_text(exp.Left),
402        "MONTH": lambda args: exp.Month(
403            this=exp.TsOrDsToDate(
404                this=seq_get(args, 0), default_date=exp.Literal.string("1900-01-01")
405            )
406        ),
407        "NEWID": exp.Uuid.from_arg_list,
408        "RIGHT": _build_with_arg_as_text(exp.Right),
409        "PARSENAME": _build_parsename,
410        "REPLICATE": exp.Repeat.from_arg_list,
411        "SCHEMA_NAME": exp.CurrentSchema.from_arg_list,
412        "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),
413        "SYSDATETIME": exp.CurrentTimestamp.from_arg_list,
414        "SUSER_NAME": exp.CurrentUser.from_arg_list,
415        "SUSER_SNAME": exp.CurrentUser.from_arg_list,
416        "SYSDATETIMEOFFSET": exp.CurrentTimestampLTZ.from_arg_list,
417        "SYSTEM_USER": exp.CurrentUser.from_arg_list,
418        "TIMEFROMPARTS": _build_timefromparts,
419        "DATETRUNC": _build_datetrunc,
420        "YEAR": lambda args: exp.Year(
421            this=exp.TsOrDsToDate(
422                this=seq_get(args, 0), default_date=exp.Literal.string("1900-01-01")
423            )
424        ),
425    }
426
427    JOIN_HINTS = {"LOOP", "HASH", "MERGE", "REMOTE"}
428
429    PROCEDURE_OPTIONS = dict.fromkeys(
430        ("ENCRYPTION", "RECOMPILE", "SCHEMABINDING", "NATIVE_COMPILATION", "EXECUTE"), tuple()
431    )
432
433    COLUMN_DEFINITION_MODES: t.ClassVar = {"OUT", "OUTPUT", "READONLY"}
434
435    RETURNS_TABLE_TOKENS: t.ClassVar = parser.Parser.ID_VAR_TOKENS - {
436        TokenType.TABLE,
437        *parser.Parser.TYPE_TOKENS,
438    }
439
440    STATEMENT_PARSERS = {
441        **parser.Parser.STATEMENT_PARSERS,
442        TokenType.EXECUTE: lambda self: self._parse_execute(),
443    }
444
445    RANGE_PARSERS = {
446        **parser.Parser.RANGE_PARSERS,
447        TokenType.DCOLON: lambda self, this: self.expression(
448            exp.ScopeResolution(
449                this=this, expression=self._parse_function() or self._parse_var(any_token=True)
450            )
451        ),
452    }
453
454    NO_PAREN_FUNCTION_PARSERS = {
455        **parser.Parser.NO_PAREN_FUNCTION_PARSERS,
456        "NEXT": lambda self: self._parse_next_value_for(),
457    }
458
459    FUNCTION_PARSERS = {
460        **parser.Parser.FUNCTION_PARSERS,
461        "JSON_ARRAYAGG": lambda self: self.expression(
462            exp.JSONArrayAgg(
463                this=self._parse_bitwise(),
464                order=self._parse_order(),
465                null_handling=self._parse_on_handling("NULL", "NULL", "ABSENT"),
466            )
467        ),
468        "DATEPART": lambda self: self._parse_datepart(),
469    }
470
471    # The DCOLON (::) operator serves as a scope resolution (exp.ScopeResolution) operator in T-SQL
472    COLUMN_OPERATORS = {
473        **parser.Parser.COLUMN_OPERATORS,
474        TokenType.DCOLON: lambda self, this, to: (
475            self.expression(exp.Cast(this=this, to=to))
476            if isinstance(to, exp.DataType) and to.this != exp.DType.USERDEFINED
477            else self.expression(exp.ScopeResolution(this=this, expression=to))
478        ),
479    }
480
481    SET_OP_MODIFIERS = {"order", "limit", "offset", "options", "for_"}
482
483    ODBC_DATETIME_LITERALS = {
484        "d": exp.Date,
485        "t": exp.Time,
486        "ts": exp.Timestamp,
487    }
488
489    def _parse_execute(self) -> exp.Execute:
490        return_status = None
491        index = self._index
492        if self._match(TokenType.PARAMETER):
493            param = self._parse_parameter()
494            if self._match(TokenType.EQ):
495                return_status = param
496            else:
497                self._retreat(index)
498
499        execute = self.expression(
500            exp.Execute(
501                this=self._parse_table(schema=True),
502                expressions=self._parse_csv(self._parse_expression),
503                return_status=return_status,
504            )
505        )
506
507        if execute.name.lower() == "sp_executesql":
508            execute = self.expression(exp.ExecuteSql(**execute.args))
509
510        return execute
511
512    def _parse_datepart(self) -> exp.Extract:
513        this = self._parse_var(tokens=[TokenType.IDENTIFIER])
514        expression = self._match(TokenType.COMMA) and self._parse_bitwise()
515        name = map_date_part(this, self.dialect)
516
517        return self.expression(exp.Extract(this=name, expression=expression))
518
519    def _parse_alter_table_set(self) -> exp.AlterSet:
520        return self._parse_wrapped(super()._parse_alter_table_set)
521
522    def _parse_wrapped_select(self, table: bool = False) -> exp.Expr | None:
523        if self._match(TokenType.MERGE):
524            comments = self._prev_comments
525            merge = self._parse_merge()
526            merge.add_comments(comments, prepend=True)
527            return merge
528
529        return super()._parse_wrapped_select(table=table)
530
531    def _parse_dcolon(self) -> exp.Expr | None:
532        # We want to use _parse_types() if the first token after :: is a known type,
533        # otherwise we could parse something like x::varchar(max) into a function
534        if self._match_set(self.TYPE_TOKENS, advance=False):
535            return self._parse_types()
536
537        return self._parse_function() or self._parse_types()
538
539    def _parse_options(self) -> list[exp.Expr] | None:
540        if not self._match(TokenType.OPTION):
541            return None
542
543        def _parse_option() -> exp.Expr | None:
544            option = self._parse_var_from_options(OPTIONS)
545            if not option:
546                return None
547
548            self._match(TokenType.EQ)
549            return self.expression(
550                exp.QueryOption(this=option, expression=self._parse_primary_or_var())
551            )
552
553        return self._parse_wrapped_csv(_parse_option)
554
555    def _parse_key_value_option(self) -> exp.XMLKeyValueOption:
556        this = self._parse_primary_or_var()
557        if self._match(TokenType.L_PAREN, advance=False):
558            expression = self._parse_wrapped(self._parse_string)
559        else:
560            expression = None
561
562        return exp.XMLKeyValueOption(this=this, expression=expression)
563
564    def _parse_for_clause_option(self, options: parser.OPTIONS_TYPE) -> exp.Expr | None:
565        return self.expression(
566            exp.QueryOption(
567                this=self._parse_var_from_options(options, raise_unmatched=False)
568                or self._parse_key_value_option()
569            )
570        )
571
572    def _parse_for(self) -> exp.ForClause | None:
573        if self._match_pair(TokenType.FOR, TokenType.XML):
574            return self.expression(
575                exp.ForClause(
576                    kind="XML",
577                    expressions=self._parse_csv(
578                        lambda: self._parse_for_clause_option(FOR_XML_OPTIONS)
579                    ),
580                )
581            )
582
583        if self._match_pair(TokenType.FOR, TokenType.JSON):
584            return self.expression(
585                exp.ForClause(
586                    kind="JSON",
587                    expressions=self._parse_csv(
588                        lambda: self._parse_for_clause_option(FOR_JSON_OPTIONS)
589                    ),
590                )
591            )
592
593        # FOR BROWSE — bare keyword, no options. BROWSE has no dedicated TokenType.
594        if self._match_text_seq("FOR", "BROWSE"):
595            return self.expression(exp.ForClause(kind="BROWSE"))
596
597        return None
598
599    def _parse_projections(
600        self,
601    ) -> tuple[list[exp.Expr], list[exp.Expr] | None]:
602        """
603        T-SQL supports the syntax alias = expression in the SELECT's projection list,
604        so we transform all parsed Selects to convert their EQ projections into Aliases.
605
606        See: https://learn.microsoft.com/en-us/sql/t-sql/queries/select-clause-transact-sql?view=sql-server-ver16#syntax
607        """
608        projections, _ = super()._parse_projections()
609        return [
610            (
611                exp.alias_(projection.expression, projection.this.this, copy=False)
612                if isinstance(projection, exp.EQ) and isinstance(projection.this, exp.Column)
613                else projection
614            )
615            for projection in projections
616        ], None
617
618    def _parse_commit_or_rollback(self) -> exp.Commit | exp.Rollback:
619        """Applies to SQL Server and Azure SQL Database
620        COMMIT [ { TRAN | TRANSACTION }
621            [ transaction_name | @tran_name_variable ] ]
622            [ WITH ( DELAYED_DURABILITY = { OFF | ON } ) ]
623
624        ROLLBACK { TRAN | TRANSACTION }
625            [ transaction_name | @tran_name_variable
626            | savepoint_name | @savepoint_variable ]
627        """
628        rollback = self._prev.token_type == TokenType.ROLLBACK
629
630        self._match_texts(("TRAN", "TRANSACTION"))
631        this = self._parse_id_var()
632
633        if rollback:
634            return self.expression(exp.Rollback(this=this))
635
636        durability = None
637        if self._match_pair(TokenType.WITH, TokenType.L_PAREN):
638            self._match_text_seq("DELAYED_DURABILITY")
639            self._match(TokenType.EQ)
640
641            if self._match_text_seq("OFF"):
642                durability = False
643            else:
644                self._match(TokenType.ON)
645                durability = True
646
647            self._match_r_paren()
648
649        return self.expression(exp.Commit(this=this, durability=durability))
650
651    def _parse_transaction(self) -> exp.Transaction | exp.Command:
652        """Applies to SQL Server and Azure SQL Database
653        BEGIN { TRAN | TRANSACTION }
654        [ { transaction_name | @tran_name_variable }
655        [ WITH MARK [ 'description' ] ]
656        ]
657        """
658        if self._match_texts(("TRAN", "TRANSACTION")):
659            transaction = self.expression(exp.Transaction(this=self._parse_id_var()))
660            if self._match_text_seq("WITH", "MARK"):
661                transaction.set("mark", self._parse_string())
662
663            return transaction
664
665        return self._parse_as_command(self._prev)
666
667    def _parse_returns(self) -> exp.ReturnsProperty:
668        table = self._parse_id_var(any_token=False, tokens=self.RETURNS_TABLE_TOKENS)
669        returns = super()._parse_returns()
670        returns.set("table", table)
671        return returns
672
673    def _parse_convert(self, strict: bool, safe: bool | None = None) -> exp.Expr | None:
674        this = self._parse_types()
675        self._match(TokenType.COMMA)
676        args = [this, *self._parse_csv(self._parse_assignment)]
677        convert = exp.Convert.from_arg_list(args)
678        convert.set("safe", safe)
679        return convert
680
681    def _parse_column_def(
682        self, this: exp.Expr | None, computed_column: bool = True
683    ) -> exp.Expr | None:
684        this = super()._parse_column_def(this=this, computed_column=computed_column)
685        if not this:
686            return None
687        if self._match(TokenType.EQ):
688            this.set("default", self._parse_disjunction())
689        if self._match_texts(self.COLUMN_DEFINITION_MODES):
690            this.set("output", self._prev.text)
691        return this
692
693    def _parse_user_defined_function(self, kind: TokenType | None = None) -> exp.Expr | None:
694        this = super()._parse_user_defined_function(kind=kind)
695
696        if kind == TokenType.FUNCTION or isinstance(this, exp.UserDefinedFunction):
697            return this
698
699        if kind == TokenType.PROCEDURE and this:
700            expressions = this.expressions
701            if not (
702                expressions or self._match_set((TokenType.ALIAS, TokenType.WITH), advance=False)
703            ):
704                expressions = self._parse_csv(self._parse_function_parameter)
705
706            return self.expression(
707                exp.StoredProcedure(
708                    this=this if isinstance(this, exp.Table) else this.this,
709                    expressions=expressions,
710                    wrapped=this.args.get("wrapped"),
711                )
712            )
713
714        return self.expression(exp.UserDefinedFunction(this=this))
715
716    def _parse_into(self) -> exp.Into | None:
717        into = super()._parse_into()
718
719        table = isinstance(into, exp.Into) and into.find(exp.Table)
720        if isinstance(table, exp.Table):
721            table_identifier = table.this
722            if table_identifier.args.get("temporary"):
723                # Promote the temporary property from the Identifier to the Into expression
724                t.cast(exp.Into, into).set("temporary", True)
725
726        return into
727
728    def _parse_id_var(
729        self,
730        any_token: bool = True,
731        tokens: Collection[TokenType] | None = None,
732    ) -> exp.Expr | None:
733        is_temporary = self._match(TokenType.HASH)
734        is_global = is_temporary and self._match(TokenType.HASH)
735
736        this = super()._parse_id_var(any_token=any_token, tokens=tokens)
737        if this:
738            if is_global:
739                this.set("global_", True)
740            elif is_temporary:
741                this.set("temporary", True)
742
743        return this
744
745    def _parse_table_part(self, schema: bool = False) -> exp.Expr | None:
746        # Schema mode already skips function parsing; otherwise, '(' may start a bare table hint.
747        if not schema and self._next.token_type == TokenType.L_PAREN:
748            index = self._index
749            self._advance(2)
750            is_hint = self._match_texts(self.BARE_TABLE_HINTS) and self._match(TokenType.R_PAREN)
751            self._retreat(index)
752
753            if is_hint and (this := self._parse_id_var(any_token=False)):
754                return this
755
756        return super()._parse_table_part(schema=schema)
757
758    def _parse_table(
759        self,
760        schema: bool = False,
761        joins: bool = False,
762        alias_tokens: Collection[TokenType] | None = None,
763        parse_bracket: bool = False,
764        is_db_reference: bool = False,
765        parse_partition: bool = False,
766        consume_pipe: bool = False,
767    ) -> exp.Expr | None:
768        table = super()._parse_table(
769            schema=schema,
770            joins=joins,
771            alias_tokens=alias_tokens,
772            parse_bracket=parse_bracket,
773            is_db_reference=is_db_reference,
774            parse_partition=parse_partition,
775            consume_pipe=consume_pipe,
776        )
777        if (
778            isinstance(table, exp.Table)
779            and not table.args.get("hints")
780            and (alias := table.args.get("alias"))
781            and len(alias.columns) == 1
782            and isinstance(hint := alias.columns[0], exp.Identifier)
783            and not hint.quoted
784            and hint.name.upper() in self.BARE_TABLE_HINTS
785            and all(isinstance(part, exp.Identifier) for part in table.parts)
786        ):
787            var = exp.var(hint.name)
788            var.add_comments(hint.pop_comments())
789            alias.set("columns", None)
790            if not alias.this:
791                table.add_comments(alias.pop_comments())
792                table.set("alias", self._parse_table_alias(alias_tokens=alias_tokens))
793            table.set("hints", [exp.WithTableHint(expressions=[var])])
794
795        return table
796
797    def _parse_table_parts(
798        self,
799        schema: bool = False,
800        is_db_reference: bool = False,
801        wildcard: bool = False,
802        fast: bool = False,
803    ) -> exp.Table | exp.Dot | None:
804        table = super()._parse_table_parts(
805            schema=schema,
806            is_db_reference=is_db_reference,
807            wildcard=wildcard,
808            fast=fast,
809        )
810        if (
811            isinstance(table, exp.Table)
812            and isinstance(table.this, exp.Identifier)
813            and (table_name := table.name).startswith("#")
814        ):
815            if table_name.startswith("##"):
816                table.this.set("this", table_name[2:])
817                table.this.set("global_", True)
818            else:
819                table.this.set("this", table_name[1:])
820                table.this.set("temporary", True)
821
822        return table
823
824    def _parse_create(self) -> exp.Create | exp.Command:
825        create = super()._parse_create()
826
827        if isinstance(create, exp.Create):
828            table = create.this.this if isinstance(create.this, exp.Schema) else create.this
829            if isinstance(table, exp.Table) and table.this and table.this.args.get("temporary"):
830                if not create.args.get("properties"):
831                    create.set("properties", exp.Properties(expressions=[]))
832
833                create.args["properties"].append("expressions", exp.TemporaryProperty())
834
835        return create
836
837    def _parse_if(self) -> exp.Expr | None:
838        this = self._parse_condition()
839        true = self._parse_block()
840
841        false = self._match(TokenType.ELSE) and self._parse_block()
842
843        return self.expression(exp.IfBlock(this=this, true=true, false=false))
844
845    def _parse_unique(self) -> exp.UniqueColumnConstraint:
846        if self._match_texts(("CLUSTERED", "NONCLUSTERED")):
847            this = self.CONSTRAINT_PARSERS[self._prev.text.upper()](self)
848        else:
849            this = self._parse_schema(self._parse_id_var(any_token=False))
850
851        return self.expression(exp.UniqueColumnConstraint(this=this))
852
853    def _parse_update(self) -> exp.Update:
854        expression = super()._parse_update()
855        expression.set("options", self._parse_options())
856        return expression
857
858    def _parse_partition(self) -> exp.Partition | None:
859        if not self._match_text_seq("WITH", "(", "PARTITIONS"):
860            return None
861
862        def parse_range():
863            low = self._parse_bitwise()
864            high = self._parse_bitwise() if self._match_text_seq("TO") else None
865
866            return self.expression(exp.PartitionRange(this=low, expression=high)) if high else low
867
868        partition = self.expression(exp.Partition(expressions=self._parse_wrapped_csv(parse_range)))
869
870        self._match_r_paren()
871
872        return partition
873
874    def _parse_alter_table_alter(self) -> exp.Expr | None:
875        expression = super()._parse_alter_table_alter()
876
877        if expression is not None:
878            collation = expression.args.get("collate")
879            if isinstance(collation, exp.Column) and isinstance(collation.this, exp.Identifier):
880                identifier = collation.this
881                collation.set("this", exp.Var(this=identifier.name))
882
883            if expression.args.get("dtype"):
884                if self._match_pair(TokenType.NOT, TokenType.NULL):
885                    expression.set("allow_null", False)
886                elif self._match(TokenType.NULL):
887                    expression.set("allow_null", True)
888
889        return expression
890
891    def _parse_primary_key_part(self) -> exp.Expr | None:
892        return self._parse_ordered()

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
max_nodes: Maximum number of AST nodes to prevent memory exhaustion. Set to -1 (default) to disable the check.

BARE_TABLE_HINTS = {'NOLOCK', 'TABLOCKX', 'SERIALIZABLE', 'REPEATABLEREAD', 'UPDLOCK', 'READUNCOMMITTED', 'NOWAIT', 'READPAST', 'PAGLOCK', 'XLOCK', 'TABLOCK', 'SNAPSHOT', 'NOEXPAND', 'ROWLOCK', 'READCOMMITTED'}

SET_REQUIRES_ASSIGNMENT_DELIMITER = False

LOG_DEFAULTS_TO_LN = True

STRING_ALIASES = True

NO_PAREN_IF_COMMANDS = False

UNPIVOT_VALUE_COLUMNS_FIRST = True

NO_PAREN_FUNCTIONS = {<TokenType.CURRENT_DATE: 247>: <class 'sqlglot.expressions.temporal.CurrentDate'>, <TokenType.CURRENT_DATETIME: 248>: <class 'sqlglot.expressions.temporal.CurrentDate'>, <TokenType.CURRENT_TIME: 250>: <class 'sqlglot.expressions.temporal.CurrentTime'>, <TokenType.CURRENT_TIMESTAMP: 251>: <class 'sqlglot.expressions.temporal.CurrentTimestamp'>, <TokenType.CURRENT_USER: 252>: <class 'sqlglot.expressions.functions.CurrentUser'>, <TokenType.CURRENT_ROLE: 254>: <class 'sqlglot.expressions.functions.CurrentRole'>, <TokenType.SESSION_USER: 61>: <class 'sqlglot.expressions.functions.SessionUser'>}

QUERY_MODIFIER_PARSERS = {<TokenType.MATCH_RECOGNIZE: 327>: <function Parser.<lambda>>, <TokenType.PREWHERE: 363>: <function Parser.<lambda>>, <TokenType.WHERE: 431>: <function Parser.<lambda>>, <TokenType.GROUP_BY: 291>: <function Parser.<lambda>>, <TokenType.HAVING: 293>: <function Parser.<lambda>>, <TokenType.QUALIFY: 370>: <function Parser.<lambda>>, <TokenType.WINDOW: 432>: <function Parser.<lambda>>, <TokenType.ORDER_BY: 342>: <function Parser.<lambda>>, <TokenType.LIMIT: 320>: <function Parser.<lambda>>, <TokenType.FETCH: 274>: <function Parser.<lambda>>, <TokenType.OFFSET: 338>: <function Parser.<lambda>>, <TokenType.FOR: 280>: <function TSQLParser.<lambda>>, <TokenType.LOCK: 323>: <function Parser.<lambda>>, <TokenType.TABLE_SAMPLE: 407>: <function Parser.<lambda>>, <TokenType.USING: 423>: <function Parser.<lambda>>, <TokenType.CLUSTER_BY: 236>: <function Parser.<lambda>>, <TokenType.DISTRIBUTE_BY: 264>: <function Parser.<lambda>>, <TokenType.SORT_BY: 399>: <function Parser.<lambda>>, <TokenType.CONNECT_BY: 241>: <function Parser.<lambda>>, <TokenType.OPTION: 438>: <function TSQLParser.<lambda>>}

ID_VAR_TOKENS = {<TokenType.SESSION: 59>, <TokenType.SESSION_USER: 61>, <TokenType.IDENTIFIER: 79>, <TokenType.DATABASE: 80>, <TokenType.COLUMN: 81>, <TokenType.SCHEMA: 83>, <TokenType.TABLE: 84>, <TokenType.WAREHOUSE: 85>, <TokenType.STAGE: 86>, <TokenType.STREAM: 87>, <TokenType.STREAMLIT: 88>, <TokenType.VAR: 89>, <TokenType.BIT: 98>, <TokenType.BOOLEAN: 99>, <TokenType.TINYINT: 100>, <TokenType.UTINYINT: 101>, <TokenType.SMALLINT: 102>, <TokenType.USMALLINT: 103>, <TokenType.MEDIUMINT: 104>, <TokenType.UMEDIUMINT: 105>, <TokenType.INT: 106>, <TokenType.UINT: 107>, <TokenType.BIGINT: 108>, <TokenType.UBIGINT: 109>, <TokenType.BIGNUM: 110>, <TokenType.INT128: 111>, <TokenType.UINT128: 112>, <TokenType.INT256: 113>, <TokenType.UINT256: 114>, <TokenType.FLOAT: 115>, <TokenType.DOUBLE: 116>, <TokenType.UDOUBLE: 117>, <TokenType.DECIMAL: 118>, <TokenType.DECIMAL32: 119>, <TokenType.DECIMAL64: 120>, <TokenType.DECIMAL128: 121>, <TokenType.DECIMAL256: 122>, <TokenType.DECFLOAT: 123>, <TokenType.UDECIMAL: 124>, <TokenType.BIGDECIMAL: 125>, <TokenType.CHAR: 126>, <TokenType.NCHAR: 127>, <TokenType.VARCHAR: 128>, <TokenType.NVARCHAR: 129>, <TokenType.BPCHAR: 130>, <TokenType.TEXT: 131>, <TokenType.MEDIUMTEXT: 132>, <TokenType.LONGTEXT: 133>, <TokenType.BLOB: 134>, <TokenType.MEDIUMBLOB: 135>, <TokenType.LONGBLOB: 136>, <TokenType.TINYBLOB: 137>, <TokenType.TINYTEXT: 138>, <TokenType.NAME: 139>, <TokenType.BINARY: 140>, <TokenType.VARBINARY: 141>, <TokenType.JSON: 142>, <TokenType.JSONB: 143>, <TokenType.TIME: 144>, <TokenType.TIMETZ: 145>, <TokenType.TIME_NS: 146>, <TokenType.TIMESTAMP: 147>, <TokenType.TIMESTAMPTZ: 148>, <TokenType.TIMESTAMPLTZ: 149>, <TokenType.TIMESTAMPNTZ: 150>, <TokenType.TIMESTAMP_S: 151>, <TokenType.TIMESTAMP_MS: 152>, <TokenType.TIMESTAMP_NS: 153>, <TokenType.DATETIME: 154>, <TokenType.DATETIME2: 155>, <TokenType.DATETIME64: 156>, <TokenType.SMALLDATETIME: 157>, <TokenType.DATE: 158>, <TokenType.DATE32: 159>, <TokenType.INT4RANGE: 160>, <TokenType.INT4MULTIRANGE: 161>, <TokenType.INT8RANGE: 162>, <TokenType.INT8MULTIRANGE: 163>, <TokenType.NUMRANGE: 164>, <TokenType.NUMMULTIRANGE: 165>, <TokenType.TSRANGE: 166>, <TokenType.TSMULTIRANGE: 167>, <TokenType.TSTZRANGE: 168>, <TokenType.TSTZMULTIRANGE: 169>, <TokenType.DATERANGE: 170>, <TokenType.DATEMULTIRANGE: 171>, <TokenType.UUID: 172>, <TokenType.GEOGRAPHY: 173>, <TokenType.GEOGRAPHYPOINT: 174>, <TokenType.NULLABLE: 175>, <TokenType.GEOMETRY: 176>, <TokenType.POINT: 177>, <TokenType.RING: 178>, <TokenType.LINESTRING: 179>, <TokenType.LOCALTIME: 180>, <TokenType.LOCALTIMESTAMP: 181>, <TokenType.MULTILINESTRING: 183>, <TokenType.POLYGON: 184>, <TokenType.MULTIPOLYGON: 185>, <TokenType.HLLSKETCH: 186>, <TokenType.HSTORE: 187>, <TokenType.SUPER: 188>, <TokenType.SERIAL: 189>, <TokenType.SMALLSERIAL: 190>, <TokenType.BIGSERIAL: 191>, <TokenType.XML: 192>, <TokenType.YEAR: 193>, <TokenType.USERDEFINED: 194>, <TokenType.MONEY: 195>, <TokenType.SMALLMONEY: 196>, <TokenType.ROWVERSION: 197>, <TokenType.IMAGE: 198>, <TokenType.VARIANT: 199>, <TokenType.OBJECT: 200>, <TokenType.INET: 201>, <TokenType.IPADDRESS: 202>, <TokenType.IPPREFIX: 203>, <TokenType.IPV4: 204>, <TokenType.IPV6: 205>, <TokenType.ENUM: 206>, <TokenType.ENUM8: 207>, <TokenType.ENUM16: 208>, <TokenType.FIXEDSTRING: 209>, <TokenType.LOWCARDINALITY: 210>, <TokenType.NESTED: 211>, <TokenType.AGGREGATEFUNCTION: 212>, <TokenType.SIMPLEAGGREGATEFUNCTION: 213>, <TokenType.TDIGEST: 214>, <TokenType.UNKNOWN: 215>, <TokenType.VECTOR: 216>, <TokenType.DYNAMIC: 217>, <TokenType.VOID: 218>, <TokenType.ALL: 221>, <TokenType.ANTI: 222>, <TokenType.ANY: 223>, <TokenType.APPLY: 224>, <TokenType.ARRAY: 225>, <TokenType.ASC: 226>, <TokenType.ASOF: 227>, <TokenType.ATTACH: 228>, <TokenType.AUTO_INCREMENT: 229>, <TokenType.CACHE: 233>, <TokenType.CASE: 234>, <TokenType.COLLATE: 237>, <TokenType.COMMAND: 238>, <TokenType.COMMENT: 239>, <TokenType.COMMIT: 240>, <TokenType.CONSTRAINT: 242>, <TokenType.COPY: 243>, <TokenType.CUBE: 246>, <TokenType.CURRENT_DATE: 247>, <TokenType.CURRENT_DATETIME: 248>, <TokenType.CURRENT_SCHEMA: 249>, <TokenType.CURRENT_TIME: 250>, <TokenType.CURRENT_TIMESTAMP: 251>, <TokenType.CURRENT_USER: 252>, <TokenType.CURRENT_ROLE: 254>, <TokenType.CURRENT_CATALOG: 255>, <TokenType.DECLARE: 256>, <TokenType.DEFAULT: 257>, <TokenType.DELETE: 258>, <TokenType.DESC: 259>, <TokenType.DESCRIBE: 260>, <TokenType.DETACH: 261>, <TokenType.DICTIONARY: 262>, <TokenType.DIV: 265>, <TokenType.END: 268>, <TokenType.ESCAPE: 269>, <TokenType.EXECUTE: 271>, <TokenType.EXISTS: 272>, <TokenType.FALSE: 273>, <TokenType.FILE: 275>, <TokenType.FILE_FORMAT: 276>, <TokenType.FILTER: 277>, <TokenType.FINAL: 278>, <TokenType.FIRST: 279>, <TokenType.FOREIGN_KEY: 282>, <TokenType.FORMAT: 283>, <TokenType.FULL: 285>, <TokenType.FUNCTION: 286>, <TokenType.GET: 287>, <TokenType.INDEX: 298>, <TokenType.INTERVAL: 305>, <TokenType.IS: 309>, <TokenType.ISNULL: 310>, <TokenType.KEEP: 313>, <TokenType.KILL: 315>, <TokenType.LEFT: 318>, <TokenType.LIMIT: 320>, <TokenType.LIST: 321>, <TokenType.LOAD: 322>, <TokenType.LOCK: 323>, <TokenType.MAP: 324>, <TokenType.MATCH: 325>, <TokenType.MERGE: 329>, <TokenType.MODEL: 331>, <TokenType.NATURAL: 332>, <TokenType.NEXT: 333>, <TokenType.NOTHING: 334>, <TokenType.NULL: 336>, <TokenType.OBJECT_IDENTIFIER: 337>, <TokenType.OFFSET: 338>, <TokenType.OPERATOR: 341>, <TokenType.ORDINALITY: 345>, <TokenType.OUT: 346>, <TokenType.INOUT: 347>, <TokenType.OVER: 349>, <TokenType.OVERLAPS: 350>, <TokenType.OVERWRITE: 351>, <TokenType.PARTITION: 353>, <TokenType.PASTE: 355>, <TokenType.PERCENT: 356>, <TokenType.PIVOT: 357>, <TokenType.PRAGMA: 362>, <TokenType.PROCEDURE: 365>, <TokenType.PROJECTION: 367>, <TokenType.PSEUDO_TYPE: 368>, <TokenType.PUT: 369>, <TokenType.RANGE: 373>, <TokenType.RECURSIVE: 374>, <TokenType.REFRESH: 375>, <TokenType.RENAME: 376>, <TokenType.REPLACE: 377>, <TokenType.RETURNING: 378>, <TokenType.REFERENCES: 380>, <TokenType.RIGHT: 381>, <TokenType.ROLLUP: 385>, <TokenType.ROW: 386>, <TokenType.ROWS: 387>, <TokenType.SEMI: 390>, <TokenType.SEQUENCE: 392>, <TokenType.SET: 394>, <TokenType.SETTINGS: 395>, <TokenType.SHOW: 396>, <TokenType.SOME: 398>, <TokenType.STORAGE_INTEGRATION: 403>, <TokenType.STRAIGHT_JOIN: 404>, <TokenType.STRUCT: 405>, <TokenType.TAG: 408>, <TokenType.TEMPORARY: 409>, <TokenType.TOP: 410>, <TokenType.TRUE: 412>, <TokenType.TRUNCATE: 413>, <TokenType.TRIGGER: 414>, <TokenType.TYPE: 415>, <TokenType.UNNEST: 419>, <TokenType.UNPIVOT: 420>, <TokenType.UPDATE: 421>, <TokenType.USE: 422>, <TokenType.VIEW: 426>, <TokenType.SEMANTIC_VIEW: 427>, <TokenType.VOLATILE: 428>, <TokenType.WINDOW: 432>, <TokenType.UNIQUE: 434>, <TokenType.SINK: 439>, <TokenType.SOURCE: 440>, <TokenType.ANALYZE: 441>, <TokenType.NAMESPACE: 442>, <TokenType.EXPORT: 443>}

ALIAS_TOKENS = {<TokenType.SESSION: 59>, <TokenType.SESSION_USER: 61>, <TokenType.IDENTIFIER: 79>, <TokenType.DATABASE: 80>, <TokenType.COLUMN: 81>, <TokenType.SCHEMA: 83>, <TokenType.TABLE: 84>, <TokenType.WAREHOUSE: 85>, <TokenType.STAGE: 86>, <TokenType.STREAM: 87>, <TokenType.STREAMLIT: 88>, <TokenType.VAR: 89>, <TokenType.BIT: 98>, <TokenType.BOOLEAN: 99>, <TokenType.TINYINT: 100>, <TokenType.UTINYINT: 101>, <TokenType.SMALLINT: 102>, <TokenType.USMALLINT: 103>, <TokenType.MEDIUMINT: 104>, <TokenType.UMEDIUMINT: 105>, <TokenType.INT: 106>, <TokenType.UINT: 107>, <TokenType.BIGINT: 108>, <TokenType.UBIGINT: 109>, <TokenType.BIGNUM: 110>, <TokenType.INT128: 111>, <TokenType.UINT128: 112>, <TokenType.INT256: 113>, <TokenType.UINT256: 114>, <TokenType.FLOAT: 115>, <TokenType.DOUBLE: 116>, <TokenType.UDOUBLE: 117>, <TokenType.DECIMAL: 118>, <TokenType.DECIMAL32: 119>, <TokenType.DECIMAL64: 120>, <TokenType.DECIMAL128: 121>, <TokenType.DECIMAL256: 122>, <TokenType.DECFLOAT: 123>, <TokenType.UDECIMAL: 124>, <TokenType.BIGDECIMAL: 125>, <TokenType.CHAR: 126>, <TokenType.NCHAR: 127>, <TokenType.VARCHAR: 128>, <TokenType.NVARCHAR: 129>, <TokenType.BPCHAR: 130>, <TokenType.TEXT: 131>, <TokenType.MEDIUMTEXT: 132>, <TokenType.LONGTEXT: 133>, <TokenType.BLOB: 134>, <TokenType.MEDIUMBLOB: 135>, <TokenType.LONGBLOB: 136>, <TokenType.TINYBLOB: 137>, <TokenType.TINYTEXT: 138>, <TokenType.NAME: 139>, <TokenType.BINARY: 140>, <TokenType.VARBINARY: 141>, <TokenType.JSON: 142>, <TokenType.JSONB: 143>, <TokenType.TIME: 144>, <TokenType.TIMETZ: 145>, <TokenType.TIME_NS: 146>, <TokenType.TIMESTAMP: 147>, <TokenType.TIMESTAMPTZ: 148>, <TokenType.TIMESTAMPLTZ: 149>, <TokenType.TIMESTAMPNTZ: 150>, <TokenType.TIMESTAMP_S: 151>, <TokenType.TIMESTAMP_MS: 152>, <TokenType.TIMESTAMP_NS: 153>, <TokenType.DATETIME: 154>, <TokenType.DATETIME2: 155>, <TokenType.DATETIME64: 156>, <TokenType.SMALLDATETIME: 157>, <TokenType.DATE: 158>, <TokenType.DATE32: 159>, <TokenType.INT4RANGE: 160>, <TokenType.INT4MULTIRANGE: 161>, <TokenType.INT8RANGE: 162>, <TokenType.INT8MULTIRANGE: 163>, <TokenType.NUMRANGE: 164>, <TokenType.NUMMULTIRANGE: 165>, <TokenType.TSRANGE: 166>, <TokenType.TSMULTIRANGE: 167>, <TokenType.TSTZRANGE: 168>, <TokenType.TSTZMULTIRANGE: 169>, <TokenType.DATERANGE: 170>, <TokenType.DATEMULTIRANGE: 171>, <TokenType.UUID: 172>, <TokenType.GEOGRAPHY: 173>, <TokenType.GEOGRAPHYPOINT: 174>, <TokenType.NULLABLE: 175>, <TokenType.GEOMETRY: 176>, <TokenType.POINT: 177>, <TokenType.RING: 178>, <TokenType.LINESTRING: 179>, <TokenType.LOCALTIME: 180>, <TokenType.LOCALTIMESTAMP: 181>, <TokenType.MULTILINESTRING: 183>, <TokenType.POLYGON: 184>, <TokenType.MULTIPOLYGON: 185>, <TokenType.HLLSKETCH: 186>, <TokenType.HSTORE: 187>, <TokenType.SUPER: 188>, <TokenType.SERIAL: 189>, <TokenType.SMALLSERIAL: 190>, <TokenType.BIGSERIAL: 191>, <TokenType.XML: 192>, <TokenType.YEAR: 193>, <TokenType.USERDEFINED: 194>, <TokenType.MONEY: 195>, <TokenType.SMALLMONEY: 196>, <TokenType.ROWVERSION: 197>, <TokenType.IMAGE: 198>, <TokenType.VARIANT: 199>, <TokenType.OBJECT: 200>, <TokenType.INET: 201>, <TokenType.IPADDRESS: 202>, <TokenType.IPPREFIX: 203>, <TokenType.IPV4: 204>, <TokenType.IPV6: 205>, <TokenType.ENUM: 206>, <TokenType.ENUM8: 207>, <TokenType.ENUM16: 208>, <TokenType.FIXEDSTRING: 209>, <TokenType.LOWCARDINALITY: 210>, <TokenType.NESTED: 211>, <TokenType.AGGREGATEFUNCTION: 212>, <TokenType.SIMPLEAGGREGATEFUNCTION: 213>, <TokenType.TDIGEST: 214>, <TokenType.UNKNOWN: 215>, <TokenType.VECTOR: 216>, <TokenType.DYNAMIC: 217>, <TokenType.VOID: 218>, <TokenType.ALL: 221>, <TokenType.ANTI: 222>, <TokenType.ANY: 223>, <TokenType.APPLY: 224>, <TokenType.ARRAY: 225>, <TokenType.ASC: 226>, <TokenType.ASOF: 227>, <TokenType.ATTACH: 228>, <TokenType.AUTO_INCREMENT: 229>, <TokenType.CACHE: 233>, <TokenType.CASE: 234>, <TokenType.COLLATE: 237>, <TokenType.COMMAND: 238>, <TokenType.COMMENT: 239>, <TokenType.COMMIT: 240>, <TokenType.CONSTRAINT: 242>, <TokenType.COPY: 243>, <TokenType.CUBE: 246>, <TokenType.CURRENT_DATE: 247>, <TokenType.CURRENT_DATETIME: 248>, <TokenType.CURRENT_SCHEMA: 249>, <TokenType.CURRENT_TIME: 250>, <TokenType.CURRENT_TIMESTAMP: 251>, <TokenType.CURRENT_USER: 252>, <TokenType.CURRENT_ROLE: 254>, <TokenType.CURRENT_CATALOG: 255>, <TokenType.DECLARE: 256>, <TokenType.DEFAULT: 257>, <TokenType.DELETE: 258>, <TokenType.DESC: 259>, <TokenType.DESCRIBE: 260>, <TokenType.DETACH: 261>, <TokenType.DICTIONARY: 262>, <TokenType.DIV: 265>, <TokenType.END: 268>, <TokenType.ESCAPE: 269>, <TokenType.EXECUTE: 271>, <TokenType.EXISTS: 272>, <TokenType.FALSE: 273>, <TokenType.FILE: 275>, <TokenType.FILE_FORMAT: 276>, <TokenType.FILTER: 277>, <TokenType.FINAL: 278>, <TokenType.FIRST: 279>, <TokenType.FOREIGN_KEY: 282>, <TokenType.FORMAT: 283>, <TokenType.FULL: 285>, <TokenType.FUNCTION: 286>, <TokenType.GET: 287>, <TokenType.INDEX: 298>, <TokenType.INTERVAL: 305>, <TokenType.IS: 309>, <TokenType.ISNULL: 310>, <TokenType.KEEP: 313>, <TokenType.KILL: 315>, <TokenType.LEFT: 318>, <TokenType.LIMIT: 320>, <TokenType.LIST: 321>, <TokenType.LOAD: 322>, <TokenType.LOCK: 323>, <TokenType.MAP: 324>, <TokenType.MATCH: 325>, <TokenType.MERGE: 329>, <TokenType.MODEL: 331>, <TokenType.NATURAL: 332>, <TokenType.NEXT: 333>, <TokenType.NOTHING: 334>, <TokenType.NULL: 336>, <TokenType.OBJECT_IDENTIFIER: 337>, <TokenType.OFFSET: 338>, <TokenType.OPERATOR: 341>, <TokenType.ORDINALITY: 345>, <TokenType.OUT: 346>, <TokenType.INOUT: 347>, <TokenType.OVER: 349>, <TokenType.OVERLAPS: 350>, <TokenType.OVERWRITE: 351>, <TokenType.PARTITION: 353>, <TokenType.PASTE: 355>, <TokenType.PERCENT: 356>, <TokenType.PIVOT: 357>, <TokenType.PRAGMA: 362>, <TokenType.PROCEDURE: 365>, <TokenType.PROJECTION: 367>, <TokenType.PSEUDO_TYPE: 368>, <TokenType.PUT: 369>, <TokenType.RANGE: 373>, <TokenType.RECURSIVE: 374>, <TokenType.REFRESH: 375>, <TokenType.RENAME: 376>, <TokenType.REPLACE: 377>, <TokenType.RETURNING: 378>, <TokenType.REFERENCES: 380>, <TokenType.RIGHT: 381>, <TokenType.ROLLUP: 385>, <TokenType.ROW: 386>, <TokenType.ROWS: 387>, <TokenType.SEMI: 390>, <TokenType.SEQUENCE: 392>, <TokenType.SET: 394>, <TokenType.SETTINGS: 395>, <TokenType.SHOW: 396>, <TokenType.SOME: 398>, <TokenType.STORAGE_INTEGRATION: 403>, <TokenType.STRAIGHT_JOIN: 404>, <TokenType.STRUCT: 405>, <TokenType.TAG: 408>, <TokenType.TEMPORARY: 409>, <TokenType.TOP: 410>, <TokenType.TRUE: 412>, <TokenType.TRUNCATE: 413>, <TokenType.TRIGGER: 414>, <TokenType.TYPE: 415>, <TokenType.UNNEST: 419>, <TokenType.UNPIVOT: 420>, <TokenType.UPDATE: 421>, <TokenType.USE: 422>, <TokenType.VIEW: 426>, <TokenType.SEMANTIC_VIEW: 427>, <TokenType.VOLATILE: 428>, <TokenType.WINDOW: 432>, <TokenType.UNIQUE: 434>, <TokenType.SINK: 439>, <TokenType.SOURCE: 440>, <TokenType.ANALYZE: 441>, <TokenType.NAMESPACE: 442>, <TokenType.EXPORT: 443>}

TABLE_ALIAS_TOKENS = {<TokenType.SESSION: 59>, <TokenType.SESSION_USER: 61>, <TokenType.IDENTIFIER: 79>, <TokenType.DATABASE: 80>, <TokenType.COLUMN: 81>, <TokenType.SCHEMA: 83>, <TokenType.TABLE: 84>, <TokenType.WAREHOUSE: 85>, <TokenType.STAGE: 86>, <TokenType.STREAM: 87>, <TokenType.STREAMLIT: 88>, <TokenType.VAR: 89>, <TokenType.BIT: 98>, <TokenType.BOOLEAN: 99>, <TokenType.TINYINT: 100>, <TokenType.UTINYINT: 101>, <TokenType.SMALLINT: 102>, <TokenType.USMALLINT: 103>, <TokenType.MEDIUMINT: 104>, <TokenType.UMEDIUMINT: 105>, <TokenType.INT: 106>, <TokenType.UINT: 107>, <TokenType.BIGINT: 108>, <TokenType.UBIGINT: 109>, <TokenType.BIGNUM: 110>, <TokenType.INT128: 111>, <TokenType.UINT128: 112>, <TokenType.INT256: 113>, <TokenType.UINT256: 114>, <TokenType.FLOAT: 115>, <TokenType.DOUBLE: 116>, <TokenType.UDOUBLE: 117>, <TokenType.DECIMAL: 118>, <TokenType.DECIMAL32: 119>, <TokenType.DECIMAL64: 120>, <TokenType.DECIMAL128: 121>, <TokenType.DECIMAL256: 122>, <TokenType.DECFLOAT: 123>, <TokenType.UDECIMAL: 124>, <TokenType.BIGDECIMAL: 125>, <TokenType.CHAR: 126>, <TokenType.NCHAR: 127>, <TokenType.VARCHAR: 128>, <TokenType.NVARCHAR: 129>, <TokenType.BPCHAR: 130>, <TokenType.TEXT: 131>, <TokenType.MEDIUMTEXT: 132>, <TokenType.LONGTEXT: 133>, <TokenType.BLOB: 134>, <TokenType.MEDIUMBLOB: 135>, <TokenType.LONGBLOB: 136>, <TokenType.TINYBLOB: 137>, <TokenType.TINYTEXT: 138>, <TokenType.NAME: 139>, <TokenType.BINARY: 140>, <TokenType.VARBINARY: 141>, <TokenType.JSON: 142>, <TokenType.JSONB: 143>, <TokenType.TIME: 144>, <TokenType.TIMETZ: 145>, <TokenType.TIME_NS: 146>, <TokenType.TIMESTAMP: 147>, <TokenType.TIMESTAMPTZ: 148>, <TokenType.TIMESTAMPLTZ: 149>, <TokenType.TIMESTAMPNTZ: 150>, <TokenType.TIMESTAMP_S: 151>, <TokenType.TIMESTAMP_MS: 152>, <TokenType.TIMESTAMP_NS: 153>, <TokenType.DATETIME: 154>, <TokenType.DATETIME2: 155>, <TokenType.DATETIME64: 156>, <TokenType.SMALLDATETIME: 157>, <TokenType.DATE: 158>, <TokenType.DATE32: 159>, <TokenType.INT4RANGE: 160>, <TokenType.INT4MULTIRANGE: 161>, <TokenType.INT8RANGE: 162>, <TokenType.INT8MULTIRANGE: 163>, <TokenType.NUMRANGE: 164>, <TokenType.NUMMULTIRANGE: 165>, <TokenType.TSRANGE: 166>, <TokenType.TSMULTIRANGE: 167>, <TokenType.TSTZRANGE: 168>, <TokenType.TSTZMULTIRANGE: 169>, <TokenType.DATERANGE: 170>, <TokenType.DATEMULTIRANGE: 171>, <TokenType.UUID: 172>, <TokenType.GEOGRAPHY: 173>, <TokenType.GEOGRAPHYPOINT: 174>, <TokenType.NULLABLE: 175>, <TokenType.GEOMETRY: 176>, <TokenType.POINT: 177>, <TokenType.RING: 178>, <TokenType.LINESTRING: 179>, <TokenType.LOCALTIME: 180>, <TokenType.LOCALTIMESTAMP: 181>, <TokenType.MULTILINESTRING: 183>, <TokenType.POLYGON: 184>, <TokenType.MULTIPOLYGON: 185>, <TokenType.HLLSKETCH: 186>, <TokenType.HSTORE: 187>, <TokenType.SUPER: 188>, <TokenType.SERIAL: 189>, <TokenType.SMALLSERIAL: 190>, <TokenType.BIGSERIAL: 191>, <TokenType.XML: 192>, <TokenType.YEAR: 193>, <TokenType.USERDEFINED: 194>, <TokenType.MONEY: 195>, <TokenType.SMALLMONEY: 196>, <TokenType.ROWVERSION: 197>, <TokenType.IMAGE: 198>, <TokenType.VARIANT: 199>, <TokenType.OBJECT: 200>, <TokenType.INET: 201>, <TokenType.IPADDRESS: 202>, <TokenType.IPPREFIX: 203>, <TokenType.IPV4: 204>, <TokenType.IPV6: 205>, <TokenType.ENUM: 206>, <TokenType.ENUM8: 207>, <TokenType.ENUM16: 208>, <TokenType.FIXEDSTRING: 209>, <TokenType.LOWCARDINALITY: 210>, <TokenType.NESTED: 211>, <TokenType.AGGREGATEFUNCTION: 212>, <TokenType.SIMPLEAGGREGATEFUNCTION: 213>, <TokenType.TDIGEST: 214>, <TokenType.UNKNOWN: 215>, <TokenType.VECTOR: 216>, <TokenType.DYNAMIC: 217>, <TokenType.VOID: 218>, <TokenType.ALL: 221>, <TokenType.ANTI: 222>, <TokenType.ANY: 223>, <TokenType.APPLY: 224>, <TokenType.ARRAY: 225>, <TokenType.ASC: 226>, <TokenType.ATTACH: 228>, <TokenType.AUTO_INCREMENT: 229>, <TokenType.CACHE: 233>, <TokenType.CASE: 234>, <TokenType.COLLATE: 237>, <TokenType.COMMAND: 238>, <TokenType.COMMENT: 239>, <TokenType.COMMIT: 240>, <TokenType.CONSTRAINT: 242>, <TokenType.COPY: 243>, <TokenType.CUBE: 246>, <TokenType.CURRENT_DATE: 247>, <TokenType.CURRENT_DATETIME: 248>, <TokenType.CURRENT_SCHEMA: 249>, <TokenType.CURRENT_TIME: 250>, <TokenType.CURRENT_TIMESTAMP: 251>, <TokenType.CURRENT_USER: 252>, <TokenType.CURRENT_ROLE: 254>, <TokenType.CURRENT_CATALOG: 255>, <TokenType.DECLARE: 256>, <TokenType.DEFAULT: 257>, <TokenType.DELETE: 258>, <TokenType.DESC: 259>, <TokenType.DESCRIBE: 260>, <TokenType.DETACH: 261>, <TokenType.DICTIONARY: 262>, <TokenType.DIV: 265>, <TokenType.END: 268>, <TokenType.ESCAPE: 269>, <TokenType.EXECUTE: 271>, <TokenType.EXISTS: 272>, <TokenType.FALSE: 273>, <TokenType.FILE: 275>, <TokenType.FILE_FORMAT: 276>, <TokenType.FILTER: 277>, <TokenType.FINAL: 278>, <TokenType.FIRST: 279>, <TokenType.FOREIGN_KEY: 282>, <TokenType.FORMAT: 283>, <TokenType.FUNCTION: 286>, <TokenType.GET: 287>, <TokenType.INDEX: 298>, <TokenType.INTERVAL: 305>, <TokenType.IS: 309>, <TokenType.ISNULL: 310>, <TokenType.KEEP: 313>, <TokenType.KILL: 315>, <TokenType.LIMIT: 320>, <TokenType.LIST: 321>, <TokenType.LOAD: 322>, <TokenType.MAP: 324>, <TokenType.MATCH: 325>, <TokenType.MERGE: 329>, <TokenType.MODEL: 331>, <TokenType.NEXT: 333>, <TokenType.NOTHING: 334>, <TokenType.NULL: 336>, <TokenType.OBJECT_IDENTIFIER: 337>, <TokenType.OFFSET: 338>, <TokenType.OPERATOR: 341>, <TokenType.ORDINALITY: 345>, <TokenType.OUT: 346>, <TokenType.INOUT: 347>, <TokenType.OVER: 349>, <TokenType.OVERLAPS: 350>, <TokenType.OVERWRITE: 351>, <TokenType.PARTITION: 353>, <TokenType.PASTE: 355>, <TokenType.PERCENT: 356>, <TokenType.PIVOT: 357>, <TokenType.PRAGMA: 362>, <TokenType.PROCEDURE: 365>, <TokenType.PROJECTION: 367>, <TokenType.PSEUDO_TYPE: 368>, <TokenType.PUT: 369>, <TokenType.RANGE: 373>, <TokenType.RECURSIVE: 374>, <TokenType.REFRESH: 375>, <TokenType.RENAME: 376>, <TokenType.REPLACE: 377>, <TokenType.REFERENCES: 380>, <TokenType.ROLLUP: 385>, <TokenType.ROW: 386>, <TokenType.ROWS: 387>, <TokenType.SEMI: 390>, <TokenType.SEQUENCE: 392>, <TokenType.SET: 394>, <TokenType.SETTINGS: 395>, <TokenType.SHOW: 396>, <TokenType.SOME: 398>, <TokenType.STORAGE_INTEGRATION: 403>, <TokenType.STRAIGHT_JOIN: 404>, <TokenType.STRUCT: 405>, <TokenType.TAG: 408>, <TokenType.TEMPORARY: 409>, <TokenType.TOP: 410>, <TokenType.TRUE: 412>, <TokenType.TRUNCATE: 413>, <TokenType.TRIGGER: 414>, <TokenType.TYPE: 415>, <TokenType.UNNEST: 419>, <TokenType.UNPIVOT: 420>, <TokenType.UPDATE: 421>, <TokenType.USE: 422>, <TokenType.VIEW: 426>, <TokenType.SEMANTIC_VIEW: 427>, <TokenType.VOLATILE: 428>, <TokenType.UNIQUE: 434>, <TokenType.SINK: 439>, <TokenType.SOURCE: 440>, <TokenType.ANALYZE: 441>, <TokenType.NAMESPACE: 442>, <TokenType.EXPORT: 443>}

COMMENT_TABLE_ALIAS_TOKENS = {<TokenType.SESSION: 59>, <TokenType.SESSION_USER: 61>, <TokenType.IDENTIFIER: 79>, <TokenType.DATABASE: 80>, <TokenType.COLUMN: 81>, <TokenType.SCHEMA: 83>, <TokenType.TABLE: 84>, <TokenType.WAREHOUSE: 85>, <TokenType.STAGE: 86>, <TokenType.STREAM: 87>, <TokenType.STREAMLIT: 88>, <TokenType.VAR: 89>, <TokenType.BIT: 98>, <TokenType.BOOLEAN: 99>, <TokenType.TINYINT: 100>, <TokenType.UTINYINT: 101>, <TokenType.SMALLINT: 102>, <TokenType.USMALLINT: 103>, <TokenType.MEDIUMINT: 104>, <TokenType.UMEDIUMINT: 105>, <TokenType.INT: 106>, <TokenType.UINT: 107>, <TokenType.BIGINT: 108>, <TokenType.UBIGINT: 109>, <TokenType.BIGNUM: 110>, <TokenType.INT128: 111>, <TokenType.UINT128: 112>, <TokenType.INT256: 113>, <TokenType.UINT256: 114>, <TokenType.FLOAT: 115>, <TokenType.DOUBLE: 116>, <TokenType.UDOUBLE: 117>, <TokenType.DECIMAL: 118>, <TokenType.DECIMAL32: 119>, <TokenType.DECIMAL64: 120>, <TokenType.DECIMAL128: 121>, <TokenType.DECIMAL256: 122>, <TokenType.DECFLOAT: 123>, <TokenType.UDECIMAL: 124>, <TokenType.BIGDECIMAL: 125>, <TokenType.CHAR: 126>, <TokenType.NCHAR: 127>, <TokenType.VARCHAR: 128>, <TokenType.NVARCHAR: 129>, <TokenType.BPCHAR: 130>, <TokenType.TEXT: 131>, <TokenType.MEDIUMTEXT: 132>, <TokenType.LONGTEXT: 133>, <TokenType.BLOB: 134>, <TokenType.MEDIUMBLOB: 135>, <TokenType.LONGBLOB: 136>, <TokenType.TINYBLOB: 137>, <TokenType.TINYTEXT: 138>, <TokenType.NAME: 139>, <TokenType.BINARY: 140>, <TokenType.VARBINARY: 141>, <TokenType.JSON: 142>, <TokenType.JSONB: 143>, <TokenType.TIME: 144>, <TokenType.TIMETZ: 145>, <TokenType.TIME_NS: 146>, <TokenType.TIMESTAMP: 147>, <TokenType.TIMESTAMPTZ: 148>, <TokenType.TIMESTAMPLTZ: 149>, <TokenType.TIMESTAMPNTZ: 150>, <TokenType.TIMESTAMP_S: 151>, <TokenType.TIMESTAMP_MS: 152>, <TokenType.TIMESTAMP_NS: 153>, <TokenType.DATETIME: 154>, <TokenType.DATETIME2: 155>, <TokenType.DATETIME64: 156>, <TokenType.SMALLDATETIME: 157>, <TokenType.DATE: 158>, <TokenType.DATE32: 159>, <TokenType.INT4RANGE: 160>, <TokenType.INT4MULTIRANGE: 161>, <TokenType.INT8RANGE: 162>, <TokenType.INT8MULTIRANGE: 163>, <TokenType.NUMRANGE: 164>, <TokenType.NUMMULTIRANGE: 165>, <TokenType.TSRANGE: 166>, <TokenType.TSMULTIRANGE: 167>, <TokenType.TSTZRANGE: 168>, <TokenType.TSTZMULTIRANGE: 169>, <TokenType.DATERANGE: 170>, <TokenType.DATEMULTIRANGE: 171>, <TokenType.UUID: 172>, <TokenType.GEOGRAPHY: 173>, <TokenType.GEOGRAPHYPOINT: 174>, <TokenType.NULLABLE: 175>, <TokenType.GEOMETRY: 176>, <TokenType.POINT: 177>, <TokenType.RING: 178>, <TokenType.LINESTRING: 179>, <TokenType.LOCALTIME: 180>, <TokenType.LOCALTIMESTAMP: 181>, <TokenType.MULTILINESTRING: 183>, <TokenType.POLYGON: 184>, <TokenType.MULTIPOLYGON: 185>, <TokenType.HLLSKETCH: 186>, <TokenType.HSTORE: 187>, <TokenType.SUPER: 188>, <TokenType.SERIAL: 189>, <TokenType.SMALLSERIAL: 190>, <TokenType.BIGSERIAL: 191>, <TokenType.XML: 192>, <TokenType.YEAR: 193>, <TokenType.USERDEFINED: 194>, <TokenType.MONEY: 195>, <TokenType.SMALLMONEY: 196>, <TokenType.ROWVERSION: 197>, <TokenType.IMAGE: 198>, <TokenType.VARIANT: 199>, <TokenType.OBJECT: 200>, <TokenType.INET: 201>, <TokenType.IPADDRESS: 202>, <TokenType.IPPREFIX: 203>, <TokenType.IPV4: 204>, <TokenType.IPV6: 205>, <TokenType.ENUM: 206>, <TokenType.ENUM8: 207>, <TokenType.ENUM16: 208>, <TokenType.FIXEDSTRING: 209>, <TokenType.LOWCARDINALITY: 210>, <TokenType.NESTED: 211>, <TokenType.AGGREGATEFUNCTION: 212>, <TokenType.SIMPLEAGGREGATEFUNCTION: 213>, <TokenType.TDIGEST: 214>, <TokenType.UNKNOWN: 215>, <TokenType.VECTOR: 216>, <TokenType.DYNAMIC: 217>, <TokenType.VOID: 218>, <TokenType.ALL: 221>, <TokenType.ANY: 223>, <TokenType.APPLY: 224>, <TokenType.ARRAY: 225>, <TokenType.ASC: 226>, <TokenType.ATTACH: 228>, <TokenType.AUTO_INCREMENT: 229>, <TokenType.CACHE: 233>, <TokenType.CASE: 234>, <TokenType.COLLATE: 237>, <TokenType.COMMAND: 238>, <TokenType.COMMENT: 239>, <TokenType.COMMIT: 240>, <TokenType.CONSTRAINT: 242>, <TokenType.COPY: 243>, <TokenType.CUBE: 246>, <TokenType.CURRENT_DATE: 247>, <TokenType.CURRENT_DATETIME: 248>, <TokenType.CURRENT_SCHEMA: 249>, <TokenType.CURRENT_TIME: 250>, <TokenType.CURRENT_TIMESTAMP: 251>, <TokenType.CURRENT_USER: 252>, <TokenType.CURRENT_ROLE: 254>, <TokenType.CURRENT_CATALOG: 255>, <TokenType.DECLARE: 256>, <TokenType.DEFAULT: 257>, <TokenType.DELETE: 258>, <TokenType.DESC: 259>, <TokenType.DESCRIBE: 260>, <TokenType.DETACH: 261>, <TokenType.DICTIONARY: 262>, <TokenType.DIV: 265>, <TokenType.END: 268>, <TokenType.ESCAPE: 269>, <TokenType.EXECUTE: 271>, <TokenType.EXISTS: 272>, <TokenType.FALSE: 273>, <TokenType.FILE: 275>, <TokenType.FILE_FORMAT: 276>, <TokenType.FILTER: 277>, <TokenType.FINAL: 278>, <TokenType.FIRST: 279>, <TokenType.FOREIGN_KEY: 282>, <TokenType.FORMAT: 283>, <TokenType.FUNCTION: 286>, <TokenType.GET: 287>, <TokenType.INDEX: 298>, <TokenType.INTERVAL: 305>, <TokenType.ISNULL: 310>, <TokenType.KEEP: 313>, <TokenType.KILL: 315>, <TokenType.LIMIT: 320>, <TokenType.LIST: 321>, <TokenType.LOAD: 322>, <TokenType.MAP: 324>, <TokenType.MATCH: 325>, <TokenType.MERGE: 329>, <TokenType.MODEL: 331>, <TokenType.NEXT: 333>, <TokenType.NOTHING: 334>, <TokenType.NULL: 336>, <TokenType.OBJECT_IDENTIFIER: 337>, <TokenType.OFFSET: 338>, <TokenType.OPERATOR: 341>, <TokenType.ORDINALITY: 345>, <TokenType.OUT: 346>, <TokenType.INOUT: 347>, <TokenType.OVER: 349>, <TokenType.OVERLAPS: 350>, <TokenType.OVERWRITE: 351>, <TokenType.PARTITION: 353>, <TokenType.PASTE: 355>, <TokenType.PERCENT: 356>, <TokenType.PIVOT: 357>, <TokenType.PRAGMA: 362>, <TokenType.PROCEDURE: 365>, <TokenType.PROJECTION: 367>, <TokenType.PSEUDO_TYPE: 368>, <TokenType.PUT: 369>, <TokenType.RANGE: 373>, <TokenType.RECURSIVE: 374>, <TokenType.REFRESH: 375>, <TokenType.RENAME: 376>, <TokenType.REPLACE: 377>, <TokenType.REFERENCES: 380>, <TokenType.ROLLUP: 385>, <TokenType.ROW: 386>, <TokenType.ROWS: 387>, <TokenType.SEQUENCE: 392>, <TokenType.SET: 394>, <TokenType.SETTINGS: 395>, <TokenType.SHOW: 396>, <TokenType.SOME: 398>, <TokenType.STORAGE_INTEGRATION: 403>, <TokenType.STRAIGHT_JOIN: 404>, <TokenType.STRUCT: 405>, <TokenType.TAG: 408>, <TokenType.TEMPORARY: 409>, <TokenType.TOP: 410>, <TokenType.TRUE: 412>, <TokenType.TRUNCATE: 413>, <TokenType.TRIGGER: 414>, <TokenType.TYPE: 415>, <TokenType.UNNEST: 419>, <TokenType.UNPIVOT: 420>, <TokenType.UPDATE: 421>, <TokenType.USE: 422>, <TokenType.VIEW: 426>, <TokenType.SEMANTIC_VIEW: 427>, <TokenType.VOLATILE: 428>, <TokenType.UNIQUE: 434>, <TokenType.SINK: 439>, <TokenType.SOURCE: 440>, <TokenType.ANALYZE: 441>, <TokenType.NAMESPACE: 442>, <TokenType.EXPORT: 443>}

UPDATE_ALIAS_TOKENS = {<TokenType.SESSION: 59>, <TokenType.SESSION_USER: 61>, <TokenType.IDENTIFIER: 79>, <TokenType.DATABASE: 80>, <TokenType.COLUMN: 81>, <TokenType.SCHEMA: 83>, <TokenType.TABLE: 84>, <TokenType.WAREHOUSE: 85>, <TokenType.STAGE: 86>, <TokenType.STREAM: 87>, <TokenType.STREAMLIT: 88>, <TokenType.VAR: 89>, <TokenType.BIT: 98>, <TokenType.BOOLEAN: 99>, <TokenType.TINYINT: 100>, <TokenType.UTINYINT: 101>, <TokenType.SMALLINT: 102>, <TokenType.USMALLINT: 103>, <TokenType.MEDIUMINT: 104>, <TokenType.UMEDIUMINT: 105>, <TokenType.INT: 106>, <TokenType.UINT: 107>, <TokenType.BIGINT: 108>, <TokenType.UBIGINT: 109>, <TokenType.BIGNUM: 110>, <TokenType.INT128: 111>, <TokenType.UINT128: 112>, <TokenType.INT256: 113>, <TokenType.UINT256: 114>, <TokenType.FLOAT: 115>, <TokenType.DOUBLE: 116>, <TokenType.UDOUBLE: 117>, <TokenType.DECIMAL: 118>, <TokenType.DECIMAL32: 119>, <TokenType.DECIMAL64: 120>, <TokenType.DECIMAL128: 121>, <TokenType.DECIMAL256: 122>, <TokenType.DECFLOAT: 123>, <TokenType.UDECIMAL: 124>, <TokenType.BIGDECIMAL: 125>, <TokenType.CHAR: 126>, <TokenType.NCHAR: 127>, <TokenType.VARCHAR: 128>, <TokenType.NVARCHAR: 129>, <TokenType.BPCHAR: 130>, <TokenType.TEXT: 131>, <TokenType.MEDIUMTEXT: 132>, <TokenType.LONGTEXT: 133>, <TokenType.BLOB: 134>, <TokenType.MEDIUMBLOB: 135>, <TokenType.LONGBLOB: 136>, <TokenType.TINYBLOB: 137>, <TokenType.TINYTEXT: 138>, <TokenType.NAME: 139>, <TokenType.BINARY: 140>, <TokenType.VARBINARY: 141>, <TokenType.JSON: 142>, <TokenType.JSONB: 143>, <TokenType.TIME: 144>, <TokenType.TIMETZ: 145>, <TokenType.TIME_NS: 146>, <TokenType.TIMESTAMP: 147>, <TokenType.TIMESTAMPTZ: 148>, <TokenType.TIMESTAMPLTZ: 149>, <TokenType.TIMESTAMPNTZ: 150>, <TokenType.TIMESTAMP_S: 151>, <TokenType.TIMESTAMP_MS: 152>, <TokenType.TIMESTAMP_NS: 153>, <TokenType.DATETIME: 154>, <TokenType.DATETIME2: 155>, <TokenType.DATETIME64: 156>, <TokenType.SMALLDATETIME: 157>, <TokenType.DATE: 158>, <TokenType.DATE32: 159>, <TokenType.INT4RANGE: 160>, <TokenType.INT4MULTIRANGE: 161>, <TokenType.INT8RANGE: 162>, <TokenType.INT8MULTIRANGE: 163>, <TokenType.NUMRANGE: 164>, <TokenType.NUMMULTIRANGE: 165>, <TokenType.TSRANGE: 166>, <TokenType.TSMULTIRANGE: 167>, <TokenType.TSTZRANGE: 168>, <TokenType.TSTZMULTIRANGE: 169>, <TokenType.DATERANGE: 170>, <TokenType.DATEMULTIRANGE: 171>, <TokenType.UUID: 172>, <TokenType.GEOGRAPHY: 173>, <TokenType.GEOGRAPHYPOINT: 174>, <TokenType.NULLABLE: 175>, <TokenType.GEOMETRY: 176>, <TokenType.POINT: 177>, <TokenType.RING: 178>, <TokenType.LINESTRING: 179>, <TokenType.LOCALTIME: 180>, <TokenType.LOCALTIMESTAMP: 181>, <TokenType.MULTILINESTRING: 183>, <TokenType.POLYGON: 184>, <TokenType.MULTIPOLYGON: 185>, <TokenType.HLLSKETCH: 186>, <TokenType.HSTORE: 187>, <TokenType.SUPER: 188>, <TokenType.SERIAL: 189>, <TokenType.SMALLSERIAL: 190>, <TokenType.BIGSERIAL: 191>, <TokenType.XML: 192>, <TokenType.YEAR: 193>, <TokenType.USERDEFINED: 194>, <TokenType.MONEY: 195>, <TokenType.SMALLMONEY: 196>, <TokenType.ROWVERSION: 197>, <TokenType.IMAGE: 198>, <TokenType.VARIANT: 199>, <TokenType.OBJECT: 200>, <TokenType.INET: 201>, <TokenType.IPADDRESS: 202>, <TokenType.IPPREFIX: 203>, <TokenType.IPV4: 204>, <TokenType.IPV6: 205>, <TokenType.ENUM: 206>, <TokenType.ENUM8: 207>, <TokenType.ENUM16: 208>, <TokenType.FIXEDSTRING: 209>, <TokenType.LOWCARDINALITY: 210>, <TokenType.NESTED: 211>, <TokenType.AGGREGATEFUNCTION: 212>, <TokenType.SIMPLEAGGREGATEFUNCTION: 213>, <TokenType.TDIGEST: 214>, <TokenType.UNKNOWN: 215>, <TokenType.VECTOR: 216>, <TokenType.DYNAMIC: 217>, <TokenType.VOID: 218>, <TokenType.ALL: 221>, <TokenType.ANY: 223>, <TokenType.APPLY: 224>, <TokenType.ARRAY: 225>, <TokenType.ASC: 226>, <TokenType.ATTACH: 228>, <TokenType.AUTO_INCREMENT: 229>, <TokenType.CACHE: 233>, <TokenType.CASE: 234>, <TokenType.COLLATE: 237>, <TokenType.COMMAND: 238>, <TokenType.COMMENT: 239>, <TokenType.COMMIT: 240>, <TokenType.CONSTRAINT: 242>, <TokenType.COPY: 243>, <TokenType.CUBE: 246>, <TokenType.CURRENT_DATE: 247>, <TokenType.CURRENT_DATETIME: 248>, <TokenType.CURRENT_SCHEMA: 249>, <TokenType.CURRENT_TIME: 250>, <TokenType.CURRENT_TIMESTAMP: 251>, <TokenType.CURRENT_USER: 252>, <TokenType.CURRENT_ROLE: 254>, <TokenType.CURRENT_CATALOG: 255>, <TokenType.DECLARE: 256>, <TokenType.DEFAULT: 257>, <TokenType.DELETE: 258>, <TokenType.DESC: 259>, <TokenType.DESCRIBE: 260>, <TokenType.DETACH: 261>, <TokenType.DICTIONARY: 262>, <TokenType.DIV: 265>, <TokenType.END: 268>, <TokenType.ESCAPE: 269>, <TokenType.EXECUTE: 271>, <TokenType.EXISTS: 272>, <TokenType.FALSE: 273>, <TokenType.FILE: 275>, <TokenType.FILE_FORMAT: 276>, <TokenType.FILTER: 277>, <TokenType.FINAL: 278>, <TokenType.FIRST: 279>, <TokenType.FOREIGN_KEY: 282>, <TokenType.FORMAT: 283>, <TokenType.FUNCTION: 286>, <TokenType.GET: 287>, <TokenType.INDEX: 298>, <TokenType.INTERVAL: 305>, <TokenType.IS: 309>, <TokenType.ISNULL: 310>, <TokenType.KEEP: 313>, <TokenType.KILL: 315>, <TokenType.LIMIT: 320>, <TokenType.LIST: 321>, <TokenType.LOAD: 322>, <TokenType.MAP: 324>, <TokenType.MATCH: 325>, <TokenType.MERGE: 329>, <TokenType.MODEL: 331>, <TokenType.NEXT: 333>, <TokenType.NOTHING: 334>, <TokenType.NULL: 336>, <TokenType.OBJECT_IDENTIFIER: 337>, <TokenType.OFFSET: 338>, <TokenType.OPERATOR: 341>, <TokenType.ORDINALITY: 345>, <TokenType.OUT: 346>, <TokenType.INOUT: 347>, <TokenType.OVER: 349>, <TokenType.OVERLAPS: 350>, <TokenType.OVERWRITE: 351>, <TokenType.PARTITION: 353>, <TokenType.PASTE: 355>, <TokenType.PERCENT: 356>, <TokenType.PIVOT: 357>, <TokenType.PRAGMA: 362>, <TokenType.PROCEDURE: 365>, <TokenType.PROJECTION: 367>, <TokenType.PSEUDO_TYPE: 368>, <TokenType.PUT: 369>, <TokenType.RANGE: 373>, <TokenType.RECURSIVE: 374>, <TokenType.REFRESH: 375>, <TokenType.RENAME: 376>, <TokenType.REPLACE: 377>, <TokenType.REFERENCES: 380>, <TokenType.ROLLUP: 385>, <TokenType.ROW: 386>, <TokenType.ROWS: 387>, <TokenType.SEQUENCE: 392>, <TokenType.SETTINGS: 395>, <TokenType.SHOW: 396>, <TokenType.SOME: 398>, <TokenType.STORAGE_INTEGRATION: 403>, <TokenType.STRAIGHT_JOIN: 404>, <TokenType.STRUCT: 405>, <TokenType.TAG: 408>, <TokenType.TEMPORARY: 409>, <TokenType.TOP: 410>, <TokenType.TRUE: 412>, <TokenType.TRUNCATE: 413>, <TokenType.TRIGGER: 414>, <TokenType.TYPE: 415>, <TokenType.UNNEST: 419>, <TokenType.UNPIVOT: 420>, <TokenType.UPDATE: 421>, <TokenType.USE: 422>, <TokenType.VIEW: 426>, <TokenType.SEMANTIC_VIEW: 427>, <TokenType.VOLATILE: 428>, <TokenType.UNIQUE: 434>, <TokenType.SINK: 439>, <TokenType.SOURCE: 440>, <TokenType.ANALYZE: 441>, <TokenType.NAMESPACE: 442>, <TokenType.EXPORT: 443>}

FUNCTIONS = {'AI_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.AIAgg'>>, 'AI_CLASSIFY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIClassify'>>, 'AI_EMBED': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIEmbed'>>, 'A_I_FORECAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIForecast'>>, 'AI_GENERATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIGenerate'>>, 'AI_SIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AISimilarity'>>, 'AI_SUMMARIZE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.AISummarizeAgg'>>, 'ABS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Abs'>>, 'ACOS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Acos'>>, 'ACOSH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Acosh'>>, 'ADD_MONTHS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.AddMonths'>>, 'AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Agg'>>, 'AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.And'>>, 'ANONYMOUS_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.AnonymousAggFunc'>>, 'ANY_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.AnyValue'>>, 'APPLY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Apply'>>, 'APPROX_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.ApproxDistinct'>>, 'APPROX_COUNT_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.ApproxDistinct'>>, 'APPROX_PERCENTILE_ACCUMULATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxPercentileAccumulate'>>, 'APPROX_PERCENTILE_COMBINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxPercentileCombine'>>, 'APPROX_PERCENTILE_ESTIMATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxPercentileEstimate'>>, 'APPROX_QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxQuantile'>>, 'APPROX_QUANTILES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxQuantiles'>>, 'APPROX_TOP_K': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopK'>>, 'APPROX_TOP_K_ACCUMULATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopKAccumulate'>>, 'APPROX_TOP_K_COMBINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopKCombine'>>, 'APPROX_TOP_K_ESTIMATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopKEstimate'>>, 'APPROX_TOP_SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopSum'>>, 'APPROXIMATE_SIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproximateSimilarity'>>, 'APPROXIMATE_JACCARD_INDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproximateSimilarity'>>, 'ARG_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMax'>>, 'ARGMAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMax'>>, 'MAX_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMax'>>, 'ARG_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMin'>>, 'ARGMIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMin'>>, 'MIN_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMin'>>, 'ARRAY': <function Parser.<lambda>>, 'ARRAY_AGG': <function Parser.<lambda>>, 'ARRAY_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayAll'>>, 'ARRAY_ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayAny'>>, 'ARRAY_APPEND': <function build_array_append>, 'ARRAY_COMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayCompact'>>, 'ARRAY_CONCAT': <function build_array_concat>, 'ARRAY_CAT': <function build_array_concat>, 'ARRAY_CONCAT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArrayConcatAgg'>>, 'ARRAY_CONSTRUCT_COMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayConstructCompact'>>, 'ARRAY_CONTAINED_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContainedBy'>>, 'ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContains'>>, 'ARRAY_HAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContains'>>, 'ARRAY_CONTAINS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContainsAll'>>, 'ARRAY_HAS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContainsAll'>>, 'ARRAY_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayDistinct'>>, 'ARRAY_EXCEPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayExcept'>>, 'FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayFilter'>>, 'ARRAY_FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayFilter'>>, 'ARRAY_FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayFirst'>>, 'ARRAY_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayInsert'>>, 'ARRAY_INTERSECT': <function Parser.<lambda>>, 'ARRAY_INTERSECTION': <function Parser.<lambda>>, 'ARRAY_LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayLast'>>, 'ARRAY_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayMax'>>, 'ARRAY_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayMin'>>, 'ARRAY_OVERLAPS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayOverlaps'>>, 'ARRAY_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayPosition'>>, 'ARRAY_PREPEND': <function build_array_prepend>, 'ARRAY_REMOVE': <function build_array_remove>, 'ARRAY_REMOVE_AT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayRemoveAt'>>, 'ARRAY_REVERSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayReverse'>>, 'ARRAY_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySize'>>, 'ARRAY_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySize'>>, 'ARRAY_SLICE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySlice'>>, 'ARRAY_SORT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySort'>>, 'ARRAY_SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySum'>>, 'ARRAY_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayToString'>>, 'ARRAY_JOIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayToString'>>, 'ARRAY_UNION_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArrayUnionAgg'>>, 'ARRAY_UNIQUE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArrayUniqueAgg'>>, 'ARRAYS_ZIP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraysZip'>>, 'ASCII': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Ascii'>>, 'ASIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Asin'>>, 'ASINH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Asinh'>>, 'ATAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Atan'>>, 'ATAN2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Atan2'>>, 'ATANH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Atanh'>>, 'AVG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Avg'>>, 'BASE64_DECODE_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Base64DecodeBinary'>>, 'BASE64_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Base64DecodeString'>>, 'BASE64_ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Base64Encode'>>, 'BIT_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.BitLength'>>, 'BITMAP_BIT_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapBitPosition'>>, 'BITMAP_BUCKET_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapBucketNumber'>>, 'BITMAP_CONSTRUCT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapConstructAgg'>>, 'BITMAP_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapCount'>>, 'BITMAP_OR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapOrAgg'>>, 'BITWISE_AND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseAndAgg'>>, 'BITWISE_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseCount'>>, 'BITWISE_OR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseOrAgg'>>, 'BITWISE_XOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseXorAgg'>>, 'BOOLAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Booland'>>, 'BOOLNOT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Boolnot'>>, 'BOOLOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Boolor'>>, 'BOOLXOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BoolxorAgg'>>, 'BYTE_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ByteLength'>>, 'CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Case'>>, 'CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Cast'>>, 'CAST_TO_STR_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CastToStrType'>>, 'CBRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cbrt'>>, 'CEIL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Ceil'>>, 'CEILING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Ceil'>>, 'CHECK_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.CheckJson'>>, 'CHECK_XML': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CheckXml'>>, 'CHR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Chr'>>, 'CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Chr'>>, 'CITY_HASH64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.CityHash64'>>, 'COALESCE': <function build_coalesce>, 'IFNULL': <function build_coalesce>, 'NVL': <function build_coalesce>, 'CODE_POINTS_TO_BYTES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.CodePointsToBytes'>>, 'CODE_POINTS_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.CodePointsToString'>>, 'COLLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Collate'>>, 'COLLATION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Collation'>>, 'COLUMNS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Columns'>>, 'COMBINED_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.CombinedAggFunc'>>, 'COMBINED_PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.CombinedParameterizedAgg'>>, 'COMPRESS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Compress'>>, 'CONCAT': <function Parser.<lambda>>, 'CONCAT_WS': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ConnectByRoot'>>, 'CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Contains'>>, 'CONVERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Convert'>>, 'CONVERT_TIMEZONE': <function build_convert_timezone>, 'CONVERT_TO_CHARSET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ConvertToCharset'>>, 'CORR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Corr'>>, 'COS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cos'>>, 'COSH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cosh'>>, 'COSINE_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.CosineDistance'>>, 'COT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cot'>>, 'COTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Coth'>>, 'COUNT': <function TSQLParser.<lambda>>, 'COUNT_IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CountIf'>>, 'COUNTIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CountIf'>>, 'COVAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CovarPop'>>, 'COVAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CovarSamp'>>, 'CSC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Csc'>>, 'CSCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Csch'>>, 'CUME_DIST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CumeDist'>>, 'CURRENT_ACCOUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentAccount'>>, 'CURRENT_ACCOUNT_NAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentAccountName'>>, 'CURRENT_AVAILABLE_ROLES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentAvailableRoles'>>, 'CURRENT_CATALOG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentCatalog'>>, 'CURRENT_CLIENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentClient'>>, 'CURRENT_DATABASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentDatabase'>>, 'CURRENT_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentDate'>>, 'CURRENT_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentDatetime'>>, 'CURRENT_IP_ADDRESS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentIpAddress'>>, 'CURRENT_ORGANIZATION_NAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentOrganizationName'>>, 'CURRENT_ORGANIZATION_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentOrganizationUser'>>, 'CURRENT_REGION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentRegion'>>, 'CURRENT_ROLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentRole'>>, 'CURRENT_ROLE_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentRoleType'>>, 'CURRENT_SCHEMA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSchema'>>, 'CURRENT_SCHEMAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSchemas'>>, 'CURRENT_SECONDARY_ROLES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSecondaryRoles'>>, 'CURRENT_SESSION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSession'>>, 'CURRENT_STATEMENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentStatement'>>, 'CURRENT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTime'>>, 'CURRENT_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTimestamp'>>, 'CURRENT_TIMESTAMP_L_T_Z': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTimestampLTZ'>>, 'CURRENT_TIMEZONE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTimezone'>>, 'CURRENT_TRANSACTION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentTransaction'>>, 'CURRENT_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentUser'>>, 'CURRENT_USER_ID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentUserId'>>, 'CURRENT_VERSION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentVersion'>>, 'CURRENT_WAREHOUSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentWarehouse'>>, 'DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Date'>>, 'DATE_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateAdd'>>, 'DATE_BIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateBin'>>, 'DATEDIFF': <function _build_date_delta.<locals>._builder>, 'DATE_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateDiff'>>, 'DATE_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateFromParts'>>, 'DATEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateFromParts'>>, 'DATE_FROM_UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateFromUnixDate'>>, 'DATE_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateStrToDate'>>, 'DATE_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateSub'>>, 'DATE_TO_DATE_STR': <function Parser.<lambda>>, 'DATE_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateToDi'>>, 'DATE_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateTrunc'>>, 'DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Datetime'>>, 'DATETIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeAdd'>>, 'DATETIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeDiff'>>, 'DATETIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeSub'>>, 'DATETIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeTrunc'>>, 'DAY': <function TSQLParser.<lambda>>, 'DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfMonth'>>, 'DAYOFMONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfMonth'>>, 'DAY_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeek'>>, 'DAYOFWEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeek'>>, 'DAYOFWEEK_ISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeekIso'>>, 'ISODOW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeekIso'>>, 'DAY_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfYear'>>, 'DAYOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfYear'>>, 'DAYNAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Dayname'>>, 'DECODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Decode'>>, 'DECODE_CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.DecodeCase'>>, 'DECOMPRESS_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.DecompressBinary'>>, 'DECOMPRESS_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.DecompressString'>>, 'DECRYPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Decrypt'>>, 'DECRYPT_RAW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.DecryptRaw'>>, 'DEGREES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Degrees'>>, 'DENSE_RANK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.DenseRank'>>, 'DI_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DiToDate'>>, 'DOT_PRODUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.DotProduct'>>, 'DYNAMIC_IDENTIFIER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.DynamicIdentifier'>>, 'ELT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Elt'>>, 'ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Encode'>>, 'ENCRYPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Encrypt'>>, 'ENCRYPT_RAW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.EncryptRaw'>>, 'ENDS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.EndsWith'>>, 'ENDSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.EndsWith'>>, 'EQUAL_NULL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.EqualNull'>>, 'EUCLIDEAN_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.EuclideanDistance'>>, 'EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Exists'>>, 'EXP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Exp'>>, 'EXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Explode'>>, 'EXPLODING_GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ExplodingGenerateSeries'>>, 'EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Extract'>>, 'FACTORIAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Factorial'>>, 'FARM_FINGERPRINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FarmFingerprint'>>, 'FARMFINGERPRINT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FarmFingerprint'>>, 'FEATURES_AT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.FeaturesAtTime'>>, 'FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.First'>>, 'FIRST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.FirstValue'>>, 'FLATTEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Flatten'>>, 'FLOAT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Float64'>>, 'FLOOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Floor'>>, 'FORMAT': <function _build_format>, 'FROM_BASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FromBase'>>, 'FROM_BASE32': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FromBase32'>>, 'FROM_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FromBase64'>>, 'FROM_ISO8601_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.FromISO8601Date'>>, 'FROM_ISO8601_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.FromISO8601Timestamp'>>, 'FROM_ISO8601_TIMESTAMP_NANOS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.FromISO8601TimestampNanos'>>, 'FROM_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.FromJson'>>, 'GAP_FILL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.GapFill'>>, 'GENERATE_BOOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateBool'>>, 'GENERATE_DATE_ARRAY': <function Parser.<lambda>>, 'GENERATE_DOUBLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateDouble'>>, 'GENERATE_EMBEDDING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateEmbedding'>>, 'GENERATE_INT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateInt'>>, 'GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.GenerateSeries'>>, 'GENERATE_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateTable'>>, 'GENERATE_TEXT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateText'>>, 'GENERATE_TIMESTAMP_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.GenerateTimestampArray'>>, 'GENERATOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Generator'>>, 'GET_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.GetExtract'>>, 'GET_IGNORE_CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GetIgnoreCase'>>, 'GETBIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Getbit'>>, 'GET_BIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Getbit'>>, 'GREATEST': <function Parser.<lambda>>, 'GROUP_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.GroupConcat'>>, 'GROUPING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Grouping'>>, 'GROUPING_ID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.GroupingId'>>, 'HASH_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.HashAgg'>>, 'HEX': <function build_hex>, 'HEX_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.HexDecodeString'>>, 'HLL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Hll'>>, 'HOST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Host'>>, 'HOUR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Hour'>>, 'IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.If'>>, 'IIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.If'>>, 'INITCAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Initcap'>>, 'INLINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Inline'>>, 'INT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Int64'>>, 'IS_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.IsArray'>>, 'IS_ASCII': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.IsAscii'>>, 'IS_INF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsInf'>>, 'ISINF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsInf'>>, 'IS_NAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsNan'>>, 'ISNAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsNan'>>, 'IS_NULL_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.IsNullValue'>>, 'J_S_O_N_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArray'>>, 'J_S_O_N_ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayAgg'>>, 'JSON_ARRAY_APPEND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayAppend'>>, 'JSON_ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayContains'>>, 'JSON_ARRAY_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayInsert'>>, 'JSONB_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBContains'>>, 'J_S_O_N_B_CONTAINS_ALL_TOP_KEYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBContainsAllTopKeys'>>, 'J_S_O_N_B_CONTAINS_ANY_TOP_KEYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBContainsAnyTopKeys'>>, 'J_S_O_N_B_CONTAINS_TOP_KEY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBContainsTopKey'>>, 'J_S_O_N_B_DELETE_AT_PATH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBDeleteAtPath'>>, 'JSONB_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBExists'>>, 'JSONB_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBExtract'>>, 'JSONB_EXTRACT_SCALAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBExtractScalar'>>, 'J_S_O_N_B_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBObjectAgg'>>, 'J_S_O_N_B_PATH_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBPathExists'>>, 'J_S_O_N_BOOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBool'>>, 'J_S_O_N_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.JSONCast'>>, 'J_S_O_N_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONExists'>>, 'JSON_EXTRACT': <function build_extract_json_with_path.<locals>._builder>, 'JSON_EXTRACT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONExtractArray'>>, 'JSON_EXTRACT_SCALAR': <function build_extract_json_with_path.<locals>._builder>, 'JSON_FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONFormat'>>, 'JSON_KEYS': <function Parser.<lambda>>, 'J_S_O_N_KEYS_AT_DEPTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONKeysAtDepth'>>, 'J_S_O_N_OBJECT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONObject'>>, 'J_S_O_N_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONObjectAgg'>>, 'JSON_REMOVE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONRemove'>>, 'JSON_SET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONSet'>>, 'JSON_STRIP_NULLS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONStripNulls'>>, 'J_S_O_N_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONTable'>>, 'JSON_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONType'>>, 'J_S_O_N_VALUE_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.query.JSONValueArray'>>, 'JAROWINKLER_SIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.JarowinklerSimilarity'>>, 'JUSTIFY_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.JustifyDays'>>, 'JUSTIFY_HOURS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.JustifyHours'>>, 'JUSTIFY_INTERVAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.JustifyInterval'>>, 'KURTOSIS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Kurtosis'>>, 'LAG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Lag'>>, 'LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Last'>>, 'LAST_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.LastDay'>>, 'LAST_DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.LastDay'>>, 'LAST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LastValue'>>, 'LAX_BOOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxBool'>>, 'LAX_FLOAT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxFloat64'>>, 'LAX_INT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxInt64'>>, 'LAX_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxString'>>, 'LEAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Lead'>>, 'LEAST': <function Parser.<lambda>>, 'LEFT': <function _build_with_arg_as_text.<locals>._parse>, 'LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Length'>>, 'LEN': <function _build_with_arg_as_text.<locals>._parse>, 'CHAR_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Length'>>, 'CHARACTER_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Length'>>, 'LEVENSHTEIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Levenshtein'>>, 'LIST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.List'>>, 'LN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Ln'>>, 'LOCALTIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Localtime'>>, 'LOCALTIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Localtimestamp'>>, 'LOG': <function build_logarithm>, 'LOGICAL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalAnd'>>, 'BOOL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalAnd'>>, 'BOOLAND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalAnd'>>, 'LOGICAL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalOr'>>, 'BOOL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalOr'>>, 'BOOLOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalOr'>>, 'LOWER': <function build_lower>, 'LCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Lower'>>, 'LOWER_HEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.LowerHex'>>, 'MD5': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5'>>, 'MD5_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5Digest'>>, 'M_D5_NUMBER_LOWER64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5NumberLower64'>>, 'M_D5_NUMBER_UPPER64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5NumberUpper64'>>, 'M_L_FORECAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.MLForecast'>>, 'M_L_TRANSLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.MLTranslate'>>, 'MAKE_INTERVAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.MakeInterval'>>, 'MANHATTAN_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.ManhattanDistance'>>, 'MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Map'>>, 'MAP_CAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapCat'>>, 'MAP_CONTAINS_KEY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapContainsKey'>>, 'MAP_DELETE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapDelete'>>, 'MAP_FROM_ENTRIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapFromEntries'>>, 'MAP_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapInsert'>>, 'MAP_KEYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapKeys'>>, 'MAP_PICK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapPick'>>, 'MAP_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapSize'>>, 'MATCH_AGAINST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MatchAgainst'>>, 'MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Max'>>, 'MEDIAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Median'>>, 'MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Min'>>, 'MINHASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Minhash'>>, 'MINHASH_COMBINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.MinhashCombine'>>, 'MINUTE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Minute'>>, 'MODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Mode'>>, 'MONTH': <function TSQLParser.<lambda>>, 'MONTHNAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Monthname'>>, 'MONTHS_BETWEEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.MonthsBetween'>>, 'NANVL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Nanvl'>>, 'NEGATIVE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Negative'>>, 'NET_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.NetFunc'>>, 'NEXT_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.NextDay'>>, 'NEXT_VALUE_FOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ddl.NextValueFor'>>, 'NORMAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Normal'>>, 'NORMALIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Normalize'>>, 'NTH_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.NthValue'>>, 'NTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Ntile'>>, 'NULLIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Nullif'>>, 'NUMBER_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.NumberToStr'>>, 'NVL2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Nvl2'>>, 'OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ObjectAgg'>>, 'OBJECT_ID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ObjectId'>>, 'OBJECT_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ObjectInsert'>>, 'OBJECT_TRANSFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ObjectTransform'>>, 'OPEN_J_S_O_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.OpenJSON'>>, 'OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Or'>>, 'OVERLAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Overlay'>>, 'PAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Pad'>>, 'PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.ParameterizedAgg'>>, 'PARSE_BIGNUMERIC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ParseBignumeric'>>, 'PARSE_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.ParseDatetime'>>, 'PARSE_IP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ParseIp'>>, 'PARSE_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ParseJSON'>>, 'JSON_PARSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ParseJSON'>>, 'PARSE_NUMERIC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ParseNumeric'>>, 'PARSE_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.ParseTime'>>, 'PARSE_URL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ParseUrl'>>, 'PERCENT_RANK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.PercentRank'>>, 'PERCENTILE_CONT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.PercentileCont'>>, 'PERCENTILE_DISC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.PercentileDisc'>>, 'PI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Pi'>>, 'POSEXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Posexplode'>>, 'POSEXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.PosexplodeOuter'>>, 'POWER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Pow'>>, 'POW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Pow'>>, 'PREDICT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Predict'>>, 'PREVIOUS_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.PreviousDay'>>, 'QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Quantile'>>, 'QUARTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Quarter'>>, 'RADIANS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Radians'>>, 'RAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Rand'>>, 'RANDOM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Rand'>>, 'RANDN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Randn'>>, 'RANDSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Randstr'>>, 'RANGE_BUCKET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.RangeBucket'>>, 'RANGE_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.RangeN'>>, 'RANK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Rank'>>, 'READ_CSV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ReadCSV'>>, 'READ_PARQUET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ReadParquet'>>, 'REDUCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Reduce'>>, 'REG_DOMAIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.RegDomain'>>, 'REGEXP_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpCount'>>, 'REGEXP_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpExtract'>>, 'REGEXP_EXTRACT_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpExtractAll'>>, 'REGEXP_FULL_MATCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpFullMatch'>>, 'REGEXP_I_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpILike'>>, 'REGEXP_INSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpInstr'>>, 'REGEXP_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.RegexpLike'>>, 'REGEXP_REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpReplace'>>, 'REGEXP_SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpSplit'>>, 'REGEXP_SUBSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpSubstr'>>, 'REGR_AVGX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrAvgx'>>, 'REGR_AVGY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrAvgy'>>, 'REGR_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrCount'>>, 'REGR_INTERCEPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrIntercept'>>, 'REGR_R2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrR2'>>, 'REGR_SLOPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSlope'>>, 'REGR_SXX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSxx'>>, 'REGR_SXY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSxy'>>, 'REGR_SYY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSyy'>>, 'REGR_VALX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrValx'>>, 'REGR_VALY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrValy'>>, 'REPEAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Repeat'>>, 'REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Replace'>>, 'REVERSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Reverse'>>, 'RIGHT': <function _build_with_arg_as_text.<locals>._parse>, 'RINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Rint'>>, 'ROUND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Round'>>, 'ROW_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RowNumber'>>, 'RTRIMMED_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RtrimmedLength'>>, 'SHA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA'>>, 'SHA1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA'>>, 'S_H_A1_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA1Digest'>>, 'SHA2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA2'>>, 'S_H_A2_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA2Digest'>>, 'SAFE_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeAdd'>>, 'SAFE_CONVERT_BYTES_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SafeConvertBytesToString'>>, 'SAFE_DIVIDE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeDivide'>>, 'SAFE_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.SafeFunc'>>, 'SAFE_MULTIPLY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeMultiply'>>, 'SAFE_NEGATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeNegate'>>, 'SAFE_SUBTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeSubtract'>>, 'SEARCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Search'>>, 'SEARCH_IP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SearchIp'>>, 'SEC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sec'>>, 'SECH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sech'>>, 'SECOND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Second'>>, 'SECRET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Secret'>>, 'SEQ1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq1'>>, 'SEQ2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq2'>>, 'SEQ4': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq4'>>, 'SEQ8': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq8'>>, 'SESSION_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.SessionUser'>>, 'SHUFFLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Shuffle'>>, 'SIGN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sign'>>, 'SIGNUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sign'>>, 'SIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sin'>>, 'SINH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sinh'>>, 'SKEWNESS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Skewness'>>, 'SOUNDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Soundex'>>, 'SOUNDEX_P123': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SoundexP123'>>, 'SPACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Space'>>, 'SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Split'>>, 'SPLIT_PART': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SplitPart'>>, 'SPLIT_TO_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.SplitToTable'>>, 'SQRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sqrt'>>, 'ST_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StDistance'>>, 'ST_POINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StPoint'>>, 'ST_MAKEPOINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StPoint'>>, 'STACK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Stack'>>, 'STANDARD_HASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StandardHash'>>, 'STAR_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StarMap'>>, 'STARTS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StartsWith'>>, 'STARTSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StartsWith'>>, 'STDDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Stddev'>>, 'STDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Stddev'>>, 'STDDEV_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.StddevPop'>>, 'STDDEV_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.StddevSamp'>>, 'STR_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StrPosition'>>, 'STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.StrToDate'>>, 'STR_TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StrToMap'>>, 'STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.StrToTime'>>, 'STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.StrToUnix'>>, 'STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.String'>>, 'STRING_TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StringToArray'>>, 'SPLIT_BY_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StringToArray'>>, 'STRIP_NULL_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.StripNullValue'>>, 'STRTOK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Strtok'>>, 'STRTOK_TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StrtokToArray'>>, 'STRUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Struct'>>, 'STRUCT_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StructExtract'>>, 'STUFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Stuff'>>, 'INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Stuff'>>, 'SUBSTRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Substring'>>, 'SUBSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Substring'>>, 'SUBSTRING_INDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SubstringIndex'>>, 'SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Sum'>>, 'SYSTIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Systimestamp'>>, 'TAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Tan'>>, 'TANH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Tanh'>>, 'TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Time'>>, 'TIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeAdd'>>, 'TIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeDiff'>>, 'TIME_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeFromParts'>>, 'TIMEFROMPARTS': <function _build_timefromparts>, 'TIME_SLICE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeSlice'>>, 'TIME_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeStrToDate'>>, 'TIME_STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeStrToTime'>>, 'TIME_STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeStrToUnix'>>, 'TIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeSub'>>, 'TIME_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeToStr'>>, 'TIME_TO_TIME_STR': <function Parser.<lambda>>, 'TIME_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeToUnix'>>, 'TIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeTrunc'>>, 'TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Timestamp'>>, 'TIMESTAMP_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampAdd'>>, 'TIMESTAMPDIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampDiff'>>, 'TIMESTAMP_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampDiff'>>, 'TIMESTAMP_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampFromParts'>>, 'TIMESTAMPFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampFromParts'>>, 'TIMESTAMP_LTZ_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampLtzFromParts'>>, 'TIMESTAMPLTZFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampLtzFromParts'>>, 'TIMESTAMP_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampSub'>>, 'TIMESTAMP_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampTrunc'>>, 'TIMESTAMP_TZ_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampTzFromParts'>>, 'TIMESTAMPTZFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampTzFromParts'>>, 'TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ToArray'>>, 'TO_BASE32': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToBase32'>>, 'TO_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToBase64'>>, 'TO_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToBinary'>>, 'TO_BOOLEAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ToBoolean'>>, 'TO_CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToChar'>>, 'TO_CODE_POINTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToCodePoints'>>, 'TO_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.ToDays'>>, 'TO_DECFLOAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToDecfloat'>>, 'TO_DOUBLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToDouble'>>, 'TO_FILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToFile'>>, 'TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ToMap'>>, 'TO_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToNumber'>>, 'TO_VARIANT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ToVariant'>>, 'TRANSFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Transform'>>, 'TRANSLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Translate'>>, 'TRIM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Trim'>>, 'TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Trunc'>>, 'TRUNCATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Trunc'>>, 'TRY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Try'>>, 'TRY_BASE64_DECODE_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryBase64DecodeBinary'>>, 'TRY_BASE64_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryBase64DecodeString'>>, 'TRY_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.TryCast'>>, 'TRY_HEX_DECODE_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryHexDecodeBinary'>>, 'TRY_HEX_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryHexDecodeString'>>, 'TRY_TO_DECFLOAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryToDecfloat'>>, 'TS_OR_DI_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDiToDi'>>, 'TS_OR_DS_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsAdd'>>, 'TS_OR_DS_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsDiff'>>, 'TS_OR_DS_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.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.temporal.TsOrDsToDatetime'>>, 'TS_OR_DS_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsToTime'>>, 'TS_OR_DS_TO_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsToTimestamp'>>, 'TYPEOF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Typeof'>>, 'UNHEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Unhex'>>, 'UNICODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Unicode'>>, 'UNIFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Uniform'>>, 'UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixDate'>>, 'UNIX_MICROS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixMicros'>>, 'UNIX_MILLIS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixMillis'>>, 'UNIX_SECONDS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixSeconds'>>, 'UNIX_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixToStr'>>, 'UNIX_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixToTime'>>, 'UNIX_TO_TIME_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixToTimeStr'>>, 'UNNEST': <function Parser.<lambda>>, 'UPPER': <function build_upper>, 'UCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Upper'>>, 'UTC_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UtcDate'>>, 'UTC_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UtcTime'>>, 'UTC_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UtcTimestamp'>>, 'UUID': <function Parser.<lambda>>, 'GEN_RANDOM_UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Uuid'>>, 'GENERATE_UUID': <function Parser.<lambda>>, 'UUID_STRING': <function Parser.<lambda>>, 'VAR_MAP': <function build_var_map>, 'VARIANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Variance'>>, 'VARIANCE_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Variance'>>, 'VAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Variance'>>, 'VARIANCE_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.VariancePop'>>, 'VAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.VariancePop'>>, 'VECTOR_SEARCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.VectorSearch'>>, 'WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Week'>>, 'WEEK_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.WeekOfYear'>>, 'WEEKOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.WeekOfYear'>>, 'WEEK_START': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.WeekStart'>>, 'WEIGHT_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.WeightString'>>, 'WIDTH_BUCKET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.WidthBucket'>>, 'XMLELEMENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.XMLElement'>>, 'XMLGET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.XMLGet'>>, 'X_M_L_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.XMLTable'>>, 'XOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Xor'>>, 'YEAR': <function TSQLParser.<lambda>>, 'YEAR_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeek'>>, 'YEAROFWEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeek'>>, 'YEAR_OF_WEEK_ISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeekIso'>>, 'YEAROFWEEKISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeekIso'>>, 'ZIPF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Zipf'>>, 'EXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array._ExplodeOuter'>>, 'SORT_ARRAY': <function build_sort_array>, 'ARRAYAGG': <function Parser.<lambda>>, 'GLOB': <function Parser.<lambda>>, 'JSON_EXTRACT_PATH_TEXT': <function build_extract_json_with_path.<locals>._builder>, 'LIKE': <function build_like>, 'LOG2': <function Parser.<lambda>>, 'LOG10': <function Parser.<lambda>>, 'LPAD': <function Parser.<lambda>>, 'LEFTPAD': <function Parser.<lambda>>, '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.string.StrPosition'>>, 'CHARINDEX': <function TSQLParser.<lambda>>, 'INSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StrPosition'>>, 'LOCATE': <function Parser.<lambda>>, 'TO_HEX': <function build_hex>, 'ATN2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Atan2'>>, 'COUNT_BIG': <function TSQLParser.<lambda>>, 'DATEADD': <function build_date_delta.<locals>._builder>, 'DATEDIFF_BIG': <function _build_date_delta.<locals>._builder>, 'DATENAME': <function _build_formatted_time.<locals>._builder>, 'DATETIMEFROMPARTS': <function _build_datetimefromparts>, 'EOMONTH': <function _build_eomonth>, 'GETDATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTimestamp'>>, 'HASHBYTES': <function _build_hashbytes>, 'ISNULL': <function TSQLParser.<lambda>>, 'JSON_QUERY': <function _build_json_query>, 'JSON_VALUE': <function build_extract_json_with_path.<locals>._builder>, 'NEWID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Uuid'>>, 'PARSENAME': <function _build_parsename>, 'REPLICATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Repeat'>>, 'SCHEMA_NAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSchema'>>, 'SQUARE': <function TSQLParser.<lambda>>, 'SYSDATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTimestamp'>>, 'SUSER_NAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentUser'>>, 'SUSER_SNAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentUser'>>, 'SYSDATETIMEOFFSET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTimestampLTZ'>>, 'SYSTEM_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentUser'>>, 'DATETRUNC': <function _build_datetrunc>}

JOIN_HINTS = {'LOOP', 'REMOTE', 'HASH', 'MERGE'}

PROCEDURE_OPTIONS = {'ENCRYPTION': (), 'RECOMPILE': (), 'SCHEMABINDING': (), 'NATIVE_COMPILATION': (), 'EXECUTE': ()}

COLUMN_DEFINITION_MODES: ClassVar = {'OUT', 'READONLY', 'OUTPUT'}

RETURNS_TABLE_TOKENS: ClassVar = {<TokenType.SESSION: 59>, <TokenType.SESSION_USER: 61>, <TokenType.IDENTIFIER: 79>, <TokenType.DATABASE: 80>, <TokenType.COLUMN: 81>, <TokenType.SCHEMA: 83>, <TokenType.WAREHOUSE: 85>, <TokenType.STAGE: 86>, <TokenType.STREAM: 87>, <TokenType.STREAMLIT: 88>, <TokenType.VAR: 89>, <TokenType.LOCALTIME: 180>, <TokenType.LOCALTIMESTAMP: 181>, <TokenType.ALL: 221>, <TokenType.ANTI: 222>, <TokenType.ANY: 223>, <TokenType.APPLY: 224>, <TokenType.ASC: 226>, <TokenType.ASOF: 227>, <TokenType.ATTACH: 228>, <TokenType.AUTO_INCREMENT: 229>, <TokenType.BEGIN: 230>, <TokenType.CACHE: 233>, <TokenType.CASE: 234>, <TokenType.COLLATE: 237>, <TokenType.COMMAND: 238>, <TokenType.COMMENT: 239>, <TokenType.COMMIT: 240>, <TokenType.CONSTRAINT: 242>, <TokenType.COPY: 243>, <TokenType.CUBE: 246>, <TokenType.CURRENT_DATE: 247>, <TokenType.CURRENT_DATETIME: 248>, <TokenType.CURRENT_SCHEMA: 249>, <TokenType.CURRENT_TIME: 250>, <TokenType.CURRENT_TIMESTAMP: 251>, <TokenType.CURRENT_USER: 252>, <TokenType.CURRENT_ROLE: 254>, <TokenType.CURRENT_CATALOG: 255>, <TokenType.DECLARE: 256>, <TokenType.DEFAULT: 257>, <TokenType.DELETE: 258>, <TokenType.DESC: 259>, <TokenType.DESCRIBE: 260>, <TokenType.DETACH: 261>, <TokenType.DICTIONARY: 262>, <TokenType.DIV: 265>, <TokenType.END: 268>, <TokenType.ESCAPE: 269>, <TokenType.EXECUTE: 271>, <TokenType.EXISTS: 272>, <TokenType.FALSE: 273>, <TokenType.FILE: 275>, <TokenType.FILE_FORMAT: 276>, <TokenType.FILTER: 277>, <TokenType.FINAL: 278>, <TokenType.FIRST: 279>, <TokenType.FOREIGN_KEY: 282>, <TokenType.FORMAT: 283>, <TokenType.FULL: 285>, <TokenType.FUNCTION: 286>, <TokenType.GET: 287>, <TokenType.INDEX: 298>, <TokenType.IS: 309>, <TokenType.ISNULL: 310>, <TokenType.KEEP: 313>, <TokenType.KILL: 315>, <TokenType.LEFT: 318>, <TokenType.LIMIT: 320>, <TokenType.LOAD: 322>, <TokenType.LOCK: 323>, <TokenType.MATCH: 325>, <TokenType.MERGE: 329>, <TokenType.MODEL: 331>, <TokenType.NATURAL: 332>, <TokenType.NEXT: 333>, <TokenType.OFFSET: 338>, <TokenType.OPERATOR: 341>, <TokenType.ORDINALITY: 345>, <TokenType.OUT: 346>, <TokenType.INOUT: 347>, <TokenType.OVER: 349>, <TokenType.OVERLAPS: 350>, <TokenType.OVERWRITE: 351>, <TokenType.PARTITION: 353>, <TokenType.PASTE: 355>, <TokenType.PERCENT: 356>, <TokenType.PIVOT: 357>, <TokenType.PRAGMA: 362>, <TokenType.PROCEDURE: 365>, <TokenType.PROJECTION: 367>, <TokenType.PUT: 369>, <TokenType.RECURSIVE: 374>, <TokenType.REFRESH: 375>, <TokenType.RENAME: 376>, <TokenType.REPLACE: 377>, <TokenType.REFERENCES: 380>, <TokenType.RIGHT: 381>, <TokenType.ROLLUP: 385>, <TokenType.ROW: 386>, <TokenType.ROWS: 387>, <TokenType.SEMI: 390>, <TokenType.SEQUENCE: 392>, <TokenType.SET: 394>, <TokenType.SETTINGS: 395>, <TokenType.SHOW: 396>, <TokenType.SOME: 398>, <TokenType.STORAGE_INTEGRATION: 403>, <TokenType.STRAIGHT_JOIN: 404>, <TokenType.TAG: 408>, <TokenType.TEMPORARY: 409>, <TokenType.TOP: 410>, <TokenType.TRUE: 412>, <TokenType.TRUNCATE: 413>, <TokenType.TRIGGER: 414>, <TokenType.TYPE: 415>, <TokenType.UNNEST: 419>, <TokenType.UNPIVOT: 420>, <TokenType.UPDATE: 421>, <TokenType.USE: 422>, <TokenType.VIEW: 426>, <TokenType.SEMANTIC_VIEW: 427>, <TokenType.VOLATILE: 428>, <TokenType.WINDOW: 432>, <TokenType.UNIQUE: 434>, <TokenType.SINK: 439>, <TokenType.SOURCE: 440>, <TokenType.ANALYZE: 441>, <TokenType.NAMESPACE: 442>, <TokenType.EXPORT: 443>}

STATEMENT_PARSERS = {<TokenType.ALTER: 220>: <function Parser.<lambda>>, <TokenType.ANALYZE: 441>: <function Parser.<lambda>>, <TokenType.BEGIN: 230>: <function Parser.<lambda>>, <TokenType.CACHE: 233>: <function Parser.<lambda>>, <TokenType.COMMENT: 239>: <function Parser.<lambda>>, <TokenType.COMMIT: 240>: <function Parser.<lambda>>, <TokenType.COPY: 243>: <function Parser.<lambda>>, <TokenType.CREATE: 244>: <function Parser.<lambda>>, <TokenType.DECLARE: 256>: <function Parser.<lambda>>, <TokenType.DELETE: 258>: <function Parser.<lambda>>, <TokenType.DESC: 259>: <function Parser.<lambda>>, <TokenType.DESCRIBE: 260>: <function Parser.<lambda>>, <TokenType.DROP: 266>: <function Parser.<lambda>>, <TokenType.GRANT: 290>: <function Parser.<lambda>>, <TokenType.REVOKE: 379>: <function Parser.<lambda>>, <TokenType.INSERT: 301>: <function Parser.<lambda>>, <TokenType.KILL: 315>: <function Parser.<lambda>>, <TokenType.LOAD: 322>: <function Parser.<lambda>>, <TokenType.MERGE: 329>: <function Parser.<lambda>>, <TokenType.PIVOT: 357>: <function Parser.<lambda>>, <TokenType.PRAGMA: 362>: <function Parser.<lambda>>, <TokenType.REFRESH: 375>: <function Parser.<lambda>>, <TokenType.ROLLBACK: 384>: <function Parser.<lambda>>, <TokenType.SET: 394>: <function Parser.<lambda>>, <TokenType.TRUNCATE: 413>: <function Parser.<lambda>>, <TokenType.UNCACHE: 416>: <function Parser.<lambda>>, <TokenType.UNPIVOT: 420>: <function Parser.<lambda>>, <TokenType.UPDATE: 421>: <function Parser.<lambda>>, <TokenType.USE: 422>: <function Parser.<lambda>>, <TokenType.SEMICOLON: 19>: <function Parser.<lambda>>, <TokenType.EXECUTE: 271>: <function TSQLParser.<lambda>>}

RANGE_PARSERS = {<TokenType.AT_GT: 56>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.BETWEEN: 231>: <function Parser.<lambda>>, <TokenType.GLOB: 288>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.ILIKE: 296>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IN: 297>: <function Parser.<lambda>>, <TokenType.IRLIKE: 308>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IS: 309>: <function Parser.<lambda>>, <TokenType.LIKE: 319>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.LT_AT: 55>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.OVERLAPS: 350>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.RLIKE: 382>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.SIMILAR_TO: 397>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.FOR: 280>: <function Parser.<lambda>>, <TokenType.QMARK_AMP: 68>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.QMARK_PIPE: 69>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.HASH_DASH: 70>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.AT_QMARK: 54>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.ADJACENT: 65>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.OPERATOR: 341>: <function Parser.<lambda>>, <TokenType.AMP_LT: 63>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.AMP_GT: 64>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.CARET_AT: 43>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.DCOLON: 14>: <function TSQLParser.<lambda>>}

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

FUNCTION_PARSERS = {'ARG_MAX': <function Parser.<dictcomp>.<lambda>>, 'ARGMAX': <function Parser.<dictcomp>.<lambda>>, 'MAX_BY': <function Parser.<dictcomp>.<lambda>>, 'ARG_MIN': <function Parser.<dictcomp>.<lambda>>, 'ARGMIN': <function Parser.<dictcomp>.<lambda>>, 'MIN_BY': <function Parser.<dictcomp>.<lambda>>, 'CAST': <function Parser.<lambda>>, 'CEIL': <function Parser.<lambda>>, 'CONVERT': <function Parser.<lambda>>, 'CHAR': <function Parser.<lambda>>, 'CHR': <function Parser.<lambda>>, 'DECODE': <function Parser.<lambda>>, 'EXTRACT': <function Parser.<lambda>>, 'FLOOR': <function Parser.<lambda>>, 'GAP_FILL': <function Parser.<lambda>>, 'INITCAP': <function Parser.<lambda>>, 'JSON_OBJECT': <function Parser.<lambda>>, 'JSON_OBJECTAGG': <function Parser.<lambda>>, 'JSON_TABLE': <function Parser.<lambda>>, 'MATCH': <function Parser.<lambda>>, 'NORMALIZE': <function Parser.<lambda>>, 'OPENJSON': <function Parser.<lambda>>, 'OVERLAY': <function Parser.<lambda>>, 'POSITION': <function Parser.<lambda>>, 'SAFE_CAST': <function Parser.<lambda>>, 'STRING_AGG': <function Parser.<lambda>>, 'SUBSTRING': <function Parser.<lambda>>, 'TRIM': <function Parser.<lambda>>, 'TRY_CAST': <function Parser.<lambda>>, 'TRY_CONVERT': <function Parser.<lambda>>, 'WEIGHT_STRING': <function Parser.<lambda>>, 'XMLELEMENT': <function Parser.<lambda>>, 'XMLTABLE': <function Parser.<lambda>>, 'JSON_ARRAYAGG': <function TSQLParser.<lambda>>, 'DATEPART': <function TSQLParser.<lambda>>}

COLUMN_OPERATORS = {<TokenType.DOT: 8>: None, <TokenType.DOTCOLON: 12>: <function Parser.<lambda>>, <TokenType.DCOLON: 14>: <function TSQLParser.<lambda>>, <TokenType.ARROW: 45>: <function Parser.<lambda>>, <TokenType.DARROW: 46>: <function Parser.<lambda>>, <TokenType.HASH_ARROW: 49>: <function Parser.<lambda>>, <TokenType.DHASH_ARROW: 50>: <function Parser.<lambda>>, <TokenType.PLACEHOLDER: 358>: <function Parser.<lambda>>}

SET_OP_MODIFIERS = {'order', 'options', 'limit', 'offset', 'for_'}

ODBC_DATETIME_LITERALS = {'d': <class 'sqlglot.expressions.temporal.Date'>, 't': <class 'sqlglot.expressions.temporal.Time'>, 'ts': <class 'sqlglot.expressions.temporal.Timestamp'>}

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; SUBQUERY_TOKENS; RESERVED_TOKENS; TEXT_MATCH_EXCLUDED_TOKENS; DB_CREATABLES; CREATABLES; TRIGGER_EVENTS; ALTERABLES; COLON_PLACEHOLDER_TOKENS; ARRAY_CONSTRUCTORS; TRIM_TYPES; IDENTIFIER_TOKENS; BRACKETS; COLUMN_POSTFIX_TOKENS; TABLE_POSTFIX_TOKENS; FUNC_TOKENS; CONJUNCTION; ASSIGNMENT; DISJUNCTION; EQUALITY; COMPARISON; BITWISE; TERM; FACTOR; EXPONENT; TIMES; TIMESTAMPS; SET_OPERATIONS; JOIN_METHODS; JOIN_SIDES; JOIN_KINDS; TABLE_TERMINATORS; LAMBDAS; TYPED_LAMBDA_ARGS; LAMBDA_ARG_TERMINATORS; JSON_OPERATORS; CAST_COLUMN_OPERATORS; EXPRESSION_PARSERS; UNARY_PARSERS; STRING_PARSERS; NUMERIC_PARSERS; PRIMARY_PARSERS; PLACEHOLDER_PARSERS; PIPE_SYNTAX_TRANSFORM_PARSERS; PROPERTY_PARSERS; CONSTRAINT_PARSERS; ALTER_PARSERS; ALTER_ALTER_PARSERS; SCHEMA_UNNAMED_CONSTRAINTS; RESERVED_CONSTRAINT_KINDS; INVALID_FUNC_NAME_TOKENS; FUNCTIONS_WITH_ALIASED_ARGS; KEY_VALUE_DEFINITIONS; QUERY_MODIFIER_TOKENS; SET_PARSERS; SHOW_PARSERS; TYPE_LITERAL_PARSERS; TYPE_CONVERTERS; DDL_SELECT_TOKENS; PRE_VOLATILE_TOKENS; TRANSACTION_KIND; TRANSACTION_CHARACTERISTICS; CONFLICT_ACTIONS; TRIGGER_TIMING; TRIGGER_DEFERRABLE; CREATE_SEQUENCE; ISOLATED_LOADING_OPTIONS; USABLES; CAST_ACTIONS; SCHEMA_BINDING_OPTIONS; EXECUTE_AS_OPTIONS; KEY_CONSTRAINT_OPTIONS; WINDOW_EXCLUDE_OPTIONS; INSERT_ALTERNATIVES; CLONE_KEYWORDS; VERSION_PHRASES; 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; ADD_CONSTRAINT_KEYWORDS; DISTINCT_TOKENS; UNNEST_OFFSET_ALIAS_TOKENS; SELECT_START_TOKENS; COPY_INTO_VARLEN_OPTIONS; IS_PREDICATE_PRECEDENCE; IS_PREDICATE_TOKENS; IS_JSON_PREDICATE_KIND; ON_CONDITION_TOKENS; PRIVILEGE_FOLLOW_TOKENS; DESCRIBE_STYLES; SET_ASSIGNMENT_DELIMITERS; ANALYZE_STYLES; ANALYZE_EXPRESSION_PARSERS; PARTITION_KEYWORDS; AMBIGUOUS_ALIAS_TOKENS; OPERATION_MODIFIERS; RECURSIVE_CTE_SEARCH_KIND; SECURITY_PROPERTY_KEYWORDS; MODIFIABLES; STRICT_CAST; PREFIXED_PIVOT_COLUMNS; IDENTIFY_PIVOT_STRINGS; PIVOT_COLUMN_NAMING; TABLESAMPLE_CSV; DEFAULT_SAMPLING_METHOD; TRIM_PATTERN_FIRST; MODIFIERS_ATTACHED_TO_SET_OP; JSON_ARROWS_REQUIRE_JSON_TYPE; COLON_IS_VARIANT_EXTRACT; COLON_CHAIN_IS_SINGLE_EXTRACT; VALUES_FOLLOWED_BY_PAREN; SUPPORTS_IMPLICIT_UNNEST; SUPPORTS_DIGIT_PREFIXED_FIELD_NAMES; INTERVAL_SPANS; SUPPORTS_PARTITION_SELECTION; WRAPPED_TRANSFORM_COLUMN_CONSTRAINT; OPTIONAL_ALIAS_TOKEN_CTE; ALTER_RENAME_REQUIRES_COLUMN; ALTER_DROP_REQUIRES_COLUMN; ALTER_TABLE_PARTITIONS; ALTER_TABLE_MIXED_ACTIONS; ALTER_TABLE_REQUIRES_ACTION; ALTER_COLUMN_TYPE_REQUIRES_KEYWORD; JOINS_HAVE_EQUAL_PRECEDENCE; ZONE_AWARE_TIMESTAMP_CONSTRUCTOR; MAP_KEYS_ARE_ARBITRARY_EXPRESSIONS; JSON_EXTRACT_REQUIRES_JSON_EXPRESSION; ADD_JOIN_ON_TRUE; SUPPORTS_OMITTED_INTERVAL_SPAN_UNIT; ADJACENT_STRINGS_CANNOT_BE_CONNECTED; SUPPORTS_NTH_VALUE_FROM_MODIFIER; QUOTED_TYPES_TO_PRESERVE; SHOW_TRIE; SET_TRIE; error_level; error_message_context; max_errors; max_nodes; dialect; sql; errors; reset; raise_error; validate_expression; parse; parse_into; check_errors; expression; parse_set_operation; build_cast