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

logger = <Logger sqlglot (WARNING)>

class BigQuery(sqlglot.dialects.dialect.Dialect): View Source

178class BigQuery(Dialect):
179    UNNEST_COLUMN_ONLY = True
180    SUPPORTS_USER_DEFINED_TYPES = False
181    SUPPORTS_SEMI_ANTI_JOIN = False
182    LOG_BASE_FIRST = False
183
184    # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#case_sensitivity
185    RESOLVES_IDENTIFIERS_AS_UPPERCASE = None
186
187    # bigquery udfs are case sensitive
188    NORMALIZE_FUNCTIONS = False
189
190    TIME_MAPPING = {
191        "%D": "%m/%d/%y",
192    }
193
194    ESCAPE_SEQUENCES = {
195        "\\a": "\a",
196        "\\b": "\b",
197        "\\f": "\f",
198        "\\n": "\n",
199        "\\r": "\r",
200        "\\t": "\t",
201        "\\v": "\v",
202    }
203
204    FORMAT_MAPPING = {
205        "DD": "%d",
206        "MM": "%m",
207        "MON": "%b",
208        "MONTH": "%B",
209        "YYYY": "%Y",
210        "YY": "%y",
211        "HH": "%I",
212        "HH12": "%I",
213        "HH24": "%H",
214        "MI": "%M",
215        "SS": "%S",
216        "SSSSS": "%f",
217        "TZH": "%z",
218    }
219
220    # The _PARTITIONTIME and _PARTITIONDATE pseudo-columns are not returned by a SELECT * statement
221    # https://cloud.google.com/bigquery/docs/querying-partitioned-tables#query_an_ingestion-time_partitioned_table
222    PSEUDOCOLUMNS = {"_PARTITIONTIME", "_PARTITIONDATE"}
223
224    @classmethod
225    def normalize_identifier(cls, expression: E) -> E:
226        if isinstance(expression, exp.Identifier):
227            parent = expression.parent
228            while isinstance(parent, exp.Dot):
229                parent = parent.parent
230
231            # In BigQuery, CTEs aren't case-sensitive, but table names are (by default, at least).
232            # The following check is essentially a heuristic to detect tables based on whether or
233            # not they're qualified. It also avoids normalizing UDFs, because they're case-sensitive.
234            if (
235                not isinstance(parent, exp.UserDefinedFunction)
236                and not (isinstance(parent, exp.Table) and parent.db)
237                and not expression.meta.get("is_table")
238            ):
239                expression.set("this", expression.this.lower())
240
241        return expression
242
243    class Tokenizer(tokens.Tokenizer):
244        QUOTES = ["'", '"', '"""', "'''"]
245        COMMENTS = ["--", "#", ("/*", "*/")]
246        IDENTIFIERS = ["`"]
247        STRING_ESCAPES = ["\\"]
248
249        HEX_STRINGS = [("0x", ""), ("0X", "")]
250
251        BYTE_STRINGS = [
252            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("b", "B")
253        ]
254
255        RAW_STRINGS = [
256            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("r", "R")
257        ]
258
259        KEYWORDS = {
260            **tokens.Tokenizer.KEYWORDS,
261            "ANY TYPE": TokenType.VARIANT,
262            "BEGIN": TokenType.COMMAND,
263            "BEGIN TRANSACTION": TokenType.BEGIN,
264            "BYTES": TokenType.BINARY,
265            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
266            "DECLARE": TokenType.COMMAND,
267            "FLOAT64": TokenType.DOUBLE,
268            "FOR SYSTEM_TIME": TokenType.TIMESTAMP_SNAPSHOT,
269            "INT64": TokenType.BIGINT,
270            "MODEL": TokenType.MODEL,
271            "NOT DETERMINISTIC": TokenType.VOLATILE,
272            "RECORD": TokenType.STRUCT,
273            "TIMESTAMP": TokenType.TIMESTAMPTZ,
274        }
275        KEYWORDS.pop("DIV")
276
277    class Parser(parser.Parser):
278        PREFIXED_PIVOT_COLUMNS = True
279
280        LOG_DEFAULTS_TO_LN = True
281
282        FUNCTIONS = {
283            **parser.Parser.FUNCTIONS,
284            "DATE": _parse_date,
285            "DATE_ADD": parse_date_delta_with_interval(exp.DateAdd),
286            "DATE_SUB": parse_date_delta_with_interval(exp.DateSub),
287            "DATE_TRUNC": lambda args: exp.DateTrunc(
288                unit=exp.Literal.string(str(seq_get(args, 1))),
289                this=seq_get(args, 0),
290            ),
291            "DATETIME_ADD": parse_date_delta_with_interval(exp.DatetimeAdd),
292            "DATETIME_SUB": parse_date_delta_with_interval(exp.DatetimeSub),
293            "DIV": binary_from_function(exp.IntDiv),
294            "GENERATE_ARRAY": exp.GenerateSeries.from_arg_list,
295            "MD5": exp.MD5Digest.from_arg_list,
296            "TO_HEX": _parse_to_hex,
297            "PARSE_DATE": lambda args: format_time_lambda(exp.StrToDate, "bigquery")(
298                [seq_get(args, 1), seq_get(args, 0)]
299            ),
300            "PARSE_TIMESTAMP": _parse_timestamp,
301            "REGEXP_CONTAINS": exp.RegexpLike.from_arg_list,
302            "REGEXP_EXTRACT": lambda args: exp.RegexpExtract(
303                this=seq_get(args, 0),
304                expression=seq_get(args, 1),
305                position=seq_get(args, 2),
306                occurrence=seq_get(args, 3),
307                group=exp.Literal.number(1) if re.compile(args[1].name).groups == 1 else None,
308            ),
309            "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
310            "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
311            "SPLIT": lambda args: exp.Split(
312                # https://cloud.google.com/bigquery/docs/reference/standard-sql/string_functions#split
313                this=seq_get(args, 0),
314                expression=seq_get(args, 1) or exp.Literal.string(","),
315            ),
316            "TIME_ADD": parse_date_delta_with_interval(exp.TimeAdd),
317            "TIME_SUB": parse_date_delta_with_interval(exp.TimeSub),
318            "TIMESTAMP_ADD": parse_date_delta_with_interval(exp.TimestampAdd),
319            "TIMESTAMP_SUB": parse_date_delta_with_interval(exp.TimestampSub),
320            "TO_JSON_STRING": exp.JSONFormat.from_arg_list,
321        }
322
323        FUNCTION_PARSERS = {
324            **parser.Parser.FUNCTION_PARSERS,
325            "ARRAY": lambda self: self.expression(exp.Array, expressions=[self._parse_statement()]),
326        }
327        FUNCTION_PARSERS.pop("TRIM")
328
329        NO_PAREN_FUNCTIONS = {
330            **parser.Parser.NO_PAREN_FUNCTIONS,
331            TokenType.CURRENT_DATETIME: exp.CurrentDatetime,
332        }
333
334        NESTED_TYPE_TOKENS = {
335            *parser.Parser.NESTED_TYPE_TOKENS,
336            TokenType.TABLE,
337        }
338
339        ID_VAR_TOKENS = {
340            *parser.Parser.ID_VAR_TOKENS,
341            TokenType.VALUES,
342        }
343
344        PROPERTY_PARSERS = {
345            **parser.Parser.PROPERTY_PARSERS,
346            "NOT DETERMINISTIC": lambda self: self.expression(
347                exp.StabilityProperty, this=exp.Literal.string("VOLATILE")
348            ),
349            "OPTIONS": lambda self: self._parse_with_property(),
350        }
351
352        CONSTRAINT_PARSERS = {
353            **parser.Parser.CONSTRAINT_PARSERS,
354            "OPTIONS": lambda self: exp.Properties(expressions=self._parse_with_property()),
355        }
356
357        RANGE_PARSERS = parser.Parser.RANGE_PARSERS.copy()
358        RANGE_PARSERS.pop(TokenType.OVERLAPS, None)
359
360        NULL_TOKENS = {TokenType.NULL, TokenType.UNKNOWN}
361
362        def _parse_table_part(self, schema: bool = False) -> t.Optional[exp.Expression]:
363            this = super()._parse_table_part(schema=schema) or self._parse_number()
364
365            # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#table_names
366            if isinstance(this, exp.Identifier):
367                table_name = this.name
368                while self._match(TokenType.DASH, advance=False) and self._next:
369                    self._advance(2)
370                    table_name += f"-{self._prev.text}"
371
372                this = exp.Identifier(this=table_name, quoted=this.args.get("quoted"))
373            elif isinstance(this, exp.Literal):
374                table_name = this.name
375
376                if (
377                    self._curr
378                    and self._prev.end == self._curr.start - 1
379                    and self._parse_var(any_token=True)
380                ):
381                    table_name += self._prev.text
382
383                this = exp.Identifier(this=table_name, quoted=True)
384
385            return this
386
387        def _parse_table_parts(self, schema: bool = False) -> exp.Table:
388            table = super()._parse_table_parts(schema=schema)
389            if isinstance(table.this, exp.Identifier) and "." in table.name:
390                catalog, db, this, *rest = (
391                    t.cast(t.Optional[exp.Expression], exp.to_identifier(x))
392                    for x in split_num_words(table.name, ".", 3)
393                )
394
395                if rest and this:
396                    this = exp.Dot.build(t.cast(t.List[exp.Expression], [this, *rest]))
397
398                table = exp.Table(this=this, db=db, catalog=catalog)
399
400            return table
401
402        def _parse_json_object(self) -> exp.JSONObject:
403            json_object = super()._parse_json_object()
404            array_kv_pair = seq_get(json_object.expressions, 0)
405
406            # Converts BQ's "signature 2" of JSON_OBJECT into SQLGlot's canonical representation
407            # https://cloud.google.com/bigquery/docs/reference/standard-sql/json_functions#json_object_signature2
408            if (
409                array_kv_pair
410                and isinstance(array_kv_pair.this, exp.Array)
411                and isinstance(array_kv_pair.expression, exp.Array)
412            ):
413                keys = array_kv_pair.this.expressions
414                values = array_kv_pair.expression.expressions
415
416                json_object.set(
417                    "expressions",
418                    [exp.JSONKeyValue(this=k, expression=v) for k, v in zip(keys, values)],
419                )
420
421            return json_object
422
423    class Generator(generator.Generator):
424        EXPLICIT_UNION = True
425        INTERVAL_ALLOWS_PLURAL_FORM = False
426        JOIN_HINTS = False
427        QUERY_HINTS = False
428        TABLE_HINTS = False
429        LIMIT_FETCH = "LIMIT"
430        RENAME_TABLE_WITH_DB = False
431        NVL2_SUPPORTED = False
432        UNNEST_WITH_ORDINALITY = False
433        COLLATE_IS_FUNC = True
434
435        TRANSFORMS = {
436            **generator.Generator.TRANSFORMS,
437            exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
438            exp.ArraySize: rename_func("ARRAY_LENGTH"),
439            exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]),
440            exp.Create: _create_sql,
441            exp.CTE: transforms.preprocess([_pushdown_cte_column_names]),
442            exp.DateAdd: date_add_interval_sql("DATE", "ADD"),
443            exp.DateDiff: lambda self, e: f"DATE_DIFF({self.sql(e, 'this')}, {self.sql(e, 'expression')}, {self.sql(e.args.get('unit', 'DAY'))})",
444            exp.DateFromParts: rename_func("DATE"),
445            exp.DateStrToDate: datestrtodate_sql,
446            exp.DateSub: date_add_interval_sql("DATE", "SUB"),
447            exp.DatetimeAdd: date_add_interval_sql("DATETIME", "ADD"),
448            exp.DatetimeSub: date_add_interval_sql("DATETIME", "SUB"),
449            exp.DateTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, e.text("unit")),
450            exp.GenerateSeries: rename_func("GENERATE_ARRAY"),
451            exp.GroupConcat: rename_func("STRING_AGG"),
452            exp.Hex: rename_func("TO_HEX"),
453            exp.If: if_sql(false_value="NULL"),
454            exp.ILike: no_ilike_sql,
455            exp.IntDiv: rename_func("DIV"),
456            exp.JSONFormat: rename_func("TO_JSON_STRING"),
457            exp.JSONKeyValue: json_keyvalue_comma_sql,
458            exp.Max: max_or_greatest,
459            exp.MD5: lambda self, e: self.func("TO_HEX", self.func("MD5", e.this)),
460            exp.MD5Digest: rename_func("MD5"),
461            exp.Min: min_or_least,
462            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
463            exp.RegexpExtract: lambda self, e: self.func(
464                "REGEXP_EXTRACT",
465                e.this,
466                e.expression,
467                e.args.get("position"),
468                e.args.get("occurrence"),
469            ),
470            exp.RegexpReplace: regexp_replace_sql,
471            exp.RegexpLike: rename_func("REGEXP_CONTAINS"),
472            exp.ReturnsProperty: _returnsproperty_sql,
473            exp.Select: transforms.preprocess(
474                [
475                    transforms.explode_to_unnest(),
476                    _unqualify_unnest,
477                    transforms.eliminate_distinct_on,
478                    _alias_ordered_group,
479                    transforms.eliminate_semi_and_anti_joins,
480                ]
481            ),
482            exp.SHA2: lambda self, e: self.func(
483                f"SHA256" if e.text("length") == "256" else "SHA512", e.this
484            ),
485            exp.StabilityProperty: lambda self, e: f"DETERMINISTIC"
486            if e.name == "IMMUTABLE"
487            else "NOT DETERMINISTIC",
488            exp.StrToDate: lambda self, e: f"PARSE_DATE({self.format_time(e)}, {self.sql(e, 'this')})",
489            exp.StrToTime: lambda self, e: self.func(
490                "PARSE_TIMESTAMP", self.format_time(e), e.this, e.args.get("zone")
491            ),
492            exp.TimeAdd: date_add_interval_sql("TIME", "ADD"),
493            exp.TimeSub: date_add_interval_sql("TIME", "SUB"),
494            exp.TimestampAdd: date_add_interval_sql("TIMESTAMP", "ADD"),
495            exp.TimestampSub: date_add_interval_sql("TIMESTAMP", "SUB"),
496            exp.TimeStrToTime: timestrtotime_sql,
497            exp.Trim: lambda self, e: self.func(f"TRIM", e.this, e.expression),
498            exp.TsOrDsAdd: date_add_interval_sql("DATE", "ADD"),
499            exp.TsOrDsToDate: ts_or_ds_to_date_sql("bigquery"),
500            exp.Unhex: rename_func("FROM_HEX"),
501            exp.Values: _derived_table_values_to_unnest,
502            exp.VariancePop: rename_func("VAR_POP"),
503        }
504
505        TYPE_MAPPING = {
506            **generator.Generator.TYPE_MAPPING,
507            exp.DataType.Type.BIGDECIMAL: "BIGNUMERIC",
508            exp.DataType.Type.BIGINT: "INT64",
509            exp.DataType.Type.BINARY: "BYTES",
510            exp.DataType.Type.BOOLEAN: "BOOL",
511            exp.DataType.Type.CHAR: "STRING",
512            exp.DataType.Type.DECIMAL: "NUMERIC",
513            exp.DataType.Type.DOUBLE: "FLOAT64",
514            exp.DataType.Type.FLOAT: "FLOAT64",
515            exp.DataType.Type.INT: "INT64",
516            exp.DataType.Type.NCHAR: "STRING",
517            exp.DataType.Type.NVARCHAR: "STRING",
518            exp.DataType.Type.SMALLINT: "INT64",
519            exp.DataType.Type.TEXT: "STRING",
520            exp.DataType.Type.TIMESTAMP: "DATETIME",
521            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
522            exp.DataType.Type.TIMESTAMPLTZ: "TIMESTAMP",
523            exp.DataType.Type.TINYINT: "INT64",
524            exp.DataType.Type.VARBINARY: "BYTES",
525            exp.DataType.Type.VARCHAR: "STRING",
526            exp.DataType.Type.VARIANT: "ANY TYPE",
527        }
528
529        PROPERTIES_LOCATION = {
530            **generator.Generator.PROPERTIES_LOCATION,
531            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
532            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
533        }
534
535        # from: https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#reserved_keywords
536        RESERVED_KEYWORDS = {
537            *generator.Generator.RESERVED_KEYWORDS,
538            "all",
539            "and",
540            "any",
541            "array",
542            "as",
543            "asc",
544            "assert_rows_modified",
545            "at",
546            "between",
547            "by",
548            "case",
549            "cast",
550            "collate",
551            "contains",
552            "create",
553            "cross",
554            "cube",
555            "current",
556            "default",
557            "define",
558            "desc",
559            "distinct",
560            "else",
561            "end",
562            "enum",
563            "escape",
564            "except",
565            "exclude",
566            "exists",
567            "extract",
568            "false",
569            "fetch",
570            "following",
571            "for",
572            "from",
573            "full",
574            "group",
575            "grouping",
576            "groups",
577            "hash",
578            "having",
579            "if",
580            "ignore",
581            "in",
582            "inner",
583            "intersect",
584            "interval",
585            "into",
586            "is",
587            "join",
588            "lateral",
589            "left",
590            "like",
591            "limit",
592            "lookup",
593            "merge",
594            "natural",
595            "new",
596            "no",
597            "not",
598            "null",
599            "nulls",
600            "of",
601            "on",
602            "or",
603            "order",
604            "outer",
605            "over",
606            "partition",
607            "preceding",
608            "proto",
609            "qualify",
610            "range",
611            "recursive",
612            "respect",
613            "right",
614            "rollup",
615            "rows",
616            "select",
617            "set",
618            "some",
619            "struct",
620            "tablesample",
621            "then",
622            "to",
623            "treat",
624            "true",
625            "unbounded",
626            "union",
627            "unnest",
628            "using",
629            "when",
630            "where",
631            "window",
632            "with",
633            "within",
634        }
635
636        def attimezone_sql(self, expression: exp.AtTimeZone) -> str:
637            parent = expression.parent
638
639            # BigQuery allows CAST(.. AS {STRING|TIMESTAMP} [FORMAT <fmt> [AT TIME ZONE <tz>]]).
640            # Only the TIMESTAMP one should use the below conversion, when AT TIME ZONE is included.
641            if not isinstance(parent, exp.Cast) or not parent.to.is_type("text"):
642                return self.func(
643                    "TIMESTAMP", self.func("DATETIME", expression.this, expression.args.get("zone"))
644                )
645
646            return super().attimezone_sql(expression)
647
648        def trycast_sql(self, expression: exp.TryCast) -> str:
649            return self.cast_sql(expression, safe_prefix="SAFE_")
650
651        def cte_sql(self, expression: exp.CTE) -> str:
652            if expression.alias_column_names:
653                self.unsupported("Column names in CTE definition are not supported.")
654            return super().cte_sql(expression)
655
656        def array_sql(self, expression: exp.Array) -> str:
657            first_arg = seq_get(expression.expressions, 0)
658            if isinstance(first_arg, exp.Subqueryable):
659                return f"ARRAY{self.wrap(self.sql(first_arg))}"
660
661            return inline_array_sql(self, expression)
662
663        def transaction_sql(self, *_) -> str:
664            return "BEGIN TRANSACTION"
665
666        def commit_sql(self, *_) -> str:
667            return "COMMIT TRANSACTION"
668
669        def rollback_sql(self, *_) -> str:
670            return "ROLLBACK TRANSACTION"
671
672        def in_unnest_op(self, expression: exp.Unnest) -> str:
673            return self.sql(expression)
674
675        def except_op(self, expression: exp.Except) -> str:
676            if not expression.args.get("distinct", False):
677                self.unsupported("EXCEPT without DISTINCT is not supported in BigQuery")
678            return f"EXCEPT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
679
680        def intersect_op(self, expression: exp.Intersect) -> str:
681            if not expression.args.get("distinct", False):
682                self.unsupported("INTERSECT without DISTINCT is not supported in BigQuery")
683            return f"INTERSECT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
684
685        def with_properties(self, properties: exp.Properties) -> str:
686            return self.properties(properties, prefix=self.seg("OPTIONS"))
687
688        def version_sql(self, expression: exp.Version) -> str:
689            if expression.name == "TIMESTAMP":
690                expression = expression.copy()
691                expression.set("this", "SYSTEM_TIME")
692            return super().version_sql(expression)

UNNEST_COLUMN_ONLY = True

SUPPORTS_USER_DEFINED_TYPES = False

SUPPORTS_SEMI_ANTI_JOIN = False

LOG_BASE_FIRST = False

RESOLVES_IDENTIFIERS_AS_UPPERCASE: Optional[bool] = None

NORMALIZE_FUNCTIONS: bool | str = False

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

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

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'}

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

@classmethod

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

224    @classmethod
225    def normalize_identifier(cls, expression: E) -> E:
226        if isinstance(expression, exp.Identifier):
227            parent = expression.parent
228            while isinstance(parent, exp.Dot):
229                parent = parent.parent
230
231            # In BigQuery, CTEs aren't case-sensitive, but table names are (by default, at least).
232            # The following check is essentially a heuristic to detect tables based on whether or
233            # not they're qualified. It also avoids normalizing UDFs, because they're case-sensitive.
234            if (
235                not isinstance(parent, exp.UserDefinedFunction)
236                and not (isinstance(parent, exp.Table) and parent.db)
237                and not expression.meta.get("is_table")
238            ):
239                expression.set("this", expression.this.lower())
240
241        return expression

Normalizes an unquoted identifier to either lower or upper case, thus essentially making it case-insensitive. If a dialect treats all identifiers as case-insensitive, they will be normalized to lowercase regardless of being quoted or not.

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

BIT_END = None

HEX_START = '0x'

HEX_END = ''

BYTE_START = "b'"

BYTE_END = "'"

Inherited Members

sqlglot.dialects.dialect.Dialect: INDEX_OFFSET; ALIAS_POST_TABLESAMPLE; IDENTIFIERS_CAN_START_WITH_DIGIT; DPIPE_IS_STRING_CONCAT; STRICT_STRING_CONCAT; NULL_ORDERING; DATE_FORMAT; DATEINT_FORMAT; TIME_FORMAT; get_or_raise; format_time; case_sensitive; can_identify; quote_identifier; parse; parse_into; generate; transpile; tokenize; tokenizer; parser; generator

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

243    class Tokenizer(tokens.Tokenizer):
244        QUOTES = ["'", '"', '"""', "'''"]
245        COMMENTS = ["--", "#", ("/*", "*/")]
246        IDENTIFIERS = ["`"]
247        STRING_ESCAPES = ["\\"]
248
249        HEX_STRINGS = [("0x", ""), ("0X", "")]
250
251        BYTE_STRINGS = [
252            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("b", "B")
253        ]
254
255        RAW_STRINGS = [
256            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("r", "R")
257        ]
258
259        KEYWORDS = {
260            **tokens.Tokenizer.KEYWORDS,
261            "ANY TYPE": TokenType.VARIANT,
262            "BEGIN": TokenType.COMMAND,
263            "BEGIN TRANSACTION": TokenType.BEGIN,
264            "BYTES": TokenType.BINARY,
265            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
266            "DECLARE": TokenType.COMMAND,
267            "FLOAT64": TokenType.DOUBLE,
268            "FOR SYSTEM_TIME": TokenType.TIMESTAMP_SNAPSHOT,
269            "INT64": TokenType.BIGINT,
270            "MODEL": TokenType.MODEL,
271            "NOT DETERMINISTIC": TokenType.VOLATILE,
272            "RECORD": TokenType.STRUCT,
273            "TIMESTAMP": TokenType.TIMESTAMPTZ,
274        }
275        KEYWORDS.pop("DIV")

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.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'>, 'VALUES': <TokenType.VALUES: 'VALUES'>, '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'>, 'TINYINT': <TokenType.TINYINT: 'TINYINT'>, 'SHORT': <TokenType.SMALLINT: 'SMALLINT'>, 'SMALLINT': <TokenType.SMALLINT: 'SMALLINT'>, 'INT128': <TokenType.INT128: 'INT128'>, 'INT2': <TokenType.SMALLINT: 'SMALLINT'>, 'INTEGER': <TokenType.INT: 'INT'>, 'INT': <TokenType.INT: 'INT'>, 'INT4': <TokenType.INT: 'INT'>, 'LONG': <TokenType.BIGINT: 'BIGINT'>, 'BIGINT': <TokenType.BIGINT: 'BIGINT'>, 'INT8': <TokenType.BIGINT: 'BIGINT'>, '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'>, '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'>, 'INT64': <TokenType.BIGINT: 'BIGINT'>, 'MODEL': <TokenType.MODEL: 'MODEL'>, 'NOT DETERMINISTIC': <TokenType.VOLATILE: 'VOLATILE'>, 'RECORD': <TokenType.STRUCT: 'STRUCT'>}

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

Inherited Members

sqlglot.tokens.Tokenizer: SINGLE_TOKENS; BIT_STRINGS; HEREDOC_STRINGS; IDENTIFIER_ESCAPES; VAR_SINGLE_TOKENS; IDENTIFIERS_CAN_START_WITH_DIGIT; WHITE_SPACE; COMMANDS; COMMAND_PREFIX_TOKENS; NUMERIC_LITERALS; ENCODE; reset; tokenize; peek; size; sql; tokens

sqlglot.dialects.bigquery

Inherited Members

Inherited Members

Arguments:

Inherited Members

Arguments:

Arguments:

Returns:

Inherited Members