sqlglot.dialects.bigquery

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