sqlglot.dialects.bigquery API documentation

Edit on GitHub

# sqlglot.dialects.bigquery

View Source

       1from __future__ import annotations
       2
       3import logging
       4import re
       5import typing as t
       6
       7
       8from sqlglot.optimizer.annotate_types import TypeAnnotator
       9
      10from sqlglot import exp, generator, jsonpath, parser, tokens, transforms
      11from sqlglot._typing import E
      12from sqlglot.dialects.dialect import (
      13    Dialect,
      14    NormalizationStrategy,
      15    annotate_with_type_lambda,
      16    arg_max_or_min_no_count,
      17    binary_from_function,
      18    date_add_interval_sql,
      19    datestrtodate_sql,
      20    build_formatted_time,
      21    filter_array_using_unnest,
      22    if_sql,
      23    inline_array_unless_query,
      24    max_or_greatest,
      25    min_or_least,
      26    no_ilike_sql,
      27    build_date_delta_with_interval,
      28    regexp_replace_sql,
      29    rename_func,
      30    sha256_sql,
      31    timestrtotime_sql,
      32    ts_or_ds_add_cast,
      33    unit_to_var,
      34    strposition_sql,
      35    groupconcat_sql,
      36)
      37from sqlglot.helper import seq_get, split_num_words
      38from sqlglot.tokens import TokenType
      39from sqlglot.generator import unsupported_args
      40
      41if t.TYPE_CHECKING:
      42    from sqlglot._typing import Lit
      43
      44    from sqlglot.optimizer.annotate_types import TypeAnnotator
      45
      46logger = logging.getLogger("sqlglot")
      47
      48
      49JSON_EXTRACT_TYPE = t.Union[exp.JSONExtract, exp.JSONExtractScalar, exp.JSONExtractArray]
      50
      51DQUOTES_ESCAPING_JSON_FUNCTIONS = ("JSON_QUERY", "JSON_VALUE", "JSON_QUERY_ARRAY")
      52
      53
      54def _derived_table_values_to_unnest(self: BigQuery.Generator, expression: exp.Values) -> str:
      55    if not expression.find_ancestor(exp.From, exp.Join):
      56        return self.values_sql(expression)
      57
      58    structs = []
      59    alias = expression.args.get("alias")
      60    for tup in expression.find_all(exp.Tuple):
      61        field_aliases = (
      62            alias.columns
      63            if alias and alias.columns
      64            else (f"_c{i}" for i in range(len(tup.expressions)))
      65        )
      66        expressions = [
      67            exp.PropertyEQ(this=exp.to_identifier(name), expression=fld)
      68            for name, fld in zip(field_aliases, tup.expressions)
      69        ]
      70        structs.append(exp.Struct(expressions=expressions))
      71
      72    # Due to `UNNEST_COLUMN_ONLY`, it is expected that the table alias be contained in the columns expression
      73    alias_name_only = exp.TableAlias(columns=[alias.this]) if alias else None
      74    return self.unnest_sql(
      75        exp.Unnest(expressions=[exp.array(*structs, copy=False)], alias=alias_name_only)
      76    )
      77
      78
      79def _returnsproperty_sql(self: BigQuery.Generator, expression: exp.ReturnsProperty) -> str:
      80    this = expression.this
      81    if isinstance(this, exp.Schema):
      82        this = f"{self.sql(this, 'this')} <{self.expressions(this)}>"
      83    else:
      84        this = self.sql(this)
      85    return f"RETURNS {this}"
      86
      87
      88def _create_sql(self: BigQuery.Generator, expression: exp.Create) -> str:
      89    returns = expression.find(exp.ReturnsProperty)
      90    if expression.kind == "FUNCTION" and returns and returns.args.get("is_table"):
      91        expression.set("kind", "TABLE FUNCTION")
      92
      93        if isinstance(expression.expression, (exp.Subquery, exp.Literal)):
      94            expression.set("expression", expression.expression.this)
      95
      96    return self.create_sql(expression)
      97
      98
      99# https://issuetracker.google.com/issues/162294746
     100# workaround for bigquery bug when grouping by an expression and then ordering
     101# WITH x AS (SELECT 1 y)
     102# SELECT y + 1 z
     103# FROM x
     104# GROUP BY x + 1
     105# ORDER by z
     106def _alias_ordered_group(expression: exp.Expression) -> exp.Expression:
     107    if isinstance(expression, exp.Select):
     108        group = expression.args.get("group")
     109        order = expression.args.get("order")
     110
     111        if group and order:
     112            aliases = {
     113                select.this: select.args["alias"]
     114                for select in expression.selects
     115                if isinstance(select, exp.Alias)
     116            }
     117
     118            for grouped in group.expressions:
     119                if grouped.is_int:
     120                    continue
     121                alias = aliases.get(grouped)
     122                if alias:
     123                    grouped.replace(exp.column(alias))
     124
     125    return expression
     126
     127
     128def _pushdown_cte_column_names(expression: exp.Expression) -> exp.Expression:
     129    """BigQuery doesn't allow column names when defining a CTE, so we try to push them down."""
     130    if isinstance(expression, exp.CTE) and expression.alias_column_names:
     131        cte_query = expression.this
     132
     133        if cte_query.is_star:
     134            logger.warning(
     135                "Can't push down CTE column names for star queries. Run the query through"
     136                " the optimizer or use 'qualify' to expand the star projections first."
     137            )
     138            return expression
     139
     140        column_names = expression.alias_column_names
     141        expression.args["alias"].set("columns", None)
     142
     143        for name, select in zip(column_names, cte_query.selects):
     144            to_replace = select
     145
     146            if isinstance(select, exp.Alias):
     147                select = select.this
     148
     149            # Inner aliases are shadowed by the CTE column names
     150            to_replace.replace(exp.alias_(select, name))
     151
     152    return expression
     153
     154
     155def _build_parse_timestamp(args: t.List) -> exp.StrToTime:
     156    this = build_formatted_time(exp.StrToTime, "bigquery")([seq_get(args, 1), seq_get(args, 0)])
     157    this.set("zone", seq_get(args, 2))
     158    return this
     159
     160
     161def _build_timestamp(args: t.List) -> exp.Timestamp:
     162    timestamp = exp.Timestamp.from_arg_list(args)
     163    timestamp.set("with_tz", True)
     164    return timestamp
     165
     166
     167def _build_date(args: t.List) -> exp.Date | exp.DateFromParts:
     168    expr_type = exp.DateFromParts if len(args) == 3 else exp.Date
     169    return expr_type.from_arg_list(args)
     170
     171
     172def _build_to_hex(args: t.List) -> exp.Hex | exp.MD5:
     173    # TO_HEX(MD5(..)) is common in BigQuery, so it's parsed into MD5 to simplify its transpilation
     174    arg = seq_get(args, 0)
     175    return exp.MD5(this=arg.this) if isinstance(arg, exp.MD5Digest) else exp.LowerHex(this=arg)
     176
     177
     178def _build_json_strip_nulls(args: t.List) -> exp.JSONStripNulls:
     179    expression = exp.JSONStripNulls(this=seq_get(args, 0))
     180
     181    for arg in args[1:]:
     182        if isinstance(arg, exp.Kwarg):
     183            expression.set(arg.this.name.lower(), arg)
     184        else:
     185            expression.set("expression", arg)
     186
     187    return expression
     188
     189
     190def _array_contains_sql(self: BigQuery.Generator, expression: exp.ArrayContains) -> str:
     191    return self.sql(
     192        exp.Exists(
     193            this=exp.select("1")
     194            .from_(exp.Unnest(expressions=[expression.left]).as_("_unnest", table=["_col"]))
     195            .where(exp.column("_col").eq(expression.right))
     196        )
     197    )
     198
     199
     200def _ts_or_ds_add_sql(self: BigQuery.Generator, expression: exp.TsOrDsAdd) -> str:
     201    return date_add_interval_sql("DATE", "ADD")(self, ts_or_ds_add_cast(expression))
     202
     203
     204def _ts_or_ds_diff_sql(self: BigQuery.Generator, expression: exp.TsOrDsDiff) -> str:
     205    expression.this.replace(exp.cast(expression.this, exp.DataType.Type.TIMESTAMP))
     206    expression.expression.replace(exp.cast(expression.expression, exp.DataType.Type.TIMESTAMP))
     207    unit = unit_to_var(expression)
     208    return self.func("DATE_DIFF", expression.this, expression.expression, unit)
     209
     210
     211def _unix_to_time_sql(self: BigQuery.Generator, expression: exp.UnixToTime) -> str:
     212    scale = expression.args.get("scale")
     213    timestamp = expression.this
     214
     215    if scale in (None, exp.UnixToTime.SECONDS):
     216        return self.func("TIMESTAMP_SECONDS", timestamp)
     217    if scale == exp.UnixToTime.MILLIS:
     218        return self.func("TIMESTAMP_MILLIS", timestamp)
     219    if scale == exp.UnixToTime.MICROS:
     220        return self.func("TIMESTAMP_MICROS", timestamp)
     221
     222    unix_seconds = exp.cast(
     223        exp.Div(this=timestamp, expression=exp.func("POW", 10, scale)), exp.DataType.Type.BIGINT
     224    )
     225    return self.func("TIMESTAMP_SECONDS", unix_seconds)
     226
     227
     228def _build_time(args: t.List) -> exp.Func:
     229    if len(args) == 1:
     230        return exp.TsOrDsToTime(this=args[0])
     231    if len(args) == 2:
     232        return exp.Time.from_arg_list(args)
     233    return exp.TimeFromParts.from_arg_list(args)
     234
     235
     236def _build_datetime(args: t.List) -> exp.Func:
     237    if len(args) == 1:
     238        return exp.TsOrDsToDatetime.from_arg_list(args)
     239    if len(args) == 2:
     240        return exp.Datetime.from_arg_list(args)
     241    return exp.TimestampFromParts.from_arg_list(args)
     242
     243
     244def _build_regexp_extract(
     245    expr_type: t.Type[E], default_group: t.Optional[exp.Expression] = None
     246) -> t.Callable[[t.List], E]:
     247    def _builder(args: t.List) -> E:
     248        try:
     249            group = re.compile(args[1].name).groups == 1
     250        except re.error:
     251            group = False
     252
     253        # Default group is used for the transpilation of REGEXP_EXTRACT_ALL
     254        return expr_type(
     255            this=seq_get(args, 0),
     256            expression=seq_get(args, 1),
     257            position=seq_get(args, 2),
     258            occurrence=seq_get(args, 3),
     259            group=exp.Literal.number(1) if group else default_group,
     260        )
     261
     262    return _builder
     263
     264
     265def _build_extract_json_with_default_path(expr_type: t.Type[E]) -> t.Callable[[t.List, Dialect], E]:
     266    def _builder(args: t.List, dialect: Dialect) -> E:
     267        if len(args) == 1:
     268            # The default value for the JSONPath is '$' i.e all of the data
     269            args.append(exp.Literal.string("$"))
     270        return parser.build_extract_json_with_path(expr_type)(args, dialect)
     271
     272    return _builder
     273
     274
     275def _str_to_datetime_sql(
     276    self: BigQuery.Generator, expression: exp.StrToDate | exp.StrToTime
     277) -> str:
     278    this = self.sql(expression, "this")
     279    dtype = "DATE" if isinstance(expression, exp.StrToDate) else "TIMESTAMP"
     280
     281    if expression.args.get("safe"):
     282        fmt = self.format_time(
     283            expression,
     284            self.dialect.INVERSE_FORMAT_MAPPING,
     285            self.dialect.INVERSE_FORMAT_TRIE,
     286        )
     287        return f"SAFE_CAST({this} AS {dtype} FORMAT {fmt})"
     288
     289    fmt = self.format_time(expression)
     290    return self.func(f"PARSE_{dtype}", fmt, this, expression.args.get("zone"))
     291
     292
     293def _annotate_math_functions(self: TypeAnnotator, expression: E) -> E:
     294    """
     295    Many BigQuery math functions such as CEIL, FLOOR etc follow this return type convention:
     296    +---------+---------+---------+------------+---------+
     297    |  INPUT  | INT64   | NUMERIC | BIGNUMERIC | FLOAT64 |
     298    +---------+---------+---------+------------+---------+
     299    |  OUTPUT | FLOAT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
     300    +---------+---------+---------+------------+---------+
     301    """
     302    self._annotate_args(expression)
     303
     304    this: exp.Expression = expression.this
     305
     306    self._set_type(
     307        expression,
     308        exp.DataType.Type.DOUBLE if this.is_type(*exp.DataType.INTEGER_TYPES) else this.type,
     309    )
     310    return expression
     311
     312
     313def _annotate_by_args_with_coerce(self: TypeAnnotator, expression: E) -> E:
     314    """
     315    +------------+------------+------------+-------------+---------+
     316    | INPUT      | INT64      | NUMERIC    | BIGNUMERIC  | FLOAT64 |
     317    +------------+------------+------------+-------------+---------+
     318    | INT64      | INT64      | NUMERIC    | BIGNUMERIC  | FLOAT64 |
     319    | NUMERIC    | NUMERIC    | NUMERIC    | BIGNUMERIC  | FLOAT64 |
     320    | BIGNUMERIC | BIGNUMERIC | BIGNUMERIC | BIGNUMERIC  | FLOAT64 |
     321    | FLOAT64    | FLOAT64    | FLOAT64    | FLOAT64     | FLOAT64 |
     322    +------------+------------+------------+-------------+---------+
     323    """
     324    self._annotate_args(expression)
     325
     326    self._set_type(expression, self._maybe_coerce(expression.this.type, expression.expression.type))
     327    return expression
     328
     329
     330def _annotate_by_args_approx_top(self: TypeAnnotator, expression: exp.ApproxTopK) -> exp.ApproxTopK:
     331    self._annotate_args(expression)
     332
     333    struct_type = exp.DataType(
     334        this=exp.DataType.Type.STRUCT,
     335        expressions=[expression.this.type, exp.DataType(this=exp.DataType.Type.BIGINT)],
     336        nested=True,
     337    )
     338    self._set_type(
     339        expression,
     340        exp.DataType(this=exp.DataType.Type.ARRAY, expressions=[struct_type], nested=True),
     341    )
     342
     343    return expression
     344
     345
     346@unsupported_args("ins_cost", "del_cost", "sub_cost")
     347def _levenshtein_sql(self: BigQuery.Generator, expression: exp.Levenshtein) -> str:
     348    max_dist = expression.args.get("max_dist")
     349    if max_dist:
     350        max_dist = exp.Kwarg(this=exp.var("max_distance"), expression=max_dist)
     351
     352    return self.func("EDIT_DISTANCE", expression.this, expression.expression, max_dist)
     353
     354
     355def _build_levenshtein(args: t.List) -> exp.Levenshtein:
     356    max_dist = seq_get(args, 2)
     357    return exp.Levenshtein(
     358        this=seq_get(args, 0),
     359        expression=seq_get(args, 1),
     360        max_dist=max_dist.expression if max_dist else None,
     361    )
     362
     363
     364def _build_format_time(expr_type: t.Type[exp.Expression]) -> t.Callable[[t.List], exp.TimeToStr]:
     365    def _builder(args: t.List) -> exp.TimeToStr:
     366        return exp.TimeToStr(
     367            this=expr_type(this=seq_get(args, 1)),
     368            format=seq_get(args, 0),
     369            zone=seq_get(args, 2),
     370        )
     371
     372    return _builder
     373
     374
     375def _build_contains_substring(args: t.List) -> exp.Contains:
     376    # Lowercase the operands in case of transpilation, as exp.Contains
     377    # is case-sensitive on other dialects
     378    this = exp.Lower(this=seq_get(args, 0))
     379    expr = exp.Lower(this=seq_get(args, 1))
     380
     381    return exp.Contains(this=this, expression=expr, json_scope=seq_get(args, 2))
     382
     383
     384def _json_extract_sql(self: BigQuery.Generator, expression: JSON_EXTRACT_TYPE) -> str:
     385    name = (expression._meta and expression.meta.get("name")) or expression.sql_name()
     386    upper = name.upper()
     387
     388    dquote_escaping = upper in DQUOTES_ESCAPING_JSON_FUNCTIONS
     389
     390    if dquote_escaping:
     391        self._quote_json_path_key_using_brackets = False
     392
     393    sql = rename_func(upper)(self, expression)
     394
     395    if dquote_escaping:
     396        self._quote_json_path_key_using_brackets = True
     397
     398    return sql
     399
     400
     401def _annotate_concat(self: TypeAnnotator, expression: exp.Concat) -> exp.Concat:
     402    annotated = self._annotate_by_args(expression, "expressions")
     403
     404    # Args must be BYTES or types that can be cast to STRING, return type is either BYTES or STRING
     405    # https://cloud.google.com/bigquery/docs/reference/standard-sql/string_functions#concat
     406    if not annotated.is_type(exp.DataType.Type.BINARY, exp.DataType.Type.UNKNOWN):
     407        annotated.type = exp.DataType.Type.VARCHAR
     408
     409    return annotated
     410
     411
     412def _annotate_array(self: TypeAnnotator, expression: exp.Array) -> exp.Array:
     413    array_args = expression.expressions
     414
     415    # BigQuery behaves as follows:
     416    #
     417    # SELECT t, TYPEOF(t) FROM (SELECT 'foo') AS t            -- foo, STRUCT<STRING>
     418    # SELECT ARRAY(SELECT 'foo'), TYPEOF(ARRAY(SELECT 'foo')) -- foo, ARRAY<STRING>
     419    if (
     420        len(array_args) == 1
     421        and isinstance(select := array_args[0].unnest(), exp.Select)
     422        and (query_type := select.meta.get("query_type")) is not None
     423        and query_type.is_type(exp.DataType.Type.STRUCT)
     424        and len(query_type.expressions) == 1
     425        and isinstance(col_def := query_type.expressions[0], exp.ColumnDef)
     426        and (projection_type := col_def.kind) is not None
     427        and not projection_type.is_type(exp.DataType.Type.UNKNOWN)
     428    ):
     429        array_type = exp.DataType(
     430            this=exp.DataType.Type.ARRAY,
     431            expressions=[projection_type.copy()],
     432            nested=True,
     433        )
     434        return self._annotate_with_type(expression, array_type)
     435
     436    return self._annotate_by_args(expression, "expressions", array=True)
     437
     438
     439class BigQuery(Dialect):
     440    WEEK_OFFSET = -1
     441    UNNEST_COLUMN_ONLY = True
     442    SUPPORTS_USER_DEFINED_TYPES = False
     443    SUPPORTS_SEMI_ANTI_JOIN = False
     444    LOG_BASE_FIRST = False
     445    HEX_LOWERCASE = True
     446    FORCE_EARLY_ALIAS_REF_EXPANSION = True
     447    PRESERVE_ORIGINAL_NAMES = True
     448    HEX_STRING_IS_INTEGER_TYPE = True
     449
     450    # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#case_sensitivity
     451    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
     452
     453    # bigquery udfs are case sensitive
     454    NORMALIZE_FUNCTIONS = False
     455
     456    # https://cloud.google.com/bigquery/docs/reference/standard-sql/format-elements#format_elements_date_time
     457    TIME_MAPPING = {
     458        "%D": "%m/%d/%y",
     459        "%E6S": "%S.%f",
     460        "%e": "%-d",
     461    }
     462
     463    FORMAT_MAPPING = {
     464        "DD": "%d",
     465        "MM": "%m",
     466        "MON": "%b",
     467        "MONTH": "%B",
     468        "YYYY": "%Y",
     469        "YY": "%y",
     470        "HH": "%I",
     471        "HH12": "%I",
     472        "HH24": "%H",
     473        "MI": "%M",
     474        "SS": "%S",
     475        "SSSSS": "%f",
     476        "TZH": "%z",
     477    }
     478
     479    # The _PARTITIONTIME and _PARTITIONDATE pseudo-columns are not returned by a SELECT * statement
     480    # https://cloud.google.com/bigquery/docs/querying-partitioned-tables#query_an_ingestion-time_partitioned_table
     481    # https://cloud.google.com/bigquery/docs/querying-wildcard-tables#scanning_a_range_of_tables_using_table_suffix
     482    # https://cloud.google.com/bigquery/docs/query-cloud-storage-data#query_the_file_name_pseudo-column
     483    PSEUDOCOLUMNS = {"_PARTITIONTIME", "_PARTITIONDATE", "_TABLE_SUFFIX", "_FILE_NAME"}
     484
     485    # All set operations require either a DISTINCT or ALL specifier
     486    SET_OP_DISTINCT_BY_DEFAULT = dict.fromkeys((exp.Except, exp.Intersect, exp.Union), None)
     487
     488    # https://cloud.google.com/bigquery/docs/reference/standard-sql/navigation_functions#percentile_cont
     489    COERCES_TO = {
     490        **TypeAnnotator.COERCES_TO,
     491        exp.DataType.Type.BIGDECIMAL: {exp.DataType.Type.DOUBLE},
     492    }
     493    COERCES_TO[exp.DataType.Type.DECIMAL] |= {exp.DataType.Type.BIGDECIMAL}
     494    COERCES_TO[exp.DataType.Type.BIGINT] |= {exp.DataType.Type.BIGDECIMAL}
     495
     496    # BigQuery maps Type.TIMESTAMP to DATETIME, so we need to amend the inferred types
     497    TYPE_TO_EXPRESSIONS = {
     498        **Dialect.TYPE_TO_EXPRESSIONS,
     499        exp.DataType.Type.TIMESTAMPTZ: Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.TIMESTAMP],
     500    }
     501    TYPE_TO_EXPRESSIONS.pop(exp.DataType.Type.TIMESTAMP)
     502
     503    ANNOTATORS = {
     504        **Dialect.ANNOTATORS,
     505        **{
     506            expr_type: annotate_with_type_lambda(data_type)
     507            for data_type, expressions in TYPE_TO_EXPRESSIONS.items()
     508            for expr_type in expressions
     509        },
     510        **{
     511            expr_type: lambda self, e: _annotate_math_functions(self, e)
     512            for expr_type in (exp.Floor, exp.Ceil, exp.Log, exp.Ln, exp.Sqrt, exp.Exp, exp.Round)
     513        },
     514        **{
     515            expr_type: lambda self, e: self._annotate_by_args(e, "this")
     516            for expr_type in (
     517                exp.Abs,
     518                exp.ArgMax,
     519                exp.ArgMin,
     520                exp.DateTrunc,
     521                exp.DatetimeTrunc,
     522                exp.FirstValue,
     523                exp.GroupConcat,
     524                exp.IgnoreNulls,
     525                exp.JSONExtract,
     526                exp.Lead,
     527                exp.Left,
     528                exp.Lower,
     529                exp.NthValue,
     530                exp.Pad,
     531                exp.PercentileDisc,
     532                exp.RegexpExtract,
     533                exp.RegexpReplace,
     534                exp.Repeat,
     535                exp.Replace,
     536                exp.RespectNulls,
     537                exp.Reverse,
     538                exp.Right,
     539                exp.SafeNegate,
     540                exp.Sign,
     541                exp.Substring,
     542                exp.TimestampTrunc,
     543                exp.Translate,
     544                exp.Trim,
     545                exp.Upper,
     546            )
     547        },
     548        exp.Acos: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     549        exp.Acosh: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     550        exp.Asin: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     551        exp.Asinh: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     552        exp.Atan: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     553        exp.Atanh: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     554        exp.Atan2: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     555        exp.ApproxTopSum: lambda self, e: _annotate_by_args_approx_top(self, e),
     556        exp.ApproxTopK: lambda self, e: _annotate_by_args_approx_top(self, e),
     557        exp.ApproxQuantiles: lambda self, e: self._annotate_by_args(e, "this", array=True),
     558        exp.Array: _annotate_array,
     559        exp.ArrayConcat: lambda self, e: self._annotate_by_args(e, "this", "expressions"),
     560        exp.Ascii: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     561        exp.BitwiseAndAgg: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     562        exp.BitwiseOrAgg: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     563        exp.BitwiseXorAgg: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     564        exp.BitwiseCountAgg: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     565        exp.ByteLength: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     566        exp.ByteString: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
     567        exp.Cbrt: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     568        exp.CodePointsToBytes: lambda self, e: self._annotate_with_type(
     569            e, exp.DataType.Type.BINARY
     570        ),
     571        exp.CodePointsToString: lambda self, e: self._annotate_with_type(
     572            e, exp.DataType.Type.VARCHAR
     573        ),
     574        exp.Concat: _annotate_concat,
     575        exp.Corr: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     576        exp.Cot: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     577        exp.CosineDistance: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     578        exp.Coth: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     579        exp.CovarPop: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     580        exp.CovarSamp: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     581        exp.Csc: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     582        exp.Csch: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     583        exp.CumeDist: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     584        exp.DateFromUnixDate: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DATE),
     585        exp.DenseRank: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     586        exp.EuclideanDistance: lambda self, e: self._annotate_with_type(
     587            e, exp.DataType.Type.DOUBLE
     588        ),
     589        exp.FarmFingerprint: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     590        exp.Unhex: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
     591        exp.Float64: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     592        exp.Format: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     593        exp.GenerateTimestampArray: lambda self, e: self._annotate_with_type(
     594            e, exp.DataType.build("ARRAY<TIMESTAMP>", dialect="bigquery")
     595        ),
     596        exp.Grouping: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     597        exp.IsInf: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BOOLEAN),
     598        exp.IsNan: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BOOLEAN),
     599        exp.JSONArray: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
     600        exp.JSONArrayAppend: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
     601        exp.JSONArrayInsert: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
     602        exp.JSONBool: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BOOLEAN),
     603        exp.JSONExtractScalar: lambda self, e: self._annotate_with_type(
     604            e, exp.DataType.Type.VARCHAR
     605        ),
     606        exp.JSONExtractArray: lambda self, e: self._annotate_by_args(e, "this", array=True),
     607        exp.JSONFormat: lambda self, e: self._annotate_with_type(
     608            e, exp.DataType.Type.JSON if e.args.get("to_json") else exp.DataType.Type.VARCHAR
     609        ),
     610        exp.JSONKeysAtDepth: lambda self, e: self._annotate_with_type(
     611            e, exp.DataType.build("ARRAY<VARCHAR>", dialect="bigquery")
     612        ),
     613        exp.JSONObject: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
     614        exp.JSONRemove: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
     615        exp.JSONSet: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
     616        exp.JSONStripNulls: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
     617        exp.JSONType: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     618        exp.JSONValueArray: lambda self, e: self._annotate_with_type(
     619            e, exp.DataType.build("ARRAY<VARCHAR>", dialect="bigquery")
     620        ),
     621        exp.Lag: lambda self, e: self._annotate_by_args(e, "this", "default"),
     622        exp.LowerHex: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     623        exp.LaxBool: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BOOLEAN),
     624        exp.LaxFloat64: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     625        exp.LaxInt64: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     626        exp.LaxString: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     627        exp.MD5Digest: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
     628        exp.Normalize: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     629        exp.Ntile: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     630        exp.ParseTime: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
     631        exp.ParseDatetime: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DATETIME),
     632        exp.ParseBignumeric: lambda self, e: self._annotate_with_type(
     633            e, exp.DataType.Type.BIGDECIMAL
     634        ),
     635        exp.ParseNumeric: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DECIMAL),
     636        exp.PercentileCont: lambda self, e: _annotate_by_args_with_coerce(self, e),
     637        exp.PercentRank: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     638        exp.Rank: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     639        exp.RangeBucket: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     640        exp.RegexpExtractAll: lambda self, e: self._annotate_by_args(e, "this", array=True),
     641        exp.RegexpInstr: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     642        exp.RowNumber: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     643        exp.Rand: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     644        exp.SafeConvertBytesToString: lambda self, e: self._annotate_with_type(
     645            e, exp.DataType.Type.VARCHAR
     646        ),
     647        exp.SafeAdd: lambda self, e: _annotate_by_args_with_coerce(self, e),
     648        exp.SafeMultiply: lambda self, e: _annotate_by_args_with_coerce(self, e),
     649        exp.SafeSubtract: lambda self, e: _annotate_by_args_with_coerce(self, e),
     650        exp.Sec: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     651        exp.Sech: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     652        exp.Soundex: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     653        exp.SHA: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
     654        exp.SHA2: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
     655        exp.Sin: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     656        exp.Sinh: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     657        exp.Split: lambda self, e: self._annotate_by_args(e, "this", array=True),
     658        exp.TimestampFromParts: lambda self, e: self._annotate_with_type(
     659            e, exp.DataType.Type.DATETIME
     660        ),
     661        exp.TimeFromParts: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
     662        exp.TimeTrunc: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
     663        exp.ToCodePoints: lambda self, e: self._annotate_with_type(
     664            e, exp.DataType.build("ARRAY<BIGINT>", dialect="bigquery")
     665        ),
     666        exp.TsOrDsToTime: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
     667        exp.Unicode: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     668        exp.Uuid: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     669    }
     670
     671    def normalize_identifier(self, expression: E) -> E:
     672        if (
     673            isinstance(expression, exp.Identifier)
     674            and self.normalization_strategy is NormalizationStrategy.CASE_INSENSITIVE
     675        ):
     676            parent = expression.parent
     677            while isinstance(parent, exp.Dot):
     678                parent = parent.parent
     679
     680            # In BigQuery, CTEs are case-insensitive, but UDF and table names are case-sensitive
     681            # by default. The following check uses a heuristic to detect tables based on whether
     682            # they are qualified. This should generally be correct, because tables in BigQuery
     683            # must be qualified with at least a dataset, unless @@dataset_id is set.
     684            case_sensitive = (
     685                isinstance(parent, exp.UserDefinedFunction)
     686                or (
     687                    isinstance(parent, exp.Table)
     688                    and parent.db
     689                    and (parent.meta.get("quoted_table") or not parent.meta.get("maybe_column"))
     690                )
     691                or expression.meta.get("is_table")
     692            )
     693            if not case_sensitive:
     694                expression.set("this", expression.this.lower())
     695
     696            return t.cast(E, expression)
     697
     698        return super().normalize_identifier(expression)
     699
     700    class JSONPathTokenizer(jsonpath.JSONPathTokenizer):
     701        VAR_TOKENS = {
     702            TokenType.DASH,
     703            TokenType.VAR,
     704        }
     705
     706    class Tokenizer(tokens.Tokenizer):
     707        QUOTES = ["'", '"', '"""', "'''"]
     708        COMMENTS = ["--", "#", ("/*", "*/")]
     709        IDENTIFIERS = ["`"]
     710        STRING_ESCAPES = ["\\"]
     711
     712        HEX_STRINGS = [("0x", ""), ("0X", "")]
     713
     714        BYTE_STRINGS = [
     715            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("b", "B")
     716        ]
     717
     718        RAW_STRINGS = [
     719            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("r", "R")
     720        ]
     721
     722        NESTED_COMMENTS = False
     723
     724        KEYWORDS = {
     725            **tokens.Tokenizer.KEYWORDS,
     726            "ANY TYPE": TokenType.VARIANT,
     727            "BEGIN": TokenType.COMMAND,
     728            "BEGIN TRANSACTION": TokenType.BEGIN,
     729            "BYTEINT": TokenType.INT,
     730            "BYTES": TokenType.BINARY,
     731            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
     732            "DATETIME": TokenType.TIMESTAMP,
     733            "DECLARE": TokenType.DECLARE,
     734            "ELSEIF": TokenType.COMMAND,
     735            "EXCEPTION": TokenType.COMMAND,
     736            "EXPORT": TokenType.EXPORT,
     737            "FLOAT64": TokenType.DOUBLE,
     738            "FOR SYSTEM_TIME": TokenType.TIMESTAMP_SNAPSHOT,
     739            "LOOP": TokenType.COMMAND,
     740            "MODEL": TokenType.MODEL,
     741            "NOT DETERMINISTIC": TokenType.VOLATILE,
     742            "RECORD": TokenType.STRUCT,
     743            "REPEAT": TokenType.COMMAND,
     744            "TIMESTAMP": TokenType.TIMESTAMPTZ,
     745            "WHILE": TokenType.COMMAND,
     746        }
     747        KEYWORDS.pop("DIV")
     748        KEYWORDS.pop("VALUES")
     749        KEYWORDS.pop("/*+")
     750
     751    class Parser(parser.Parser):
     752        PREFIXED_PIVOT_COLUMNS = True
     753        LOG_DEFAULTS_TO_LN = True
     754        SUPPORTS_IMPLICIT_UNNEST = True
     755        JOINS_HAVE_EQUAL_PRECEDENCE = True
     756
     757        # BigQuery does not allow ASC/DESC to be used as an identifier
     758        ID_VAR_TOKENS = parser.Parser.ID_VAR_TOKENS - {TokenType.ASC, TokenType.DESC}
     759        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {TokenType.ASC, TokenType.DESC}
     760        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {TokenType.ASC, TokenType.DESC}
     761        COMMENT_TABLE_ALIAS_TOKENS = parser.Parser.COMMENT_TABLE_ALIAS_TOKENS - {
     762            TokenType.ASC,
     763            TokenType.DESC,
     764        }
     765        UPDATE_ALIAS_TOKENS = parser.Parser.UPDATE_ALIAS_TOKENS - {TokenType.ASC, TokenType.DESC}
     766
     767        FUNCTIONS = {
     768            **parser.Parser.FUNCTIONS,
     769            "APPROX_TOP_COUNT": exp.ApproxTopK.from_arg_list,
     770            "BIT_AND": exp.BitwiseAndAgg.from_arg_list,
     771            "BIT_OR": exp.BitwiseOrAgg.from_arg_list,
     772            "BIT_XOR": exp.BitwiseXorAgg.from_arg_list,
     773            "BIT_COUNT": exp.BitwiseCountAgg.from_arg_list,
     774            "BOOL": exp.JSONBool.from_arg_list,
     775            "CONTAINS_SUBSTR": _build_contains_substring,
     776            "DATE": _build_date,
     777            "DATE_ADD": build_date_delta_with_interval(exp.DateAdd),
     778            "DATE_SUB": build_date_delta_with_interval(exp.DateSub),
     779            "DATE_TRUNC": lambda args: exp.DateTrunc(
     780                unit=seq_get(args, 1),
     781                this=seq_get(args, 0),
     782                zone=seq_get(args, 2),
     783            ),
     784            "DATETIME": _build_datetime,
     785            "DATETIME_ADD": build_date_delta_with_interval(exp.DatetimeAdd),
     786            "DATETIME_SUB": build_date_delta_with_interval(exp.DatetimeSub),
     787            "DIV": binary_from_function(exp.IntDiv),
     788            "EDIT_DISTANCE": _build_levenshtein,
     789            "FORMAT_DATE": _build_format_time(exp.TsOrDsToDate),
     790            "GENERATE_ARRAY": exp.GenerateSeries.from_arg_list,
     791            "JSON_EXTRACT_SCALAR": _build_extract_json_with_default_path(exp.JSONExtractScalar),
     792            "JSON_EXTRACT_ARRAY": _build_extract_json_with_default_path(exp.JSONExtractArray),
     793            "JSON_EXTRACT_STRING_ARRAY": _build_extract_json_with_default_path(exp.JSONValueArray),
     794            "JSON_KEYS": exp.JSONKeysAtDepth.from_arg_list,
     795            "JSON_QUERY": parser.build_extract_json_with_path(exp.JSONExtract),
     796            "JSON_QUERY_ARRAY": _build_extract_json_with_default_path(exp.JSONExtractArray),
     797            "JSON_STRIP_NULLS": _build_json_strip_nulls,
     798            "JSON_VALUE": _build_extract_json_with_default_path(exp.JSONExtractScalar),
     799            "JSON_VALUE_ARRAY": _build_extract_json_with_default_path(exp.JSONValueArray),
     800            "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
     801            "MD5": exp.MD5Digest.from_arg_list,
     802            "NORMALIZE_AND_CASEFOLD": lambda args: exp.Normalize(
     803                this=seq_get(args, 0), form=seq_get(args, 1), is_casefold=True
     804            ),
     805            "OCTET_LENGTH": exp.ByteLength.from_arg_list,
     806            "TO_HEX": _build_to_hex,
     807            "PARSE_DATE": lambda args: build_formatted_time(exp.StrToDate, "bigquery")(
     808                [seq_get(args, 1), seq_get(args, 0)]
     809            ),
     810            "PARSE_TIME": lambda args: build_formatted_time(exp.ParseTime, "bigquery")(
     811                [seq_get(args, 1), seq_get(args, 0)]
     812            ),
     813            "PARSE_TIMESTAMP": _build_parse_timestamp,
     814            "PARSE_DATETIME": lambda args: build_formatted_time(exp.ParseDatetime, "bigquery")(
     815                [seq_get(args, 1), seq_get(args, 0)]
     816            ),
     817            "REGEXP_CONTAINS": exp.RegexpLike.from_arg_list,
     818            "REGEXP_EXTRACT": _build_regexp_extract(exp.RegexpExtract),
     819            "REGEXP_SUBSTR": _build_regexp_extract(exp.RegexpExtract),
     820            "REGEXP_EXTRACT_ALL": _build_regexp_extract(
     821                exp.RegexpExtractAll, default_group=exp.Literal.number(0)
     822            ),
     823            "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
     824            "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
     825            "SPLIT": lambda args: exp.Split(
     826                # https://cloud.google.com/bigquery/docs/reference/standard-sql/string_functions#split
     827                this=seq_get(args, 0),
     828                expression=seq_get(args, 1) or exp.Literal.string(","),
     829            ),
     830            "STRPOS": exp.StrPosition.from_arg_list,
     831            "TIME": _build_time,
     832            "TIME_ADD": build_date_delta_with_interval(exp.TimeAdd),
     833            "TIME_SUB": build_date_delta_with_interval(exp.TimeSub),
     834            "TIMESTAMP": _build_timestamp,
     835            "TIMESTAMP_ADD": build_date_delta_with_interval(exp.TimestampAdd),
     836            "TIMESTAMP_SUB": build_date_delta_with_interval(exp.TimestampSub),
     837            "TIMESTAMP_MICROS": lambda args: exp.UnixToTime(
     838                this=seq_get(args, 0), scale=exp.UnixToTime.MICROS
     839            ),
     840            "TIMESTAMP_MILLIS": lambda args: exp.UnixToTime(
     841                this=seq_get(args, 0), scale=exp.UnixToTime.MILLIS
     842            ),
     843            "TIMESTAMP_SECONDS": lambda args: exp.UnixToTime(this=seq_get(args, 0)),
     844            "TO_JSON": lambda args: exp.JSONFormat(
     845                this=seq_get(args, 0), options=seq_get(args, 1), to_json=True
     846            ),
     847            "TO_JSON_STRING": exp.JSONFormat.from_arg_list,
     848            "FORMAT_DATETIME": _build_format_time(exp.TsOrDsToDatetime),
     849            "FORMAT_TIMESTAMP": _build_format_time(exp.TsOrDsToTimestamp),
     850            "FORMAT_TIME": _build_format_time(exp.TsOrDsToTime),
     851            "FROM_HEX": exp.Unhex.from_arg_list,
     852            "WEEK": lambda args: exp.WeekStart(this=exp.var(seq_get(args, 0))),
     853        }
     854
     855        FUNCTION_PARSERS = {
     856            **parser.Parser.FUNCTION_PARSERS,
     857            "ARRAY": lambda self: self.expression(exp.Array, expressions=[self._parse_statement()]),
     858            "JSON_ARRAY": lambda self: self.expression(
     859                exp.JSONArray, expressions=self._parse_csv(self._parse_bitwise)
     860            ),
     861            "MAKE_INTERVAL": lambda self: self._parse_make_interval(),
     862            "PREDICT": lambda self: self._parse_ml(exp.Predict),
     863            "TRANSLATE": lambda self: self._parse_translate(),
     864            "FEATURES_AT_TIME": lambda self: self._parse_features_at_time(),
     865            "GENERATE_EMBEDDING": lambda self: self._parse_ml(exp.GenerateEmbedding),
     866            "GENERATE_TEXT_EMBEDDING": lambda self: self._parse_ml(
     867                exp.GenerateEmbedding, is_text=True
     868            ),
     869            "VECTOR_SEARCH": lambda self: self._parse_vector_search(),
     870            "FORECAST": lambda self: self._parse_ml(exp.MLForecast),
     871        }
     872        FUNCTION_PARSERS.pop("TRIM")
     873
     874        NO_PAREN_FUNCTIONS = {
     875            **parser.Parser.NO_PAREN_FUNCTIONS,
     876            TokenType.CURRENT_DATETIME: exp.CurrentDatetime,
     877        }
     878
     879        NESTED_TYPE_TOKENS = {
     880            *parser.Parser.NESTED_TYPE_TOKENS,
     881            TokenType.TABLE,
     882        }
     883
     884        PROPERTY_PARSERS = {
     885            **parser.Parser.PROPERTY_PARSERS,
     886            "NOT DETERMINISTIC": lambda self: self.expression(
     887                exp.StabilityProperty, this=exp.Literal.string("VOLATILE")
     888            ),
     889            "OPTIONS": lambda self: self._parse_with_property(),
     890        }
     891
     892        CONSTRAINT_PARSERS = {
     893            **parser.Parser.CONSTRAINT_PARSERS,
     894            "OPTIONS": lambda self: exp.Properties(expressions=self._parse_with_property()),
     895        }
     896
     897        RANGE_PARSERS = parser.Parser.RANGE_PARSERS.copy()
     898        RANGE_PARSERS.pop(TokenType.OVERLAPS)
     899
     900        DASHED_TABLE_PART_FOLLOW_TOKENS = {TokenType.DOT, TokenType.L_PAREN, TokenType.R_PAREN}
     901
     902        STATEMENT_PARSERS = {
     903            **parser.Parser.STATEMENT_PARSERS,
     904            TokenType.ELSE: lambda self: self._parse_as_command(self._prev),
     905            TokenType.END: lambda self: self._parse_as_command(self._prev),
     906            TokenType.FOR: lambda self: self._parse_for_in(),
     907            TokenType.EXPORT: lambda self: self._parse_export_data(),
     908            TokenType.DECLARE: lambda self: self._parse_declare(),
     909        }
     910
     911        BRACKET_OFFSETS = {
     912            "OFFSET": (0, False),
     913            "ORDINAL": (1, False),
     914            "SAFE_OFFSET": (0, True),
     915            "SAFE_ORDINAL": (1, True),
     916        }
     917
     918        def _parse_for_in(self) -> t.Union[exp.ForIn, exp.Command]:
     919            index = self._index
     920            this = self._parse_range()
     921            self._match_text_seq("DO")
     922            if self._match(TokenType.COMMAND):
     923                self._retreat(index)
     924                return self._parse_as_command(self._prev)
     925            return self.expression(exp.ForIn, this=this, expression=self._parse_statement())
     926
     927        def _parse_table_part(self, schema: bool = False) -> t.Optional[exp.Expression]:
     928            this = super()._parse_table_part(schema=schema) or self._parse_number()
     929
     930            # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#table_names
     931            if isinstance(this, exp.Identifier):
     932                table_name = this.name
     933                while self._match(TokenType.DASH, advance=False) and self._next:
     934                    start = self._curr
     935                    while self._is_connected() and not self._match_set(
     936                        self.DASHED_TABLE_PART_FOLLOW_TOKENS, advance=False
     937                    ):
     938                        self._advance()
     939
     940                    if start == self._curr:
     941                        break
     942
     943                    table_name += self._find_sql(start, self._prev)
     944
     945                this = exp.Identifier(
     946                    this=table_name, quoted=this.args.get("quoted")
     947                ).update_positions(this)
     948            elif isinstance(this, exp.Literal):
     949                table_name = this.name
     950
     951                if self._is_connected() and self._parse_var(any_token=True):
     952                    table_name += self._prev.text
     953
     954                this = exp.Identifier(this=table_name, quoted=True).update_positions(this)
     955
     956            return this
     957
     958        def _parse_table_parts(
     959            self, schema: bool = False, is_db_reference: bool = False, wildcard: bool = False
     960        ) -> exp.Table:
     961            table = super()._parse_table_parts(
     962                schema=schema, is_db_reference=is_db_reference, wildcard=True
     963            )
     964
     965            # proj-1.db.tbl -- `1.` is tokenized as a float so we need to unravel it here
     966            if not table.catalog:
     967                if table.db:
     968                    previous_db = table.args["db"]
     969                    parts = table.db.split(".")
     970                    if len(parts) == 2 and not table.args["db"].quoted:
     971                        table.set(
     972                            "catalog", exp.Identifier(this=parts[0]).update_positions(previous_db)
     973                        )
     974                        table.set("db", exp.Identifier(this=parts[1]).update_positions(previous_db))
     975                else:
     976                    previous_this = table.this
     977                    parts = table.name.split(".")
     978                    if len(parts) == 2 and not table.this.quoted:
     979                        table.set(
     980                            "db", exp.Identifier(this=parts[0]).update_positions(previous_this)
     981                        )
     982                        table.set(
     983                            "this", exp.Identifier(this=parts[1]).update_positions(previous_this)
     984                        )
     985
     986            if isinstance(table.this, exp.Identifier) and any("." in p.name for p in table.parts):
     987                alias = table.this
     988                catalog, db, this, *rest = (
     989                    exp.to_identifier(p, quoted=True)
     990                    for p in split_num_words(".".join(p.name for p in table.parts), ".", 3)
     991                )
     992
     993                for part in (catalog, db, this):
     994                    if part:
     995                        part.update_positions(table.this)
     996
     997                if rest and this:
     998                    this = exp.Dot.build([this, *rest])  # type: ignore
     999
    1000                table = exp.Table(
    1001                    this=this, db=db, catalog=catalog, pivots=table.args.get("pivots")
    1002                )
    1003                table.meta["quoted_table"] = True
    1004            else:
    1005                alias = None
    1006
    1007            # The `INFORMATION_SCHEMA` views in BigQuery need to be qualified by a region or
    1008            # dataset, so if the project identifier is omitted we need to fix the ast so that
    1009            # the `INFORMATION_SCHEMA.X` bit is represented as a single (quoted) Identifier.
    1010            # Otherwise, we wouldn't correctly qualify a `Table` node that references these
    1011            # views, because it would seem like the "catalog" part is set, when it'd actually
    1012            # be the region/dataset. Merging the two identifiers into a single one is done to
    1013            # avoid producing a 4-part Table reference, which would cause issues in the schema
    1014            # module, when there are 3-part table names mixed with information schema views.
    1015            #
    1016            # See: https://cloud.google.com/bigquery/docs/information-schema-intro#syntax
    1017            table_parts = table.parts
    1018            if len(table_parts) > 1 and table_parts[-2].name.upper() == "INFORMATION_SCHEMA":
    1019                # We need to alias the table here to avoid breaking existing qualified columns.
    1020                # This is expected to be safe, because if there's an actual alias coming up in
    1021                # the token stream, it will overwrite this one. If there isn't one, we are only
    1022                # exposing the name that can be used to reference the view explicitly (a no-op).
    1023                exp.alias_(
    1024                    table,
    1025                    t.cast(exp.Identifier, alias or table_parts[-1]),
    1026                    table=True,
    1027                    copy=False,
    1028                )
    1029
    1030                info_schema_view = f"{table_parts[-2].name}.{table_parts[-1].name}"
    1031                new_this = exp.Identifier(this=info_schema_view, quoted=True).update_positions(
    1032                    line=table_parts[-2].meta.get("line"),
    1033                    col=table_parts[-1].meta.get("col"),
    1034                    start=table_parts[-2].meta.get("start"),
    1035                    end=table_parts[-1].meta.get("end"),
    1036                )
    1037                table.set("this", new_this)
    1038                table.set("db", seq_get(table_parts, -3))
    1039                table.set("catalog", seq_get(table_parts, -4))
    1040
    1041            return table
    1042
    1043        def _parse_column(self) -> t.Optional[exp.Expression]:
    1044            column = super()._parse_column()
    1045            if isinstance(column, exp.Column):
    1046                parts = column.parts
    1047                if any("." in p.name for p in parts):
    1048                    catalog, db, table, this, *rest = (
    1049                        exp.to_identifier(p, quoted=True)
    1050                        for p in split_num_words(".".join(p.name for p in parts), ".", 4)
    1051                    )
    1052
    1053                    if rest and this:
    1054                        this = exp.Dot.build([this, *rest])  # type: ignore
    1055
    1056                    column = exp.Column(this=this, table=table, db=db, catalog=catalog)
    1057                    column.meta["quoted_column"] = True
    1058
    1059            return column
    1060
    1061        @t.overload
    1062        def _parse_json_object(self, agg: Lit[False]) -> exp.JSONObject: ...
    1063
    1064        @t.overload
    1065        def _parse_json_object(self, agg: Lit[True]) -> exp.JSONObjectAgg: ...
    1066
    1067        def _parse_json_object(self, agg=False):
    1068            json_object = super()._parse_json_object()
    1069            array_kv_pair = seq_get(json_object.expressions, 0)
    1070
    1071            # Converts BQ's "signature 2" of JSON_OBJECT into SQLGlot's canonical representation
    1072            # https://cloud.google.com/bigquery/docs/reference/standard-sql/json_functions#json_object_signature2
    1073            if (
    1074                array_kv_pair
    1075                and isinstance(array_kv_pair.this, exp.Array)
    1076                and isinstance(array_kv_pair.expression, exp.Array)
    1077            ):
    1078                keys = array_kv_pair.this.expressions
    1079                values = array_kv_pair.expression.expressions
    1080
    1081                json_object.set(
    1082                    "expressions",
    1083                    [exp.JSONKeyValue(this=k, expression=v) for k, v in zip(keys, values)],
    1084                )
    1085
    1086            return json_object
    1087
    1088        def _parse_bracket(
    1089            self, this: t.Optional[exp.Expression] = None
    1090        ) -> t.Optional[exp.Expression]:
    1091            bracket = super()._parse_bracket(this)
    1092
    1093            if this is bracket:
    1094                return bracket
    1095
    1096            if isinstance(bracket, exp.Bracket):
    1097                for expression in bracket.expressions:
    1098                    name = expression.name.upper()
    1099
    1100                    if name not in self.BRACKET_OFFSETS:
    1101                        break
    1102
    1103                    offset, safe = self.BRACKET_OFFSETS[name]
    1104                    bracket.set("offset", offset)
    1105                    bracket.set("safe", safe)
    1106                    expression.replace(expression.expressions[0])
    1107
    1108            return bracket
    1109
    1110        def _parse_unnest(self, with_alias: bool = True) -> t.Optional[exp.Unnest]:
    1111            unnest = super()._parse_unnest(with_alias=with_alias)
    1112
    1113            if not unnest:
    1114                return None
    1115
    1116            unnest_expr = seq_get(unnest.expressions, 0)
    1117            if unnest_expr:
    1118                from sqlglot.optimizer.annotate_types import annotate_types
    1119
    1120                unnest_expr = annotate_types(unnest_expr, dialect=self.dialect)
    1121
    1122                # Unnesting a nested array (i.e array of structs) explodes the top-level struct fields,
    1123                # in contrast to other dialects such as DuckDB which flattens only the array by default
    1124                if unnest_expr.is_type(exp.DataType.Type.ARRAY) and any(
    1125                    array_elem.is_type(exp.DataType.Type.STRUCT)
    1126                    for array_elem in unnest_expr._type.expressions
    1127                ):
    1128                    unnest.set("explode_array", True)
    1129
    1130            return unnest
    1131
    1132        def _parse_make_interval(self) -> exp.MakeInterval:
    1133            expr = exp.MakeInterval()
    1134
    1135            for arg_key in expr.arg_types:
    1136                value = self._parse_lambda()
    1137
    1138                if not value:
    1139                    break
    1140
    1141                # Non-named arguments are filled sequentially, (optionally) followed by named arguments
    1142                # that can appear in any order e.g MAKE_INTERVAL(1, minute => 5, day => 2)
    1143                if isinstance(value, exp.Kwarg):
    1144                    arg_key = value.this.name
    1145
    1146                expr.set(arg_key, value)
    1147
    1148                self._match(TokenType.COMMA)
    1149
    1150            return expr
    1151
    1152        def _parse_ml(self, expr_type: t.Type[E], **kwargs) -> E:
    1153            self._match_text_seq("MODEL")
    1154            this = self._parse_table()
    1155
    1156            self._match(TokenType.COMMA)
    1157            self._match_text_seq("TABLE")
    1158
    1159            # Certain functions like ML.FORECAST require a STRUCT argument but not a TABLE/SELECT one
    1160            expression = (
    1161                self._parse_table() if not self._match(TokenType.STRUCT, advance=False) else None
    1162            )
    1163
    1164            self._match(TokenType.COMMA)
    1165
    1166            return self.expression(
    1167                expr_type,
    1168                this=this,
    1169                expression=expression,
    1170                params_struct=self._parse_bitwise(),
    1171                **kwargs,
    1172            )
    1173
    1174        def _parse_translate(self) -> exp.Translate | exp.MLTranslate:
    1175            # Check if this is ML.TRANSLATE by looking at previous tokens
    1176            token = seq_get(self._tokens, self._index - 4)
    1177            if token and token.text.upper() == "ML":
    1178                return self._parse_ml(exp.MLTranslate)
    1179
    1180            return exp.Translate.from_arg_list(self._parse_function_args())
    1181
    1182        def _parse_features_at_time(self) -> exp.FeaturesAtTime:
    1183            self._match(TokenType.TABLE)
    1184            this = self._parse_table()
    1185
    1186            expr = self.expression(exp.FeaturesAtTime, this=this)
    1187
    1188            while self._match(TokenType.COMMA):
    1189                arg = self._parse_lambda()
    1190
    1191                # Get the LHS of the Kwarg and set the arg to that value, e.g
    1192                # "num_rows => 1" sets the expr's `num_rows` arg
    1193                if arg:
    1194                    expr.set(arg.this.name, arg)
    1195
    1196            return expr
    1197
    1198        def _parse_vector_search(self) -> exp.VectorSearch:
    1199            self._match(TokenType.TABLE)
    1200            base_table = self._parse_table()
    1201
    1202            self._match(TokenType.COMMA)
    1203
    1204            column_to_search = self._parse_bitwise()
    1205            self._match(TokenType.COMMA)
    1206
    1207            self._match(TokenType.TABLE)
    1208            query_table = self._parse_table()
    1209
    1210            expr = self.expression(
    1211                exp.VectorSearch,
    1212                this=base_table,
    1213                column_to_search=column_to_search,
    1214                query_table=query_table,
    1215            )
    1216
    1217            while self._match(TokenType.COMMA):
    1218                # query_column_to_search can be named argument or positional
    1219                if self._match(TokenType.STRING, advance=False):
    1220                    query_column = self._parse_string()
    1221                    expr.set("query_column_to_search", query_column)
    1222                else:
    1223                    arg = self._parse_lambda()
    1224                    if arg:
    1225                        expr.set(arg.this.name, arg)
    1226
    1227            return expr
    1228
    1229        def _parse_export_data(self) -> exp.Export:
    1230            self._match_text_seq("DATA")
    1231
    1232            return self.expression(
    1233                exp.Export,
    1234                connection=self._match_text_seq("WITH", "CONNECTION") and self._parse_table_parts(),
    1235                options=self._parse_properties(),
    1236                this=self._match_text_seq("AS") and self._parse_select(),
    1237            )
    1238
    1239    class Generator(generator.Generator):
    1240        INTERVAL_ALLOWS_PLURAL_FORM = False
    1241        JOIN_HINTS = False
    1242        QUERY_HINTS = False
    1243        TABLE_HINTS = False
    1244        LIMIT_FETCH = "LIMIT"
    1245        RENAME_TABLE_WITH_DB = False
    1246        NVL2_SUPPORTED = False
    1247        UNNEST_WITH_ORDINALITY = False
    1248        COLLATE_IS_FUNC = True
    1249        LIMIT_ONLY_LITERALS = True
    1250        SUPPORTS_TABLE_ALIAS_COLUMNS = False
    1251        UNPIVOT_ALIASES_ARE_IDENTIFIERS = False
    1252        JSON_KEY_VALUE_PAIR_SEP = ","
    1253        NULL_ORDERING_SUPPORTED = False
    1254        IGNORE_NULLS_IN_FUNC = True
    1255        JSON_PATH_SINGLE_QUOTE_ESCAPE = True
    1256        CAN_IMPLEMENT_ARRAY_ANY = True
    1257        SUPPORTS_TO_NUMBER = False
    1258        NAMED_PLACEHOLDER_TOKEN = "@"
    1259        HEX_FUNC = "TO_HEX"
    1260        WITH_PROPERTIES_PREFIX = "OPTIONS"
    1261        SUPPORTS_EXPLODING_PROJECTIONS = False
    1262        EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE = False
    1263        SUPPORTS_UNIX_SECONDS = True
    1264
    1265        SAFE_JSON_PATH_KEY_RE = re.compile(r"^[_\-a-zA-Z][\-\w]*$")
    1266
    1267        TS_OR_DS_TYPES = (
    1268            exp.TsOrDsToDatetime,
    1269            exp.TsOrDsToTimestamp,
    1270            exp.TsOrDsToTime,
    1271            exp.TsOrDsToDate,
    1272        )
    1273
    1274        TRANSFORMS = {
    1275            **generator.Generator.TRANSFORMS,
    1276            exp.ApproxTopK: rename_func("APPROX_TOP_COUNT"),
    1277            exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
    1278            exp.ArgMax: arg_max_or_min_no_count("MAX_BY"),
    1279            exp.ArgMin: arg_max_or_min_no_count("MIN_BY"),
    1280            exp.Array: inline_array_unless_query,
    1281            exp.ArrayContains: _array_contains_sql,
    1282            exp.ArrayFilter: filter_array_using_unnest,
    1283            exp.ArrayRemove: filter_array_using_unnest,
    1284            exp.BitwiseAndAgg: rename_func("BIT_AND"),
    1285            exp.BitwiseOrAgg: rename_func("BIT_OR"),
    1286            exp.BitwiseXorAgg: rename_func("BIT_XOR"),
    1287            exp.BitwiseCountAgg: rename_func("BIT_COUNT"),
    1288            exp.ByteLength: rename_func("BYTE_LENGTH"),
    1289            exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]),
    1290            exp.CollateProperty: lambda self, e: (
    1291                f"DEFAULT COLLATE {self.sql(e, 'this')}"
    1292                if e.args.get("default")
    1293                else f"COLLATE {self.sql(e, 'this')}"
    1294            ),
    1295            exp.Commit: lambda *_: "COMMIT TRANSACTION",
    1296            exp.CountIf: rename_func("COUNTIF"),
    1297            exp.Create: _create_sql,
    1298            exp.CTE: transforms.preprocess([_pushdown_cte_column_names]),
    1299            exp.DateAdd: date_add_interval_sql("DATE", "ADD"),
    1300            exp.DateDiff: lambda self, e: self.func(
    1301                "DATE_DIFF", e.this, e.expression, unit_to_var(e)
    1302            ),
    1303            exp.DateFromParts: rename_func("DATE"),
    1304            exp.DateStrToDate: datestrtodate_sql,
    1305            exp.DateSub: date_add_interval_sql("DATE", "SUB"),
    1306            exp.DatetimeAdd: date_add_interval_sql("DATETIME", "ADD"),
    1307            exp.DatetimeSub: date_add_interval_sql("DATETIME", "SUB"),
    1308            exp.DateFromUnixDate: rename_func("DATE_FROM_UNIX_DATE"),
    1309            exp.FromTimeZone: lambda self, e: self.func(
    1310                "DATETIME", self.func("TIMESTAMP", e.this, e.args.get("zone")), "'UTC'"
    1311            ),
    1312            exp.GenerateSeries: rename_func("GENERATE_ARRAY"),
    1313            exp.GroupConcat: lambda self, e: groupconcat_sql(
    1314                self, e, func_name="STRING_AGG", within_group=False
    1315            ),
    1316            exp.Hex: lambda self, e: self.func("UPPER", self.func("TO_HEX", self.sql(e, "this"))),
    1317            exp.HexString: lambda self, e: self.hexstring_sql(e, binary_function_repr="FROM_HEX"),
    1318            exp.If: if_sql(false_value="NULL"),
    1319            exp.ILike: no_ilike_sql,
    1320            exp.IntDiv: rename_func("DIV"),
    1321            exp.Int64: rename_func("INT64"),
    1322            exp.JSONBool: rename_func("BOOL"),
    1323            exp.JSONExtract: _json_extract_sql,
    1324            exp.JSONExtractArray: _json_extract_sql,
    1325            exp.JSONExtractScalar: _json_extract_sql,
    1326            exp.JSONFormat: lambda self, e: self.func(
    1327                "TO_JSON" if e.args.get("to_json") else "TO_JSON_STRING",
    1328                e.this,
    1329                e.args.get("options"),
    1330            ),
    1331            exp.JSONKeysAtDepth: rename_func("JSON_KEYS"),
    1332            exp.JSONValueArray: rename_func("JSON_VALUE_ARRAY"),
    1333            exp.Levenshtein: _levenshtein_sql,
    1334            exp.Max: max_or_greatest,
    1335            exp.MD5: lambda self, e: self.func("TO_HEX", self.func("MD5", e.this)),
    1336            exp.MD5Digest: rename_func("MD5"),
    1337            exp.Min: min_or_least,
    1338            exp.Normalize: lambda self, e: self.func(
    1339                "NORMALIZE_AND_CASEFOLD" if e.args.get("is_casefold") else "NORMALIZE",
    1340                e.this,
    1341                e.args.get("form"),
    1342            ),
    1343            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
    1344            exp.RegexpExtract: lambda self, e: self.func(
    1345                "REGEXP_EXTRACT",
    1346                e.this,
    1347                e.expression,
    1348                e.args.get("position"),
    1349                e.args.get("occurrence"),
    1350            ),
    1351            exp.RegexpExtractAll: lambda self, e: self.func(
    1352                "REGEXP_EXTRACT_ALL", e.this, e.expression
    1353            ),
    1354            exp.RegexpReplace: regexp_replace_sql,
    1355            exp.RegexpLike: rename_func("REGEXP_CONTAINS"),
    1356            exp.ReturnsProperty: _returnsproperty_sql,
    1357            exp.Rollback: lambda *_: "ROLLBACK TRANSACTION",
    1358            exp.ParseTime: lambda self, e: self.func("PARSE_TIME", self.format_time(e), e.this),
    1359            exp.ParseDatetime: lambda self, e: self.func(
    1360                "PARSE_DATETIME", self.format_time(e), e.this
    1361            ),
    1362            exp.Select: transforms.preprocess(
    1363                [
    1364                    transforms.explode_projection_to_unnest(),
    1365                    transforms.unqualify_unnest,
    1366                    transforms.eliminate_distinct_on,
    1367                    _alias_ordered_group,
    1368                    transforms.eliminate_semi_and_anti_joins,
    1369                ]
    1370            ),
    1371            exp.SHA: rename_func("SHA1"),
    1372            exp.SHA2: sha256_sql,
    1373            exp.StabilityProperty: lambda self, e: (
    1374                "DETERMINISTIC" if e.name == "IMMUTABLE" else "NOT DETERMINISTIC"
    1375            ),
    1376            exp.String: rename_func("STRING"),
    1377            exp.StrPosition: lambda self, e: (
    1378                strposition_sql(
    1379                    self, e, func_name="INSTR", supports_position=True, supports_occurrence=True
    1380                )
    1381            ),
    1382            exp.StrToDate: _str_to_datetime_sql,
    1383            exp.StrToTime: _str_to_datetime_sql,
    1384            exp.TimeAdd: date_add_interval_sql("TIME", "ADD"),
    1385            exp.TimeFromParts: rename_func("TIME"),
    1386            exp.TimestampFromParts: rename_func("DATETIME"),
    1387            exp.TimeSub: date_add_interval_sql("TIME", "SUB"),
    1388            exp.TimestampAdd: date_add_interval_sql("TIMESTAMP", "ADD"),
    1389            exp.TimestampDiff: rename_func("TIMESTAMP_DIFF"),
    1390            exp.TimestampSub: date_add_interval_sql("TIMESTAMP", "SUB"),
    1391            exp.TimeStrToTime: timestrtotime_sql,
    1392            exp.Transaction: lambda *_: "BEGIN TRANSACTION",
    1393            exp.TsOrDsAdd: _ts_or_ds_add_sql,
    1394            exp.TsOrDsDiff: _ts_or_ds_diff_sql,
    1395            exp.TsOrDsToTime: rename_func("TIME"),
    1396            exp.TsOrDsToDatetime: rename_func("DATETIME"),
    1397            exp.TsOrDsToTimestamp: rename_func("TIMESTAMP"),
    1398            exp.Unhex: rename_func("FROM_HEX"),
    1399            exp.UnixDate: rename_func("UNIX_DATE"),
    1400            exp.UnixToTime: _unix_to_time_sql,
    1401            exp.Uuid: lambda *_: "GENERATE_UUID()",
    1402            exp.Values: _derived_table_values_to_unnest,
    1403            exp.VariancePop: rename_func("VAR_POP"),
    1404            exp.SafeDivide: rename_func("SAFE_DIVIDE"),
    1405        }
    1406
    1407        SUPPORTED_JSON_PATH_PARTS = {
    1408            exp.JSONPathKey,
    1409            exp.JSONPathRoot,
    1410            exp.JSONPathSubscript,
    1411        }
    1412
    1413        TYPE_MAPPING = {
    1414            **generator.Generator.TYPE_MAPPING,
    1415            exp.DataType.Type.BIGDECIMAL: "BIGNUMERIC",
    1416            exp.DataType.Type.BIGINT: "INT64",
    1417            exp.DataType.Type.BINARY: "BYTES",
    1418            exp.DataType.Type.BLOB: "BYTES",
    1419            exp.DataType.Type.BOOLEAN: "BOOL",
    1420            exp.DataType.Type.CHAR: "STRING",
    1421            exp.DataType.Type.DECIMAL: "NUMERIC",
    1422            exp.DataType.Type.DOUBLE: "FLOAT64",
    1423            exp.DataType.Type.FLOAT: "FLOAT64",
    1424            exp.DataType.Type.INT: "INT64",
    1425            exp.DataType.Type.NCHAR: "STRING",
    1426            exp.DataType.Type.NVARCHAR: "STRING",
    1427            exp.DataType.Type.SMALLINT: "INT64",
    1428            exp.DataType.Type.TEXT: "STRING",
    1429            exp.DataType.Type.TIMESTAMP: "DATETIME",
    1430            exp.DataType.Type.TIMESTAMPNTZ: "DATETIME",
    1431            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
    1432            exp.DataType.Type.TIMESTAMPLTZ: "TIMESTAMP",
    1433            exp.DataType.Type.TINYINT: "INT64",
    1434            exp.DataType.Type.ROWVERSION: "BYTES",
    1435            exp.DataType.Type.UUID: "STRING",
    1436            exp.DataType.Type.VARBINARY: "BYTES",
    1437            exp.DataType.Type.VARCHAR: "STRING",
    1438            exp.DataType.Type.VARIANT: "ANY TYPE",
    1439        }
    1440
    1441        PROPERTIES_LOCATION = {
    1442            **generator.Generator.PROPERTIES_LOCATION,
    1443            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
    1444            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
    1445        }
    1446
    1447        # WINDOW comes after QUALIFY
    1448        # https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#window_clause
    1449        AFTER_HAVING_MODIFIER_TRANSFORMS = {
    1450            "qualify": generator.Generator.AFTER_HAVING_MODIFIER_TRANSFORMS["qualify"],
    1451            "windows": generator.Generator.AFTER_HAVING_MODIFIER_TRANSFORMS["windows"],
    1452        }
    1453
    1454        # from: https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#reserved_keywords
    1455        RESERVED_KEYWORDS = {
    1456            "all",
    1457            "and",
    1458            "any",
    1459            "array",
    1460            "as",
    1461            "asc",
    1462            "assert_rows_modified",
    1463            "at",
    1464            "between",
    1465            "by",
    1466            "case",
    1467            "cast",
    1468            "collate",
    1469            "contains",
    1470            "create",
    1471            "cross",
    1472            "cube",
    1473            "current",
    1474            "default",
    1475            "define",
    1476            "desc",
    1477            "distinct",
    1478            "else",
    1479            "end",
    1480            "enum",
    1481            "escape",
    1482            "except",
    1483            "exclude",
    1484            "exists",
    1485            "extract",
    1486            "false",
    1487            "fetch",
    1488            "following",
    1489            "for",
    1490            "from",
    1491            "full",
    1492            "group",
    1493            "grouping",
    1494            "groups",
    1495            "hash",
    1496            "having",
    1497            "if",
    1498            "ignore",
    1499            "in",
    1500            "inner",
    1501            "intersect",
    1502            "interval",
    1503            "into",
    1504            "is",
    1505            "join",
    1506            "lateral",
    1507            "left",
    1508            "like",
    1509            "limit",
    1510            "lookup",
    1511            "merge",
    1512            "natural",
    1513            "new",
    1514            "no",
    1515            "not",
    1516            "null",
    1517            "nulls",
    1518            "of",
    1519            "on",
    1520            "or",
    1521            "order",
    1522            "outer",
    1523            "over",
    1524            "partition",
    1525            "preceding",
    1526            "proto",
    1527            "qualify",
    1528            "range",
    1529            "recursive",
    1530            "respect",
    1531            "right",
    1532            "rollup",
    1533            "rows",
    1534            "select",
    1535            "set",
    1536            "some",
    1537            "struct",
    1538            "tablesample",
    1539            "then",
    1540            "to",
    1541            "treat",
    1542            "true",
    1543            "unbounded",
    1544            "union",
    1545            "unnest",
    1546            "using",
    1547            "when",
    1548            "where",
    1549            "window",
    1550            "with",
    1551            "within",
    1552        }
    1553
    1554        def datetrunc_sql(self, expression: exp.DateTrunc) -> str:
    1555            unit = expression.unit
    1556            unit_sql = unit.name if unit.is_string else self.sql(unit)
    1557            return self.func("DATE_TRUNC", expression.this, unit_sql, expression.args.get("zone"))
    1558
    1559        def mod_sql(self, expression: exp.Mod) -> str:
    1560            this = expression.this
    1561            expr = expression.expression
    1562            return self.func(
    1563                "MOD",
    1564                this.unnest() if isinstance(this, exp.Paren) else this,
    1565                expr.unnest() if isinstance(expr, exp.Paren) else expr,
    1566            )
    1567
    1568        def column_parts(self, expression: exp.Column) -> str:
    1569            if expression.meta.get("quoted_column"):
    1570                # If a column reference is of the form `dataset.table`.name, we need
    1571                # to preserve the quoted table path, otherwise the reference breaks
    1572                table_parts = ".".join(p.name for p in expression.parts[:-1])
    1573                table_path = self.sql(exp.Identifier(this=table_parts, quoted=True))
    1574                return f"{table_path}.{self.sql(expression, 'this')}"
    1575
    1576            return super().column_parts(expression)
    1577
    1578        def table_parts(self, expression: exp.Table) -> str:
    1579            # Depending on the context, `x.y` may not resolve to the same data source as `x`.`y`, so
    1580            # we need to make sure the correct quoting is used in each case.
    1581            #
    1582            # For example, if there is a CTE x that clashes with a schema name, then the former will
    1583            # return the table y in that schema, whereas the latter will return the CTE's y column:
    1584            #
    1585            # - WITH x AS (SELECT [1, 2] AS y) SELECT * FROM x, `x.y`   -> cross join
    1586            # - WITH x AS (SELECT [1, 2] AS y) SELECT * FROM x, `x`.`y` -> implicit unnest
    1587            if expression.meta.get("quoted_table"):
    1588                table_parts = ".".join(p.name for p in expression.parts)
    1589                return self.sql(exp.Identifier(this=table_parts, quoted=True))
    1590
    1591            return super().table_parts(expression)
    1592
    1593        def timetostr_sql(self, expression: exp.TimeToStr) -> str:
    1594            this = expression.this
    1595            if isinstance(this, exp.TsOrDsToDatetime):
    1596                func_name = "FORMAT_DATETIME"
    1597            elif isinstance(this, exp.TsOrDsToTimestamp):
    1598                func_name = "FORMAT_TIMESTAMP"
    1599            elif isinstance(this, exp.TsOrDsToTime):
    1600                func_name = "FORMAT_TIME"
    1601            else:
    1602                func_name = "FORMAT_DATE"
    1603
    1604            time_expr = this if isinstance(this, self.TS_OR_DS_TYPES) else expression
    1605            return self.func(
    1606                func_name, self.format_time(expression), time_expr.this, expression.args.get("zone")
    1607            )
    1608
    1609        def eq_sql(self, expression: exp.EQ) -> str:
    1610            # Operands of = cannot be NULL in BigQuery
    1611            if isinstance(expression.left, exp.Null) or isinstance(expression.right, exp.Null):
    1612                if not isinstance(expression.parent, exp.Update):
    1613                    return "NULL"
    1614
    1615            return self.binary(expression, "=")
    1616
    1617        def attimezone_sql(self, expression: exp.AtTimeZone) -> str:
    1618            parent = expression.parent
    1619
    1620            # BigQuery allows CAST(.. AS {STRING|TIMESTAMP} [FORMAT <fmt> [AT TIME ZONE <tz>]]).
    1621            # Only the TIMESTAMP one should use the below conversion, when AT TIME ZONE is included.
    1622            if not isinstance(parent, exp.Cast) or not parent.to.is_type("text"):
    1623                return self.func(
    1624                    "TIMESTAMP", self.func("DATETIME", expression.this, expression.args.get("zone"))
    1625                )
    1626
    1627            return super().attimezone_sql(expression)
    1628
    1629        def trycast_sql(self, expression: exp.TryCast) -> str:
    1630            return self.cast_sql(expression, safe_prefix="SAFE_")
    1631
    1632        def bracket_sql(self, expression: exp.Bracket) -> str:
    1633            this = expression.this
    1634            expressions = expression.expressions
    1635
    1636            if len(expressions) == 1 and this and this.is_type(exp.DataType.Type.STRUCT):
    1637                arg = expressions[0]
    1638                if arg.type is None:
    1639                    from sqlglot.optimizer.annotate_types import annotate_types
    1640
    1641                    arg = annotate_types(arg, dialect=self.dialect)
    1642
    1643                if arg.type and arg.type.this in exp.DataType.TEXT_TYPES:
    1644                    # BQ doesn't support bracket syntax with string values for structs
    1645                    return f"{self.sql(this)}.{arg.name}"
    1646
    1647            expressions_sql = self.expressions(expression, flat=True)
    1648            offset = expression.args.get("offset")
    1649
    1650            if offset == 0:
    1651                expressions_sql = f"OFFSET({expressions_sql})"
    1652            elif offset == 1:
    1653                expressions_sql = f"ORDINAL({expressions_sql})"
    1654            elif offset is not None:
    1655                self.unsupported(f"Unsupported array offset: {offset}")
    1656
    1657            if expression.args.get("safe"):
    1658                expressions_sql = f"SAFE_{expressions_sql}"
    1659
    1660            return f"{self.sql(this)}[{expressions_sql}]"
    1661
    1662        def in_unnest_op(self, expression: exp.Unnest) -> str:
    1663            return self.sql(expression)
    1664
    1665        def version_sql(self, expression: exp.Version) -> str:
    1666            if expression.name == "TIMESTAMP":
    1667                expression.set("this", "SYSTEM_TIME")
    1668            return super().version_sql(expression)
    1669
    1670        def contains_sql(self, expression: exp.Contains) -> str:
    1671            this = expression.this
    1672            expr = expression.expression
    1673
    1674            if isinstance(this, exp.Lower) and isinstance(expr, exp.Lower):
    1675                this = this.this
    1676                expr = expr.this
    1677
    1678            return self.func("CONTAINS_SUBSTR", this, expr, expression.args.get("json_scope"))
    1679
    1680        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
    1681            this = expression.this
    1682
    1683            # This ensures that inline type-annotated ARRAY literals like ARRAY<INT64>[1, 2, 3]
    1684            # are roundtripped unaffected. The inner check excludes ARRAY(SELECT ...) expressions,
    1685            # because they aren't literals and so the above syntax is invalid BigQuery.
    1686            if isinstance(this, exp.Array):
    1687                elem = seq_get(this.expressions, 0)
    1688                if not (elem and elem.find(exp.Query)):
    1689                    return f"{self.sql(expression, 'to')}{self.sql(this)}"
    1690
    1691            return super().cast_sql(expression, safe_prefix=safe_prefix)
    1692
    1693        def declareitem_sql(self, expression: exp.DeclareItem) -> str:
    1694            variables = self.expressions(expression, "this")
    1695            default = self.sql(expression, "default")
    1696            default = f" DEFAULT {default}" if default else ""
    1697            kind = self.sql(expression, "kind")
    1698            kind = f" {kind}" if kind else ""
    1699
    1700            return f"{variables}{kind}{default}"

logger = <Logger sqlglot (WARNING)>
JSON_EXTRACT_TYPE = typing.Union[sqlglot.expressions.JSONExtract, sqlglot.expressions.JSONExtractScalar, sqlglot.expressions.JSONExtractArray]
DQUOTES_ESCAPING_JSON_FUNCTIONS = ('JSON_QUERY', 'JSON_VALUE', 'JSON_QUERY_ARRAY')
class BigQuery(sqlglot.dialects.dialect.Dialect): View Source

     440class BigQuery(Dialect):
     441    WEEK_OFFSET = -1
     442    UNNEST_COLUMN_ONLY = True
     443    SUPPORTS_USER_DEFINED_TYPES = False
     444    SUPPORTS_SEMI_ANTI_JOIN = False
     445    LOG_BASE_FIRST = False
     446    HEX_LOWERCASE = True
     447    FORCE_EARLY_ALIAS_REF_EXPANSION = True
     448    PRESERVE_ORIGINAL_NAMES = True
     449    HEX_STRING_IS_INTEGER_TYPE = True
     450
     451    # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#case_sensitivity
     452    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
     453
     454    # bigquery udfs are case sensitive
     455    NORMALIZE_FUNCTIONS = False
     456
     457    # https://cloud.google.com/bigquery/docs/reference/standard-sql/format-elements#format_elements_date_time
     458    TIME_MAPPING = {
     459        "%D": "%m/%d/%y",
     460        "%E6S": "%S.%f",
     461        "%e": "%-d",
     462    }
     463
     464    FORMAT_MAPPING = {
     465        "DD": "%d",
     466        "MM": "%m",
     467        "MON": "%b",
     468        "MONTH": "%B",
     469        "YYYY": "%Y",
     470        "YY": "%y",
     471        "HH": "%I",
     472        "HH12": "%I",
     473        "HH24": "%H",
     474        "MI": "%M",
     475        "SS": "%S",
     476        "SSSSS": "%f",
     477        "TZH": "%z",
     478    }
     479
     480    # The _PARTITIONTIME and _PARTITIONDATE pseudo-columns are not returned by a SELECT * statement
     481    # https://cloud.google.com/bigquery/docs/querying-partitioned-tables#query_an_ingestion-time_partitioned_table
     482    # https://cloud.google.com/bigquery/docs/querying-wildcard-tables#scanning_a_range_of_tables_using_table_suffix
     483    # https://cloud.google.com/bigquery/docs/query-cloud-storage-data#query_the_file_name_pseudo-column
     484    PSEUDOCOLUMNS = {"_PARTITIONTIME", "_PARTITIONDATE", "_TABLE_SUFFIX", "_FILE_NAME"}
     485
     486    # All set operations require either a DISTINCT or ALL specifier
     487    SET_OP_DISTINCT_BY_DEFAULT = dict.fromkeys((exp.Except, exp.Intersect, exp.Union), None)
     488
     489    # https://cloud.google.com/bigquery/docs/reference/standard-sql/navigation_functions#percentile_cont
     490    COERCES_TO = {
     491        **TypeAnnotator.COERCES_TO,
     492        exp.DataType.Type.BIGDECIMAL: {exp.DataType.Type.DOUBLE},
     493    }
     494    COERCES_TO[exp.DataType.Type.DECIMAL] |= {exp.DataType.Type.BIGDECIMAL}
     495    COERCES_TO[exp.DataType.Type.BIGINT] |= {exp.DataType.Type.BIGDECIMAL}
     496
     497    # BigQuery maps Type.TIMESTAMP to DATETIME, so we need to amend the inferred types
     498    TYPE_TO_EXPRESSIONS = {
     499        **Dialect.TYPE_TO_EXPRESSIONS,
     500        exp.DataType.Type.TIMESTAMPTZ: Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.TIMESTAMP],
     501    }
     502    TYPE_TO_EXPRESSIONS.pop(exp.DataType.Type.TIMESTAMP)
     503
     504    ANNOTATORS = {
     505        **Dialect.ANNOTATORS,
     506        **{
     507            expr_type: annotate_with_type_lambda(data_type)
     508            for data_type, expressions in TYPE_TO_EXPRESSIONS.items()
     509            for expr_type in expressions
     510        },
     511        **{
     512            expr_type: lambda self, e: _annotate_math_functions(self, e)
     513            for expr_type in (exp.Floor, exp.Ceil, exp.Log, exp.Ln, exp.Sqrt, exp.Exp, exp.Round)
     514        },
     515        **{
     516            expr_type: lambda self, e: self._annotate_by_args(e, "this")
     517            for expr_type in (
     518                exp.Abs,
     519                exp.ArgMax,
     520                exp.ArgMin,
     521                exp.DateTrunc,
     522                exp.DatetimeTrunc,
     523                exp.FirstValue,
     524                exp.GroupConcat,
     525                exp.IgnoreNulls,
     526                exp.JSONExtract,
     527                exp.Lead,
     528                exp.Left,
     529                exp.Lower,
     530                exp.NthValue,
     531                exp.Pad,
     532                exp.PercentileDisc,
     533                exp.RegexpExtract,
     534                exp.RegexpReplace,
     535                exp.Repeat,
     536                exp.Replace,
     537                exp.RespectNulls,
     538                exp.Reverse,
     539                exp.Right,
     540                exp.SafeNegate,
     541                exp.Sign,
     542                exp.Substring,
     543                exp.TimestampTrunc,
     544                exp.Translate,
     545                exp.Trim,
     546                exp.Upper,
     547            )
     548        },
     549        exp.Acos: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     550        exp.Acosh: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     551        exp.Asin: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     552        exp.Asinh: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     553        exp.Atan: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     554        exp.Atanh: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     555        exp.Atan2: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     556        exp.ApproxTopSum: lambda self, e: _annotate_by_args_approx_top(self, e),
     557        exp.ApproxTopK: lambda self, e: _annotate_by_args_approx_top(self, e),
     558        exp.ApproxQuantiles: lambda self, e: self._annotate_by_args(e, "this", array=True),
     559        exp.Array: _annotate_array,
     560        exp.ArrayConcat: lambda self, e: self._annotate_by_args(e, "this", "expressions"),
     561        exp.Ascii: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     562        exp.BitwiseAndAgg: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     563        exp.BitwiseOrAgg: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     564        exp.BitwiseXorAgg: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     565        exp.BitwiseCountAgg: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     566        exp.ByteLength: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     567        exp.ByteString: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
     568        exp.Cbrt: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     569        exp.CodePointsToBytes: lambda self, e: self._annotate_with_type(
     570            e, exp.DataType.Type.BINARY
     571        ),
     572        exp.CodePointsToString: lambda self, e: self._annotate_with_type(
     573            e, exp.DataType.Type.VARCHAR
     574        ),
     575        exp.Concat: _annotate_concat,
     576        exp.Corr: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     577        exp.Cot: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     578        exp.CosineDistance: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     579        exp.Coth: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     580        exp.CovarPop: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     581        exp.CovarSamp: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     582        exp.Csc: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     583        exp.Csch: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     584        exp.CumeDist: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     585        exp.DateFromUnixDate: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DATE),
     586        exp.DenseRank: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     587        exp.EuclideanDistance: lambda self, e: self._annotate_with_type(
     588            e, exp.DataType.Type.DOUBLE
     589        ),
     590        exp.FarmFingerprint: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     591        exp.Unhex: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
     592        exp.Float64: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     593        exp.Format: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     594        exp.GenerateTimestampArray: lambda self, e: self._annotate_with_type(
     595            e, exp.DataType.build("ARRAY<TIMESTAMP>", dialect="bigquery")
     596        ),
     597        exp.Grouping: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     598        exp.IsInf: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BOOLEAN),
     599        exp.IsNan: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BOOLEAN),
     600        exp.JSONArray: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
     601        exp.JSONArrayAppend: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
     602        exp.JSONArrayInsert: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
     603        exp.JSONBool: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BOOLEAN),
     604        exp.JSONExtractScalar: lambda self, e: self._annotate_with_type(
     605            e, exp.DataType.Type.VARCHAR
     606        ),
     607        exp.JSONExtractArray: lambda self, e: self._annotate_by_args(e, "this", array=True),
     608        exp.JSONFormat: lambda self, e: self._annotate_with_type(
     609            e, exp.DataType.Type.JSON if e.args.get("to_json") else exp.DataType.Type.VARCHAR
     610        ),
     611        exp.JSONKeysAtDepth: lambda self, e: self._annotate_with_type(
     612            e, exp.DataType.build("ARRAY<VARCHAR>", dialect="bigquery")
     613        ),
     614        exp.JSONObject: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
     615        exp.JSONRemove: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
     616        exp.JSONSet: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
     617        exp.JSONStripNulls: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
     618        exp.JSONType: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     619        exp.JSONValueArray: lambda self, e: self._annotate_with_type(
     620            e, exp.DataType.build("ARRAY<VARCHAR>", dialect="bigquery")
     621        ),
     622        exp.Lag: lambda self, e: self._annotate_by_args(e, "this", "default"),
     623        exp.LowerHex: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     624        exp.LaxBool: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BOOLEAN),
     625        exp.LaxFloat64: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     626        exp.LaxInt64: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     627        exp.LaxString: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     628        exp.MD5Digest: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
     629        exp.Normalize: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     630        exp.Ntile: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     631        exp.ParseTime: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
     632        exp.ParseDatetime: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DATETIME),
     633        exp.ParseBignumeric: lambda self, e: self._annotate_with_type(
     634            e, exp.DataType.Type.BIGDECIMAL
     635        ),
     636        exp.ParseNumeric: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DECIMAL),
     637        exp.PercentileCont: lambda self, e: _annotate_by_args_with_coerce(self, e),
     638        exp.PercentRank: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     639        exp.Rank: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     640        exp.RangeBucket: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     641        exp.RegexpExtractAll: lambda self, e: self._annotate_by_args(e, "this", array=True),
     642        exp.RegexpInstr: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     643        exp.RowNumber: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     644        exp.Rand: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     645        exp.SafeConvertBytesToString: lambda self, e: self._annotate_with_type(
     646            e, exp.DataType.Type.VARCHAR
     647        ),
     648        exp.SafeAdd: lambda self, e: _annotate_by_args_with_coerce(self, e),
     649        exp.SafeMultiply: lambda self, e: _annotate_by_args_with_coerce(self, e),
     650        exp.SafeSubtract: lambda self, e: _annotate_by_args_with_coerce(self, e),
     651        exp.Sec: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     652        exp.Sech: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     653        exp.Soundex: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     654        exp.SHA: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
     655        exp.SHA2: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
     656        exp.Sin: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     657        exp.Sinh: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DOUBLE),
     658        exp.Split: lambda self, e: self._annotate_by_args(e, "this", array=True),
     659        exp.TimestampFromParts: lambda self, e: self._annotate_with_type(
     660            e, exp.DataType.Type.DATETIME
     661        ),
     662        exp.TimeFromParts: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
     663        exp.TimeTrunc: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
     664        exp.ToCodePoints: lambda self, e: self._annotate_with_type(
     665            e, exp.DataType.build("ARRAY<BIGINT>", dialect="bigquery")
     666        ),
     667        exp.TsOrDsToTime: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
     668        exp.Unicode: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     669        exp.Uuid: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     670    }
     671
     672    def normalize_identifier(self, expression: E) -> E:
     673        if (
     674            isinstance(expression, exp.Identifier)
     675            and self.normalization_strategy is NormalizationStrategy.CASE_INSENSITIVE
     676        ):
     677            parent = expression.parent
     678            while isinstance(parent, exp.Dot):
     679                parent = parent.parent
     680
     681            # In BigQuery, CTEs are case-insensitive, but UDF and table names are case-sensitive
     682            # by default. The following check uses a heuristic to detect tables based on whether
     683            # they are qualified. This should generally be correct, because tables in BigQuery
     684            # must be qualified with at least a dataset, unless @@dataset_id is set.
     685            case_sensitive = (
     686                isinstance(parent, exp.UserDefinedFunction)
     687                or (
     688                    isinstance(parent, exp.Table)
     689                    and parent.db
     690                    and (parent.meta.get("quoted_table") or not parent.meta.get("maybe_column"))
     691                )
     692                or expression.meta.get("is_table")
     693            )
     694            if not case_sensitive:
     695                expression.set("this", expression.this.lower())
     696
     697            return t.cast(E, expression)
     698
     699        return super().normalize_identifier(expression)
     700
     701    class JSONPathTokenizer(jsonpath.JSONPathTokenizer):
     702        VAR_TOKENS = {
     703            TokenType.DASH,
     704            TokenType.VAR,
     705        }
     706
     707    class Tokenizer(tokens.Tokenizer):
     708        QUOTES = ["'", '"', '"""', "'''"]
     709        COMMENTS = ["--", "#", ("/*", "*/")]
     710        IDENTIFIERS = ["`"]
     711        STRING_ESCAPES = ["\\"]
     712
     713        HEX_STRINGS = [("0x", ""), ("0X", "")]
     714
     715        BYTE_STRINGS = [
     716            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("b", "B")
     717        ]
     718
     719        RAW_STRINGS = [
     720            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("r", "R")
     721        ]
     722
     723        NESTED_COMMENTS = False
     724
     725        KEYWORDS = {
     726            **tokens.Tokenizer.KEYWORDS,
     727            "ANY TYPE": TokenType.VARIANT,
     728            "BEGIN": TokenType.COMMAND,
     729            "BEGIN TRANSACTION": TokenType.BEGIN,
     730            "BYTEINT": TokenType.INT,
     731            "BYTES": TokenType.BINARY,
     732            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
     733            "DATETIME": TokenType.TIMESTAMP,
     734            "DECLARE": TokenType.DECLARE,
     735            "ELSEIF": TokenType.COMMAND,
     736            "EXCEPTION": TokenType.COMMAND,
     737            "EXPORT": TokenType.EXPORT,
     738            "FLOAT64": TokenType.DOUBLE,
     739            "FOR SYSTEM_TIME": TokenType.TIMESTAMP_SNAPSHOT,
     740            "LOOP": TokenType.COMMAND,
     741            "MODEL": TokenType.MODEL,
     742            "NOT DETERMINISTIC": TokenType.VOLATILE,
     743            "RECORD": TokenType.STRUCT,
     744            "REPEAT": TokenType.COMMAND,
     745            "TIMESTAMP": TokenType.TIMESTAMPTZ,
     746            "WHILE": TokenType.COMMAND,
     747        }
     748        KEYWORDS.pop("DIV")
     749        KEYWORDS.pop("VALUES")
     750        KEYWORDS.pop("/*+")
     751
     752    class Parser(parser.Parser):
     753        PREFIXED_PIVOT_COLUMNS = True
     754        LOG_DEFAULTS_TO_LN = True
     755        SUPPORTS_IMPLICIT_UNNEST = True
     756        JOINS_HAVE_EQUAL_PRECEDENCE = True
     757
     758        # BigQuery does not allow ASC/DESC to be used as an identifier
     759        ID_VAR_TOKENS = parser.Parser.ID_VAR_TOKENS - {TokenType.ASC, TokenType.DESC}
     760        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {TokenType.ASC, TokenType.DESC}
     761        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {TokenType.ASC, TokenType.DESC}
     762        COMMENT_TABLE_ALIAS_TOKENS = parser.Parser.COMMENT_TABLE_ALIAS_TOKENS - {
     763            TokenType.ASC,
     764            TokenType.DESC,
     765        }
     766        UPDATE_ALIAS_TOKENS = parser.Parser.UPDATE_ALIAS_TOKENS - {TokenType.ASC, TokenType.DESC}
     767
     768        FUNCTIONS = {
     769            **parser.Parser.FUNCTIONS,
     770            "APPROX_TOP_COUNT": exp.ApproxTopK.from_arg_list,
     771            "BIT_AND": exp.BitwiseAndAgg.from_arg_list,
     772            "BIT_OR": exp.BitwiseOrAgg.from_arg_list,
     773            "BIT_XOR": exp.BitwiseXorAgg.from_arg_list,
     774            "BIT_COUNT": exp.BitwiseCountAgg.from_arg_list,
     775            "BOOL": exp.JSONBool.from_arg_list,
     776            "CONTAINS_SUBSTR": _build_contains_substring,
     777            "DATE": _build_date,
     778            "DATE_ADD": build_date_delta_with_interval(exp.DateAdd),
     779            "DATE_SUB": build_date_delta_with_interval(exp.DateSub),
     780            "DATE_TRUNC": lambda args: exp.DateTrunc(
     781                unit=seq_get(args, 1),
     782                this=seq_get(args, 0),
     783                zone=seq_get(args, 2),
     784            ),
     785            "DATETIME": _build_datetime,
     786            "DATETIME_ADD": build_date_delta_with_interval(exp.DatetimeAdd),
     787            "DATETIME_SUB": build_date_delta_with_interval(exp.DatetimeSub),
     788            "DIV": binary_from_function(exp.IntDiv),
     789            "EDIT_DISTANCE": _build_levenshtein,
     790            "FORMAT_DATE": _build_format_time(exp.TsOrDsToDate),
     791            "GENERATE_ARRAY": exp.GenerateSeries.from_arg_list,
     792            "JSON_EXTRACT_SCALAR": _build_extract_json_with_default_path(exp.JSONExtractScalar),
     793            "JSON_EXTRACT_ARRAY": _build_extract_json_with_default_path(exp.JSONExtractArray),
     794            "JSON_EXTRACT_STRING_ARRAY": _build_extract_json_with_default_path(exp.JSONValueArray),
     795            "JSON_KEYS": exp.JSONKeysAtDepth.from_arg_list,
     796            "JSON_QUERY": parser.build_extract_json_with_path(exp.JSONExtract),
     797            "JSON_QUERY_ARRAY": _build_extract_json_with_default_path(exp.JSONExtractArray),
     798            "JSON_STRIP_NULLS": _build_json_strip_nulls,
     799            "JSON_VALUE": _build_extract_json_with_default_path(exp.JSONExtractScalar),
     800            "JSON_VALUE_ARRAY": _build_extract_json_with_default_path(exp.JSONValueArray),
     801            "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
     802            "MD5": exp.MD5Digest.from_arg_list,
     803            "NORMALIZE_AND_CASEFOLD": lambda args: exp.Normalize(
     804                this=seq_get(args, 0), form=seq_get(args, 1), is_casefold=True
     805            ),
     806            "OCTET_LENGTH": exp.ByteLength.from_arg_list,
     807            "TO_HEX": _build_to_hex,
     808            "PARSE_DATE": lambda args: build_formatted_time(exp.StrToDate, "bigquery")(
     809                [seq_get(args, 1), seq_get(args, 0)]
     810            ),
     811            "PARSE_TIME": lambda args: build_formatted_time(exp.ParseTime, "bigquery")(
     812                [seq_get(args, 1), seq_get(args, 0)]
     813            ),
     814            "PARSE_TIMESTAMP": _build_parse_timestamp,
     815            "PARSE_DATETIME": lambda args: build_formatted_time(exp.ParseDatetime, "bigquery")(
     816                [seq_get(args, 1), seq_get(args, 0)]
     817            ),
     818            "REGEXP_CONTAINS": exp.RegexpLike.from_arg_list,
     819            "REGEXP_EXTRACT": _build_regexp_extract(exp.RegexpExtract),
     820            "REGEXP_SUBSTR": _build_regexp_extract(exp.RegexpExtract),
     821            "REGEXP_EXTRACT_ALL": _build_regexp_extract(
     822                exp.RegexpExtractAll, default_group=exp.Literal.number(0)
     823            ),
     824            "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
     825            "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
     826            "SPLIT": lambda args: exp.Split(
     827                # https://cloud.google.com/bigquery/docs/reference/standard-sql/string_functions#split
     828                this=seq_get(args, 0),
     829                expression=seq_get(args, 1) or exp.Literal.string(","),
     830            ),
     831            "STRPOS": exp.StrPosition.from_arg_list,
     832            "TIME": _build_time,
     833            "TIME_ADD": build_date_delta_with_interval(exp.TimeAdd),
     834            "TIME_SUB": build_date_delta_with_interval(exp.TimeSub),
     835            "TIMESTAMP": _build_timestamp,
     836            "TIMESTAMP_ADD": build_date_delta_with_interval(exp.TimestampAdd),
     837            "TIMESTAMP_SUB": build_date_delta_with_interval(exp.TimestampSub),
     838            "TIMESTAMP_MICROS": lambda args: exp.UnixToTime(
     839                this=seq_get(args, 0), scale=exp.UnixToTime.MICROS
     840            ),
     841            "TIMESTAMP_MILLIS": lambda args: exp.UnixToTime(
     842                this=seq_get(args, 0), scale=exp.UnixToTime.MILLIS
     843            ),
     844            "TIMESTAMP_SECONDS": lambda args: exp.UnixToTime(this=seq_get(args, 0)),
     845            "TO_JSON": lambda args: exp.JSONFormat(
     846                this=seq_get(args, 0), options=seq_get(args, 1), to_json=True
     847            ),
     848            "TO_JSON_STRING": exp.JSONFormat.from_arg_list,
     849            "FORMAT_DATETIME": _build_format_time(exp.TsOrDsToDatetime),
     850            "FORMAT_TIMESTAMP": _build_format_time(exp.TsOrDsToTimestamp),
     851            "FORMAT_TIME": _build_format_time(exp.TsOrDsToTime),
     852            "FROM_HEX": exp.Unhex.from_arg_list,
     853            "WEEK": lambda args: exp.WeekStart(this=exp.var(seq_get(args, 0))),
     854        }
     855
     856        FUNCTION_PARSERS = {
     857            **parser.Parser.FUNCTION_PARSERS,
     858            "ARRAY": lambda self: self.expression(exp.Array, expressions=[self._parse_statement()]),
     859            "JSON_ARRAY": lambda self: self.expression(
     860                exp.JSONArray, expressions=self._parse_csv(self._parse_bitwise)
     861            ),
     862            "MAKE_INTERVAL": lambda self: self._parse_make_interval(),
     863            "PREDICT": lambda self: self._parse_ml(exp.Predict),
     864            "TRANSLATE": lambda self: self._parse_translate(),
     865            "FEATURES_AT_TIME": lambda self: self._parse_features_at_time(),
     866            "GENERATE_EMBEDDING": lambda self: self._parse_ml(exp.GenerateEmbedding),
     867            "GENERATE_TEXT_EMBEDDING": lambda self: self._parse_ml(
     868                exp.GenerateEmbedding, is_text=True
     869            ),
     870            "VECTOR_SEARCH": lambda self: self._parse_vector_search(),
     871            "FORECAST": lambda self: self._parse_ml(exp.MLForecast),
     872        }
     873        FUNCTION_PARSERS.pop("TRIM")
     874
     875        NO_PAREN_FUNCTIONS = {
     876            **parser.Parser.NO_PAREN_FUNCTIONS,
     877            TokenType.CURRENT_DATETIME: exp.CurrentDatetime,
     878        }
     879
     880        NESTED_TYPE_TOKENS = {
     881            *parser.Parser.NESTED_TYPE_TOKENS,
     882            TokenType.TABLE,
     883        }
     884
     885        PROPERTY_PARSERS = {
     886            **parser.Parser.PROPERTY_PARSERS,
     887            "NOT DETERMINISTIC": lambda self: self.expression(
     888                exp.StabilityProperty, this=exp.Literal.string("VOLATILE")
     889            ),
     890            "OPTIONS": lambda self: self._parse_with_property(),
     891        }
     892
     893        CONSTRAINT_PARSERS = {
     894            **parser.Parser.CONSTRAINT_PARSERS,
     895            "OPTIONS": lambda self: exp.Properties(expressions=self._parse_with_property()),
     896        }
     897
     898        RANGE_PARSERS = parser.Parser.RANGE_PARSERS.copy()
     899        RANGE_PARSERS.pop(TokenType.OVERLAPS)
     900
     901        DASHED_TABLE_PART_FOLLOW_TOKENS = {TokenType.DOT, TokenType.L_PAREN, TokenType.R_PAREN}
     902
     903        STATEMENT_PARSERS = {
     904            **parser.Parser.STATEMENT_PARSERS,
     905            TokenType.ELSE: lambda self: self._parse_as_command(self._prev),
     906            TokenType.END: lambda self: self._parse_as_command(self._prev),
     907            TokenType.FOR: lambda self: self._parse_for_in(),
     908            TokenType.EXPORT: lambda self: self._parse_export_data(),
     909            TokenType.DECLARE: lambda self: self._parse_declare(),
     910        }
     911
     912        BRACKET_OFFSETS = {
     913            "OFFSET": (0, False),
     914            "ORDINAL": (1, False),
     915            "SAFE_OFFSET": (0, True),
     916            "SAFE_ORDINAL": (1, True),
     917        }
     918
     919        def _parse_for_in(self) -> t.Union[exp.ForIn, exp.Command]:
     920            index = self._index
     921            this = self._parse_range()
     922            self._match_text_seq("DO")
     923            if self._match(TokenType.COMMAND):
     924                self._retreat(index)
     925                return self._parse_as_command(self._prev)
     926            return self.expression(exp.ForIn, this=this, expression=self._parse_statement())
     927
     928        def _parse_table_part(self, schema: bool = False) -> t.Optional[exp.Expression]:
     929            this = super()._parse_table_part(schema=schema) or self._parse_number()
     930
     931            # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#table_names
     932            if isinstance(this, exp.Identifier):
     933                table_name = this.name
     934                while self._match(TokenType.DASH, advance=False) and self._next:
     935                    start = self._curr
     936                    while self._is_connected() and not self._match_set(
     937                        self.DASHED_TABLE_PART_FOLLOW_TOKENS, advance=False
     938                    ):
     939                        self._advance()
     940
     941                    if start == self._curr:
     942                        break
     943
     944                    table_name += self._find_sql(start, self._prev)
     945
     946                this = exp.Identifier(
     947                    this=table_name, quoted=this.args.get("quoted")
     948                ).update_positions(this)
     949            elif isinstance(this, exp.Literal):
     950                table_name = this.name
     951
     952                if self._is_connected() and self._parse_var(any_token=True):
     953                    table_name += self._prev.text
     954
     955                this = exp.Identifier(this=table_name, quoted=True).update_positions(this)
     956
     957            return this
     958
     959        def _parse_table_parts(
     960            self, schema: bool = False, is_db_reference: bool = False, wildcard: bool = False
     961        ) -> exp.Table:
     962            table = super()._parse_table_parts(
     963                schema=schema, is_db_reference=is_db_reference, wildcard=True
     964            )
     965
     966            # proj-1.db.tbl -- `1.` is tokenized as a float so we need to unravel it here
     967            if not table.catalog:
     968                if table.db:
     969                    previous_db = table.args["db"]
     970                    parts = table.db.split(".")
     971                    if len(parts) == 2 and not table.args["db"].quoted:
     972                        table.set(
     973                            "catalog", exp.Identifier(this=parts[0]).update_positions(previous_db)
     974                        )
     975                        table.set("db", exp.Identifier(this=parts[1]).update_positions(previous_db))
     976                else:
     977                    previous_this = table.this
     978                    parts = table.name.split(".")
     979                    if len(parts) == 2 and not table.this.quoted:
     980                        table.set(
     981                            "db", exp.Identifier(this=parts[0]).update_positions(previous_this)
     982                        )
     983                        table.set(
     984                            "this", exp.Identifier(this=parts[1]).update_positions(previous_this)
     985                        )
     986
     987            if isinstance(table.this, exp.Identifier) and any("." in p.name for p in table.parts):
     988                alias = table.this
     989                catalog, db, this, *rest = (
     990                    exp.to_identifier(p, quoted=True)
     991                    for p in split_num_words(".".join(p.name for p in table.parts), ".", 3)
     992                )
     993
     994                for part in (catalog, db, this):
     995                    if part:
     996                        part.update_positions(table.this)
     997
     998                if rest and this:
     999                    this = exp.Dot.build([this, *rest])  # type: ignore
    1000
    1001                table = exp.Table(
    1002                    this=this, db=db, catalog=catalog, pivots=table.args.get("pivots")
    1003                )
    1004                table.meta["quoted_table"] = True
    1005            else:
    1006                alias = None
    1007
    1008            # The `INFORMATION_SCHEMA` views in BigQuery need to be qualified by a region or
    1009            # dataset, so if the project identifier is omitted we need to fix the ast so that
    1010            # the `INFORMATION_SCHEMA.X` bit is represented as a single (quoted) Identifier.
    1011            # Otherwise, we wouldn't correctly qualify a `Table` node that references these
    1012            # views, because it would seem like the "catalog" part is set, when it'd actually
    1013            # be the region/dataset. Merging the two identifiers into a single one is done to
    1014            # avoid producing a 4-part Table reference, which would cause issues in the schema
    1015            # module, when there are 3-part table names mixed with information schema views.
    1016            #
    1017            # See: https://cloud.google.com/bigquery/docs/information-schema-intro#syntax
    1018            table_parts = table.parts
    1019            if len(table_parts) > 1 and table_parts[-2].name.upper() == "INFORMATION_SCHEMA":
    1020                # We need to alias the table here to avoid breaking existing qualified columns.
    1021                # This is expected to be safe, because if there's an actual alias coming up in
    1022                # the token stream, it will overwrite this one. If there isn't one, we are only
    1023                # exposing the name that can be used to reference the view explicitly (a no-op).
    1024                exp.alias_(
    1025                    table,
    1026                    t.cast(exp.Identifier, alias or table_parts[-1]),
    1027                    table=True,
    1028                    copy=False,
    1029                )
    1030
    1031                info_schema_view = f"{table_parts[-2].name}.{table_parts[-1].name}"
    1032                new_this = exp.Identifier(this=info_schema_view, quoted=True).update_positions(
    1033                    line=table_parts[-2].meta.get("line"),
    1034                    col=table_parts[-1].meta.get("col"),
    1035                    start=table_parts[-2].meta.get("start"),
    1036                    end=table_parts[-1].meta.get("end"),
    1037                )
    1038                table.set("this", new_this)
    1039                table.set("db", seq_get(table_parts, -3))
    1040                table.set("catalog", seq_get(table_parts, -4))
    1041
    1042            return table
    1043
    1044        def _parse_column(self) -> t.Optional[exp.Expression]:
    1045            column = super()._parse_column()
    1046            if isinstance(column, exp.Column):
    1047                parts = column.parts
    1048                if any("." in p.name for p in parts):
    1049                    catalog, db, table, this, *rest = (
    1050                        exp.to_identifier(p, quoted=True)
    1051                        for p in split_num_words(".".join(p.name for p in parts), ".", 4)
    1052                    )
    1053
    1054                    if rest and this:
    1055                        this = exp.Dot.build([this, *rest])  # type: ignore
    1056
    1057                    column = exp.Column(this=this, table=table, db=db, catalog=catalog)
    1058                    column.meta["quoted_column"] = True
    1059
    1060            return column
    1061
    1062        @t.overload
    1063        def _parse_json_object(self, agg: Lit[False]) -> exp.JSONObject: ...
    1064
    1065        @t.overload
    1066        def _parse_json_object(self, agg: Lit[True]) -> exp.JSONObjectAgg: ...
    1067
    1068        def _parse_json_object(self, agg=False):
    1069            json_object = super()._parse_json_object()
    1070            array_kv_pair = seq_get(json_object.expressions, 0)
    1071
    1072            # Converts BQ's "signature 2" of JSON_OBJECT into SQLGlot's canonical representation
    1073            # https://cloud.google.com/bigquery/docs/reference/standard-sql/json_functions#json_object_signature2
    1074            if (
    1075                array_kv_pair
    1076                and isinstance(array_kv_pair.this, exp.Array)
    1077                and isinstance(array_kv_pair.expression, exp.Array)
    1078            ):
    1079                keys = array_kv_pair.this.expressions
    1080                values = array_kv_pair.expression.expressions
    1081
    1082                json_object.set(
    1083                    "expressions",
    1084                    [exp.JSONKeyValue(this=k, expression=v) for k, v in zip(keys, values)],
    1085                )
    1086
    1087            return json_object
    1088
    1089        def _parse_bracket(
    1090            self, this: t.Optional[exp.Expression] = None
    1091        ) -> t.Optional[exp.Expression]:
    1092            bracket = super()._parse_bracket(this)
    1093
    1094            if this is bracket:
    1095                return bracket
    1096
    1097            if isinstance(bracket, exp.Bracket):
    1098                for expression in bracket.expressions:
    1099                    name = expression.name.upper()
    1100
    1101                    if name not in self.BRACKET_OFFSETS:
    1102                        break
    1103
    1104                    offset, safe = self.BRACKET_OFFSETS[name]
    1105                    bracket.set("offset", offset)
    1106                    bracket.set("safe", safe)
    1107                    expression.replace(expression.expressions[0])
    1108
    1109            return bracket
    1110
    1111        def _parse_unnest(self, with_alias: bool = True) -> t.Optional[exp.Unnest]:
    1112            unnest = super()._parse_unnest(with_alias=with_alias)
    1113
    1114            if not unnest:
    1115                return None
    1116
    1117            unnest_expr = seq_get(unnest.expressions, 0)
    1118            if unnest_expr:
    1119                from sqlglot.optimizer.annotate_types import annotate_types
    1120
    1121                unnest_expr = annotate_types(unnest_expr, dialect=self.dialect)
    1122
    1123                # Unnesting a nested array (i.e array of structs) explodes the top-level struct fields,
    1124                # in contrast to other dialects such as DuckDB which flattens only the array by default
    1125                if unnest_expr.is_type(exp.DataType.Type.ARRAY) and any(
    1126                    array_elem.is_type(exp.DataType.Type.STRUCT)
    1127                    for array_elem in unnest_expr._type.expressions
    1128                ):
    1129                    unnest.set("explode_array", True)
    1130
    1131            return unnest
    1132
    1133        def _parse_make_interval(self) -> exp.MakeInterval:
    1134            expr = exp.MakeInterval()
    1135
    1136            for arg_key in expr.arg_types:
    1137                value = self._parse_lambda()
    1138
    1139                if not value:
    1140                    break
    1141
    1142                # Non-named arguments are filled sequentially, (optionally) followed by named arguments
    1143                # that can appear in any order e.g MAKE_INTERVAL(1, minute => 5, day => 2)
    1144                if isinstance(value, exp.Kwarg):
    1145                    arg_key = value.this.name
    1146
    1147                expr.set(arg_key, value)
    1148
    1149                self._match(TokenType.COMMA)
    1150
    1151            return expr
    1152
    1153        def _parse_ml(self, expr_type: t.Type[E], **kwargs) -> E:
    1154            self._match_text_seq("MODEL")
    1155            this = self._parse_table()
    1156
    1157            self._match(TokenType.COMMA)
    1158            self._match_text_seq("TABLE")
    1159
    1160            # Certain functions like ML.FORECAST require a STRUCT argument but not a TABLE/SELECT one
    1161            expression = (
    1162                self._parse_table() if not self._match(TokenType.STRUCT, advance=False) else None
    1163            )
    1164
    1165            self._match(TokenType.COMMA)
    1166
    1167            return self.expression(
    1168                expr_type,
    1169                this=this,
    1170                expression=expression,
    1171                params_struct=self._parse_bitwise(),
    1172                **kwargs,
    1173            )
    1174
    1175        def _parse_translate(self) -> exp.Translate | exp.MLTranslate:
    1176            # Check if this is ML.TRANSLATE by looking at previous tokens
    1177            token = seq_get(self._tokens, self._index - 4)
    1178            if token and token.text.upper() == "ML":
    1179                return self._parse_ml(exp.MLTranslate)
    1180
    1181            return exp.Translate.from_arg_list(self._parse_function_args())
    1182
    1183        def _parse_features_at_time(self) -> exp.FeaturesAtTime:
    1184            self._match(TokenType.TABLE)
    1185            this = self._parse_table()
    1186
    1187            expr = self.expression(exp.FeaturesAtTime, this=this)
    1188
    1189            while self._match(TokenType.COMMA):
    1190                arg = self._parse_lambda()
    1191
    1192                # Get the LHS of the Kwarg and set the arg to that value, e.g
    1193                # "num_rows => 1" sets the expr's `num_rows` arg
    1194                if arg:
    1195                    expr.set(arg.this.name, arg)
    1196
    1197            return expr
    1198
    1199        def _parse_vector_search(self) -> exp.VectorSearch:
    1200            self._match(TokenType.TABLE)
    1201            base_table = self._parse_table()
    1202
    1203            self._match(TokenType.COMMA)
    1204
    1205            column_to_search = self._parse_bitwise()
    1206            self._match(TokenType.COMMA)
    1207
    1208            self._match(TokenType.TABLE)
    1209            query_table = self._parse_table()
    1210
    1211            expr = self.expression(
    1212                exp.VectorSearch,
    1213                this=base_table,
    1214                column_to_search=column_to_search,
    1215                query_table=query_table,
    1216            )
    1217
    1218            while self._match(TokenType.COMMA):
    1219                # query_column_to_search can be named argument or positional
    1220                if self._match(TokenType.STRING, advance=False):
    1221                    query_column = self._parse_string()
    1222                    expr.set("query_column_to_search", query_column)
    1223                else:
    1224                    arg = self._parse_lambda()
    1225                    if arg:
    1226                        expr.set(arg.this.name, arg)
    1227
    1228            return expr
    1229
    1230        def _parse_export_data(self) -> exp.Export:
    1231            self._match_text_seq("DATA")
    1232
    1233            return self.expression(
    1234                exp.Export,
    1235                connection=self._match_text_seq("WITH", "CONNECTION") and self._parse_table_parts(),
    1236                options=self._parse_properties(),
    1237                this=self._match_text_seq("AS") and self._parse_select(),
    1238            )
    1239
    1240    class Generator(generator.Generator):
    1241        INTERVAL_ALLOWS_PLURAL_FORM = False
    1242        JOIN_HINTS = False
    1243        QUERY_HINTS = False
    1244        TABLE_HINTS = False
    1245        LIMIT_FETCH = "LIMIT"
    1246        RENAME_TABLE_WITH_DB = False
    1247        NVL2_SUPPORTED = False
    1248        UNNEST_WITH_ORDINALITY = False
    1249        COLLATE_IS_FUNC = True
    1250        LIMIT_ONLY_LITERALS = True
    1251        SUPPORTS_TABLE_ALIAS_COLUMNS = False
    1252        UNPIVOT_ALIASES_ARE_IDENTIFIERS = False
    1253        JSON_KEY_VALUE_PAIR_SEP = ","
    1254        NULL_ORDERING_SUPPORTED = False
    1255        IGNORE_NULLS_IN_FUNC = True
    1256        JSON_PATH_SINGLE_QUOTE_ESCAPE = True
    1257        CAN_IMPLEMENT_ARRAY_ANY = True
    1258        SUPPORTS_TO_NUMBER = False
    1259        NAMED_PLACEHOLDER_TOKEN = "@"
    1260        HEX_FUNC = "TO_HEX"
    1261        WITH_PROPERTIES_PREFIX = "OPTIONS"
    1262        SUPPORTS_EXPLODING_PROJECTIONS = False
    1263        EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE = False
    1264        SUPPORTS_UNIX_SECONDS = True
    1265
    1266        SAFE_JSON_PATH_KEY_RE = re.compile(r"^[_\-a-zA-Z][\-\w]*$")
    1267
    1268        TS_OR_DS_TYPES = (
    1269            exp.TsOrDsToDatetime,
    1270            exp.TsOrDsToTimestamp,
    1271            exp.TsOrDsToTime,
    1272            exp.TsOrDsToDate,
    1273        )
    1274
    1275        TRANSFORMS = {
    1276            **generator.Generator.TRANSFORMS,
    1277            exp.ApproxTopK: rename_func("APPROX_TOP_COUNT"),
    1278            exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
    1279            exp.ArgMax: arg_max_or_min_no_count("MAX_BY"),
    1280            exp.ArgMin: arg_max_or_min_no_count("MIN_BY"),
    1281            exp.Array: inline_array_unless_query,
    1282            exp.ArrayContains: _array_contains_sql,
    1283            exp.ArrayFilter: filter_array_using_unnest,
    1284            exp.ArrayRemove: filter_array_using_unnest,
    1285            exp.BitwiseAndAgg: rename_func("BIT_AND"),
    1286            exp.BitwiseOrAgg: rename_func("BIT_OR"),
    1287            exp.BitwiseXorAgg: rename_func("BIT_XOR"),
    1288            exp.BitwiseCountAgg: rename_func("BIT_COUNT"),
    1289            exp.ByteLength: rename_func("BYTE_LENGTH"),
    1290            exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]),
    1291            exp.CollateProperty: lambda self, e: (
    1292                f"DEFAULT COLLATE {self.sql(e, 'this')}"
    1293                if e.args.get("default")
    1294                else f"COLLATE {self.sql(e, 'this')}"
    1295            ),
    1296            exp.Commit: lambda *_: "COMMIT TRANSACTION",
    1297            exp.CountIf: rename_func("COUNTIF"),
    1298            exp.Create: _create_sql,
    1299            exp.CTE: transforms.preprocess([_pushdown_cte_column_names]),
    1300            exp.DateAdd: date_add_interval_sql("DATE", "ADD"),
    1301            exp.DateDiff: lambda self, e: self.func(
    1302                "DATE_DIFF", e.this, e.expression, unit_to_var(e)
    1303            ),
    1304            exp.DateFromParts: rename_func("DATE"),
    1305            exp.DateStrToDate: datestrtodate_sql,
    1306            exp.DateSub: date_add_interval_sql("DATE", "SUB"),
    1307            exp.DatetimeAdd: date_add_interval_sql("DATETIME", "ADD"),
    1308            exp.DatetimeSub: date_add_interval_sql("DATETIME", "SUB"),
    1309            exp.DateFromUnixDate: rename_func("DATE_FROM_UNIX_DATE"),
    1310            exp.FromTimeZone: lambda self, e: self.func(
    1311                "DATETIME", self.func("TIMESTAMP", e.this, e.args.get("zone")), "'UTC'"
    1312            ),
    1313            exp.GenerateSeries: rename_func("GENERATE_ARRAY"),
    1314            exp.GroupConcat: lambda self, e: groupconcat_sql(
    1315                self, e, func_name="STRING_AGG", within_group=False
    1316            ),
    1317            exp.Hex: lambda self, e: self.func("UPPER", self.func("TO_HEX", self.sql(e, "this"))),
    1318            exp.HexString: lambda self, e: self.hexstring_sql(e, binary_function_repr="FROM_HEX"),
    1319            exp.If: if_sql(false_value="NULL"),
    1320            exp.ILike: no_ilike_sql,
    1321            exp.IntDiv: rename_func("DIV"),
    1322            exp.Int64: rename_func("INT64"),
    1323            exp.JSONBool: rename_func("BOOL"),
    1324            exp.JSONExtract: _json_extract_sql,
    1325            exp.JSONExtractArray: _json_extract_sql,
    1326            exp.JSONExtractScalar: _json_extract_sql,
    1327            exp.JSONFormat: lambda self, e: self.func(
    1328                "TO_JSON" if e.args.get("to_json") else "TO_JSON_STRING",
    1329                e.this,
    1330                e.args.get("options"),
    1331            ),
    1332            exp.JSONKeysAtDepth: rename_func("JSON_KEYS"),
    1333            exp.JSONValueArray: rename_func("JSON_VALUE_ARRAY"),
    1334            exp.Levenshtein: _levenshtein_sql,
    1335            exp.Max: max_or_greatest,
    1336            exp.MD5: lambda self, e: self.func("TO_HEX", self.func("MD5", e.this)),
    1337            exp.MD5Digest: rename_func("MD5"),
    1338            exp.Min: min_or_least,
    1339            exp.Normalize: lambda self, e: self.func(
    1340                "NORMALIZE_AND_CASEFOLD" if e.args.get("is_casefold") else "NORMALIZE",
    1341                e.this,
    1342                e.args.get("form"),
    1343            ),
    1344            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
    1345            exp.RegexpExtract: lambda self, e: self.func(
    1346                "REGEXP_EXTRACT",
    1347                e.this,
    1348                e.expression,
    1349                e.args.get("position"),
    1350                e.args.get("occurrence"),
    1351            ),
    1352            exp.RegexpExtractAll: lambda self, e: self.func(
    1353                "REGEXP_EXTRACT_ALL", e.this, e.expression
    1354            ),
    1355            exp.RegexpReplace: regexp_replace_sql,
    1356            exp.RegexpLike: rename_func("REGEXP_CONTAINS"),
    1357            exp.ReturnsProperty: _returnsproperty_sql,
    1358            exp.Rollback: lambda *_: "ROLLBACK TRANSACTION",
    1359            exp.ParseTime: lambda self, e: self.func("PARSE_TIME", self.format_time(e), e.this),
    1360            exp.ParseDatetime: lambda self, e: self.func(
    1361                "PARSE_DATETIME", self.format_time(e), e.this
    1362            ),
    1363            exp.Select: transforms.preprocess(
    1364                [
    1365                    transforms.explode_projection_to_unnest(),
    1366                    transforms.unqualify_unnest,
    1367                    transforms.eliminate_distinct_on,
    1368                    _alias_ordered_group,
    1369                    transforms.eliminate_semi_and_anti_joins,
    1370                ]
    1371            ),
    1372            exp.SHA: rename_func("SHA1"),
    1373            exp.SHA2: sha256_sql,
    1374            exp.StabilityProperty: lambda self, e: (
    1375                "DETERMINISTIC" if e.name == "IMMUTABLE" else "NOT DETERMINISTIC"
    1376            ),
    1377            exp.String: rename_func("STRING"),
    1378            exp.StrPosition: lambda self, e: (
    1379                strposition_sql(
    1380                    self, e, func_name="INSTR", supports_position=True, supports_occurrence=True
    1381                )
    1382            ),
    1383            exp.StrToDate: _str_to_datetime_sql,
    1384            exp.StrToTime: _str_to_datetime_sql,
    1385            exp.TimeAdd: date_add_interval_sql("TIME", "ADD"),
    1386            exp.TimeFromParts: rename_func("TIME"),
    1387            exp.TimestampFromParts: rename_func("DATETIME"),
    1388            exp.TimeSub: date_add_interval_sql("TIME", "SUB"),
    1389            exp.TimestampAdd: date_add_interval_sql("TIMESTAMP", "ADD"),
    1390            exp.TimestampDiff: rename_func("TIMESTAMP_DIFF"),
    1391            exp.TimestampSub: date_add_interval_sql("TIMESTAMP", "SUB"),
    1392            exp.TimeStrToTime: timestrtotime_sql,
    1393            exp.Transaction: lambda *_: "BEGIN TRANSACTION",
    1394            exp.TsOrDsAdd: _ts_or_ds_add_sql,
    1395            exp.TsOrDsDiff: _ts_or_ds_diff_sql,
    1396            exp.TsOrDsToTime: rename_func("TIME"),
    1397            exp.TsOrDsToDatetime: rename_func("DATETIME"),
    1398            exp.TsOrDsToTimestamp: rename_func("TIMESTAMP"),
    1399            exp.Unhex: rename_func("FROM_HEX"),
    1400            exp.UnixDate: rename_func("UNIX_DATE"),
    1401            exp.UnixToTime: _unix_to_time_sql,
    1402            exp.Uuid: lambda *_: "GENERATE_UUID()",
    1403            exp.Values: _derived_table_values_to_unnest,
    1404            exp.VariancePop: rename_func("VAR_POP"),
    1405            exp.SafeDivide: rename_func("SAFE_DIVIDE"),
    1406        }
    1407
    1408        SUPPORTED_JSON_PATH_PARTS = {
    1409            exp.JSONPathKey,
    1410            exp.JSONPathRoot,
    1411            exp.JSONPathSubscript,
    1412        }
    1413
    1414        TYPE_MAPPING = {
    1415            **generator.Generator.TYPE_MAPPING,
    1416            exp.DataType.Type.BIGDECIMAL: "BIGNUMERIC",
    1417            exp.DataType.Type.BIGINT: "INT64",
    1418            exp.DataType.Type.BINARY: "BYTES",
    1419            exp.DataType.Type.BLOB: "BYTES",
    1420            exp.DataType.Type.BOOLEAN: "BOOL",
    1421            exp.DataType.Type.CHAR: "STRING",
    1422            exp.DataType.Type.DECIMAL: "NUMERIC",
    1423            exp.DataType.Type.DOUBLE: "FLOAT64",
    1424            exp.DataType.Type.FLOAT: "FLOAT64",
    1425            exp.DataType.Type.INT: "INT64",
    1426            exp.DataType.Type.NCHAR: "STRING",
    1427            exp.DataType.Type.NVARCHAR: "STRING",
    1428            exp.DataType.Type.SMALLINT: "INT64",
    1429            exp.DataType.Type.TEXT: "STRING",
    1430            exp.DataType.Type.TIMESTAMP: "DATETIME",
    1431            exp.DataType.Type.TIMESTAMPNTZ: "DATETIME",
    1432            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
    1433            exp.DataType.Type.TIMESTAMPLTZ: "TIMESTAMP",
    1434            exp.DataType.Type.TINYINT: "INT64",
    1435            exp.DataType.Type.ROWVERSION: "BYTES",
    1436            exp.DataType.Type.UUID: "STRING",
    1437            exp.DataType.Type.VARBINARY: "BYTES",
    1438            exp.DataType.Type.VARCHAR: "STRING",
    1439            exp.DataType.Type.VARIANT: "ANY TYPE",
    1440        }
    1441
    1442        PROPERTIES_LOCATION = {
    1443            **generator.Generator.PROPERTIES_LOCATION,
    1444            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
    1445            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
    1446        }
    1447
    1448        # WINDOW comes after QUALIFY
    1449        # https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#window_clause
    1450        AFTER_HAVING_MODIFIER_TRANSFORMS = {
    1451            "qualify": generator.Generator.AFTER_HAVING_MODIFIER_TRANSFORMS["qualify"],
    1452            "windows": generator.Generator.AFTER_HAVING_MODIFIER_TRANSFORMS["windows"],
    1453        }
    1454
    1455        # from: https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#reserved_keywords
    1456        RESERVED_KEYWORDS = {
    1457            "all",
    1458            "and",
    1459            "any",
    1460            "array",
    1461            "as",
    1462            "asc",
    1463            "assert_rows_modified",
    1464            "at",
    1465            "between",
    1466            "by",
    1467            "case",
    1468            "cast",
    1469            "collate",
    1470            "contains",
    1471            "create",
    1472            "cross",
    1473            "cube",
    1474            "current",
    1475            "default",
    1476            "define",
    1477            "desc",
    1478            "distinct",
    1479            "else",
    1480            "end",
    1481            "enum",
    1482            "escape",
    1483            "except",
    1484            "exclude",
    1485            "exists",
    1486            "extract",
    1487            "false",
    1488            "fetch",
    1489            "following",
    1490            "for",
    1491            "from",
    1492            "full",
    1493            "group",
    1494            "grouping",
    1495            "groups",
    1496            "hash",
    1497            "having",
    1498            "if",
    1499            "ignore",
    1500            "in",
    1501            "inner",
    1502            "intersect",
    1503            "interval",
    1504            "into",
    1505            "is",
    1506            "join",
    1507            "lateral",
    1508            "left",
    1509            "like",
    1510            "limit",
    1511            "lookup",
    1512            "merge",
    1513            "natural",
    1514            "new",
    1515            "no",
    1516            "not",
    1517            "null",
    1518            "nulls",
    1519            "of",
    1520            "on",
    1521            "or",
    1522            "order",
    1523            "outer",
    1524            "over",
    1525            "partition",
    1526            "preceding",
    1527            "proto",
    1528            "qualify",
    1529            "range",
    1530            "recursive",
    1531            "respect",
    1532            "right",
    1533            "rollup",
    1534            "rows",
    1535            "select",
    1536            "set",
    1537            "some",
    1538            "struct",
    1539            "tablesample",
    1540            "then",
    1541            "to",
    1542            "treat",
    1543            "true",
    1544            "unbounded",
    1545            "union",
    1546            "unnest",
    1547            "using",
    1548            "when",
    1549            "where",
    1550            "window",
    1551            "with",
    1552            "within",
    1553        }
    1554
    1555        def datetrunc_sql(self, expression: exp.DateTrunc) -> str:
    1556            unit = expression.unit
    1557            unit_sql = unit.name if unit.is_string else self.sql(unit)
    1558            return self.func("DATE_TRUNC", expression.this, unit_sql, expression.args.get("zone"))
    1559
    1560        def mod_sql(self, expression: exp.Mod) -> str:
    1561            this = expression.this
    1562            expr = expression.expression
    1563            return self.func(
    1564                "MOD",
    1565                this.unnest() if isinstance(this, exp.Paren) else this,
    1566                expr.unnest() if isinstance(expr, exp.Paren) else expr,
    1567            )
    1568
    1569        def column_parts(self, expression: exp.Column) -> str:
    1570            if expression.meta.get("quoted_column"):
    1571                # If a column reference is of the form `dataset.table`.name, we need
    1572                # to preserve the quoted table path, otherwise the reference breaks
    1573                table_parts = ".".join(p.name for p in expression.parts[:-1])
    1574                table_path = self.sql(exp.Identifier(this=table_parts, quoted=True))
    1575                return f"{table_path}.{self.sql(expression, 'this')}"
    1576
    1577            return super().column_parts(expression)
    1578
    1579        def table_parts(self, expression: exp.Table) -> str:
    1580            # Depending on the context, `x.y` may not resolve to the same data source as `x`.`y`, so
    1581            # we need to make sure the correct quoting is used in each case.
    1582            #
    1583            # For example, if there is a CTE x that clashes with a schema name, then the former will
    1584            # return the table y in that schema, whereas the latter will return the CTE's y column:
    1585            #
    1586            # - WITH x AS (SELECT [1, 2] AS y) SELECT * FROM x, `x.y`   -> cross join
    1587            # - WITH x AS (SELECT [1, 2] AS y) SELECT * FROM x, `x`.`y` -> implicit unnest
    1588            if expression.meta.get("quoted_table"):
    1589                table_parts = ".".join(p.name for p in expression.parts)
    1590                return self.sql(exp.Identifier(this=table_parts, quoted=True))
    1591
    1592            return super().table_parts(expression)
    1593
    1594        def timetostr_sql(self, expression: exp.TimeToStr) -> str:
    1595            this = expression.this
    1596            if isinstance(this, exp.TsOrDsToDatetime):
    1597                func_name = "FORMAT_DATETIME"
    1598            elif isinstance(this, exp.TsOrDsToTimestamp):
    1599                func_name = "FORMAT_TIMESTAMP"
    1600            elif isinstance(this, exp.TsOrDsToTime):
    1601                func_name = "FORMAT_TIME"
    1602            else:
    1603                func_name = "FORMAT_DATE"
    1604
    1605            time_expr = this if isinstance(this, self.TS_OR_DS_TYPES) else expression
    1606            return self.func(
    1607                func_name, self.format_time(expression), time_expr.this, expression.args.get("zone")
    1608            )
    1609
    1610        def eq_sql(self, expression: exp.EQ) -> str:
    1611            # Operands of = cannot be NULL in BigQuery
    1612            if isinstance(expression.left, exp.Null) or isinstance(expression.right, exp.Null):
    1613                if not isinstance(expression.parent, exp.Update):
    1614                    return "NULL"
    1615
    1616            return self.binary(expression, "=")
    1617
    1618        def attimezone_sql(self, expression: exp.AtTimeZone) -> str:
    1619            parent = expression.parent
    1620
    1621            # BigQuery allows CAST(.. AS {STRING|TIMESTAMP} [FORMAT <fmt> [AT TIME ZONE <tz>]]).
    1622            # Only the TIMESTAMP one should use the below conversion, when AT TIME ZONE is included.
    1623            if not isinstance(parent, exp.Cast) or not parent.to.is_type("text"):
    1624                return self.func(
    1625                    "TIMESTAMP", self.func("DATETIME", expression.this, expression.args.get("zone"))
    1626                )
    1627
    1628            return super().attimezone_sql(expression)
    1629
    1630        def trycast_sql(self, expression: exp.TryCast) -> str:
    1631            return self.cast_sql(expression, safe_prefix="SAFE_")
    1632
    1633        def bracket_sql(self, expression: exp.Bracket) -> str:
    1634            this = expression.this
    1635            expressions = expression.expressions
    1636
    1637            if len(expressions) == 1 and this and this.is_type(exp.DataType.Type.STRUCT):
    1638                arg = expressions[0]
    1639                if arg.type is None:
    1640                    from sqlglot.optimizer.annotate_types import annotate_types
    1641
    1642                    arg = annotate_types(arg, dialect=self.dialect)
    1643
    1644                if arg.type and arg.type.this in exp.DataType.TEXT_TYPES:
    1645                    # BQ doesn't support bracket syntax with string values for structs
    1646                    return f"{self.sql(this)}.{arg.name}"
    1647
    1648            expressions_sql = self.expressions(expression, flat=True)
    1649            offset = expression.args.get("offset")
    1650
    1651            if offset == 0:
    1652                expressions_sql = f"OFFSET({expressions_sql})"
    1653            elif offset == 1:
    1654                expressions_sql = f"ORDINAL({expressions_sql})"
    1655            elif offset is not None:
    1656                self.unsupported(f"Unsupported array offset: {offset}")
    1657
    1658            if expression.args.get("safe"):
    1659                expressions_sql = f"SAFE_{expressions_sql}"
    1660
    1661            return f"{self.sql(this)}[{expressions_sql}]"
    1662
    1663        def in_unnest_op(self, expression: exp.Unnest) -> str:
    1664            return self.sql(expression)
    1665
    1666        def version_sql(self, expression: exp.Version) -> str:
    1667            if expression.name == "TIMESTAMP":
    1668                expression.set("this", "SYSTEM_TIME")
    1669            return super().version_sql(expression)
    1670
    1671        def contains_sql(self, expression: exp.Contains) -> str:
    1672            this = expression.this
    1673            expr = expression.expression
    1674
    1675            if isinstance(this, exp.Lower) and isinstance(expr, exp.Lower):
    1676                this = this.this
    1677                expr = expr.this
    1678
    1679            return self.func("CONTAINS_SUBSTR", this, expr, expression.args.get("json_scope"))
    1680
    1681        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
    1682            this = expression.this
    1683
    1684            # This ensures that inline type-annotated ARRAY literals like ARRAY<INT64>[1, 2, 3]
    1685            # are roundtripped unaffected. The inner check excludes ARRAY(SELECT ...) expressions,
    1686            # because they aren't literals and so the above syntax is invalid BigQuery.
    1687            if isinstance(this, exp.Array):
    1688                elem = seq_get(this.expressions, 0)
    1689                if not (elem and elem.find(exp.Query)):
    1690                    return f"{self.sql(expression, 'to')}{self.sql(this)}"
    1691
    1692            return super().cast_sql(expression, safe_prefix=safe_prefix)
    1693
    1694        def declareitem_sql(self, expression: exp.DeclareItem) -> str:
    1695            variables = self.expressions(expression, "this")
    1696            default = self.sql(expression, "default")
    1697            default = f" DEFAULT {default}" if default else ""
    1698            kind = self.sql(expression, "kind")
    1699            kind = f" {kind}" if kind else ""
    1700
    1701            return f"{variables}{kind}{default}"

WEEK_OFFSET = -1

First day of the week in DATE_TRUNC(week). Defaults to 0 (Monday). -1 would be Sunday.

UNNEST_COLUMN_ONLY = True

Whether `UNNEST` table aliases are treated as column aliases.

SUPPORTS_USER_DEFINED_TYPES = False

Whether user-defined data types are supported.

SUPPORTS_SEMI_ANTI_JOIN = False

Whether `SEMI` or `ANTI` joins are supported.

LOG_BASE_FIRST: Optional[bool] = False

Whether the base comes first in the `LOG` function. Possible values: `True`, `False`, `None` (two arguments are not supported by `LOG`)

HEX_LOWERCASE = True

Whether the `HEX` function returns a lowercase hexadecimal string.

FORCE_EARLY_ALIAS_REF_EXPANSION = True

Whether alias reference expansion (_expand_alias_refs()) should run before column qualification (_qualify_columns()).

###### For example:

> WITH data AS ( SELECT 1 AS id, 2 AS my_id ) SELECT id AS my_id FROM data WHERE my_id = 1 GROUP BY my_id, HAVING my_id = 1

In most dialects, "my_id" would refer to "data.my_id" across the query, except: - BigQuery, which will forward the alias to GROUP BY + HAVING clauses i.e it resolves to "WHERE my_id = 1 GROUP BY id HAVING id = 1" - Clickhouse, which will forward the alias across the query i.e it resolves to "WHERE id = 1 GROUP BY id HAVING id = 1"

PRESERVE_ORIGINAL_NAMES: bool = True

Whether the name of the function should be preserved inside the node's metadata, can be useful for roundtripping deprecated vs new functions that share an AST node e.g JSON_VALUE vs JSON_EXTRACT_SCALAR in BigQuery

HEX_STRING_IS_INTEGER_TYPE: bool = True

Whether hex strings such as x'CC' evaluate to integer or binary/blob type

NORMALIZATION_STRATEGY = <NormalizationStrategy.CASE_INSENSITIVE: 'CASE_INSENSITIVE'>

Specifies the strategy according to which identifiers should be normalized.

NORMALIZE_FUNCTIONS: bool | str = False

Determines how function names are going to be normalized.

###### Possible values:

> "upper" or True: Convert names to uppercase. "lower": Convert names to lowercase. False: Disables function name normalization.

TIME_MAPPING: Dict[str, str] = {'%D': '%m/%d/%y', '%E6S': '%S.%f', '%e': '%-d'}

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

FORMAT_MAPPING: Dict[str, str] = {'DD': '%d', 'MM': '%m', 'MON': '%b', 'MONTH': '%B', 'YYYY': '%Y', 'YY': '%y', 'HH': '%I', 'HH12': '%I', 'HH24': '%H', 'MI': '%M', 'SS': '%S', 'SSSSS': '%f', 'TZH': '%z'}

Helper which is used for parsing the special syntax `CAST(x AS DATE FORMAT 'yyyy')`. If empty, the corresponding trie will be constructed off of `TIME_MAPPING`.

PSEUDOCOLUMNS: Set[str] = {'_PARTITIONTIME', '_FILE_NAME', '_TABLE_SUFFIX', '_PARTITIONDATE'}

Columns that are auto-generated by the engine corresponding to this dialect. For example, such columns may be excluded from `SELECT *` queries.

SET_OP_DISTINCT_BY_DEFAULT: Dict[Type[sqlglot.expressions.Expression], Optional[bool]] = {<class 'sqlglot.expressions.Except'>: None, <class 'sqlglot.expressions.Intersect'>: None, <class 'sqlglot.expressions.Union'>: None}

Whether a set operation uses DISTINCT by default. This is `None` when either `DISTINCT` or `ALL` must be explicitly specified.

COERCES_TO: Dict[sqlglot.expressions.DataType.Type, Set[sqlglot.expressions.DataType.Type]] = {<Type.TEXT: 'TEXT'>: set(), <Type.NVARCHAR: 'NVARCHAR'>: {<Type.TEXT: 'TEXT'>}, <Type.VARCHAR: 'VARCHAR'>: {<Type.NVARCHAR: 'NVARCHAR'>, <Type.TEXT: 'TEXT'>}, <Type.NCHAR: 'NCHAR'>: {<Type.NVARCHAR: 'NVARCHAR'>, <Type.TEXT: 'TEXT'>, <Type.VARCHAR: 'VARCHAR'>}, <Type.CHAR: 'CHAR'>: {<Type.NCHAR: 'NCHAR'>, <Type.NVARCHAR: 'NVARCHAR'>, <Type.TEXT: 'TEXT'>, <Type.VARCHAR: 'VARCHAR'>}, <Type.DOUBLE: 'DOUBLE'>: set(), <Type.FLOAT: 'FLOAT'>: {<Type.DOUBLE: 'DOUBLE'>}, <Type.DECIMAL: 'DECIMAL'>: {<Type.BIGDECIMAL: 'BIGDECIMAL'>, <Type.DOUBLE: 'DOUBLE'>, <Type.FLOAT: 'FLOAT'>}, <Type.BIGINT: 'BIGINT'>: {<Type.BIGDECIMAL: 'BIGDECIMAL'>, <Type.DOUBLE: 'DOUBLE'>, <Type.DECIMAL: 'DECIMAL'>, <Type.FLOAT: 'FLOAT'>}, <Type.INT: 'INT'>: {<Type.BIGINT: 'BIGINT'>, <Type.DOUBLE: 'DOUBLE'>, <Type.DECIMAL: 'DECIMAL'>, <Type.FLOAT: 'FLOAT'>}, <Type.SMALLINT: 'SMALLINT'>: {<Type.INT: 'INT'>, <Type.FLOAT: 'FLOAT'>, <Type.BIGINT: 'BIGINT'>, <Type.DOUBLE: 'DOUBLE'>, <Type.DECIMAL: 'DECIMAL'>}, <Type.TINYINT: 'TINYINT'>: {<Type.INT: 'INT'>, <Type.FLOAT: 'FLOAT'>, <Type.SMALLINT: 'SMALLINT'>, <Type.BIGINT: 'BIGINT'>, <Type.DOUBLE: 'DOUBLE'>, <Type.DECIMAL: 'DECIMAL'>}, <Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>: set(), <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>: {<Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>}, <Type.TIMESTAMP: 'TIMESTAMP'>: {<Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>}, <Type.DATETIME: 'DATETIME'>: {<Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <Type.TIMESTAMP: 'TIMESTAMP'>}, <Type.DATE: 'DATE'>: {<Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <Type.TIMESTAMP: 'TIMESTAMP'>, <Type.DATETIME: 'DATETIME'>}, <Type.NULL: 'NULL'>: {<Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <Type.VARCHAR: 'VARCHAR'>, <Type.INT: 'INT'>, <Type.FLOAT: 'FLOAT'>, <Type.DATETIME: 'DATETIME'>, <Type.NVARCHAR: 'NVARCHAR'>, <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <Type.DOUBLE: 'DOUBLE'>, <Type.NCHAR: 'NCHAR'>, <Type.TINYINT: 'TINYINT'>, <Type.TEXT: 'TEXT'>, <Type.TIMESTAMP: 'TIMESTAMP'>, <Type.DATE: 'DATE'>, <Type.CHAR: 'CHAR'>, <Type.SMALLINT: 'SMALLINT'>, <Type.BIGINT: 'BIGINT'>, <Type.DECIMAL: 'DECIMAL'>}, <Type.BIGDECIMAL: 'BIGDECIMAL'>: {<Type.DOUBLE: 'DOUBLE'>}}
TYPE_TO_EXPRESSIONS: Dict[sqlglot.expressions.DataType.Type, Set[Type[sqlglot.expressions.Expression]]] = {<Type.BIGINT: 'BIGINT'>: {<class 'sqlglot.expressions.Length'>, <class 'sqlglot.expressions.CountIf'>, <class 'sqlglot.expressions.UnixDate'>, <class 'sqlglot.expressions.UnixMillis'>, <class 'sqlglot.expressions.ApproxDistinct'>, <class 'sqlglot.expressions.UnixMicros'>, <class 'sqlglot.expressions.ArraySize'>, <class 'sqlglot.expressions.UnixSeconds'>, <class 'sqlglot.expressions.Int64'>}, <Type.BINARY: 'BINARY'>: {<class 'sqlglot.expressions.FromBase64'>, <class 'sqlglot.expressions.FromBase32'>}, <Type.BOOLEAN: 'BOOLEAN'>: {<class 'sqlglot.expressions.LogicalAnd'>, <class 'sqlglot.expressions.In'>, <class 'sqlglot.expressions.Contains'>, <class 'sqlglot.expressions.LogicalOr'>, <class 'sqlglot.expressions.EndsWith'>, <class 'sqlglot.expressions.StartsWith'>, <class 'sqlglot.expressions.Between'>, <class 'sqlglot.expressions.Boolean'>, <class 'sqlglot.expressions.RegexpLike'>}, <Type.DATE: 'DATE'>: {<class 'sqlglot.expressions.TsOrDsToDate'>, <class 'sqlglot.expressions.TimeStrToDate'>, <class 'sqlglot.expressions.DateStrToDate'>, <class 'sqlglot.expressions.DiToDate'>, <class 'sqlglot.expressions.StrToDate'>, <class 'sqlglot.expressions.DateFromParts'>, <class 'sqlglot.expressions.LastDay'>, <class 'sqlglot.expressions.CurrentDate'>, <class 'sqlglot.expressions.Date'>}, <Type.DATETIME: 'DATETIME'>: {<class 'sqlglot.expressions.CurrentDatetime'>, <class 'sqlglot.expressions.Datetime'>, <class 'sqlglot.expressions.DatetimeSub'>, <class 'sqlglot.expressions.DatetimeAdd'>}, <Type.DOUBLE: 'DOUBLE'>: {<class 'sqlglot.expressions.ToDouble'>, <class 'sqlglot.expressions.Exp'>, <class 'sqlglot.expressions.Stddev'>, <class 'sqlglot.expressions.Round'>, <class 'sqlglot.expressions.VariancePop'>, <class 'sqlglot.expressions.ApproxQuantile'>, <class 'sqlglot.expressions.Variance'>, <class 'sqlglot.expressions.Quantile'>, <class 'sqlglot.expressions.Log'>, <class 'sqlglot.expressions.Pow'>, <class 'sqlglot.expressions.StddevSamp'>, <class 'sqlglot.expressions.StddevPop'>, <class 'sqlglot.expressions.Ln'>, <class 'sqlglot.expressions.SafeDivide'>, <class 'sqlglot.expressions.Avg'>, <class 'sqlglot.expressions.Sqrt'>}, <Type.INT: 'INT'>: {<class 'sqlglot.expressions.DateToDi'>, <class 'sqlglot.expressions.TimestampDiff'>, <class 'sqlglot.expressions.Unicode'>, <class 'sqlglot.expressions.StrPosition'>, <class 'sqlglot.expressions.Ceil'>, <class 'sqlglot.expressions.DateDiff'>, <class 'sqlglot.expressions.TsOrDiToDi'>, <class 'sqlglot.expressions.Sign'>, <class 'sqlglot.expressions.TimeDiff'>, <class 'sqlglot.expressions.Levenshtein'>, <class 'sqlglot.expressions.Ascii'>, <class 'sqlglot.expressions.DatetimeDiff'>}, <Type.INTERVAL: 'INTERVAL'>: {<class 'sqlglot.expressions.JustifyInterval'>, <class 'sqlglot.expressions.Interval'>, <class 'sqlglot.expressions.JustifyHours'>, <class 'sqlglot.expressions.JustifyDays'>, <class 'sqlglot.expressions.MakeInterval'>}, <Type.JSON: 'JSON'>: {<class 'sqlglot.expressions.ParseJSON'>}, <Type.TIME: 'TIME'>: {<class 'sqlglot.expressions.TimeSub'>, <class 'sqlglot.expressions.TimeAdd'>, <class 'sqlglot.expressions.CurrentTime'>, <class 'sqlglot.expressions.Time'>}, <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>: {<class 'sqlglot.expressions.StrToTime'>, <class 'sqlglot.expressions.CurrentTimestamp'>, <class 'sqlglot.expressions.TimestampSub'>, <class 'sqlglot.expressions.TimestampAdd'>, <class 'sqlglot.expressions.UnixToTime'>, <class 'sqlglot.expressions.TimeStrToTime'>}, <Type.TINYINT: 'TINYINT'>: {<class 'sqlglot.expressions.Year'>, <class 'sqlglot.expressions.Month'>, <class 'sqlglot.expressions.Quarter'>, <class 'sqlglot.expressions.Day'>, <class 'sqlglot.expressions.Week'>}, <Type.VARCHAR: 'VARCHAR'>: {<class 'sqlglot.expressions.TsOrDsToDateStr'>, <class 'sqlglot.expressions.DPipe'>, <class 'sqlglot.expressions.ConcatWs'>, <class 'sqlglot.expressions.ToBase32'>, <class 'sqlglot.expressions.String'>, <class 'sqlglot.expressions.UnixToStr'>, <class 'sqlglot.expressions.TimeToTimeStr'>, <class 'sqlglot.expressions.ArrayToString'>, <class 'sqlglot.expressions.Chr'>, <class 'sqlglot.expressions.Substring'>, <class 'sqlglot.expressions.Lower'>, <class 'sqlglot.expressions.GroupConcat'>, <class 'sqlglot.expressions.ArrayConcat'>, <class 'sqlglot.expressions.Trim'>, <class 'sqlglot.expressions.ToBase64'>, <class 'sqlglot.expressions.Upper'>, <class 'sqlglot.expressions.Initcap'>, <class 'sqlglot.expressions.Concat'>, <class 'sqlglot.expressions.DateToDateStr'>, <class 'sqlglot.expressions.TimeToStr'>, <class 'sqlglot.expressions.UnixToTimeStr'>}}
ANNOTATORS: Dict[Type[~E], Callable[[sqlglot.optimizer.annotate_types.TypeAnnotator, ~E], ~E]] = {<class 'sqlglot.expressions.Alias'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.BitwiseNot'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Neg'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Not'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Paren'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.PivotAlias'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Unary'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Add'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.And'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.ArrayContains'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.ArrayContainsAll'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.ArrayOverlaps'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Binary'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.BitwiseAnd'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.BitwiseLeftShift'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.BitwiseOr'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.BitwiseRightShift'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.BitwiseXor'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Collate'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Connector'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Corr'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.CovarPop'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.CovarSamp'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.DPipe'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Distance'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Div'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Dot'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.EQ'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Escape'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.GT'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.GTE'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Glob'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.ILike'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.IntDiv'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Is'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.JSONArrayContains'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.JSONBContains'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.JSONBContainsAllTopKeys'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.JSONBContainsAnyTopKeys'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.JSONBDeleteAtPath'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.JSONBExtract'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.JSONBExtractScalar'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.JSONExtract'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.JSONExtractScalar'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Kwarg'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.LT'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.LTE'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Like'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Mod'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Mul'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.NEQ'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.NullSafeEQ'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.NullSafeNEQ'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Operator'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Or'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Overlaps'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Pow'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.PropertyEQ'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.RegexpILike'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.RegexpLike'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.SimilarTo'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Slice'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Sub'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Xor'>: <function Dialect.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Length'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.CountIf'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.UnixDate'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.UnixMillis'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.ApproxDistinct'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.UnixMicros'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.ArraySize'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.UnixSeconds'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Int64'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.FromBase64'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.FromBase32'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.LogicalAnd'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.In'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Contains'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.LogicalOr'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.EndsWith'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.StartsWith'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Between'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Boolean'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.TsOrDsToDate'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.TimeStrToDate'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.DateStrToDate'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.DiToDate'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.StrToDate'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.DateFromParts'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.LastDay'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.CurrentDate'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Date'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.CurrentDatetime'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Datetime'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.DatetimeSub'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.DatetimeAdd'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.ToDouble'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Exp'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Stddev'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Round'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.VariancePop'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.ApproxQuantile'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Variance'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Quantile'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Log'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.StddevSamp'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.StddevPop'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Ln'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.SafeDivide'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Avg'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Sqrt'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.DateToDi'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.TimestampDiff'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Unicode'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.StrPosition'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Ceil'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.DateDiff'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.TsOrDiToDi'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Sign'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.TimeDiff'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Levenshtein'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Ascii'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.DatetimeDiff'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.JustifyInterval'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Interval'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.JustifyHours'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.JustifyDays'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.MakeInterval'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.ParseJSON'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.TimeSub'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.TimeAdd'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.CurrentTime'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Time'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.CurrentTimestampLTZ'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.StrToTime'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.CurrentTimestamp'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.TimestampSub'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.TimestampAdd'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.UnixToTime'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.TimeStrToTime'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Year'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Month'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Quarter'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Day'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Week'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.TsOrDsToDateStr'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.ConcatWs'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.ToBase32'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.String'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.UnixToStr'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.TimeToTimeStr'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.ArrayToString'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Chr'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Substring'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Lower'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.GroupConcat'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.ArrayConcat'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Trim'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.ToBase64'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Upper'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Initcap'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Concat'>: <function _annotate_concat>, <class 'sqlglot.expressions.DateToDateStr'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.TimeToStr'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.UnixToTimeStr'>: <function annotate_with_type_lambda.<locals>.<lambda>>, <class 'sqlglot.expressions.Abs'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Anonymous'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Array'>: <function _annotate_array>, <class 'sqlglot.expressions.AnyValue'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.ArrayAgg'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.ArrayConcatAgg'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.ArrayFirst'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.ArrayLast'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.ArrayReverse'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.ArraySlice'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Bracket'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Cast'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Case'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Coalesce'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Count'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.DataType'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.DateAdd'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.DateSub'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.DateTrunc'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Distinct'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Explode'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Extract'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Filter'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.GenerateSeries'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.GenerateDateArray'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.GenerateTimestampArray'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Greatest'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.If'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Least'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Literal'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.LastValue'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Map'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Max'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Min'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Null'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Nullif'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Struct'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Sum'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.SortArray'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Timestamp'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.ToMap'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.TryCast'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Unnest'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.VarMap'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Window'>: <function Dialect.<lambda>>, <class 'sqlglot.expressions.Floor'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.ArgMax'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.ArgMin'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.DatetimeTrunc'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.FirstValue'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.IgnoreNulls'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Lead'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Left'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.NthValue'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Pad'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.PercentileDisc'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.RegexpExtract'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.RegexpReplace'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Repeat'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Replace'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.RespectNulls'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Reverse'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Right'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.SafeNegate'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.TimestampTrunc'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Translate'>: <function BigQuery.<dictcomp>.<lambda>>, <class 'sqlglot.expressions.Acos'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Acosh'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Asin'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Asinh'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Atan'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Atanh'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Atan2'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.ApproxTopSum'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.ApproxTopK'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.ApproxQuantiles'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.BitwiseAndAgg'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.BitwiseOrAgg'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.BitwiseXorAgg'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.BitwiseCountAgg'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.ByteLength'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.ByteString'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Cbrt'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.CodePointsToBytes'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.CodePointsToString'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Cot'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.CosineDistance'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Coth'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Csc'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Csch'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.CumeDist'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.DateFromUnixDate'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.DenseRank'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.EuclideanDistance'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.FarmFingerprint'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Unhex'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Float64'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Format'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Grouping'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.IsInf'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.IsNan'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.JSONArray'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.JSONArrayAppend'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.JSONArrayInsert'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.JSONBool'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.JSONExtractArray'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.JSONFormat'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.JSONKeysAtDepth'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.JSONObject'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.JSONRemove'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.JSONSet'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.JSONStripNulls'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.JSONType'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.JSONValueArray'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Lag'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.LowerHex'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.LaxBool'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.LaxFloat64'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.LaxInt64'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.LaxString'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.MD5Digest'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Normalize'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Ntile'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.ParseTime'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.ParseDatetime'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.ParseBignumeric'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.ParseNumeric'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.PercentileCont'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.PercentRank'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Rank'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.RangeBucket'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.RegexpExtractAll'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.RegexpInstr'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.RowNumber'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Rand'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.SafeConvertBytesToString'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.SafeAdd'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.SafeMultiply'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.SafeSubtract'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Sec'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Sech'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Soundex'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.SHA'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.SHA2'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Sin'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Sinh'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Split'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.TimestampFromParts'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.TimeFromParts'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.TimeTrunc'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.ToCodePoints'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.TsOrDsToTime'>: <function BigQuery.<lambda>>, <class 'sqlglot.expressions.Uuid'>: <function BigQuery.<lambda>>}
def normalize_identifier(self, expression: ~E) -> ~E: View Source

    672    def normalize_identifier(self, expression: E) -> E:
    673        if (
    674            isinstance(expression, exp.Identifier)
    675            and self.normalization_strategy is NormalizationStrategy.CASE_INSENSITIVE
    676        ):
    677            parent = expression.parent
    678            while isinstance(parent, exp.Dot):
    679                parent = parent.parent
    680
    681            # In BigQuery, CTEs are case-insensitive, but UDF and table names are case-sensitive
    682            # by default. The following check uses a heuristic to detect tables based on whether
    683            # they are qualified. This should generally be correct, because tables in BigQuery
    684            # must be qualified with at least a dataset, unless @@dataset_id is set.
    685            case_sensitive = (
    686                isinstance(parent, exp.UserDefinedFunction)
    687                or (
    688                    isinstance(parent, exp.Table)
    689                    and parent.db
    690                    and (parent.meta.get("quoted_table") or not parent.meta.get("maybe_column"))
    691                )
    692                or expression.meta.get("is_table")
    693            )
    694            if not case_sensitive:
    695                expression.set("this", expression.this.lower())
    696
    697            return t.cast(E, expression)
    698
    699        return super().normalize_identifier(expression)

Transforms an identifier in a way that resembles how it'd be resolved by this dialect.

For example, an identifier like `FoO` would be resolved as `foo` in Postgres, because it lowercases all unquoted identifiers. On the other hand, Snowflake uppercases them, so it would resolve it as `FOO`. If it was quoted, it'd need to be treated as case-sensitive, and so any normalization would be prohibited in order to avoid "breaking" the identifier.

There are also dialects like Spark, which are case-insensitive even when quotes are present, and dialects like MySQL, whose resolution rules match those employed by the underlying operating system, for example they may always be case-sensitive in Linux.

Finally, the normalization behavior of some engines can even be controlled through flags, like in Redshift's case, where users can explicitly set enable_case_sensitive_identifier.

SQLGlot aims to understand and handle all of these different behaviors gracefully, so that it can analyze queries in the optimizer and successfully capture their semantics.

SUPPORTS_COLUMN_JOIN_MARKS = False

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

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

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

tokenizer_class = <class 'BigQuery.Tokenizer'>
jsonpath_tokenizer_class = <class 'BigQuery.JSONPathTokenizer'>
parser_class = <class 'BigQuery.Parser'>
generator_class = <class 'BigQuery.Generator'>
TIME_TRIE: Dict = {'%': {'D': {0: True}, 'E': {'6': {'S': {0: True}}}, 'e': {0: True}}}
FORMAT_TRIE: Dict = {'D': {'D': {0: True}}, 'M': {'M': {0: True}, 'O': {'N': {0: True, 'T': {'H': {0: True}}}}, 'I': {0: True}}, 'Y': {'Y': {'Y': {'Y': {0: True}}, 0: True}}, 'H': {'H': {0: True, '1': {'2': {0: True}}, '2': {'4': {0: True}}}}, 'S': {'S': {0: True, 'S': {'S': {'S': {0: True}}}}}, 'T': {'Z': {'H': {0: True}}}}
INVERSE_TIME_MAPPING: Dict[str, str] = {'%m/%d/%y': '%D', '%S.%f': '%E6S', '%-d': '%e'}
INVERSE_TIME_TRIE: Dict = {'%': {'m': {'/': {'%': {'d': {'/': {'%': {'y': {0: True}}}}}}}, 'S': {'.': {'%': {'f': {0: True}}}}, '-': {'d': {0: True}}}}
INVERSE_FORMAT_MAPPING: Dict[str, str] = {'%d': 'DD', '%m': 'MM', '%b': 'MON', '%B': 'MONTH', '%Y': 'YYYY', '%y': 'YY', '%I': 'HH12', '%H': 'HH24', '%M': 'MI', '%S': 'SS', '%f': 'SSSSS', '%z': 'TZH'}
INVERSE_FORMAT_TRIE: Dict = {'%': {'d': {0: True}, 'm': {0: True}, 'b': {0: True}, 'B': {0: True}, 'Y': {0: True}, 'y': {0: True}, 'I': {0: True}, 'H': {0: True}, 'M': {0: True}, 'S': {0: True}, 'f': {0: True}, 'z': {0: True}}}
INVERSE_CREATABLE_KIND_MAPPING: dict[str, str] = {}
ESCAPED_SEQUENCES: Dict[str, str] = {'\x07': '\\a', '\x08': '\\b', '\x0c': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t', '\x0b': '\\v', '\\': '\\\\'}
QUOTE_START = "'"
QUOTE_END = "'"
IDENTIFIER_START = '`'
IDENTIFIER_END = '`'
BIT_START: Optional[str] = None
BIT_END: Optional[str] = None
HEX_START: Optional[str] = '0x'
HEX_END: Optional[str] = ''
BYTE_START: Optional[str] = "b'"
BYTE_END: Optional[str] = "'"
UNICODE_START: Optional[str] = None
UNICODE_END: Optional[str] = None
class BigQuery.JSONPathTokenizer(sqlglot.jsonpath.JSONPathTokenizer): View Source

    701    class JSONPathTokenizer(jsonpath.JSONPathTokenizer):
    702        VAR_TOKENS = {
    703            TokenType.DASH,
    704            TokenType.VAR,
    705        }

VAR_TOKENS = {<TokenType.VAR: 'VAR'>, <TokenType.DASH: 'DASH'>}

##### Inherited Members

sqlglot.tokens.Tokenizer
  Tokenizer
  BIT_STRINGS
  BYTE_STRINGS
  HEX_STRINGS
  RAW_STRINGS
  HEREDOC_STRINGS
  UNICODE_STRINGS
  IDENTIFIERS
  QUOTES
  VAR_SINGLE_TOKENS
  HEREDOC_TAG_IS_IDENTIFIER
  HEREDOC_STRING_ALTERNATIVE
  STRING_ESCAPES_ALLOWED_IN_RAW_STRINGS
  NESTED_COMMENTS
  HINT_START
  TOKENS_PRECEDING_HINT
  WHITE_SPACE
  COMMANDS
  COMMAND_PREFIX_TOKENS
  NUMERIC_LITERALS
  COMMENTS
  dialect
  use_rs_tokenizer
  reset
  tokenize
  tokenize_rs
  size
  sql
  tokens
sqlglot.jsonpath.JSONPathTokenizer
  SINGLE_TOKENS
  KEYWORDS
  IDENTIFIER_ESCAPES
  STRING_ESCAPES

class BigQuery.Tokenizer(sqlglot.tokens.Tokenizer): View Source

    707    class Tokenizer(tokens.Tokenizer):
    708        QUOTES = ["'", '"', '"""', "'''"]
    709        COMMENTS = ["--", "#", ("/*", "*/")]
    710        IDENTIFIERS = ["`"]
    711        STRING_ESCAPES = ["\\"]
    712
    713        HEX_STRINGS = [("0x", ""), ("0X", "")]
    714
    715        BYTE_STRINGS = [
    716            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("b", "B")
    717        ]
    718
    719        RAW_STRINGS = [
    720            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("r", "R")
    721        ]
    722
    723        NESTED_COMMENTS = False
    724
    725        KEYWORDS = {
    726            **tokens.Tokenizer.KEYWORDS,
    727            "ANY TYPE": TokenType.VARIANT,
    728            "BEGIN": TokenType.COMMAND,
    729            "BEGIN TRANSACTION": TokenType.BEGIN,
    730            "BYTEINT": TokenType.INT,
    731            "BYTES": TokenType.BINARY,
    732            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
    733            "DATETIME": TokenType.TIMESTAMP,
    734            "DECLARE": TokenType.DECLARE,
    735            "ELSEIF": TokenType.COMMAND,
    736            "EXCEPTION": TokenType.COMMAND,
    737            "EXPORT": TokenType.EXPORT,
    738            "FLOAT64": TokenType.DOUBLE,
    739            "FOR SYSTEM_TIME": TokenType.TIMESTAMP_SNAPSHOT,
    740            "LOOP": TokenType.COMMAND,
    741            "MODEL": TokenType.MODEL,
    742            "NOT DETERMINISTIC": TokenType.VOLATILE,
    743            "RECORD": TokenType.STRUCT,
    744            "REPEAT": TokenType.COMMAND,
    745            "TIMESTAMP": TokenType.TIMESTAMPTZ,
    746            "WHILE": TokenType.COMMAND,
    747        }
    748        KEYWORDS.pop("DIV")
    749        KEYWORDS.pop("VALUES")
    750        KEYWORDS.pop("/*+")

QUOTES = ["'", '"', '"""', "'''"]
COMMENTS = ['--', '#', ('/*', '*/')]
IDENTIFIERS = ['`']
STRING_ESCAPES = ['\\']
HEX_STRINGS = [('0x', ''), ('0X', '')]
BYTE_STRINGS = [("b'", "'"), ("B'", "'"), ('b"', '"'), ('B"', '"'), ('b"""', '"""'), ('B"""', '"""'), ("b'''", "'''"), ("B'''", "'''")]
RAW_STRINGS = [("r'", "'"), ("R'", "'"), ('r"', '"'), ('R"', '"'), ('r"""', '"""'), ('R"""', '"""'), ("r'''", "'''"), ("R'''", "'''")]
NESTED_COMMENTS = False
KEYWORDS = {'{%': <TokenType.BLOCK_START: 'BLOCK_START'>, '{%+': <TokenType.BLOCK_START: 'BLOCK_START'>, '{%-': <TokenType.BLOCK_START: 'BLOCK_START'>, '%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '+%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '-%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '{{+': <TokenType.BLOCK_START: 'BLOCK_START'>, '{{-': <TokenType.BLOCK_START: 'BLOCK_START'>, '+}}': <TokenType.BLOCK_END: 'BLOCK_END'>, '-}}': <TokenType.BLOCK_END: 'BLOCK_END'>, '==': <TokenType.EQ: 'EQ'>, '::': <TokenType.DCOLON: 'DCOLON'>, '||': <TokenType.DPIPE: 'DPIPE'>, '|>': <TokenType.PIPE_GT: 'PIPE_GT'>, '>=': <TokenType.GTE: 'GTE'>, '<=': <TokenType.LTE: 'LTE'>, '<>': <TokenType.NEQ: 'NEQ'>, '!=': <TokenType.NEQ: 'NEQ'>, ':=': <TokenType.COLON_EQ: 'COLON_EQ'>, '<=>': <TokenType.NULLSAFE_EQ: 'NULLSAFE_EQ'>, '->': <TokenType.ARROW: 'ARROW'>, '->>': <TokenType.DARROW: 'DARROW'>, '=>': <TokenType.FARROW: 'FARROW'>, '#>': <TokenType.HASH_ARROW: 'HASH_ARROW'>, '#>>': <TokenType.DHASH_ARROW: 'DHASH_ARROW'>, '<->': <TokenType.LR_ARROW: 'LR_ARROW'>, '&&': <TokenType.DAMP: 'DAMP'>, '??': <TokenType.DQMARK: 'DQMARK'>, '~~~': <TokenType.GLOB: 'GLOB'>, '~~': <TokenType.LIKE: 'LIKE'>, '~~*': <TokenType.ILIKE: 'ILIKE'>, '~*': <TokenType.IRLIKE: 'IRLIKE'>, 'ALL': <TokenType.ALL: 'ALL'>, 'AND': <TokenType.AND: 'AND'>, 'ANTI': <TokenType.ANTI: 'ANTI'>, 'ANY': <TokenType.ANY: 'ANY'>, 'ASC': <TokenType.ASC: 'ASC'>, 'AS': <TokenType.ALIAS: 'ALIAS'>, 'ASOF': <TokenType.ASOF: 'ASOF'>, 'AUTOINCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'AUTO_INCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'BEGIN': <TokenType.COMMAND: 'COMMAND'>, 'BETWEEN': <TokenType.BETWEEN: 'BETWEEN'>, 'CACHE': <TokenType.CACHE: 'CACHE'>, 'UNCACHE': <TokenType.UNCACHE: 'UNCACHE'>, 'CASE': <TokenType.CASE: 'CASE'>, 'CHARACTER SET': <TokenType.CHARACTER_SET: 'CHARACTER_SET'>, 'CLUSTER BY': <TokenType.CLUSTER_BY: 'CLUSTER_BY'>, 'COLLATE': <TokenType.COLLATE: 'COLLATE'>, 'COLUMN': <TokenType.COLUMN: 'COLUMN'>, 'COMMIT': <TokenType.COMMIT: 'COMMIT'>, 'CONNECT BY': <TokenType.CONNECT_BY: 'CONNECT_BY'>, 'CONSTRAINT': <TokenType.CONSTRAINT: 'CONSTRAINT'>, 'COPY': <TokenType.COPY: 'COPY'>, 'CREATE': <TokenType.CREATE: 'CREATE'>, 'CROSS': <TokenType.CROSS: 'CROSS'>, 'CUBE': <TokenType.CUBE: 'CUBE'>, 'CURRENT_DATE': <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, 'CURRENT_SCHEMA': <TokenType.CURRENT_SCHEMA: 'CURRENT_SCHEMA'>, 'CURRENT_TIME': <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, 'CURRENT_TIMESTAMP': <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, 'CURRENT_USER': <TokenType.CURRENT_USER: 'CURRENT_USER'>, 'DATABASE': <TokenType.DATABASE: 'DATABASE'>, 'DEFAULT': <TokenType.DEFAULT: 'DEFAULT'>, 'DELETE': <TokenType.DELETE: 'DELETE'>, 'DESC': <TokenType.DESC: 'DESC'>, 'DESCRIBE': <TokenType.DESCRIBE: 'DESCRIBE'>, 'DISTINCT': <TokenType.DISTINCT: 'DISTINCT'>, 'DISTRIBUTE BY': <TokenType.DISTRIBUTE_BY: 'DISTRIBUTE_BY'>, 'DROP': <TokenType.DROP: 'DROP'>, 'ELSE': <TokenType.ELSE: 'ELSE'>, 'END': <TokenType.END: 'END'>, 'ENUM': <TokenType.ENUM: 'ENUM'>, 'ESCAPE': <TokenType.ESCAPE: 'ESCAPE'>, 'EXCEPT': <TokenType.EXCEPT: 'EXCEPT'>, 'EXECUTE': <TokenType.EXECUTE: 'EXECUTE'>, 'EXISTS': <TokenType.EXISTS: 'EXISTS'>, 'FALSE': <TokenType.FALSE: 'FALSE'>, 'FETCH': <TokenType.FETCH: 'FETCH'>, 'FILTER': <TokenType.FILTER: 'FILTER'>, 'FIRST': <TokenType.FIRST: 'FIRST'>, 'FULL': <TokenType.FULL: 'FULL'>, 'FUNCTION': <TokenType.FUNCTION: 'FUNCTION'>, 'FOR': <TokenType.FOR: 'FOR'>, 'FOREIGN KEY': <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, 'FORMAT': <TokenType.FORMAT: 'FORMAT'>, 'FROM': <TokenType.FROM: 'FROM'>, 'GEOGRAPHY': <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, 'GEOMETRY': <TokenType.GEOMETRY: 'GEOMETRY'>, 'GLOB': <TokenType.GLOB: 'GLOB'>, 'GROUP BY': <TokenType.GROUP_BY: 'GROUP_BY'>, 'GROUPING SETS': <TokenType.GROUPING_SETS: 'GROUPING_SETS'>, 'HAVING': <TokenType.HAVING: 'HAVING'>, 'ILIKE': <TokenType.ILIKE: 'ILIKE'>, 'IN': <TokenType.IN: 'IN'>, 'INDEX': <TokenType.INDEX: 'INDEX'>, 'INET': <TokenType.INET: 'INET'>, 'INNER': <TokenType.INNER: 'INNER'>, 'INSERT': <TokenType.INSERT: 'INSERT'>, 'INTERVAL': <TokenType.INTERVAL: 'INTERVAL'>, 'INTERSECT': <TokenType.INTERSECT: 'INTERSECT'>, 'INTO': <TokenType.INTO: 'INTO'>, 'IS': <TokenType.IS: 'IS'>, 'ISNULL': <TokenType.ISNULL: 'ISNULL'>, 'JOIN': <TokenType.JOIN: 'JOIN'>, 'KEEP': <TokenType.KEEP: 'KEEP'>, 'KILL': <TokenType.KILL: 'KILL'>, 'LATERAL': <TokenType.LATERAL: 'LATERAL'>, 'LEFT': <TokenType.LEFT: 'LEFT'>, 'LIKE': <TokenType.LIKE: 'LIKE'>, 'LIMIT': <TokenType.LIMIT: 'LIMIT'>, 'LOAD': <TokenType.LOAD: 'LOAD'>, 'LOCK': <TokenType.LOCK: 'LOCK'>, 'MERGE': <TokenType.MERGE: 'MERGE'>, 'NAMESPACE': <TokenType.NAMESPACE: 'NAMESPACE'>, 'NATURAL': <TokenType.NATURAL: 'NATURAL'>, 'NEXT': <TokenType.NEXT: 'NEXT'>, 'NOT': <TokenType.NOT: 'NOT'>, 'NOTNULL': <TokenType.NOTNULL: 'NOTNULL'>, 'NULL': <TokenType.NULL: 'NULL'>, 'OBJECT': <TokenType.OBJECT: 'OBJECT'>, 'OFFSET': <TokenType.OFFSET: 'OFFSET'>, 'ON': <TokenType.ON: 'ON'>, 'OR': <TokenType.OR: 'OR'>, 'XOR': <TokenType.XOR: 'XOR'>, 'ORDER BY': <TokenType.ORDER_BY: 'ORDER_BY'>, 'ORDINALITY': <TokenType.ORDINALITY: 'ORDINALITY'>, 'OUTER': <TokenType.OUTER: 'OUTER'>, 'OVER': <TokenType.OVER: 'OVER'>, 'OVERLAPS': <TokenType.OVERLAPS: 'OVERLAPS'>, 'OVERWRITE': <TokenType.OVERWRITE: 'OVERWRITE'>, 'PARTITION': <TokenType.PARTITION: 'PARTITION'>, 'PARTITION BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED_BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PERCENT': <TokenType.PERCENT: 'PERCENT'>, 'PIVOT': <TokenType.PIVOT: 'PIVOT'>, 'PRAGMA': <TokenType.PRAGMA: 'PRAGMA'>, 'PRIMARY KEY': <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, 'PROCEDURE': <TokenType.PROCEDURE: 'PROCEDURE'>, 'QUALIFY': <TokenType.QUALIFY: 'QUALIFY'>, 'RANGE': <TokenType.RANGE: 'RANGE'>, 'RECURSIVE': <TokenType.RECURSIVE: 'RECURSIVE'>, 'REGEXP': <TokenType.RLIKE: 'RLIKE'>, 'RENAME': <TokenType.RENAME: 'RENAME'>, 'REPLACE': <TokenType.REPLACE: 'REPLACE'>, 'RETURNING': <TokenType.RETURNING: 'RETURNING'>, 'REFERENCES': <TokenType.REFERENCES: 'REFERENCES'>, 'RIGHT': <TokenType.RIGHT: 'RIGHT'>, 'RLIKE': <TokenType.RLIKE: 'RLIKE'>, 'ROLLBACK': <TokenType.ROLLBACK: 'ROLLBACK'>, 'ROLLUP': <TokenType.ROLLUP: 'ROLLUP'>, 'ROW': <TokenType.ROW: 'ROW'>, 'ROWS': <TokenType.ROWS: 'ROWS'>, 'SCHEMA': <TokenType.SCHEMA: 'SCHEMA'>, 'SELECT': <TokenType.SELECT: 'SELECT'>, 'SEMI': <TokenType.SEMI: 'SEMI'>, 'SESSION': <TokenType.SESSION: 'SESSION'>, 'SET': <TokenType.SET: 'SET'>, 'SETTINGS': <TokenType.SETTINGS: 'SETTINGS'>, 'SHOW': <TokenType.SHOW: 'SHOW'>, 'SIMILAR TO': <TokenType.SIMILAR_TO: 'SIMILAR_TO'>, 'SOME': <TokenType.SOME: 'SOME'>, 'SORT BY': <TokenType.SORT_BY: 'SORT_BY'>, 'START WITH': <TokenType.START_WITH: 'START_WITH'>, 'STRAIGHT_JOIN': <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, 'TABLE': <TokenType.TABLE: 'TABLE'>, 'TABLESAMPLE': <TokenType.TABLE_SAMPLE: 'TABLE_SAMPLE'>, 'TEMP': <TokenType.TEMPORARY: 'TEMPORARY'>, 'TEMPORARY': <TokenType.TEMPORARY: 'TEMPORARY'>, 'THEN': <TokenType.THEN: 'THEN'>, 'TRUE': <TokenType.TRUE: 'TRUE'>, 'TRUNCATE': <TokenType.TRUNCATE: 'TRUNCATE'>, 'UNION': <TokenType.UNION: 'UNION'>, 'UNKNOWN': <TokenType.UNKNOWN: 'UNKNOWN'>, 'UNNEST': <TokenType.UNNEST: 'UNNEST'>, 'UNPIVOT': <TokenType.UNPIVOT: 'UNPIVOT'>, 'UPDATE': <TokenType.UPDATE: 'UPDATE'>, 'USE': <TokenType.USE: 'USE'>, 'USING': <TokenType.USING: 'USING'>, 'UUID': <TokenType.UUID: 'UUID'>, 'VIEW': <TokenType.VIEW: 'VIEW'>, 'VOLATILE': <TokenType.VOLATILE: 'VOLATILE'>, 'WHEN': <TokenType.WHEN: 'WHEN'>, 'WHERE': <TokenType.WHERE: 'WHERE'>, 'WINDOW': <TokenType.WINDOW: 'WINDOW'>, 'WITH': <TokenType.WITH: 'WITH'>, 'APPLY': <TokenType.APPLY: 'APPLY'>, 'ARRAY': <TokenType.ARRAY: 'ARRAY'>, 'BIT': <TokenType.BIT: 'BIT'>, 'BOOL': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BOOLEAN': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BYTE': <TokenType.TINYINT: 'TINYINT'>, 'MEDIUMINT': <TokenType.MEDIUMINT: 'MEDIUMINT'>, 'INT1': <TokenType.TINYINT: 'TINYINT'>, 'TINYINT': <TokenType.TINYINT: 'TINYINT'>, 'INT16': <TokenType.SMALLINT: 'SMALLINT'>, 'SHORT': <TokenType.SMALLINT: 'SMALLINT'>, 'SMALLINT': <TokenType.SMALLINT: 'SMALLINT'>, 'HUGEINT': <TokenType.INT128: 'INT128'>, 'UHUGEINT': <TokenType.UINT128: 'UINT128'>, 'INT2': <TokenType.SMALLINT: 'SMALLINT'>, 'INTEGER': <TokenType.INT: 'INT'>, 'INT': <TokenType.INT: 'INT'>, 'INT4': <TokenType.INT: 'INT'>, 'INT32': <TokenType.INT: 'INT'>, 'INT64': <TokenType.BIGINT: 'BIGINT'>, 'INT128': <TokenType.INT128: 'INT128'>, 'INT256': <TokenType.INT256: 'INT256'>, 'LONG': <TokenType.BIGINT: 'BIGINT'>, 'BIGINT': <TokenType.BIGINT: 'BIGINT'>, 'INT8': <TokenType.TINYINT: 'TINYINT'>, 'UINT': <TokenType.UINT: 'UINT'>, 'UINT128': <TokenType.UINT128: 'UINT128'>, 'UINT256': <TokenType.UINT256: 'UINT256'>, 'DEC': <TokenType.DECIMAL: 'DECIMAL'>, 'DECIMAL': <TokenType.DECIMAL: 'DECIMAL'>, 'DECIMAL32': <TokenType.DECIMAL32: 'DECIMAL32'>, 'DECIMAL64': <TokenType.DECIMAL64: 'DECIMAL64'>, 'DECIMAL128': <TokenType.DECIMAL128: 'DECIMAL128'>, 'DECIMAL256': <TokenType.DECIMAL256: 'DECIMAL256'>, 'BIGDECIMAL': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, 'BIGNUMERIC': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, 'LIST': <TokenType.LIST: 'LIST'>, 'MAP': <TokenType.MAP: 'MAP'>, 'NULLABLE': <TokenType.NULLABLE: 'NULLABLE'>, 'NUMBER': <TokenType.DECIMAL: 'DECIMAL'>, 'NUMERIC': <TokenType.DECIMAL: 'DECIMAL'>, 'FIXED': <TokenType.DECIMAL: 'DECIMAL'>, 'REAL': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT4': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT8': <TokenType.DOUBLE: 'DOUBLE'>, 'DOUBLE': <TokenType.DOUBLE: 'DOUBLE'>, 'DOUBLE PRECISION': <TokenType.DOUBLE: 'DOUBLE'>, 'JSON': <TokenType.JSON: 'JSON'>, 'JSONB': <TokenType.JSONB: 'JSONB'>, 'CHAR': <TokenType.CHAR: 'CHAR'>, 'CHARACTER': <TokenType.CHAR: 'CHAR'>, 'CHAR VARYING': <TokenType.VARCHAR: 'VARCHAR'>, 'CHARACTER VARYING': <TokenType.VARCHAR: 'VARCHAR'>, 'NCHAR': <TokenType.NCHAR: 'NCHAR'>, 'VARCHAR': <TokenType.VARCHAR: 'VARCHAR'>, 'VARCHAR2': <TokenType.VARCHAR: 'VARCHAR'>, 'NVARCHAR': <TokenType.NVARCHAR: 'NVARCHAR'>, 'NVARCHAR2': <TokenType.NVARCHAR: 'NVARCHAR'>, 'BPCHAR': <TokenType.BPCHAR: 'BPCHAR'>, 'STR': <TokenType.TEXT: 'TEXT'>, 'STRING': <TokenType.TEXT: 'TEXT'>, 'TEXT': <TokenType.TEXT: 'TEXT'>, 'LONGTEXT': <TokenType.LONGTEXT: 'LONGTEXT'>, 'MEDIUMTEXT': <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, 'TINYTEXT': <TokenType.TINYTEXT: 'TINYTEXT'>, 'CLOB': <TokenType.TEXT: 'TEXT'>, 'LONGVARCHAR': <TokenType.TEXT: 'TEXT'>, 'BINARY': <TokenType.BINARY: 'BINARY'>, 'BLOB': <TokenType.VARBINARY: 'VARBINARY'>, 'LONGBLOB': <TokenType.LONGBLOB: 'LONGBLOB'>, 'MEDIUMBLOB': <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, 'TINYBLOB': <TokenType.TINYBLOB: 'TINYBLOB'>, 'BYTEA': <TokenType.VARBINARY: 'VARBINARY'>, 'VARBINARY': <TokenType.VARBINARY: 'VARBINARY'>, 'TIME': <TokenType.TIME: 'TIME'>, 'TIMETZ': <TokenType.TIMETZ: 'TIMETZ'>, 'TIMESTAMP': <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, 'TIMESTAMPTZ': <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, 'TIMESTAMPLTZ': <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, 'TIMESTAMP_LTZ': <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, 'TIMESTAMPNTZ': <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, 'TIMESTAMP_NTZ': <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, 'DATE': <TokenType.DATE: 'DATE'>, 'DATETIME': <TokenType.TIMESTAMP: 'TIMESTAMP'>, 'INT4RANGE': <TokenType.INT4RANGE: 'INT4RANGE'>, 'INT4MULTIRANGE': <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, 'INT8RANGE': <TokenType.INT8RANGE: 'INT8RANGE'>, 'INT8MULTIRANGE': <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, 'NUMRANGE': <TokenType.NUMRANGE: 'NUMRANGE'>, 'NUMMULTIRANGE': <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, 'TSRANGE': <TokenType.TSRANGE: 'TSRANGE'>, 'TSMULTIRANGE': <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, 'TSTZRANGE': <TokenType.TSTZRANGE: 'TSTZRANGE'>, 'TSTZMULTIRANGE': <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, 'DATERANGE': <TokenType.DATERANGE: 'DATERANGE'>, 'DATEMULTIRANGE': <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, 'UNIQUE': <TokenType.UNIQUE: 'UNIQUE'>, 'VECTOR': <TokenType.VECTOR: 'VECTOR'>, 'STRUCT': <TokenType.STRUCT: 'STRUCT'>, 'SEQUENCE': <TokenType.SEQUENCE: 'SEQUENCE'>, 'VARIANT': <TokenType.VARIANT: 'VARIANT'>, 'ALTER': <TokenType.ALTER: 'ALTER'>, 'ANALYZE': <TokenType.ANALYZE: 'ANALYZE'>, 'CALL': <TokenType.COMMAND: 'COMMAND'>, 'COMMENT': <TokenType.COMMENT: 'COMMENT'>, 'EXPLAIN': <TokenType.COMMAND: 'COMMAND'>, 'GRANT': <TokenType.GRANT: 'GRANT'>, 'REVOKE': <TokenType.REVOKE: 'REVOKE'>, 'OPTIMIZE': <TokenType.COMMAND: 'COMMAND'>, 'PREPARE': <TokenType.COMMAND: 'COMMAND'>, 'VACUUM': <TokenType.COMMAND: 'COMMAND'>, 'USER-DEFINED': <TokenType.USERDEFINED: 'USERDEFINED'>, 'FOR VERSION': <TokenType.VERSION_SNAPSHOT: 'VERSION_SNAPSHOT'>, 'FOR TIMESTAMP': <TokenType.TIMESTAMP_SNAPSHOT: 'TIMESTAMP_SNAPSHOT'>, 'ANY TYPE': <TokenType.VARIANT: 'VARIANT'>, 'BEGIN TRANSACTION': <TokenType.BEGIN: 'BEGIN'>, 'BYTEINT': <TokenType.INT: 'INT'>, 'BYTES': <TokenType.BINARY: 'BINARY'>, 'CURRENT_DATETIME': <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, 'DECLARE': <TokenType.DECLARE: 'DECLARE'>, 'ELSEIF': <TokenType.COMMAND: 'COMMAND'>, 'EXCEPTION': <TokenType.COMMAND: 'COMMAND'>, 'EXPORT': <TokenType.EXPORT: 'EXPORT'>, 'FLOAT64': <TokenType.DOUBLE: 'DOUBLE'>, 'FOR SYSTEM_TIME': <TokenType.TIMESTAMP_SNAPSHOT: 'TIMESTAMP_SNAPSHOT'>, 'LOOP': <TokenType.COMMAND: 'COMMAND'>, 'MODEL': <TokenType.MODEL: 'MODEL'>, 'NOT DETERMINISTIC': <TokenType.VOLATILE: 'VOLATILE'>, 'RECORD': <TokenType.STRUCT: 'STRUCT'>, 'REPEAT': <TokenType.COMMAND: 'COMMAND'>, 'WHILE': <TokenType.COMMAND: 'COMMAND'>}

##### Inherited Members

sqlglot.tokens.Tokenizer
  Tokenizer
  SINGLE_TOKENS
  BIT_STRINGS
  HEREDOC_STRINGS
  UNICODE_STRINGS
  VAR_SINGLE_TOKENS
  IDENTIFIER_ESCAPES
  HEREDOC_TAG_IS_IDENTIFIER
  HEREDOC_STRING_ALTERNATIVE
  STRING_ESCAPES_ALLOWED_IN_RAW_STRINGS
  HINT_START
  TOKENS_PRECEDING_HINT
  WHITE_SPACE
  COMMANDS
  COMMAND_PREFIX_TOKENS
  NUMERIC_LITERALS
  dialect
  use_rs_tokenizer
  reset
  tokenize
  tokenize_rs
  size
  sql
  tokens

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

     752    class Parser(parser.Parser):
     753        PREFIXED_PIVOT_COLUMNS = True
     754        LOG_DEFAULTS_TO_LN = True
     755        SUPPORTS_IMPLICIT_UNNEST = True
     756        JOINS_HAVE_EQUAL_PRECEDENCE = True
     757
     758        # BigQuery does not allow ASC/DESC to be used as an identifier
     759        ID_VAR_TOKENS = parser.Parser.ID_VAR_TOKENS - {TokenType.ASC, TokenType.DESC}
     760        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {TokenType.ASC, TokenType.DESC}
     761        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {TokenType.ASC, TokenType.DESC}
     762        COMMENT_TABLE_ALIAS_TOKENS = parser.Parser.COMMENT_TABLE_ALIAS_TOKENS - {
     763            TokenType.ASC,
     764            TokenType.DESC,
     765        }
     766        UPDATE_ALIAS_TOKENS = parser.Parser.UPDATE_ALIAS_TOKENS - {TokenType.ASC, TokenType.DESC}
     767
     768        FUNCTIONS = {
     769            **parser.Parser.FUNCTIONS,
     770            "APPROX_TOP_COUNT": exp.ApproxTopK.from_arg_list,
     771            "BIT_AND": exp.BitwiseAndAgg.from_arg_list,
     772            "BIT_OR": exp.BitwiseOrAgg.from_arg_list,
     773            "BIT_XOR": exp.BitwiseXorAgg.from_arg_list,
     774            "BIT_COUNT": exp.BitwiseCountAgg.from_arg_list,
     775            "BOOL": exp.JSONBool.from_arg_list,
     776            "CONTAINS_SUBSTR": _build_contains_substring,
     777            "DATE": _build_date,
     778            "DATE_ADD": build_date_delta_with_interval(exp.DateAdd),
     779            "DATE_SUB": build_date_delta_with_interval(exp.DateSub),
     780            "DATE_TRUNC": lambda args: exp.DateTrunc(
     781                unit=seq_get(args, 1),
     782                this=seq_get(args, 0),
     783                zone=seq_get(args, 2),
     784            ),
     785            "DATETIME": _build_datetime,
     786            "DATETIME_ADD": build_date_delta_with_interval(exp.DatetimeAdd),
     787            "DATETIME_SUB": build_date_delta_with_interval(exp.DatetimeSub),
     788            "DIV": binary_from_function(exp.IntDiv),
     789            "EDIT_DISTANCE": _build_levenshtein,
     790            "FORMAT_DATE": _build_format_time(exp.TsOrDsToDate),
     791            "GENERATE_ARRAY": exp.GenerateSeries.from_arg_list,
     792            "JSON_EXTRACT_SCALAR": _build_extract_json_with_default_path(exp.JSONExtractScalar),
     793            "JSON_EXTRACT_ARRAY": _build_extract_json_with_default_path(exp.JSONExtractArray),
     794            "JSON_EXTRACT_STRING_ARRAY": _build_extract_json_with_default_path(exp.JSONValueArray),
     795            "JSON_KEYS": exp.JSONKeysAtDepth.from_arg_list,
     796            "JSON_QUERY": parser.build_extract_json_with_path(exp.JSONExtract),
     797            "JSON_QUERY_ARRAY": _build_extract_json_with_default_path(exp.JSONExtractArray),
     798            "JSON_STRIP_NULLS": _build_json_strip_nulls,
     799            "JSON_VALUE": _build_extract_json_with_default_path(exp.JSONExtractScalar),
     800            "JSON_VALUE_ARRAY": _build_extract_json_with_default_path(exp.JSONValueArray),
     801            "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
     802            "MD5": exp.MD5Digest.from_arg_list,
     803            "NORMALIZE_AND_CASEFOLD": lambda args: exp.Normalize(
     804                this=seq_get(args, 0), form=seq_get(args, 1), is_casefold=True
     805            ),
     806            "OCTET_LENGTH": exp.ByteLength.from_arg_list,
     807            "TO_HEX": _build_to_hex,
     808            "PARSE_DATE": lambda args: build_formatted_time(exp.StrToDate, "bigquery")(
     809                [seq_get(args, 1), seq_get(args, 0)]
     810            ),
     811            "PARSE_TIME": lambda args: build_formatted_time(exp.ParseTime, "bigquery")(
     812                [seq_get(args, 1), seq_get(args, 0)]
     813            ),
     814            "PARSE_TIMESTAMP": _build_parse_timestamp,
     815            "PARSE_DATETIME": lambda args: build_formatted_time(exp.ParseDatetime, "bigquery")(
     816                [seq_get(args, 1), seq_get(args, 0)]
     817            ),
     818            "REGEXP_CONTAINS": exp.RegexpLike.from_arg_list,
     819            "REGEXP_EXTRACT": _build_regexp_extract(exp.RegexpExtract),
     820            "REGEXP_SUBSTR": _build_regexp_extract(exp.RegexpExtract),
     821            "REGEXP_EXTRACT_ALL": _build_regexp_extract(
     822                exp.RegexpExtractAll, default_group=exp.Literal.number(0)
     823            ),
     824            "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
     825            "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
     826            "SPLIT": lambda args: exp.Split(
     827                # https://cloud.google.com/bigquery/docs/reference/standard-sql/string_functions#split
     828                this=seq_get(args, 0),
     829                expression=seq_get(args, 1) or exp.Literal.string(","),
     830            ),
     831            "STRPOS": exp.StrPosition.from_arg_list,
     832            "TIME": _build_time,
     833            "TIME_ADD": build_date_delta_with_interval(exp.TimeAdd),
     834            "TIME_SUB": build_date_delta_with_interval(exp.TimeSub),
     835            "TIMESTAMP": _build_timestamp,
     836            "TIMESTAMP_ADD": build_date_delta_with_interval(exp.TimestampAdd),
     837            "TIMESTAMP_SUB": build_date_delta_with_interval(exp.TimestampSub),
     838            "TIMESTAMP_MICROS": lambda args: exp.UnixToTime(
     839                this=seq_get(args, 0), scale=exp.UnixToTime.MICROS
     840            ),
     841            "TIMESTAMP_MILLIS": lambda args: exp.UnixToTime(
     842                this=seq_get(args, 0), scale=exp.UnixToTime.MILLIS
     843            ),
     844            "TIMESTAMP_SECONDS": lambda args: exp.UnixToTime(this=seq_get(args, 0)),
     845            "TO_JSON": lambda args: exp.JSONFormat(
     846                this=seq_get(args, 0), options=seq_get(args, 1), to_json=True
     847            ),
     848            "TO_JSON_STRING": exp.JSONFormat.from_arg_list,
     849            "FORMAT_DATETIME": _build_format_time(exp.TsOrDsToDatetime),
     850            "FORMAT_TIMESTAMP": _build_format_time(exp.TsOrDsToTimestamp),
     851            "FORMAT_TIME": _build_format_time(exp.TsOrDsToTime),
     852            "FROM_HEX": exp.Unhex.from_arg_list,
     853            "WEEK": lambda args: exp.WeekStart(this=exp.var(seq_get(args, 0))),
     854        }
     855
     856        FUNCTION_PARSERS = {
     857            **parser.Parser.FUNCTION_PARSERS,
     858            "ARRAY": lambda self: self.expression(exp.Array, expressions=[self._parse_statement()]),
     859            "JSON_ARRAY": lambda self: self.expression(
     860                exp.JSONArray, expressions=self._parse_csv(self._parse_bitwise)
     861            ),
     862            "MAKE_INTERVAL": lambda self: self._parse_make_interval(),
     863            "PREDICT": lambda self: self._parse_ml(exp.Predict),
     864            "TRANSLATE": lambda self: self._parse_translate(),
     865            "FEATURES_AT_TIME": lambda self: self._parse_features_at_time(),
     866            "GENERATE_EMBEDDING": lambda self: self._parse_ml(exp.GenerateEmbedding),
     867            "GENERATE_TEXT_EMBEDDING": lambda self: self._parse_ml(
     868                exp.GenerateEmbedding, is_text=True
     869            ),
     870            "VECTOR_SEARCH": lambda self: self._parse_vector_search(),
     871            "FORECAST": lambda self: self._parse_ml(exp.MLForecast),
     872        }
     873        FUNCTION_PARSERS.pop("TRIM")
     874
     875        NO_PAREN_FUNCTIONS = {
     876            **parser.Parser.NO_PAREN_FUNCTIONS,
     877            TokenType.CURRENT_DATETIME: exp.CurrentDatetime,
     878        }
     879
     880        NESTED_TYPE_TOKENS = {
     881            *parser.Parser.NESTED_TYPE_TOKENS,
     882            TokenType.TABLE,
     883        }
     884
     885        PROPERTY_PARSERS = {
     886            **parser.Parser.PROPERTY_PARSERS,
     887            "NOT DETERMINISTIC": lambda self: self.expression(
     888                exp.StabilityProperty, this=exp.Literal.string("VOLATILE")
     889            ),
     890            "OPTIONS": lambda self: self._parse_with_property(),
     891        }
     892
     893        CONSTRAINT_PARSERS = {
     894            **parser.Parser.CONSTRAINT_PARSERS,
     895            "OPTIONS": lambda self: exp.Properties(expressions=self._parse_with_property()),
     896        }
     897
     898        RANGE_PARSERS = parser.Parser.RANGE_PARSERS.copy()
     899        RANGE_PARSERS.pop(TokenType.OVERLAPS)
     900
     901        DASHED_TABLE_PART_FOLLOW_TOKENS = {TokenType.DOT, TokenType.L_PAREN, TokenType.R_PAREN}
     902
     903        STATEMENT_PARSERS = {
     904            **parser.Parser.STATEMENT_PARSERS,
     905            TokenType.ELSE: lambda self: self._parse_as_command(self._prev),
     906            TokenType.END: lambda self: self._parse_as_command(self._prev),
     907            TokenType.FOR: lambda self: self._parse_for_in(),
     908            TokenType.EXPORT: lambda self: self._parse_export_data(),
     909            TokenType.DECLARE: lambda self: self._parse_declare(),
     910        }
     911
     912        BRACKET_OFFSETS = {
     913            "OFFSET": (0, False),
     914            "ORDINAL": (1, False),
     915            "SAFE_OFFSET": (0, True),
     916            "SAFE_ORDINAL": (1, True),
     917        }
     918
     919        def _parse_for_in(self) -> t.Union[exp.ForIn, exp.Command]:
     920            index = self._index
     921            this = self._parse_range()
     922            self._match_text_seq("DO")
     923            if self._match(TokenType.COMMAND):
     924                self._retreat(index)
     925                return self._parse_as_command(self._prev)
     926            return self.expression(exp.ForIn, this=this, expression=self._parse_statement())
     927
     928        def _parse_table_part(self, schema: bool = False) -> t.Optional[exp.Expression]:
     929            this = super()._parse_table_part(schema=schema) or self._parse_number()
     930
     931            # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#table_names
     932            if isinstance(this, exp.Identifier):
     933                table_name = this.name
     934                while self._match(TokenType.DASH, advance=False) and self._next:
     935                    start = self._curr
     936                    while self._is_connected() and not self._match_set(
     937                        self.DASHED_TABLE_PART_FOLLOW_TOKENS, advance=False
     938                    ):
     939                        self._advance()
     940
     941                    if start == self._curr:
     942                        break
     943
     944                    table_name += self._find_sql(start, self._prev)
     945
     946                this = exp.Identifier(
     947                    this=table_name, quoted=this.args.get("quoted")
     948                ).update_positions(this)
     949            elif isinstance(this, exp.Literal):
     950                table_name = this.name
     951
     952                if self._is_connected() and self._parse_var(any_token=True):
     953                    table_name += self._prev.text
     954
     955                this = exp.Identifier(this=table_name, quoted=True).update_positions(this)
     956
     957            return this
     958
     959        def _parse_table_parts(
     960            self, schema: bool = False, is_db_reference: bool = False, wildcard: bool = False
     961        ) -> exp.Table:
     962            table = super()._parse_table_parts(
     963                schema=schema, is_db_reference=is_db_reference, wildcard=True
     964            )
     965
     966            # proj-1.db.tbl -- `1.` is tokenized as a float so we need to unravel it here
     967            if not table.catalog:
     968                if table.db:
     969                    previous_db = table.args["db"]
     970                    parts = table.db.split(".")
     971                    if len(parts) == 2 and not table.args["db"].quoted:
     972                        table.set(
     973                            "catalog", exp.Identifier(this=parts[0]).update_positions(previous_db)
     974                        )
     975                        table.set("db", exp.Identifier(this=parts[1]).update_positions(previous_db))
     976                else:
     977                    previous_this = table.this
     978                    parts = table.name.split(".")
     979                    if len(parts) == 2 and not table.this.quoted:
     980                        table.set(
     981                            "db", exp.Identifier(this=parts[0]).update_positions(previous_this)
     982                        )
     983                        table.set(
     984                            "this", exp.Identifier(this=parts[1]).update_positions(previous_this)
     985                        )
     986
     987            if isinstance(table.this, exp.Identifier) and any("." in p.name for p in table.parts):
     988                alias = table.this
     989                catalog, db, this, *rest = (
     990                    exp.to_identifier(p, quoted=True)
     991                    for p in split_num_words(".".join(p.name for p in table.parts), ".", 3)
     992                )
     993
     994                for part in (catalog, db, this):
     995                    if part:
     996                        part.update_positions(table.this)
     997
     998                if rest and this:
     999                    this = exp.Dot.build([this, *rest])  # type: ignore
    1000
    1001                table = exp.Table(
    1002                    this=this, db=db, catalog=catalog, pivots=table.args.get("pivots")
    1003                )
    1004                table.meta["quoted_table"] = True
    1005            else:
    1006                alias = None
    1007
    1008            # The `INFORMATION_SCHEMA` views in BigQuery need to be qualified by a region or
    1009            # dataset, so if the project identifier is omitted we need to fix the ast so that
    1010            # the `INFORMATION_SCHEMA.X` bit is represented as a single (quoted) Identifier.
    1011            # Otherwise, we wouldn't correctly qualify a `Table` node that references these
    1012            # views, because it would seem like the "catalog" part is set, when it'd actually
    1013            # be the region/dataset. Merging the two identifiers into a single one is done to
    1014            # avoid producing a 4-part Table reference, which would cause issues in the schema
    1015            # module, when there are 3-part table names mixed with information schema views.
    1016            #
    1017            # See: https://cloud.google.com/bigquery/docs/information-schema-intro#syntax
    1018            table_parts = table.parts
    1019            if len(table_parts) > 1 and table_parts[-2].name.upper() == "INFORMATION_SCHEMA":
    1020                # We need to alias the table here to avoid breaking existing qualified columns.
    1021                # This is expected to be safe, because if there's an actual alias coming up in
    1022                # the token stream, it will overwrite this one. If there isn't one, we are only
    1023                # exposing the name that can be used to reference the view explicitly (a no-op).
    1024                exp.alias_(
    1025                    table,
    1026                    t.cast(exp.Identifier, alias or table_parts[-1]),
    1027                    table=True,
    1028                    copy=False,
    1029                )
    1030
    1031                info_schema_view = f"{table_parts[-2].name}.{table_parts[-1].name}"
    1032                new_this = exp.Identifier(this=info_schema_view, quoted=True).update_positions(
    1033                    line=table_parts[-2].meta.get("line"),
    1034                    col=table_parts[-1].meta.get("col"),
    1035                    start=table_parts[-2].meta.get("start"),
    1036                    end=table_parts[-1].meta.get("end"),
    1037                )
    1038                table.set("this", new_this)
    1039                table.set("db", seq_get(table_parts, -3))
    1040                table.set("catalog", seq_get(table_parts, -4))
    1041
    1042            return table
    1043
    1044        def _parse_column(self) -> t.Optional[exp.Expression]:
    1045            column = super()._parse_column()
    1046            if isinstance(column, exp.Column):
    1047                parts = column.parts
    1048                if any("." in p.name for p in parts):
    1049                    catalog, db, table, this, *rest = (
    1050                        exp.to_identifier(p, quoted=True)
    1051                        for p in split_num_words(".".join(p.name for p in parts), ".", 4)
    1052                    )
    1053
    1054                    if rest and this:
    1055                        this = exp.Dot.build([this, *rest])  # type: ignore
    1056
    1057                    column = exp.Column(this=this, table=table, db=db, catalog=catalog)
    1058                    column.meta["quoted_column"] = True
    1059
    1060            return column
    1061
    1062        @t.overload
    1063        def _parse_json_object(self, agg: Lit[False]) -> exp.JSONObject: ...
    1064
    1065        @t.overload
    1066        def _parse_json_object(self, agg: Lit[True]) -> exp.JSONObjectAgg: ...
    1067
    1068        def _parse_json_object(self, agg=False):
    1069            json_object = super()._parse_json_object()
    1070            array_kv_pair = seq_get(json_object.expressions, 0)
    1071
    1072            # Converts BQ's "signature 2" of JSON_OBJECT into SQLGlot's canonical representation
    1073            # https://cloud.google.com/bigquery/docs/reference/standard-sql/json_functions#json_object_signature2
    1074            if (
    1075                array_kv_pair
    1076                and isinstance(array_kv_pair.this, exp.Array)
    1077                and isinstance(array_kv_pair.expression, exp.Array)
    1078            ):
    1079                keys = array_kv_pair.this.expressions
    1080                values = array_kv_pair.expression.expressions
    1081
    1082                json_object.set(
    1083                    "expressions",
    1084                    [exp.JSONKeyValue(this=k, expression=v) for k, v in zip(keys, values)],
    1085                )
    1086
    1087            return json_object
    1088
    1089        def _parse_bracket(
    1090            self, this: t.Optional[exp.Expression] = None
    1091        ) -> t.Optional[exp.Expression]:
    1092            bracket = super()._parse_bracket(this)
    1093
    1094            if this is bracket:
    1095                return bracket
    1096
    1097            if isinstance(bracket, exp.Bracket):
    1098                for expression in bracket.expressions:
    1099                    name = expression.name.upper()
    1100
    1101                    if name not in self.BRACKET_OFFSETS:
    1102                        break
    1103
    1104                    offset, safe = self.BRACKET_OFFSETS[name]
    1105                    bracket.set("offset", offset)
    1106                    bracket.set("safe", safe)
    1107                    expression.replace(expression.expressions[0])
    1108
    1109            return bracket
    1110
    1111        def _parse_unnest(self, with_alias: bool = True) -> t.Optional[exp.Unnest]:
    1112            unnest = super()._parse_unnest(with_alias=with_alias)
    1113
    1114            if not unnest:
    1115                return None
    1116
    1117            unnest_expr = seq_get(unnest.expressions, 0)
    1118            if unnest_expr:
    1119                from sqlglot.optimizer.annotate_types import annotate_types
    1120
    1121                unnest_expr = annotate_types(unnest_expr, dialect=self.dialect)
    1122
    1123                # Unnesting a nested array (i.e array of structs) explodes the top-level struct fields,
    1124                # in contrast to other dialects such as DuckDB which flattens only the array by default
    1125                if unnest_expr.is_type(exp.DataType.Type.ARRAY) and any(
    1126                    array_elem.is_type(exp.DataType.Type.STRUCT)
    1127                    for array_elem in unnest_expr._type.expressions
    1128                ):
    1129                    unnest.set("explode_array", True)
    1130
    1131            return unnest
    1132
    1133        def _parse_make_interval(self) -> exp.MakeInterval:
    1134            expr = exp.MakeInterval()
    1135
    1136            for arg_key in expr.arg_types:
    1137                value = self._parse_lambda()
    1138
    1139                if not value:
    1140                    break
    1141
    1142                # Non-named arguments are filled sequentially, (optionally) followed by named arguments
    1143                # that can appear in any order e.g MAKE_INTERVAL(1, minute => 5, day => 2)
    1144                if isinstance(value, exp.Kwarg):
    1145                    arg_key = value.this.name
    1146
    1147                expr.set(arg_key, value)
    1148
    1149                self._match(TokenType.COMMA)
    1150
    1151            return expr
    1152
    1153        def _parse_ml(self, expr_type: t.Type[E], **kwargs) -> E:
    1154            self._match_text_seq("MODEL")
    1155            this = self._parse_table()
    1156
    1157            self._match(TokenType.COMMA)
    1158            self._match_text_seq("TABLE")
    1159
    1160            # Certain functions like ML.FORECAST require a STRUCT argument but not a TABLE/SELECT one
    1161            expression = (
    1162                self._parse_table() if not self._match(TokenType.STRUCT, advance=False) else None
    1163            )
    1164
    1165            self._match(TokenType.COMMA)
    1166
    1167            return self.expression(
    1168                expr_type,
    1169                this=this,
    1170                expression=expression,
    1171                params_struct=self._parse_bitwise(),
    1172                **kwargs,
    1173            )
    1174
    1175        def _parse_translate(self) -> exp.Translate | exp.MLTranslate:
    1176            # Check if this is ML.TRANSLATE by looking at previous tokens
    1177            token = seq_get(self._tokens, self._index - 4)
    1178            if token and token.text.upper() == "ML":
    1179                return self._parse_ml(exp.MLTranslate)
    1180
    1181            return exp.Translate.from_arg_list(self._parse_function_args())
    1182
    1183        def _parse_features_at_time(self) -> exp.FeaturesAtTime:
    1184            self._match(TokenType.TABLE)
    1185            this = self._parse_table()
    1186
    1187            expr = self.expression(exp.FeaturesAtTime, this=this)
    1188
    1189            while self._match(TokenType.COMMA):
    1190                arg = self._parse_lambda()
    1191
    1192                # Get the LHS of the Kwarg and set the arg to that value, e.g
    1193                # "num_rows => 1" sets the expr's `num_rows` arg
    1194                if arg:
    1195                    expr.set(arg.this.name, arg)
    1196
    1197            return expr
    1198
    1199        def _parse_vector_search(self) -> exp.VectorSearch:
    1200            self._match(TokenType.TABLE)
    1201            base_table = self._parse_table()
    1202
    1203            self._match(TokenType.COMMA)
    1204
    1205            column_to_search = self._parse_bitwise()
    1206            self._match(TokenType.COMMA)
    1207
    1208            self._match(TokenType.TABLE)
    1209            query_table = self._parse_table()
    1210
    1211            expr = self.expression(
    1212                exp.VectorSearch,
    1213                this=base_table,
    1214                column_to_search=column_to_search,
    1215                query_table=query_table,
    1216            )
    1217
    1218            while self._match(TokenType.COMMA):
    1219                # query_column_to_search can be named argument or positional
    1220                if self._match(TokenType.STRING, advance=False):
    1221                    query_column = self._parse_string()
    1222                    expr.set("query_column_to_search", query_column)
    1223                else:
    1224                    arg = self._parse_lambda()
    1225                    if arg:
    1226                        expr.set(arg.this.name, arg)
    1227
    1228            return expr
    1229
    1230        def _parse_export_data(self) -> exp.Export:
    1231            self._match_text_seq("DATA")
    1232
    1233            return self.expression(
    1234                exp.Export,
    1235                connection=self._match_text_seq("WITH", "CONNECTION") and self._parse_table_parts(),
    1236                options=self._parse_properties(),
    1237                this=self._match_text_seq("AS") and self._parse_select(),
    1238            )

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

PREFIXED_PIVOT_COLUMNS = True
LOG_DEFAULTS_TO_LN = True
SUPPORTS_IMPLICIT_UNNEST = True
JOINS_HAVE_EQUAL_PRECEDENCE = True
ID_VAR_TOKENS = {<TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, <TokenType.INT: 'INT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.RANGE: 'RANGE'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.POLYGON: 'POLYGON'>, <TokenType.CASE: 'CASE'>, <TokenType.STAGE: 'STAGE'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.APPLY: 'APPLY'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.MULTIPOLYGON: 'MULTIPOLYGON'>, <TokenType.INT256: 'INT256'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.LOAD: 'LOAD'>, <TokenType.ROWS: 'ROWS'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.DELETE: 'DELETE'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.UINT: 'UINT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.INT128: 'INT128'>, <TokenType.FALSE: 'FALSE'>, <TokenType.END: 'END'>, <TokenType.UINT256: 'UINT256'>, <TokenType.EXPORT: 'EXPORT'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.NAME: 'NAME'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.DATE32: 'DATE32'>, <TokenType.TABLE: 'TABLE'>, <TokenType.DATE: 'DATE'>, <TokenType.DECIMAL256: 'DECIMAL256'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.SOURCE: 'SOURCE'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.SESSION: 'SESSION'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.LOCK: 'LOCK'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.ANY: 'ANY'>, <TokenType.KILL: 'KILL'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.ANTI: 'ANTI'>, <TokenType.DECIMAL128: 'DECIMAL128'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.SINK: 'SINK'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.TRUE: 'TRUE'>, <TokenType.NULL: 'NULL'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.LINESTRING: 'LINESTRING'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.ENUM: 'ENUM'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.IS: 'IS'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.LEFT: 'LEFT'>, <TokenType.SMALLDATETIME: 'SMALLDATETIME'>, <TokenType.VAR: 'VAR'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.SEMI: 'SEMI'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.BLOB: 'BLOB'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.VOID: 'VOID'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.GEOGRAPHYPOINT: 'GEOGRAPHYPOINT'>, <TokenType.NEXT: 'NEXT'>, <TokenType.SEMANTIC_VIEW: 'SEMANTIC_VIEW'>, <TokenType.FILTER: 'FILTER'>, <TokenType.ASOF: 'ASOF'>, <TokenType.DIV: 'DIV'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.ROW: 'ROW'>, <TokenType.TEXT: 'TEXT'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.IPV4: 'IPV4'>, <TokenType.XML: 'XML'>, <TokenType.JSON: 'JSON'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.CUBE: 'CUBE'>, <TokenType.BINARY: 'BINARY'>, <TokenType.SOME: 'SOME'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.MERGE: 'MERGE'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.TIME: 'TIME'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.UINT128: 'UINT128'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.DECIMAL32: 'DECIMAL32'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.RENAME: 'RENAME'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.LIMIT: 'LIMIT'>, <TokenType.VIEW: 'VIEW'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.BIT: 'BIT'>, <TokenType.GET: 'GET'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.CACHE: 'CACHE'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.NESTED: 'NESTED'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.USE: 'USE'>, <TokenType.UDOUBLE: 'UDOUBLE'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.TAG: 'TAG'>, <TokenType.NOTHING: 'NOTHING'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.FILE_FORMAT: 'FILE_FORMAT'>, <TokenType.INET: 'INET'>, <TokenType.NAMESPACE: 'NAMESPACE'>, <TokenType.SUPER: 'SUPER'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.COPY: 'COPY'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.LIST: 'LIST'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.MULTILINESTRING: 'MULTILINESTRING'>, <TokenType.YEAR: 'YEAR'>, <TokenType.ALL: 'ALL'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.FULL: 'FULL'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.INDEX: 'INDEX'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DECIMAL64: 'DECIMAL64'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.KEEP: 'KEEP'>, <TokenType.PUT: 'PUT'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.MAP: 'MAP'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.MONEY: 'MONEY'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.CURRENT_SCHEMA: 'CURRENT_SCHEMA'>, <TokenType.JSONB: 'JSONB'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.ATTACH: 'ATTACH'>, <TokenType.SHOW: 'SHOW'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.TOP: 'TOP'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.DATETIME2: 'DATETIME2'>, <TokenType.POINT: 'POINT'>, <TokenType.IPV6: 'IPV6'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.FIRST: 'FIRST'>, <TokenType.FINAL: 'FINAL'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.DYNAMIC: 'DYNAMIC'>, <TokenType.DETACH: 'DETACH'>, <TokenType.SET: 'SET'>, <TokenType.RING: 'RING'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.CHAR: 'CHAR'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>}
ALIAS_TOKENS = {<TokenType.INT: 'INT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.RANGE: 'RANGE'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.POLYGON: 'POLYGON'>, <TokenType.CASE: 'CASE'>, <TokenType.STAGE: 'STAGE'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.APPLY: 'APPLY'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.MULTIPOLYGON: 'MULTIPOLYGON'>, <TokenType.INT256: 'INT256'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.LOAD: 'LOAD'>, <TokenType.ROWS: 'ROWS'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.DELETE: 'DELETE'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.UINT: 'UINT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.INT128: 'INT128'>, <TokenType.FALSE: 'FALSE'>, <TokenType.END: 'END'>, <TokenType.UINT256: 'UINT256'>, <TokenType.EXPORT: 'EXPORT'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.NAME: 'NAME'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.DATE32: 'DATE32'>, <TokenType.TABLE: 'TABLE'>, <TokenType.DATE: 'DATE'>, <TokenType.DECIMAL256: 'DECIMAL256'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.SOURCE: 'SOURCE'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.SESSION: 'SESSION'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.LOCK: 'LOCK'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.ANY: 'ANY'>, <TokenType.KILL: 'KILL'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.ANTI: 'ANTI'>, <TokenType.DECIMAL128: 'DECIMAL128'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.SINK: 'SINK'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.TRUE: 'TRUE'>, <TokenType.NULL: 'NULL'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.LINESTRING: 'LINESTRING'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.ENUM: 'ENUM'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.IS: 'IS'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.LEFT: 'LEFT'>, <TokenType.SMALLDATETIME: 'SMALLDATETIME'>, <TokenType.VAR: 'VAR'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.SEMI: 'SEMI'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.BLOB: 'BLOB'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.VOID: 'VOID'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.GEOGRAPHYPOINT: 'GEOGRAPHYPOINT'>, <TokenType.NEXT: 'NEXT'>, <TokenType.SEMANTIC_VIEW: 'SEMANTIC_VIEW'>, <TokenType.FILTER: 'FILTER'>, <TokenType.ASOF: 'ASOF'>, <TokenType.DIV: 'DIV'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.ROW: 'ROW'>, <TokenType.TEXT: 'TEXT'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.IPV4: 'IPV4'>, <TokenType.XML: 'XML'>, <TokenType.JSON: 'JSON'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.CUBE: 'CUBE'>, <TokenType.BINARY: 'BINARY'>, <TokenType.SOME: 'SOME'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.MERGE: 'MERGE'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.TIME: 'TIME'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.UINT128: 'UINT128'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.DECIMAL32: 'DECIMAL32'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.RENAME: 'RENAME'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.LIMIT: 'LIMIT'>, <TokenType.VIEW: 'VIEW'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.BIT: 'BIT'>, <TokenType.GET: 'GET'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.CACHE: 'CACHE'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.NESTED: 'NESTED'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.USE: 'USE'>, <TokenType.UDOUBLE: 'UDOUBLE'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.TAG: 'TAG'>, <TokenType.NOTHING: 'NOTHING'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.FILE_FORMAT: 'FILE_FORMAT'>, <TokenType.INET: 'INET'>, <TokenType.NAMESPACE: 'NAMESPACE'>, <TokenType.SUPER: 'SUPER'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.COPY: 'COPY'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.LIST: 'LIST'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.MULTILINESTRING: 'MULTILINESTRING'>, <TokenType.YEAR: 'YEAR'>, <TokenType.ALL: 'ALL'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.FULL: 'FULL'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.INDEX: 'INDEX'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DECIMAL64: 'DECIMAL64'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.KEEP: 'KEEP'>, <TokenType.PUT: 'PUT'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.MAP: 'MAP'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.MONEY: 'MONEY'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.CURRENT_SCHEMA: 'CURRENT_SCHEMA'>, <TokenType.JSONB: 'JSONB'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.ATTACH: 'ATTACH'>, <TokenType.SHOW: 'SHOW'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.TOP: 'TOP'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.DATETIME2: 'DATETIME2'>, <TokenType.POINT: 'POINT'>, <TokenType.IPV6: 'IPV6'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.FIRST: 'FIRST'>, <TokenType.FINAL: 'FINAL'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.DYNAMIC: 'DYNAMIC'>, <TokenType.DETACH: 'DETACH'>, <TokenType.SET: 'SET'>, <TokenType.RING: 'RING'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.CHAR: 'CHAR'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>}
TABLE_ALIAS_TOKENS = {<TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, <TokenType.INT: 'INT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.RANGE: 'RANGE'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.POLYGON: 'POLYGON'>, <TokenType.CASE: 'CASE'>, <TokenType.STAGE: 'STAGE'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.APPLY: 'APPLY'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.MULTIPOLYGON: 'MULTIPOLYGON'>, <TokenType.INT256: 'INT256'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.LOAD: 'LOAD'>, <TokenType.ROWS: 'ROWS'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.DELETE: 'DELETE'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.UINT: 'UINT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.INT128: 'INT128'>, <TokenType.FALSE: 'FALSE'>, <TokenType.END: 'END'>, <TokenType.UINT256: 'UINT256'>, <TokenType.EXPORT: 'EXPORT'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.NAME: 'NAME'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.DATE32: 'DATE32'>, <TokenType.TABLE: 'TABLE'>, <TokenType.DATE: 'DATE'>, <TokenType.DECIMAL256: 'DECIMAL256'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.SOURCE: 'SOURCE'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.SESSION: 'SESSION'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.ANY: 'ANY'>, <TokenType.KILL: 'KILL'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.ANTI: 'ANTI'>, <TokenType.DECIMAL128: 'DECIMAL128'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.SINK: 'SINK'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.TRUE: 'TRUE'>, <TokenType.NULL: 'NULL'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.LINESTRING: 'LINESTRING'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.ENUM: 'ENUM'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.IS: 'IS'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.SMALLDATETIME: 'SMALLDATETIME'>, <TokenType.VAR: 'VAR'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.SEMI: 'SEMI'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.BLOB: 'BLOB'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.VOID: 'VOID'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.GEOGRAPHYPOINT: 'GEOGRAPHYPOINT'>, <TokenType.NEXT: 'NEXT'>, <TokenType.SEMANTIC_VIEW: 'SEMANTIC_VIEW'>, <TokenType.FILTER: 'FILTER'>, <TokenType.DIV: 'DIV'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.ROW: 'ROW'>, <TokenType.TEXT: 'TEXT'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.IPV4: 'IPV4'>, <TokenType.XML: 'XML'>, <TokenType.JSON: 'JSON'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.CUBE: 'CUBE'>, <TokenType.BINARY: 'BINARY'>, <TokenType.SOME: 'SOME'>, <TokenType.MERGE: 'MERGE'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.TIME: 'TIME'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.UINT128: 'UINT128'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.DECIMAL32: 'DECIMAL32'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.RENAME: 'RENAME'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.LIMIT: 'LIMIT'>, <TokenType.VIEW: 'VIEW'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.BIT: 'BIT'>, <TokenType.GET: 'GET'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.CACHE: 'CACHE'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.NESTED: 'NESTED'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.USE: 'USE'>, <TokenType.UDOUBLE: 'UDOUBLE'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.TAG: 'TAG'>, <TokenType.NOTHING: 'NOTHING'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.FILE_FORMAT: 'FILE_FORMAT'>, <TokenType.INET: 'INET'>, <TokenType.NAMESPACE: 'NAMESPACE'>, <TokenType.SUPER: 'SUPER'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.COPY: 'COPY'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.LIST: 'LIST'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.MULTILINESTRING: 'MULTILINESTRING'>, <TokenType.YEAR: 'YEAR'>, <TokenType.ALL: 'ALL'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.INDEX: 'INDEX'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DECIMAL64: 'DECIMAL64'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.KEEP: 'KEEP'>, <TokenType.PUT: 'PUT'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.MAP: 'MAP'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.MONEY: 'MONEY'>, <TokenType.CURRENT_SCHEMA: 'CURRENT_SCHEMA'>, <TokenType.JSONB: 'JSONB'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.ATTACH: 'ATTACH'>, <TokenType.SHOW: 'SHOW'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.TOP: 'TOP'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.DATETIME2: 'DATETIME2'>, <TokenType.POINT: 'POINT'>, <TokenType.IPV6: 'IPV6'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.FIRST: 'FIRST'>, <TokenType.FINAL: 'FINAL'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.DYNAMIC: 'DYNAMIC'>, <TokenType.DETACH: 'DETACH'>, <TokenType.SET: 'SET'>, <TokenType.RING: 'RING'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.CHAR: 'CHAR'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>}
COMMENT_TABLE_ALIAS_TOKENS = {<TokenType.INT: 'INT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.RANGE: 'RANGE'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.POLYGON: 'POLYGON'>, <TokenType.CASE: 'CASE'>, <TokenType.STAGE: 'STAGE'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.APPLY: 'APPLY'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.MULTIPOLYGON: 'MULTIPOLYGON'>, <TokenType.INT256: 'INT256'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.LOAD: 'LOAD'>, <TokenType.ROWS: 'ROWS'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.DELETE: 'DELETE'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.UINT: 'UINT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.INT128: 'INT128'>, <TokenType.FALSE: 'FALSE'>, <TokenType.END: 'END'>, <TokenType.UINT256: 'UINT256'>, <TokenType.EXPORT: 'EXPORT'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.NAME: 'NAME'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.DATE32: 'DATE32'>, <TokenType.TABLE: 'TABLE'>, <TokenType.DATE: 'DATE'>, <TokenType.DECIMAL256: 'DECIMAL256'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.SOURCE: 'SOURCE'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.SESSION: 'SESSION'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.ANY: 'ANY'>, <TokenType.KILL: 'KILL'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.DECIMAL128: 'DECIMAL128'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.SINK: 'SINK'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.TRUE: 'TRUE'>, <TokenType.NULL: 'NULL'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.LINESTRING: 'LINESTRING'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.ENUM: 'ENUM'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.SMALLDATETIME: 'SMALLDATETIME'>, <TokenType.VAR: 'VAR'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.BLOB: 'BLOB'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.VOID: 'VOID'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.GEOGRAPHYPOINT: 'GEOGRAPHYPOINT'>, <TokenType.NEXT: 'NEXT'>, <TokenType.SEMANTIC_VIEW: 'SEMANTIC_VIEW'>, <TokenType.FILTER: 'FILTER'>, <TokenType.DIV: 'DIV'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.ROW: 'ROW'>, <TokenType.TEXT: 'TEXT'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.IPV4: 'IPV4'>, <TokenType.XML: 'XML'>, <TokenType.JSON: 'JSON'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.CUBE: 'CUBE'>, <TokenType.BINARY: 'BINARY'>, <TokenType.SOME: 'SOME'>, <TokenType.MERGE: 'MERGE'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.TIME: 'TIME'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.UINT128: 'UINT128'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.DECIMAL32: 'DECIMAL32'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.RENAME: 'RENAME'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.LIMIT: 'LIMIT'>, <TokenType.VIEW: 'VIEW'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.BIT: 'BIT'>, <TokenType.GET: 'GET'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.CACHE: 'CACHE'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.NESTED: 'NESTED'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.USE: 'USE'>, <TokenType.UDOUBLE: 'UDOUBLE'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.TAG: 'TAG'>, <TokenType.NOTHING: 'NOTHING'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.FILE_FORMAT: 'FILE_FORMAT'>, <TokenType.INET: 'INET'>, <TokenType.NAMESPACE: 'NAMESPACE'>, <TokenType.SUPER: 'SUPER'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.COPY: 'COPY'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.LIST: 'LIST'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.MULTILINESTRING: 'MULTILINESTRING'>, <TokenType.YEAR: 'YEAR'>, <TokenType.ALL: 'ALL'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.INDEX: 'INDEX'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DECIMAL64: 'DECIMAL64'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.KEEP: 'KEEP'>, <TokenType.PUT: 'PUT'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.MAP: 'MAP'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.MONEY: 'MONEY'>, <TokenType.CURRENT_SCHEMA: 'CURRENT_SCHEMA'>, <TokenType.JSONB: 'JSONB'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.ATTACH: 'ATTACH'>, <TokenType.SHOW: 'SHOW'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.TOP: 'TOP'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.DATETIME2: 'DATETIME2'>, <TokenType.POINT: 'POINT'>, <TokenType.IPV6: 'IPV6'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.FIRST: 'FIRST'>, <TokenType.FINAL: 'FINAL'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.DYNAMIC: 'DYNAMIC'>, <TokenType.DETACH: 'DETACH'>, <TokenType.SET: 'SET'>, <TokenType.RING: 'RING'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.CHAR: 'CHAR'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>}
UPDATE_ALIAS_TOKENS = {<TokenType.INT: 'INT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.RANGE: 'RANGE'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.POLYGON: 'POLYGON'>, <TokenType.CASE: 'CASE'>, <TokenType.STAGE: 'STAGE'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.APPLY: 'APPLY'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.MULTIPOLYGON: 'MULTIPOLYGON'>, <TokenType.INT256: 'INT256'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.LOAD: 'LOAD'>, <TokenType.ROWS: 'ROWS'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.DELETE: 'DELETE'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.UINT: 'UINT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.INT128: 'INT128'>, <TokenType.FALSE: 'FALSE'>, <TokenType.END: 'END'>, <TokenType.UINT256: 'UINT256'>, <TokenType.EXPORT: 'EXPORT'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.NAME: 'NAME'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.DATE32: 'DATE32'>, <TokenType.TABLE: 'TABLE'>, <TokenType.DATE: 'DATE'>, <TokenType.DECIMAL256: 'DECIMAL256'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.SOURCE: 'SOURCE'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.SESSION: 'SESSION'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.ANY: 'ANY'>, <TokenType.KILL: 'KILL'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.DECIMAL128: 'DECIMAL128'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.SINK: 'SINK'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.TRUE: 'TRUE'>, <TokenType.NULL: 'NULL'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.LINESTRING: 'LINESTRING'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.ENUM: 'ENUM'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.IS: 'IS'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.SMALLDATETIME: 'SMALLDATETIME'>, <TokenType.VAR: 'VAR'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.BLOB: 'BLOB'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.VOID: 'VOID'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.GEOGRAPHYPOINT: 'GEOGRAPHYPOINT'>, <TokenType.NEXT: 'NEXT'>, <TokenType.SEMANTIC_VIEW: 'SEMANTIC_VIEW'>, <TokenType.FILTER: 'FILTER'>, <TokenType.DIV: 'DIV'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.ROW: 'ROW'>, <TokenType.TEXT: 'TEXT'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.IPV4: 'IPV4'>, <TokenType.XML: 'XML'>, <TokenType.JSON: 'JSON'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.CUBE: 'CUBE'>, <TokenType.BINARY: 'BINARY'>, <TokenType.SOME: 'SOME'>, <TokenType.MERGE: 'MERGE'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.TIME: 'TIME'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.UINT128: 'UINT128'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.DECIMAL32: 'DECIMAL32'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.RENAME: 'RENAME'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.LIMIT: 'LIMIT'>, <TokenType.VIEW: 'VIEW'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.BIT: 'BIT'>, <TokenType.GET: 'GET'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.CACHE: 'CACHE'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.NESTED: 'NESTED'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.USE: 'USE'>, <TokenType.UDOUBLE: 'UDOUBLE'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.TAG: 'TAG'>, <TokenType.NOTHING: 'NOTHING'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.FILE_FORMAT: 'FILE_FORMAT'>, <TokenType.INET: 'INET'>, <TokenType.NAMESPACE: 'NAMESPACE'>, <TokenType.SUPER: 'SUPER'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.COPY: 'COPY'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.LIST: 'LIST'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.MULTILINESTRING: 'MULTILINESTRING'>, <TokenType.YEAR: 'YEAR'>, <TokenType.ALL: 'ALL'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.INDEX: 'INDEX'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DECIMAL64: 'DECIMAL64'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.KEEP: 'KEEP'>, <TokenType.PUT: 'PUT'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.MAP: 'MAP'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.MONEY: 'MONEY'>, <TokenType.CURRENT_SCHEMA: 'CURRENT_SCHEMA'>, <TokenType.JSONB: 'JSONB'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.ATTACH: 'ATTACH'>, <TokenType.SHOW: 'SHOW'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.TOP: 'TOP'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.DATETIME2: 'DATETIME2'>, <TokenType.POINT: 'POINT'>, <TokenType.IPV6: 'IPV6'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.FIRST: 'FIRST'>, <TokenType.FINAL: 'FINAL'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.DYNAMIC: 'DYNAMIC'>, <TokenType.DETACH: 'DETACH'>, <TokenType.RING: 'RING'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.CHAR: 'CHAR'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>}
FUNCTIONS = {'AI_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AIAgg'>>, 'AI_CLASSIFY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AIClassify'>>, 'AI_SUMMARIZE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AISummarizeAgg'>>, 'ABS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Abs'>>, 'ACOS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Acos'>>, 'ACOSH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Acosh'>>, 'ADD_MONTHS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AddMonths'>>, 'AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.And'>>, 'ANONYMOUS_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnonymousAggFunc'>>, 'ANY_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnyValue'>>, 'APPLY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Apply'>>, 'APPROX_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_COUNT_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxQuantile'>>, 'APPROX_QUANTILES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxQuantiles'>>, 'APPROX_TOP_K': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxTopK'>>, 'APPROX_TOP_SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxTopSum'>>, 'ARG_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARGMAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'MAX_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARG_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARGMIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'MIN_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARRAY': <function Parser.<lambda>>, 'ARRAY_AGG': <function Parser.<lambda>>, 'ARRAY_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAll'>>, 'ARRAY_ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAny'>>, 'ARRAY_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CONCAT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcatAgg'>>, 'ARRAY_CONSTRUCT_COMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConstructCompact'>>, 'ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContains'>>, 'ARRAY_HAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContains'>>, 'ARRAY_CONTAINS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContainsAll'>>, 'ARRAY_HAS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContainsAll'>>, 'FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFirst'>>, 'ARRAY_INTERSECT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayIntersect'>>, 'ARRAY_INTERSECTION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayIntersect'>>, 'ARRAY_LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayLast'>>, 'ARRAY_OVERLAPS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayOverlaps'>>, 'ARRAY_REMOVE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayRemove'>>, 'ARRAY_REVERSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayReverse'>>, 'ARRAY_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_SLICE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySlice'>>, 'ARRAY_SORT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySort'>>, 'ARRAY_SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySum'>>, 'ARRAY_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayToString'>>, 'ARRAY_JOIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayToString'>>, 'ARRAY_UNION_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUnionAgg'>>, 'ARRAY_UNIQUE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUniqueAgg'>>, 'ASCII': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ascii'>>, 'ASIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Asin'>>, 'ASINH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Asinh'>>, 'ATAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Atan'>>, 'ATAN2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Atan2'>>, 'ATANH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Atanh'>>, 'AVG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Avg'>>, 'BASE64_DECODE_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Base64DecodeBinary'>>, 'BASE64_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Base64DecodeString'>>, 'BASE64_ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Base64Encode'>>, 'BIT_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.BitLength'>>, 'BITWISE_AND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.BitwiseAndAgg'>>, 'BITWISE_COUNT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.BitwiseCountAgg'>>, 'BITWISE_OR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.BitwiseOrAgg'>>, 'BITWISE_XOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.BitwiseXorAgg'>>, 'BYTE_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ByteLength'>>, 'CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Case'>>, 'CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cast'>>, 'CAST_TO_STR_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CastToStrType'>>, 'CBRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cbrt'>>, 'CEIL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CEILING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CHR': <function Parser.<lambda>>, 'CHAR': <function Parser.<lambda>>, 'COALESCE': <function build_coalesce>, 'IFNULL': <function build_coalesce>, 'NVL': <function build_coalesce>, 'CODE_POINTS_TO_BYTES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CodePointsToBytes'>>, 'CODE_POINTS_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CodePointsToString'>>, 'COLLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Collate'>>, 'COLUMNS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Columns'>>, 'COMBINED_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedAggFunc'>>, 'COMBINED_PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedParameterizedAgg'>>, 'COMPRESS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Compress'>>, 'CONCAT': <function Parser.<lambda>>, 'CONCAT_WS': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ConnectByRoot'>>, 'CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Contains'>>, 'CONVERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Convert'>>, 'CONVERT_TIMEZONE': <function build_convert_timezone>, 'CONVERT_TO_CHARSET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ConvertToCharset'>>, 'CORR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Corr'>>, 'COSINE_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CosineDistance'>>, 'COT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cot'>>, 'COTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coth'>>, 'COUNT': <function Parser.<lambda>>, 'COUNT_IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CountIf'>>, 'COUNTIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CountIf'>>, 'COVAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CovarPop'>>, 'COVAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CovarSamp'>>, 'CSC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Csc'>>, 'CSCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Csch'>>, 'CUME_DIST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CumeDist'>>, 'CURRENT_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDate'>>, 'CURRENT_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDatetime'>>, 'CURRENT_SCHEMA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentSchema'>>, 'CURRENT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTime'>>, 'CURRENT_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTimestamp'>>, 'CURRENT_TIMESTAMP_L_T_Z': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTimestampLTZ'>>, 'CURRENT_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentUser'>>, 'DATE': <function _build_date>, 'DATE_ADD': <function build_date_delta_with_interval.<locals>._builder>, 'DATE_BIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateBin'>>, 'DATEDIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateDiff'>>, 'DATE_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateDiff'>>, 'DATE_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATE_FROM_UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromUnixDate'>>, 'DATE_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateStrToDate'>>, 'DATE_SUB': <function build_date_delta_with_interval.<locals>._builder>, 'DATE_TO_DATE_STR': <function Parser.<lambda>>, 'DATE_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateToDi'>>, 'DATE_TRUNC': <function BigQuery.Parser.<lambda>>, 'DATETIME': <function _build_datetime>, 'DATETIME_ADD': <function build_date_delta_with_interval.<locals>._builder>, 'DATETIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeDiff'>>, 'DATETIME_SUB': <function build_date_delta_with_interval.<locals>._builder>, 'DATETIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeTrunc'>>, 'DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Day'>>, 'DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAYOFMONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAY_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAYOFWEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAYOFWEEK_ISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeekIso'>>, 'ISODOW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeekIso'>>, 'DAY_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DAYOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DECODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Decode'>>, 'DECODE_CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DecodeCase'>>, 'DENSE_RANK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DenseRank'>>, 'DI_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DiToDate'>>, 'ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Encode'>>, 'ENDS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.EndsWith'>>, 'ENDSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.EndsWith'>>, 'EUCLIDEAN_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.EuclideanDistance'>>, 'EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Exists'>>, 'EXP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Exp'>>, 'EXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Explode'>>, 'EXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ExplodeOuter'>>, 'EXPLODING_GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ExplodingGenerateSeries'>>, 'EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Extract'>>, 'FARM_FINGERPRINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FarmFingerprint'>>, 'FARMFINGERPRINT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FarmFingerprint'>>, 'FEATURES_AT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FeaturesAtTime'>>, 'FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.First'>>, 'FIRST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FirstValue'>>, 'FLATTEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Flatten'>>, 'FLOAT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Float64'>>, 'FLOOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Floor'>>, 'FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Format'>>, 'FROM_BASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase'>>, 'FROM_BASE32': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase32'>>, 'FROM_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase64'>>, 'FROM_ISO8601_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromISO8601Timestamp'>>, 'GAP_FILL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GapFill'>>, 'GENERATE_DATE_ARRAY': <function Parser.<lambda>>, 'GENERATE_EMBEDDING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateEmbedding'>>, 'GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateSeries'>>, 'GENERATE_TIMESTAMP_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateTimestampArray'>>, 'GET_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GetExtract'>>, 'GREATEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Greatest'>>, 'GROUP_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GroupConcat'>>, 'GROUPING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Grouping'>>, 'HEX': <function build_hex>, 'HEX_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.HexDecodeString'>>, 'HEX_ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.HexEncode'>>, 'HLL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Hll'>>, 'IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'IIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'INITCAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Initcap'>>, 'INLINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Inline'>>, 'INT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Int64'>>, 'IS_ASCII': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsAscii'>>, 'IS_INF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'ISINF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'IS_NAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'ISNAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'J_S_O_N_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArray'>>, 'J_S_O_N_ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayAgg'>>, 'JSON_ARRAY_APPEND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayAppend'>>, 'JSON_ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayContains'>>, 'JSON_ARRAY_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayInsert'>>, 'JSONB_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBContains'>>, 'J_S_O_N_B_CONTAINS_ALL_TOP_KEYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBContainsAllTopKeys'>>, 'J_S_O_N_B_CONTAINS_ANY_TOP_KEYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBContainsAnyTopKeys'>>, 'J_S_O_N_B_DELETE_AT_PATH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBDeleteAtPath'>>, 'JSONB_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExists'>>, 'JSONB_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtract'>>, 'JSONB_EXTRACT_SCALAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtractScalar'>>, 'J_S_O_N_B_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBObjectAgg'>>, 'J_S_O_N_BOOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBool'>>, 'J_S_O_N_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONCast'>>, 'J_S_O_N_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONExists'>>, 'JSON_EXTRACT': <function build_extract_json_with_path.<locals>._builder>, 'JSON_EXTRACT_ARRAY': <function _build_extract_json_with_default_path.<locals>._builder>, 'JSON_EXTRACT_SCALAR': <function _build_extract_json_with_default_path.<locals>._builder>, 'JSON_FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONFormat'>>, 'J_S_O_N_KEYS_AT_DEPTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONKeysAtDepth'>>, 'J_S_O_N_OBJECT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObject'>>, 'J_S_O_N_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObjectAgg'>>, 'JSON_REMOVE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONRemove'>>, 'JSON_SET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONSet'>>, 'JSON_STRIP_NULLS': <function _build_json_strip_nulls>, 'J_S_O_N_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONTable'>>, 'JSON_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONType'>>, 'J_S_O_N_VALUE_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONValueArray'>>, 'JUSTIFY_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JustifyDays'>>, 'JUSTIFY_HOURS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JustifyHours'>>, 'JUSTIFY_INTERVAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JustifyInterval'>>, 'LAG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lag'>>, 'LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Last'>>, 'LAST_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastValue'>>, 'LAX_BOOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LaxBool'>>, 'LAX_FLOAT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LaxFloat64'>>, 'LAX_INT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LaxInt64'>>, 'LAX_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LaxString'>>, 'LEAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lead'>>, 'LEAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Least'>>, 'LEFT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Left'>>, 'LENGTH': <function BigQuery.Parser.<lambda>>, 'LEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'CHAR_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'CHARACTER_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEVENSHTEIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Levenshtein'>>, 'LIST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.List'>>, 'LN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ln'>>, 'LOG': <function build_logarithm>, 'LOGICAL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOLAND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'LOGICAL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOLOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'LOWER': <function build_lower>, 'LCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lower'>>, 'LOWER_HEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LowerHex'>>, 'MD5': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5Digest'>>, 'MD5_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5Digest'>>, 'M_D5_NUMBER_LOWER64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5NumberLower64'>>, 'M_D5_NUMBER_UPPER64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5NumberUpper64'>>, 'M_L_FORECAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MLForecast'>>, 'M_L_TRANSLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MLTranslate'>>, 'MAKE_INTERVAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MakeInterval'>>, 'MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Map'>>, 'MAP_FROM_ENTRIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MapFromEntries'>>, 'MATCH_AGAINST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MatchAgainst'>>, 'MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Max'>>, 'MEDIAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Median'>>, 'MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Min'>>, 'MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Month'>>, 'MONTHS_BETWEEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MonthsBetween'>>, 'NEXT_VALUE_FOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NextValueFor'>>, 'NORMALIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Normalize'>>, 'NTH_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NthValue'>>, 'NTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ntile'>>, 'NULLIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nullif'>>, 'NUMBER_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NumberToStr'>>, 'NVL2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nvl2'>>, 'OBJECT_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ObjectInsert'>>, 'OPEN_J_S_O_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.OpenJSON'>>, 'OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Or'>>, 'OVERLAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Overlay'>>, 'PAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pad'>>, 'PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParameterizedAgg'>>, 'PARSE_BIGNUMERIC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseBignumeric'>>, 'PARSE_DATETIME': <function BigQuery.Parser.<lambda>>, 'PARSE_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'JSON_PARSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'PARSE_NUMERIC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseNumeric'>>, 'PARSE_TIME': <function BigQuery.Parser.<lambda>>, 'PERCENT_RANK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentRank'>>, 'PERCENTILE_CONT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileCont'>>, 'PERCENTILE_DISC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileDisc'>>, 'POSEXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Posexplode'>>, 'POSEXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PosexplodeOuter'>>, 'POWER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'POW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'PREDICT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Predict'>>, 'QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quantile'>>, 'QUARTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quarter'>>, 'RAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDOM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Randn'>>, 'RANGE_BUCKET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RangeBucket'>>, 'RANGE_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RangeN'>>, 'RANK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rank'>>, 'READ_CSV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ReadCSV'>>, 'REDUCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Reduce'>>, 'REGEXP_EXTRACT': <function _build_regexp_extract.<locals>._builder>, 'REGEXP_EXTRACT_ALL': <function _build_regexp_extract.<locals>._builder>, 'REGEXP_I_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpILike'>>, 'REGEXP_INSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpInstr'>>, 'REGEXP_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpLike'>>, 'REGEXP_REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpReplace'>>, 'REGEXP_SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpSplit'>>, 'REPEAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Repeat'>>, 'REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Replace'>>, 'REVERSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Reverse'>>, 'RIGHT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Right'>>, 'ROUND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Round'>>, 'ROW_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RowNumber'>>, 'SHA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'S_H_A1_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA1Digest'>>, 'SHA2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA2'>>, 'S_H_A2_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA2Digest'>>, 'SAFE_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SafeAdd'>>, 'SAFE_CONVERT_BYTES_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SafeConvertBytesToString'>>, 'SAFE_DIVIDE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SafeDivide'>>, 'SAFE_MULTIPLY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SafeMultiply'>>, 'SAFE_NEGATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SafeNegate'>>, 'SAFE_SUBTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SafeSubtract'>>, 'SEC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sec'>>, 'SECH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sech'>>, 'SIGN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sign'>>, 'SIGNUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sign'>>, 'SIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sin'>>, 'SINH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sinh'>>, 'SORT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SortArray'>>, 'SOUNDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Soundex'>>, 'SPACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Space'>>, 'SPLIT': <function BigQuery.Parser.<lambda>>, 'SPLIT_PART': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SplitPart'>>, 'SQRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sqrt'>>, 'ST_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StDistance'>>, 'ST_POINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StPoint'>>, 'ST_MAKEPOINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StPoint'>>, 'STANDARD_HASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StandardHash'>>, 'STAR_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StarMap'>>, 'STARTS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STARTSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STDDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stddev'>>, 'STDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stddev'>>, 'STDDEV_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevPop'>>, 'STDDEV_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevSamp'>>, 'STR_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrPosition'>>, 'STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToDate'>>, 'STR_TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToMap'>>, 'STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToTime'>>, 'STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToUnix'>>, 'STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.String'>>, 'STRING_TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StringToArray'>>, 'SPLIT_BY_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StringToArray'>>, 'STRTOK_TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StringToArray'>>, 'STRUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Struct'>>, 'STRUCT_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StructExtract'>>, 'STUFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'SUBSTRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Substring'>>, 'SUBSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Substring'>>, 'SUBSTRING_INDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SubstringIndex'>>, 'SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sum'>>, 'TIME': <function _build_time>, 'TIME_ADD': <function build_date_delta_with_interval.<locals>._builder>, 'TIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeDiff'>>, 'TIME_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIMEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIME_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToDate'>>, 'TIME_STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToTime'>>, 'TIME_STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToUnix'>>, 'TIME_SUB': <function build_date_delta_with_interval.<locals>._builder>, 'TIME_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToStr'>>, 'TIME_TO_TIME_STR': <function Parser.<lambda>>, 'TIME_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToUnix'>>, 'TIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeTrunc'>>, 'TIMESTAMP': <function _build_timestamp>, 'TIMESTAMP_ADD': <function build_date_delta_with_interval.<locals>._builder>, 'TIMESTAMPDIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampDiff'>>, 'TIMESTAMP_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampDiff'>>, 'TIMESTAMP_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMPFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMP_SUB': <function build_date_delta_with_interval.<locals>._builder>, 'TIMESTAMP_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampTrunc'>>, 'TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToArray'>>, 'TO_BASE32': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToBase32'>>, 'TO_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToBase64'>>, 'TO_CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToChar'>>, 'TO_CODE_POINTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToCodePoints'>>, 'TO_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToDays'>>, 'TO_DOUBLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToDouble'>>, 'TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToMap'>>, 'TO_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToNumber'>>, 'TRANSFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Transform'>>, 'TRANSLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Translate'>>, 'TRIM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Trim'>>, 'TRY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Try'>>, 'TRY_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TryCast'>>, 'TS_OR_DI_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDiToDi'>>, 'TS_OR_DS_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsAdd'>>, 'TS_OR_DS_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsDiff'>>, 'TS_OR_DS_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToDate'>>, 'TS_OR_DS_TO_DATE_STR': <function Parser.<lambda>>, 'TS_OR_DS_TO_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToDatetime'>>, 'TS_OR_DS_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTime'>>, 'TS_OR_DS_TO_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTimestamp'>>, 'TYPEOF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Typeof'>>, 'UNHEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Unhex'>>, 'UNICODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Unicode'>>, 'UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixDate'>>, 'UNIX_MICROS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixMicros'>>, 'UNIX_MILLIS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixMillis'>>, 'UNIX_SECONDS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixSeconds'>>, 'UNIX_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToStr'>>, 'UNIX_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTime'>>, 'UNIX_TO_TIME_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTimeStr'>>, 'UNNEST': <function Parser.<lambda>>, 'UPPER': <function build_upper>, 'UCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Upper'>>, 'UTC_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UtcDate'>>, 'UTC_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UtcTime'>>, 'UTC_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UtcTimestamp'>>, 'UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, 'GEN_RANDOM_UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, 'GENERATE_UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, 'UUID_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, 'VAR_MAP': <function build_var_map>, 'VARIANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'VAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'VECTOR_SEARCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VectorSearch'>>, 'WEEK': <function BigQuery.Parser.<lambda>>, 'WEEK_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'WEEKOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'XMLELEMENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.XMLElement'>>, 'X_M_L_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.XMLTable'>>, 'XOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Xor'>>, 'YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Year'>>, 'ARRAYAGG': <function Parser.<lambda>>, 'GLOB': <function Parser.<lambda>>, 'JSON_EXTRACT_PATH_TEXT': <function build_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.StrPosition'>>, 'CHARINDEX': <function Parser.<lambda>>, 'INSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrPosition'>>, 'LOCATE': <function Parser.<lambda>>, 'TO_HEX': <function _build_to_hex>, 'APPROX_TOP_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxTopK'>>, 'BIT_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.BitwiseAndAgg'>>, 'BIT_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.BitwiseOrAgg'>>, 'BIT_XOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.BitwiseXorAgg'>>, 'BIT_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.BitwiseCountAgg'>>, 'BOOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBool'>>, 'CONTAINS_SUBSTR': <function _build_contains_substring>, 'DIV': <function binary_from_function.<locals>.<lambda>>, 'EDIT_DISTANCE': <function _build_levenshtein>, 'FORMAT_DATE': <function _build_format_time.<locals>._builder>, 'GENERATE_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateSeries'>>, 'JSON_EXTRACT_STRING_ARRAY': <function _build_extract_json_with_default_path.<locals>._builder>, 'JSON_KEYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONKeysAtDepth'>>, 'JSON_QUERY': <function build_extract_json_with_path.<locals>._builder>, 'JSON_QUERY_ARRAY': <function _build_extract_json_with_default_path.<locals>._builder>, 'JSON_VALUE': <function _build_extract_json_with_default_path.<locals>._builder>, 'JSON_VALUE_ARRAY': <function _build_extract_json_with_default_path.<locals>._builder>, 'NORMALIZE_AND_CASEFOLD': <function BigQuery.Parser.<lambda>>, 'OCTET_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ByteLength'>>, 'PARSE_DATE': <function BigQuery.Parser.<lambda>>, 'PARSE_TIMESTAMP': <function _build_parse_timestamp>, 'REGEXP_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpLike'>>, 'REGEXP_SUBSTR': <function _build_regexp_extract.<locals>._builder>, 'SHA256': <function BigQuery.Parser.<lambda>>, 'SHA512': <function BigQuery.Parser.<lambda>>, 'TIMESTAMP_MICROS': <function BigQuery.Parser.<lambda>>, 'TIMESTAMP_MILLIS': <function BigQuery.Parser.<lambda>>, 'TIMESTAMP_SECONDS': <function BigQuery.Parser.<lambda>>, 'TO_JSON': <function BigQuery.Parser.<lambda>>, 'TO_JSON_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONFormat'>>, 'FORMAT_DATETIME': <function _build_format_time.<locals>._builder>, 'FORMAT_TIMESTAMP': <function _build_format_time.<locals>._builder>, 'FORMAT_TIME': <function _build_format_time.<locals>._builder>, 'FROM_HEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Unhex'>>}
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>>, 'DECODE': <function Parser.<lambda>>, 'EXTRACT': <function Parser.<lambda>>, 'FLOOR': <function Parser.<lambda>>, 'GAP_FILL': <function Parser.<lambda>>, 'JSON_OBJECT': <function Parser.<lambda>>, 'JSON_OBJECTAGG': <function Parser.<lambda>>, 'JSON_TABLE': <function Parser.<lambda>>, 'MATCH': <function Parser.<lambda>>, '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>>, 'TRY_CAST': <function Parser.<lambda>>, 'TRY_CONVERT': <function Parser.<lambda>>, 'XMLELEMENT': <function Parser.<lambda>>, 'XMLTABLE': <function Parser.<lambda>>, 'ARRAY': <function BigQuery.Parser.<lambda>>, 'JSON_ARRAY': <function BigQuery.Parser.<lambda>>, 'MAKE_INTERVAL': <function BigQuery.Parser.<lambda>>, 'PREDICT': <function BigQuery.Parser.<lambda>>, 'TRANSLATE': <function BigQuery.Parser.<lambda>>, 'FEATURES_AT_TIME': <function BigQuery.Parser.<lambda>>, 'GENERATE_EMBEDDING': <function BigQuery.Parser.<lambda>>, 'GENERATE_TEXT_EMBEDDING': <function BigQuery.Parser.<lambda>>, 'VECTOR_SEARCH': <function BigQuery.Parser.<lambda>>, 'FORECAST': <function BigQuery.Parser.<lambda>>}
NO_PAREN_FUNCTIONS = {<TokenType.CURRENT_DATE: 'CURRENT_DATE'>: <class 'sqlglot.expressions.CurrentDate'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>: <class 'sqlglot.expressions.CurrentDatetime'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>: <class 'sqlglot.expressions.CurrentTime'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>: <class 'sqlglot.expressions.CurrentTimestamp'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>: <class 'sqlglot.expressions.CurrentUser'>}
NESTED_TYPE_TOKENS = {<TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.TABLE: 'TABLE'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.RANGE: 'RANGE'>, <TokenType.LIST: 'LIST'>, <TokenType.UNION: 'UNION'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.MAP: 'MAP'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.NESTED: 'NESTED'>}
PROPERTY_PARSERS = {'ALLOWED_VALUES': <function Parser.<lambda>>, 'ALGORITHM': <function Parser.<lambda>>, 'AUTO': <function Parser.<lambda>>, 'AUTO_INCREMENT': <function Parser.<lambda>>, 'BACKUP': <function Parser.<lambda>>, 'BLOCKCOMPRESSION': <function Parser.<lambda>>, 'CHARSET': <function Parser.<lambda>>, 'CHARACTER SET': <function Parser.<lambda>>, 'CHECKSUM': <function Parser.<lambda>>, 'CLUSTER BY': <function Parser.<lambda>>, 'CLUSTERED': <function Parser.<lambda>>, 'COLLATE': <function Parser.<lambda>>, 'COMMENT': <function Parser.<lambda>>, 'CONTAINS': <function Parser.<lambda>>, 'COPY': <function Parser.<lambda>>, 'DATABLOCKSIZE': <function Parser.<lambda>>, 'DATA_DELETION': <function Parser.<lambda>>, 'DEFINER': <function Parser.<lambda>>, 'DETERMINISTIC': <function Parser.<lambda>>, 'DISTRIBUTED': <function Parser.<lambda>>, 'DUPLICATE': <function Parser.<lambda>>, 'DYNAMIC': <function Parser.<lambda>>, 'DISTKEY': <function Parser.<lambda>>, 'DISTSTYLE': <function Parser.<lambda>>, 'EMPTY': <function Parser.<lambda>>, 'ENGINE': <function Parser.<lambda>>, 'ENVIRONMENT': <function Parser.<lambda>>, 'EXECUTE': <function Parser.<lambda>>, 'EXTERNAL': <function Parser.<lambda>>, 'FALLBACK': <function Parser.<lambda>>, 'FORMAT': <function Parser.<lambda>>, 'FREESPACE': <function Parser.<lambda>>, 'GLOBAL': <function Parser.<lambda>>, 'HEAP': <function Parser.<lambda>>, 'ICEBERG': <function Parser.<lambda>>, 'IMMUTABLE': <function Parser.<lambda>>, 'INHERITS': <function Parser.<lambda>>, 'INPUT': <function Parser.<lambda>>, 'JOURNAL': <function Parser.<lambda>>, 'LANGUAGE': <function Parser.<lambda>>, 'LAYOUT': <function Parser.<lambda>>, 'LIFETIME': <function Parser.<lambda>>, 'LIKE': <function Parser.<lambda>>, 'LOCATION': <function Parser.<lambda>>, 'LOCK': <function Parser.<lambda>>, 'LOCKING': <function Parser.<lambda>>, 'LOG': <function Parser.<lambda>>, 'MATERIALIZED': <function Parser.<lambda>>, 'MERGEBLOCKRATIO': <function Parser.<lambda>>, 'MODIFIES': <function Parser.<lambda>>, 'MULTISET': <function Parser.<lambda>>, 'NO': <function Parser.<lambda>>, 'ON': <function Parser.<lambda>>, 'ORDER BY': <function Parser.<lambda>>, 'OUTPUT': <function Parser.<lambda>>, 'PARTITION': <function Parser.<lambda>>, 'PARTITION BY': <function Parser.<lambda>>, 'PARTITIONED BY': <function Parser.<lambda>>, 'PARTITIONED_BY': <function Parser.<lambda>>, 'PRIMARY KEY': <function Parser.<lambda>>, 'RANGE': <function Parser.<lambda>>, 'READS': <function Parser.<lambda>>, 'REMOTE': <function Parser.<lambda>>, 'RETURNS': <function Parser.<lambda>>, 'STRICT': <function Parser.<lambda>>, 'STREAMING': <function Parser.<lambda>>, 'ROW': <function Parser.<lambda>>, 'ROW_FORMAT': <function Parser.<lambda>>, 'SAMPLE': <function Parser.<lambda>>, 'SECURE': <function Parser.<lambda>>, 'SECURITY': <function Parser.<lambda>>, 'SET': <function Parser.<lambda>>, 'SETTINGS': <function Parser.<lambda>>, 'SHARING': <function Parser.<lambda>>, 'SORTKEY': <function Parser.<lambda>>, 'SOURCE': <function Parser.<lambda>>, 'STABLE': <function Parser.<lambda>>, 'STORED': <function Parser.<lambda>>, 'SYSTEM_VERSIONING': <function Parser.<lambda>>, 'TBLPROPERTIES': <function Parser.<lambda>>, 'TEMP': <function Parser.<lambda>>, 'TEMPORARY': <function Parser.<lambda>>, 'TO': <function Parser.<lambda>>, 'TRANSIENT': <function Parser.<lambda>>, 'TRANSFORM': <function Parser.<lambda>>, 'TTL': <function Parser.<lambda>>, 'USING': <function Parser.<lambda>>, 'UNLOGGED': <function Parser.<lambda>>, 'VOLATILE': <function Parser.<lambda>>, 'WITH': <function Parser.<lambda>>, 'NOT DETERMINISTIC': <function BigQuery.Parser.<lambda>>, 'OPTIONS': <function BigQuery.Parser.<lambda>>}
CONSTRAINT_PARSERS = {'AUTOINCREMENT': <function Parser.<lambda>>, 'AUTO_INCREMENT': <function Parser.<lambda>>, 'CASESPECIFIC': <function Parser.<lambda>>, 'CHARACTER SET': <function Parser.<lambda>>, 'CHECK': <function Parser.<lambda>>, 'COLLATE': <function Parser.<lambda>>, 'COMMENT': <function Parser.<lambda>>, 'COMPRESS': <function Parser.<lambda>>, 'CLUSTERED': <function Parser.<lambda>>, 'NONCLUSTERED': <function Parser.<lambda>>, 'DEFAULT': <function Parser.<lambda>>, 'ENCODE': <function Parser.<lambda>>, 'EPHEMERAL': <function Parser.<lambda>>, 'EXCLUDE': <function Parser.<lambda>>, 'FOREIGN KEY': <function Parser.<lambda>>, 'FORMAT': <function Parser.<lambda>>, 'GENERATED': <function Parser.<lambda>>, 'IDENTITY': <function Parser.<lambda>>, 'INLINE': <function Parser.<lambda>>, 'LIKE': <function Parser.<lambda>>, 'NOT': <function Parser.<lambda>>, 'NULL': <function Parser.<lambda>>, 'ON': <function Parser.<lambda>>, 'PATH': <function Parser.<lambda>>, 'PERIOD': <function Parser.<lambda>>, 'PRIMARY KEY': <function Parser.<lambda>>, 'REFERENCES': <function Parser.<lambda>>, 'TITLE': <function Parser.<lambda>>, 'TTL': <function Parser.<lambda>>, 'UNIQUE': <function Parser.<lambda>>, 'UPPERCASE': <function Parser.<lambda>>, 'WATERMARK': <function Parser.<lambda>>, 'WITH': <function Parser.<lambda>>, 'BUCKET': <function Parser.<lambda>>, 'TRUNCATE': <function Parser.<lambda>>, 'OPTIONS': <function BigQuery.Parser.<lambda>>}
RANGE_PARSERS = {<TokenType.AT_GT: 'AT_GT'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.BETWEEN: 'BETWEEN'>: <function Parser.<lambda>>, <TokenType.GLOB: 'GLOB'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.ILIKE: 'ILIKE'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IN: 'IN'>: <function Parser.<lambda>>, <TokenType.IRLIKE: 'IRLIKE'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IS: 'IS'>: <function Parser.<lambda>>, <TokenType.LIKE: 'LIKE'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.LT_AT: 'LT_AT'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.RLIKE: 'RLIKE'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.SIMILAR_TO: 'SIMILAR_TO'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.FOR: 'FOR'>: <function Parser.<lambda>>, <TokenType.QMARK_AMP: 'QMARK_AMP'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.QMARK_PIPE: 'QMARK_PIPE'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.HASH_DASH: 'HASH_DASH'>: <function binary_range_parser.<locals>._parse_binary_range>}
DASHED_TABLE_PART_FOLLOW_TOKENS = {<TokenType.DOT: 'DOT'>, <TokenType.L_PAREN: 'L_PAREN'>, <TokenType.R_PAREN: 'R_PAREN'>}
STATEMENT_PARSERS = {<TokenType.ALTER: 'ALTER'>: <function Parser.<lambda>>, <TokenType.ANALYZE: 'ANALYZE'>: <function Parser.<lambda>>, <TokenType.BEGIN: 'BEGIN'>: <function Parser.<lambda>>, <TokenType.CACHE: 'CACHE'>: <function Parser.<lambda>>, <TokenType.COMMENT: 'COMMENT'>: <function Parser.<lambda>>, <TokenType.COMMIT: 'COMMIT'>: <function Parser.<lambda>>, <TokenType.COPY: 'COPY'>: <function Parser.<lambda>>, <TokenType.CREATE: 'CREATE'>: <function Parser.<lambda>>, <TokenType.DELETE: 'DELETE'>: <function Parser.<lambda>>, <TokenType.DESC: 'DESC'>: <function Parser.<lambda>>, <TokenType.DESCRIBE: 'DESCRIBE'>: <function Parser.<lambda>>, <TokenType.DROP: 'DROP'>: <function Parser.<lambda>>, <TokenType.GRANT: 'GRANT'>: <function Parser.<lambda>>, <TokenType.REVOKE: 'REVOKE'>: <function Parser.<lambda>>, <TokenType.INSERT: 'INSERT'>: <function Parser.<lambda>>, <TokenType.KILL: 'KILL'>: <function Parser.<lambda>>, <TokenType.LOAD: 'LOAD'>: <function Parser.<lambda>>, <TokenType.MERGE: 'MERGE'>: <function Parser.<lambda>>, <TokenType.PIVOT: 'PIVOT'>: <function Parser.<lambda>>, <TokenType.PRAGMA: 'PRAGMA'>: <function Parser.<lambda>>, <TokenType.REFRESH: 'REFRESH'>: <function Parser.<lambda>>, <TokenType.ROLLBACK: 'ROLLBACK'>: <function Parser.<lambda>>, <TokenType.SET: 'SET'>: <function Parser.<lambda>>, <TokenType.TRUNCATE: 'TRUNCATE'>: <function Parser.<lambda>>, <TokenType.UNCACHE: 'UNCACHE'>: <function Parser.<lambda>>, <TokenType.UNPIVOT: 'UNPIVOT'>: <function Parser.<lambda>>, <TokenType.UPDATE: 'UPDATE'>: <function Parser.<lambda>>, <TokenType.USE: 'USE'>: <function Parser.<lambda>>, <TokenType.SEMICOLON: 'SEMICOLON'>: <function Parser.<lambda>>, <TokenType.ELSE: 'ELSE'>: <function BigQuery.Parser.<lambda>>, <TokenType.END: 'END'>: <function BigQuery.Parser.<lambda>>, <TokenType.FOR: 'FOR'>: <function BigQuery.Parser.<lambda>>, <TokenType.EXPORT: 'EXPORT'>: <function BigQuery.Parser.<lambda>>, <TokenType.DECLARE: 'DECLARE'>: <function BigQuery.Parser.<lambda>>}
BRACKET_OFFSETS = {'OFFSET': (0, False), 'ORDINAL': (1, False), 'SAFE_OFFSET': (0, True), 'SAFE_ORDINAL': (1, True)}
SHOW_TRIE: Dict = {}
SET_TRIE: Dict = {'GLOBAL': {0: True}, 'LOCAL': {0: True}, 'SESSION': {0: True}, 'TRANSACTION': {0: True}}

##### Inherited Members

sqlglot.parser.Parser
  Parser
  STRUCT_TYPE_TOKENS
  ENUM_TYPE_TOKENS
  AGGREGATE_TYPE_TOKENS
  TYPE_TOKENS
  SIGNED_TO_UNSIGNED_TYPE_TOKEN
  SUBQUERY_PREDICATES
  RESERVED_TOKENS
  DB_CREATABLES
  CREATABLES
  ALTERABLES
  COLON_PLACEHOLDER_TOKENS
  ARRAY_CONSTRUCTORS
  TRIM_TYPES
  FUNC_TOKENS
  CONJUNCTION
  ASSIGNMENT
  DISJUNCTION
  EQUALITY
  COMPARISON
  BITWISE
  TERM
  FACTOR
  EXPONENT
  TIMES
  TIMESTAMPS
  SET_OPERATIONS
  JOIN_METHODS
  JOIN_SIDES
  JOIN_KINDS
  JOIN_HINTS
  LAMBDAS
  COLUMN_OPERATORS
  CAST_COLUMN_OPERATORS
  EXPRESSION_PARSERS
  UNARY_PARSERS
  STRING_PARSERS
  NUMERIC_PARSERS
  PRIMARY_PARSERS
  PLACEHOLDER_PARSERS
  PIPE_SYNTAX_TRANSFORM_PARSERS
  ALTER_PARSERS
  ALTER_ALTER_PARSERS
  SCHEMA_UNNAMED_CONSTRAINTS
  NO_PAREN_FUNCTION_PARSERS
  INVALID_FUNC_NAME_TOKENS
  FUNCTIONS_WITH_ALIASED_ARGS
  KEY_VALUE_DEFINITIONS
  QUERY_MODIFIER_PARSERS
  QUERY_MODIFIER_TOKENS
  SET_PARSERS
  SHOW_PARSERS
  TYPE_LITERAL_PARSERS
  TYPE_CONVERTERS
  DDL_SELECT_TOKENS
  PRE_VOLATILE_TOKENS
  TRANSACTION_KIND
  TRANSACTION_CHARACTERISTICS
  CONFLICT_ACTIONS
  CREATE_SEQUENCE
  ISOLATED_LOADING_OPTIONS
  USABLES
  CAST_ACTIONS
  SCHEMA_BINDING_OPTIONS
  PROCEDURE_OPTIONS
  EXECUTE_AS_OPTIONS
  KEY_CONSTRAINT_OPTIONS
  WINDOW_EXCLUDE_OPTIONS
  INSERT_ALTERNATIVES
  CLONE_KEYWORDS
  HISTORICAL_DATA_PREFIX
  HISTORICAL_DATA_KIND
  OPCLASS_FOLLOW_KEYWORDS
  OPTYPE_FOLLOW_TOKENS
  TABLE_INDEX_HINT_TOKENS
  VIEW_ATTRIBUTES
  WINDOW_ALIAS_TOKENS
  WINDOW_BEFORE_PAREN_TOKENS
  WINDOW_SIDES
  JSON_KEY_VALUE_SEPARATOR_TOKENS
  FETCH_TOKENS
  ADD_CONSTRAINT_TOKENS
  DISTINCT_TOKENS
  UNNEST_OFFSET_ALIAS_TOKENS
  SELECT_START_TOKENS
  COPY_INTO_VARLEN_OPTIONS
  IS_JSON_PREDICATE_KIND
  ODBC_DATETIME_LITERALS
  ON_CONDITION_TOKENS
  PRIVILEGE_FOLLOW_TOKENS
  DESCRIBE_STYLES
  ANALYZE_STYLES
  ANALYZE_EXPRESSION_PARSERS
  PARTITION_KEYWORDS
  AMBIGUOUS_ALIAS_TOKENS
  OPERATION_MODIFIERS
  RECURSIVE_CTE_SEARCH_KIND
  MODIFIABLES
  STRICT_CAST
  IDENTIFY_PIVOT_STRINGS
  TABLESAMPLE_CSV
  DEFAULT_SAMPLING_METHOD
  SET_REQUIRES_ASSIGNMENT_DELIMITER
  TRIM_PATTERN_FIRST
  STRING_ALIASES
  MODIFIERS_ATTACHED_TO_SET_OP
  SET_OP_MODIFIERS
  NO_PAREN_IF_COMMANDS
  JSON_ARROWS_REQUIRE_JSON_TYPE
  COLON_IS_VARIANT_EXTRACT
  VALUES_FOLLOWED_BY_PAREN
  INTERVAL_SPANS
  SUPPORTS_PARTITION_SELECTION
  WRAPPED_TRANSFORM_COLUMN_CONSTRAINT
  OPTIONAL_ALIAS_TOKEN_CTE
  ALTER_RENAME_REQUIRES_COLUMN
  ZONE_AWARE_TIMESTAMP_CONSTRUCTOR
  MAP_KEYS_ARE_ARBITRARY_EXPRESSIONS
  JSON_EXTRACT_REQUIRES_JSON_EXPRESSION
  ADD_JOIN_ON_TRUE
  SUPPORTS_OMITTED_INTERVAL_SPAN_UNIT
  error_level
  error_message_context
  max_errors
  dialect
  reset
  parse
  parse_into
  check_errors
  raise_error
  expression
  validate_expression
  parse_set_operation
  build_cast
  errors
  sql

class BigQuery.Generator(sqlglot.generator.Generator): View Source

    1240    class Generator(generator.Generator):
    1241        INTERVAL_ALLOWS_PLURAL_FORM = False
    1242        JOIN_HINTS = False
    1243        QUERY_HINTS = False
    1244        TABLE_HINTS = False
    1245        LIMIT_FETCH = "LIMIT"
    1246        RENAME_TABLE_WITH_DB = False
    1247        NVL2_SUPPORTED = False
    1248        UNNEST_WITH_ORDINALITY = False
    1249        COLLATE_IS_FUNC = True
    1250        LIMIT_ONLY_LITERALS = True
    1251        SUPPORTS_TABLE_ALIAS_COLUMNS = False
    1252        UNPIVOT_ALIASES_ARE_IDENTIFIERS = False
    1253        JSON_KEY_VALUE_PAIR_SEP = ","
    1254        NULL_ORDERING_SUPPORTED = False
    1255        IGNORE_NULLS_IN_FUNC = True
    1256        JSON_PATH_SINGLE_QUOTE_ESCAPE = True
    1257        CAN_IMPLEMENT_ARRAY_ANY = True
    1258        SUPPORTS_TO_NUMBER = False
    1259        NAMED_PLACEHOLDER_TOKEN = "@"
    1260        HEX_FUNC = "TO_HEX"
    1261        WITH_PROPERTIES_PREFIX = "OPTIONS"
    1262        SUPPORTS_EXPLODING_PROJECTIONS = False
    1263        EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE = False
    1264        SUPPORTS_UNIX_SECONDS = True
    1265
    1266        SAFE_JSON_PATH_KEY_RE = re.compile(r"^[_\-a-zA-Z][\-\w]*$")
    1267
    1268        TS_OR_DS_TYPES = (
    1269            exp.TsOrDsToDatetime,
    1270            exp.TsOrDsToTimestamp,
    1271            exp.TsOrDsToTime,
    1272            exp.TsOrDsToDate,
    1273        )
    1274
    1275        TRANSFORMS = {
    1276            **generator.Generator.TRANSFORMS,
    1277            exp.ApproxTopK: rename_func("APPROX_TOP_COUNT"),
    1278            exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
    1279            exp.ArgMax: arg_max_or_min_no_count("MAX_BY"),
    1280            exp.ArgMin: arg_max_or_min_no_count("MIN_BY"),
    1281            exp.Array: inline_array_unless_query,
    1282            exp.ArrayContains: _array_contains_sql,
    1283            exp.ArrayFilter: filter_array_using_unnest,
    1284            exp.ArrayRemove: filter_array_using_unnest,
    1285            exp.BitwiseAndAgg: rename_func("BIT_AND"),
    1286            exp.BitwiseOrAgg: rename_func("BIT_OR"),
    1287            exp.BitwiseXorAgg: rename_func("BIT_XOR"),
    1288            exp.BitwiseCountAgg: rename_func("BIT_COUNT"),
    1289            exp.ByteLength: rename_func("BYTE_LENGTH"),
    1290            exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]),
    1291            exp.CollateProperty: lambda self, e: (
    1292                f"DEFAULT COLLATE {self.sql(e, 'this')}"
    1293                if e.args.get("default")
    1294                else f"COLLATE {self.sql(e, 'this')}"
    1295            ),
    1296            exp.Commit: lambda *_: "COMMIT TRANSACTION",
    1297            exp.CountIf: rename_func("COUNTIF"),
    1298            exp.Create: _create_sql,
    1299            exp.CTE: transforms.preprocess([_pushdown_cte_column_names]),
    1300            exp.DateAdd: date_add_interval_sql("DATE", "ADD"),
    1301            exp.DateDiff: lambda self, e: self.func(
    1302                "DATE_DIFF", e.this, e.expression, unit_to_var(e)
    1303            ),
    1304            exp.DateFromParts: rename_func("DATE"),
    1305            exp.DateStrToDate: datestrtodate_sql,
    1306            exp.DateSub: date_add_interval_sql("DATE", "SUB"),
    1307            exp.DatetimeAdd: date_add_interval_sql("DATETIME", "ADD"),
    1308            exp.DatetimeSub: date_add_interval_sql("DATETIME", "SUB"),
    1309            exp.DateFromUnixDate: rename_func("DATE_FROM_UNIX_DATE"),
    1310            exp.FromTimeZone: lambda self, e: self.func(
    1311                "DATETIME", self.func("TIMESTAMP", e.this, e.args.get("zone")), "'UTC'"
    1312            ),
    1313            exp.GenerateSeries: rename_func("GENERATE_ARRAY"),
    1314            exp.GroupConcat: lambda self, e: groupconcat_sql(
    1315                self, e, func_name="STRING_AGG", within_group=False
    1316            ),
    1317            exp.Hex: lambda self, e: self.func("UPPER", self.func("TO_HEX", self.sql(e, "this"))),
    1318            exp.HexString: lambda self, e: self.hexstring_sql(e, binary_function_repr="FROM_HEX"),
    1319            exp.If: if_sql(false_value="NULL"),
    1320            exp.ILike: no_ilike_sql,
    1321            exp.IntDiv: rename_func("DIV"),
    1322            exp.Int64: rename_func("INT64"),
    1323            exp.JSONBool: rename_func("BOOL"),
    1324            exp.JSONExtract: _json_extract_sql,
    1325            exp.JSONExtractArray: _json_extract_sql,
    1326            exp.JSONExtractScalar: _json_extract_sql,
    1327            exp.JSONFormat: lambda self, e: self.func(
    1328                "TO_JSON" if e.args.get("to_json") else "TO_JSON_STRING",
    1329                e.this,
    1330                e.args.get("options"),
    1331            ),
    1332            exp.JSONKeysAtDepth: rename_func("JSON_KEYS"),
    1333            exp.JSONValueArray: rename_func("JSON_VALUE_ARRAY"),
    1334            exp.Levenshtein: _levenshtein_sql,
    1335            exp.Max: max_or_greatest,
    1336            exp.MD5: lambda self, e: self.func("TO_HEX", self.func("MD5", e.this)),
    1337            exp.MD5Digest: rename_func("MD5"),
    1338            exp.Min: min_or_least,
    1339            exp.Normalize: lambda self, e: self.func(
    1340                "NORMALIZE_AND_CASEFOLD" if e.args.get("is_casefold") else "NORMALIZE",
    1341                e.this,
    1342                e.args.get("form"),
    1343            ),
    1344            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
    1345            exp.RegexpExtract: lambda self, e: self.func(
    1346                "REGEXP_EXTRACT",
    1347                e.this,
    1348                e.expression,
    1349                e.args.get("position"),
    1350                e.args.get("occurrence"),
    1351            ),
    1352            exp.RegexpExtractAll: lambda self, e: self.func(
    1353                "REGEXP_EXTRACT_ALL", e.this, e.expression
    1354            ),
    1355            exp.RegexpReplace: regexp_replace_sql,
    1356            exp.RegexpLike: rename_func("REGEXP_CONTAINS"),
    1357            exp.ReturnsProperty: _returnsproperty_sql,
    1358            exp.Rollback: lambda *_: "ROLLBACK TRANSACTION",
    1359            exp.ParseTime: lambda self, e: self.func("PARSE_TIME", self.format_time(e), e.this),
    1360            exp.ParseDatetime: lambda self, e: self.func(
    1361                "PARSE_DATETIME", self.format_time(e), e.this
    1362            ),
    1363            exp.Select: transforms.preprocess(
    1364                [
    1365                    transforms.explode_projection_to_unnest(),
    1366                    transforms.unqualify_unnest,
    1367                    transforms.eliminate_distinct_on,
    1368                    _alias_ordered_group,
    1369                    transforms.eliminate_semi_and_anti_joins,
    1370                ]
    1371            ),
    1372            exp.SHA: rename_func("SHA1"),
    1373            exp.SHA2: sha256_sql,
    1374            exp.StabilityProperty: lambda self, e: (
    1375                "DETERMINISTIC" if e.name == "IMMUTABLE" else "NOT DETERMINISTIC"
    1376            ),
    1377            exp.String: rename_func("STRING"),
    1378            exp.StrPosition: lambda self, e: (
    1379                strposition_sql(
    1380                    self, e, func_name="INSTR", supports_position=True, supports_occurrence=True
    1381                )
    1382            ),
    1383            exp.StrToDate: _str_to_datetime_sql,
    1384            exp.StrToTime: _str_to_datetime_sql,
    1385            exp.TimeAdd: date_add_interval_sql("TIME", "ADD"),
    1386            exp.TimeFromParts: rename_func("TIME"),
    1387            exp.TimestampFromParts: rename_func("DATETIME"),
    1388            exp.TimeSub: date_add_interval_sql("TIME", "SUB"),
    1389            exp.TimestampAdd: date_add_interval_sql("TIMESTAMP", "ADD"),
    1390            exp.TimestampDiff: rename_func("TIMESTAMP_DIFF"),
    1391            exp.TimestampSub: date_add_interval_sql("TIMESTAMP", "SUB"),
    1392            exp.TimeStrToTime: timestrtotime_sql,
    1393            exp.Transaction: lambda *_: "BEGIN TRANSACTION",
    1394            exp.TsOrDsAdd: _ts_or_ds_add_sql,
    1395            exp.TsOrDsDiff: _ts_or_ds_diff_sql,
    1396            exp.TsOrDsToTime: rename_func("TIME"),
    1397            exp.TsOrDsToDatetime: rename_func("DATETIME"),
    1398            exp.TsOrDsToTimestamp: rename_func("TIMESTAMP"),
    1399            exp.Unhex: rename_func("FROM_HEX"),
    1400            exp.UnixDate: rename_func("UNIX_DATE"),
    1401            exp.UnixToTime: _unix_to_time_sql,
    1402            exp.Uuid: lambda *_: "GENERATE_UUID()",
    1403            exp.Values: _derived_table_values_to_unnest,
    1404            exp.VariancePop: rename_func("VAR_POP"),
    1405            exp.SafeDivide: rename_func("SAFE_DIVIDE"),
    1406        }
    1407
    1408        SUPPORTED_JSON_PATH_PARTS = {
    1409            exp.JSONPathKey,
    1410            exp.JSONPathRoot,
    1411            exp.JSONPathSubscript,
    1412        }
    1413
    1414        TYPE_MAPPING = {
    1415            **generator.Generator.TYPE_MAPPING,
    1416            exp.DataType.Type.BIGDECIMAL: "BIGNUMERIC",
    1417            exp.DataType.Type.BIGINT: "INT64",
    1418            exp.DataType.Type.BINARY: "BYTES",
    1419            exp.DataType.Type.BLOB: "BYTES",
    1420            exp.DataType.Type.BOOLEAN: "BOOL",
    1421            exp.DataType.Type.CHAR: "STRING",
    1422            exp.DataType.Type.DECIMAL: "NUMERIC",
    1423            exp.DataType.Type.DOUBLE: "FLOAT64",
    1424            exp.DataType.Type.FLOAT: "FLOAT64",
    1425            exp.DataType.Type.INT: "INT64",
    1426            exp.DataType.Type.NCHAR: "STRING",
    1427            exp.DataType.Type.NVARCHAR: "STRING",
    1428            exp.DataType.Type.SMALLINT: "INT64",
    1429            exp.DataType.Type.TEXT: "STRING",
    1430            exp.DataType.Type.TIMESTAMP: "DATETIME",
    1431            exp.DataType.Type.TIMESTAMPNTZ: "DATETIME",
    1432            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
    1433            exp.DataType.Type.TIMESTAMPLTZ: "TIMESTAMP",
    1434            exp.DataType.Type.TINYINT: "INT64",
    1435            exp.DataType.Type.ROWVERSION: "BYTES",
    1436            exp.DataType.Type.UUID: "STRING",
    1437            exp.DataType.Type.VARBINARY: "BYTES",
    1438            exp.DataType.Type.VARCHAR: "STRING",
    1439            exp.DataType.Type.VARIANT: "ANY TYPE",
    1440        }
    1441
    1442        PROPERTIES_LOCATION = {
    1443            **generator.Generator.PROPERTIES_LOCATION,
    1444            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
    1445            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
    1446        }
    1447
    1448        # WINDOW comes after QUALIFY
    1449        # https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#window_clause
    1450        AFTER_HAVING_MODIFIER_TRANSFORMS = {
    1451            "qualify": generator.Generator.AFTER_HAVING_MODIFIER_TRANSFORMS["qualify"],
    1452            "windows": generator.Generator.AFTER_HAVING_MODIFIER_TRANSFORMS["windows"],
    1453        }
    1454
    1455        # from: https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#reserved_keywords
    1456        RESERVED_KEYWORDS = {
    1457            "all",
    1458            "and",
    1459            "any",
    1460            "array",
    1461            "as",
    1462            "asc",
    1463            "assert_rows_modified",
    1464            "at",
    1465            "between",
    1466            "by",
    1467            "case",
    1468            "cast",
    1469            "collate",
    1470            "contains",
    1471            "create",
    1472            "cross",
    1473            "cube",
    1474            "current",
    1475            "default",
    1476            "define",
    1477            "desc",
    1478            "distinct",
    1479            "else",
    1480            "end",
    1481            "enum",
    1482            "escape",
    1483            "except",
    1484            "exclude",
    1485            "exists",
    1486            "extract",
    1487            "false",
    1488            "fetch",
    1489            "following",
    1490            "for",
    1491            "from",
    1492            "full",
    1493            "group",
    1494            "grouping",
    1495            "groups",
    1496            "hash",
    1497            "having",
    1498            "if",
    1499            "ignore",
    1500            "in",
    1501            "inner",
    1502            "intersect",
    1503            "interval",
    1504            "into",
    1505            "is",
    1506            "join",
    1507            "lateral",
    1508            "left",
    1509            "like",
    1510            "limit",
    1511            "lookup",
    1512            "merge",
    1513            "natural",
    1514            "new",
    1515            "no",
    1516            "not",
    1517            "null",
    1518            "nulls",
    1519            "of",
    1520            "on",
    1521            "or",
    1522            "order",
    1523            "outer",
    1524            "over",
    1525            "partition",
    1526            "preceding",
    1527            "proto",
    1528            "qualify",
    1529            "range",
    1530            "recursive",
    1531            "respect",
    1532            "right",
    1533            "rollup",
    1534            "rows",
    1535            "select",
    1536            "set",
    1537            "some",
    1538            "struct",
    1539            "tablesample",
    1540            "then",
    1541            "to",
    1542            "treat",
    1543            "true",
    1544            "unbounded",
    1545            "union",
    1546            "unnest",
    1547            "using",
    1548            "when",
    1549            "where",
    1550            "window",
    1551            "with",
    1552            "within",
    1553        }
    1554
    1555        def datetrunc_sql(self, expression: exp.DateTrunc) -> str:
    1556            unit = expression.unit
    1557            unit_sql = unit.name if unit.is_string else self.sql(unit)
    1558            return self.func("DATE_TRUNC", expression.this, unit_sql, expression.args.get("zone"))
    1559
    1560        def mod_sql(self, expression: exp.Mod) -> str:
    1561            this = expression.this
    1562            expr = expression.expression
    1563            return self.func(
    1564                "MOD",
    1565                this.unnest() if isinstance(this, exp.Paren) else this,
    1566                expr.unnest() if isinstance(expr, exp.Paren) else expr,
    1567            )
    1568
    1569        def column_parts(self, expression: exp.Column) -> str:
    1570            if expression.meta.get("quoted_column"):
    1571                # If a column reference is of the form `dataset.table`.name, we need
    1572                # to preserve the quoted table path, otherwise the reference breaks
    1573                table_parts = ".".join(p.name for p in expression.parts[:-1])
    1574                table_path = self.sql(exp.Identifier(this=table_parts, quoted=True))
    1575                return f"{table_path}.{self.sql(expression, 'this')}"
    1576
    1577            return super().column_parts(expression)
    1578
    1579        def table_parts(self, expression: exp.Table) -> str:
    1580            # Depending on the context, `x.y` may not resolve to the same data source as `x`.`y`, so
    1581            # we need to make sure the correct quoting is used in each case.
    1582            #
    1583            # For example, if there is a CTE x that clashes with a schema name, then the former will
    1584            # return the table y in that schema, whereas the latter will return the CTE's y column:
    1585            #
    1586            # - WITH x AS (SELECT [1, 2] AS y) SELECT * FROM x, `x.y`   -> cross join
    1587            # - WITH x AS (SELECT [1, 2] AS y) SELECT * FROM x, `x`.`y` -> implicit unnest
    1588            if expression.meta.get("quoted_table"):
    1589                table_parts = ".".join(p.name for p in expression.parts)
    1590                return self.sql(exp.Identifier(this=table_parts, quoted=True))
    1591
    1592            return super().table_parts(expression)
    1593
    1594        def timetostr_sql(self, expression: exp.TimeToStr) -> str:
    1595            this = expression.this
    1596            if isinstance(this, exp.TsOrDsToDatetime):
    1597                func_name = "FORMAT_DATETIME"
    1598            elif isinstance(this, exp.TsOrDsToTimestamp):
    1599                func_name = "FORMAT_TIMESTAMP"
    1600            elif isinstance(this, exp.TsOrDsToTime):
    1601                func_name = "FORMAT_TIME"
    1602            else:
    1603                func_name = "FORMAT_DATE"
    1604
    1605            time_expr = this if isinstance(this, self.TS_OR_DS_TYPES) else expression
    1606            return self.func(
    1607                func_name, self.format_time(expression), time_expr.this, expression.args.get("zone")
    1608            )
    1609
    1610        def eq_sql(self, expression: exp.EQ) -> str:
    1611            # Operands of = cannot be NULL in BigQuery
    1612            if isinstance(expression.left, exp.Null) or isinstance(expression.right, exp.Null):
    1613                if not isinstance(expression.parent, exp.Update):
    1614                    return "NULL"
    1615
    1616            return self.binary(expression, "=")
    1617
    1618        def attimezone_sql(self, expression: exp.AtTimeZone) -> str:
    1619            parent = expression.parent
    1620
    1621            # BigQuery allows CAST(.. AS {STRING|TIMESTAMP} [FORMAT <fmt> [AT TIME ZONE <tz>]]).
    1622            # Only the TIMESTAMP one should use the below conversion, when AT TIME ZONE is included.
    1623            if not isinstance(parent, exp.Cast) or not parent.to.is_type("text"):
    1624                return self.func(
    1625                    "TIMESTAMP", self.func("DATETIME", expression.this, expression.args.get("zone"))
    1626                )
    1627
    1628            return super().attimezone_sql(expression)
    1629
    1630        def trycast_sql(self, expression: exp.TryCast) -> str:
    1631            return self.cast_sql(expression, safe_prefix="SAFE_")
    1632
    1633        def bracket_sql(self, expression: exp.Bracket) -> str:
    1634            this = expression.this
    1635            expressions = expression.expressions
    1636
    1637            if len(expressions) == 1 and this and this.is_type(exp.DataType.Type.STRUCT):
    1638                arg = expressions[0]
    1639                if arg.type is None:
    1640                    from sqlglot.optimizer.annotate_types import annotate_types
    1641
    1642                    arg = annotate_types(arg, dialect=self.dialect)
    1643
    1644                if arg.type and arg.type.this in exp.DataType.TEXT_TYPES:
    1645                    # BQ doesn't support bracket syntax with string values for structs
    1646                    return f"{self.sql(this)}.{arg.name}"
    1647
    1648            expressions_sql = self.expressions(expression, flat=True)
    1649            offset = expression.args.get("offset")
    1650
    1651            if offset == 0:
    1652                expressions_sql = f"OFFSET({expressions_sql})"
    1653            elif offset == 1:
    1654                expressions_sql = f"ORDINAL({expressions_sql})"
    1655            elif offset is not None:
    1656                self.unsupported(f"Unsupported array offset: {offset}")
    1657
    1658            if expression.args.get("safe"):
    1659                expressions_sql = f"SAFE_{expressions_sql}"
    1660
    1661            return f"{self.sql(this)}[{expressions_sql}]"
    1662
    1663        def in_unnest_op(self, expression: exp.Unnest) -> str:
    1664            return self.sql(expression)
    1665
    1666        def version_sql(self, expression: exp.Version) -> str:
    1667            if expression.name == "TIMESTAMP":
    1668                expression.set("this", "SYSTEM_TIME")
    1669            return super().version_sql(expression)
    1670
    1671        def contains_sql(self, expression: exp.Contains) -> str:
    1672            this = expression.this
    1673            expr = expression.expression
    1674
    1675            if isinstance(this, exp.Lower) and isinstance(expr, exp.Lower):
    1676                this = this.this
    1677                expr = expr.this
    1678
    1679            return self.func("CONTAINS_SUBSTR", this, expr, expression.args.get("json_scope"))
    1680
    1681        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
    1682            this = expression.this
    1683
    1684            # This ensures that inline type-annotated ARRAY literals like ARRAY<INT64>[1, 2, 3]
    1685            # are roundtripped unaffected. The inner check excludes ARRAY(SELECT ...) expressions,
    1686            # because they aren't literals and so the above syntax is invalid BigQuery.
    1687            if isinstance(this, exp.Array):
    1688                elem = seq_get(this.expressions, 0)
    1689                if not (elem and elem.find(exp.Query)):
    1690                    return f"{self.sql(expression, 'to')}{self.sql(this)}"
    1691
    1692            return super().cast_sql(expression, safe_prefix=safe_prefix)
    1693
    1694        def declareitem_sql(self, expression: exp.DeclareItem) -> str:
    1695            variables = self.expressions(expression, "this")
    1696            default = self.sql(expression, "default")
    1697            default = f" DEFAULT {default}" if default else ""
    1698            kind = self.sql(expression, "kind")
    1699            kind = f" {kind}" if kind else ""
    1700
    1701            return f"{variables}{kind}{default}"

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

###### Arguments:

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

INTERVAL_ALLOWS_PLURAL_FORM = False
JOIN_HINTS = False
QUERY_HINTS = False
TABLE_HINTS = False
LIMIT_FETCH = 'LIMIT'
RENAME_TABLE_WITH_DB = False
NVL2_SUPPORTED = False
UNNEST_WITH_ORDINALITY = False
COLLATE_IS_FUNC = True
LIMIT_ONLY_LITERALS = True
SUPPORTS_TABLE_ALIAS_COLUMNS = False
UNPIVOT_ALIASES_ARE_IDENTIFIERS = False
JSON_KEY_VALUE_PAIR_SEP = ','
NULL_ORDERING_SUPPORTED = False
IGNORE_NULLS_IN_FUNC = True
JSON_PATH_SINGLE_QUOTE_ESCAPE = True
CAN_IMPLEMENT_ARRAY_ANY = True
SUPPORTS_TO_NUMBER = False
NAMED_PLACEHOLDER_TOKEN = '@'
HEX_FUNC = 'TO_HEX'
WITH_PROPERTIES_PREFIX = 'OPTIONS'
SUPPORTS_EXPLODING_PROJECTIONS = False
EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE = False
SUPPORTS_UNIX_SECONDS = True
SAFE_JSON_PATH_KEY_RE = re.compile('^[_\\-a-zA-Z][\\-\\w]*$')
TS_OR_DS_TYPES = (<class 'sqlglot.expressions.TsOrDsToDatetime'>, <class 'sqlglot.expressions.TsOrDsToTimestamp'>, <class 'sqlglot.expressions.TsOrDsToTime'>, <class 'sqlglot.expressions.TsOrDsToDate'>)
TRANSFORMS = {<class 'sqlglot.expressions.JSONPathKey'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathRoot'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathSubscript'>: <function <lambda>>, <class 'sqlglot.expressions.AllowedValuesProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.AnalyzeColumns'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.AnalyzeWith'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ArrayContainsAll'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ArrayOverlaps'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.AutoRefreshProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.BackupProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CaseSpecificColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Ceil'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ClusteredColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CollateColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CommentColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ConnectByRoot'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ConvertToCharset'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CopyGrantsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CredentialsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DateFormatColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DefaultColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DynamicProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EmptyProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EncodeColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EnviromentProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EphemeralColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExcludeColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExecuteAsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Except'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExternalProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Floor'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Get'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.GlobalProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.HeapProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.IcebergProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InheritsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InlineLengthColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Intersect'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.IntervalSpan'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Int64'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.JSONBContainsAnyTopKeys'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.JSONBContainsAllTopKeys'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.JSONBDeleteAtPath'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LanguageProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LocationProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LogProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.MaterializedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NonClusteredColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NoPrimaryIndexProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NotForReplicationColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnCommitProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnUpdateColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Operator'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OutputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.PathColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.PartitionedByBucket'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.PartitionByTruncate'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.PivotAny'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.PositionalColumn'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ProjectionPolicyColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Put'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.RemoteWithConnectionModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ReturnsProperty'>: <function _returnsproperty_sql>, <class 'sqlglot.expressions.SampleProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SecureProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SecurityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SetConfigProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SetProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SettingsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SharingProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SqlReadWriteProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SqlSecurityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StabilityProperty'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.Stream'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StreamingTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StrictProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SwapTable'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TableColumn'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Tags'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TemporaryProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TitleColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ToMap'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ToTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransformModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransientProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Union'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UnloggedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UsingTemplateProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UsingData'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Uuid'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.UppercaseColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UtcDate'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UtcTime'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UtcTimestamp'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VarMap'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ViewAttributeProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VolatileProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WeekStart'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithJournalTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithProcedureOptions'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithSchemaBindingProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithOperator'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ForceProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ApproxTopK'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ApproxDistinct'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ArgMax'>: <function arg_max_or_min_no_count.<locals>._arg_max_or_min_sql>, <class 'sqlglot.expressions.ArgMin'>: <function arg_max_or_min_no_count.<locals>._arg_max_or_min_sql>, <class 'sqlglot.expressions.Array'>: <function inline_array_unless_query>, <class 'sqlglot.expressions.ArrayContains'>: <function _array_contains_sql>, <class 'sqlglot.expressions.ArrayFilter'>: <function filter_array_using_unnest>, <class 'sqlglot.expressions.ArrayRemove'>: <function filter_array_using_unnest>, <class 'sqlglot.expressions.BitwiseAndAgg'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.BitwiseOrAgg'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.BitwiseXorAgg'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.BitwiseCountAgg'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ByteLength'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Cast'>: <function preprocess.<locals>._to_sql>, <class 'sqlglot.expressions.CollateProperty'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.Commit'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.CountIf'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Create'>: <function _create_sql>, <class 'sqlglot.expressions.CTE'>: <function preprocess.<locals>._to_sql>, <class 'sqlglot.expressions.DateAdd'>: <function date_add_interval_sql.<locals>.func>, <class 'sqlglot.expressions.DateDiff'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.DateFromParts'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.DateStrToDate'>: <function datestrtodate_sql>, <class 'sqlglot.expressions.DateSub'>: <function date_add_interval_sql.<locals>.func>, <class 'sqlglot.expressions.DatetimeAdd'>: <function date_add_interval_sql.<locals>.func>, <class 'sqlglot.expressions.DatetimeSub'>: <function date_add_interval_sql.<locals>.func>, <class 'sqlglot.expressions.DateFromUnixDate'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.FromTimeZone'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.GenerateSeries'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.GroupConcat'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.Hex'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.HexString'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.If'>: <function if_sql.<locals>._if_sql>, <class 'sqlglot.expressions.ILike'>: <function no_ilike_sql>, <class 'sqlglot.expressions.IntDiv'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.JSONBool'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.JSONExtract'>: <function _json_extract_sql>, <class 'sqlglot.expressions.JSONExtractArray'>: <function _json_extract_sql>, <class 'sqlglot.expressions.JSONExtractScalar'>: <function _json_extract_sql>, <class 'sqlglot.expressions.JSONFormat'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.JSONKeysAtDepth'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.JSONValueArray'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Levenshtein'>: <function _levenshtein_sql>, <class 'sqlglot.expressions.Max'>: <function max_or_greatest>, <class 'sqlglot.expressions.MD5'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.MD5Digest'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Min'>: <function min_or_least>, <class 'sqlglot.expressions.Normalize'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.PartitionedByProperty'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.RegexpExtract'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.RegexpExtractAll'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.RegexpReplace'>: <function regexp_replace_sql>, <class 'sqlglot.expressions.RegexpLike'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Rollback'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.ParseTime'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.ParseDatetime'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.Select'>: <function preprocess.<locals>._to_sql>, <class 'sqlglot.expressions.SHA'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.SHA2'>: <function sha256_sql>, <class 'sqlglot.expressions.String'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.StrPosition'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.StrToDate'>: <function _str_to_datetime_sql>, <class 'sqlglot.expressions.StrToTime'>: <function _str_to_datetime_sql>, <class 'sqlglot.expressions.TimeAdd'>: <function date_add_interval_sql.<locals>.func>, <class 'sqlglot.expressions.TimeFromParts'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TimestampFromParts'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TimeSub'>: <function date_add_interval_sql.<locals>.func>, <class 'sqlglot.expressions.TimestampAdd'>: <function date_add_interval_sql.<locals>.func>, <class 'sqlglot.expressions.TimestampDiff'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TimestampSub'>: <function date_add_interval_sql.<locals>.func>, <class 'sqlglot.expressions.TimeStrToTime'>: <function timestrtotime_sql>, <class 'sqlglot.expressions.Transaction'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.TsOrDsAdd'>: <function _ts_or_ds_add_sql>, <class 'sqlglot.expressions.TsOrDsDiff'>: <function _ts_or_ds_diff_sql>, <class 'sqlglot.expressions.TsOrDsToTime'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TsOrDsToDatetime'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TsOrDsToTimestamp'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Unhex'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.UnixDate'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.UnixToTime'>: <function _unix_to_time_sql>, <class 'sqlglot.expressions.Values'>: <function _derived_table_values_to_unnest>, <class 'sqlglot.expressions.VariancePop'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.SafeDivide'>: <function rename_func.<locals>.<lambda>>}
SUPPORTED_JSON_PATH_PARTS = {<class 'sqlglot.expressions.JSONPathSubscript'>, <class 'sqlglot.expressions.JSONPathRoot'>, <class 'sqlglot.expressions.JSONPathKey'>}
TYPE_MAPPING = {<Type.DATETIME2: 'DATETIME2'>: 'TIMESTAMP', <Type.NCHAR: 'NCHAR'>: 'STRING', <Type.NVARCHAR: 'NVARCHAR'>: 'STRING', <Type.MEDIUMTEXT: 'MEDIUMTEXT'>: 'TEXT', <Type.LONGTEXT: 'LONGTEXT'>: 'TEXT', <Type.TINYTEXT: 'TINYTEXT'>: 'TEXT', <Type.BLOB: 'BLOB'>: 'BYTES', <Type.MEDIUMBLOB: 'MEDIUMBLOB'>: 'BLOB', <Type.LONGBLOB: 'LONGBLOB'>: 'BLOB', <Type.TINYBLOB: 'TINYBLOB'>: 'BLOB', <Type.INET: 'INET'>: 'INET', <Type.ROWVERSION: 'ROWVERSION'>: 'BYTES', <Type.SMALLDATETIME: 'SMALLDATETIME'>: 'TIMESTAMP', <Type.BIGDECIMAL: 'BIGDECIMAL'>: 'BIGNUMERIC', <Type.BIGINT: 'BIGINT'>: 'INT64', <Type.BINARY: 'BINARY'>: 'BYTES', <Type.BOOLEAN: 'BOOLEAN'>: 'BOOL', <Type.CHAR: 'CHAR'>: 'STRING', <Type.DECIMAL: 'DECIMAL'>: 'NUMERIC', <Type.DOUBLE: 'DOUBLE'>: 'FLOAT64', <Type.FLOAT: 'FLOAT'>: 'FLOAT64', <Type.INT: 'INT'>: 'INT64', <Type.SMALLINT: 'SMALLINT'>: 'INT64', <Type.TEXT: 'TEXT'>: 'STRING', <Type.TIMESTAMP: 'TIMESTAMP'>: 'DATETIME', <Type.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>: 'DATETIME', <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>: 'TIMESTAMP', <Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>: 'TIMESTAMP', <Type.TINYINT: 'TINYINT'>: 'INT64', <Type.UUID: 'UUID'>: 'STRING', <Type.VARBINARY: 'VARBINARY'>: 'BYTES', <Type.VARCHAR: 'VARCHAR'>: 'STRING', <Type.VARIANT: 'VARIANT'>: 'ANY TYPE'}
PROPERTIES_LOCATION = {<class 'sqlglot.expressions.AllowedValuesProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.AlgorithmProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.AutoIncrementProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.AutoRefreshProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.BackupProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.BlockCompressionProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.CharacterSetProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ChecksumProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.CollateProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.CopyGrantsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Cluster'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ClusteredByProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DistributedByProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DuplicateKeyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DataBlocksizeProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.DataDeletionProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DefinerProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.DictRange'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DictProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DynamicProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.DistKeyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DistStyleProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.EmptyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.EncodeProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.EngineProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.EnviromentProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ExecuteAsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ExternalProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.FallbackProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.FileFormatProperty'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.FreespaceProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.GlobalProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.HeapProperty'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.InheritsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.IcebergProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.IncludeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.InputModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.IsolatedLoadingProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.JournalProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.LanguageProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LikeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LocationProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LockProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LockingProperty'>: <Location.POST_ALIAS: 'POST_ALIAS'>, <class 'sqlglot.expressions.LogProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.MaterializedProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.MergeBlockRatioProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.NoPrimaryIndexProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.OnProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.OnCommitProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.Order'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.OutputModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PartitionedByProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PartitionedOfProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PrimaryKey'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Property'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.RemoteWithConnectionModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ReturnsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatDelimitedProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatSerdeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SampleProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SchemaCommentProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SecureProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.SecurityProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SerdeProperties'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Set'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SettingsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SetProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.SetConfigProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SharingProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.SequenceProperties'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.SortKeyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SqlReadWriteProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SqlSecurityProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.StabilityProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.StorageHandlerProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.StreamingTableProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.StrictProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Tags'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.TemporaryProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.ToTableProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.TransientProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.TransformModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.MergeTreeTTL'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.UnloggedProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.UsingTemplateProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ViewAttributeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.VolatileProperty'>: <Location.UNSUPPORTED: 'UNSUPPORTED'>, <class 'sqlglot.expressions.WithDataProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.WithJournalTableProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.WithProcedureOptions'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.WithSchemaBindingProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.WithSystemVersioningProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ForceProperty'>: <Location.POST_CREATE: 'POST_CREATE'>}
AFTER_HAVING_MODIFIER_TRANSFORMS = {'qualify': <function Generator.<lambda>>, 'windows': <function Generator.<lambda>>}
RESERVED_KEYWORDS = {'like', 'true', 'struct', 'cross', 'set', 'ignore', 'enum', 'and', 'with', 'at', 'from', 'union', 'exclude', 'collate', 'right', 'following', 'outer', 'current', 'where', 'cube', 'within', 'by', 'intersect', 'is', 'hash', 'when', 'escape', 'create', 'having', 'assert_rows_modified', 'all', 'false', 'null', 'window', 'join', 'array', 'new', 'to', 'proto', 'inner', 'lookup', 'left', 'cast', 'interval', 'default', 'fetch', 'qualify', 'group', 'grouping', 'as', 'case', 'if', 'in', 'limit', 'recursive', 'range', 'over', 'partition', 'unbounded', 'else', 'lateral', 'natural', 'of', 'extract', 'order', 'contains', 'exists', 'into', 'no', 'for', 'rollup', 'then', 'nulls', 'rows', 'preceding', 'some', 'or', 'groups', 'any', 'except', 'using', 'distinct', 'asc', 'treat', 'full', 'respect', 'merge', 'between', 'end', 'not', 'select', 'desc', 'on', 'unnest', 'tablesample', 'define'}
def datetrunc_sql(self, expression: sqlglot.expressions.DateTrunc) -> str: View Source

    1555        def datetrunc_sql(self, expression: exp.DateTrunc) -> str:
    1556            unit = expression.unit
    1557            unit_sql = unit.name if unit.is_string else self.sql(unit)
    1558            return self.func("DATE_TRUNC", expression.this, unit_sql, expression.args.get("zone"))

def mod_sql(self, expression: sqlglot.expressions.Mod) -> str: View Source

    1560        def mod_sql(self, expression: exp.Mod) -> str:
    1561            this = expression.this
    1562            expr = expression.expression
    1563            return self.func(
    1564                "MOD",
    1565                this.unnest() if isinstance(this, exp.Paren) else this,
    1566                expr.unnest() if isinstance(expr, exp.Paren) else expr,
    1567            )

def column_parts(self, expression: sqlglot.expressions.Column) -> str: View Source

    1569        def column_parts(self, expression: exp.Column) -> str:
    1570            if expression.meta.get("quoted_column"):
    1571                # If a column reference is of the form `dataset.table`.name, we need
    1572                # to preserve the quoted table path, otherwise the reference breaks
    1573                table_parts = ".".join(p.name for p in expression.parts[:-1])
    1574                table_path = self.sql(exp.Identifier(this=table_parts, quoted=True))
    1575                return f"{table_path}.{self.sql(expression, 'this')}"
    1576
    1577            return super().column_parts(expression)

def table_parts(self, expression: sqlglot.expressions.Table) -> str: View Source

    1579        def table_parts(self, expression: exp.Table) -> str:
    1580            # Depending on the context, `x.y` may not resolve to the same data source as `x`.`y`, so
    1581            # we need to make sure the correct quoting is used in each case.
    1582            #
    1583            # For example, if there is a CTE x that clashes with a schema name, then the former will
    1584            # return the table y in that schema, whereas the latter will return the CTE's y column:
    1585            #
    1586            # - WITH x AS (SELECT [1, 2] AS y) SELECT * FROM x, `x.y`   -> cross join
    1587            # - WITH x AS (SELECT [1, 2] AS y) SELECT * FROM x, `x`.`y` -> implicit unnest
    1588            if expression.meta.get("quoted_table"):
    1589                table_parts = ".".join(p.name for p in expression.parts)
    1590                return self.sql(exp.Identifier(this=table_parts, quoted=True))
    1591
    1592            return super().table_parts(expression)

def timetostr_sql(self, expression: sqlglot.expressions.TimeToStr) -> str: View Source

    1594        def timetostr_sql(self, expression: exp.TimeToStr) -> str:
    1595            this = expression.this
    1596            if isinstance(this, exp.TsOrDsToDatetime):
    1597                func_name = "FORMAT_DATETIME"
    1598            elif isinstance(this, exp.TsOrDsToTimestamp):
    1599                func_name = "FORMAT_TIMESTAMP"
    1600            elif isinstance(this, exp.TsOrDsToTime):
    1601                func_name = "FORMAT_TIME"
    1602            else:
    1603                func_name = "FORMAT_DATE"
    1604
    1605            time_expr = this if isinstance(this, self.TS_OR_DS_TYPES) else expression
    1606            return self.func(
    1607                func_name, self.format_time(expression), time_expr.this, expression.args.get("zone")
    1608            )

def eq_sql(self, expression: sqlglot.expressions.EQ) -> str: View Source

    1610        def eq_sql(self, expression: exp.EQ) -> str:
    1611            # Operands of = cannot be NULL in BigQuery
    1612            if isinstance(expression.left, exp.Null) or isinstance(expression.right, exp.Null):
    1613                if not isinstance(expression.parent, exp.Update):
    1614                    return "NULL"
    1615
    1616            return self.binary(expression, "=")

def attimezone_sql(self, expression: sqlglot.expressions.AtTimeZone) -> str: View Source

    1618        def attimezone_sql(self, expression: exp.AtTimeZone) -> str:
    1619            parent = expression.parent
    1620
    1621            # BigQuery allows CAST(.. AS {STRING|TIMESTAMP} [FORMAT <fmt> [AT TIME ZONE <tz>]]).
    1622            # Only the TIMESTAMP one should use the below conversion, when AT TIME ZONE is included.
    1623            if not isinstance(parent, exp.Cast) or not parent.to.is_type("text"):
    1624                return self.func(
    1625                    "TIMESTAMP", self.func("DATETIME", expression.this, expression.args.get("zone"))
    1626                )
    1627
    1628            return super().attimezone_sql(expression)

def trycast_sql(self, expression: sqlglot.expressions.TryCast) -> str: View Source

    1630        def trycast_sql(self, expression: exp.TryCast) -> str:
    1631            return self.cast_sql(expression, safe_prefix="SAFE_")

def bracket_sql(self, expression: sqlglot.expressions.Bracket) -> str: View Source

    1633        def bracket_sql(self, expression: exp.Bracket) -> str:
    1634            this = expression.this
    1635            expressions = expression.expressions
    1636
    1637            if len(expressions) == 1 and this and this.is_type(exp.DataType.Type.STRUCT):
    1638                arg = expressions[0]
    1639                if arg.type is None:
    1640                    from sqlglot.optimizer.annotate_types import annotate_types
    1641
    1642                    arg = annotate_types(arg, dialect=self.dialect)
    1643
    1644                if arg.type and arg.type.this in exp.DataType.TEXT_TYPES:
    1645                    # BQ doesn't support bracket syntax with string values for structs
    1646                    return f"{self.sql(this)}.{arg.name}"
    1647
    1648            expressions_sql = self.expressions(expression, flat=True)
    1649            offset = expression.args.get("offset")
    1650
    1651            if offset == 0:
    1652                expressions_sql = f"OFFSET({expressions_sql})"
    1653            elif offset == 1:
    1654                expressions_sql = f"ORDINAL({expressions_sql})"
    1655            elif offset is not None:
    1656                self.unsupported(f"Unsupported array offset: {offset}")
    1657
    1658            if expression.args.get("safe"):
    1659                expressions_sql = f"SAFE_{expressions_sql}"
    1660
    1661            return f"{self.sql(this)}[{expressions_sql}]"

def in_unnest_op(self, expression: sqlglot.expressions.Unnest) -> str: View Source

    1663        def in_unnest_op(self, expression: exp.Unnest) -> str:
    1664            return self.sql(expression)

def version_sql(self, expression: sqlglot.expressions.Version) -> str: View Source

    1666        def version_sql(self, expression: exp.Version) -> str:
    1667            if expression.name == "TIMESTAMP":
    1668                expression.set("this", "SYSTEM_TIME")
    1669            return super().version_sql(expression)

def contains_sql(self, expression: sqlglot.expressions.Contains) -> str: View Source

    1671        def contains_sql(self, expression: exp.Contains) -> str:
    1672            this = expression.this
    1673            expr = expression.expression
    1674
    1675            if isinstance(this, exp.Lower) and isinstance(expr, exp.Lower):
    1676                this = this.this
    1677                expr = expr.this
    1678
    1679            return self.func("CONTAINS_SUBSTR", this, expr, expression.args.get("json_scope"))

def cast_sql( self, expression: sqlglot.expressions.Cast, safe_prefix: Optional[str] = None) -> str: View Source

    1681        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
    1682            this = expression.this
    1683
    1684            # This ensures that inline type-annotated ARRAY literals like ARRAY<INT64>[1, 2, 3]
    1685            # are roundtripped unaffected. The inner check excludes ARRAY(SELECT ...) expressions,
    1686            # because they aren't literals and so the above syntax is invalid BigQuery.
    1687            if isinstance(this, exp.Array):
    1688                elem = seq_get(this.expressions, 0)
    1689                if not (elem and elem.find(exp.Query)):
    1690                    return f"{self.sql(expression, 'to')}{self.sql(this)}"
    1691
    1692            return super().cast_sql(expression, safe_prefix=safe_prefix)

def declareitem_sql(self, expression: sqlglot.expressions.DeclareItem) -> str: View Source

    1694        def declareitem_sql(self, expression: exp.DeclareItem) -> str:
    1695            variables = self.expressions(expression, "this")
    1696            default = self.sql(expression, "default")
    1697            default = f" DEFAULT {default}" if default else ""
    1698            kind = self.sql(expression, "kind")
    1699            kind = f" {kind}" if kind else ""
    1700
    1701            return f"{variables}{kind}{default}"

TRY_SUPPORTED = False
SUPPORTS_UESCAPE = False
SUPPORTS_DECODE_CASE = False

##### Inherited Members

sqlglot.generator.Generator
  Generator
  LOCKING_READS_SUPPORTED
  WRAP_DERIVED_VALUES
  CREATE_FUNCTION_RETURN_AS
  MATCHED_BY_SOURCE
  SINGLE_STRING_INTERVAL
  GROUPINGS_SEP
  INDEX_ON
  QUERY_HINT_SEP
  IS_BOOL_ALLOWED
  DUPLICATE_KEY_UPDATE_WITH_SET
  LIMIT_IS_TOP
  RETURNING_END
  EXTRACT_ALLOWS_QUOTES
  TZ_TO_WITH_TIME_ZONE
  SELECT_KINDS
  VALUES_AS_TABLE
  ALTER_TABLE_INCLUDE_COLUMN_KEYWORD
  AGGREGATE_FILTER_SUPPORTED
  SEMI_ANTI_JOIN_WITH_SIDE
  COMPUTED_COLUMN_WITH_TYPE
  SUPPORTS_TABLE_COPY
  TABLESAMPLE_REQUIRES_PARENS
  TABLESAMPLE_SIZE_IS_ROWS
  TABLESAMPLE_KEYWORDS
  TABLESAMPLE_WITH_METHOD
  TABLESAMPLE_SEED_KEYWORD
  DATA_TYPE_SPECIFIERS_ALLOWED
  ENSURE_BOOLS
  CTE_RECURSIVE_KEYWORD_REQUIRED
  SUPPORTS_SINGLE_ARG_CONCAT
  LAST_DAY_SUPPORTS_DATE_PART
  INSERT_OVERWRITE
  SUPPORTS_SELECT_INTO
  SUPPORTS_UNLOGGED_TABLES
  SUPPORTS_CREATE_TABLE_LIKE
  LIKE_PROPERTY_INSIDE_SCHEMA
  MULTI_ARG_DISTINCT
  JSON_TYPE_REQUIRED_FOR_EXTRACTION
  JSON_PATH_BRACKETED_KEY_SUPPORTED
  SUPPORTS_WINDOW_EXCLUDE
  SET_OP_MODIFIERS
  COPY_PARAMS_ARE_WRAPPED
  COPY_PARAMS_EQ_REQUIRED
  COPY_HAS_INTO_KEYWORD
  UNICODE_SUBSTITUTE
  STAR_EXCEPT
  QUOTE_JSON_PATH
  PAD_FILL_PATTERN_IS_REQUIRED
  ARRAY_CONCAT_IS_VAR_LEN
  SUPPORTS_CONVERT_TIMEZONE
  SUPPORTS_MEDIAN
  ALTER_SET_WRAPPED
  NORMALIZE_EXTRACT_DATE_PARTS
  PARSE_JSON_NAME
  ARRAY_SIZE_NAME
  ALTER_SET_TYPE
  ARRAY_SIZE_DIM_REQUIRED
  SUPPORTS_BETWEEN_FLAGS
  SUPPORTS_LIKE_QUANTIFIERS
  MATCH_AGAINST_TABLE_PREFIX
  UNSUPPORTED_TYPES
  TIME_PART_SINGULARS
  TOKEN_MAPPING
  STRUCT_DELIMITER
  PARAMETER_TOKEN
  EXPRESSION_PRECEDES_PROPERTIES_CREATABLES
  WITH_SEPARATED_COMMENTS
  EXCLUDE_COMMENTS
  UNWRAPPED_INTERVAL_VALUES
  PARAMETERIZABLE_TEXT_TYPES
  EXPRESSIONS_WITHOUT_NESTED_CTES
  RESPECT_IGNORE_NULLS_UNSUPPORTED_EXPRESSIONS
  SENTINEL_LINE_BREAK
  pretty
  identify
  normalize
  pad
  unsupported_level
  max_unsupported
  leading_comma
  max_text_width
  comments
  dialect
  normalize_functions
  unsupported_messages
  generate
  preprocess
  unsupported
  sep
  seg
  sanitize_comment
  maybe_comment
  wrap
  no_identify
  normalize_func
  indent
  sql
  uncache_sql
  cache_sql
  characterset_sql
  column_sql
  columnposition_sql
  columndef_sql
  columnconstraint_sql
  computedcolumnconstraint_sql
  autoincrementcolumnconstraint_sql
  compresscolumnconstraint_sql
  generatedasidentitycolumnconstraint_sql
  generatedasrowcolumnconstraint_sql
  periodforsystemtimeconstraint_sql
  notnullcolumnconstraint_sql
  primarykeycolumnconstraint_sql
  uniquecolumnconstraint_sql
  createable_sql
  create_sql
  sequenceproperties_sql
  clone_sql
  describe_sql
  heredoc_sql
  prepend_ctes
  with_sql
  cte_sql
  tablealias_sql
  bitstring_sql
  hexstring_sql
  bytestring_sql
  unicodestring_sql
  rawstring_sql
  datatypeparam_sql
  datatype_sql
  directory_sql
  delete_sql
  drop_sql
  set_operation
  set_operations
  fetch_sql
  limitoptions_sql
  filter_sql
  hint_sql
  indexparameters_sql
  index_sql
  identifier_sql
  hex_sql
  lowerhex_sql
  inputoutputformat_sql
  national_sql
  partition_sql
  properties_sql
  root_properties
  properties
  with_properties
  locate_properties
  property_name
  property_sql
  likeproperty_sql
  fallbackproperty_sql
  journalproperty_sql
  freespaceproperty_sql
  checksumproperty_sql
  mergeblockratioproperty_sql
  datablocksizeproperty_sql
  blockcompressionproperty_sql
  isolatedloadingproperty_sql
  partitionboundspec_sql
  partitionedofproperty_sql
  lockingproperty_sql
  withdataproperty_sql
  withsystemversioningproperty_sql
  insert_sql
  introducer_sql
  kill_sql
  pseudotype_sql
  objectidentifier_sql
  onconflict_sql
  returning_sql
  rowformatdelimitedproperty_sql
  withtablehint_sql
  indextablehint_sql
  historicaldata_sql
  table_sql
  tablefromrows_sql
  tablesample_sql
  pivot_sql
  tuple_sql
  update_sql
  values_sql
  var_sql
  into_sql
  from_sql
  groupingsets_sql
  rollup_sql
  cube_sql
  group_sql
  having_sql
  connect_sql
  prior_sql
  join_sql
  lambda_sql
  lateral_op
  lateral_sql
  limit_sql
  offset_sql
  setitem_sql
  set_sql
  queryband_sql
  pragma_sql
  lock_sql
  literal_sql
  escape_str
  loaddata_sql
  null_sql
  boolean_sql
  order_sql
  withfill_sql
  cluster_sql
  distribute_sql
  sort_sql
  ordered_sql
  matchrecognizemeasure_sql
  matchrecognize_sql
  query_modifiers
  options_modifier
  for_modifiers
  queryoption_sql
  offset_limit_modifiers
  after_limit_modifiers
  select_sql
  schema_sql
  schema_columns_sql
  star_sql
  parameter_sql
  sessionparameter_sql
  placeholder_sql
  subquery_sql
  qualify_sql
  unnest_sql
  prewhere_sql
  where_sql
  window_sql
  partition_by_sql
  windowspec_sql
  withingroup_sql
  between_sql
  bracket_offset_expressions
  all_sql
  any_sql
  exists_sql
  case_sql
  constraint_sql
  nextvaluefor_sql
  extract_sql
  trim_sql
  convert_concat_args
  concat_sql
  concatws_sql
  check_sql
  foreignkey_sql
  primarykey_sql
  if_sql
  matchagainst_sql
  jsonkeyvalue_sql
  jsonpath_sql
  json_path_part
  formatjson_sql
  formatphrase_sql
  jsonobject_sql
  jsonobjectagg_sql
  jsonarray_sql
  jsonarrayagg_sql
  jsoncolumndef_sql
  jsonschema_sql
  jsontable_sql
  openjsoncolumndef_sql
  openjson_sql
  in_sql
  interval_sql
  return_sql
  reference_sql
  anonymous_sql
  paren_sql
  neg_sql
  not_sql
  alias_sql
  pivotalias_sql
  aliases_sql
  atindex_sql
  fromtimezone_sql
  add_sql
  and_sql
  or_sql
  xor_sql
  connector_sql
  bitwiseand_sql
  bitwiseleftshift_sql
  bitwisenot_sql
  bitwiseor_sql
  bitwiserightshift_sql
  bitwisexor_sql
  currentdate_sql
  collate_sql
  command_sql
  comment_sql
  mergetreettlaction_sql
  mergetreettl_sql
  transaction_sql
  commit_sql
  rollback_sql
  altercolumn_sql
  alterindex_sql
  alterdiststyle_sql
  altersortkey_sql
  alterrename_sql
  renamecolumn_sql
  alterset_sql
  alter_sql
  altersession_sql
  add_column_sql
  droppartition_sql
  addconstraint_sql
  addpartition_sql
  distinct_sql
  ignorenulls_sql
  respectnulls_sql
  havingmax_sql
  intdiv_sql
  dpipe_sql
  div_sql
  safedivide_sql
  overlaps_sql
  distance_sql
  dot_sql
  propertyeq_sql
  escape_sql
  glob_sql
  gt_sql
  gte_sql
  is_sql
  like_sql
  ilike_sql
  similarto_sql
  lt_sql
  lte_sql
  mul_sql
  neq_sql
  nullsafeeq_sql
  nullsafeneq_sql
  slice_sql
  sub_sql
  jsoncast_sql
  try_sql
  log_sql
  use_sql
  binary
  ceil_floor
  function_fallback_sql
  func
  format_args
  too_wide
  format_time
  expressions
  op_expressions
  naked_property
  tag_sql
  token_sql
  userdefinedfunction_sql
  joinhint_sql
  kwarg_sql
  when_sql
  whens_sql
  merge_sql
  tochar_sql
  tonumber_sql
  dictproperty_sql
  dictrange_sql
  dictsubproperty_sql
  duplicatekeyproperty_sql
  uniquekeyproperty_sql
  distributedbyproperty_sql
  oncluster_sql
  clusteredbyproperty_sql
  anyvalue_sql
  querytransform_sql
  indexconstraintoption_sql
  checkcolumnconstraint_sql
  indexcolumnconstraint_sql
  nvl2_sql
  comprehension_sql
  columnprefix_sql
  opclass_sql
  predict_sql
  generateembedding_sql
  mltranslate_sql
  mlforecast_sql
  featuresattime_sql
  vectorsearch_sql
  forin_sql
  refresh_sql
  toarray_sql
  tsordstotime_sql
  tsordstotimestamp_sql
  tsordstodatetime_sql
  tsordstodate_sql
  unixdate_sql
  lastday_sql
  dateadd_sql
  arrayany_sql
  struct_sql
  partitionrange_sql
  truncatetable_sql
  convert_sql
  copyparameter_sql
  credentials_sql
  copy_sql
  semicolon_sql
  datadeletionproperty_sql
  maskingpolicycolumnconstraint_sql
  gapfill_sql
  scope_resolution
  scoperesolution_sql
  parsejson_sql
  rand_sql
  changes_sql
  pad_sql
  summarize_sql
  explodinggenerateseries_sql
  arrayconcat_sql
  converttimezone_sql
  json_sql
  jsonvalue_sql
  conditionalinsert_sql
  multitableinserts_sql
  oncondition_sql
  jsonextractquote_sql
  jsonexists_sql
  arrayagg_sql
  apply_sql
  grant_sql
  revoke_sql
  grantprivilege_sql
  grantprincipal_sql
  columns_sql
  overlay_sql
  todouble_sql
  string_sql
  median_sql
  overflowtruncatebehavior_sql
  unixseconds_sql
  arraysize_sql
  attach_sql
  detach_sql
  attachoption_sql
  watermarkcolumnconstraint_sql
  encodeproperty_sql
  includeproperty_sql
  xmlelement_sql
  xmlkeyvalueoption_sql
  partitionbyrangeproperty_sql
  partitionbyrangepropertydynamic_sql
  unpivotcolumns_sql
  analyzesample_sql
  analyzestatistics_sql
  analyzehistogram_sql
  analyzedelete_sql
  analyzelistchainedrows_sql
  analyzevalidate_sql
  analyze_sql
  xmltable_sql
  xmlnamespace_sql
  export_sql
  declare_sql
  recursivewithsearch_sql
  parameterizedagg_sql
  anonymousaggfunc_sql
  combinedaggfunc_sql
  combinedparameterizedagg_sql
  show_sql
  install_sql
  get_put_sql
  translatecharacters_sql
  decodecase_sql
  semanticview_sql
  getextract_sql
  datefromunixdate_sql
  space_sql
  buildproperty_sql
  refreshtriggerproperty_sql
  modelattribute_sql