sqlglot.dialects.postgres

  1from __future__ import annotations
  2
  3import typing as t
  4
  5from sqlglot import exp, generator, parser, tokens, transforms
  6from sqlglot.dialects.dialect import (
  7    DATE_ADD_OR_SUB,
  8    Dialect,
  9    JSON_EXTRACT_TYPE,
 10    any_value_to_max_sql,
 11    bool_xor_sql,
 12    datestrtodate_sql,
 13    build_formatted_time,
 14    filter_array_using_unnest,
 15    json_extract_segments,
 16    json_path_key_only_name,
 17    max_or_greatest,
 18    merge_without_target_sql,
 19    min_or_least,
 20    no_last_day_sql,
 21    no_map_from_entries_sql,
 22    no_paren_current_date_sql,
 23    no_pivot_sql,
 24    no_trycast_sql,
 25    build_json_extract_path,
 26    build_timestamp_trunc,
 27    rename_func,
 28    str_position_sql,
 29    struct_extract_sql,
 30    timestamptrunc_sql,
 31    timestrtotime_sql,
 32    trim_sql,
 33    ts_or_ds_add_cast,
 34)
 35from sqlglot.helper import is_int, seq_get
 36from sqlglot.parser import binary_range_parser
 37from sqlglot.tokens import TokenType
 38
 39DATE_DIFF_FACTOR = {
 40    "MICROSECOND": " * 1000000",
 41    "MILLISECOND": " * 1000",
 42    "SECOND": "",
 43    "MINUTE": " / 60",
 44    "HOUR": " / 3600",
 45    "DAY": " / 86400",
 46}
 47
 48
 49def _date_add_sql(kind: str) -> t.Callable[[Postgres.Generator, DATE_ADD_OR_SUB], str]:
 50    def func(self: Postgres.Generator, expression: DATE_ADD_OR_SUB) -> str:
 51        if isinstance(expression, exp.TsOrDsAdd):
 52            expression = ts_or_ds_add_cast(expression)
 53
 54        this = self.sql(expression, "this")
 55        unit = expression.args.get("unit")
 56
 57        expression = self._simplify_unless_literal(expression.expression)
 58        if not isinstance(expression, exp.Literal):
 59            self.unsupported("Cannot add non literal")
 60
 61        expression.args["is_string"] = True
 62        return f"{this} {kind} {self.sql(exp.Interval(this=expression, unit=unit))}"
 63
 64    return func
 65
 66
 67def _date_diff_sql(self: Postgres.Generator, expression: exp.DateDiff) -> str:
 68    unit = expression.text("unit").upper()
 69    factor = DATE_DIFF_FACTOR.get(unit)
 70
 71    end = f"CAST({self.sql(expression, 'this')} AS TIMESTAMP)"
 72    start = f"CAST({self.sql(expression, 'expression')} AS TIMESTAMP)"
 73
 74    if factor is not None:
 75        return f"CAST(EXTRACT(epoch FROM {end} - {start}){factor} AS BIGINT)"
 76
 77    age = f"AGE({end}, {start})"
 78
 79    if unit == "WEEK":
 80        unit = f"EXTRACT(days FROM ({end} - {start})) / 7"
 81    elif unit == "MONTH":
 82        unit = f"EXTRACT(year FROM {age}) * 12 + EXTRACT(month FROM {age})"
 83    elif unit == "QUARTER":
 84        unit = f"EXTRACT(year FROM {age}) * 4 + EXTRACT(month FROM {age}) / 3"
 85    elif unit == "YEAR":
 86        unit = f"EXTRACT(year FROM {age})"
 87    else:
 88        unit = age
 89
 90    return f"CAST({unit} AS BIGINT)"
 91
 92
 93def _substring_sql(self: Postgres.Generator, expression: exp.Substring) -> str:
 94    this = self.sql(expression, "this")
 95    start = self.sql(expression, "start")
 96    length = self.sql(expression, "length")
 97
 98    from_part = f" FROM {start}" if start else ""
 99    for_part = f" FOR {length}" if length else ""
100
101    return f"SUBSTRING({this}{from_part}{for_part})"
102
103
104def _string_agg_sql(self: Postgres.Generator, expression: exp.GroupConcat) -> str:
105    separator = expression.args.get("separator") or exp.Literal.string(",")
106
107    order = ""
108    this = expression.this
109    if isinstance(this, exp.Order):
110        if this.this:
111            this = this.this.pop()
112        order = self.sql(expression.this)  # Order has a leading space
113
114    return f"STRING_AGG({self.format_args(this, separator)}{order})"
115
116
117def _datatype_sql(self: Postgres.Generator, expression: exp.DataType) -> str:
118    if expression.is_type("array"):
119        return f"{self.expressions(expression, flat=True)}[]" if expression.expressions else "ARRAY"
120    return self.datatype_sql(expression)
121
122
123def _auto_increment_to_serial(expression: exp.Expression) -> exp.Expression:
124    auto = expression.find(exp.AutoIncrementColumnConstraint)
125
126    if auto:
127        expression.args["constraints"].remove(auto.parent)
128        kind = expression.args["kind"]
129
130        if kind.this == exp.DataType.Type.INT:
131            kind.replace(exp.DataType(this=exp.DataType.Type.SERIAL))
132        elif kind.this == exp.DataType.Type.SMALLINT:
133            kind.replace(exp.DataType(this=exp.DataType.Type.SMALLSERIAL))
134        elif kind.this == exp.DataType.Type.BIGINT:
135            kind.replace(exp.DataType(this=exp.DataType.Type.BIGSERIAL))
136
137    return expression
138
139
140def _serial_to_generated(expression: exp.Expression) -> exp.Expression:
141    if not isinstance(expression, exp.ColumnDef):
142        return expression
143    kind = expression.kind
144    if not kind:
145        return expression
146
147    if kind.this == exp.DataType.Type.SERIAL:
148        data_type = exp.DataType(this=exp.DataType.Type.INT)
149    elif kind.this == exp.DataType.Type.SMALLSERIAL:
150        data_type = exp.DataType(this=exp.DataType.Type.SMALLINT)
151    elif kind.this == exp.DataType.Type.BIGSERIAL:
152        data_type = exp.DataType(this=exp.DataType.Type.BIGINT)
153    else:
154        data_type = None
155
156    if data_type:
157        expression.args["kind"].replace(data_type)
158        constraints = expression.args["constraints"]
159        generated = exp.ColumnConstraint(kind=exp.GeneratedAsIdentityColumnConstraint(this=False))
160        notnull = exp.ColumnConstraint(kind=exp.NotNullColumnConstraint())
161
162        if notnull not in constraints:
163            constraints.insert(0, notnull)
164        if generated not in constraints:
165            constraints.insert(0, generated)
166
167    return expression
168
169
170def _build_generate_series(args: t.List) -> exp.GenerateSeries:
171    # The goal is to convert step values like '1 day' or INTERVAL '1 day' into INTERVAL '1' day
172    step = seq_get(args, 2)
173
174    if step is None:
175        # Postgres allows calls with just two arguments -- the "step" argument defaults to 1
176        return exp.GenerateSeries.from_arg_list(args)
177
178    if step.is_string:
179        args[2] = exp.to_interval(step.this)
180    elif isinstance(step, exp.Interval) and not step.args.get("unit"):
181        args[2] = exp.to_interval(step.this.this)
182
183    return exp.GenerateSeries.from_arg_list(args)
184
185
186def _build_to_timestamp(args: t.List) -> exp.UnixToTime | exp.StrToTime:
187    # TO_TIMESTAMP accepts either a single double argument or (text, text)
188    if len(args) == 1:
189        # https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-TABLE
190        return exp.UnixToTime.from_arg_list(args)
191
192    # https://www.postgresql.org/docs/current/functions-formatting.html
193    return build_formatted_time(exp.StrToTime, "postgres")(args)
194
195
196def _json_extract_sql(
197    name: str, op: str
198) -> t.Callable[[Postgres.Generator, JSON_EXTRACT_TYPE], str]:
199    def _generate(self: Postgres.Generator, expression: JSON_EXTRACT_TYPE) -> str:
200        if expression.args.get("only_json_types"):
201            return json_extract_segments(name, quoted_index=False, op=op)(self, expression)
202        return json_extract_segments(name)(self, expression)
203
204    return _generate
205
206
207def _build_regexp_replace(args: t.List) -> exp.RegexpReplace:
208    # The signature of REGEXP_REPLACE is:
209    # regexp_replace(source, pattern, replacement [, start [, N ]] [, flags ])
210    #
211    # Any one of `start`, `N` and `flags` can be column references, meaning that
212    # unless we can statically see that the last argument is a non-integer string
213    # (eg. not '0'), then it's not possible to construct the correct AST
214    if len(args) > 3:
215        last = args[-1]
216        if not is_int(last.name):
217            if not last.type or last.is_type(exp.DataType.Type.UNKNOWN, exp.DataType.Type.NULL):
218                from sqlglot.optimizer.annotate_types import annotate_types
219
220                last = annotate_types(last)
221
222            if last.is_type(*exp.DataType.TEXT_TYPES):
223                regexp_replace = exp.RegexpReplace.from_arg_list(args[:-1])
224                regexp_replace.set("modifiers", last)
225                return regexp_replace
226
227    return exp.RegexpReplace.from_arg_list(args)
228
229
230class Postgres(Dialect):
231    INDEX_OFFSET = 1
232    TYPED_DIVISION = True
233    CONCAT_COALESCE = True
234    NULL_ORDERING = "nulls_are_large"
235    TIME_FORMAT = "'YYYY-MM-DD HH24:MI:SS'"
236
237    TIME_MAPPING = {
238        "AM": "%p",
239        "PM": "%p",
240        "D": "%u",  # 1-based day of week
241        "DD": "%d",  # day of month
242        "DDD": "%j",  # zero padded day of year
243        "FMDD": "%-d",  # - is no leading zero for Python; same for FM in postgres
244        "FMDDD": "%-j",  # day of year
245        "FMHH12": "%-I",  # 9
246        "FMHH24": "%-H",  # 9
247        "FMMI": "%-M",  # Minute
248        "FMMM": "%-m",  # 1
249        "FMSS": "%-S",  # Second
250        "HH12": "%I",  # 09
251        "HH24": "%H",  # 09
252        "MI": "%M",  # zero padded minute
253        "MM": "%m",  # 01
254        "OF": "%z",  # utc offset
255        "SS": "%S",  # zero padded second
256        "TMDay": "%A",  # TM is locale dependent
257        "TMDy": "%a",
258        "TMMon": "%b",  # Sep
259        "TMMonth": "%B",  # September
260        "TZ": "%Z",  # uppercase timezone name
261        "US": "%f",  # zero padded microsecond
262        "WW": "%U",  # 1-based week of year
263        "YY": "%y",  # 15
264        "YYYY": "%Y",  # 2015
265    }
266
267    class Tokenizer(tokens.Tokenizer):
268        BIT_STRINGS = [("b'", "'"), ("B'", "'")]
269        HEX_STRINGS = [("x'", "'"), ("X'", "'")]
270        BYTE_STRINGS = [("e'", "'"), ("E'", "'")]
271        HEREDOC_STRINGS = ["$"]
272
273        HEREDOC_TAG_IS_IDENTIFIER = True
274        HEREDOC_STRING_ALTERNATIVE = TokenType.PARAMETER
275
276        KEYWORDS = {
277            **tokens.Tokenizer.KEYWORDS,
278            "~~": TokenType.LIKE,
279            "~~*": TokenType.ILIKE,
280            "~*": TokenType.IRLIKE,
281            "~": TokenType.RLIKE,
282            "@@": TokenType.DAT,
283            "@>": TokenType.AT_GT,
284            "<@": TokenType.LT_AT,
285            "|/": TokenType.PIPE_SLASH,
286            "||/": TokenType.DPIPE_SLASH,
287            "BEGIN": TokenType.COMMAND,
288            "BEGIN TRANSACTION": TokenType.BEGIN,
289            "BIGSERIAL": TokenType.BIGSERIAL,
290            "CHARACTER VARYING": TokenType.VARCHAR,
291            "CONSTRAINT TRIGGER": TokenType.COMMAND,
292            "CSTRING": TokenType.PSEUDO_TYPE,
293            "DECLARE": TokenType.COMMAND,
294            "DO": TokenType.COMMAND,
295            "EXEC": TokenType.COMMAND,
296            "HSTORE": TokenType.HSTORE,
297            "INT8": TokenType.BIGINT,
298            "JSONB": TokenType.JSONB,
299            "MONEY": TokenType.MONEY,
300            "NAME": TokenType.NAME,
301            "OID": TokenType.OBJECT_IDENTIFIER,
302            "ONLY": TokenType.ONLY,
303            "OPERATOR": TokenType.OPERATOR,
304            "REFRESH": TokenType.COMMAND,
305            "REINDEX": TokenType.COMMAND,
306            "RESET": TokenType.COMMAND,
307            "REVOKE": TokenType.COMMAND,
308            "SERIAL": TokenType.SERIAL,
309            "SMALLSERIAL": TokenType.SMALLSERIAL,
310            "TEMP": TokenType.TEMPORARY,
311            "REGCLASS": TokenType.OBJECT_IDENTIFIER,
312            "REGCOLLATION": TokenType.OBJECT_IDENTIFIER,
313            "REGCONFIG": TokenType.OBJECT_IDENTIFIER,
314            "REGDICTIONARY": TokenType.OBJECT_IDENTIFIER,
315            "REGNAMESPACE": TokenType.OBJECT_IDENTIFIER,
316            "REGOPER": TokenType.OBJECT_IDENTIFIER,
317            "REGOPERATOR": TokenType.OBJECT_IDENTIFIER,
318            "REGPROC": TokenType.OBJECT_IDENTIFIER,
319            "REGPROCEDURE": TokenType.OBJECT_IDENTIFIER,
320            "REGROLE": TokenType.OBJECT_IDENTIFIER,
321            "REGTYPE": TokenType.OBJECT_IDENTIFIER,
322        }
323
324        SINGLE_TOKENS = {
325            **tokens.Tokenizer.SINGLE_TOKENS,
326            "$": TokenType.HEREDOC_STRING,
327        }
328
329        VAR_SINGLE_TOKENS = {"$"}
330
331    class Parser(parser.Parser):
332        PROPERTY_PARSERS = {
333            **parser.Parser.PROPERTY_PARSERS,
334            "SET": lambda self: self.expression(exp.SetConfigProperty, this=self._parse_set()),
335        }
336        PROPERTY_PARSERS.pop("INPUT")
337
338        FUNCTIONS = {
339            **parser.Parser.FUNCTIONS,
340            "DATE_TRUNC": build_timestamp_trunc,
341            "GENERATE_SERIES": _build_generate_series,
342            "JSON_EXTRACT_PATH": build_json_extract_path(exp.JSONExtract),
343            "JSON_EXTRACT_PATH_TEXT": build_json_extract_path(exp.JSONExtractScalar),
344            "MAKE_TIME": exp.TimeFromParts.from_arg_list,
345            "MAKE_TIMESTAMP": exp.TimestampFromParts.from_arg_list,
346            "NOW": exp.CurrentTimestamp.from_arg_list,
347            "REGEXP_REPLACE": _build_regexp_replace,
348            "TO_CHAR": build_formatted_time(exp.TimeToStr, "postgres"),
349            "TO_TIMESTAMP": _build_to_timestamp,
350            "UNNEST": exp.Explode.from_arg_list,
351        }
352
353        FUNCTION_PARSERS = {
354            **parser.Parser.FUNCTION_PARSERS,
355            "DATE_PART": lambda self: self._parse_date_part(),
356        }
357
358        BITWISE = {
359            **parser.Parser.BITWISE,
360            TokenType.HASH: exp.BitwiseXor,
361        }
362
363        EXPONENT = {
364            TokenType.CARET: exp.Pow,
365        }
366
367        RANGE_PARSERS = {
368            **parser.Parser.RANGE_PARSERS,
369            TokenType.AT_GT: binary_range_parser(exp.ArrayContains),
370            TokenType.DAMP: binary_range_parser(exp.ArrayOverlaps),
371            TokenType.DAT: lambda self, this: self.expression(
372                exp.MatchAgainst, this=self._parse_bitwise(), expressions=[this]
373            ),
374            TokenType.LT_AT: binary_range_parser(exp.ArrayContained),
375            TokenType.OPERATOR: lambda self, this: self._parse_operator(this),
376        }
377
378        STATEMENT_PARSERS = {
379            **parser.Parser.STATEMENT_PARSERS,
380            TokenType.END: lambda self: self._parse_commit_or_rollback(),
381        }
382
383        JSON_ARROWS_REQUIRE_JSON_TYPE = True
384
385        COLUMN_OPERATORS = {
386            **parser.Parser.COLUMN_OPERATORS,
387            TokenType.ARROW: lambda self, this, path: build_json_extract_path(
388                exp.JSONExtract, arrow_req_json_type=self.JSON_ARROWS_REQUIRE_JSON_TYPE
389            )([this, path]),
390            TokenType.DARROW: lambda self, this, path: build_json_extract_path(
391                exp.JSONExtractScalar, arrow_req_json_type=self.JSON_ARROWS_REQUIRE_JSON_TYPE
392            )([this, path]),
393        }
394
395        def _parse_operator(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
396            while True:
397                if not self._match(TokenType.L_PAREN):
398                    break
399
400                op = ""
401                while self._curr and not self._match(TokenType.R_PAREN):
402                    op += self._curr.text
403                    self._advance()
404
405                this = self.expression(
406                    exp.Operator,
407                    comments=self._prev_comments,
408                    this=this,
409                    operator=op,
410                    expression=self._parse_bitwise(),
411                )
412
413                if not self._match(TokenType.OPERATOR):
414                    break
415
416            return this
417
418        def _parse_date_part(self) -> exp.Expression:
419            part = self._parse_type()
420            self._match(TokenType.COMMA)
421            value = self._parse_bitwise()
422
423            if part and part.is_string:
424                part = exp.var(part.name)
425
426            return self.expression(exp.Extract, this=part, expression=value)
427
428    class Generator(generator.Generator):
429        SINGLE_STRING_INTERVAL = True
430        RENAME_TABLE_WITH_DB = False
431        LOCKING_READS_SUPPORTED = True
432        JOIN_HINTS = False
433        TABLE_HINTS = False
434        QUERY_HINTS = False
435        NVL2_SUPPORTED = False
436        PARAMETER_TOKEN = "$"
437        TABLESAMPLE_SIZE_IS_ROWS = False
438        TABLESAMPLE_SEED_KEYWORD = "REPEATABLE"
439        SUPPORTS_SELECT_INTO = True
440        JSON_TYPE_REQUIRED_FOR_EXTRACTION = True
441        SUPPORTS_UNLOGGED_TABLES = True
442        LIKE_PROPERTY_INSIDE_SCHEMA = True
443        MULTI_ARG_DISTINCT = False
444        CAN_IMPLEMENT_ARRAY_ANY = True
445        COPY_HAS_INTO_KEYWORD = False
446
447        SUPPORTED_JSON_PATH_PARTS = {
448            exp.JSONPathKey,
449            exp.JSONPathRoot,
450            exp.JSONPathSubscript,
451        }
452
453        TYPE_MAPPING = {
454            **generator.Generator.TYPE_MAPPING,
455            exp.DataType.Type.TINYINT: "SMALLINT",
456            exp.DataType.Type.FLOAT: "REAL",
457            exp.DataType.Type.DOUBLE: "DOUBLE PRECISION",
458            exp.DataType.Type.BINARY: "BYTEA",
459            exp.DataType.Type.VARBINARY: "BYTEA",
460            exp.DataType.Type.ROWVERSION: "BYTEA",
461            exp.DataType.Type.DATETIME: "TIMESTAMP",
462        }
463
464        TRANSFORMS = {
465            **generator.Generator.TRANSFORMS,
466            exp.AnyValue: any_value_to_max_sql,
467            exp.Array: lambda self, e: (
468                f"{self.normalize_func('ARRAY')}({self.sql(e.expressions[0])})"
469                if isinstance(seq_get(e.expressions, 0), exp.Select)
470                else f"{self.normalize_func('ARRAY')}[{self.expressions(e, flat=True)}]"
471            ),
472            exp.ArrayConcat: rename_func("ARRAY_CAT"),
473            exp.ArrayContained: lambda self, e: self.binary(e, "<@"),
474            exp.ArrayContains: lambda self, e: self.binary(e, "@>"),
475            exp.ArrayOverlaps: lambda self, e: self.binary(e, "&&"),
476            exp.ArrayFilter: filter_array_using_unnest,
477            exp.ArraySize: lambda self, e: self.func("ARRAY_LENGTH", e.this, e.expression or "1"),
478            exp.BitwiseXor: lambda self, e: self.binary(e, "#"),
479            exp.ColumnDef: transforms.preprocess([_auto_increment_to_serial, _serial_to_generated]),
480            exp.CurrentDate: no_paren_current_date_sql,
481            exp.CurrentTimestamp: lambda *_: "CURRENT_TIMESTAMP",
482            exp.CurrentUser: lambda *_: "CURRENT_USER",
483            exp.DateAdd: _date_add_sql("+"),
484            exp.DateDiff: _date_diff_sql,
485            exp.DateStrToDate: datestrtodate_sql,
486            exp.DataType: _datatype_sql,
487            exp.DateSub: _date_add_sql("-"),
488            exp.Explode: rename_func("UNNEST"),
489            exp.GroupConcat: _string_agg_sql,
490            exp.JSONExtract: _json_extract_sql("JSON_EXTRACT_PATH", "->"),
491            exp.JSONExtractScalar: _json_extract_sql("JSON_EXTRACT_PATH_TEXT", "->>"),
492            exp.JSONBExtract: lambda self, e: self.binary(e, "#>"),
493            exp.JSONBExtractScalar: lambda self, e: self.binary(e, "#>>"),
494            exp.JSONBContains: lambda self, e: self.binary(e, "?"),
495            exp.ParseJSON: lambda self, e: self.sql(exp.cast(e.this, exp.DataType.Type.JSON)),
496            exp.JSONPathKey: json_path_key_only_name,
497            exp.JSONPathRoot: lambda *_: "",
498            exp.JSONPathSubscript: lambda self, e: self.json_path_part(e.this),
499            exp.LastDay: no_last_day_sql,
500            exp.LogicalOr: rename_func("BOOL_OR"),
501            exp.LogicalAnd: rename_func("BOOL_AND"),
502            exp.Max: max_or_greatest,
503            exp.MapFromEntries: no_map_from_entries_sql,
504            exp.Min: min_or_least,
505            exp.Merge: merge_without_target_sql,
506            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
507            exp.PercentileCont: transforms.preprocess(
508                [transforms.add_within_group_for_percentiles]
509            ),
510            exp.PercentileDisc: transforms.preprocess(
511                [transforms.add_within_group_for_percentiles]
512            ),
513            exp.Pivot: no_pivot_sql,
514            exp.Pow: lambda self, e: self.binary(e, "^"),
515            exp.Rand: rename_func("RANDOM"),
516            exp.RegexpLike: lambda self, e: self.binary(e, "~"),
517            exp.RegexpILike: lambda self, e: self.binary(e, "~*"),
518            exp.Select: transforms.preprocess(
519                [
520                    transforms.eliminate_semi_and_anti_joins,
521                    transforms.eliminate_qualify,
522                ]
523            ),
524            exp.StrPosition: str_position_sql,
525            exp.StrToDate: lambda self, e: self.func("TO_DATE", e.this, self.format_time(e)),
526            exp.StrToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this, self.format_time(e)),
527            exp.StructExtract: struct_extract_sql,
528            exp.Substring: _substring_sql,
529            exp.TimeFromParts: rename_func("MAKE_TIME"),
530            exp.TimestampFromParts: rename_func("MAKE_TIMESTAMP"),
531            exp.TimestampTrunc: timestamptrunc_sql,
532            exp.TimeStrToTime: timestrtotime_sql,
533            exp.TimeToStr: lambda self, e: self.func("TO_CHAR", e.this, self.format_time(e)),
534            exp.ToChar: lambda self, e: self.function_fallback_sql(e),
535            exp.Trim: trim_sql,
536            exp.TryCast: no_trycast_sql,
537            exp.TsOrDsAdd: _date_add_sql("+"),
538            exp.TsOrDsDiff: _date_diff_sql,
539            exp.UnixToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this),
540            exp.TimeToUnix: lambda self, e: self.func(
541                "DATE_PART", exp.Literal.string("epoch"), e.this
542            ),
543            exp.VariancePop: rename_func("VAR_POP"),
544            exp.Variance: rename_func("VAR_SAMP"),
545            exp.Xor: bool_xor_sql,
546        }
547        TRANSFORMS.pop(exp.CommentColumnConstraint)
548
549        PROPERTIES_LOCATION = {
550            **generator.Generator.PROPERTIES_LOCATION,
551            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
552            exp.TransientProperty: exp.Properties.Location.UNSUPPORTED,
553            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
554        }
555
556        def schemacommentproperty_sql(self, expression: exp.SchemaCommentProperty) -> str:
557            self.unsupported("Table comments are not supported in the CREATE statement")
558            return ""
559
560        def commentcolumnconstraint_sql(self, expression: exp.CommentColumnConstraint) -> str:
561            self.unsupported("Column comments are not supported in the CREATE statement")
562            return ""
563
564        def unnest_sql(self, expression: exp.Unnest) -> str:
565            if len(expression.expressions) == 1:
566                from sqlglot.optimizer.annotate_types import annotate_types
567
568                this = annotate_types(expression.expressions[0])
569                if this.is_type("array<json>"):
570                    while isinstance(this, exp.Cast):
571                        this = this.this
572
573                    arg = self.sql(exp.cast(this, exp.DataType.Type.JSON))
574                    alias = self.sql(expression, "alias")
575                    alias = f" AS {alias}" if alias else ""
576
577                    if expression.args.get("offset"):
578                        self.unsupported("Unsupported JSON_ARRAY_ELEMENTS with offset")
579
580                    return f"JSON_ARRAY_ELEMENTS({arg}){alias}"
581
582            return super().unnest_sql(expression)
583
584        def bracket_sql(self, expression: exp.Bracket) -> str:
585            """Forms like ARRAY[1, 2, 3][3] aren't allowed; we need to wrap the ARRAY."""
586            if isinstance(expression.this, exp.Array):
587                expression.set("this", exp.paren(expression.this, copy=False))
588
589            return super().bracket_sql(expression)
590
591        def matchagainst_sql(self, expression: exp.MatchAgainst) -> str:
592            this = self.sql(expression, "this")
593            expressions = [f"{self.sql(e)} @@ {this}" for e in expression.expressions]
594            sql = " OR ".join(expressions)
595            return f"({sql})" if len(expressions) > 1 else sql