sqlglot.dialects.bigquery API documentation

114class BigQuery(Dialect):
-115    unnest_column_only = True
-116    time_mapping = {
-117        "%M": "%-M",
-118        "%d": "%-d",
-119        "%m": "%-m",
-120        "%y": "%-y",
-121        "%H": "%-H",
-122        "%I": "%-I",
-123        "%S": "%-S",
-124        "%j": "%-j",
-125    }
-126
-127    class Tokenizer(tokens.Tokenizer):
-128        QUOTES = [
-129            (prefix + quote, quote) if prefix else quote
-130            for quote in ["'", '"', '"""', "'''"]
-131            for prefix in ["", "r", "R"]
-132        ]
-133        COMMENTS = ["--", "#", ("/*", "*/")]
-134        IDENTIFIERS = ["`"]
-135        STRING_ESCAPES = ["\\"]
-136        HEX_STRINGS = [("0x", ""), ("0X", "")]
-137
-138        KEYWORDS = {
-139            **tokens.Tokenizer.KEYWORDS,
-140            "BEGIN": TokenType.COMMAND,
-141            "BEGIN TRANSACTION": TokenType.BEGIN,
-142            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
-143            "CURRENT_TIME": TokenType.CURRENT_TIME,
-144            "DECLARE": TokenType.COMMAND,
-145            "GEOGRAPHY": TokenType.GEOGRAPHY,
-146            "FLOAT64": TokenType.DOUBLE,
-147            "INT64": TokenType.BIGINT,
-148            "NOT DETERMINISTIC": TokenType.VOLATILE,
-149            "UNKNOWN": TokenType.NULL,
-150        }
-151        KEYWORDS.pop("DIV")
-152
-153    class Parser(parser.Parser):
-154        FUNCTIONS = {
-155            **parser.Parser.FUNCTIONS,  # type: ignore
-156            "DATE_TRUNC": lambda args: exp.DateTrunc(
-157                unit=exp.Literal.string(seq_get(args, 1).name),  # type: ignore
-158                this=seq_get(args, 0),
-159            ),
-160            "DATE_ADD": _date_add(exp.DateAdd),
-161            "DATETIME_ADD": _date_add(exp.DatetimeAdd),
-162            "DIV": lambda args: exp.IntDiv(this=seq_get(args, 0), expression=seq_get(args, 1)),
-163            "REGEXP_CONTAINS": exp.RegexpLike.from_arg_list,
-164            "REGEXP_EXTRACT": lambda args: exp.RegexpExtract(
-165                this=seq_get(args, 0),
-166                expression=seq_get(args, 1),
-167                position=seq_get(args, 2),
-168                occurrence=seq_get(args, 3),
-169                group=exp.Literal.number(1)
-170                if re.compile(str(seq_get(args, 1))).groups == 1
-171                else None,
-172            ),
-173            "TIME_ADD": _date_add(exp.TimeAdd),
-174            "TIMESTAMP_ADD": _date_add(exp.TimestampAdd),
-175            "DATE_SUB": _date_add(exp.DateSub),
-176            "DATETIME_SUB": _date_add(exp.DatetimeSub),
-177            "TIME_SUB": _date_add(exp.TimeSub),
-178            "TIMESTAMP_SUB": _date_add(exp.TimestampSub),
-179            "PARSE_TIMESTAMP": lambda args: exp.StrToTime(
-180                this=seq_get(args, 1), format=seq_get(args, 0)
-181            ),
-182        }
-183
-184        FUNCTION_PARSERS = {
-185            **parser.Parser.FUNCTION_PARSERS,  # type: ignore
-186            "ARRAY": lambda self: self.expression(exp.Array, expressions=[self._parse_statement()]),
-187        }
-188        FUNCTION_PARSERS.pop("TRIM")
-189
-190        NO_PAREN_FUNCTIONS = {
-191            **parser.Parser.NO_PAREN_FUNCTIONS,  # type: ignore
-192            TokenType.CURRENT_DATETIME: exp.CurrentDatetime,
-193            TokenType.CURRENT_TIME: exp.CurrentTime,
-194        }
-195
-196        NESTED_TYPE_TOKENS = {
-197            *parser.Parser.NESTED_TYPE_TOKENS,  # type: ignore
-198            TokenType.TABLE,
-199        }
-200
-201        ID_VAR_TOKENS = {
-202            *parser.Parser.ID_VAR_TOKENS,  # type: ignore
-203            TokenType.VALUES,
-204        }
-205
-206        PROPERTY_PARSERS = {
-207            **parser.Parser.PROPERTY_PARSERS,  # type: ignore
-208            "NOT DETERMINISTIC": lambda self: self.expression(
-209                exp.VolatilityProperty, this=exp.Literal.string("VOLATILE")
-210            ),
-211        }
-212
-213    class Generator(generator.Generator):
-214        TRANSFORMS = {
-215            **generator.Generator.TRANSFORMS,  # type: ignore
-216            **transforms.REMOVE_PRECISION_PARAMETERIZED_TYPES,  # type: ignore
-217            exp.ArraySize: rename_func("ARRAY_LENGTH"),
-218            exp.DateAdd: _date_add_sql("DATE", "ADD"),
-219            exp.DateSub: _date_add_sql("DATE", "SUB"),
-220            exp.DatetimeAdd: _date_add_sql("DATETIME", "ADD"),
-221            exp.DatetimeSub: _date_add_sql("DATETIME", "SUB"),
-222            exp.DateDiff: lambda self, e: f"DATE_DIFF({self.sql(e, 'this')}, {self.sql(e, 'expression')}, {self.sql(e.args.get('unit', 'DAY'))})",
-223            exp.DateStrToDate: datestrtodate_sql,
-224            exp.DateTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, e.text("unit")),
-225            exp.GroupConcat: rename_func("STRING_AGG"),
-226            exp.ILike: no_ilike_sql,
-227            exp.IntDiv: rename_func("DIV"),
-228            exp.Select: transforms.preprocess(
-229                [_unqualify_unnest], transforms.delegate("select_sql")
-230            ),
-231            exp.StrToTime: lambda self, e: f"PARSE_TIMESTAMP({self.format_time(e)}, {self.sql(e, 'this')})",
-232            exp.TimeAdd: _date_add_sql("TIME", "ADD"),
-233            exp.TimeSub: _date_add_sql("TIME", "SUB"),
-234            exp.TimestampAdd: _date_add_sql("TIMESTAMP", "ADD"),
-235            exp.TimestampSub: _date_add_sql("TIMESTAMP", "SUB"),
-236            exp.TimeStrToTime: timestrtotime_sql,
-237            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
-238            exp.VariancePop: rename_func("VAR_POP"),
-239            exp.Values: _derived_table_values_to_unnest,
-240            exp.ReturnsProperty: _returnsproperty_sql,
-241            exp.Create: _create_sql,
-242            exp.Trim: lambda self, e: self.func(f"TRIM", e.this, e.expression),
-243            exp.VolatilityProperty: lambda self, e: f"DETERMINISTIC"
-244            if e.name == "IMMUTABLE"
-245            else "NOT DETERMINISTIC",
-246            exp.RegexpLike: rename_func("REGEXP_CONTAINS"),
-247        }
-248
-249        TYPE_MAPPING = {
-250            **generator.Generator.TYPE_MAPPING,  # type: ignore
-251            exp.DataType.Type.TINYINT: "INT64",
-252            exp.DataType.Type.SMALLINT: "INT64",
-253            exp.DataType.Type.INT: "INT64",
-254            exp.DataType.Type.BIGINT: "INT64",
-255            exp.DataType.Type.DECIMAL: "NUMERIC",
-256            exp.DataType.Type.FLOAT: "FLOAT64",
-257            exp.DataType.Type.DOUBLE: "FLOAT64",
-258            exp.DataType.Type.BOOLEAN: "BOOL",
-259            exp.DataType.Type.TEXT: "STRING",
-260            exp.DataType.Type.VARCHAR: "STRING",
-261            exp.DataType.Type.NVARCHAR: "STRING",
-262        }
-263        PROPERTIES_LOCATION = {
-264            **generator.Generator.PROPERTIES_LOCATION,  # type: ignore
-265            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
-266        }
-267
-268        EXPLICIT_UNION = True
+            115class BigQuery(Dialect):
+116    unnest_column_only = True
+117    time_mapping = {
+118        "%M": "%-M",
+119        "%d": "%-d",
+120        "%m": "%-m",
+121        "%y": "%-y",
+122        "%H": "%-H",
+123        "%I": "%-I",
+124        "%S": "%-S",
+125        "%j": "%-j",
+126    }
+127
+128    class Tokenizer(tokens.Tokenizer):
+129        QUOTES = [
+130            (prefix + quote, quote) if prefix else quote
+131            for quote in ["'", '"', '"""', "'''"]
+132            for prefix in ["", "r", "R"]
+133        ]
+134        COMMENTS = ["--", "#", ("/*", "*/")]
+135        IDENTIFIERS = ["`"]
+136        STRING_ESCAPES = ["\\"]
+137        HEX_STRINGS = [("0x", ""), ("0X", "")]
+138
+139        KEYWORDS = {
+140            **tokens.Tokenizer.KEYWORDS,
+141            "BEGIN": TokenType.COMMAND,
+142            "BEGIN TRANSACTION": TokenType.BEGIN,
+143            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
+144            "CURRENT_TIME": TokenType.CURRENT_TIME,
+145            "DECLARE": TokenType.COMMAND,
+146            "GEOGRAPHY": TokenType.GEOGRAPHY,
+147            "FLOAT64": TokenType.DOUBLE,
+148            "INT64": TokenType.BIGINT,
+149            "NOT DETERMINISTIC": TokenType.VOLATILE,
+150            "UNKNOWN": TokenType.NULL,
+151        }
+152        KEYWORDS.pop("DIV")
+153
+154    class Parser(parser.Parser):
+155        FUNCTIONS = {
+156            **parser.Parser.FUNCTIONS,  # type: ignore
+157            "DATE_TRUNC": lambda args: exp.DateTrunc(
+158                unit=exp.Literal.string(seq_get(args, 1).name),  # type: ignore
+159                this=seq_get(args, 0),
+160            ),
+161            "DATE_ADD": _date_add(exp.DateAdd),
+162            "DATETIME_ADD": _date_add(exp.DatetimeAdd),
+163            "DIV": lambda args: exp.IntDiv(this=seq_get(args, 0), expression=seq_get(args, 1)),
+164            "REGEXP_CONTAINS": exp.RegexpLike.from_arg_list,
+165            "REGEXP_EXTRACT": lambda args: exp.RegexpExtract(
+166                this=seq_get(args, 0),
+167                expression=seq_get(args, 1),
+168                position=seq_get(args, 2),
+169                occurrence=seq_get(args, 3),
+170                group=exp.Literal.number(1)
+171                if re.compile(str(seq_get(args, 1))).groups == 1
+172                else None,
+173            ),
+174            "TIME_ADD": _date_add(exp.TimeAdd),
+175            "TIMESTAMP_ADD": _date_add(exp.TimestampAdd),
+176            "DATE_SUB": _date_add(exp.DateSub),
+177            "DATETIME_SUB": _date_add(exp.DatetimeSub),
+178            "TIME_SUB": _date_add(exp.TimeSub),
+179            "TIMESTAMP_SUB": _date_add(exp.TimestampSub),
+180            "PARSE_TIMESTAMP": lambda args: exp.StrToTime(
+181                this=seq_get(args, 1), format=seq_get(args, 0)
+182            ),
+183        }
+184
+185        FUNCTION_PARSERS = {
+186            **parser.Parser.FUNCTION_PARSERS,  # type: ignore
+187            "ARRAY": lambda self: self.expression(exp.Array, expressions=[self._parse_statement()]),
+188        }
+189        FUNCTION_PARSERS.pop("TRIM")
+190
+191        NO_PAREN_FUNCTIONS = {
+192            **parser.Parser.NO_PAREN_FUNCTIONS,  # type: ignore
+193            TokenType.CURRENT_DATETIME: exp.CurrentDatetime,
+194            TokenType.CURRENT_TIME: exp.CurrentTime,
+195        }
+196
+197        NESTED_TYPE_TOKENS = {
+198            *parser.Parser.NESTED_TYPE_TOKENS,  # type: ignore
+199            TokenType.TABLE,
+200        }
+201
+202        ID_VAR_TOKENS = {
+203            *parser.Parser.ID_VAR_TOKENS,  # type: ignore
+204            TokenType.VALUES,
+205        }
+206
+207        PROPERTY_PARSERS = {
+208            **parser.Parser.PROPERTY_PARSERS,  # type: ignore
+209            "NOT DETERMINISTIC": lambda self: self.expression(
+210                exp.VolatilityProperty, this=exp.Literal.string("VOLATILE")
+211            ),
+212        }
+213
+214    class Generator(generator.Generator):
+215        TRANSFORMS = {
+216            **generator.Generator.TRANSFORMS,  # type: ignore
+217            **transforms.REMOVE_PRECISION_PARAMETERIZED_TYPES,  # type: ignore
+218            exp.ArraySize: rename_func("ARRAY_LENGTH"),
+219            exp.DateAdd: _date_add_sql("DATE", "ADD"),
+220            exp.DateSub: _date_add_sql("DATE", "SUB"),
+221            exp.DatetimeAdd: _date_add_sql("DATETIME", "ADD"),
+222            exp.DatetimeSub: _date_add_sql("DATETIME", "SUB"),
+223            exp.DateDiff: lambda self, e: f"DATE_DIFF({self.sql(e, 'this')}, {self.sql(e, 'expression')}, {self.sql(e.args.get('unit', 'DAY'))})",
+224            exp.DateStrToDate: datestrtodate_sql,
+225            exp.DateTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, e.text("unit")),
+226            exp.GroupConcat: rename_func("STRING_AGG"),
+227            exp.ILike: no_ilike_sql,
+228            exp.IntDiv: rename_func("DIV"),
+229            exp.Select: transforms.preprocess(
+230                [_unqualify_unnest], transforms.delegate("select_sql")
+231            ),
+232            exp.StrToTime: lambda self, e: f"PARSE_TIMESTAMP({self.format_time(e)}, {self.sql(e, 'this')})",
+233            exp.TimeAdd: _date_add_sql("TIME", "ADD"),
+234            exp.TimeSub: _date_add_sql("TIME", "SUB"),
+235            exp.TimestampAdd: _date_add_sql("TIMESTAMP", "ADD"),
+236            exp.TimestampSub: _date_add_sql("TIMESTAMP", "SUB"),
+237            exp.TimeStrToTime: timestrtotime_sql,
+238            exp.TsOrDsToDate: ts_or_ds_to_date_sql("bigquery"),
+239            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
+240            exp.VariancePop: rename_func("VAR_POP"),
+241            exp.Values: _derived_table_values_to_unnest,
+242            exp.ReturnsProperty: _returnsproperty_sql,
+243            exp.Create: _create_sql,
+244            exp.Trim: lambda self, e: self.func(f"TRIM", e.this, e.expression),
+245            exp.VolatilityProperty: lambda self, e: f"DETERMINISTIC"
+246            if e.name == "IMMUTABLE"
+247            else "NOT DETERMINISTIC",
+248            exp.RegexpLike: rename_func("REGEXP_CONTAINS"),
+249        }
+250
+251        TYPE_MAPPING = {
+252            **generator.Generator.TYPE_MAPPING,  # type: ignore
+253            exp.DataType.Type.TINYINT: "INT64",
+254            exp.DataType.Type.SMALLINT: "INT64",
+255            exp.DataType.Type.INT: "INT64",
+256            exp.DataType.Type.BIGINT: "INT64",
+257            exp.DataType.Type.DECIMAL: "NUMERIC",
+258            exp.DataType.Type.FLOAT: "FLOAT64",
+259            exp.DataType.Type.DOUBLE: "FLOAT64",
+260            exp.DataType.Type.BOOLEAN: "BOOL",
+261            exp.DataType.Type.TEXT: "STRING",
+262            exp.DataType.Type.VARCHAR: "STRING",
+263            exp.DataType.Type.NVARCHAR: "STRING",
+264        }
+265        PROPERTIES_LOCATION = {
+266            **generator.Generator.PROPERTIES_LOCATION,  # type: ignore
+267            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
+268        }
 269
-270        def array_sql(self, expression: exp.Array) -> str:
-271            first_arg = seq_get(expression.expressions, 0)
-272            if isinstance(first_arg, exp.Subqueryable):
-273                return f"ARRAY{self.wrap(self.sql(first_arg))}"
-274
-275            return inline_array_sql(self, expression)
+270        EXPLICIT_UNION = True
+271
+272        def array_sql(self, expression: exp.Array) -> str:
+273            first_arg = seq_get(expression.expressions, 0)
+274            if isinstance(first_arg, exp.Subqueryable):
+275                return f"ARRAY{self.wrap(self.sql(first_arg))}"
 276
-277        def transaction_sql(self, *_) -> str:
-278            return "BEGIN TRANSACTION"
-279
-280        def commit_sql(self, *_) -> str:
-281            return "COMMIT TRANSACTION"
-282
-283        def rollback_sql(self, *_) -> str:
-284            return "ROLLBACK TRANSACTION"
-285
-286        def in_unnest_op(self, expression: exp.Unnest) -> str:
-287            return self.sql(expression)
-288
-289        def except_op(self, expression: exp.Except) -> str:
-290            if not expression.args.get("distinct", False):
-291                self.unsupported("EXCEPT without DISTINCT is not supported in BigQuery")
-292            return f"EXCEPT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
-293
-294        def intersect_op(self, expression: exp.Intersect) -> str:
-295            if not expression.args.get("distinct", False):
-296                self.unsupported("INTERSECT without DISTINCT is not supported in BigQuery")
-297            return f"INTERSECT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
+277            return inline_array_sql(self, expression)
+278
+279        def transaction_sql(self, *_) -> str:
+280            return "BEGIN TRANSACTION"
+281
+282        def commit_sql(self, *_) -> str:
+283            return "COMMIT TRANSACTION"
+284
+285        def rollback_sql(self, *_) -> str:
+286            return "ROLLBACK TRANSACTION"
+287
+288        def in_unnest_op(self, expression: exp.Unnest) -> str:
+289            return self.sql(expression)
+290
+291        def except_op(self, expression: exp.Except) -> str:
+292            if not expression.args.get("distinct", False):
+293                self.unsupported("EXCEPT without DISTINCT is not supported in BigQuery")
+294            return f"EXCEPT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
+295
+296        def intersect_op(self, expression: exp.Intersect) -> str:
+297            if not expression.args.get("distinct", False):
+298                self.unsupported("INTERSECT without DISTINCT is not supported in BigQuery")
+299            return f"INTERSECT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
 
 
 
     
 
-                            
-                                
-            
-        BigQuery()
-
-        
-    
-    
-    
-    
-
-                            
                             
                                 Inherited Members
                                 
@@ -641,31 +629,31 @@
 
     
     
-            127    class Tokenizer(tokens.Tokenizer):
-128        QUOTES = [
-129            (prefix + quote, quote) if prefix else quote
-130            for quote in ["'", '"', '"""', "'''"]
-131            for prefix in ["", "r", "R"]
-132        ]
-133        COMMENTS = ["--", "#", ("/*", "*/")]
-134        IDENTIFIERS = ["`"]
-135        STRING_ESCAPES = ["\\"]
-136        HEX_STRINGS = [("0x", ""), ("0X", "")]
-137
-138        KEYWORDS = {
-139            **tokens.Tokenizer.KEYWORDS,
-140            "BEGIN": TokenType.COMMAND,
-141            "BEGIN TRANSACTION": TokenType.BEGIN,
-142            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
-143            "CURRENT_TIME": TokenType.CURRENT_TIME,
-144            "DECLARE": TokenType.COMMAND,
-145            "GEOGRAPHY": TokenType.GEOGRAPHY,
-146            "FLOAT64": TokenType.DOUBLE,
-147            "INT64": TokenType.BIGINT,
-148            "NOT DETERMINISTIC": TokenType.VOLATILE,
-149            "UNKNOWN": TokenType.NULL,
-150        }
-151        KEYWORDS.pop("DIV")
+            128    class Tokenizer(tokens.Tokenizer):
+129        QUOTES = [
+130            (prefix + quote, quote) if prefix else quote
+131            for quote in ["'", '"', '"""', "'''"]
+132            for prefix in ["", "r", "R"]
+133        ]
+134        COMMENTS = ["--", "#", ("/*", "*/")]
+135        IDENTIFIERS = ["`"]
+136        STRING_ESCAPES = ["\\"]
+137        HEX_STRINGS = [("0x", ""), ("0X", "")]
+138
+139        KEYWORDS = {
+140            **tokens.Tokenizer.KEYWORDS,
+141            "BEGIN": TokenType.COMMAND,
+142            "BEGIN TRANSACTION": TokenType.BEGIN,
+143            "CURRENT_DATETIME": TokenType.CURRENT_DATETIME,
+144            "CURRENT_TIME": TokenType.CURRENT_TIME,
+145            "DECLARE": TokenType.COMMAND,
+146            "GEOGRAPHY": TokenType.GEOGRAPHY,
+147            "FLOAT64": TokenType.DOUBLE,
+148            "INT64": TokenType.BIGINT,
+149            "NOT DETERMINISTIC": TokenType.VOLATILE,
+150            "UNKNOWN": TokenType.NULL,
+151        }
+152        KEYWORDS.pop("DIV")
 
 
 
@@ -675,8 +663,7 @@
                                 Inherited Members
                                 
                                     sqlglot.tokens.Tokenizer
-                                Tokenizer
-                reset
+                                reset
                 tokenize
 
             
@@ -694,65 +681,65 @@
 
     
     
-            153    class Parser(parser.Parser):
-154        FUNCTIONS = {
-155            **parser.Parser.FUNCTIONS,  # type: ignore
-156            "DATE_TRUNC": lambda args: exp.DateTrunc(
-157                unit=exp.Literal.string(seq_get(args, 1).name),  # type: ignore
-158                this=seq_get(args, 0),
-159            ),
-160            "DATE_ADD": _date_add(exp.DateAdd),
-161            "DATETIME_ADD": _date_add(exp.DatetimeAdd),
-162            "DIV": lambda args: exp.IntDiv(this=seq_get(args, 0), expression=seq_get(args, 1)),
-163            "REGEXP_CONTAINS": exp.RegexpLike.from_arg_list,
-164            "REGEXP_EXTRACT": lambda args: exp.RegexpExtract(
-165                this=seq_get(args, 0),
-166                expression=seq_get(args, 1),
-167                position=seq_get(args, 2),
-168                occurrence=seq_get(args, 3),
-169                group=exp.Literal.number(1)
-170                if re.compile(str(seq_get(args, 1))).groups == 1
-171                else None,
-172            ),
-173            "TIME_ADD": _date_add(exp.TimeAdd),
-174            "TIMESTAMP_ADD": _date_add(exp.TimestampAdd),
-175            "DATE_SUB": _date_add(exp.DateSub),
-176            "DATETIME_SUB": _date_add(exp.DatetimeSub),
-177            "TIME_SUB": _date_add(exp.TimeSub),
-178            "TIMESTAMP_SUB": _date_add(exp.TimestampSub),
-179            "PARSE_TIMESTAMP": lambda args: exp.StrToTime(
-180                this=seq_get(args, 1), format=seq_get(args, 0)
-181            ),
-182        }
-183
-184        FUNCTION_PARSERS = {
-185            **parser.Parser.FUNCTION_PARSERS,  # type: ignore
-186            "ARRAY": lambda self: self.expression(exp.Array, expressions=[self._parse_statement()]),
-187        }
-188        FUNCTION_PARSERS.pop("TRIM")
-189
-190        NO_PAREN_FUNCTIONS = {
-191            **parser.Parser.NO_PAREN_FUNCTIONS,  # type: ignore
-192            TokenType.CURRENT_DATETIME: exp.CurrentDatetime,
-193            TokenType.CURRENT_TIME: exp.CurrentTime,
-194        }
-195
-196        NESTED_TYPE_TOKENS = {
-197            *parser.Parser.NESTED_TYPE_TOKENS,  # type: ignore
-198            TokenType.TABLE,
-199        }
-200
-201        ID_VAR_TOKENS = {
-202            *parser.Parser.ID_VAR_TOKENS,  # type: ignore
-203            TokenType.VALUES,
-204        }
-205
-206        PROPERTY_PARSERS = {
-207            **parser.Parser.PROPERTY_PARSERS,  # type: ignore
-208            "NOT DETERMINISTIC": lambda self: self.expression(
-209                exp.VolatilityProperty, this=exp.Literal.string("VOLATILE")
-210            ),
-211        }
+            154    class Parser(parser.Parser):
+155        FUNCTIONS = {
+156            **parser.Parser.FUNCTIONS,  # type: ignore
+157            "DATE_TRUNC": lambda args: exp.DateTrunc(
+158                unit=exp.Literal.string(seq_get(args, 1).name),  # type: ignore
+159                this=seq_get(args, 0),
+160            ),
+161            "DATE_ADD": _date_add(exp.DateAdd),
+162            "DATETIME_ADD": _date_add(exp.DatetimeAdd),
+163            "DIV": lambda args: exp.IntDiv(this=seq_get(args, 0), expression=seq_get(args, 1)),
+164            "REGEXP_CONTAINS": exp.RegexpLike.from_arg_list,
+165            "REGEXP_EXTRACT": lambda args: exp.RegexpExtract(
+166                this=seq_get(args, 0),
+167                expression=seq_get(args, 1),
+168                position=seq_get(args, 2),
+169                occurrence=seq_get(args, 3),
+170                group=exp.Literal.number(1)
+171                if re.compile(str(seq_get(args, 1))).groups == 1
+172                else None,
+173            ),
+174            "TIME_ADD": _date_add(exp.TimeAdd),
+175            "TIMESTAMP_ADD": _date_add(exp.TimestampAdd),
+176            "DATE_SUB": _date_add(exp.DateSub),
+177            "DATETIME_SUB": _date_add(exp.DatetimeSub),
+178            "TIME_SUB": _date_add(exp.TimeSub),
+179            "TIMESTAMP_SUB": _date_add(exp.TimestampSub),
+180            "PARSE_TIMESTAMP": lambda args: exp.StrToTime(
+181                this=seq_get(args, 1), format=seq_get(args, 0)
+182            ),
+183        }
+184
+185        FUNCTION_PARSERS = {
+186            **parser.Parser.FUNCTION_PARSERS,  # type: ignore
+187            "ARRAY": lambda self: self.expression(exp.Array, expressions=[self._parse_statement()]),
+188        }
+189        FUNCTION_PARSERS.pop("TRIM")
+190
+191        NO_PAREN_FUNCTIONS = {
+192            **parser.Parser.NO_PAREN_FUNCTIONS,  # type: ignore
+193            TokenType.CURRENT_DATETIME: exp.CurrentDatetime,
+194            TokenType.CURRENT_TIME: exp.CurrentTime,
+195        }
+196
+197        NESTED_TYPE_TOKENS = {
+198            *parser.Parser.NESTED_TYPE_TOKENS,  # type: ignore
+199            TokenType.TABLE,
+200        }
+201
+202        ID_VAR_TOKENS = {
+203            *parser.Parser.ID_VAR_TOKENS,  # type: ignore
+204            TokenType.VALUES,
+205        }
+206
+207        PROPERTY_PARSERS = {
+208            **parser.Parser.PROPERTY_PARSERS,  # type: ignore
+209            "NOT DETERMINISTIC": lambda self: self.expression(
+210                exp.VolatilityProperty, this=exp.Literal.string("VOLATILE")
+211            ),
+212        }
 
 
 
@@ -809,91 +796,92 @@ Default: "nulls_are_small"
 
     
     
-            213    class Generator(generator.Generator):
-214        TRANSFORMS = {
-215            **generator.Generator.TRANSFORMS,  # type: ignore
-216            **transforms.REMOVE_PRECISION_PARAMETERIZED_TYPES,  # type: ignore
-217            exp.ArraySize: rename_func("ARRAY_LENGTH"),
-218            exp.DateAdd: _date_add_sql("DATE", "ADD"),
-219            exp.DateSub: _date_add_sql("DATE", "SUB"),
-220            exp.DatetimeAdd: _date_add_sql("DATETIME", "ADD"),
-221            exp.DatetimeSub: _date_add_sql("DATETIME", "SUB"),
-222            exp.DateDiff: lambda self, e: f"DATE_DIFF({self.sql(e, 'this')}, {self.sql(e, 'expression')}, {self.sql(e.args.get('unit', 'DAY'))})",
-223            exp.DateStrToDate: datestrtodate_sql,
-224            exp.DateTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, e.text("unit")),
-225            exp.GroupConcat: rename_func("STRING_AGG"),
-226            exp.ILike: no_ilike_sql,
-227            exp.IntDiv: rename_func("DIV"),
-228            exp.Select: transforms.preprocess(
-229                [_unqualify_unnest], transforms.delegate("select_sql")
-230            ),
-231            exp.StrToTime: lambda self, e: f"PARSE_TIMESTAMP({self.format_time(e)}, {self.sql(e, 'this')})",
-232            exp.TimeAdd: _date_add_sql("TIME", "ADD"),
-233            exp.TimeSub: _date_add_sql("TIME", "SUB"),
-234            exp.TimestampAdd: _date_add_sql("TIMESTAMP", "ADD"),
-235            exp.TimestampSub: _date_add_sql("TIMESTAMP", "SUB"),
-236            exp.TimeStrToTime: timestrtotime_sql,
-237            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
-238            exp.VariancePop: rename_func("VAR_POP"),
-239            exp.Values: _derived_table_values_to_unnest,
-240            exp.ReturnsProperty: _returnsproperty_sql,
-241            exp.Create: _create_sql,
-242            exp.Trim: lambda self, e: self.func(f"TRIM", e.this, e.expression),
-243            exp.VolatilityProperty: lambda self, e: f"DETERMINISTIC"
-244            if e.name == "IMMUTABLE"
-245            else "NOT DETERMINISTIC",
-246            exp.RegexpLike: rename_func("REGEXP_CONTAINS"),
-247        }
-248
-249        TYPE_MAPPING = {
-250            **generator.Generator.TYPE_MAPPING,  # type: ignore
-251            exp.DataType.Type.TINYINT: "INT64",
-252            exp.DataType.Type.SMALLINT: "INT64",
-253            exp.DataType.Type.INT: "INT64",
-254            exp.DataType.Type.BIGINT: "INT64",
-255            exp.DataType.Type.DECIMAL: "NUMERIC",
-256            exp.DataType.Type.FLOAT: "FLOAT64",
-257            exp.DataType.Type.DOUBLE: "FLOAT64",
-258            exp.DataType.Type.BOOLEAN: "BOOL",
-259            exp.DataType.Type.TEXT: "STRING",
-260            exp.DataType.Type.VARCHAR: "STRING",
-261            exp.DataType.Type.NVARCHAR: "STRING",
-262        }
-263        PROPERTIES_LOCATION = {
-264            **generator.Generator.PROPERTIES_LOCATION,  # type: ignore
-265            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
-266        }
-267
-268        EXPLICIT_UNION = True
+            214    class Generator(generator.Generator):
+215        TRANSFORMS = {
+216            **generator.Generator.TRANSFORMS,  # type: ignore
+217            **transforms.REMOVE_PRECISION_PARAMETERIZED_TYPES,  # type: ignore
+218            exp.ArraySize: rename_func("ARRAY_LENGTH"),
+219            exp.DateAdd: _date_add_sql("DATE", "ADD"),
+220            exp.DateSub: _date_add_sql("DATE", "SUB"),
+221            exp.DatetimeAdd: _date_add_sql("DATETIME", "ADD"),
+222            exp.DatetimeSub: _date_add_sql("DATETIME", "SUB"),
+223            exp.DateDiff: lambda self, e: f"DATE_DIFF({self.sql(e, 'this')}, {self.sql(e, 'expression')}, {self.sql(e.args.get('unit', 'DAY'))})",
+224            exp.DateStrToDate: datestrtodate_sql,
+225            exp.DateTrunc: lambda self, e: self.func("DATE_TRUNC", e.this, e.text("unit")),
+226            exp.GroupConcat: rename_func("STRING_AGG"),
+227            exp.ILike: no_ilike_sql,
+228            exp.IntDiv: rename_func("DIV"),
+229            exp.Select: transforms.preprocess(
+230                [_unqualify_unnest], transforms.delegate("select_sql")
+231            ),
+232            exp.StrToTime: lambda self, e: f"PARSE_TIMESTAMP({self.format_time(e)}, {self.sql(e, 'this')})",
+233            exp.TimeAdd: _date_add_sql("TIME", "ADD"),
+234            exp.TimeSub: _date_add_sql("TIME", "SUB"),
+235            exp.TimestampAdd: _date_add_sql("TIMESTAMP", "ADD"),
+236            exp.TimestampSub: _date_add_sql("TIMESTAMP", "SUB"),
+237            exp.TimeStrToTime: timestrtotime_sql,
+238            exp.TsOrDsToDate: ts_or_ds_to_date_sql("bigquery"),
+239            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
+240            exp.VariancePop: rename_func("VAR_POP"),
+241            exp.Values: _derived_table_values_to_unnest,
+242            exp.ReturnsProperty: _returnsproperty_sql,
+243            exp.Create: _create_sql,
+244            exp.Trim: lambda self, e: self.func(f"TRIM", e.this, e.expression),
+245            exp.VolatilityProperty: lambda self, e: f"DETERMINISTIC"
+246            if e.name == "IMMUTABLE"
+247            else "NOT DETERMINISTIC",
+248            exp.RegexpLike: rename_func("REGEXP_CONTAINS"),
+249        }
+250
+251        TYPE_MAPPING = {
+252            **generator.Generator.TYPE_MAPPING,  # type: ignore
+253            exp.DataType.Type.TINYINT: "INT64",
+254            exp.DataType.Type.SMALLINT: "INT64",
+255            exp.DataType.Type.INT: "INT64",
+256            exp.DataType.Type.BIGINT: "INT64",
+257            exp.DataType.Type.DECIMAL: "NUMERIC",
+258            exp.DataType.Type.FLOAT: "FLOAT64",
+259            exp.DataType.Type.DOUBLE: "FLOAT64",
+260            exp.DataType.Type.BOOLEAN: "BOOL",
+261            exp.DataType.Type.TEXT: "STRING",
+262            exp.DataType.Type.VARCHAR: "STRING",
+263            exp.DataType.Type.NVARCHAR: "STRING",
+264        }
+265        PROPERTIES_LOCATION = {
+266            **generator.Generator.PROPERTIES_LOCATION,  # type: ignore
+267            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
+268        }
 269
-270        def array_sql(self, expression: exp.Array) -> str:
-271            first_arg = seq_get(expression.expressions, 0)
-272            if isinstance(first_arg, exp.Subqueryable):
-273                return f"ARRAY{self.wrap(self.sql(first_arg))}"
-274
-275            return inline_array_sql(self, expression)
+270        EXPLICIT_UNION = True
+271
+272        def array_sql(self, expression: exp.Array) -> str:
+273            first_arg = seq_get(expression.expressions, 0)
+274            if isinstance(first_arg, exp.Subqueryable):
+275                return f"ARRAY{self.wrap(self.sql(first_arg))}"
 276
-277        def transaction_sql(self, *_) -> str:
-278            return "BEGIN TRANSACTION"
-279
-280        def commit_sql(self, *_) -> str:
-281            return "COMMIT TRANSACTION"
-282
-283        def rollback_sql(self, *_) -> str:
-284            return "ROLLBACK TRANSACTION"
-285
-286        def in_unnest_op(self, expression: exp.Unnest) -> str:
-287            return self.sql(expression)
-288
-289        def except_op(self, expression: exp.Except) -> str:
-290            if not expression.args.get("distinct", False):
-291                self.unsupported("EXCEPT without DISTINCT is not supported in BigQuery")
-292            return f"EXCEPT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
-293
-294        def intersect_op(self, expression: exp.Intersect) -> str:
-295            if not expression.args.get("distinct", False):
-296                self.unsupported("INTERSECT without DISTINCT is not supported in BigQuery")
-297            return f"INTERSECT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
+277            return inline_array_sql(self, expression)
+278
+279        def transaction_sql(self, *_) -> str:
+280            return "BEGIN TRANSACTION"
+281
+282        def commit_sql(self, *_) -> str:
+283            return "COMMIT TRANSACTION"
+284
+285        def rollback_sql(self, *_) -> str:
+286            return "ROLLBACK TRANSACTION"
+287
+288        def in_unnest_op(self, expression: exp.Unnest) -> str:
+289            return self.sql(expression)
+290
+291        def except_op(self, expression: exp.Except) -> str:
+292            if not expression.args.get("distinct", False):
+293                self.unsupported("EXCEPT without DISTINCT is not supported in BigQuery")
+294            return f"EXCEPT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
+295
+296        def intersect_op(self, expression: exp.Intersect) -> str:
+297            if not expression.args.get("distinct", False):
+298                self.unsupported("INTERSECT without DISTINCT is not supported in BigQuery")
+299            return f"INTERSECT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
 
 
 
@@ -953,12 +941,12 @@ Default: True
 
     
     
-            270        def array_sql(self, expression: exp.Array) -> str:
-271            first_arg = seq_get(expression.expressions, 0)
-272            if isinstance(first_arg, exp.Subqueryable):
-273                return f"ARRAY{self.wrap(self.sql(first_arg))}"
-274
-275            return inline_array_sql(self, expression)
+            272        def array_sql(self, expression: exp.Array) -> str:
+273            first_arg = seq_get(expression.expressions, 0)
+274            if isinstance(first_arg, exp.Subqueryable):
+275                return f"ARRAY{self.wrap(self.sql(first_arg))}"
+276
+277            return inline_array_sql(self, expression)
 
 
 
@@ -976,8 +964,8 @@ Default: True
 
     
     
-            277        def transaction_sql(self, *_) -> str:
-278            return "BEGIN TRANSACTION"
+            279        def transaction_sql(self, *_) -> str:
+280            return "BEGIN TRANSACTION"
 
 
 
@@ -995,8 +983,8 @@ Default: True
 
     
     
-            280        def commit_sql(self, *_) -> str:
-281            return "COMMIT TRANSACTION"
+            282        def commit_sql(self, *_) -> str:
+283            return "COMMIT TRANSACTION"
 
 
 
@@ -1014,8 +1002,8 @@ Default: True
 
     
     
-            283        def rollback_sql(self, *_) -> str:
-284            return "ROLLBACK TRANSACTION"
+            285        def rollback_sql(self, *_) -> str:
+286            return "ROLLBACK TRANSACTION"
 
 
 
@@ -1033,8 +1021,8 @@ Default: True
 
     
     
-            286        def in_unnest_op(self, expression: exp.Unnest) -> str:
-287            return self.sql(expression)
+            288        def in_unnest_op(self, expression: exp.Unnest) -> str:
+289            return self.sql(expression)
 
 
 
@@ -1052,10 +1040,10 @@ Default: True
 
     
     
-            289        def except_op(self, expression: exp.Except) -> str:
-290            if not expression.args.get("distinct", False):
-291                self.unsupported("EXCEPT without DISTINCT is not supported in BigQuery")
-292            return f"EXCEPT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
+            291        def except_op(self, expression: exp.Except) -> str:
+292            if not expression.args.get("distinct", False):
+293                self.unsupported("EXCEPT without DISTINCT is not supported in BigQuery")
+294            return f"EXCEPT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
 
 
 
@@ -1073,10 +1061,10 @@ Default: True
 
     
     
-            294        def intersect_op(self, expression: exp.Intersect) -> str:
-295            if not expression.args.get("distinct", False):
-296                self.unsupported("INTERSECT without DISTINCT is not supported in BigQuery")
-297            return f"INTERSECT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
+            296        def intersect_op(self, expression: exp.Intersect) -> str:
+297            if not expression.args.get("distinct", False):
+298                self.unsupported("INTERSECT without DISTINCT is not supported in BigQuery")
+299            return f"INTERSECT{' DISTINCT' if expression.args.get('distinct') else ' ALL'}"
 
 
 
@@ -1106,6 +1094,7 @@ Default: True
                 columndef_sql
                 columnconstraint_sql
                 autoincrementcolumnconstraint_sql
+                compresscolumnconstraint_sql
                 generatedasidentitycolumnconstraint_sql
                 notnullcolumnconstraint_sql
                 primarykeycolumnconstraint_sql
@@ -1147,6 +1136,7 @@ Default: True
                 blockcompressionproperty_sql
                 isolatedloadingproperty_sql
                 lockingproperty_sql
+                withdataproperty_sql
                 insert_sql
                 intersect_sql
                 introducer_sql
@@ -1412,7 +1402,7 @@ Default: True
                         if (doc.annotation)
                             heading += `${doc.annotation}`;
                         if (doc.default_value)
-                            heading += `${doc.default_value}`;
+                            heading += ` = ${doc.default_value}`;
                         break;
                     default:
                         heading = `${doc.fullname}`;
-- 
cgit v1.2.3