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
      7from sqlglot import exp, generator, parser, tokens, transforms
      8from sqlglot.dialects.dialect import (
      9    Dialect,
     10    NormalizationStrategy,
     11    arg_max_or_min_no_count,
     12    binary_from_function,
     13    date_add_interval_sql,
     14    datestrtodate_sql,
     15    format_time_lambda,
     16    if_sql,
     17    inline_array_sql,
     18    max_or_greatest,
     19    min_or_least,
     20    no_ilike_sql,
     21    parse_date_delta_with_interval,
     22    regexp_replace_sql,
     23    rename_func,
     24    timestrtotime_sql,
     25    ts_or_ds_add_cast,
     26)
     27from sqlglot.helper import seq_get, split_num_words
     28from sqlglot.tokens import TokenType
     29
     30if t.TYPE_CHECKING:
     31    from sqlglot._typing import E, Lit
     32
     33logger = logging.getLogger("sqlglot")
     34
     35
     36def _derived_table_values_to_unnest(self: BigQuery.Generator, expression: exp.Values) -> str:
     37    if not expression.find_ancestor(exp.From, exp.Join):
     38        return self.values_sql(expression)
     39
     40    alias = expression.args.get("alias")
     41
     42    return self.unnest_sql(
     43        exp.Unnest(
     44            expressions=[
     45                exp.array(
     46                    *(
     47                        exp.Struct(
     48                            expressions=[
     49                                exp.alias_(value, column_name)
     50                                for value, column_name in zip(
     51                                    t.expressions,
     52                                    (
     53                                        alias.columns
     54                                        if alias and alias.columns
     55                                        else (f"_c{i}" for i in range(len(t.expressions)))
     56                                    ),
     57                                )
     58                            ]
     59                        )
     60                        for t in expression.find_all(exp.Tuple)
     61                    ),
     62                    copy=False,
     63                )
     64            ]
     65        )
     66    )
     67
     68
     69def _returnsproperty_sql(self: BigQuery.Generator, expression: exp.ReturnsProperty) -> str:
     70    this = expression.this
     71    if isinstance(this, exp.Schema):
     72        this = f"{this.this} <{self.expressions(this)}>"
     73    else:
     74        this = self.sql(this)
     75    return f"RETURNS {this}"
     76
     77
     78def _create_sql(self: BigQuery.Generator, expression: exp.Create) -> str:
     79    kind = expression.args["kind"]
     80    returns = expression.find(exp.ReturnsProperty)
     81
     82    if kind.upper() == "FUNCTION" and returns and returns.args.get("is_table"):
     83        expression.set("kind", "TABLE FUNCTION")
     84
     85        if isinstance(expression.expression, (exp.Subquery, exp.Literal)):
     86            expression.set("expression", expression.expression.this)
     87
     88        return self.create_sql(expression)
     89
     90    return self.create_sql(expression)
     91
     92
     93def _unqualify_unnest(expression: exp.Expression) -> exp.Expression:
     94    """Remove references to unnest table aliases since bigquery doesn't allow them.
     95
     96    These are added by the optimizer's qualify_column step.
     97    """
     98    from sqlglot.optimizer.scope import find_all_in_scope
     99
    100    if isinstance(expression, exp.Select):
    101        unnest_aliases = {
    102            unnest.alias
    103            for unnest in find_all_in_scope(expression, exp.Unnest)
    104            if isinstance(unnest.parent, (exp.From, exp.Join))
    105        }
    106        if unnest_aliases:
    107            for column in expression.find_all(exp.Column):
    108                if column.table in unnest_aliases:
    109                    column.set("table", None)
    110                elif column.db in unnest_aliases:
    111                    column.set("db", None)
    112
    113    return expression
    114
    115
    116# https://issuetracker.google.com/issues/162294746
    117# workaround for bigquery bug when grouping by an expression and then ordering
    118# WITH x AS (SELECT 1 y)
    119# SELECT y + 1 z
    120# FROM x
    121# GROUP BY x + 1
    122# ORDER by z
    123def _alias_ordered_group(expression: exp.Expression) -> exp.Expression:
    124    if isinstance(expression, exp.Select):
    125        group = expression.args.get("group")
    126        order = expression.args.get("order")
    127
    128        if group and order:
    129            aliases = {
    130                select.this: select.args["alias"]
    131                for select in expression.selects
    132                if isinstance(select, exp.Alias)
    133            }
    134
    135            for e in group.expressions:
    136                alias = aliases.get(e)
    137
    138                if alias:
    139                    e.replace(exp.column(alias))
    140
    141    return expression
    142
    143
    144def _pushdown_cte_column_names(expression: exp.Expression) -> exp.Expression:
    145    """BigQuery doesn't allow column names when defining a CTE, so we try to push them down."""
    146    if isinstance(expression, exp.CTE) and expression.alias_column_names:
    147        cte_query = expression.this
    148
    149        if cte_query.is_star:
    150            logger.warning(
    151                "Can't push down CTE column names for star queries. Run the query through"
    152                " the optimizer or use 'qualify' to expand the star projections first."
    153            )
    154            return expression
    155
    156        column_names = expression.alias_column_names
    157        expression.args["alias"].set("columns", None)
    158
    159        for name, select in zip(column_names, cte_query.selects):
    160            to_replace = select
    161
    162            if isinstance(select, exp.Alias):
    163                select = select.this
    164
    165            # Inner aliases are shadowed by the CTE column names
    166            to_replace.replace(exp.alias_(select, name))
    167
    168    return expression
    169
    170
    171def _parse_parse_timestamp(args: t.List) -> exp.StrToTime:
    172    this = format_time_lambda(exp.StrToTime, "bigquery")([seq_get(args, 1), seq_get(args, 0)])
    173    this.set("zone", seq_get(args, 2))
    174    return this
    175
    176
    177def _parse_timestamp(args: t.List) -> exp.Timestamp:
    178    timestamp = exp.Timestamp.from_arg_list(args)
    179    timestamp.set("with_tz", True)
    180    return timestamp
    181
    182
    183def _parse_date(args: t.List) -> exp.Date | exp.DateFromParts:
    184    expr_type = exp.DateFromParts if len(args) == 3 else exp.Date
    185    return expr_type.from_arg_list(args)
    186
    187
    188def _parse_to_hex(args: t.List) -> exp.Hex | exp.MD5:
    189    # TO_HEX(MD5(..)) is common in BigQuery, so it's parsed into MD5 to simplify its transpilation
    190    arg = seq_get(args, 0)
    191    return exp.MD5(this=arg.this) if isinstance(arg, exp.MD5Digest) else exp.Hex(this=arg)
    192
    193
    194def _array_contains_sql(self: BigQuery.Generator, expression: exp.ArrayContains) -> str:
    195    return self.sql(
    196        exp.Exists(
    197            this=exp.select("1")
    198            .from_(exp.Unnest(expressions=[expression.left]).as_("_unnest", table=["_col"]))
    199            .where(exp.column("_col").eq(expression.right))
    200        )
    201    )
    202
    203
    204def _ts_or_ds_add_sql(self: BigQuery.Generator, expression: exp.TsOrDsAdd) -> str:
    205    return date_add_interval_sql("DATE", "ADD")(self, ts_or_ds_add_cast(expression))
    206
    207
    208def _ts_or_ds_diff_sql(self: BigQuery.Generator, expression: exp.TsOrDsDiff) -> str:
    209    expression.this.replace(exp.cast(expression.this, "TIMESTAMP", copy=True))
    210    expression.expression.replace(exp.cast(expression.expression, "TIMESTAMP", copy=True))
    211    unit = expression.args.get("unit") or "DAY"
    212    return self.func("DATE_DIFF", expression.this, expression.expression, unit)
    213
    214
    215def _unix_to_time_sql(self: BigQuery.Generator, expression: exp.UnixToTime) -> str:
    216    scale = expression.args.get("scale")
    217    timestamp = self.sql(expression, "this")
    218    if scale in (None, exp.UnixToTime.SECONDS):
    219        return f"TIMESTAMP_SECONDS({timestamp})"
    220    if scale == exp.UnixToTime.MILLIS:
    221        return f"TIMESTAMP_MILLIS({timestamp})"
    222    if scale == exp.UnixToTime.MICROS:
    223        return f"TIMESTAMP_MICROS({timestamp})"
    224
    225    return f"TIMESTAMP_SECONDS(CAST({timestamp} / POW(10, {scale}) AS INT64))"
    226
    227
    228def _parse_time(args: t.List) -> exp.Func:
    229    if len(args) == 1:
    230        return exp.TsOrDsToTime(this=args[0])
    231    if len(args) == 3:
    232        return exp.TimeFromParts.from_arg_list(args)
    233
    234    return exp.Anonymous(this="TIME", expressions=args)
    235
    236
    237class BigQuery(Dialect):
    238    WEEK_OFFSET = -1
    239    UNNEST_COLUMN_ONLY = True
    240    SUPPORTS_USER_DEFINED_TYPES = False
    241    SUPPORTS_SEMI_ANTI_JOIN = False
    242    LOG_BASE_FIRST = False
    243
    244    # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#case_sensitivity
    245    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
    246
    247    # bigquery udfs are case sensitive
    248    NORMALIZE_FUNCTIONS = False
    249
    250    TIME_MAPPING = {
    251        "%D": "%m/%d/%y",
    252    }
    253
    254    ESCAPE_SEQUENCES = {
    255        "\\a": "\a",
    256        "\\b": "\b",
    257        "\\f": "\f",
    258        "\\n": "\n",
    259        "\\r": "\r",
    260        "\\t": "\t",
    261        "\\v": "\v",
    262    }
    263
    264    FORMAT_MAPPING = {
    265        "DD": "%d",
    266        "MM": "%m",
    267        "MON": "%b",
    268        "MONTH": "%B",
    269        "YYYY": "%Y",
    270        "YY": "%y",
    271        "HH": "%I",
    272        "HH12": "%I",
    273        "HH24": "%H",
    274        "MI": "%M",
    275        "SS": "%S",
    276        "SSSSS": "%f",
    277        "TZH": "%z",
    278    }
    279
    280    # The _PARTITIONTIME and _PARTITIONDATE pseudo-columns are not returned by a SELECT * statement
    281    # https://cloud.google.com/bigquery/docs/querying-partitioned-tables#query_an_ingestion-time_partitioned_table
    282    PSEUDOCOLUMNS = {"_PARTITIONTIME", "_PARTITIONDATE"}
    283
    284    def normalize_identifier(self, expression: E) -> E:
    285        if isinstance(expression, exp.Identifier):
    286            parent = expression.parent
    287            while isinstance(parent, exp.Dot):
    288                parent = parent.parent
    289
    290            # In BigQuery, CTEs aren't case-sensitive, but table names are (by default, at least).
    291            # The following check is essentially a heuristic to detect tables based on whether or
    292            # not they're qualified. It also avoids normalizing UDFs, because they're case-sensitive.
    293            if (
    294                not isinstance(parent, exp.UserDefinedFunction)
    295                and not (isinstance(parent, exp.Table) and parent.db)
    296                and not expression.meta.get("is_table")
    297            ):
    298                expression.set("this", expression.this.lower())
    299
    300        return expression
    301
    302    class Tokenizer(tokens.Tokenizer):
    303        QUOTES = ["'", '"', '"""', "'''"]
    304        COMMENTS = ["--", "#", ("/*", "*/")]
    305        IDENTIFIERS = ["`"]
    306        STRING_ESCAPES = ["\\"]
    307
    308        HEX_STRINGS = [("0x", ""), ("0X", "")]
    309
    310        BYTE_STRINGS = [
    311            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("b", "B")
    312        ]
    313
    314        RAW_STRINGS = [
    315            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("r", "R")
    316        ]
    317
    318        KEYWORDS = {
    319            **tokens.Tokenizer.KEYWORDS,
    320            "ANY TYPE": TokenType.VARIANT,
    321            "BEGIN": TokenType.COMMAND,
    322            "BEGIN TRANSACTION": TokenType.BEGIN,
    323            "BYTES": TokenType.BINARY,
    324            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
    325            "DECLARE": TokenType.COMMAND,
    326            "FLOAT64": TokenType.DOUBLE,
    327            "FOR SYSTEM_TIME": TokenType.TIMESTAMP_SNAPSHOT,
    328            "MODEL": TokenType.MODEL,
    329            "NOT DETERMINISTIC": TokenType.VOLATILE,
    330            "RECORD": TokenType.STRUCT,
    331            "TIMESTAMP": TokenType.TIMESTAMPTZ,
    332        }
    333        KEYWORDS.pop("DIV")
    334        KEYWORDS.pop("VALUES")
    335
    336    class Parser(parser.Parser):
    337        PREFIXED_PIVOT_COLUMNS = True
    338
    339        LOG_DEFAULTS_TO_LN = True
    340
    341        FUNCTIONS = {
    342            **parser.Parser.FUNCTIONS,
    343            "DATE": _parse_date,
    344            "DATE_ADD": parse_date_delta_with_interval(exp.DateAdd),
    345            "DATE_SUB": parse_date_delta_with_interval(exp.DateSub),
    346            "DATE_TRUNC": lambda args: exp.DateTrunc(
    347                unit=exp.Literal.string(str(seq_get(args, 1))),
    348                this=seq_get(args, 0),
    349            ),
    350            "DATETIME_ADD": parse_date_delta_with_interval(exp.DatetimeAdd),
    351            "DATETIME_SUB": parse_date_delta_with_interval(exp.DatetimeSub),
    352            "DIV": binary_from_function(exp.IntDiv),
    353            "FORMAT_DATE": lambda args: exp.TimeToStr(
    354                this=exp.TsOrDsToDate(this=seq_get(args, 1)), format=seq_get(args, 0)
    355            ),
    356            "GENERATE_ARRAY": exp.GenerateSeries.from_arg_list,
    357            "JSON_EXTRACT_SCALAR": lambda args: exp.JSONExtractScalar(
    358                this=seq_get(args, 0), expression=seq_get(args, 1) or exp.Literal.string("$")
    359            ),
    360            "MD5": exp.MD5Digest.from_arg_list,
    361            "TO_HEX": _parse_to_hex,
    362            "PARSE_DATE": lambda args: format_time_lambda(exp.StrToDate, "bigquery")(
    363                [seq_get(args, 1), seq_get(args, 0)]
    364            ),
    365            "PARSE_TIMESTAMP": _parse_parse_timestamp,
    366            "REGEXP_CONTAINS": exp.RegexpLike.from_arg_list,
    367            "REGEXP_EXTRACT": lambda args: exp.RegexpExtract(
    368                this=seq_get(args, 0),
    369                expression=seq_get(args, 1),
    370                position=seq_get(args, 2),
    371                occurrence=seq_get(args, 3),
    372                group=exp.Literal.number(1) if re.compile(args[1].name).groups == 1 else None,
    373            ),
    374            "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
    375            "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
    376            "SPLIT": lambda args: exp.Split(
    377                # https://cloud.google.com/bigquery/docs/reference/standard-sql/string_functions#split
    378                this=seq_get(args, 0),
    379                expression=seq_get(args, 1) or exp.Literal.string(","),
    380            ),
    381            "TIME": _parse_time,
    382            "TIME_ADD": parse_date_delta_with_interval(exp.TimeAdd),
    383            "TIME_SUB": parse_date_delta_with_interval(exp.TimeSub),
    384            "TIMESTAMP": _parse_timestamp,
    385            "TIMESTAMP_ADD": parse_date_delta_with_interval(exp.TimestampAdd),
    386            "TIMESTAMP_SUB": parse_date_delta_with_interval(exp.TimestampSub),
    387            "TIMESTAMP_MICROS": lambda args: exp.UnixToTime(
    388                this=seq_get(args, 0), scale=exp.UnixToTime.MICROS
    389            ),
    390            "TIMESTAMP_MILLIS": lambda args: exp.UnixToTime(
    391                this=seq_get(args, 0), scale=exp.UnixToTime.MILLIS
    392            ),
    393            "TIMESTAMP_SECONDS": lambda args: exp.UnixToTime(this=seq_get(args, 0)),
    394            "TO_JSON_STRING": exp.JSONFormat.from_arg_list,
    395        }
    396
    397        FUNCTION_PARSERS = {
    398            **parser.Parser.FUNCTION_PARSERS,
    399            "ARRAY": lambda self: self.expression(exp.Array, expressions=[self._parse_statement()]),
    400        }
    401        FUNCTION_PARSERS.pop("TRIM")
    402
    403        NO_PAREN_FUNCTIONS = {
    404            **parser.Parser.NO_PAREN_FUNCTIONS,
    405            TokenType.CURRENT_DATETIME: exp.CurrentDatetime,
    406        }
    407
    408        NESTED_TYPE_TOKENS = {
    409            *parser.Parser.NESTED_TYPE_TOKENS,
    410            TokenType.TABLE,
    411        }
    412
    413        PROPERTY_PARSERS = {
    414            **parser.Parser.PROPERTY_PARSERS,
    415            "NOT DETERMINISTIC": lambda self: self.expression(
    416                exp.StabilityProperty, this=exp.Literal.string("VOLATILE")
    417            ),
    418            "OPTIONS": lambda self: self._parse_with_property(),
    419        }
    420
    421        CONSTRAINT_PARSERS = {
    422            **parser.Parser.CONSTRAINT_PARSERS,
    423            "OPTIONS": lambda self: exp.Properties(expressions=self._parse_with_property()),
    424        }
    425
    426        RANGE_PARSERS = parser.Parser.RANGE_PARSERS.copy()
    427        RANGE_PARSERS.pop(TokenType.OVERLAPS, None)
    428
    429        NULL_TOKENS = {TokenType.NULL, TokenType.UNKNOWN}
    430
    431        STATEMENT_PARSERS = {
    432            **parser.Parser.STATEMENT_PARSERS,
    433            TokenType.END: lambda self: self._parse_as_command(self._prev),
    434            TokenType.FOR: lambda self: self._parse_for_in(),
    435        }
    436
    437        BRACKET_OFFSETS = {
    438            "OFFSET": (0, False),
    439            "ORDINAL": (1, False),
    440            "SAFE_OFFSET": (0, True),
    441            "SAFE_ORDINAL": (1, True),
    442        }
    443
    444        def _parse_for_in(self) -> exp.ForIn:
    445            this = self._parse_range()
    446            self._match_text_seq("DO")
    447            return self.expression(exp.ForIn, this=this, expression=self._parse_statement())
    448
    449        def _parse_table_part(self, schema: bool = False) -> t.Optional[exp.Expression]:
    450            this = super()._parse_table_part(schema=schema) or self._parse_number()
    451
    452            # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#table_names
    453            if isinstance(this, exp.Identifier):
    454                table_name = this.name
    455                while self._match(TokenType.DASH, advance=False) and self._next:
    456                    self._advance(2)
    457                    table_name += f"-{self._prev.text}"
    458
    459                this = exp.Identifier(this=table_name, quoted=this.args.get("quoted"))
    460            elif isinstance(this, exp.Literal):
    461                table_name = this.name
    462
    463                if self._is_connected() and self._parse_var(any_token=True):
    464                    table_name += self._prev.text
    465
    466                this = exp.Identifier(this=table_name, quoted=True)
    467
    468            return this
    469
    470        def _parse_table_parts(
    471            self, schema: bool = False, is_db_reference: bool = False
    472        ) -> exp.Table:
    473            table = super()._parse_table_parts(schema=schema, is_db_reference=is_db_reference)
    474            if isinstance(table.this, exp.Identifier) and "." in table.name:
    475                catalog, db, this, *rest = (
    476                    t.cast(t.Optional[exp.Expression], exp.to_identifier(x))
    477                    for x in split_num_words(table.name, ".", 3)
    478                )
    479
    480                if rest and this:
    481                    this = exp.Dot.build(t.cast(t.List[exp.Expression], [this, *rest]))
    482
    483                table = exp.Table(this=this, db=db, catalog=catalog)
    484
    485            return table
    486
    487        @t.overload
    488        def _parse_json_object(self, agg: Lit[False]) -> exp.JSONObject:
    489            ...
    490
    491        @t.overload
    492        def _parse_json_object(self, agg: Lit[True]) -> exp.JSONObjectAgg:
    493            ...
    494
    495        def _parse_json_object(self, agg=False):
    496            json_object = super()._parse_json_object()
    497            array_kv_pair = seq_get(json_object.expressions, 0)
    498
    499            # Converts BQ's "signature 2" of JSON_OBJECT into SQLGlot's canonical representation
    500            # https://cloud.google.com/bigquery/docs/reference/standard-sql/json_functions#json_object_signature2
    501            if (
    502                array_kv_pair
    503                and isinstance(array_kv_pair.this, exp.Array)
    504                and isinstance(array_kv_pair.expression, exp.Array)
    505            ):
    506                keys = array_kv_pair.this.expressions
    507                values = array_kv_pair.expression.expressions
    508
    509                json_object.set(
    510                    "expressions",
    511                    [exp.JSONKeyValue(this=k, expression=v) for k, v in zip(keys, values)],
    512                )
    513
    514            return json_object
    515
    516        def _parse_bracket(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    517            bracket = super()._parse_bracket(this)
    518
    519            if this is bracket:
    520                return bracket
    521
    522            if isinstance(bracket, exp.Bracket):
    523                for expression in bracket.expressions:
    524                    name = expression.name.upper()
    525
    526                    if name not in self.BRACKET_OFFSETS:
    527                        break
    528
    529                    offset, safe = self.BRACKET_OFFSETS[name]
    530                    bracket.set("offset", offset)
    531                    bracket.set("safe", safe)
    532                    expression.replace(expression.expressions[0])
    533
    534            return bracket
    535
    536    class Generator(generator.Generator):
    537        EXPLICIT_UNION = True
    538        INTERVAL_ALLOWS_PLURAL_FORM = False
    539        JOIN_HINTS = False
    540        QUERY_HINTS = False
    541        TABLE_HINTS = False
    542        LIMIT_FETCH = "LIMIT"
    543        RENAME_TABLE_WITH_DB = False
    544        NVL2_SUPPORTED = False
    545        UNNEST_WITH_ORDINALITY = False
    546        COLLATE_IS_FUNC = True
    547        LIMIT_ONLY_LITERALS = True
    548        SUPPORTS_TABLE_ALIAS_COLUMNS = False
    549        UNPIVOT_ALIASES_ARE_IDENTIFIERS = False
    550        JSON_KEY_VALUE_PAIR_SEP = ","
    551        NULL_ORDERING_SUPPORTED = False
    552        IGNORE_NULLS_IN_FUNC = True
    553        JSON_PATH_SINGLE_QUOTE_ESCAPE = True
    554
    555        TRANSFORMS = {
    556            **generator.Generator.TRANSFORMS,
    557            exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
    558            exp.ArgMax: arg_max_or_min_no_count("MAX_BY"),
    559            exp.ArgMin: arg_max_or_min_no_count("MIN_BY"),
    560            exp.ArrayContains: _array_contains_sql,
    561            exp.ArraySize: rename_func("ARRAY_LENGTH"),
    562            exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]),
    563            exp.CollateProperty: lambda self, e: (
    564                f"DEFAULT COLLATE {self.sql(e, 'this')}"
    565                if e.args.get("default")
    566                else f"COLLATE {self.sql(e, 'this')}"
    567            ),
    568            exp.CountIf: rename_func("COUNTIF"),
    569            exp.Create: _create_sql,
    570            exp.CTE: transforms.preprocess([_pushdown_cte_column_names]),
    571            exp.DateAdd: date_add_interval_sql("DATE", "ADD"),
    572            exp.DateDiff: lambda self,
    573            e: f"DATE_DIFF({self.sql(e, 'this')}, {self.sql(e, 'expression')}, {self.sql(e.args.get('unit', 'DAY'))})",
    574            exp.DateFromParts: rename_func("DATE"),
    575            exp.DateStrToDate: datestrtodate_sql,
    576            exp.DateSub: date_add_interval_sql("DATE", "SUB"),
    577            exp.DatetimeAdd: date_add_interval_sql("DATETIME", "ADD"),
    578            exp.DatetimeSub: date_add_interval_sql("DATETIME", "SUB"),
    579            exp.DateTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, e.text("unit")),
    580            exp.FromTimeZone: lambda self, e: self.func(
    581                "DATETIME", self.func("TIMESTAMP", e.this, e.args.get("zone")), "'UTC'"
    582            ),
    583            exp.GenerateSeries: rename_func("GENERATE_ARRAY"),
    584            exp.GroupConcat: rename_func("STRING_AGG"),
    585            exp.Hex: rename_func("TO_HEX"),
    586            exp.If: if_sql(false_value="NULL"),
    587            exp.ILike: no_ilike_sql,
    588            exp.IntDiv: rename_func("DIV"),
    589            exp.JSONFormat: rename_func("TO_JSON_STRING"),
    590            exp.Max: max_or_greatest,
    591            exp.MD5: lambda self, e: self.func("TO_HEX", self.func("MD5", e.this)),
    592            exp.MD5Digest: rename_func("MD5"),
    593            exp.Min: min_or_least,
    594            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
    595            exp.RegexpExtract: lambda self, e: self.func(
    596                "REGEXP_EXTRACT",
    597                e.this,
    598                e.expression,
    599                e.args.get("position"),
    600                e.args.get("occurrence"),
    601            ),
    602            exp.RegexpReplace: regexp_replace_sql,
    603            exp.RegexpLike: rename_func("REGEXP_CONTAINS"),
    604            exp.ReturnsProperty: _returnsproperty_sql,
    605            exp.Select: transforms.preprocess(
    606                [
    607                    transforms.explode_to_unnest(),
    608                    _unqualify_unnest,
    609                    transforms.eliminate_distinct_on,
    610                    _alias_ordered_group,
    611                    transforms.eliminate_semi_and_anti_joins,
    612                ]
    613            ),
    614            exp.SHA2: lambda self, e: self.func(
    615                "SHA256" if e.text("length") == "256" else "SHA512", e.this
    616            ),
    617            exp.StabilityProperty: lambda self, e: (
    618                "DETERMINISTIC" if e.name == "IMMUTABLE" else "NOT DETERMINISTIC"
    619            ),
    620            exp.StrToDate: lambda self,
    621            e: f"PARSE_DATE({self.format_time(e)}, {self.sql(e, 'this')})",
    622            exp.StrToTime: lambda self, e: self.func(
    623                "PARSE_TIMESTAMP", self.format_time(e), e.this, e.args.get("zone")
    624            ),
    625            exp.TimeAdd: date_add_interval_sql("TIME", "ADD"),
    626            exp.TimeFromParts: rename_func("TIME"),
    627            exp.TimeSub: date_add_interval_sql("TIME", "SUB"),
    628            exp.TimestampAdd: date_add_interval_sql("TIMESTAMP", "ADD"),
    629            exp.TimestampDiff: rename_func("TIMESTAMP_DIFF"),
    630            exp.TimestampSub: date_add_interval_sql("TIMESTAMP", "SUB"),
    631            exp.TimeStrToTime: timestrtotime_sql,
    632            exp.Trim: lambda self, e: self.func("TRIM", e.this, e.expression),
    633            exp.TsOrDsAdd: _ts_or_ds_add_sql,
    634            exp.TsOrDsDiff: _ts_or_ds_diff_sql,
    635            exp.TsOrDsToTime: rename_func("TIME"),
    636            exp.Unhex: rename_func("FROM_HEX"),
    637            exp.UnixDate: rename_func("UNIX_DATE"),
    638            exp.UnixToTime: _unix_to_time_sql,
    639            exp.Values: _derived_table_values_to_unnest,
    640            exp.VariancePop: rename_func("VAR_POP"),
    641        }
    642
    643        SUPPORTED_JSON_PATH_PARTS = {
    644            exp.JSONPathKey,
    645            exp.JSONPathRoot,
    646            exp.JSONPathSubscript,
    647        }
    648
    649        TYPE_MAPPING = {
    650            **generator.Generator.TYPE_MAPPING,
    651            exp.DataType.Type.BIGDECIMAL: "BIGNUMERIC",
    652            exp.DataType.Type.BIGINT: "INT64",
    653            exp.DataType.Type.BINARY: "BYTES",
    654            exp.DataType.Type.BOOLEAN: "BOOL",
    655            exp.DataType.Type.CHAR: "STRING",
    656            exp.DataType.Type.DECIMAL: "NUMERIC",
    657            exp.DataType.Type.DOUBLE: "FLOAT64",
    658            exp.DataType.Type.FLOAT: "FLOAT64",
    659            exp.DataType.Type.INT: "INT64",
    660            exp.DataType.Type.NCHAR: "STRING",
    661            exp.DataType.Type.NVARCHAR: "STRING",
    662            exp.DataType.Type.SMALLINT: "INT64",
    663            exp.DataType.Type.TEXT: "STRING",
    664            exp.DataType.Type.TIMESTAMP: "DATETIME",
    665            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
    666            exp.DataType.Type.TIMESTAMPLTZ: "TIMESTAMP",
    667            exp.DataType.Type.TINYINT: "INT64",
    668            exp.DataType.Type.VARBINARY: "BYTES",
    669            exp.DataType.Type.VARCHAR: "STRING",
    670            exp.DataType.Type.VARIANT: "ANY TYPE",
    671        }
    672
    673        PROPERTIES_LOCATION = {
    674            **generator.Generator.PROPERTIES_LOCATION,
    675            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
    676            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
    677        }
    678
    679        # from: https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#reserved_keywords
    680        RESERVED_KEYWORDS = {
    681            *generator.Generator.RESERVED_KEYWORDS,
    682            "all",
    683            "and",
    684            "any",
    685            "array",
    686            "as",
    687            "asc",
    688            "assert_rows_modified",
    689            "at",
    690            "between",
    691            "by",
    692            "case",
    693            "cast",
    694            "collate",
    695            "contains",
    696            "create",
    697            "cross",
    698            "cube",
    699            "current",
    700            "default",
    701            "define",
    702            "desc",
    703            "distinct",
    704            "else",
    705            "end",
    706            "enum",
    707            "escape",
    708            "except",
    709            "exclude",
    710            "exists",
    711            "extract",
    712            "false",
    713            "fetch",
    714            "following",
    715            "for",
    716            "from",
    717            "full",
    718            "group",
    719            "grouping",
    720            "groups",
    721            "hash",
    722            "having",
    723            "if",
    724            "ignore",
    725            "in",
    726            "inner",
    727            "intersect",
    728            "interval",
    729            "into",
    730            "is",
    731            "join",
    732            "lateral",
    733            "left",
    734            "like",
    735            "limit",
    736            "lookup",
    737            "merge",
    738            "natural",
    739            "new",
    740            "no",
    741            "not",
    742            "null",
    743            "nulls",
    744            "of",
    745            "on",
    746            "or",
    747            "order",
    748            "outer",
    749            "over",
    750            "partition",
    751            "preceding",
    752            "proto",
    753            "qualify",
    754            "range",
    755            "recursive",
    756            "respect",
    757            "right",
    758            "rollup",
    759            "rows",
    760            "select",
    761            "set",
    762            "some",
    763            "struct",
    764            "tablesample",
    765            "then",
    766            "to",
    767            "treat",
    768            "true",
    769            "unbounded",
    770            "union",
    771            "unnest",
    772            "using",
    773            "when",
    774            "where",
    775            "window",
    776            "with",
    777            "within",
    778        }
    779
    780        def timetostr_sql(self, expression: exp.TimeToStr) -> str:
    781            if isinstance(expression.this, exp.TsOrDsToDate):
    782                this: exp.Expression = expression.this
    783            else:
    784                this = expression
    785
    786            return f"FORMAT_DATE({self.format_time(expression)}, {self.sql(this, 'this')})"
    787
    788        def struct_sql(self, expression: exp.Struct) -> str:
    789            args = []
    790            for expr in expression.expressions:
    791                if isinstance(expr, self.KEY_VALUE_DEFINITIONS):
    792                    arg = f"{self.sql(expr, 'expression')} AS {expr.this.name}"
    793                else:
    794                    arg = self.sql(expr)
    795
    796                args.append(arg)
    797
    798            return self.func("STRUCT", *args)
    799
    800        def eq_sql(self, expression: exp.EQ) -> str:
    801            # Operands of = cannot be NULL in BigQuery
    802            if isinstance(expression.left, exp.Null) or isinstance(expression.right, exp.Null):
    803                if not isinstance(expression.parent, exp.Update):
    804                    return "NULL"
    805
    806            return self.binary(expression, "=")
    807
    808        def attimezone_sql(self, expression: exp.AtTimeZone) -> str:
    809            parent = expression.parent
    810
    811            # BigQuery allows CAST(.. AS {STRING|TIMESTAMP} [FORMAT <fmt> [AT TIME ZONE <tz>]]).
    812            # Only the TIMESTAMP one should use the below conversion, when AT TIME ZONE is included.
    813            if not isinstance(parent, exp.Cast) or not parent.to.is_type("text"):
    814                return self.func(
    815                    "TIMESTAMP", self.func("DATETIME", expression.this, expression.args.get("zone"))
    816                )
    817
    818            return super().attimezone_sql(expression)
    819
    820        def trycast_sql(self, expression: exp.TryCast) -> str:
    821            return self.cast_sql(expression, safe_prefix="SAFE_")
    822
    823        def cte_sql(self, expression: exp.CTE) -> str:
    824            if expression.alias_column_names:
    825                self.unsupported("Column names in CTE definition are not supported.")
    826            return super().cte_sql(expression)
    827
    828        def array_sql(self, expression: exp.Array) -> str:
    829            first_arg = seq_get(expression.expressions, 0)
    830            if isinstance(first_arg, exp.Subqueryable):
    831                return f"ARRAY{self.wrap(self.sql(first_arg))}"
    832
    833            return inline_array_sql(self, expression)
    834
    835        def bracket_sql(self, expression: exp.Bracket) -> str:
    836            this = self.sql(expression, "this")
    837            expressions = expression.expressions
    838
    839            if len(expressions) == 1:
    840                arg = expressions[0]
    841                if arg.type is None:
    842                    from sqlglot.optimizer.annotate_types import annotate_types
    843
    844                    arg = annotate_types(arg)
    845
    846                if arg.type and arg.type.this in exp.DataType.TEXT_TYPES:
    847                    # BQ doesn't support bracket syntax with string values
    848                    return f"{this}.{arg.name}"
    849
    850            expressions_sql = ", ".join(self.sql(e) for e in expressions)
    851            offset = expression.args.get("offset")
    852
    853            if offset == 0:
    854                expressions_sql = f"OFFSET({expressions_sql})"
    855            elif offset == 1:
    856                expressions_sql = f"ORDINAL({expressions_sql})"
    857            elif offset is not None:
    858                self.unsupported(f"Unsupported array offset: {offset}")
    859
    860            if expression.args.get("safe"):
    861                expressions_sql = f"SAFE_{expressions_sql}"
    862
    863            return f"{this}[{expressions_sql}]"
    864
    865        def transaction_sql(self, *_) -> str:
    866            return "BEGIN TRANSACTION"
    867
    868        def commit_sql(self, *_) -> str:
    869            return "COMMIT TRANSACTION"
    870
    871        def rollback_sql(self, *_) -> str:
    872            return "ROLLBACK TRANSACTION"
    873
    874        def in_unnest_op(self, expression: exp.Unnest) -> str:
    875            return self.sql(expression)
    876
    877        def except_op(self, expression: exp.Except) -> str:
    878            if not expression.args.get("distinct", False):
    879                self.unsupported("EXCEPT without DISTINCT is not supported in BigQuery")
    880            return f"EXCEPT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
    881
    882        def intersect_op(self, expression: exp.Intersect) -> str:
    883            if not expression.args.get("distinct", False):
    884                self.unsupported("INTERSECT without DISTINCT is not supported in BigQuery")
    885            return f"INTERSECT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
    886
    887        def with_properties(self, properties: exp.Properties) -> str:
    888            return self.properties(properties, prefix=self.seg("OPTIONS"))
    889
    890        def version_sql(self, expression: exp.Version) -> str:
    891            if expression.name == "TIMESTAMP":
    892                expression.set("this", "SYSTEM_TIME")
    893            return super().version_sql(expression)

logger = <Logger sqlglot (WARNING)>
class BigQuery(sqlglot.dialects.dialect.Dialect): View Source

    238class BigQuery(Dialect):
    239    WEEK_OFFSET = -1
    240    UNNEST_COLUMN_ONLY = True
    241    SUPPORTS_USER_DEFINED_TYPES = False
    242    SUPPORTS_SEMI_ANTI_JOIN = False
    243    LOG_BASE_FIRST = False
    244
    245    # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#case_sensitivity
    246    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
    247
    248    # bigquery udfs are case sensitive
    249    NORMALIZE_FUNCTIONS = False
    250
    251    TIME_MAPPING = {
    252        "%D": "%m/%d/%y",
    253    }
    254
    255    ESCAPE_SEQUENCES = {
    256        "\\a": "\a",
    257        "\\b": "\b",
    258        "\\f": "\f",
    259        "\\n": "\n",
    260        "\\r": "\r",
    261        "\\t": "\t",
    262        "\\v": "\v",
    263    }
    264
    265    FORMAT_MAPPING = {
    266        "DD": "%d",
    267        "MM": "%m",
    268        "MON": "%b",
    269        "MONTH": "%B",
    270        "YYYY": "%Y",
    271        "YY": "%y",
    272        "HH": "%I",
    273        "HH12": "%I",
    274        "HH24": "%H",
    275        "MI": "%M",
    276        "SS": "%S",
    277        "SSSSS": "%f",
    278        "TZH": "%z",
    279    }
    280
    281    # The _PARTITIONTIME and _PARTITIONDATE pseudo-columns are not returned by a SELECT * statement
    282    # https://cloud.google.com/bigquery/docs/querying-partitioned-tables#query_an_ingestion-time_partitioned_table
    283    PSEUDOCOLUMNS = {"_PARTITIONTIME", "_PARTITIONDATE"}
    284
    285    def normalize_identifier(self, expression: E) -> E:
    286        if isinstance(expression, exp.Identifier):
    287            parent = expression.parent
    288            while isinstance(parent, exp.Dot):
    289                parent = parent.parent
    290
    291            # In BigQuery, CTEs aren't case-sensitive, but table names are (by default, at least).
    292            # The following check is essentially a heuristic to detect tables based on whether or
    293            # not they're qualified. It also avoids normalizing UDFs, because they're case-sensitive.
    294            if (
    295                not isinstance(parent, exp.UserDefinedFunction)
    296                and not (isinstance(parent, exp.Table) and parent.db)
    297                and not expression.meta.get("is_table")
    298            ):
    299                expression.set("this", expression.this.lower())
    300
    301        return expression
    302
    303    class Tokenizer(tokens.Tokenizer):
    304        QUOTES = ["'", '"', '"""', "'''"]
    305        COMMENTS = ["--", "#", ("/*", "*/")]
    306        IDENTIFIERS = ["`"]
    307        STRING_ESCAPES = ["\\"]
    308
    309        HEX_STRINGS = [("0x", ""), ("0X", "")]
    310
    311        BYTE_STRINGS = [
    312            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("b", "B")
    313        ]
    314
    315        RAW_STRINGS = [
    316            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("r", "R")
    317        ]
    318
    319        KEYWORDS = {
    320            **tokens.Tokenizer.KEYWORDS,
    321            "ANY TYPE": TokenType.VARIANT,
    322            "BEGIN": TokenType.COMMAND,
    323            "BEGIN TRANSACTION": TokenType.BEGIN,
    324            "BYTES": TokenType.BINARY,
    325            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
    326            "DECLARE": TokenType.COMMAND,
    327            "FLOAT64": TokenType.DOUBLE,
    328            "FOR SYSTEM_TIME": TokenType.TIMESTAMP_SNAPSHOT,
    329            "MODEL": TokenType.MODEL,
    330            "NOT DETERMINISTIC": TokenType.VOLATILE,
    331            "RECORD": TokenType.STRUCT,
    332            "TIMESTAMP": TokenType.TIMESTAMPTZ,
    333        }
    334        KEYWORDS.pop("DIV")
    335        KEYWORDS.pop("VALUES")
    336
    337    class Parser(parser.Parser):
    338        PREFIXED_PIVOT_COLUMNS = True
    339
    340        LOG_DEFAULTS_TO_LN = True
    341
    342        FUNCTIONS = {
    343            **parser.Parser.FUNCTIONS,
    344            "DATE": _parse_date,
    345            "DATE_ADD": parse_date_delta_with_interval(exp.DateAdd),
    346            "DATE_SUB": parse_date_delta_with_interval(exp.DateSub),
    347            "DATE_TRUNC": lambda args: exp.DateTrunc(
    348                unit=exp.Literal.string(str(seq_get(args, 1))),
    349                this=seq_get(args, 0),
    350            ),
    351            "DATETIME_ADD": parse_date_delta_with_interval(exp.DatetimeAdd),
    352            "DATETIME_SUB": parse_date_delta_with_interval(exp.DatetimeSub),
    353            "DIV": binary_from_function(exp.IntDiv),
    354            "FORMAT_DATE": lambda args: exp.TimeToStr(
    355                this=exp.TsOrDsToDate(this=seq_get(args, 1)), format=seq_get(args, 0)
    356            ),
    357            "GENERATE_ARRAY": exp.GenerateSeries.from_arg_list,
    358            "JSON_EXTRACT_SCALAR": lambda args: exp.JSONExtractScalar(
    359                this=seq_get(args, 0), expression=seq_get(args, 1) or exp.Literal.string("$")
    360            ),
    361            "MD5": exp.MD5Digest.from_arg_list,
    362            "TO_HEX": _parse_to_hex,
    363            "PARSE_DATE": lambda args: format_time_lambda(exp.StrToDate, "bigquery")(
    364                [seq_get(args, 1), seq_get(args, 0)]
    365            ),
    366            "PARSE_TIMESTAMP": _parse_parse_timestamp,
    367            "REGEXP_CONTAINS": exp.RegexpLike.from_arg_list,
    368            "REGEXP_EXTRACT": lambda args: exp.RegexpExtract(
    369                this=seq_get(args, 0),
    370                expression=seq_get(args, 1),
    371                position=seq_get(args, 2),
    372                occurrence=seq_get(args, 3),
    373                group=exp.Literal.number(1) if re.compile(args[1].name).groups == 1 else None,
    374            ),
    375            "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
    376            "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
    377            "SPLIT": lambda args: exp.Split(
    378                # https://cloud.google.com/bigquery/docs/reference/standard-sql/string_functions#split
    379                this=seq_get(args, 0),
    380                expression=seq_get(args, 1) or exp.Literal.string(","),
    381            ),
    382            "TIME": _parse_time,
    383            "TIME_ADD": parse_date_delta_with_interval(exp.TimeAdd),
    384            "TIME_SUB": parse_date_delta_with_interval(exp.TimeSub),
    385            "TIMESTAMP": _parse_timestamp,
    386            "TIMESTAMP_ADD": parse_date_delta_with_interval(exp.TimestampAdd),
    387            "TIMESTAMP_SUB": parse_date_delta_with_interval(exp.TimestampSub),
    388            "TIMESTAMP_MICROS": lambda args: exp.UnixToTime(
    389                this=seq_get(args, 0), scale=exp.UnixToTime.MICROS
    390            ),
    391            "TIMESTAMP_MILLIS": lambda args: exp.UnixToTime(
    392                this=seq_get(args, 0), scale=exp.UnixToTime.MILLIS
    393            ),
    394            "TIMESTAMP_SECONDS": lambda args: exp.UnixToTime(this=seq_get(args, 0)),
    395            "TO_JSON_STRING": exp.JSONFormat.from_arg_list,
    396        }
    397
    398        FUNCTION_PARSERS = {
    399            **parser.Parser.FUNCTION_PARSERS,
    400            "ARRAY": lambda self: self.expression(exp.Array, expressions=[self._parse_statement()]),
    401        }
    402        FUNCTION_PARSERS.pop("TRIM")
    403
    404        NO_PAREN_FUNCTIONS = {
    405            **parser.Parser.NO_PAREN_FUNCTIONS,
    406            TokenType.CURRENT_DATETIME: exp.CurrentDatetime,
    407        }
    408
    409        NESTED_TYPE_TOKENS = {
    410            *parser.Parser.NESTED_TYPE_TOKENS,
    411            TokenType.TABLE,
    412        }
    413
    414        PROPERTY_PARSERS = {
    415            **parser.Parser.PROPERTY_PARSERS,
    416            "NOT DETERMINISTIC": lambda self: self.expression(
    417                exp.StabilityProperty, this=exp.Literal.string("VOLATILE")
    418            ),
    419            "OPTIONS": lambda self: self._parse_with_property(),
    420        }
    421
    422        CONSTRAINT_PARSERS = {
    423            **parser.Parser.CONSTRAINT_PARSERS,
    424            "OPTIONS": lambda self: exp.Properties(expressions=self._parse_with_property()),
    425        }
    426
    427        RANGE_PARSERS = parser.Parser.RANGE_PARSERS.copy()
    428        RANGE_PARSERS.pop(TokenType.OVERLAPS, None)
    429
    430        NULL_TOKENS = {TokenType.NULL, TokenType.UNKNOWN}
    431
    432        STATEMENT_PARSERS = {
    433            **parser.Parser.STATEMENT_PARSERS,
    434            TokenType.END: lambda self: self._parse_as_command(self._prev),
    435            TokenType.FOR: lambda self: self._parse_for_in(),
    436        }
    437
    438        BRACKET_OFFSETS = {
    439            "OFFSET": (0, False),
    440            "ORDINAL": (1, False),
    441            "SAFE_OFFSET": (0, True),
    442            "SAFE_ORDINAL": (1, True),
    443        }
    444
    445        def _parse_for_in(self) -> exp.ForIn:
    446            this = self._parse_range()
    447            self._match_text_seq("DO")
    448            return self.expression(exp.ForIn, this=this, expression=self._parse_statement())
    449
    450        def _parse_table_part(self, schema: bool = False) -> t.Optional[exp.Expression]:
    451            this = super()._parse_table_part(schema=schema) or self._parse_number()
    452
    453            # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#table_names
    454            if isinstance(this, exp.Identifier):
    455                table_name = this.name
    456                while self._match(TokenType.DASH, advance=False) and self._next:
    457                    self._advance(2)
    458                    table_name += f"-{self._prev.text}"
    459
    460                this = exp.Identifier(this=table_name, quoted=this.args.get("quoted"))
    461            elif isinstance(this, exp.Literal):
    462                table_name = this.name
    463
    464                if self._is_connected() and self._parse_var(any_token=True):
    465                    table_name += self._prev.text
    466
    467                this = exp.Identifier(this=table_name, quoted=True)
    468
    469            return this
    470
    471        def _parse_table_parts(
    472            self, schema: bool = False, is_db_reference: bool = False
    473        ) -> exp.Table:
    474            table = super()._parse_table_parts(schema=schema, is_db_reference=is_db_reference)
    475            if isinstance(table.this, exp.Identifier) and "." in table.name:
    476                catalog, db, this, *rest = (
    477                    t.cast(t.Optional[exp.Expression], exp.to_identifier(x))
    478                    for x in split_num_words(table.name, ".", 3)
    479                )
    480
    481                if rest and this:
    482                    this = exp.Dot.build(t.cast(t.List[exp.Expression], [this, *rest]))
    483
    484                table = exp.Table(this=this, db=db, catalog=catalog)
    485
    486            return table
    487
    488        @t.overload
    489        def _parse_json_object(self, agg: Lit[False]) -> exp.JSONObject:
    490            ...
    491
    492        @t.overload
    493        def _parse_json_object(self, agg: Lit[True]) -> exp.JSONObjectAgg:
    494            ...
    495
    496        def _parse_json_object(self, agg=False):
    497            json_object = super()._parse_json_object()
    498            array_kv_pair = seq_get(json_object.expressions, 0)
    499
    500            # Converts BQ's "signature 2" of JSON_OBJECT into SQLGlot's canonical representation
    501            # https://cloud.google.com/bigquery/docs/reference/standard-sql/json_functions#json_object_signature2
    502            if (
    503                array_kv_pair
    504                and isinstance(array_kv_pair.this, exp.Array)
    505                and isinstance(array_kv_pair.expression, exp.Array)
    506            ):
    507                keys = array_kv_pair.this.expressions
    508                values = array_kv_pair.expression.expressions
    509
    510                json_object.set(
    511                    "expressions",
    512                    [exp.JSONKeyValue(this=k, expression=v) for k, v in zip(keys, values)],
    513                )
    514
    515            return json_object
    516
    517        def _parse_bracket(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    518            bracket = super()._parse_bracket(this)
    519
    520            if this is bracket:
    521                return bracket
    522
    523            if isinstance(bracket, exp.Bracket):
    524                for expression in bracket.expressions:
    525                    name = expression.name.upper()
    526
    527                    if name not in self.BRACKET_OFFSETS:
    528                        break
    529
    530                    offset, safe = self.BRACKET_OFFSETS[name]
    531                    bracket.set("offset", offset)
    532                    bracket.set("safe", safe)
    533                    expression.replace(expression.expressions[0])
    534
    535            return bracket
    536
    537    class Generator(generator.Generator):
    538        EXPLICIT_UNION = True
    539        INTERVAL_ALLOWS_PLURAL_FORM = False
    540        JOIN_HINTS = False
    541        QUERY_HINTS = False
    542        TABLE_HINTS = False
    543        LIMIT_FETCH = "LIMIT"
    544        RENAME_TABLE_WITH_DB = False
    545        NVL2_SUPPORTED = False
    546        UNNEST_WITH_ORDINALITY = False
    547        COLLATE_IS_FUNC = True
    548        LIMIT_ONLY_LITERALS = True
    549        SUPPORTS_TABLE_ALIAS_COLUMNS = False
    550        UNPIVOT_ALIASES_ARE_IDENTIFIERS = False
    551        JSON_KEY_VALUE_PAIR_SEP = ","
    552        NULL_ORDERING_SUPPORTED = False
    553        IGNORE_NULLS_IN_FUNC = True
    554        JSON_PATH_SINGLE_QUOTE_ESCAPE = True
    555
    556        TRANSFORMS = {
    557            **generator.Generator.TRANSFORMS,
    558            exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
    559            exp.ArgMax: arg_max_or_min_no_count("MAX_BY"),
    560            exp.ArgMin: arg_max_or_min_no_count("MIN_BY"),
    561            exp.ArrayContains: _array_contains_sql,
    562            exp.ArraySize: rename_func("ARRAY_LENGTH"),
    563            exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]),
    564            exp.CollateProperty: lambda self, e: (
    565                f"DEFAULT COLLATE {self.sql(e, 'this')}"
    566                if e.args.get("default")
    567                else f"COLLATE {self.sql(e, 'this')}"
    568            ),
    569            exp.CountIf: rename_func("COUNTIF"),
    570            exp.Create: _create_sql,
    571            exp.CTE: transforms.preprocess([_pushdown_cte_column_names]),
    572            exp.DateAdd: date_add_interval_sql("DATE", "ADD"),
    573            exp.DateDiff: lambda self,
    574            e: f"DATE_DIFF({self.sql(e, 'this')}, {self.sql(e, 'expression')}, {self.sql(e.args.get('unit', 'DAY'))})",
    575            exp.DateFromParts: rename_func("DATE"),
    576            exp.DateStrToDate: datestrtodate_sql,
    577            exp.DateSub: date_add_interval_sql("DATE", "SUB"),
    578            exp.DatetimeAdd: date_add_interval_sql("DATETIME", "ADD"),
    579            exp.DatetimeSub: date_add_interval_sql("DATETIME", "SUB"),
    580            exp.DateTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, e.text("unit")),
    581            exp.FromTimeZone: lambda self, e: self.func(
    582                "DATETIME", self.func("TIMESTAMP", e.this, e.args.get("zone")), "'UTC'"
    583            ),
    584            exp.GenerateSeries: rename_func("GENERATE_ARRAY"),
    585            exp.GroupConcat: rename_func("STRING_AGG"),
    586            exp.Hex: rename_func("TO_HEX"),
    587            exp.If: if_sql(false_value="NULL"),
    588            exp.ILike: no_ilike_sql,
    589            exp.IntDiv: rename_func("DIV"),
    590            exp.JSONFormat: rename_func("TO_JSON_STRING"),
    591            exp.Max: max_or_greatest,
    592            exp.MD5: lambda self, e: self.func("TO_HEX", self.func("MD5", e.this)),
    593            exp.MD5Digest: rename_func("MD5"),
    594            exp.Min: min_or_least,
    595            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
    596            exp.RegexpExtract: lambda self, e: self.func(
    597                "REGEXP_EXTRACT",
    598                e.this,
    599                e.expression,
    600                e.args.get("position"),
    601                e.args.get("occurrence"),
    602            ),
    603            exp.RegexpReplace: regexp_replace_sql,
    604            exp.RegexpLike: rename_func("REGEXP_CONTAINS"),
    605            exp.ReturnsProperty: _returnsproperty_sql,
    606            exp.Select: transforms.preprocess(
    607                [
    608                    transforms.explode_to_unnest(),
    609                    _unqualify_unnest,
    610                    transforms.eliminate_distinct_on,
    611                    _alias_ordered_group,
    612                    transforms.eliminate_semi_and_anti_joins,
    613                ]
    614            ),
    615            exp.SHA2: lambda self, e: self.func(
    616                "SHA256" if e.text("length") == "256" else "SHA512", e.this
    617            ),
    618            exp.StabilityProperty: lambda self, e: (
    619                "DETERMINISTIC" if e.name == "IMMUTABLE" else "NOT DETERMINISTIC"
    620            ),
    621            exp.StrToDate: lambda self,
    622            e: f"PARSE_DATE({self.format_time(e)}, {self.sql(e, 'this')})",
    623            exp.StrToTime: lambda self, e: self.func(
    624                "PARSE_TIMESTAMP", self.format_time(e), e.this, e.args.get("zone")
    625            ),
    626            exp.TimeAdd: date_add_interval_sql("TIME", "ADD"),
    627            exp.TimeFromParts: rename_func("TIME"),
    628            exp.TimeSub: date_add_interval_sql("TIME", "SUB"),
    629            exp.TimestampAdd: date_add_interval_sql("TIMESTAMP", "ADD"),
    630            exp.TimestampDiff: rename_func("TIMESTAMP_DIFF"),
    631            exp.TimestampSub: date_add_interval_sql("TIMESTAMP", "SUB"),
    632            exp.TimeStrToTime: timestrtotime_sql,
    633            exp.Trim: lambda self, e: self.func("TRIM", e.this, e.expression),
    634            exp.TsOrDsAdd: _ts_or_ds_add_sql,
    635            exp.TsOrDsDiff: _ts_or_ds_diff_sql,
    636            exp.TsOrDsToTime: rename_func("TIME"),
    637            exp.Unhex: rename_func("FROM_HEX"),
    638            exp.UnixDate: rename_func("UNIX_DATE"),
    639            exp.UnixToTime: _unix_to_time_sql,
    640            exp.Values: _derived_table_values_to_unnest,
    641            exp.VariancePop: rename_func("VAR_POP"),
    642        }
    643
    644        SUPPORTED_JSON_PATH_PARTS = {
    645            exp.JSONPathKey,
    646            exp.JSONPathRoot,
    647            exp.JSONPathSubscript,
    648        }
    649
    650        TYPE_MAPPING = {
    651            **generator.Generator.TYPE_MAPPING,
    652            exp.DataType.Type.BIGDECIMAL: "BIGNUMERIC",
    653            exp.DataType.Type.BIGINT: "INT64",
    654            exp.DataType.Type.BINARY: "BYTES",
    655            exp.DataType.Type.BOOLEAN: "BOOL",
    656            exp.DataType.Type.CHAR: "STRING",
    657            exp.DataType.Type.DECIMAL: "NUMERIC",
    658            exp.DataType.Type.DOUBLE: "FLOAT64",
    659            exp.DataType.Type.FLOAT: "FLOAT64",
    660            exp.DataType.Type.INT: "INT64",
    661            exp.DataType.Type.NCHAR: "STRING",
    662            exp.DataType.Type.NVARCHAR: "STRING",
    663            exp.DataType.Type.SMALLINT: "INT64",
    664            exp.DataType.Type.TEXT: "STRING",
    665            exp.DataType.Type.TIMESTAMP: "DATETIME",
    666            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
    667            exp.DataType.Type.TIMESTAMPLTZ: "TIMESTAMP",
    668            exp.DataType.Type.TINYINT: "INT64",
    669            exp.DataType.Type.VARBINARY: "BYTES",
    670            exp.DataType.Type.VARCHAR: "STRING",
    671            exp.DataType.Type.VARIANT: "ANY TYPE",
    672        }
    673
    674        PROPERTIES_LOCATION = {
    675            **generator.Generator.PROPERTIES_LOCATION,
    676            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
    677            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
    678        }
    679
    680        # from: https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#reserved_keywords
    681        RESERVED_KEYWORDS = {
    682            *generator.Generator.RESERVED_KEYWORDS,
    683            "all",
    684            "and",
    685            "any",
    686            "array",
    687            "as",
    688            "asc",
    689            "assert_rows_modified",
    690            "at",
    691            "between",
    692            "by",
    693            "case",
    694            "cast",
    695            "collate",
    696            "contains",
    697            "create",
    698            "cross",
    699            "cube",
    700            "current",
    701            "default",
    702            "define",
    703            "desc",
    704            "distinct",
    705            "else",
    706            "end",
    707            "enum",
    708            "escape",
    709            "except",
    710            "exclude",
    711            "exists",
    712            "extract",
    713            "false",
    714            "fetch",
    715            "following",
    716            "for",
    717            "from",
    718            "full",
    719            "group",
    720            "grouping",
    721            "groups",
    722            "hash",
    723            "having",
    724            "if",
    725            "ignore",
    726            "in",
    727            "inner",
    728            "intersect",
    729            "interval",
    730            "into",
    731            "is",
    732            "join",
    733            "lateral",
    734            "left",
    735            "like",
    736            "limit",
    737            "lookup",
    738            "merge",
    739            "natural",
    740            "new",
    741            "no",
    742            "not",
    743            "null",
    744            "nulls",
    745            "of",
    746            "on",
    747            "or",
    748            "order",
    749            "outer",
    750            "over",
    751            "partition",
    752            "preceding",
    753            "proto",
    754            "qualify",
    755            "range",
    756            "recursive",
    757            "respect",
    758            "right",
    759            "rollup",
    760            "rows",
    761            "select",
    762            "set",
    763            "some",
    764            "struct",
    765            "tablesample",
    766            "then",
    767            "to",
    768            "treat",
    769            "true",
    770            "unbounded",
    771            "union",
    772            "unnest",
    773            "using",
    774            "when",
    775            "where",
    776            "window",
    777            "with",
    778            "within",
    779        }
    780
    781        def timetostr_sql(self, expression: exp.TimeToStr) -> str:
    782            if isinstance(expression.this, exp.TsOrDsToDate):
    783                this: exp.Expression = expression.this
    784            else:
    785                this = expression
    786
    787            return f"FORMAT_DATE({self.format_time(expression)}, {self.sql(this, 'this')})"
    788
    789        def struct_sql(self, expression: exp.Struct) -> str:
    790            args = []
    791            for expr in expression.expressions:
    792                if isinstance(expr, self.KEY_VALUE_DEFINITIONS):
    793                    arg = f"{self.sql(expr, 'expression')} AS {expr.this.name}"
    794                else:
    795                    arg = self.sql(expr)
    796
    797                args.append(arg)
    798
    799            return self.func("STRUCT", *args)
    800
    801        def eq_sql(self, expression: exp.EQ) -> str:
    802            # Operands of = cannot be NULL in BigQuery
    803            if isinstance(expression.left, exp.Null) or isinstance(expression.right, exp.Null):
    804                if not isinstance(expression.parent, exp.Update):
    805                    return "NULL"
    806
    807            return self.binary(expression, "=")
    808
    809        def attimezone_sql(self, expression: exp.AtTimeZone) -> str:
    810            parent = expression.parent
    811
    812            # BigQuery allows CAST(.. AS {STRING|TIMESTAMP} [FORMAT <fmt> [AT TIME ZONE <tz>]]).
    813            # Only the TIMESTAMP one should use the below conversion, when AT TIME ZONE is included.
    814            if not isinstance(parent, exp.Cast) or not parent.to.is_type("text"):
    815                return self.func(
    816                    "TIMESTAMP", self.func("DATETIME", expression.this, expression.args.get("zone"))
    817                )
    818
    819            return super().attimezone_sql(expression)
    820
    821        def trycast_sql(self, expression: exp.TryCast) -> str:
    822            return self.cast_sql(expression, safe_prefix="SAFE_")
    823
    824        def cte_sql(self, expression: exp.CTE) -> str:
    825            if expression.alias_column_names:
    826                self.unsupported("Column names in CTE definition are not supported.")
    827            return super().cte_sql(expression)
    828
    829        def array_sql(self, expression: exp.Array) -> str:
    830            first_arg = seq_get(expression.expressions, 0)
    831            if isinstance(first_arg, exp.Subqueryable):
    832                return f"ARRAY{self.wrap(self.sql(first_arg))}"
    833
    834            return inline_array_sql(self, expression)
    835
    836        def bracket_sql(self, expression: exp.Bracket) -> str:
    837            this = self.sql(expression, "this")
    838            expressions = expression.expressions
    839
    840            if len(expressions) == 1:
    841                arg = expressions[0]
    842                if arg.type is None:
    843                    from sqlglot.optimizer.annotate_types import annotate_types
    844
    845                    arg = annotate_types(arg)
    846
    847                if arg.type and arg.type.this in exp.DataType.TEXT_TYPES:
    848                    # BQ doesn't support bracket syntax with string values
    849                    return f"{this}.{arg.name}"
    850
    851            expressions_sql = ", ".join(self.sql(e) for e in expressions)
    852            offset = expression.args.get("offset")
    853
    854            if offset == 0:
    855                expressions_sql = f"OFFSET({expressions_sql})"
    856            elif offset == 1:
    857                expressions_sql = f"ORDINAL({expressions_sql})"
    858            elif offset is not None:
    859                self.unsupported(f"Unsupported array offset: {offset}")
    860
    861            if expression.args.get("safe"):
    862                expressions_sql = f"SAFE_{expressions_sql}"
    863
    864            return f"{this}[{expressions_sql}]"
    865
    866        def transaction_sql(self, *_) -> str:
    867            return "BEGIN TRANSACTION"
    868
    869        def commit_sql(self, *_) -> str:
    870            return "COMMIT TRANSACTION"
    871
    872        def rollback_sql(self, *_) -> str:
    873            return "ROLLBACK TRANSACTION"
    874
    875        def in_unnest_op(self, expression: exp.Unnest) -> str:
    876            return self.sql(expression)
    877
    878        def except_op(self, expression: exp.Except) -> str:
    879            if not expression.args.get("distinct", False):
    880                self.unsupported("EXCEPT without DISTINCT is not supported in BigQuery")
    881            return f"EXCEPT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
    882
    883        def intersect_op(self, expression: exp.Intersect) -> str:
    884            if not expression.args.get("distinct", False):
    885                self.unsupported("INTERSECT without DISTINCT is not supported in BigQuery")
    886            return f"INTERSECT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
    887
    888        def with_properties(self, properties: exp.Properties) -> str:
    889            return self.properties(properties, prefix=self.seg("OPTIONS"))
    890
    891        def version_sql(self, expression: exp.Version) -> str:
    892            if expression.name == "TIMESTAMP":
    893                expression.set("this", "SYSTEM_TIME")
    894            return super().version_sql(expression)

WEEK_OFFSET = -1

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

UNNEST_COLUMN_ONLY = True

Determines whether or not `UNNEST` table aliases are treated as column aliases.

SUPPORTS_USER_DEFINED_TYPES = False

Determines whether or not user-defined data types are supported.

SUPPORTS_SEMI_ANTI_JOIN = False

Determines whether or not `SEMI` or `ANTI` joins are supported.

LOG_BASE_FIRST = False

Determines whether the base comes first in the `LOG` function.

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.

TIME_MAPPING: Dict[str, str] = {'%D': '%m/%d/%y'}

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

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

Mapping of an unescaped escape sequence to the corresponding character.

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] = {'_PARTITIONDATE', '_PARTITIONTIME'}

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

def normalize_identifier(self, expression: ~E) -> ~E: View Source

    285    def normalize_identifier(self, expression: E) -> E:
    286        if isinstance(expression, exp.Identifier):
    287            parent = expression.parent
    288            while isinstance(parent, exp.Dot):
    289                parent = parent.parent
    290
    291            # In BigQuery, CTEs aren't case-sensitive, but table names are (by default, at least).
    292            # The following check is essentially a heuristic to detect tables based on whether or
    293            # not they're qualified. It also avoids normalizing UDFs, because they're case-sensitive.
    294            if (
    295                not isinstance(parent, exp.UserDefinedFunction)
    296                and not (isinstance(parent, exp.Table) and parent.db)
    297                and not expression.meta.get("is_table")
    298            ):
    299                expression.set("this", expression.this.lower())
    300
    301        return 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.

tokenizer_class = <class 'BigQuery.Tokenizer'>
parser_class = <class 'BigQuery.Parser'>
generator_class = <class 'BigQuery.Generator'>
TIME_TRIE: Dict = {'%': {'D': {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'}
INVERSE_TIME_TRIE: Dict = {'%': {'m': {'/': {'%': {'d': {'/': {'%': {'y': {0: True}}}}}}}}}
INVERSE_ESCAPE_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

##### Inherited Members

sqlglot.dialects.dialect.Dialect
  Dialect
  INDEX_OFFSET
  ALIAS_POST_TABLESAMPLE
  TABLESAMPLE_SIZE_IS_PERCENT
  IDENTIFIERS_CAN_START_WITH_DIGIT
  DPIPE_IS_STRING_CONCAT
  STRICT_STRING_CONCAT
  NULL_ORDERING
  TYPED_DIVISION
  SAFE_DIVISION
  CONCAT_COALESCE
  DATE_FORMAT
  DATEINT_FORMAT
  TIME_FORMAT
  PREFER_CTE_ALIAS_COLUMN
  get_or_raise
  format_time
  case_sensitive
  can_identify
  quote_identifier
  to_json_path
  parse
  parse_into
  generate
  transpile
  tokenize
  tokenizer
  parser
  generator

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

    303    class Tokenizer(tokens.Tokenizer):
    304        QUOTES = ["'", '"', '"""', "'''"]
    305        COMMENTS = ["--", "#", ("/*", "*/")]
    306        IDENTIFIERS = ["`"]
    307        STRING_ESCAPES = ["\\"]
    308
    309        HEX_STRINGS = [("0x", ""), ("0X", "")]
    310
    311        BYTE_STRINGS = [
    312            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("b", "B")
    313        ]
    314
    315        RAW_STRINGS = [
    316            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("r", "R")
    317        ]
    318
    319        KEYWORDS = {
    320            **tokens.Tokenizer.KEYWORDS,
    321            "ANY TYPE": TokenType.VARIANT,
    322            "BEGIN": TokenType.COMMAND,
    323            "BEGIN TRANSACTION": TokenType.BEGIN,
    324            "BYTES": TokenType.BINARY,
    325            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
    326            "DECLARE": TokenType.COMMAND,
    327            "FLOAT64": TokenType.DOUBLE,
    328            "FOR SYSTEM_TIME": TokenType.TIMESTAMP_SNAPSHOT,
    329            "MODEL": TokenType.MODEL,
    330            "NOT DETERMINISTIC": TokenType.VOLATILE,
    331            "RECORD": TokenType.STRUCT,
    332            "TIMESTAMP": TokenType.TIMESTAMPTZ,
    333        }
    334        KEYWORDS.pop("DIV")
    335        KEYWORDS.pop("VALUES")

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'''", "'''")]
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.HINT: 'HINT'>, '==': <TokenType.EQ: 'EQ'>, '::': <TokenType.DCOLON: 'DCOLON'>, '||': <TokenType.DPIPE: 'DPIPE'>, '>=': <TokenType.GTE: 'GTE'>, '<=': <TokenType.LTE: 'LTE'>, '<>': <TokenType.NEQ: 'NEQ'>, '!=': <TokenType.NEQ: 'NEQ'>, ':=': <TokenType.COLON_EQ: 'COLON_EQ'>, '<=>': <TokenType.NULLSAFE_EQ: 'NULLSAFE_EQ'>, '->': <TokenType.ARROW: 'ARROW'>, '->>': <TokenType.DARROW: 'DARROW'>, '=>': <TokenType.FARROW: 'FARROW'>, '#>': <TokenType.HASH_ARROW: 'HASH_ARROW'>, '#>>': <TokenType.DHASH_ARROW: 'DHASH_ARROW'>, '<->': <TokenType.LR_ARROW: 'LR_ARROW'>, '&&': <TokenType.DAMP: 'DAMP'>, '??': <TokenType.DQMARK: 'DQMARK'>, 'ALL': <TokenType.ALL: 'ALL'>, 'ALWAYS': <TokenType.ALWAYS: 'ALWAYS'>, 'AND': <TokenType.AND: 'AND'>, 'ANTI': <TokenType.ANTI: 'ANTI'>, 'ANY': <TokenType.ANY: 'ANY'>, 'ASC': <TokenType.ASC: 'ASC'>, 'AS': <TokenType.ALIAS: 'ALIAS'>, 'ASOF': <TokenType.ASOF: 'ASOF'>, 'AUTOINCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'AUTO_INCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'BEGIN': <TokenType.COMMAND: 'COMMAND'>, 'BETWEEN': <TokenType.BETWEEN: 'BETWEEN'>, 'CACHE': <TokenType.CACHE: 'CACHE'>, 'UNCACHE': <TokenType.UNCACHE: 'UNCACHE'>, 'CASE': <TokenType.CASE: 'CASE'>, 'CHARACTER SET': <TokenType.CHARACTER_SET: 'CHARACTER_SET'>, 'CLUSTER BY': <TokenType.CLUSTER_BY: 'CLUSTER_BY'>, 'COLLATE': <TokenType.COLLATE: 'COLLATE'>, 'COLUMN': <TokenType.COLUMN: 'COLUMN'>, 'COMMIT': <TokenType.COMMIT: 'COMMIT'>, 'CONNECT BY': <TokenType.CONNECT_BY: 'CONNECT_BY'>, 'CONSTRAINT': <TokenType.CONSTRAINT: 'CONSTRAINT'>, 'CREATE': <TokenType.CREATE: 'CREATE'>, 'CROSS': <TokenType.CROSS: 'CROSS'>, 'CUBE': <TokenType.CUBE: 'CUBE'>, 'CURRENT_DATE': <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, 'CURRENT_TIME': <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, 'CURRENT_TIMESTAMP': <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, 'CURRENT_USER': <TokenType.CURRENT_USER: 'CURRENT_USER'>, 'DATABASE': <TokenType.DATABASE: 'DATABASE'>, 'DEFAULT': <TokenType.DEFAULT: 'DEFAULT'>, 'DELETE': <TokenType.DELETE: 'DELETE'>, 'DESC': <TokenType.DESC: 'DESC'>, 'DESCRIBE': <TokenType.DESCRIBE: 'DESCRIBE'>, 'DISTINCT': <TokenType.DISTINCT: 'DISTINCT'>, 'DISTRIBUTE BY': <TokenType.DISTRIBUTE_BY: 'DISTRIBUTE_BY'>, 'DROP': <TokenType.DROP: 'DROP'>, 'ELSE': <TokenType.ELSE: 'ELSE'>, 'END': <TokenType.END: 'END'>, 'ESCAPE': <TokenType.ESCAPE: 'ESCAPE'>, 'EXCEPT': <TokenType.EXCEPT: 'EXCEPT'>, 'EXECUTE': <TokenType.EXECUTE: 'EXECUTE'>, 'EXISTS': <TokenType.EXISTS: 'EXISTS'>, 'FALSE': <TokenType.FALSE: 'FALSE'>, 'FETCH': <TokenType.FETCH: 'FETCH'>, 'FILTER': <TokenType.FILTER: 'FILTER'>, 'FIRST': <TokenType.FIRST: 'FIRST'>, 'FULL': <TokenType.FULL: 'FULL'>, 'FUNCTION': <TokenType.FUNCTION: 'FUNCTION'>, 'FOR': <TokenType.FOR: 'FOR'>, 'FOREIGN KEY': <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, 'FORMAT': <TokenType.FORMAT: 'FORMAT'>, 'FROM': <TokenType.FROM: 'FROM'>, 'GEOGRAPHY': <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, 'GEOMETRY': <TokenType.GEOMETRY: 'GEOMETRY'>, 'GLOB': <TokenType.GLOB: 'GLOB'>, 'GROUP BY': <TokenType.GROUP_BY: 'GROUP_BY'>, 'GROUPING SETS': <TokenType.GROUPING_SETS: 'GROUPING_SETS'>, 'HAVING': <TokenType.HAVING: 'HAVING'>, 'ILIKE': <TokenType.ILIKE: 'ILIKE'>, 'IN': <TokenType.IN: 'IN'>, 'INDEX': <TokenType.INDEX: 'INDEX'>, 'INET': <TokenType.INET: 'INET'>, 'INNER': <TokenType.INNER: 'INNER'>, 'INSERT': <TokenType.INSERT: 'INSERT'>, 'INTERVAL': <TokenType.INTERVAL: 'INTERVAL'>, 'INTERSECT': <TokenType.INTERSECT: 'INTERSECT'>, 'INTO': <TokenType.INTO: 'INTO'>, 'IS': <TokenType.IS: 'IS'>, 'ISNULL': <TokenType.ISNULL: 'ISNULL'>, 'JOIN': <TokenType.JOIN: 'JOIN'>, 'KEEP': <TokenType.KEEP: 'KEEP'>, 'KILL': <TokenType.KILL: 'KILL'>, 'LATERAL': <TokenType.LATERAL: 'LATERAL'>, 'LEFT': <TokenType.LEFT: 'LEFT'>, 'LIKE': <TokenType.LIKE: 'LIKE'>, 'LIMIT': <TokenType.LIMIT: 'LIMIT'>, 'LOAD': <TokenType.LOAD: 'LOAD'>, 'LOCK': <TokenType.LOCK: 'LOCK'>, 'MERGE': <TokenType.MERGE: 'MERGE'>, 'NATURAL': <TokenType.NATURAL: 'NATURAL'>, 'NEXT': <TokenType.NEXT: 'NEXT'>, 'NOT': <TokenType.NOT: 'NOT'>, 'NOTNULL': <TokenType.NOTNULL: 'NOTNULL'>, 'NULL': <TokenType.NULL: 'NULL'>, 'OBJECT': <TokenType.OBJECT: 'OBJECT'>, 'OFFSET': <TokenType.OFFSET: 'OFFSET'>, 'ON': <TokenType.ON: 'ON'>, 'OR': <TokenType.OR: 'OR'>, 'XOR': <TokenType.XOR: 'XOR'>, 'ORDER BY': <TokenType.ORDER_BY: 'ORDER_BY'>, 'ORDINALITY': <TokenType.ORDINALITY: 'ORDINALITY'>, 'OUTER': <TokenType.OUTER: 'OUTER'>, 'OVER': <TokenType.OVER: 'OVER'>, 'OVERLAPS': <TokenType.OVERLAPS: 'OVERLAPS'>, 'OVERWRITE': <TokenType.OVERWRITE: 'OVERWRITE'>, 'PARTITION': <TokenType.PARTITION: 'PARTITION'>, 'PARTITION BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED_BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PERCENT': <TokenType.PERCENT: 'PERCENT'>, 'PIVOT': <TokenType.PIVOT: 'PIVOT'>, 'PRAGMA': <TokenType.PRAGMA: 'PRAGMA'>, 'PRIMARY KEY': <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, 'PROCEDURE': <TokenType.PROCEDURE: 'PROCEDURE'>, 'QUALIFY': <TokenType.QUALIFY: 'QUALIFY'>, 'RANGE': <TokenType.RANGE: 'RANGE'>, 'RECURSIVE': <TokenType.RECURSIVE: 'RECURSIVE'>, 'REGEXP': <TokenType.RLIKE: 'RLIKE'>, 'REPLACE': <TokenType.REPLACE: 'REPLACE'>, 'RETURNING': <TokenType.RETURNING: 'RETURNING'>, 'REFERENCES': <TokenType.REFERENCES: 'REFERENCES'>, 'RIGHT': <TokenType.RIGHT: 'RIGHT'>, 'RLIKE': <TokenType.RLIKE: 'RLIKE'>, 'ROLLBACK': <TokenType.ROLLBACK: 'ROLLBACK'>, 'ROLLUP': <TokenType.ROLLUP: 'ROLLUP'>, 'ROW': <TokenType.ROW: 'ROW'>, 'ROWS': <TokenType.ROWS: 'ROWS'>, 'SCHEMA': <TokenType.SCHEMA: 'SCHEMA'>, 'SELECT': <TokenType.SELECT: 'SELECT'>, 'SEMI': <TokenType.SEMI: 'SEMI'>, 'SET': <TokenType.SET: 'SET'>, 'SETTINGS': <TokenType.SETTINGS: 'SETTINGS'>, 'SHOW': <TokenType.SHOW: 'SHOW'>, 'SIMILAR TO': <TokenType.SIMILAR_TO: 'SIMILAR_TO'>, 'SOME': <TokenType.SOME: 'SOME'>, 'SORT BY': <TokenType.SORT_BY: 'SORT_BY'>, 'START WITH': <TokenType.START_WITH: 'START_WITH'>, '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'>, 'UNION': <TokenType.UNION: 'UNION'>, 'UNKNOWN': <TokenType.UNKNOWN: 'UNKNOWN'>, 'UNNEST': <TokenType.UNNEST: 'UNNEST'>, 'UNPIVOT': <TokenType.UNPIVOT: 'UNPIVOT'>, 'UPDATE': <TokenType.UPDATE: 'UPDATE'>, 'USE': <TokenType.USE: 'USE'>, 'USING': <TokenType.USING: 'USING'>, 'UUID': <TokenType.UUID: 'UUID'>, 'VIEW': <TokenType.VIEW: 'VIEW'>, 'VOLATILE': <TokenType.VOLATILE: 'VOLATILE'>, 'WHEN': <TokenType.WHEN: 'WHEN'>, 'WHERE': <TokenType.WHERE: 'WHERE'>, 'WINDOW': <TokenType.WINDOW: 'WINDOW'>, 'WITH': <TokenType.WITH: 'WITH'>, 'APPLY': <TokenType.APPLY: 'APPLY'>, 'ARRAY': <TokenType.ARRAY: 'ARRAY'>, 'BIT': <TokenType.BIT: 'BIT'>, 'BOOL': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BOOLEAN': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BYTE': <TokenType.TINYINT: 'TINYINT'>, 'MEDIUMINT': <TokenType.MEDIUMINT: 'MEDIUMINT'>, 'INT1': <TokenType.TINYINT: 'TINYINT'>, 'TINYINT': <TokenType.TINYINT: 'TINYINT'>, 'INT16': <TokenType.SMALLINT: 'SMALLINT'>, 'SHORT': <TokenType.SMALLINT: 'SMALLINT'>, 'SMALLINT': <TokenType.SMALLINT: 'SMALLINT'>, 'INT128': <TokenType.INT128: 'INT128'>, 'HUGEINT': <TokenType.INT128: 'INT128'>, 'INT2': <TokenType.SMALLINT: 'SMALLINT'>, 'INTEGER': <TokenType.INT: 'INT'>, 'INT': <TokenType.INT: 'INT'>, 'INT4': <TokenType.INT: 'INT'>, 'INT32': <TokenType.INT: 'INT'>, 'INT64': <TokenType.BIGINT: 'BIGINT'>, 'LONG': <TokenType.BIGINT: 'BIGINT'>, 'BIGINT': <TokenType.BIGINT: 'BIGINT'>, 'INT8': <TokenType.TINYINT: 'TINYINT'>, 'DEC': <TokenType.DECIMAL: 'DECIMAL'>, 'DECIMAL': <TokenType.DECIMAL: 'DECIMAL'>, 'BIGDECIMAL': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, 'BIGNUMERIC': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, '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'>, 'CHAR': <TokenType.CHAR: 'CHAR'>, 'CHARACTER': <TokenType.CHAR: 'CHAR'>, 'NCHAR': <TokenType.NCHAR: 'NCHAR'>, 'VARCHAR': <TokenType.VARCHAR: 'VARCHAR'>, 'VARCHAR2': <TokenType.VARCHAR: 'VARCHAR'>, 'NVARCHAR': <TokenType.NVARCHAR: 'NVARCHAR'>, 'NVARCHAR2': <TokenType.NVARCHAR: 'NVARCHAR'>, 'BPCHAR': <TokenType.BPCHAR: 'BPCHAR'>, 'STR': <TokenType.TEXT: 'TEXT'>, 'STRING': <TokenType.TEXT: 'TEXT'>, 'TEXT': <TokenType.TEXT: 'TEXT'>, 'LONGTEXT': <TokenType.LONGTEXT: 'LONGTEXT'>, 'MEDIUMTEXT': <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, 'TINYTEXT': <TokenType.TINYTEXT: 'TINYTEXT'>, 'CLOB': <TokenType.TEXT: 'TEXT'>, 'LONGVARCHAR': <TokenType.TEXT: 'TEXT'>, 'BINARY': <TokenType.BINARY: 'BINARY'>, 'BLOB': <TokenType.VARBINARY: 'VARBINARY'>, 'LONGBLOB': <TokenType.LONGBLOB: 'LONGBLOB'>, 'MEDIUMBLOB': <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, 'TINYBLOB': <TokenType.TINYBLOB: 'TINYBLOB'>, 'BYTEA': <TokenType.VARBINARY: 'VARBINARY'>, 'VARBINARY': <TokenType.VARBINARY: 'VARBINARY'>, 'TIME': <TokenType.TIME: 'TIME'>, 'TIMETZ': <TokenType.TIMETZ: 'TIMETZ'>, 'TIMESTAMP': <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, 'TIMESTAMPTZ': <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, 'TIMESTAMPLTZ': <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, 'DATE': <TokenType.DATE: 'DATE'>, 'DATETIME': <TokenType.DATETIME: 'DATETIME'>, 'INT4RANGE': <TokenType.INT4RANGE: 'INT4RANGE'>, 'INT4MULTIRANGE': <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, 'INT8RANGE': <TokenType.INT8RANGE: 'INT8RANGE'>, 'INT8MULTIRANGE': <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, 'NUMRANGE': <TokenType.NUMRANGE: 'NUMRANGE'>, 'NUMMULTIRANGE': <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, 'TSRANGE': <TokenType.TSRANGE: 'TSRANGE'>, 'TSMULTIRANGE': <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, 'TSTZRANGE': <TokenType.TSTZRANGE: 'TSTZRANGE'>, 'TSTZMULTIRANGE': <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, 'DATERANGE': <TokenType.DATERANGE: 'DATERANGE'>, 'DATEMULTIRANGE': <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, 'UNIQUE': <TokenType.UNIQUE: 'UNIQUE'>, 'STRUCT': <TokenType.STRUCT: 'STRUCT'>, 'VARIANT': <TokenType.VARIANT: 'VARIANT'>, 'ALTER': <TokenType.ALTER: 'ALTER'>, 'ANALYZE': <TokenType.COMMAND: 'COMMAND'>, 'CALL': <TokenType.COMMAND: 'COMMAND'>, 'COMMENT': <TokenType.COMMENT: 'COMMENT'>, 'COPY': <TokenType.COMMAND: 'COMMAND'>, 'EXPLAIN': <TokenType.COMMAND: 'COMMAND'>, 'GRANT': <TokenType.COMMAND: 'COMMAND'>, 'OPTIMIZE': <TokenType.COMMAND: 'COMMAND'>, 'PREPARE': <TokenType.COMMAND: 'COMMAND'>, 'TRUNCATE': <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'>, 'BYTES': <TokenType.BINARY: 'BINARY'>, 'CURRENT_DATETIME': <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, 'DECLARE': <TokenType.COMMAND: 'COMMAND'>, 'FLOAT64': <TokenType.DOUBLE: 'DOUBLE'>, 'FOR SYSTEM_TIME': <TokenType.TIMESTAMP_SNAPSHOT: 'TIMESTAMP_SNAPSHOT'>, 'MODEL': <TokenType.MODEL: 'MODEL'>, 'NOT DETERMINISTIC': <TokenType.VOLATILE: 'VOLATILE'>, 'RECORD': <TokenType.STRUCT: 'STRUCT'>}

##### Inherited Members

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

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

    337    class Parser(parser.Parser):
    338        PREFIXED_PIVOT_COLUMNS = True
    339
    340        LOG_DEFAULTS_TO_LN = True
    341
    342        FUNCTIONS = {
    343            **parser.Parser.FUNCTIONS,
    344            "DATE": _parse_date,
    345            "DATE_ADD": parse_date_delta_with_interval(exp.DateAdd),
    346            "DATE_SUB": parse_date_delta_with_interval(exp.DateSub),
    347            "DATE_TRUNC": lambda args: exp.DateTrunc(
    348                unit=exp.Literal.string(str(seq_get(args, 1))),
    349                this=seq_get(args, 0),
    350            ),
    351            "DATETIME_ADD": parse_date_delta_with_interval(exp.DatetimeAdd),
    352            "DATETIME_SUB": parse_date_delta_with_interval(exp.DatetimeSub),
    353            "DIV": binary_from_function(exp.IntDiv),
    354            "FORMAT_DATE": lambda args: exp.TimeToStr(
    355                this=exp.TsOrDsToDate(this=seq_get(args, 1)), format=seq_get(args, 0)
    356            ),
    357            "GENERATE_ARRAY": exp.GenerateSeries.from_arg_list,
    358            "JSON_EXTRACT_SCALAR": lambda args: exp.JSONExtractScalar(
    359                this=seq_get(args, 0), expression=seq_get(args, 1) or exp.Literal.string("$")
    360            ),
    361            "MD5": exp.MD5Digest.from_arg_list,
    362            "TO_HEX": _parse_to_hex,
    363            "PARSE_DATE": lambda args: format_time_lambda(exp.StrToDate, "bigquery")(
    364                [seq_get(args, 1), seq_get(args, 0)]
    365            ),
    366            "PARSE_TIMESTAMP": _parse_parse_timestamp,
    367            "REGEXP_CONTAINS": exp.RegexpLike.from_arg_list,
    368            "REGEXP_EXTRACT": lambda args: exp.RegexpExtract(
    369                this=seq_get(args, 0),
    370                expression=seq_get(args, 1),
    371                position=seq_get(args, 2),
    372                occurrence=seq_get(args, 3),
    373                group=exp.Literal.number(1) if re.compile(args[1].name).groups == 1 else None,
    374            ),
    375            "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
    376            "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
    377            "SPLIT": lambda args: exp.Split(
    378                # https://cloud.google.com/bigquery/docs/reference/standard-sql/string_functions#split
    379                this=seq_get(args, 0),
    380                expression=seq_get(args, 1) or exp.Literal.string(","),
    381            ),
    382            "TIME": _parse_time,
    383            "TIME_ADD": parse_date_delta_with_interval(exp.TimeAdd),
    384            "TIME_SUB": parse_date_delta_with_interval(exp.TimeSub),
    385            "TIMESTAMP": _parse_timestamp,
    386            "TIMESTAMP_ADD": parse_date_delta_with_interval(exp.TimestampAdd),
    387            "TIMESTAMP_SUB": parse_date_delta_with_interval(exp.TimestampSub),
    388            "TIMESTAMP_MICROS": lambda args: exp.UnixToTime(
    389                this=seq_get(args, 0), scale=exp.UnixToTime.MICROS
    390            ),
    391            "TIMESTAMP_MILLIS": lambda args: exp.UnixToTime(
    392                this=seq_get(args, 0), scale=exp.UnixToTime.MILLIS
    393            ),
    394            "TIMESTAMP_SECONDS": lambda args: exp.UnixToTime(this=seq_get(args, 0)),
    395            "TO_JSON_STRING": exp.JSONFormat.from_arg_list,
    396        }
    397
    398        FUNCTION_PARSERS = {
    399            **parser.Parser.FUNCTION_PARSERS,
    400            "ARRAY": lambda self: self.expression(exp.Array, expressions=[self._parse_statement()]),
    401        }
    402        FUNCTION_PARSERS.pop("TRIM")
    403
    404        NO_PAREN_FUNCTIONS = {
    405            **parser.Parser.NO_PAREN_FUNCTIONS,
    406            TokenType.CURRENT_DATETIME: exp.CurrentDatetime,
    407        }
    408
    409        NESTED_TYPE_TOKENS = {
    410            *parser.Parser.NESTED_TYPE_TOKENS,
    411            TokenType.TABLE,
    412        }
    413
    414        PROPERTY_PARSERS = {
    415            **parser.Parser.PROPERTY_PARSERS,
    416            "NOT DETERMINISTIC": lambda self: self.expression(
    417                exp.StabilityProperty, this=exp.Literal.string("VOLATILE")
    418            ),
    419            "OPTIONS": lambda self: self._parse_with_property(),
    420        }
    421
    422        CONSTRAINT_PARSERS = {
    423            **parser.Parser.CONSTRAINT_PARSERS,
    424            "OPTIONS": lambda self: exp.Properties(expressions=self._parse_with_property()),
    425        }
    426
    427        RANGE_PARSERS = parser.Parser.RANGE_PARSERS.copy()
    428        RANGE_PARSERS.pop(TokenType.OVERLAPS, None)
    429
    430        NULL_TOKENS = {TokenType.NULL, TokenType.UNKNOWN}
    431
    432        STATEMENT_PARSERS = {
    433            **parser.Parser.STATEMENT_PARSERS,
    434            TokenType.END: lambda self: self._parse_as_command(self._prev),
    435            TokenType.FOR: lambda self: self._parse_for_in(),
    436        }
    437
    438        BRACKET_OFFSETS = {
    439            "OFFSET": (0, False),
    440            "ORDINAL": (1, False),
    441            "SAFE_OFFSET": (0, True),
    442            "SAFE_ORDINAL": (1, True),
    443        }
    444
    445        def _parse_for_in(self) -> exp.ForIn:
    446            this = self._parse_range()
    447            self._match_text_seq("DO")
    448            return self.expression(exp.ForIn, this=this, expression=self._parse_statement())
    449
    450        def _parse_table_part(self, schema: bool = False) -> t.Optional[exp.Expression]:
    451            this = super()._parse_table_part(schema=schema) or self._parse_number()
    452
    453            # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#table_names
    454            if isinstance(this, exp.Identifier):
    455                table_name = this.name
    456                while self._match(TokenType.DASH, advance=False) and self._next:
    457                    self._advance(2)
    458                    table_name += f"-{self._prev.text}"
    459
    460                this = exp.Identifier(this=table_name, quoted=this.args.get("quoted"))
    461            elif isinstance(this, exp.Literal):
    462                table_name = this.name
    463
    464                if self._is_connected() and self._parse_var(any_token=True):
    465                    table_name += self._prev.text
    466
    467                this = exp.Identifier(this=table_name, quoted=True)
    468
    469            return this
    470
    471        def _parse_table_parts(
    472            self, schema: bool = False, is_db_reference: bool = False
    473        ) -> exp.Table:
    474            table = super()._parse_table_parts(schema=schema, is_db_reference=is_db_reference)
    475            if isinstance(table.this, exp.Identifier) and "." in table.name:
    476                catalog, db, this, *rest = (
    477                    t.cast(t.Optional[exp.Expression], exp.to_identifier(x))
    478                    for x in split_num_words(table.name, ".", 3)
    479                )
    480
    481                if rest and this:
    482                    this = exp.Dot.build(t.cast(t.List[exp.Expression], [this, *rest]))
    483
    484                table = exp.Table(this=this, db=db, catalog=catalog)
    485
    486            return table
    487
    488        @t.overload
    489        def _parse_json_object(self, agg: Lit[False]) -> exp.JSONObject:
    490            ...
    491
    492        @t.overload
    493        def _parse_json_object(self, agg: Lit[True]) -> exp.JSONObjectAgg:
    494            ...
    495
    496        def _parse_json_object(self, agg=False):
    497            json_object = super()._parse_json_object()
    498            array_kv_pair = seq_get(json_object.expressions, 0)
    499
    500            # Converts BQ's "signature 2" of JSON_OBJECT into SQLGlot's canonical representation
    501            # https://cloud.google.com/bigquery/docs/reference/standard-sql/json_functions#json_object_signature2
    502            if (
    503                array_kv_pair
    504                and isinstance(array_kv_pair.this, exp.Array)
    505                and isinstance(array_kv_pair.expression, exp.Array)
    506            ):
    507                keys = array_kv_pair.this.expressions
    508                values = array_kv_pair.expression.expressions
    509
    510                json_object.set(
    511                    "expressions",
    512                    [exp.JSONKeyValue(this=k, expression=v) for k, v in zip(keys, values)],
    513                )
    514
    515            return json_object
    516
    517        def _parse_bracket(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    518            bracket = super()._parse_bracket(this)
    519
    520            if this is bracket:
    521                return bracket
    522
    523            if isinstance(bracket, exp.Bracket):
    524                for expression in bracket.expressions:
    525                    name = expression.name.upper()
    526
    527                    if name not in self.BRACKET_OFFSETS:
    528                        break
    529
    530                    offset, safe = self.BRACKET_OFFSETS[name]
    531                    bracket.set("offset", offset)
    532                    bracket.set("safe", safe)
    533                    expression.replace(expression.expressions[0])
    534
    535            return bracket

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: Determines 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
FUNCTIONS = {'ABS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Abs'>>, 'ANONYMOUS_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnonymousAggFunc'>>, 'ANY_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnyValue'>>, 'APPROX_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_COUNT_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxQuantile'>>, 'APPROX_TOP_K': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxTopK'>>, 'ARG_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARGMAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'MAX_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARG_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARGMIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'MIN_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Array'>>, 'ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAgg'>>, 'ARRAY_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAll'>>, 'ARRAY_ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAny'>>, 'ARRAY_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContains'>>, '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_JOIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayJoin'>>, 'ARRAY_OVERLAPS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayOverlaps'>>, 'ARRAY_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_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_UNION_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUnionAgg'>>, 'ARRAY_UNIQUE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUniqueAgg'>>, 'AVG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Avg'>>, 'CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Case'>>, 'CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cast'>>, 'CAST_TO_STR_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CastToStrType'>>, 'CBRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cbrt'>>, 'CEIL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CEILING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CHR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Chr'>>, 'CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Chr'>>, 'COALESCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'IFNULL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'NVL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'COLLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Collate'>>, 'COMBINED_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedAggFunc'>>, 'COMBINED_PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedParameterizedAgg'>>, 'CONCAT': <function Parser.<lambda>>, 'CONCAT_WS': <function Parser.<lambda>>, 'COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Count'>>, 'COUNT_IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CountIf'>>, 'COUNTIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CountIf'>>, 'CURRENT_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDate'>>, 'CURRENT_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDatetime'>>, 'CURRENT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTime'>>, 'CURRENT_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTimestamp'>>, 'CURRENT_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentUser'>>, 'DATE': <function _parse_date>, 'DATE_ADD': <function parse_date_delta_with_interval.<locals>.func>, 'DATEDIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateDiff'>>, 'DATE_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateDiff'>>, 'DATE_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATE_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateStrToDate'>>, 'DATE_SUB': <function parse_date_delta_with_interval.<locals>.func>, '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_ADD': <function parse_date_delta_with_interval.<locals>.func>, 'DATETIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeDiff'>>, 'DATETIME_SUB': <function parse_date_delta_with_interval.<locals>.func>, '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'>>, 'DAY_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DAYOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DECODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Decode'>>, 'DI_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DiToDate'>>, 'ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Encode'>>, 'EXP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Exp'>>, 'EXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Explode'>>, 'EXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ExplodeOuter'>>, 'EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Extract'>>, 'FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.First'>>, 'FIRST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FirstValue'>>, 'FLATTEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Flatten'>>, 'FLOOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Floor'>>, 'FROM_BASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase'>>, 'FROM_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase64'>>, 'GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateSeries'>>, 'GREATEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Greatest'>>, 'GROUP_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GroupConcat'>>, 'HEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Hex'>>, 'HLL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Hll'>>, 'IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'IIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'INITCAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Initcap'>>, 'IS_INF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'ISINF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'IS_NAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'ISNAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'J_S_O_N_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArray'>>, 'J_S_O_N_ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayAgg'>>, 'JSON_ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayContains'>>, 'JSONB_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtract'>>, 'JSONB_EXTRACT_SCALAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtractScalar'>>, 'JSON_EXTRACT': <function parse_extract_json_with_path.<locals>._parser>, 'JSON_EXTRACT_SCALAR': <function BigQuery.Parser.<lambda>>, 'JSON_FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONFormat'>>, 'J_S_O_N_OBJECT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObject'>>, 'J_S_O_N_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObjectAgg'>>, 'J_S_O_N_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONTable'>>, 'LAG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lag'>>, 'LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Last'>>, 'LAST_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastValue'>>, 'LEAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lead'>>, 'LEAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Least'>>, 'LEFT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Left'>>, 'LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEVENSHTEIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Levenshtein'>>, 'LN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ln'>>, 'LOG': <function parse_logarithm>, 'LOG10': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Log10'>>, 'LOG2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Log2'>>, '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': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lower'>>, 'LCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lower'>>, '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'>>, 'MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Map'>>, 'MAP_FROM_ENTRIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MapFromEntries'>>, 'MATCH_AGAINST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MatchAgainst'>>, 'MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Max'>>, 'MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Min'>>, 'MONTH': <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'>>, 'NTH_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NthValue'>>, 'NULLIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nullif'>>, 'NUMBER_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NumberToStr'>>, 'NVL2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nvl2'>>, 'OPEN_J_S_O_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.OpenJSON'>>, 'PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParameterizedAgg'>>, 'PARSE_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'JSON_PARSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'PERCENTILE_CONT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileCont'>>, 'PERCENTILE_DISC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileDisc'>>, 'POSEXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Posexplode'>>, 'POSEXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PosexplodeOuter'>>, 'POWER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'POW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'PREDICT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Predict'>>, 'QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quantile'>>, 'RAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDOM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Randn'>>, 'RANGE_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RangeN'>>, 'READ_CSV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ReadCSV'>>, 'REDUCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Reduce'>>, 'REGEXP_EXTRACT': <function BigQuery.Parser.<lambda>>, 'REGEXP_I_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpILike'>>, 'REGEXP_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpLike'>>, 'REGEXP_REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpReplace'>>, 'REGEXP_SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpSplit'>>, 'REPEAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Repeat'>>, 'RIGHT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Right'>>, 'ROUND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Round'>>, 'ROW_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RowNumber'>>, 'SHA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA2'>>, 'SAFE_DIVIDE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SafeDivide'>>, 'SORT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SortArray'>>, 'SPLIT': <function BigQuery.Parser.<lambda>>, 'SQRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sqrt'>>, 'STANDARD_HASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StandardHash'>>, 'STAR_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StarMap'>>, 'STARTS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STARTSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STDDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stddev'>>, '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'>>, 'STRUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Struct'>>, 'STRUCT_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StructExtract'>>, 'STUFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'SUBSTRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Substring'>>, 'SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sum'>>, 'TIME_ADD': <function parse_date_delta_with_interval.<locals>.func>, '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 parse_date_delta_with_interval.<locals>.func>, '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 _parse_timestamp>, 'TIMESTAMP_ADD': <function parse_date_delta_with_interval.<locals>.func>, '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 parse_date_delta_with_interval.<locals>.func>, 'TIMESTAMP_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampTrunc'>>, 'TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToArray'>>, 'TO_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToBase64'>>, 'TO_CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToChar'>>, 'TO_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToDays'>>, 'TRANSFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Transform'>>, 'TRIM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Trim'>>, 'TRY_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TryCast'>>, 'TS_OR_DI_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDiToDi'>>, 'TS_OR_DS_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsAdd'>>, 'TS_OR_DS_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsDiff'>>, 'TS_OR_DS_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToDate'>>, 'TS_OR_DS_TO_DATE_STR': <function Parser.<lambda>>, 'TS_OR_DS_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTime'>>, 'UNHEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Unhex'>>, 'UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixDate'>>, 'UNIX_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToStr'>>, 'UNIX_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTime'>>, 'UNIX_TO_TIME_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTimeStr'>>, 'UPPER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Upper'>>, 'UCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Upper'>>, 'VAR_MAP': <function parse_var_map>, 'VARIANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'VAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Week'>>, 'WEEK_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'WEEKOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'WHEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.When'>>, 'X_M_L_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.XMLTable'>>, 'XOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Xor'>>, 'YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Year'>>, 'GLOB': <function Parser.<lambda>>, 'JSON_EXTRACT_PATH_TEXT': <function parse_extract_json_with_path.<locals>._parser>, 'LIKE': <function parse_like>, 'DIV': <function binary_from_function.<locals>.<lambda>>, 'FORMAT_DATE': <function BigQuery.Parser.<lambda>>, 'GENERATE_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateSeries'>>, 'TO_HEX': <function _parse_to_hex>, 'PARSE_DATE': <function BigQuery.Parser.<lambda>>, 'PARSE_TIMESTAMP': <function _parse_parse_timestamp>, 'REGEXP_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpLike'>>, 'SHA256': <function BigQuery.Parser.<lambda>>, 'SHA512': <function BigQuery.Parser.<lambda>>, 'TIME': <function _parse_time>, 'TIMESTAMP_MICROS': <function BigQuery.Parser.<lambda>>, 'TIMESTAMP_MILLIS': <function BigQuery.Parser.<lambda>>, 'TIMESTAMP_SECONDS': <function BigQuery.Parser.<lambda>>, 'TO_JSON_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONFormat'>>}
FUNCTION_PARSERS = {'CAST': <function Parser.<lambda>>, 'CONVERT': <function Parser.<lambda>>, 'DECODE': <function Parser.<lambda>>, 'EXTRACT': <function Parser.<lambda>>, 'JSON_OBJECT': <function Parser.<lambda>>, 'JSON_OBJECTAGG': <function Parser.<lambda>>, 'JSON_TABLE': <function Parser.<lambda>>, 'MATCH': <function Parser.<lambda>>, 'OPENJSON': <function Parser.<lambda>>, 'POSITION': <function Parser.<lambda>>, 'PREDICT': <function Parser.<lambda>>, 'SAFE_CAST': <function Parser.<lambda>>, 'STRING_AGG': <function Parser.<lambda>>, 'SUBSTRING': <function Parser.<lambda>>, 'TRY_CAST': <function Parser.<lambda>>, 'TRY_CONVERT': <function Parser.<lambda>>, 'ARRAY': <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.TABLE: 'TABLE'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.MAP: 'MAP'>, <TokenType.NESTED: 'NESTED'>}
PROPERTY_PARSERS = {'ALGORITHM': <function Parser.<lambda>>, 'AUTO': <function Parser.<lambda>>, 'AUTO_INCREMENT': <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>>, 'DEFINER': <function Parser.<lambda>>, 'DETERMINISTIC': <function Parser.<lambda>>, 'DISTKEY': <function Parser.<lambda>>, 'DISTSTYLE': <function Parser.<lambda>>, 'ENGINE': <function Parser.<lambda>>, 'EXECUTE': <function Parser.<lambda>>, 'EXTERNAL': <function Parser.<lambda>>, 'FALLBACK': <function Parser.<lambda>>, 'FORMAT': <function Parser.<lambda>>, 'FREESPACE': <function Parser.<lambda>>, 'HEAP': <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>>, 'ROW': <function Parser.<lambda>>, 'ROW_FORMAT': <function Parser.<lambda>>, 'SAMPLE': <function Parser.<lambda>>, 'SET': <function Parser.<lambda>>, 'SETTINGS': <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>>, '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>>, '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>>, 'WITH': <function Parser.<lambda>>, 'OPTIONS': <function BigQuery.Parser.<lambda>>}
RANGE_PARSERS = {<TokenType.BETWEEN: 'BETWEEN'>: <function Parser.<lambda>>, <TokenType.GLOB: 'GLOB'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.ILIKE: 'ILIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.IN: 'IN'>: <function Parser.<lambda>>, <TokenType.IRLIKE: 'IRLIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.IS: 'IS'>: <function Parser.<lambda>>, <TokenType.LIKE: 'LIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.RLIKE: 'RLIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.SIMILAR_TO: 'SIMILAR_TO'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.FOR: 'FOR'>: <function Parser.<lambda>>}
NULL_TOKENS = {<TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.NULL: 'NULL'>}
STATEMENT_PARSERS = {<TokenType.ALTER: 'ALTER'>: <function Parser.<lambda>>, <TokenType.BEGIN: 'BEGIN'>: <function Parser.<lambda>>, <TokenType.CACHE: 'CACHE'>: <function Parser.<lambda>>, <TokenType.COMMIT: 'COMMIT'>: <function Parser.<lambda>>, <TokenType.COMMENT: 'COMMENT'>: <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.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.UNCACHE: 'UNCACHE'>: <function Parser.<lambda>>, <TokenType.UPDATE: 'UPDATE'>: <function Parser.<lambda>>, <TokenType.USE: 'USE'>: <function Parser.<lambda>>, <TokenType.END: 'END'>: <function BigQuery.Parser.<lambda>>, <TokenType.FOR: 'FOR'>: <function BigQuery.Parser.<lambda>>}
BRACKET_OFFSETS = {'OFFSET': (0, False), 'ORDINAL': (1, False), 'SAFE_OFFSET': (0, True), 'SAFE_ORDINAL': (1, True)}
TABLE_ALIAS_TOKENS = {<TokenType.BIT: 'BIT'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.FIRST: 'FIRST'>, <TokenType.RANGE: 'RANGE'>, <TokenType.TIME: 'TIME'>, <TokenType.INT: 'INT'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.IS: 'IS'>, <TokenType.XML: 'XML'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.VAR: 'VAR'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.ROWS: 'ROWS'>, <TokenType.MERGE: 'MERGE'>, <TokenType.ANY: 'ANY'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.CACHE: 'CACHE'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.JSONB: 'JSONB'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.ENUM: 'ENUM'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.INDEX: 'INDEX'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.FINAL: 'FINAL'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.USE: 'USE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.IPV6: 'IPV6'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.ASC: 'ASC'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.BINARY: 'BINARY'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.DATE: 'DATE'>, <TokenType.SUPER: 'SUPER'>, <TokenType.TOP: 'TOP'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.FILTER: 'FILTER'>, <TokenType.TEXT: 'TEXT'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.TRUE: 'TRUE'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.SHOW: 'SHOW'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.SET: 'SET'>, <TokenType.NESTED: 'NESTED'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.MONEY: 'MONEY'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.NULL: 'NULL'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.NEXT: 'NEXT'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.ALL: 'ALL'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.ROW: 'ROW'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.TABLE: 'TABLE'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.CASE: 'CASE'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.MODEL: 'MODEL'>, <TokenType.YEAR: 'YEAR'>, <TokenType.IPV4: 'IPV4'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.INT256: 'INT256'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.INET: 'INET'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.MAP: 'MAP'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.UINT: 'UINT'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.UINT256: 'UINT256'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.CHAR: 'CHAR'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.DIV: 'DIV'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.UINT128: 'UINT128'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.DELETE: 'DELETE'>, <TokenType.LOAD: 'LOAD'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.UUID: 'UUID'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.DATE32: 'DATE32'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.VIEW: 'VIEW'>, <TokenType.JSON: 'JSON'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.KEEP: 'KEEP'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.END: 'END'>, <TokenType.INT128: 'INT128'>, <TokenType.KILL: 'KILL'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.SEMI: 'SEMI'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.SOME: 'SOME'>, <TokenType.ANTI: 'ANTI'>, <TokenType.FALSE: 'FALSE'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.DESC: 'DESC'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.UPDATE: 'UPDATE'>}
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
  ID_VAR_TOKENS
  INTERVAL_VARS
  COMMENT_TABLE_ALIAS_TOKENS
  UPDATE_ALIAS_TOKENS
  TRIM_TYPES
  FUNC_TOKENS
  CONJUNCTION
  EQUALITY
  COMPARISON
  BITWISE
  TERM
  FACTOR
  EXPONENT
  TIMES
  TIMESTAMPS
  SET_OPERATIONS
  JOIN_METHODS
  JOIN_SIDES
  JOIN_KINDS
  JOIN_HINTS
  LAMBDAS
  COLUMN_OPERATORS
  EXPRESSION_PARSERS
  UNARY_PARSERS
  PRIMARY_PARSERS
  PLACEHOLDER_PARSERS
  ALTER_PARSERS
  SCHEMA_UNNAMED_CONSTRAINTS
  NO_PAREN_FUNCTION_PARSERS
  INVALID_FUNC_NAME_TOKENS
  FUNCTIONS_WITH_ALIASED_ARGS
  QUERY_MODIFIER_PARSERS
  SET_PARSERS
  SHOW_PARSERS
  TYPE_LITERAL_PARSERS
  MODIFIABLES
  DDL_SELECT_TOKENS
  PRE_VOLATILE_TOKENS
  TRANSACTION_KIND
  TRANSACTION_CHARACTERISTICS
  INSERT_ALTERNATIVES
  CLONE_KEYWORDS
  HISTORICAL_DATA_KIND
  OPCLASS_FOLLOW_KEYWORDS
  OPTYPE_FOLLOW_TOKENS
  TABLE_INDEX_HINT_TOKENS
  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
  STRICT_CAST
  IDENTIFY_PIVOT_STRINGS
  ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN
  TABLESAMPLE_CSV
  SET_REQUIRES_ASSIGNMENT_DELIMITER
  TRIM_PATTERN_FIRST
  STRING_ALIASES
  MODIFIERS_ATTACHED_TO_UNION
  UNION_MODIFIERS
  NO_PAREN_IF_COMMANDS
  VALUES_FOLLOWED_BY_PAREN
  error_level
  error_message_context
  max_errors
  dialect
  reset
  parse
  parse_into
  check_errors
  raise_error
  expression
  validate_expression
  errors
  sql

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

    537    class Generator(generator.Generator):
    538        EXPLICIT_UNION = True
    539        INTERVAL_ALLOWS_PLURAL_FORM = False
    540        JOIN_HINTS = False
    541        QUERY_HINTS = False
    542        TABLE_HINTS = False
    543        LIMIT_FETCH = "LIMIT"
    544        RENAME_TABLE_WITH_DB = False
    545        NVL2_SUPPORTED = False
    546        UNNEST_WITH_ORDINALITY = False
    547        COLLATE_IS_FUNC = True
    548        LIMIT_ONLY_LITERALS = True
    549        SUPPORTS_TABLE_ALIAS_COLUMNS = False
    550        UNPIVOT_ALIASES_ARE_IDENTIFIERS = False
    551        JSON_KEY_VALUE_PAIR_SEP = ","
    552        NULL_ORDERING_SUPPORTED = False
    553        IGNORE_NULLS_IN_FUNC = True
    554        JSON_PATH_SINGLE_QUOTE_ESCAPE = True
    555
    556        TRANSFORMS = {
    557            **generator.Generator.TRANSFORMS,
    558            exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
    559            exp.ArgMax: arg_max_or_min_no_count("MAX_BY"),
    560            exp.ArgMin: arg_max_or_min_no_count("MIN_BY"),
    561            exp.ArrayContains: _array_contains_sql,
    562            exp.ArraySize: rename_func("ARRAY_LENGTH"),
    563            exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]),
    564            exp.CollateProperty: lambda self, e: (
    565                f"DEFAULT COLLATE {self.sql(e, 'this')}"
    566                if e.args.get("default")
    567                else f"COLLATE {self.sql(e, 'this')}"
    568            ),
    569            exp.CountIf: rename_func("COUNTIF"),
    570            exp.Create: _create_sql,
    571            exp.CTE: transforms.preprocess([_pushdown_cte_column_names]),
    572            exp.DateAdd: date_add_interval_sql("DATE", "ADD"),
    573            exp.DateDiff: lambda self,
    574            e: f"DATE_DIFF({self.sql(e, 'this')}, {self.sql(e, 'expression')}, {self.sql(e.args.get('unit', 'DAY'))})",
    575            exp.DateFromParts: rename_func("DATE"),
    576            exp.DateStrToDate: datestrtodate_sql,
    577            exp.DateSub: date_add_interval_sql("DATE", "SUB"),
    578            exp.DatetimeAdd: date_add_interval_sql("DATETIME", "ADD"),
    579            exp.DatetimeSub: date_add_interval_sql("DATETIME", "SUB"),
    580            exp.DateTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, e.text("unit")),
    581            exp.FromTimeZone: lambda self, e: self.func(
    582                "DATETIME", self.func("TIMESTAMP", e.this, e.args.get("zone")), "'UTC'"
    583            ),
    584            exp.GenerateSeries: rename_func("GENERATE_ARRAY"),
    585            exp.GroupConcat: rename_func("STRING_AGG"),
    586            exp.Hex: rename_func("TO_HEX"),
    587            exp.If: if_sql(false_value="NULL"),
    588            exp.ILike: no_ilike_sql,
    589            exp.IntDiv: rename_func("DIV"),
    590            exp.JSONFormat: rename_func("TO_JSON_STRING"),
    591            exp.Max: max_or_greatest,
    592            exp.MD5: lambda self, e: self.func("TO_HEX", self.func("MD5", e.this)),
    593            exp.MD5Digest: rename_func("MD5"),
    594            exp.Min: min_or_least,
    595            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
    596            exp.RegexpExtract: lambda self, e: self.func(
    597                "REGEXP_EXTRACT",
    598                e.this,
    599                e.expression,
    600                e.args.get("position"),
    601                e.args.get("occurrence"),
    602            ),
    603            exp.RegexpReplace: regexp_replace_sql,
    604            exp.RegexpLike: rename_func("REGEXP_CONTAINS"),
    605            exp.ReturnsProperty: _returnsproperty_sql,
    606            exp.Select: transforms.preprocess(
    607                [
    608                    transforms.explode_to_unnest(),
    609                    _unqualify_unnest,
    610                    transforms.eliminate_distinct_on,
    611                    _alias_ordered_group,
    612                    transforms.eliminate_semi_and_anti_joins,
    613                ]
    614            ),
    615            exp.SHA2: lambda self, e: self.func(
    616                "SHA256" if e.text("length") == "256" else "SHA512", e.this
    617            ),
    618            exp.StabilityProperty: lambda self, e: (
    619                "DETERMINISTIC" if e.name == "IMMUTABLE" else "NOT DETERMINISTIC"
    620            ),
    621            exp.StrToDate: lambda self,
    622            e: f"PARSE_DATE({self.format_time(e)}, {self.sql(e, 'this')})",
    623            exp.StrToTime: lambda self, e: self.func(
    624                "PARSE_TIMESTAMP", self.format_time(e), e.this, e.args.get("zone")
    625            ),
    626            exp.TimeAdd: date_add_interval_sql("TIME", "ADD"),
    627            exp.TimeFromParts: rename_func("TIME"),
    628            exp.TimeSub: date_add_interval_sql("TIME", "SUB"),
    629            exp.TimestampAdd: date_add_interval_sql("TIMESTAMP", "ADD"),
    630            exp.TimestampDiff: rename_func("TIMESTAMP_DIFF"),
    631            exp.TimestampSub: date_add_interval_sql("TIMESTAMP", "SUB"),
    632            exp.TimeStrToTime: timestrtotime_sql,
    633            exp.Trim: lambda self, e: self.func("TRIM", e.this, e.expression),
    634            exp.TsOrDsAdd: _ts_or_ds_add_sql,
    635            exp.TsOrDsDiff: _ts_or_ds_diff_sql,
    636            exp.TsOrDsToTime: rename_func("TIME"),
    637            exp.Unhex: rename_func("FROM_HEX"),
    638            exp.UnixDate: rename_func("UNIX_DATE"),
    639            exp.UnixToTime: _unix_to_time_sql,
    640            exp.Values: _derived_table_values_to_unnest,
    641            exp.VariancePop: rename_func("VAR_POP"),
    642        }
    643
    644        SUPPORTED_JSON_PATH_PARTS = {
    645            exp.JSONPathKey,
    646            exp.JSONPathRoot,
    647            exp.JSONPathSubscript,
    648        }
    649
    650        TYPE_MAPPING = {
    651            **generator.Generator.TYPE_MAPPING,
    652            exp.DataType.Type.BIGDECIMAL: "BIGNUMERIC",
    653            exp.DataType.Type.BIGINT: "INT64",
    654            exp.DataType.Type.BINARY: "BYTES",
    655            exp.DataType.Type.BOOLEAN: "BOOL",
    656            exp.DataType.Type.CHAR: "STRING",
    657            exp.DataType.Type.DECIMAL: "NUMERIC",
    658            exp.DataType.Type.DOUBLE: "FLOAT64",
    659            exp.DataType.Type.FLOAT: "FLOAT64",
    660            exp.DataType.Type.INT: "INT64",
    661            exp.DataType.Type.NCHAR: "STRING",
    662            exp.DataType.Type.NVARCHAR: "STRING",
    663            exp.DataType.Type.SMALLINT: "INT64",
    664            exp.DataType.Type.TEXT: "STRING",
    665            exp.DataType.Type.TIMESTAMP: "DATETIME",
    666            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
    667            exp.DataType.Type.TIMESTAMPLTZ: "TIMESTAMP",
    668            exp.DataType.Type.TINYINT: "INT64",
    669            exp.DataType.Type.VARBINARY: "BYTES",
    670            exp.DataType.Type.VARCHAR: "STRING",
    671            exp.DataType.Type.VARIANT: "ANY TYPE",
    672        }
    673
    674        PROPERTIES_LOCATION = {
    675            **generator.Generator.PROPERTIES_LOCATION,
    676            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
    677            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
    678        }
    679
    680        # from: https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#reserved_keywords
    681        RESERVED_KEYWORDS = {
    682            *generator.Generator.RESERVED_KEYWORDS,
    683            "all",
    684            "and",
    685            "any",
    686            "array",
    687            "as",
    688            "asc",
    689            "assert_rows_modified",
    690            "at",
    691            "between",
    692            "by",
    693            "case",
    694            "cast",
    695            "collate",
    696            "contains",
    697            "create",
    698            "cross",
    699            "cube",
    700            "current",
    701            "default",
    702            "define",
    703            "desc",
    704            "distinct",
    705            "else",
    706            "end",
    707            "enum",
    708            "escape",
    709            "except",
    710            "exclude",
    711            "exists",
    712            "extract",
    713            "false",
    714            "fetch",
    715            "following",
    716            "for",
    717            "from",
    718            "full",
    719            "group",
    720            "grouping",
    721            "groups",
    722            "hash",
    723            "having",
    724            "if",
    725            "ignore",
    726            "in",
    727            "inner",
    728            "intersect",
    729            "interval",
    730            "into",
    731            "is",
    732            "join",
    733            "lateral",
    734            "left",
    735            "like",
    736            "limit",
    737            "lookup",
    738            "merge",
    739            "natural",
    740            "new",
    741            "no",
    742            "not",
    743            "null",
    744            "nulls",
    745            "of",
    746            "on",
    747            "or",
    748            "order",
    749            "outer",
    750            "over",
    751            "partition",
    752            "preceding",
    753            "proto",
    754            "qualify",
    755            "range",
    756            "recursive",
    757            "respect",
    758            "right",
    759            "rollup",
    760            "rows",
    761            "select",
    762            "set",
    763            "some",
    764            "struct",
    765            "tablesample",
    766            "then",
    767            "to",
    768            "treat",
    769            "true",
    770            "unbounded",
    771            "union",
    772            "unnest",
    773            "using",
    774            "when",
    775            "where",
    776            "window",
    777            "with",
    778            "within",
    779        }
    780
    781        def timetostr_sql(self, expression: exp.TimeToStr) -> str:
    782            if isinstance(expression.this, exp.TsOrDsToDate):
    783                this: exp.Expression = expression.this
    784            else:
    785                this = expression
    786
    787            return f"FORMAT_DATE({self.format_time(expression)}, {self.sql(this, 'this')})"
    788
    789        def struct_sql(self, expression: exp.Struct) -> str:
    790            args = []
    791            for expr in expression.expressions:
    792                if isinstance(expr, self.KEY_VALUE_DEFINITIONS):
    793                    arg = f"{self.sql(expr, 'expression')} AS {expr.this.name}"
    794                else:
    795                    arg = self.sql(expr)
    796
    797                args.append(arg)
    798
    799            return self.func("STRUCT", *args)
    800
    801        def eq_sql(self, expression: exp.EQ) -> str:
    802            # Operands of = cannot be NULL in BigQuery
    803            if isinstance(expression.left, exp.Null) or isinstance(expression.right, exp.Null):
    804                if not isinstance(expression.parent, exp.Update):
    805                    return "NULL"
    806
    807            return self.binary(expression, "=")
    808
    809        def attimezone_sql(self, expression: exp.AtTimeZone) -> str:
    810            parent = expression.parent
    811
    812            # BigQuery allows CAST(.. AS {STRING|TIMESTAMP} [FORMAT <fmt> [AT TIME ZONE <tz>]]).
    813            # Only the TIMESTAMP one should use the below conversion, when AT TIME ZONE is included.
    814            if not isinstance(parent, exp.Cast) or not parent.to.is_type("text"):
    815                return self.func(
    816                    "TIMESTAMP", self.func("DATETIME", expression.this, expression.args.get("zone"))
    817                )
    818
    819            return super().attimezone_sql(expression)
    820
    821        def trycast_sql(self, expression: exp.TryCast) -> str:
    822            return self.cast_sql(expression, safe_prefix="SAFE_")
    823
    824        def cte_sql(self, expression: exp.CTE) -> str:
    825            if expression.alias_column_names:
    826                self.unsupported("Column names in CTE definition are not supported.")
    827            return super().cte_sql(expression)
    828
    829        def array_sql(self, expression: exp.Array) -> str:
    830            first_arg = seq_get(expression.expressions, 0)
    831            if isinstance(first_arg, exp.Subqueryable):
    832                return f"ARRAY{self.wrap(self.sql(first_arg))}"
    833
    834            return inline_array_sql(self, expression)
    835
    836        def bracket_sql(self, expression: exp.Bracket) -> str:
    837            this = self.sql(expression, "this")
    838            expressions = expression.expressions
    839
    840            if len(expressions) == 1:
    841                arg = expressions[0]
    842                if arg.type is None:
    843                    from sqlglot.optimizer.annotate_types import annotate_types
    844
    845                    arg = annotate_types(arg)
    846
    847                if arg.type and arg.type.this in exp.DataType.TEXT_TYPES:
    848                    # BQ doesn't support bracket syntax with string values
    849                    return f"{this}.{arg.name}"
    850
    851            expressions_sql = ", ".join(self.sql(e) for e in expressions)
    852            offset = expression.args.get("offset")
    853
    854            if offset == 0:
    855                expressions_sql = f"OFFSET({expressions_sql})"
    856            elif offset == 1:
    857                expressions_sql = f"ORDINAL({expressions_sql})"
    858            elif offset is not None:
    859                self.unsupported(f"Unsupported array offset: {offset}")
    860
    861            if expression.args.get("safe"):
    862                expressions_sql = f"SAFE_{expressions_sql}"
    863
    864            return f"{this}[{expressions_sql}]"
    865
    866        def transaction_sql(self, *_) -> str:
    867            return "BEGIN TRANSACTION"
    868
    869        def commit_sql(self, *_) -> str:
    870            return "COMMIT TRANSACTION"
    871
    872        def rollback_sql(self, *_) -> str:
    873            return "ROLLBACK TRANSACTION"
    874
    875        def in_unnest_op(self, expression: exp.Unnest) -> str:
    876            return self.sql(expression)
    877
    878        def except_op(self, expression: exp.Except) -> str:
    879            if not expression.args.get("distinct", False):
    880                self.unsupported("EXCEPT without DISTINCT is not supported in BigQuery")
    881            return f"EXCEPT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
    882
    883        def intersect_op(self, expression: exp.Intersect) -> str:
    884            if not expression.args.get("distinct", False):
    885                self.unsupported("INTERSECT without DISTINCT is not supported in BigQuery")
    886            return f"INTERSECT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
    887
    888        def with_properties(self, properties: exp.Properties) -> str:
    889            return self.properties(properties, prefix=self.seg("OPTIONS"))
    890
    891        def version_sql(self, expression: exp.Version) -> str:
    892            if expression.name == "TIMESTAMP":
    893                expression.set("this", "SYSTEM_TIME")
    894            return super().version_sql(expression)

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

###### Arguments:

- pretty: Whether or not 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 or not to normalize identifiers to lowercase. Default: False.
- pad: Determines the pad size in a formatted string. Default: 2.
- indent: Determines the indentation size in a formatted string. Default: 2.
- normalize_functions: Whether or not to normalize all 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: Determines whether or not 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 or not to preserve comments in the output SQL code. Default: True

EXPLICIT_UNION = 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
TRANSFORMS = {<class 'sqlglot.expressions.JSONPathKey'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathRoot'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathSubscript'>: <function <lambda>>, <class 'sqlglot.expressions.AutoRefreshProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CaseSpecificColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CheckColumnConstraint'>: <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.CopyGrantsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DateAdd'>: <function date_add_interval_sql.<locals>.func>, <class 'sqlglot.expressions.DateFormatColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DefaultColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EncodeColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExecuteAsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExternalProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.HeapProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InheritsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InlineLengthColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.IntervalSpan'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LanguageProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LocationProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LogProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.MaterializedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NonClusteredColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NoPrimaryIndexProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NotForReplicationColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnCommitProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnUpdateColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OutputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.PathColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.RemoteWithConnectionModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ReturnsProperty'>: <function _returnsproperty_sql>, <class 'sqlglot.expressions.SampleProperty'>: <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.SqlReadWriteProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SqlSecurityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StabilityProperty'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.TemporaryProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TitleColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Timestamp'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ToTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransformModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransientProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UppercaseColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VarMap'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VolatileProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithJournalTableProperty'>: <function Generator.<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.ArrayContains'>: <function _array_contains_sql>, <class 'sqlglot.expressions.ArraySize'>: <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.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.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.DateTrunc'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.FromTimeZone'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.GenerateSeries'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.GroupConcat'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Hex'>: <function rename_func.<locals>.<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.JSONFormat'>: <function rename_func.<locals>.<lambda>>, <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.PartitionedByProperty'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.RegexpExtract'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.RegexpReplace'>: <function regexp_replace_sql>, <class 'sqlglot.expressions.RegexpLike'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Select'>: <function preprocess.<locals>._to_sql>, <class 'sqlglot.expressions.SHA2'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.StrToDate'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.StrToTime'>: <function BigQuery.Generator.<lambda>>, <class 'sqlglot.expressions.TimeAdd'>: <function date_add_interval_sql.<locals>.func>, <class 'sqlglot.expressions.TimeFromParts'>: <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.Trim'>: <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.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>>}
SUPPORTED_JSON_PATH_PARTS = {<class 'sqlglot.expressions.JSONPathSubscript'>, <class 'sqlglot.expressions.JSONPathKey'>, <class 'sqlglot.expressions.JSONPathRoot'>}
TYPE_MAPPING = {<Type.NCHAR: 'NCHAR'>: 'STRING', <Type.NVARCHAR: 'NVARCHAR'>: 'STRING', <Type.MEDIUMTEXT: 'MEDIUMTEXT'>: 'TEXT', <Type.LONGTEXT: 'LONGTEXT'>: 'TEXT', <Type.TINYTEXT: 'TINYTEXT'>: 'TEXT', <Type.MEDIUMBLOB: 'MEDIUMBLOB'>: 'BLOB', <Type.LONGBLOB: 'LONGBLOB'>: 'BLOB', <Type.TINYBLOB: 'TINYBLOB'>: 'BLOB', <Type.INET: 'INET'>: 'INET', <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.TIMESTAMPTZ: 'TIMESTAMPTZ'>: 'TIMESTAMP', <Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>: 'TIMESTAMP', <Type.TINYINT: 'TINYINT'>: 'INT64', <Type.VARBINARY: 'VARBINARY'>: 'BYTES', <Type.VARCHAR: 'VARCHAR'>: 'STRING', <Type.VARIANT: 'VARIANT'>: 'ANY TYPE'}
PROPERTIES_LOCATION = {<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.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.DataBlocksizeProperty'>: <Location.POST_NAME: 'POST_NAME'>, <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.DistKeyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DistStyleProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.EngineProperty'>: <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.HeapProperty'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.InheritsProperty'>: <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.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.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.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.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.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.WithSystemVersioningProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>}
RESERVED_KEYWORDS = {'lookup', 'intersect', 'end', 'on', 'cube', 'full', 'limit', 'preceding', 'in', 'assert_rows_modified', 'extract', 'ignore', 'struct', 'tablesample', 'or', 'false', 'of', 'rows', 'when', 'nulls', 'and', 'then', 'within', 'over', 'window', 'using', 'not', 'no', 'left', 'distinct', 'else', 'into', 'as', 'where', 'merge', 'some', 'qualify', 'create', 'exists', 'proto', 'inner', 'union', 'rollup', 'with', 'if', 'any', 'cross', 'for', 'array', 'having', 'default', 'all', 'like', 'contains', 'groups', 'desc', 'asc', 'following', 'right', 'natural', 'respect', 'at', 'case', 'interval', 'null', 'from', 'recursive', 'select', 'grouping', 'current', 'between', 'partition', 'lateral', 'define', 'join', 'escape', 'fetch', 'to', 'except', 'new', 'true', 'group', 'exclude', 'hash', 'is', 'set', 'enum', 'treat', 'outer', 'unbounded', 'order', 'cast', 'collate', 'unnest', 'range', 'by'}
def timetostr_sql(self, expression: sqlglot.expressions.TimeToStr) -> str: View Source

    781        def timetostr_sql(self, expression: exp.TimeToStr) -> str:
    782            if isinstance(expression.this, exp.TsOrDsToDate):
    783                this: exp.Expression = expression.this
    784            else:
    785                this = expression
    786
    787            return f"FORMAT_DATE({self.format_time(expression)}, {self.sql(this, 'this')})"

def struct_sql(self, expression: sqlglot.expressions.Struct) -> str: View Source

    789        def struct_sql(self, expression: exp.Struct) -> str:
    790            args = []
    791            for expr in expression.expressions:
    792                if isinstance(expr, self.KEY_VALUE_DEFINITIONS):
    793                    arg = f"{self.sql(expr, 'expression')} AS {expr.this.name}"
    794                else:
    795                    arg = self.sql(expr)
    796
    797                args.append(arg)
    798
    799            return self.func("STRUCT", *args)

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

    801        def eq_sql(self, expression: exp.EQ) -> str:
    802            # Operands of = cannot be NULL in BigQuery
    803            if isinstance(expression.left, exp.Null) or isinstance(expression.right, exp.Null):
    804                if not isinstance(expression.parent, exp.Update):
    805                    return "NULL"
    806
    807            return self.binary(expression, "=")

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

    809        def attimezone_sql(self, expression: exp.AtTimeZone) -> str:
    810            parent = expression.parent
    811
    812            # BigQuery allows CAST(.. AS {STRING|TIMESTAMP} [FORMAT <fmt> [AT TIME ZONE <tz>]]).
    813            # Only the TIMESTAMP one should use the below conversion, when AT TIME ZONE is included.
    814            if not isinstance(parent, exp.Cast) or not parent.to.is_type("text"):
    815                return self.func(
    816                    "TIMESTAMP", self.func("DATETIME", expression.this, expression.args.get("zone"))
    817                )
    818
    819            return super().attimezone_sql(expression)

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

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

def cte_sql(self, expression: sqlglot.expressions.CTE) -> str: View Source

    824        def cte_sql(self, expression: exp.CTE) -> str:
    825            if expression.alias_column_names:
    826                self.unsupported("Column names in CTE definition are not supported.")
    827            return super().cte_sql(expression)

def array_sql(self, expression: sqlglot.expressions.Array) -> str: View Source

    829        def array_sql(self, expression: exp.Array) -> str:
    830            first_arg = seq_get(expression.expressions, 0)
    831            if isinstance(first_arg, exp.Subqueryable):
    832                return f"ARRAY{self.wrap(self.sql(first_arg))}"
    833
    834            return inline_array_sql(self, expression)

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

    836        def bracket_sql(self, expression: exp.Bracket) -> str:
    837            this = self.sql(expression, "this")
    838            expressions = expression.expressions
    839
    840            if len(expressions) == 1:
    841                arg = expressions[0]
    842                if arg.type is None:
    843                    from sqlglot.optimizer.annotate_types import annotate_types
    844
    845                    arg = annotate_types(arg)
    846
    847                if arg.type and arg.type.this in exp.DataType.TEXT_TYPES:
    848                    # BQ doesn't support bracket syntax with string values
    849                    return f"{this}.{arg.name}"
    850
    851            expressions_sql = ", ".join(self.sql(e) for e in expressions)
    852            offset = expression.args.get("offset")
    853
    854            if offset == 0:
    855                expressions_sql = f"OFFSET({expressions_sql})"
    856            elif offset == 1:
    857                expressions_sql = f"ORDINAL({expressions_sql})"
    858            elif offset is not None:
    859                self.unsupported(f"Unsupported array offset: {offset}")
    860
    861            if expression.args.get("safe"):
    862                expressions_sql = f"SAFE_{expressions_sql}"
    863
    864            return f"{this}[{expressions_sql}]"

def transaction_sql(self, *_) -> str: View Source

    866        def transaction_sql(self, *_) -> str:
    867            return "BEGIN TRANSACTION"

def commit_sql(self, *_) -> str: View Source

    869        def commit_sql(self, *_) -> str:
    870            return "COMMIT TRANSACTION"

def rollback_sql(self, *_) -> str: View Source

    872        def rollback_sql(self, *_) -> str:
    873            return "ROLLBACK TRANSACTION"

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

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

def except_op(self, expression: sqlglot.expressions.Except) -> str: View Source

    878        def except_op(self, expression: exp.Except) -> str:
    879            if not expression.args.get("distinct", False):
    880                self.unsupported("EXCEPT without DISTINCT is not supported in BigQuery")
    881            return f"EXCEPT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"

def intersect_op(self, expression: sqlglot.expressions.Intersect) -> str: View Source

    883        def intersect_op(self, expression: exp.Intersect) -> str:
    884            if not expression.args.get("distinct", False):
    885                self.unsupported("INTERSECT without DISTINCT is not supported in BigQuery")
    886            return f"INTERSECT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"

def with_properties(self, properties: sqlglot.expressions.Properties) -> str: View Source

    888        def with_properties(self, properties: exp.Properties) -> str:
    889            return self.properties(properties, prefix=self.seg("OPTIONS"))

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

    891        def version_sql(self, expression: exp.Version) -> str:
    892            if expression.name == "TIMESTAMP":
    893                expression.set("this", "SYSTEM_TIME")
    894            return super().version_sql(expression)

##### 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
  COLUMN_JOIN_MARKS_SUPPORTED
  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
  STAR_MAPPING
  TIME_PART_SINGULARS
  TOKEN_MAPPING
  STRUCT_DELIMITER
  PARAMETER_TOKEN
  WITH_SEPARATED_COMMENTS
  EXCLUDE_COMMENTS
  UNWRAPPED_INTERVAL_VALUES
  EXPRESSIONS_WITHOUT_NESTED_CTES
  KEY_VALUE_DEFINITIONS
  SENTINEL_LINE_BREAK
  pretty
  identify
  normalize
  pad
  unsupported_level
  max_unsupported
  leading_comma
  max_text_width
  comments
  dialect
  normalize_functions
  unsupported_messages
  generate
  preprocess
  unsupported
  sep
  seg
  pad_comment
  maybe_comment
  wrap
  no_identify
  normalize_func
  indent
  sql
  uncache_sql
  cache_sql
  characterset_sql
  column_sql
  columnposition_sql
  columndef_sql
  columnconstraint_sql
  computedcolumnconstraint_sql
  autoincrementcolumnconstraint_sql
  compresscolumnconstraint_sql
  generatedasidentitycolumnconstraint_sql
  generatedasrowcolumnconstraint_sql
  periodforsystemtimeconstraint_sql
  notnullcolumnconstraint_sql
  transformcolumnconstraint_sql
  primarykeycolumnconstraint_sql
  uniquecolumnconstraint_sql
  createable_sql
  create_sql
  clone_sql
  describe_sql
  heredoc_sql
  prepend_ctes
  with_sql
  tablealias_sql
  bitstring_sql
  hexstring_sql
  bytestring_sql
  unicodestring_sql
  rawstring_sql
  datatypeparam_sql
  datatype_sql
  directory_sql
  delete_sql
  drop_sql
  except_sql
  fetch_sql
  filter_sql
  hint_sql
  index_sql
  identifier_sql
  inputoutputformat_sql
  national_sql
  partition_sql
  properties_sql
  root_properties
  properties
  locate_properties
  property_name
  property_sql
  likeproperty_sql
  fallbackproperty_sql
  journalproperty_sql
  freespaceproperty_sql
  checksumproperty_sql
  mergeblockratioproperty_sql
  datablocksizeproperty_sql
  blockcompressionproperty_sql
  isolatedloadingproperty_sql
  partitionboundspec_sql
  partitionedofproperty_sql
  lockingproperty_sql
  withdataproperty_sql
  withsystemversioningproperty_sql
  insert_sql
  intersect_sql
  introducer_sql
  kill_sql
  pseudotype_sql
  objectidentifier_sql
  onconflict_sql
  returning_sql
  rowformatdelimitedproperty_sql
  withtablehint_sql
  indextablehint_sql
  historicaldata_sql
  table_sql
  tablesample_sql
  pivot_sql
  tuple_sql
  update_sql
  values_sql
  var_sql
  into_sql
  from_sql
  group_sql
  having_sql
  connect_sql
  prior_sql
  join_sql
  lambda_sql
  lateral_op
  lateral_sql
  limit_sql
  offset_sql
  setitem_sql
  set_sql
  pragma_sql
  lock_sql
  literal_sql
  escape_str
  loaddata_sql
  null_sql
  boolean_sql
  order_sql
  withfill_sql
  cluster_sql
  distribute_sql
  sort_sql
  ordered_sql
  matchrecognize_sql
  query_modifiers
  offset_limit_modifiers
  after_having_modifiers
  after_limit_modifiers
  select_sql
  schema_sql
  schema_columns_sql
  star_sql
  parameter_sql
  sessionparameter_sql
  placeholder_sql
  subquery_sql
  qualify_sql
  union_sql
  union_op
  unnest_sql
  where_sql
  window_sql
  partition_by_sql
  windowspec_sql
  withingroup_sql
  between_sql
  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
  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
  xor_sql
  connector_sql
  bitwiseand_sql
  bitwiseleftshift_sql
  bitwisenot_sql
  bitwiseor_sql
  bitwiserightshift_sql
  bitwisexor_sql
  cast_sql
  currentdate_sql
  currenttimestamp_sql
  collate_sql
  command_sql
  comment_sql
  mergetreettlaction_sql
  mergetreettl_sql
  altercolumn_sql
  renametable_sql
  renamecolumn_sql
  altertable_sql
  add_column_sql
  droppartition_sql
  addconstraint_sql
  distinct_sql
  ignorenulls_sql
  respectnulls_sql
  havingmax_sql
  intdiv_sql
  dpipe_sql
  div_sql
  overlaps_sql
  distance_sql
  dot_sql
  propertyeq_sql
  escape_sql
  glob_sql
  gt_sql
  gte_sql
  ilike_sql
  ilikeany_sql
  is_sql
  like_sql
  likeany_sql
  similarto_sql
  lt_sql
  lte_sql
  mod_sql
  mul_sql
  neq_sql
  nullsafeeq_sql
  nullsafeneq_sql
  or_sql
  slice_sql
  sub_sql
  log_sql
  use_sql
  binary
  function_fallback_sql
  func
  format_args
  text_width
  format_time
  expressions
  op_expressions
  naked_property
  set_operation
  tag_sql
  token_sql
  userdefinedfunction_sql
  joinhint_sql
  kwarg_sql
  when_sql
  merge_sql
  tochar_sql
  dictproperty_sql
  dictrange_sql
  dictsubproperty_sql
  oncluster_sql
  clusteredbyproperty_sql
  anyvalue_sql
  querytransform_sql
  indexconstraintoption_sql
  indexcolumnconstraint_sql
  nvl2_sql
  comprehension_sql
  columnprefix_sql
  opclass_sql
  predict_sql
  forin_sql
  refresh_sql
  operator_sql
  toarray_sql
  tsordstotime_sql
  tsordstodate_sql
  unixdate_sql
  lastday_sql