Edit on GitHub

sqlglot.dialects.bigquery

View Source

  1from __future__ import annotations
  2
  3import re
  4import typing as t
  5
  6from sqlglot import exp, generator, parser, tokens, transforms
  7from sqlglot._typing import E
  8from sqlglot.dialects.dialect import (
  9    Dialect,
 10    datestrtodate_sql,
 11    format_time_lambda,
 12    inline_array_sql,
 13    max_or_greatest,
 14    min_or_least,
 15    no_ilike_sql,
 16    parse_date_delta_with_interval,
 17    rename_func,
 18    timestrtotime_sql,
 19    ts_or_ds_to_date_sql,
 20)
 21from sqlglot.helper import seq_get, split_num_words
 22from sqlglot.tokens import TokenType
 23
 24
 25def _date_add_sql(
 26    data_type: str, kind: str
 27) -> t.Callable[[generator.Generator, exp.Expression], str]:
 28    def func(self, expression):
 29        this = self.sql(expression, "this")
 30        unit = expression.args.get("unit")
 31        unit = exp.var(unit.name.upper() if unit else "DAY")
 32        interval = exp.Interval(this=expression.expression, unit=unit)
 33        return f"{data_type}_{kind}({this}, {self.sql(interval)})"
 34
 35    return func
 36
 37
 38def _derived_table_values_to_unnest(self: generator.Generator, expression: exp.Values) -> str:
 39    if not isinstance(expression.unnest().parent, exp.From):
 40        return self.values_sql(expression)
 41
 42    alias = expression.args.get("alias")
 43
 44    structs = [
 45        exp.Struct(
 46            expressions=[
 47                exp.alias_(value, column_name)
 48                for value, column_name in zip(
 49                    t.expressions,
 50                    alias.columns
 51                    if alias and alias.columns
 52                    else (f"_c{i}" for i in range(len(t.expressions))),
 53                )
 54            ]
 55        )
 56        for t in expression.find_all(exp.Tuple)
 57    ]
 58
 59    return self.unnest_sql(exp.Unnest(expressions=[exp.Array(expressions=structs)]))
 60
 61
 62def _returnsproperty_sql(self: generator.Generator, expression: exp.ReturnsProperty) -> str:
 63    this = expression.this
 64    if isinstance(this, exp.Schema):
 65        this = f"{this.this} <{self.expressions(this)}>"
 66    else:
 67        this = self.sql(this)
 68    return f"RETURNS {this}"
 69
 70
 71def _create_sql(self: generator.Generator, expression: exp.Create) -> str:
 72    kind = expression.args["kind"]
 73    returns = expression.find(exp.ReturnsProperty)
 74    if kind.upper() == "FUNCTION" and returns and returns.args.get("is_table"):
 75        expression = expression.copy()
 76        expression.set("kind", "TABLE FUNCTION")
 77        if isinstance(
 78            expression.expression,
 79            (
 80                exp.Subquery,
 81                exp.Literal,
 82            ),
 83        ):
 84            expression.set("expression", expression.expression.this)
 85
 86        return self.create_sql(expression)
 87
 88    return self.create_sql(expression)
 89
 90
 91def _unqualify_unnest(expression: exp.Expression) -> exp.Expression:
 92    """Remove references to unnest table aliases since bigquery doesn't allow them.
 93
 94    These are added by the optimizer's qualify_column step.
 95    """
 96    if isinstance(expression, exp.Select):
 97        for unnest in expression.find_all(exp.Unnest):
 98            if isinstance(unnest.parent, (exp.From, exp.Join)) and unnest.alias:
 99                for select in expression.selects:
100                    for column in select.find_all(exp.Column):
101                        if column.table == unnest.alias:
102                            column.set("table", None)
103
104    return expression
105
106
107class BigQuery(Dialect):
108    UNNEST_COLUMN_ONLY = True
109
110    # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#case_sensitivity
111    RESOLVES_IDENTIFIERS_AS_UPPERCASE = None
112
113    TIME_MAPPING = {
114        "%D": "%m/%d/%y",
115    }
116
117    FORMAT_MAPPING = {
118        "DD": "%d",
119        "MM": "%m",
120        "MON": "%b",
121        "MONTH": "%B",
122        "YYYY": "%Y",
123        "YY": "%y",
124        "HH": "%I",
125        "HH12": "%I",
126        "HH24": "%H",
127        "MI": "%M",
128        "SS": "%S",
129        "SSSSS": "%f",
130        "TZH": "%z",
131    }
132
133    @classmethod
134    def normalize_identifier(cls, expression: E) -> E:
135        # In BigQuery, CTEs aren't case-sensitive, but table names are (by default, at least).
136        # The following check is essentially a heuristic to detect tables based on whether or
137        # not they're qualified.
138        if (
139            isinstance(expression, exp.Identifier)
140            and not (isinstance(expression.parent, exp.Table) and expression.parent.db)
141            and not expression.meta.get("is_table")
142        ):
143            expression.set("this", expression.this.lower())
144
145        return expression
146
147    class Tokenizer(tokens.Tokenizer):
148        QUOTES = ["'", '"', '"""', "'''"]
149        COMMENTS = ["--", "#", ("/*", "*/")]
150        IDENTIFIERS = ["`"]
151        STRING_ESCAPES = ["\\"]
152
153        HEX_STRINGS = [("0x", ""), ("0X", "")]
154
155        BYTE_STRINGS = [
156            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("b", "B")
157        ]
158
159        RAW_STRINGS = [
160            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("r", "R")
161        ]
162
163        KEYWORDS = {
164            **tokens.Tokenizer.KEYWORDS,
165            "ANY TYPE": TokenType.VARIANT,
166            "BEGIN": TokenType.COMMAND,
167            "BEGIN TRANSACTION": TokenType.BEGIN,
168            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
169            "BYTES": TokenType.BINARY,
170            "DECLARE": TokenType.COMMAND,
171            "FLOAT64": TokenType.DOUBLE,
172            "INT64": TokenType.BIGINT,
173            "RECORD": TokenType.STRUCT,
174            "TIMESTAMP": TokenType.TIMESTAMPTZ,
175            "NOT DETERMINISTIC": TokenType.VOLATILE,
176            "UNKNOWN": TokenType.NULL,
177        }
178        KEYWORDS.pop("DIV")
179
180    class Parser(parser.Parser):
181        PREFIXED_PIVOT_COLUMNS = True
182
183        LOG_BASE_FIRST = False
184        LOG_DEFAULTS_TO_LN = True
185
186        FUNCTIONS = {
187            **parser.Parser.FUNCTIONS,
188            "DATE_ADD": parse_date_delta_with_interval(exp.DateAdd),
189            "DATE_SUB": parse_date_delta_with_interval(exp.DateSub),
190            "DATE_TRUNC": lambda args: exp.DateTrunc(
191                unit=exp.Literal.string(str(seq_get(args, 1))),
192                this=seq_get(args, 0),
193            ),
194            "DATETIME_ADD": parse_date_delta_with_interval(exp.DatetimeAdd),
195            "DATETIME_SUB": parse_date_delta_with_interval(exp.DatetimeSub),
196            "DIV": lambda args: exp.IntDiv(this=seq_get(args, 0), expression=seq_get(args, 1)),
197            "GENERATE_ARRAY": exp.GenerateSeries.from_arg_list,
198            "PARSE_DATE": lambda args: format_time_lambda(exp.StrToDate, "bigquery")(
199                [seq_get(args, 1), seq_get(args, 0)]
200            ),
201            "PARSE_TIMESTAMP": lambda args: format_time_lambda(exp.StrToTime, "bigquery")(
202                [seq_get(args, 1), seq_get(args, 0)]
203            ),
204            "REGEXP_CONTAINS": exp.RegexpLike.from_arg_list,
205            "REGEXP_EXTRACT": lambda args: exp.RegexpExtract(
206                this=seq_get(args, 0),
207                expression=seq_get(args, 1),
208                position=seq_get(args, 2),
209                occurrence=seq_get(args, 3),
210                group=exp.Literal.number(1)
211                if re.compile(str(seq_get(args, 1))).groups == 1
212                else None,
213            ),
214            "SPLIT": lambda args: exp.Split(
215                # https://cloud.google.com/bigquery/docs/reference/standard-sql/string_functions#split
216                this=seq_get(args, 0),
217                expression=seq_get(args, 1) or exp.Literal.string(","),
218            ),
219            "TIME_ADD": parse_date_delta_with_interval(exp.TimeAdd),
220            "TIME_SUB": parse_date_delta_with_interval(exp.TimeSub),
221            "TIMESTAMP_ADD": parse_date_delta_with_interval(exp.TimestampAdd),
222            "TIMESTAMP_SUB": parse_date_delta_with_interval(exp.TimestampSub),
223            "TO_JSON_STRING": exp.JSONFormat.from_arg_list,
224        }
225
226        FUNCTION_PARSERS = {
227            **parser.Parser.FUNCTION_PARSERS,
228            "ARRAY": lambda self: self.expression(exp.Array, expressions=[self._parse_statement()]),
229        }
230        FUNCTION_PARSERS.pop("TRIM")
231
232        NO_PAREN_FUNCTIONS = {
233            **parser.Parser.NO_PAREN_FUNCTIONS,
234            TokenType.CURRENT_DATETIME: exp.CurrentDatetime,
235        }
236
237        NESTED_TYPE_TOKENS = {
238            *parser.Parser.NESTED_TYPE_TOKENS,
239            TokenType.TABLE,
240        }
241
242        ID_VAR_TOKENS = {
243            *parser.Parser.ID_VAR_TOKENS,
244            TokenType.VALUES,
245        }
246
247        PROPERTY_PARSERS = {
248            **parser.Parser.PROPERTY_PARSERS,
249            "NOT DETERMINISTIC": lambda self: self.expression(
250                exp.StabilityProperty, this=exp.Literal.string("VOLATILE")
251            ),
252            "OPTIONS": lambda self: self._parse_with_property(),
253        }
254
255        CONSTRAINT_PARSERS = {
256            **parser.Parser.CONSTRAINT_PARSERS,
257            "OPTIONS": lambda self: exp.Properties(expressions=self._parse_with_property()),
258        }
259
260        def _parse_table_part(self, schema: bool = False) -> t.Optional[exp.Expression]:
261            this = super()._parse_table_part(schema=schema)
262
263            # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#table_names
264            if isinstance(this, exp.Identifier):
265                table_name = this.name
266                while self._match(TokenType.DASH, advance=False) and self._next:
267                    self._advance(2)
268                    table_name += f"-{self._prev.text}"
269
270                this = exp.Identifier(this=table_name, quoted=this.args.get("quoted"))
271
272            return this
273
274        def _parse_table_parts(self, schema: bool = False) -> exp.Table:
275            table = super()._parse_table_parts(schema=schema)
276            if isinstance(table.this, exp.Identifier) and "." in table.name:
277                catalog, db, this, *rest = (
278                    t.cast(t.Optional[exp.Expression], exp.to_identifier(x))
279                    for x in split_num_words(table.name, ".", 3)
280                )
281
282                if rest and this:
283                    this = exp.Dot.build(t.cast(t.List[exp.Expression], [this, *rest]))
284
285                table = exp.Table(this=this, db=db, catalog=catalog)
286
287            return table
288
289    class Generator(generator.Generator):
290        EXPLICIT_UNION = True
291        INTERVAL_ALLOWS_PLURAL_FORM = False
292        JOIN_HINTS = False
293        TABLE_HINTS = False
294        LIMIT_FETCH = "LIMIT"
295        RENAME_TABLE_WITH_DB = False
296
297        TRANSFORMS = {
298            **generator.Generator.TRANSFORMS,
299            exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
300            exp.ArraySize: rename_func("ARRAY_LENGTH"),
301            exp.AtTimeZone: lambda self, e: self.func(
302                "TIMESTAMP", self.func("DATETIME", e.this, e.args.get("zone"))
303            ),
304            exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]),
305            exp.DateAdd: _date_add_sql("DATE", "ADD"),
306            exp.DateSub: _date_add_sql("DATE", "SUB"),
307            exp.DatetimeAdd: _date_add_sql("DATETIME", "ADD"),
308            exp.DatetimeSub: _date_add_sql("DATETIME", "SUB"),
309            exp.DateDiff: lambda self, e: f"DATE_DIFF({self.sql(e, 'this')}, {self.sql(e, 'expression')}, {self.sql(e.args.get('unit', 'DAY'))})",
310            exp.DateStrToDate: datestrtodate_sql,
311            exp.DateTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, e.text("unit")),
312            exp.JSONFormat: rename_func("TO_JSON_STRING"),
313            exp.GenerateSeries: rename_func("GENERATE_ARRAY"),
314            exp.GroupConcat: rename_func("STRING_AGG"),
315            exp.ILike: no_ilike_sql,
316            exp.IntDiv: rename_func("DIV"),
317            exp.Max: max_or_greatest,
318            exp.Min: min_or_least,
319            exp.RegexpExtract: lambda self, e: self.func(
320                "REGEXP_EXTRACT",
321                e.this,
322                e.expression,
323                e.args.get("position"),
324                e.args.get("occurrence"),
325            ),
326            exp.RegexpLike: rename_func("REGEXP_CONTAINS"),
327            exp.Select: transforms.preprocess(
328                [_unqualify_unnest, transforms.eliminate_distinct_on]
329            ),
330            exp.StrToDate: lambda self, e: f"PARSE_DATE({self.format_time(e)}, {self.sql(e, 'this')})",
331            exp.StrToTime: lambda self, e: f"PARSE_TIMESTAMP({self.format_time(e)}, {self.sql(e, 'this')})",
332            exp.TimeAdd: _date_add_sql("TIME", "ADD"),
333            exp.TimeSub: _date_add_sql("TIME", "SUB"),
334            exp.TimestampAdd: _date_add_sql("TIMESTAMP", "ADD"),
335            exp.TimestampSub: _date_add_sql("TIMESTAMP", "SUB"),
336            exp.TimeStrToTime: timestrtotime_sql,
337            exp.TryCast: lambda self, e: f"SAFE_CAST({self.sql(e, 'this')} AS {self.sql(e, 'to')})",
338            exp.TsOrDsToDate: ts_or_ds_to_date_sql("bigquery"),
339            exp.TsOrDsAdd: _date_add_sql("DATE", "ADD"),
340            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
341            exp.VariancePop: rename_func("VAR_POP"),
342            exp.Values: _derived_table_values_to_unnest,
343            exp.ReturnsProperty: _returnsproperty_sql,
344            exp.Create: _create_sql,
345            exp.Trim: lambda self, e: self.func(f"TRIM", e.this, e.expression),
346            exp.StabilityProperty: lambda self, e: f"DETERMINISTIC"
347            if e.name == "IMMUTABLE"
348            else "NOT DETERMINISTIC",
349        }
350
351        TYPE_MAPPING = {
352            **generator.Generator.TYPE_MAPPING,
353            exp.DataType.Type.BIGDECIMAL: "BIGNUMERIC",
354            exp.DataType.Type.BIGINT: "INT64",
355            exp.DataType.Type.BINARY: "BYTES",
356            exp.DataType.Type.BOOLEAN: "BOOL",
357            exp.DataType.Type.CHAR: "STRING",
358            exp.DataType.Type.DECIMAL: "NUMERIC",
359            exp.DataType.Type.DOUBLE: "FLOAT64",
360            exp.DataType.Type.FLOAT: "FLOAT64",
361            exp.DataType.Type.INT: "INT64",
362            exp.DataType.Type.NCHAR: "STRING",
363            exp.DataType.Type.NVARCHAR: "STRING",
364            exp.DataType.Type.SMALLINT: "INT64",
365            exp.DataType.Type.TEXT: "STRING",
366            exp.DataType.Type.TIMESTAMP: "DATETIME",
367            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
368            exp.DataType.Type.TIMESTAMPLTZ: "TIMESTAMP",
369            exp.DataType.Type.TINYINT: "INT64",
370            exp.DataType.Type.VARBINARY: "BYTES",
371            exp.DataType.Type.VARCHAR: "STRING",
372            exp.DataType.Type.VARIANT: "ANY TYPE",
373        }
374
375        PROPERTIES_LOCATION = {
376            **generator.Generator.PROPERTIES_LOCATION,
377            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
378            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
379        }
380
381        RESERVED_KEYWORDS = {*generator.Generator.RESERVED_KEYWORDS, "hash"}
382
383        def array_sql(self, expression: exp.Array) -> str:
384            first_arg = seq_get(expression.expressions, 0)
385            if isinstance(first_arg, exp.Subqueryable):
386                return f"ARRAY{self.wrap(self.sql(first_arg))}"
387
388            return inline_array_sql(self, expression)
389
390        def transaction_sql(self, *_) -> str:
391            return "BEGIN TRANSACTION"
392
393        def commit_sql(self, *_) -> str:
394            return "COMMIT TRANSACTION"
395
396        def rollback_sql(self, *_) -> str:
397            return "ROLLBACK TRANSACTION"
398
399        def in_unnest_op(self, expression: exp.Unnest) -> str:
400            return self.sql(expression)
401
402        def except_op(self, expression: exp.Except) -> str:
403            if not expression.args.get("distinct", False):
404                self.unsupported("EXCEPT without DISTINCT is not supported in BigQuery")
405            return f"EXCEPT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
406
407        def intersect_op(self, expression: exp.Intersect) -> str:
408            if not expression.args.get("distinct", False):
409                self.unsupported("INTERSECT without DISTINCT is not supported in BigQuery")
410            return f"INTERSECT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
411
412        def with_properties(self, properties: exp.Properties) -> str:
413            return self.properties(properties, prefix=self.seg("OPTIONS"))

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

108class BigQuery(Dialect):
109    UNNEST_COLUMN_ONLY = True
110
111    # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#case_sensitivity
112    RESOLVES_IDENTIFIERS_AS_UPPERCASE = None
113
114    TIME_MAPPING = {
115        "%D": "%m/%d/%y",
116    }
117
118    FORMAT_MAPPING = {
119        "DD": "%d",
120        "MM": "%m",
121        "MON": "%b",
122        "MONTH": "%B",
123        "YYYY": "%Y",
124        "YY": "%y",
125        "HH": "%I",
126        "HH12": "%I",
127        "HH24": "%H",
128        "MI": "%M",
129        "SS": "%S",
130        "SSSSS": "%f",
131        "TZH": "%z",
132    }
133
134    @classmethod
135    def normalize_identifier(cls, expression: E) -> E:
136        # In BigQuery, CTEs aren't case-sensitive, but table names are (by default, at least).
137        # The following check is essentially a heuristic to detect tables based on whether or
138        # not they're qualified.
139        if (
140            isinstance(expression, exp.Identifier)
141            and not (isinstance(expression.parent, exp.Table) and expression.parent.db)
142            and not expression.meta.get("is_table")
143        ):
144            expression.set("this", expression.this.lower())
145
146        return expression
147
148    class Tokenizer(tokens.Tokenizer):
149        QUOTES = ["'", '"', '"""', "'''"]
150        COMMENTS = ["--", "#", ("/*", "*/")]
151        IDENTIFIERS = ["`"]
152        STRING_ESCAPES = ["\\"]
153
154        HEX_STRINGS = [("0x", ""), ("0X", "")]
155
156        BYTE_STRINGS = [
157            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("b", "B")
158        ]
159
160        RAW_STRINGS = [
161            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("r", "R")
162        ]
163
164        KEYWORDS = {
165            **tokens.Tokenizer.KEYWORDS,
166            "ANY TYPE": TokenType.VARIANT,
167            "BEGIN": TokenType.COMMAND,
168            "BEGIN TRANSACTION": TokenType.BEGIN,
169            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
170            "BYTES": TokenType.BINARY,
171            "DECLARE": TokenType.COMMAND,
172            "FLOAT64": TokenType.DOUBLE,
173            "INT64": TokenType.BIGINT,
174            "RECORD": TokenType.STRUCT,
175            "TIMESTAMP": TokenType.TIMESTAMPTZ,
176            "NOT DETERMINISTIC": TokenType.VOLATILE,
177            "UNKNOWN": TokenType.NULL,
178        }
179        KEYWORDS.pop("DIV")
180
181    class Parser(parser.Parser):
182        PREFIXED_PIVOT_COLUMNS = True
183
184        LOG_BASE_FIRST = False
185        LOG_DEFAULTS_TO_LN = True
186
187        FUNCTIONS = {
188            **parser.Parser.FUNCTIONS,
189            "DATE_ADD": parse_date_delta_with_interval(exp.DateAdd),
190            "DATE_SUB": parse_date_delta_with_interval(exp.DateSub),
191            "DATE_TRUNC": lambda args: exp.DateTrunc(
192                unit=exp.Literal.string(str(seq_get(args, 1))),
193                this=seq_get(args, 0),
194            ),
195            "DATETIME_ADD": parse_date_delta_with_interval(exp.DatetimeAdd),
196            "DATETIME_SUB": parse_date_delta_with_interval(exp.DatetimeSub),
197            "DIV": lambda args: exp.IntDiv(this=seq_get(args, 0), expression=seq_get(args, 1)),
198            "GENERATE_ARRAY": exp.GenerateSeries.from_arg_list,
199            "PARSE_DATE": lambda args: format_time_lambda(exp.StrToDate, "bigquery")(
200                [seq_get(args, 1), seq_get(args, 0)]
201            ),
202            "PARSE_TIMESTAMP": lambda args: format_time_lambda(exp.StrToTime, "bigquery")(
203                [seq_get(args, 1), seq_get(args, 0)]
204            ),
205            "REGEXP_CONTAINS": exp.RegexpLike.from_arg_list,
206            "REGEXP_EXTRACT": lambda args: exp.RegexpExtract(
207                this=seq_get(args, 0),
208                expression=seq_get(args, 1),
209                position=seq_get(args, 2),
210                occurrence=seq_get(args, 3),
211                group=exp.Literal.number(1)
212                if re.compile(str(seq_get(args, 1))).groups == 1
213                else None,
214            ),
215            "SPLIT": lambda args: exp.Split(
216                # https://cloud.google.com/bigquery/docs/reference/standard-sql/string_functions#split
217                this=seq_get(args, 0),
218                expression=seq_get(args, 1) or exp.Literal.string(","),
219            ),
220            "TIME_ADD": parse_date_delta_with_interval(exp.TimeAdd),
221            "TIME_SUB": parse_date_delta_with_interval(exp.TimeSub),
222            "TIMESTAMP_ADD": parse_date_delta_with_interval(exp.TimestampAdd),
223            "TIMESTAMP_SUB": parse_date_delta_with_interval(exp.TimestampSub),
224            "TO_JSON_STRING": exp.JSONFormat.from_arg_list,
225        }
226
227        FUNCTION_PARSERS = {
228            **parser.Parser.FUNCTION_PARSERS,
229            "ARRAY": lambda self: self.expression(exp.Array, expressions=[self._parse_statement()]),
230        }
231        FUNCTION_PARSERS.pop("TRIM")
232
233        NO_PAREN_FUNCTIONS = {
234            **parser.Parser.NO_PAREN_FUNCTIONS,
235            TokenType.CURRENT_DATETIME: exp.CurrentDatetime,
236        }
237
238        NESTED_TYPE_TOKENS = {
239            *parser.Parser.NESTED_TYPE_TOKENS,
240            TokenType.TABLE,
241        }
242
243        ID_VAR_TOKENS = {
244            *parser.Parser.ID_VAR_TOKENS,
245            TokenType.VALUES,
246        }
247
248        PROPERTY_PARSERS = {
249            **parser.Parser.PROPERTY_PARSERS,
250            "NOT DETERMINISTIC": lambda self: self.expression(
251                exp.StabilityProperty, this=exp.Literal.string("VOLATILE")
252            ),
253            "OPTIONS": lambda self: self._parse_with_property(),
254        }
255
256        CONSTRAINT_PARSERS = {
257            **parser.Parser.CONSTRAINT_PARSERS,
258            "OPTIONS": lambda self: exp.Properties(expressions=self._parse_with_property()),
259        }
260
261        def _parse_table_part(self, schema: bool = False) -> t.Optional[exp.Expression]:
262            this = super()._parse_table_part(schema=schema)
263
264            # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#table_names
265            if isinstance(this, exp.Identifier):
266                table_name = this.name
267                while self._match(TokenType.DASH, advance=False) and self._next:
268                    self._advance(2)
269                    table_name += f"-{self._prev.text}"
270
271                this = exp.Identifier(this=table_name, quoted=this.args.get("quoted"))
272
273            return this
274
275        def _parse_table_parts(self, schema: bool = False) -> exp.Table:
276            table = super()._parse_table_parts(schema=schema)
277            if isinstance(table.this, exp.Identifier) and "." in table.name:
278                catalog, db, this, *rest = (
279                    t.cast(t.Optional[exp.Expression], exp.to_identifier(x))
280                    for x in split_num_words(table.name, ".", 3)
281                )
282
283                if rest and this:
284                    this = exp.Dot.build(t.cast(t.List[exp.Expression], [this, *rest]))
285
286                table = exp.Table(this=this, db=db, catalog=catalog)
287
288            return table
289
290    class Generator(generator.Generator):
291        EXPLICIT_UNION = True
292        INTERVAL_ALLOWS_PLURAL_FORM = False
293        JOIN_HINTS = False
294        TABLE_HINTS = False
295        LIMIT_FETCH = "LIMIT"
296        RENAME_TABLE_WITH_DB = False
297
298        TRANSFORMS = {
299            **generator.Generator.TRANSFORMS,
300            exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
301            exp.ArraySize: rename_func("ARRAY_LENGTH"),
302            exp.AtTimeZone: lambda self, e: self.func(
303                "TIMESTAMP", self.func("DATETIME", e.this, e.args.get("zone"))
304            ),
305            exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]),
306            exp.DateAdd: _date_add_sql("DATE", "ADD"),
307            exp.DateSub: _date_add_sql("DATE", "SUB"),
308            exp.DatetimeAdd: _date_add_sql("DATETIME", "ADD"),
309            exp.DatetimeSub: _date_add_sql("DATETIME", "SUB"),
310            exp.DateDiff: lambda self, e: f"DATE_DIFF({self.sql(e, 'this')}, {self.sql(e, 'expression')}, {self.sql(e.args.get('unit', 'DAY'))})",
311            exp.DateStrToDate: datestrtodate_sql,
312            exp.DateTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, e.text("unit")),
313            exp.JSONFormat: rename_func("TO_JSON_STRING"),
314            exp.GenerateSeries: rename_func("GENERATE_ARRAY"),
315            exp.GroupConcat: rename_func("STRING_AGG"),
316            exp.ILike: no_ilike_sql,
317            exp.IntDiv: rename_func("DIV"),
318            exp.Max: max_or_greatest,
319            exp.Min: min_or_least,
320            exp.RegexpExtract: lambda self, e: self.func(
321                "REGEXP_EXTRACT",
322                e.this,
323                e.expression,
324                e.args.get("position"),
325                e.args.get("occurrence"),
326            ),
327            exp.RegexpLike: rename_func("REGEXP_CONTAINS"),
328            exp.Select: transforms.preprocess(
329                [_unqualify_unnest, transforms.eliminate_distinct_on]
330            ),
331            exp.StrToDate: lambda self, e: f"PARSE_DATE({self.format_time(e)}, {self.sql(e, 'this')})",
332            exp.StrToTime: lambda self, e: f"PARSE_TIMESTAMP({self.format_time(e)}, {self.sql(e, 'this')})",
333            exp.TimeAdd: _date_add_sql("TIME", "ADD"),
334            exp.TimeSub: _date_add_sql("TIME", "SUB"),
335            exp.TimestampAdd: _date_add_sql("TIMESTAMP", "ADD"),
336            exp.TimestampSub: _date_add_sql("TIMESTAMP", "SUB"),
337            exp.TimeStrToTime: timestrtotime_sql,
338            exp.TryCast: lambda self, e: f"SAFE_CAST({self.sql(e, 'this')} AS {self.sql(e, 'to')})",
339            exp.TsOrDsToDate: ts_or_ds_to_date_sql("bigquery"),
340            exp.TsOrDsAdd: _date_add_sql("DATE", "ADD"),
341            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
342            exp.VariancePop: rename_func("VAR_POP"),
343            exp.Values: _derived_table_values_to_unnest,
344            exp.ReturnsProperty: _returnsproperty_sql,
345            exp.Create: _create_sql,
346            exp.Trim: lambda self, e: self.func(f"TRIM", e.this, e.expression),
347            exp.StabilityProperty: lambda self, e: f"DETERMINISTIC"
348            if e.name == "IMMUTABLE"
349            else "NOT DETERMINISTIC",
350        }
351
352        TYPE_MAPPING = {
353            **generator.Generator.TYPE_MAPPING,
354            exp.DataType.Type.BIGDECIMAL: "BIGNUMERIC",
355            exp.DataType.Type.BIGINT: "INT64",
356            exp.DataType.Type.BINARY: "BYTES",
357            exp.DataType.Type.BOOLEAN: "BOOL",
358            exp.DataType.Type.CHAR: "STRING",
359            exp.DataType.Type.DECIMAL: "NUMERIC",
360            exp.DataType.Type.DOUBLE: "FLOAT64",
361            exp.DataType.Type.FLOAT: "FLOAT64",
362            exp.DataType.Type.INT: "INT64",
363            exp.DataType.Type.NCHAR: "STRING",
364            exp.DataType.Type.NVARCHAR: "STRING",
365            exp.DataType.Type.SMALLINT: "INT64",
366            exp.DataType.Type.TEXT: "STRING",
367            exp.DataType.Type.TIMESTAMP: "DATETIME",
368            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
369            exp.DataType.Type.TIMESTAMPLTZ: "TIMESTAMP",
370            exp.DataType.Type.TINYINT: "INT64",
371            exp.DataType.Type.VARBINARY: "BYTES",
372            exp.DataType.Type.VARCHAR: "STRING",
373            exp.DataType.Type.VARIANT: "ANY TYPE",
374        }
375
376        PROPERTIES_LOCATION = {
377            **generator.Generator.PROPERTIES_LOCATION,
378            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
379            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
380        }
381
382        RESERVED_KEYWORDS = {*generator.Generator.RESERVED_KEYWORDS, "hash"}
383
384        def array_sql(self, expression: exp.Array) -> str:
385            first_arg = seq_get(expression.expressions, 0)
386            if isinstance(first_arg, exp.Subqueryable):
387                return f"ARRAY{self.wrap(self.sql(first_arg))}"
388
389            return inline_array_sql(self, expression)
390
391        def transaction_sql(self, *_) -> str:
392            return "BEGIN TRANSACTION"
393
394        def commit_sql(self, *_) -> str:
395            return "COMMIT TRANSACTION"
396
397        def rollback_sql(self, *_) -> str:
398            return "ROLLBACK TRANSACTION"
399
400        def in_unnest_op(self, expression: exp.Unnest) -> str:
401            return self.sql(expression)
402
403        def except_op(self, expression: exp.Except) -> str:
404            if not expression.args.get("distinct", False):
405                self.unsupported("EXCEPT without DISTINCT is not supported in BigQuery")
406            return f"EXCEPT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
407
408        def intersect_op(self, expression: exp.Intersect) -> str:
409            if not expression.args.get("distinct", False):
410                self.unsupported("INTERSECT without DISTINCT is not supported in BigQuery")
411            return f"INTERSECT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
412
413        def with_properties(self, properties: exp.Properties) -> str:
414            return self.properties(properties, prefix=self.seg("OPTIONS"))

UNNEST_COLUMN_ONLY = True

RESOLVES_IDENTIFIERS_AS_UPPERCASE: Optional[bool] = None

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

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

@classmethod

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

134    @classmethod
135    def normalize_identifier(cls, expression: E) -> E:
136        # In BigQuery, CTEs aren't case-sensitive, but table names are (by default, at least).
137        # The following check is essentially a heuristic to detect tables based on whether or
138        # not they're qualified.
139        if (
140            isinstance(expression, exp.Identifier)
141            and not (isinstance(expression.parent, exp.Table) and expression.parent.db)
142            and not expression.meta.get("is_table")
143        ):
144            expression.set("this", expression.this.lower())
145
146        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 regardless of being quoted or not.

tokenizer_class = <class 'sqlglot.dialects.bigquery.BigQuery.Tokenizer'>

parser_class = <class 'sqlglot.dialects.bigquery.BigQuery.Parser'>

generator_class = <class 'sqlglot.dialects.bigquery.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}}}}}}}}}

QUOTE_START = "'"

QUOTE_END = "'"

IDENTIFIER_START = '`'

IDENTIFIER_END = '`'

BIT_START = None

BIT_END = None

HEX_START = '0x'

HEX_END = ''

BYTE_START = "b'"

BYTE_END = "'"

RAW_START = "r'"

RAW_END = "'"

Inherited Members

sqlglot.dialects.dialect.Dialect: INDEX_OFFSET; ALIAS_POST_TABLESAMPLE; IDENTIFIERS_CAN_START_WITH_DIGIT; STRICT_STRING_CONCAT; NORMALIZE_FUNCTIONS; 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

148    class Tokenizer(tokens.Tokenizer):
149        QUOTES = ["'", '"', '"""', "'''"]
150        COMMENTS = ["--", "#", ("/*", "*/")]
151        IDENTIFIERS = ["`"]
152        STRING_ESCAPES = ["\\"]
153
154        HEX_STRINGS = [("0x", ""), ("0X", "")]
155
156        BYTE_STRINGS = [
157            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("b", "B")
158        ]
159
160        RAW_STRINGS = [
161            (prefix + q, q) for q in t.cast(t.List[str], QUOTES) for prefix in ("r", "R")
162        ]
163
164        KEYWORDS = {
165            **tokens.Tokenizer.KEYWORDS,
166            "ANY TYPE": TokenType.VARIANT,
167            "BEGIN": TokenType.COMMAND,
168            "BEGIN TRANSACTION": TokenType.BEGIN,
169            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
170            "BYTES": TokenType.BINARY,
171            "DECLARE": TokenType.COMMAND,
172            "FLOAT64": TokenType.DOUBLE,
173            "INT64": TokenType.BIGINT,
174            "RECORD": TokenType.STRUCT,
175            "TIMESTAMP": TokenType.TIMESTAMPTZ,
176            "NOT DETERMINISTIC": TokenType.VOLATILE,
177            "UNKNOWN": TokenType.NULL,
178        }
179        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'>, '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'>, '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'>, 'IF': <TokenType.IF: 'IF'>, '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'>, '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'>, 'NEXT VALUE FOR': <TokenType.NEXT_VALUE_FOR: 'NEXT_VALUE_FOR'>, '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'>, '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'>, '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'>, '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'>, 'TINYINT': <TokenType.TINYINT: 'TINYINT'>, 'SHORT': <TokenType.SMALLINT: 'SMALLINT'>, 'SMALLINT': <TokenType.SMALLINT: 'SMALLINT'>, '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'>, 'CLOB': <TokenType.TEXT: 'TEXT'>, 'LONGVARCHAR': <TokenType.TEXT: 'TEXT'>, 'BINARY': <TokenType.BINARY: 'BINARY'>, 'BLOB': <TokenType.VARBINARY: 'VARBINARY'>, 'BYTEA': <TokenType.VARBINARY: 'VARBINARY'>, 'VARBINARY': <TokenType.VARBINARY: 'VARBINARY'>, 'TIME': <TokenType.TIME: 'TIME'>, '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'>, 'ANY TYPE': <TokenType.VARIANT: 'VARIANT'>, 'BEGIN TRANSACTION': <TokenType.BEGIN: 'BEGIN'>, 'CURRENT_DATETIME': <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, 'BYTES': <TokenType.BINARY: 'BINARY'>, 'DECLARE': <TokenType.COMMAND: 'COMMAND'>, 'FLOAT64': <TokenType.DOUBLE: 'DOUBLE'>, 'INT64': <TokenType.BIGINT: 'BIGINT'>, 'RECORD': <TokenType.STRUCT: 'STRUCT'>, 'NOT DETERMINISTIC': <TokenType.VOLATILE: 'VOLATILE'>, 'UNKNOWN': <TokenType.NULL: 'NULL'>}

Inherited Members

sqlglot.tokens.Tokenizer: SINGLE_TOKENS; BIT_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