sqlglot.generator

   1from __future__ import annotations
   2
   3import logging
   4import re
   5import typing as t
   6from collections import defaultdict
   7from functools import reduce, wraps
   8
   9from sqlglot import exp
  10from sqlglot.errors import ErrorLevel, UnsupportedError, concat_messages
  11from sqlglot.helper import apply_index_offset, csv, name_sequence, seq_get
  12from sqlglot.jsonpath import ALL_JSON_PATH_PARTS, JSON_PATH_PART_TRANSFORMS
  13from sqlglot.time import format_time
  14from sqlglot.tokens import TokenType
  15
  16if t.TYPE_CHECKING:
  17    from sqlglot._typing import E
  18    from sqlglot.dialects.dialect import DialectType
  19
  20    G = t.TypeVar("G", bound="Generator")
  21    GeneratorMethod = t.Callable[[G, E], str]
  22
  23logger = logging.getLogger("sqlglot")
  24
  25ESCAPED_UNICODE_RE = re.compile(r"\\(\d+)")
  26UNSUPPORTED_TEMPLATE = "Argument '{}' is not supported for expression '{}' when targeting {}."
  27
  28
  29def unsupported_args(
  30    *args: t.Union[str, t.Tuple[str, str]],
  31) -> t.Callable[[GeneratorMethod], GeneratorMethod]:
  32    """
  33    Decorator that can be used to mark certain args of an `Expression` subclass as unsupported.
  34    It expects a sequence of argument names or pairs of the form (argument_name, diagnostic_msg).
  35    """
  36    diagnostic_by_arg: t.Dict[str, t.Optional[str]] = {}
  37    for arg in args:
  38        if isinstance(arg, str):
  39            diagnostic_by_arg[arg] = None
  40        else:
  41            diagnostic_by_arg[arg[0]] = arg[1]
  42
  43    def decorator(func: GeneratorMethod) -> GeneratorMethod:
  44        @wraps(func)
  45        def _func(generator: G, expression: E) -> str:
  46            expression_name = expression.__class__.__name__
  47            dialect_name = generator.dialect.__class__.__name__
  48
  49            for arg_name, diagnostic in diagnostic_by_arg.items():
  50                if expression.args.get(arg_name):
  51                    diagnostic = diagnostic or UNSUPPORTED_TEMPLATE.format(
  52                        arg_name, expression_name, dialect_name
  53                    )
  54                    generator.unsupported(diagnostic)
  55
  56            return func(generator, expression)
  57
  58        return _func
  59
  60    return decorator
  61
  62
  63class _Generator(type):
  64    def __new__(cls, clsname, bases, attrs):
  65        klass = super().__new__(cls, clsname, bases, attrs)
  66
  67        # Remove transforms that correspond to unsupported JSONPathPart expressions
  68        for part in ALL_JSON_PATH_PARTS - klass.SUPPORTED_JSON_PATH_PARTS:
  69            klass.TRANSFORMS.pop(part, None)
  70
  71        return klass
  72
  73
  74class Generator(metaclass=_Generator):
  75    """
  76    Generator converts a given syntax tree to the corresponding SQL string.
  77
  78    Args:
  79        pretty: Whether to format the produced SQL string.
  80            Default: False.
  81        identify: Determines when an identifier should be quoted. Possible values are:
  82            False (default): Never quote, except in cases where it's mandatory by the dialect.
  83            True or 'always': Always quote.
  84            'safe': Only quote identifiers that are case insensitive.
  85        normalize: Whether to normalize identifiers to lowercase.
  86            Default: False.
  87        pad: The pad size in a formatted string. For example, this affects the indentation of
  88            a projection in a query, relative to its nesting level.
  89            Default: 2.
  90        indent: The indentation size in a formatted string. For example, this affects the
  91            indentation of subqueries and filters under a `WHERE` clause.
  92            Default: 2.
  93        normalize_functions: How to normalize function names. Possible values are:
  94            "upper" or True (default): Convert names to uppercase.
  95            "lower": Convert names to lowercase.
  96            False: Disables function name normalization.
  97        unsupported_level: Determines the generator's behavior when it encounters unsupported expressions.
  98            Default ErrorLevel.WARN.
  99        max_unsupported: Maximum number of unsupported messages to include in a raised UnsupportedError.
 100            This is only relevant if unsupported_level is ErrorLevel.RAISE.
 101            Default: 3
 102        leading_comma: Whether the comma is leading or trailing in select expressions.
 103            This is only relevant when generating in pretty mode.
 104            Default: False
 105        max_text_width: The max number of characters in a segment before creating new lines in pretty mode.
 106            The default is on the smaller end because the length only represents a segment and not the true
 107            line length.
 108            Default: 80
 109        comments: Whether to preserve comments in the output SQL code.
 110            Default: True
 111    """
 112
 113    TRANSFORMS: t.Dict[t.Type[exp.Expression], t.Callable[..., str]] = {
 114        **JSON_PATH_PART_TRANSFORMS,
 115        exp.AllowedValuesProperty: lambda self,
 116        e: f"ALLOWED_VALUES {self.expressions(e, flat=True)}",
 117        exp.AnalyzeColumns: lambda self, e: self.sql(e, "this"),
 118        exp.AnalyzeWith: lambda self, e: self.expressions(e, prefix="WITH ", sep=" "),
 119        exp.ArrayContainsAll: lambda self, e: self.binary(e, "@>"),
 120        exp.ArrayOverlaps: lambda self, e: self.binary(e, "&&"),
 121        exp.AutoRefreshProperty: lambda self, e: f"AUTO REFRESH {self.sql(e, 'this')}",
 122        exp.BackupProperty: lambda self, e: f"BACKUP {self.sql(e, 'this')}",
 123        exp.CaseSpecificColumnConstraint: lambda _,
 124        e: f"{'NOT ' if e.args.get('not_') else ''}CASESPECIFIC",
 125        exp.Ceil: lambda self, e: self.ceil_floor(e),
 126        exp.CharacterSetColumnConstraint: lambda self, e: f"CHARACTER SET {self.sql(e, 'this')}",
 127        exp.CharacterSetProperty: lambda self,
 128        e: f"{'DEFAULT ' if e.args.get('default') else ''}CHARACTER SET={self.sql(e, 'this')}",
 129        exp.ClusteredColumnConstraint: lambda self,
 130        e: f"CLUSTERED ({self.expressions(e, 'this', indent=False)})",
 131        exp.CollateColumnConstraint: lambda self, e: f"COLLATE {self.sql(e, 'this')}",
 132        exp.CommentColumnConstraint: lambda self, e: f"COMMENT {self.sql(e, 'this')}",
 133        exp.ConnectByRoot: lambda self, e: f"CONNECT_BY_ROOT {self.sql(e, 'this')}",
 134        exp.ConvertToCharset: lambda self, e: self.func(
 135            "CONVERT", e.this, e.args["dest"], e.args.get("source")
 136        ),
 137        exp.CopyGrantsProperty: lambda *_: "COPY GRANTS",
 138        exp.CredentialsProperty: lambda self,
 139        e: f"CREDENTIALS=({self.expressions(e, 'expressions', sep=' ')})",
 140        exp.DateFormatColumnConstraint: lambda self, e: f"FORMAT {self.sql(e, 'this')}",
 141        exp.DefaultColumnConstraint: lambda self, e: f"DEFAULT {self.sql(e, 'this')}",
 142        exp.DynamicProperty: lambda *_: "DYNAMIC",
 143        exp.EmptyProperty: lambda *_: "EMPTY",
 144        exp.EncodeColumnConstraint: lambda self, e: f"ENCODE {self.sql(e, 'this')}",
 145        exp.EnviromentProperty: lambda self, e: f"ENVIRONMENT ({self.expressions(e, flat=True)})",
 146        exp.EphemeralColumnConstraint: lambda self,
 147        e: f"EPHEMERAL{(' ' + self.sql(e, 'this')) if e.this else ''}",
 148        exp.ExcludeColumnConstraint: lambda self, e: f"EXCLUDE {self.sql(e, 'this').lstrip()}",
 149        exp.ExecuteAsProperty: lambda self, e: self.naked_property(e),
 150        exp.Except: lambda self, e: self.set_operations(e),
 151        exp.ExternalProperty: lambda *_: "EXTERNAL",
 152        exp.Floor: lambda self, e: self.ceil_floor(e),
 153        exp.Get: lambda self, e: self.get_put_sql(e),
 154        exp.GlobalProperty: lambda *_: "GLOBAL",
 155        exp.HeapProperty: lambda *_: "HEAP",
 156        exp.IcebergProperty: lambda *_: "ICEBERG",
 157        exp.InheritsProperty: lambda self, e: f"INHERITS ({self.expressions(e, flat=True)})",
 158        exp.InlineLengthColumnConstraint: lambda self, e: f"INLINE LENGTH {self.sql(e, 'this')}",
 159        exp.InputModelProperty: lambda self, e: f"INPUT{self.sql(e, 'this')}",
 160        exp.Intersect: lambda self, e: self.set_operations(e),
 161        exp.IntervalSpan: lambda self, e: f"{self.sql(e, 'this')} TO {self.sql(e, 'expression')}",
 162        exp.Int64: lambda self, e: self.sql(exp.cast(e.this, exp.DataType.Type.BIGINT)),
 163        exp.LanguageProperty: lambda self, e: self.naked_property(e),
 164        exp.LocationProperty: lambda self, e: self.naked_property(e),
 165        exp.LogProperty: lambda _, e: f"{'NO ' if e.args.get('no') else ''}LOG",
 166        exp.MaterializedProperty: lambda *_: "MATERIALIZED",
 167        exp.NonClusteredColumnConstraint: lambda self,
 168        e: f"NONCLUSTERED ({self.expressions(e, 'this', indent=False)})",
 169        exp.NoPrimaryIndexProperty: lambda *_: "NO PRIMARY INDEX",
 170        exp.NotForReplicationColumnConstraint: lambda *_: "NOT FOR REPLICATION",
 171        exp.OnCommitProperty: lambda _,
 172        e: f"ON COMMIT {'DELETE' if e.args.get('delete') else 'PRESERVE'} ROWS",
 173        exp.OnProperty: lambda self, e: f"ON {self.sql(e, 'this')}",
 174        exp.OnUpdateColumnConstraint: lambda self, e: f"ON UPDATE {self.sql(e, 'this')}",
 175        exp.Operator: lambda self, e: self.binary(e, ""),  # The operator is produced in `binary`
 176        exp.OutputModelProperty: lambda self, e: f"OUTPUT{self.sql(e, 'this')}",
 177        exp.PathColumnConstraint: lambda self, e: f"PATH {self.sql(e, 'this')}",
 178        exp.PartitionedByBucket: lambda self, e: self.func("BUCKET", e.this, e.expression),
 179        exp.PartitionByTruncate: lambda self, e: self.func("TRUNCATE", e.this, e.expression),
 180        exp.PivotAny: lambda self, e: f"ANY{self.sql(e, 'this')}",
 181        exp.ProjectionPolicyColumnConstraint: lambda self,
 182        e: f"PROJECTION POLICY {self.sql(e, 'this')}",
 183        exp.Put: lambda self, e: self.get_put_sql(e),
 184        exp.RemoteWithConnectionModelProperty: lambda self,
 185        e: f"REMOTE WITH CONNECTION {self.sql(e, 'this')}",
 186        exp.ReturnsProperty: lambda self, e: (
 187            "RETURNS NULL ON NULL INPUT" if e.args.get("null") else self.naked_property(e)
 188        ),
 189        exp.SampleProperty: lambda self, e: f"SAMPLE BY {self.sql(e, 'this')}",
 190        exp.SecureProperty: lambda *_: "SECURE",
 191        exp.SecurityProperty: lambda self, e: f"SECURITY {self.sql(e, 'this')}",
 192        exp.SetConfigProperty: lambda self, e: self.sql(e, "this"),
 193        exp.SetProperty: lambda _, e: f"{'MULTI' if e.args.get('multi') else ''}SET",
 194        exp.SettingsProperty: lambda self, e: f"SETTINGS{self.seg('')}{(self.expressions(e))}",
 195        exp.SharingProperty: lambda self, e: f"SHARING={self.sql(e, 'this')}",
 196        exp.SqlReadWriteProperty: lambda _, e: e.name,
 197        exp.SqlSecurityProperty: lambda _,
 198        e: f"SQL SECURITY {'DEFINER' if e.args.get('definer') else 'INVOKER'}",
 199        exp.StabilityProperty: lambda _, e: e.name,
 200        exp.Stream: lambda self, e: f"STREAM {self.sql(e, 'this')}",
 201        exp.StreamingTableProperty: lambda *_: "STREAMING",
 202        exp.StrictProperty: lambda *_: "STRICT",
 203        exp.SwapTable: lambda self, e: f"SWAP WITH {self.sql(e, 'this')}",
 204        exp.TableColumn: lambda self, e: self.sql(e.this),
 205        exp.Tags: lambda self, e: f"TAG ({self.expressions(e, flat=True)})",
 206        exp.TemporaryProperty: lambda *_: "TEMPORARY",
 207        exp.TitleColumnConstraint: lambda self, e: f"TITLE {self.sql(e, 'this')}",
 208        exp.ToMap: lambda self, e: f"MAP {self.sql(e, 'this')}",
 209        exp.ToTableProperty: lambda self, e: f"TO {self.sql(e.this)}",
 210        exp.TransformModelProperty: lambda self, e: self.func("TRANSFORM", *e.expressions),
 211        exp.TransientProperty: lambda *_: "TRANSIENT",
 212        exp.Union: lambda self, e: self.set_operations(e),
 213        exp.UnloggedProperty: lambda *_: "UNLOGGED",
 214        exp.UsingTemplateProperty: lambda self, e: f"USING TEMPLATE {self.sql(e, 'this')}",
 215        exp.UsingData: lambda self, e: f"USING DATA {self.sql(e, 'this')}",
 216        exp.Uuid: lambda *_: "UUID()",
 217        exp.UppercaseColumnConstraint: lambda *_: "UPPERCASE",
 218        exp.VarMap: lambda self, e: self.func("MAP", e.args["keys"], e.args["values"]),
 219        exp.ViewAttributeProperty: lambda self, e: f"WITH {self.sql(e, 'this')}",
 220        exp.VolatileProperty: lambda *_: "VOLATILE",
 221        exp.WithJournalTableProperty: lambda self, e: f"WITH JOURNAL TABLE={self.sql(e, 'this')}",
 222        exp.WithProcedureOptions: lambda self, e: f"WITH {self.expressions(e, flat=True)}",
 223        exp.WithSchemaBindingProperty: lambda self, e: f"WITH SCHEMA {self.sql(e, 'this')}",
 224        exp.WithOperator: lambda self, e: f"{self.sql(e, 'this')} WITH {self.sql(e, 'op')}",
 225        exp.ForceProperty: lambda *_: "FORCE",
 226    }
 227
 228    # Whether null ordering is supported in order by
 229    # True: Full Support, None: No support, False: No support for certain cases
 230    # such as window specifications, aggregate functions etc
 231    NULL_ORDERING_SUPPORTED: t.Optional[bool] = True
 232
 233    # Whether ignore nulls is inside the agg or outside.
 234    # FIRST(x IGNORE NULLS) OVER vs FIRST (x) IGNORE NULLS OVER
 235    IGNORE_NULLS_IN_FUNC = False
 236
 237    # Whether locking reads (i.e. SELECT ... FOR UPDATE/SHARE) are supported
 238    LOCKING_READS_SUPPORTED = False
 239
 240    # Whether the EXCEPT and INTERSECT operations can return duplicates
 241    EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE = True
 242
 243    # Wrap derived values in parens, usually standard but spark doesn't support it
 244    WRAP_DERIVED_VALUES = True
 245
 246    # Whether create function uses an AS before the RETURN
 247    CREATE_FUNCTION_RETURN_AS = True
 248
 249    # Whether MERGE ... WHEN MATCHED BY SOURCE is allowed
 250    MATCHED_BY_SOURCE = True
 251
 252    # Whether the INTERVAL expression works only with values like '1 day'
 253    SINGLE_STRING_INTERVAL = False
 254
 255    # Whether the plural form of date parts like day (i.e. "days") is supported in INTERVALs
 256    INTERVAL_ALLOWS_PLURAL_FORM = True
 257
 258    # Whether limit and fetch are supported (possible values: "ALL", "LIMIT", "FETCH")
 259    LIMIT_FETCH = "ALL"
 260
 261    # Whether limit and fetch allows expresions or just limits
 262    LIMIT_ONLY_LITERALS = False
 263
 264    # Whether a table is allowed to be renamed with a db
 265    RENAME_TABLE_WITH_DB = True
 266
 267    # The separator for grouping sets and rollups
 268    GROUPINGS_SEP = ","
 269
 270    # The string used for creating an index on a table
 271    INDEX_ON = "ON"
 272
 273    # Whether join hints should be generated
 274    JOIN_HINTS = True
 275
 276    # Whether table hints should be generated
 277    TABLE_HINTS = True
 278
 279    # Whether query hints should be generated
 280    QUERY_HINTS = True
 281
 282    # What kind of separator to use for query hints
 283    QUERY_HINT_SEP = ", "
 284
 285    # Whether comparing against booleans (e.g. x IS TRUE) is supported
 286    IS_BOOL_ALLOWED = True
 287
 288    # Whether to include the "SET" keyword in the "INSERT ... ON DUPLICATE KEY UPDATE" statement
 289    DUPLICATE_KEY_UPDATE_WITH_SET = True
 290
 291    # Whether to generate the limit as TOP <value> instead of LIMIT <value>
 292    LIMIT_IS_TOP = False
 293
 294    # Whether to generate INSERT INTO ... RETURNING or INSERT INTO RETURNING ...
 295    RETURNING_END = True
 296
 297    # Whether to generate an unquoted value for EXTRACT's date part argument
 298    EXTRACT_ALLOWS_QUOTES = True
 299
 300    # Whether TIMETZ / TIMESTAMPTZ will be generated using the "WITH TIME ZONE" syntax
 301    TZ_TO_WITH_TIME_ZONE = False
 302
 303    # Whether the NVL2 function is supported
 304    NVL2_SUPPORTED = True
 305
 306    # https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax
 307    SELECT_KINDS: t.Tuple[str, ...] = ("STRUCT", "VALUE")
 308
 309    # Whether VALUES statements can be used as derived tables.
 310    # MySQL 5 and Redshift do not allow this, so when False, it will convert
 311    # SELECT * VALUES into SELECT UNION
 312    VALUES_AS_TABLE = True
 313
 314    # Whether the word COLUMN is included when adding a column with ALTER TABLE
 315    ALTER_TABLE_INCLUDE_COLUMN_KEYWORD = True
 316
 317    # UNNEST WITH ORDINALITY (presto) instead of UNNEST WITH OFFSET (bigquery)
 318    UNNEST_WITH_ORDINALITY = True
 319
 320    # Whether FILTER (WHERE cond) can be used for conditional aggregation
 321    AGGREGATE_FILTER_SUPPORTED = True
 322
 323    # Whether JOIN sides (LEFT, RIGHT) are supported in conjunction with SEMI/ANTI join kinds
 324    SEMI_ANTI_JOIN_WITH_SIDE = True
 325
 326    # Whether to include the type of a computed column in the CREATE DDL
 327    COMPUTED_COLUMN_WITH_TYPE = True
 328
 329    # Whether CREATE TABLE .. COPY .. is supported. False means we'll generate CLONE instead of COPY
 330    SUPPORTS_TABLE_COPY = True
 331
 332    # Whether parentheses are required around the table sample's expression
 333    TABLESAMPLE_REQUIRES_PARENS = True
 334
 335    # Whether a table sample clause's size needs to be followed by the ROWS keyword
 336    TABLESAMPLE_SIZE_IS_ROWS = True
 337
 338    # The keyword(s) to use when generating a sample clause
 339    TABLESAMPLE_KEYWORDS = "TABLESAMPLE"
 340
 341    # Whether the TABLESAMPLE clause supports a method name, like BERNOULLI
 342    TABLESAMPLE_WITH_METHOD = True
 343
 344    # The keyword to use when specifying the seed of a sample clause
 345    TABLESAMPLE_SEED_KEYWORD = "SEED"
 346
 347    # Whether COLLATE is a function instead of a binary operator
 348    COLLATE_IS_FUNC = False
 349
 350    # Whether data types support additional specifiers like e.g. CHAR or BYTE (oracle)
 351    DATA_TYPE_SPECIFIERS_ALLOWED = False
 352
 353    # Whether conditions require booleans WHERE x = 0 vs WHERE x
 354    ENSURE_BOOLS = False
 355
 356    # Whether the "RECURSIVE" keyword is required when defining recursive CTEs
 357    CTE_RECURSIVE_KEYWORD_REQUIRED = True
 358
 359    # Whether CONCAT requires >1 arguments
 360    SUPPORTS_SINGLE_ARG_CONCAT = True
 361
 362    # Whether LAST_DAY function supports a date part argument
 363    LAST_DAY_SUPPORTS_DATE_PART = True
 364
 365    # Whether named columns are allowed in table aliases
 366    SUPPORTS_TABLE_ALIAS_COLUMNS = True
 367
 368    # Whether UNPIVOT aliases are Identifiers (False means they're Literals)
 369    UNPIVOT_ALIASES_ARE_IDENTIFIERS = True
 370
 371    # What delimiter to use for separating JSON key/value pairs
 372    JSON_KEY_VALUE_PAIR_SEP = ":"
 373
 374    # INSERT OVERWRITE TABLE x override
 375    INSERT_OVERWRITE = " OVERWRITE TABLE"
 376
 377    # Whether the SELECT .. INTO syntax is used instead of CTAS
 378    SUPPORTS_SELECT_INTO = False
 379
 380    # Whether UNLOGGED tables can be created
 381    SUPPORTS_UNLOGGED_TABLES = False
 382
 383    # Whether the CREATE TABLE LIKE statement is supported
 384    SUPPORTS_CREATE_TABLE_LIKE = True
 385
 386    # Whether the LikeProperty needs to be specified inside of the schema clause
 387    LIKE_PROPERTY_INSIDE_SCHEMA = False
 388
 389    # Whether DISTINCT can be followed by multiple args in an AggFunc. If not, it will be
 390    # transpiled into a series of CASE-WHEN-ELSE, ultimately using a tuple conseisting of the args
 391    MULTI_ARG_DISTINCT = True
 392
 393    # Whether the JSON extraction operators expect a value of type JSON
 394    JSON_TYPE_REQUIRED_FOR_EXTRACTION = False
 395
 396    # Whether bracketed keys like ["foo"] are supported in JSON paths
 397    JSON_PATH_BRACKETED_KEY_SUPPORTED = True
 398
 399    # Whether to escape keys using single quotes in JSON paths
 400    JSON_PATH_SINGLE_QUOTE_ESCAPE = False
 401
 402    # The JSONPathPart expressions supported by this dialect
 403    SUPPORTED_JSON_PATH_PARTS = ALL_JSON_PATH_PARTS.copy()
 404
 405    # Whether any(f(x) for x in array) can be implemented by this dialect
 406    CAN_IMPLEMENT_ARRAY_ANY = False
 407
 408    # Whether the function TO_NUMBER is supported
 409    SUPPORTS_TO_NUMBER = True
 410
 411    # Whether EXCLUDE in window specification is supported
 412    SUPPORTS_WINDOW_EXCLUDE = False
 413
 414    # Whether or not set op modifiers apply to the outer set op or select.
 415    # SELECT * FROM x UNION SELECT * FROM y LIMIT 1
 416    # True means limit 1 happens after the set op, False means it it happens on y.
 417    SET_OP_MODIFIERS = True
 418
 419    # Whether parameters from COPY statement are wrapped in parentheses
 420    COPY_PARAMS_ARE_WRAPPED = True
 421
 422    # Whether values of params are set with "=" token or empty space
 423    COPY_PARAMS_EQ_REQUIRED = False
 424
 425    # Whether COPY statement has INTO keyword
 426    COPY_HAS_INTO_KEYWORD = True
 427
 428    # Whether the conditional TRY(expression) function is supported
 429    TRY_SUPPORTED = True
 430
 431    # Whether the UESCAPE syntax in unicode strings is supported
 432    SUPPORTS_UESCAPE = True
 433
 434    # The keyword to use when generating a star projection with excluded columns
 435    STAR_EXCEPT = "EXCEPT"
 436
 437    # The HEX function name
 438    HEX_FUNC = "HEX"
 439
 440    # The keywords to use when prefixing & separating WITH based properties
 441    WITH_PROPERTIES_PREFIX = "WITH"
 442
 443    # Whether to quote the generated expression of exp.JsonPath
 444    QUOTE_JSON_PATH = True
 445
 446    # Whether the text pattern/fill (3rd) parameter of RPAD()/LPAD() is optional (defaults to space)
 447    PAD_FILL_PATTERN_IS_REQUIRED = False
 448
 449    # Whether a projection can explode into multiple rows, e.g. by unnesting an array.
 450    SUPPORTS_EXPLODING_PROJECTIONS = True
 451
 452    # Whether ARRAY_CONCAT can be generated with varlen args or if it should be reduced to 2-arg version
 453    ARRAY_CONCAT_IS_VAR_LEN = True
 454
 455    # Whether CONVERT_TIMEZONE() is supported; if not, it will be generated as exp.AtTimeZone
 456    SUPPORTS_CONVERT_TIMEZONE = False
 457
 458    # Whether MEDIAN(expr) is supported; if not, it will be generated as PERCENTILE_CONT(expr, 0.5)
 459    SUPPORTS_MEDIAN = True
 460
 461    # Whether UNIX_SECONDS(timestamp) is supported
 462    SUPPORTS_UNIX_SECONDS = False
 463
 464    # Whether to wrap <props> in `AlterSet`, e.g., ALTER ... SET (<props>)
 465    ALTER_SET_WRAPPED = False
 466
 467    # Whether to normalize the date parts in EXTRACT(<date_part> FROM <expr>) into a common representation
 468    # For instance, to extract the day of week in ISO semantics, one can use ISODOW, DAYOFWEEKISO etc depending on the dialect.
 469    # TODO: The normalization should be done by default once we've tested it across all dialects.
 470    NORMALIZE_EXTRACT_DATE_PARTS = False
 471
 472    # The name to generate for the JSONPath expression. If `None`, only `this` will be generated
 473    PARSE_JSON_NAME: t.Optional[str] = "PARSE_JSON"
 474
 475    # The function name of the exp.ArraySize expression
 476    ARRAY_SIZE_NAME: str = "ARRAY_LENGTH"
 477
 478    # The syntax to use when altering the type of a column
 479    ALTER_SET_TYPE = "SET DATA TYPE"
 480
 481    # Whether exp.ArraySize should generate the dimension arg too (valid for Postgres & DuckDB)
 482    # None -> Doesn't support it at all
 483    # False (DuckDB) -> Has backwards-compatible support, but preferably generated without
 484    # True (Postgres) -> Explicitly requires it
 485    ARRAY_SIZE_DIM_REQUIRED: t.Optional[bool] = None
 486
 487    # Whether a multi-argument DECODE(...) function is supported. If not, a CASE expression is generated
 488    SUPPORTS_DECODE_CASE = True
 489
 490    TYPE_MAPPING = {
 491        exp.DataType.Type.DATETIME2: "TIMESTAMP",
 492        exp.DataType.Type.NCHAR: "CHAR",
 493        exp.DataType.Type.NVARCHAR: "VARCHAR",
 494        exp.DataType.Type.MEDIUMTEXT: "TEXT",
 495        exp.DataType.Type.LONGTEXT: "TEXT",
 496        exp.DataType.Type.TINYTEXT: "TEXT",
 497        exp.DataType.Type.BLOB: "VARBINARY",
 498        exp.DataType.Type.MEDIUMBLOB: "BLOB",
 499        exp.DataType.Type.LONGBLOB: "BLOB",
 500        exp.DataType.Type.TINYBLOB: "BLOB",
 501        exp.DataType.Type.INET: "INET",
 502        exp.DataType.Type.ROWVERSION: "VARBINARY",
 503        exp.DataType.Type.SMALLDATETIME: "TIMESTAMP",
 504    }
 505
 506    TIME_PART_SINGULARS = {
 507        "MICROSECONDS": "MICROSECOND",
 508        "SECONDS": "SECOND",
 509        "MINUTES": "MINUTE",
 510        "HOURS": "HOUR",
 511        "DAYS": "DAY",
 512        "WEEKS": "WEEK",
 513        "MONTHS": "MONTH",
 514        "QUARTERS": "QUARTER",
 515        "YEARS": "YEAR",
 516    }
 517
 518    AFTER_HAVING_MODIFIER_TRANSFORMS = {
 519        "cluster": lambda self, e: self.sql(e, "cluster"),
 520        "distribute": lambda self, e: self.sql(e, "distribute"),
 521        "sort": lambda self, e: self.sql(e, "sort"),
 522        "windows": lambda self, e: (
 523            self.seg("WINDOW ") + self.expressions(e, key="windows", flat=True)
 524            if e.args.get("windows")
 525            else ""
 526        ),
 527        "qualify": lambda self, e: self.sql(e, "qualify"),
 528    }
 529
 530    TOKEN_MAPPING: t.Dict[TokenType, str] = {}
 531
 532    STRUCT_DELIMITER = ("<", ">")
 533
 534    PARAMETER_TOKEN = "@"
 535    NAMED_PLACEHOLDER_TOKEN = ":"
 536
 537    EXPRESSION_PRECEDES_PROPERTIES_CREATABLES: t.Set[str] = set()
 538
 539    PROPERTIES_LOCATION = {
 540        exp.AllowedValuesProperty: exp.Properties.Location.POST_SCHEMA,
 541        exp.AlgorithmProperty: exp.Properties.Location.POST_CREATE,
 542        exp.AutoIncrementProperty: exp.Properties.Location.POST_SCHEMA,
 543        exp.AutoRefreshProperty: exp.Properties.Location.POST_SCHEMA,
 544        exp.BackupProperty: exp.Properties.Location.POST_SCHEMA,
 545        exp.BlockCompressionProperty: exp.Properties.Location.POST_NAME,
 546        exp.CharacterSetProperty: exp.Properties.Location.POST_SCHEMA,
 547        exp.ChecksumProperty: exp.Properties.Location.POST_NAME,
 548        exp.CollateProperty: exp.Properties.Location.POST_SCHEMA,
 549        exp.CopyGrantsProperty: exp.Properties.Location.POST_SCHEMA,
 550        exp.Cluster: exp.Properties.Location.POST_SCHEMA,
 551        exp.ClusteredByProperty: exp.Properties.Location.POST_SCHEMA,
 552        exp.DistributedByProperty: exp.Properties.Location.POST_SCHEMA,
 553        exp.DuplicateKeyProperty: exp.Properties.Location.POST_SCHEMA,
 554        exp.DataBlocksizeProperty: exp.Properties.Location.POST_NAME,
 555        exp.DataDeletionProperty: exp.Properties.Location.POST_SCHEMA,
 556        exp.DefinerProperty: exp.Properties.Location.POST_CREATE,
 557        exp.DictRange: exp.Properties.Location.POST_SCHEMA,
 558        exp.DictProperty: exp.Properties.Location.POST_SCHEMA,
 559        exp.DynamicProperty: exp.Properties.Location.POST_CREATE,
 560        exp.DistKeyProperty: exp.Properties.Location.POST_SCHEMA,
 561        exp.DistStyleProperty: exp.Properties.Location.POST_SCHEMA,
 562        exp.EmptyProperty: exp.Properties.Location.POST_SCHEMA,
 563        exp.EncodeProperty: exp.Properties.Location.POST_EXPRESSION,
 564        exp.EngineProperty: exp.Properties.Location.POST_SCHEMA,
 565        exp.EnviromentProperty: exp.Properties.Location.POST_SCHEMA,
 566        exp.ExecuteAsProperty: exp.Properties.Location.POST_SCHEMA,
 567        exp.ExternalProperty: exp.Properties.Location.POST_CREATE,
 568        exp.FallbackProperty: exp.Properties.Location.POST_NAME,
 569        exp.FileFormatProperty: exp.Properties.Location.POST_WITH,
 570        exp.FreespaceProperty: exp.Properties.Location.POST_NAME,
 571        exp.GlobalProperty: exp.Properties.Location.POST_CREATE,
 572        exp.HeapProperty: exp.Properties.Location.POST_WITH,
 573        exp.InheritsProperty: exp.Properties.Location.POST_SCHEMA,
 574        exp.IcebergProperty: exp.Properties.Location.POST_CREATE,
 575        exp.IncludeProperty: exp.Properties.Location.POST_SCHEMA,
 576        exp.InputModelProperty: exp.Properties.Location.POST_SCHEMA,
 577        exp.IsolatedLoadingProperty: exp.Properties.Location.POST_NAME,
 578        exp.JournalProperty: exp.Properties.Location.POST_NAME,
 579        exp.LanguageProperty: exp.Properties.Location.POST_SCHEMA,
 580        exp.LikeProperty: exp.Properties.Location.POST_SCHEMA,
 581        exp.LocationProperty: exp.Properties.Location.POST_SCHEMA,
 582        exp.LockProperty: exp.Properties.Location.POST_SCHEMA,
 583        exp.LockingProperty: exp.Properties.Location.POST_ALIAS,
 584        exp.LogProperty: exp.Properties.Location.POST_NAME,
 585        exp.MaterializedProperty: exp.Properties.Location.POST_CREATE,
 586        exp.MergeBlockRatioProperty: exp.Properties.Location.POST_NAME,
 587        exp.NoPrimaryIndexProperty: exp.Properties.Location.POST_EXPRESSION,
 588        exp.OnProperty: exp.Properties.Location.POST_SCHEMA,
 589        exp.OnCommitProperty: exp.Properties.Location.POST_EXPRESSION,
 590        exp.Order: exp.Properties.Location.POST_SCHEMA,
 591        exp.OutputModelProperty: exp.Properties.Location.POST_SCHEMA,
 592        exp.PartitionedByProperty: exp.Properties.Location.POST_WITH,
 593        exp.PartitionedOfProperty: exp.Properties.Location.POST_SCHEMA,
 594        exp.PrimaryKey: exp.Properties.Location.POST_SCHEMA,
 595        exp.Property: exp.Properties.Location.POST_WITH,
 596        exp.RemoteWithConnectionModelProperty: exp.Properties.Location.POST_SCHEMA,
 597        exp.ReturnsProperty: exp.Properties.Location.POST_SCHEMA,
 598        exp.RowFormatProperty: exp.Properties.Location.POST_SCHEMA,
 599        exp.RowFormatDelimitedProperty: exp.Properties.Location.POST_SCHEMA,
 600        exp.RowFormatSerdeProperty: exp.Properties.Location.POST_SCHEMA,
 601        exp.SampleProperty: exp.Properties.Location.POST_SCHEMA,
 602        exp.SchemaCommentProperty: exp.Properties.Location.POST_SCHEMA,
 603        exp.SecureProperty: exp.Properties.Location.POST_CREATE,
 604        exp.SecurityProperty: exp.Properties.Location.POST_SCHEMA,
 605        exp.SerdeProperties: exp.Properties.Location.POST_SCHEMA,
 606        exp.Set: exp.Properties.Location.POST_SCHEMA,
 607        exp.SettingsProperty: exp.Properties.Location.POST_SCHEMA,
 608        exp.SetProperty: exp.Properties.Location.POST_CREATE,
 609        exp.SetConfigProperty: exp.Properties.Location.POST_SCHEMA,
 610        exp.SharingProperty: exp.Properties.Location.POST_EXPRESSION,
 611        exp.SequenceProperties: exp.Properties.Location.POST_EXPRESSION,
 612        exp.SortKeyProperty: exp.Properties.Location.POST_SCHEMA,
 613        exp.SqlReadWriteProperty: exp.Properties.Location.POST_SCHEMA,
 614        exp.SqlSecurityProperty: exp.Properties.Location.POST_CREATE,
 615        exp.StabilityProperty: exp.Properties.Location.POST_SCHEMA,
 616        exp.StorageHandlerProperty: exp.Properties.Location.POST_SCHEMA,
 617        exp.StreamingTableProperty: exp.Properties.Location.POST_CREATE,
 618        exp.StrictProperty: exp.Properties.Location.POST_SCHEMA,
 619        exp.Tags: exp.Properties.Location.POST_WITH,
 620        exp.TemporaryProperty: exp.Properties.Location.POST_CREATE,
 621        exp.ToTableProperty: exp.Properties.Location.POST_SCHEMA,
 622        exp.TransientProperty: exp.Properties.Location.POST_CREATE,
 623        exp.TransformModelProperty: exp.Properties.Location.POST_SCHEMA,
 624        exp.MergeTreeTTL: exp.Properties.Location.POST_SCHEMA,
 625        exp.UnloggedProperty: exp.Properties.Location.POST_CREATE,
 626        exp.UsingTemplateProperty: exp.Properties.Location.POST_SCHEMA,
 627        exp.ViewAttributeProperty: exp.Properties.Location.POST_SCHEMA,
 628        exp.VolatileProperty: exp.Properties.Location.POST_CREATE,
 629        exp.WithDataProperty: exp.Properties.Location.POST_EXPRESSION,
 630        exp.WithJournalTableProperty: exp.Properties.Location.POST_NAME,
 631        exp.WithProcedureOptions: exp.Properties.Location.POST_SCHEMA,
 632        exp.WithSchemaBindingProperty: exp.Properties.Location.POST_SCHEMA,
 633        exp.WithSystemVersioningProperty: exp.Properties.Location.POST_SCHEMA,
 634        exp.ForceProperty: exp.Properties.Location.POST_CREATE,
 635    }
 636
 637    # Keywords that can't be used as unquoted identifier names
 638    RESERVED_KEYWORDS: t.Set[str] = set()
 639
 640    # Expressions whose comments are separated from them for better formatting
 641    WITH_SEPARATED_COMMENTS: t.Tuple[t.Type[exp.Expression], ...] = (
 642        exp.Command,
 643        exp.Create,
 644        exp.Describe,
 645        exp.Delete,
 646        exp.Drop,
 647        exp.From,
 648        exp.Insert,
 649        exp.Join,
 650        exp.MultitableInserts,
 651        exp.Order,
 652        exp.Group,
 653        exp.Having,
 654        exp.Select,
 655        exp.SetOperation,
 656        exp.Update,
 657        exp.Where,
 658        exp.With,
 659    )
 660
 661    # Expressions that should not have their comments generated in maybe_comment
 662    EXCLUDE_COMMENTS: t.Tuple[t.Type[exp.Expression], ...] = (
 663        exp.Binary,
 664        exp.SetOperation,
 665    )
 666
 667    # Expressions that can remain unwrapped when appearing in the context of an INTERVAL
 668    UNWRAPPED_INTERVAL_VALUES: t.Tuple[t.Type[exp.Expression], ...] = (
 669        exp.Column,
 670        exp.Literal,
 671        exp.Neg,
 672        exp.Paren,
 673    )
 674
 675    PARAMETERIZABLE_TEXT_TYPES = {
 676        exp.DataType.Type.NVARCHAR,
 677        exp.DataType.Type.VARCHAR,
 678        exp.DataType.Type.CHAR,
 679        exp.DataType.Type.NCHAR,
 680    }
 681
 682    # Expressions that need to have all CTEs under them bubbled up to them
 683    EXPRESSIONS_WITHOUT_NESTED_CTES: t.Set[t.Type[exp.Expression]] = set()
 684
 685    RESPECT_IGNORE_NULLS_UNSUPPORTED_EXPRESSIONS: t.Tuple[t.Type[exp.Expression], ...] = ()
 686
 687    SENTINEL_LINE_BREAK = "__SQLGLOT__LB__"
 688
 689    __slots__ = (
 690        "pretty",
 691        "identify",
 692        "normalize",
 693        "pad",
 694        "_indent",
 695        "normalize_functions",
 696        "unsupported_level",
 697        "max_unsupported",
 698        "leading_comma",
 699        "max_text_width",
 700        "comments",
 701        "dialect",
 702        "unsupported_messages",
 703        "_escaped_quote_end",
 704        "_escaped_identifier_end",
 705        "_next_name",
 706        "_identifier_start",
 707        "_identifier_end",
 708        "_quote_json_path_key_using_brackets",
 709    )
 710
 711    def __init__(
 712        self,
 713        pretty: t.Optional[bool] = None,
 714        identify: str | bool = False,
 715        normalize: bool = False,
 716        pad: int = 2,
 717        indent: int = 2,
 718        normalize_functions: t.Optional[str | bool] = None,
 719        unsupported_level: ErrorLevel = ErrorLevel.WARN,
 720        max_unsupported: int = 3,
 721        leading_comma: bool = False,
 722        max_text_width: int = 80,
 723        comments: bool = True,
 724        dialect: DialectType = None,
 725    ):
 726        import sqlglot
 727        from sqlglot.dialects import Dialect
 728
 729        self.pretty = pretty if pretty is not None else sqlglot.pretty
 730        self.identify = identify
 731        self.normalize = normalize
 732        self.pad = pad
 733        self._indent = indent
 734        self.unsupported_level = unsupported_level
 735        self.max_unsupported = max_unsupported
 736        self.leading_comma = leading_comma
 737        self.max_text_width = max_text_width
 738        self.comments = comments
 739        self.dialect = Dialect.get_or_raise(dialect)
 740
 741        # This is both a Dialect property and a Generator argument, so we prioritize the latter
 742        self.normalize_functions = (
 743            self.dialect.NORMALIZE_FUNCTIONS if normalize_functions is None else normalize_functions
 744        )
 745
 746        self.unsupported_messages: t.List[str] = []
 747        self._escaped_quote_end: str = (
 748            self.dialect.tokenizer_class.STRING_ESCAPES[0] + self.dialect.QUOTE_END
 749        )
 750        self._escaped_identifier_end = self.dialect.IDENTIFIER_END * 2
 751
 752        self._next_name = name_sequence("_t")
 753
 754        self._identifier_start = self.dialect.IDENTIFIER_START
 755        self._identifier_end = self.dialect.IDENTIFIER_END
 756
 757        self._quote_json_path_key_using_brackets = True
 758
 759    def generate(self, expression: exp.Expression, copy: bool = True) -> str:
 760        """
 761        Generates the SQL string corresponding to the given syntax tree.
 762
 763        Args:
 764            expression: The syntax tree.
 765            copy: Whether to copy the expression. The generator performs mutations so
 766                it is safer to copy.
 767
 768        Returns:
 769            The SQL string corresponding to `expression`.
 770        """
 771        if copy:
 772            expression = expression.copy()
 773
 774        expression = self.preprocess(expression)
 775
 776        self.unsupported_messages = []
 777        sql = self.sql(expression).strip()
 778
 779        if self.pretty:
 780            sql = sql.replace(self.SENTINEL_LINE_BREAK, "\n")
 781
 782        if self.unsupported_level == ErrorLevel.IGNORE:
 783            return sql
 784
 785        if self.unsupported_level == ErrorLevel.WARN:
 786            for msg in self.unsupported_messages:
 787                logger.warning(msg)
 788        elif self.unsupported_level == ErrorLevel.RAISE and self.unsupported_messages:
 789            raise UnsupportedError(concat_messages(self.unsupported_messages, self.max_unsupported))
 790
 791        return sql
 792
 793    def preprocess(self, expression: exp.Expression) -> exp.Expression:
 794        """Apply generic preprocessing transformations to a given expression."""
 795        expression = self._move_ctes_to_top_level(expression)
 796
 797        if self.ENSURE_BOOLS:
 798            from sqlglot.transforms import ensure_bools
 799
 800            expression = ensure_bools(expression)
 801
 802        return expression
 803
 804    def _move_ctes_to_top_level(self, expression: E) -> E:
 805        if (
 806            not expression.parent
 807            and type(expression) in self.EXPRESSIONS_WITHOUT_NESTED_CTES
 808            and any(node.parent is not expression for node in expression.find_all(exp.With))
 809        ):
 810            from sqlglot.transforms import move_ctes_to_top_level
 811
 812            expression = move_ctes_to_top_level(expression)
 813        return expression
 814
 815    def unsupported(self, message: str) -> None:
 816        if self.unsupported_level == ErrorLevel.IMMEDIATE:
 817            raise UnsupportedError(message)
 818        self.unsupported_messages.append(message)
 819
 820    def sep(self, sep: str = " ") -> str:
 821        return f"{sep.strip()}\n" if self.pretty else sep
 822
 823    def seg(self, sql: str, sep: str = " ") -> str:
 824        return f"{self.sep(sep)}{sql}"
 825
 826    def sanitize_comment(self, comment: str) -> str:
 827        comment = " " + comment if comment[0].strip() else comment
 828        comment = comment + " " if comment[-1].strip() else comment
 829
 830        if not self.dialect.tokenizer_class.NESTED_COMMENTS:
 831            # Necessary workaround to avoid syntax errors due to nesting: /* ... */ ... */
 832            comment = comment.replace("*/", "* /")
 833
 834        return comment
 835
 836    def maybe_comment(
 837        self,
 838        sql: str,
 839        expression: t.Optional[exp.Expression] = None,
 840        comments: t.Optional[t.List[str]] = None,
 841        separated: bool = False,
 842    ) -> str:
 843        comments = (
 844            ((expression and expression.comments) if comments is None else comments)  # type: ignore
 845            if self.comments
 846            else None
 847        )
 848
 849        if not comments or isinstance(expression, self.EXCLUDE_COMMENTS):
 850            return sql
 851
 852        comments_sql = " ".join(
 853            f"/*{self.sanitize_comment(comment)}*/" for comment in comments if comment
 854        )
 855
 856        if not comments_sql:
 857            return sql
 858
 859        comments_sql = self._replace_line_breaks(comments_sql)
 860
 861        if separated or isinstance(expression, self.WITH_SEPARATED_COMMENTS):
 862            return (
 863                f"{self.sep()}{comments_sql}{sql}"
 864                if not sql or sql[0].isspace()
 865                else f"{comments_sql}{self.sep()}{sql}"
 866            )
 867
 868        return f"{sql} {comments_sql}"
 869
 870    def wrap(self, expression: exp.Expression | str) -> str:
 871        this_sql = (
 872            self.sql(expression)
 873            if isinstance(expression, exp.UNWRAPPED_QUERIES)
 874            else self.sql(expression, "this")
 875        )
 876        if not this_sql:
 877            return "()"
 878
 879        this_sql = self.indent(this_sql, level=1, pad=0)
 880        return f"({self.sep('')}{this_sql}{self.seg(')', sep='')}"
 881
 882    def no_identify(self, func: t.Callable[..., str], *args, **kwargs) -> str:
 883        original = self.identify
 884        self.identify = False
 885        result = func(*args, **kwargs)
 886        self.identify = original
 887        return result
 888
 889    def normalize_func(self, name: str) -> str:
 890        if self.normalize_functions == "upper" or self.normalize_functions is True:
 891            return name.upper()
 892        if self.normalize_functions == "lower":
 893            return name.lower()
 894        return name
 895
 896    def indent(
 897        self,
 898        sql: str,
 899        level: int = 0,
 900        pad: t.Optional[int] = None,
 901        skip_first: bool = False,
 902        skip_last: bool = False,
 903    ) -> str:
 904        if not self.pretty or not sql:
 905            return sql
 906
 907        pad = self.pad if pad is None else pad
 908        lines = sql.split("\n")
 909
 910        return "\n".join(
 911            (
 912                line
 913                if (skip_first and i == 0) or (skip_last and i == len(lines) - 1)
 914                else f"{' ' * (level * self._indent + pad)}{line}"
 915            )
 916            for i, line in enumerate(lines)
 917        )
 918
 919    def sql(
 920        self,
 921        expression: t.Optional[str | exp.Expression],
 922        key: t.Optional[str] = None,
 923        comment: bool = True,
 924    ) -> str:
 925        if not expression:
 926            return ""
 927
 928        if isinstance(expression, str):
 929            return expression
 930
 931        if key:
 932            value = expression.args.get(key)
 933            if value:
 934                return self.sql(value)
 935            return ""
 936
 937        transform = self.TRANSFORMS.get(expression.__class__)
 938
 939        if callable(transform):
 940            sql = transform(self, expression)
 941        elif isinstance(expression, exp.Expression):
 942            exp_handler_name = f"{expression.key}_sql"
 943
 944            if hasattr(self, exp_handler_name):
 945                sql = getattr(self, exp_handler_name)(expression)
 946            elif isinstance(expression, exp.Func):
 947                sql = self.function_fallback_sql(expression)
 948            elif isinstance(expression, exp.Property):
 949                sql = self.property_sql(expression)
 950            else:
 951                raise ValueError(f"Unsupported expression type {expression.__class__.__name__}")
 952        else:
 953            raise ValueError(f"Expected an Expression. Received {type(expression)}: {expression}")
 954
 955        return self.maybe_comment(sql, expression) if self.comments and comment else sql
 956
 957    def uncache_sql(self, expression: exp.Uncache) -> str:
 958        table = self.sql(expression, "this")
 959        exists_sql = " IF EXISTS" if expression.args.get("exists") else ""
 960        return f"UNCACHE TABLE{exists_sql} {table}"
 961
 962    def cache_sql(self, expression: exp.Cache) -> str:
 963        lazy = " LAZY" if expression.args.get("lazy") else ""
 964        table = self.sql(expression, "this")
 965        options = expression.args.get("options")
 966        options = f" OPTIONS({self.sql(options[0])} = {self.sql(options[1])})" if options else ""
 967        sql = self.sql(expression, "expression")
 968        sql = f" AS{self.sep()}{sql}" if sql else ""
 969        sql = f"CACHE{lazy} TABLE {table}{options}{sql}"
 970        return self.prepend_ctes(expression, sql)
 971
 972    def characterset_sql(self, expression: exp.CharacterSet) -> str:
 973        if isinstance(expression.parent, exp.Cast):
 974            return f"CHAR CHARACTER SET {self.sql(expression, 'this')}"
 975        default = "DEFAULT " if expression.args.get("default") else ""
 976        return f"{default}CHARACTER SET={self.sql(expression, 'this')}"
 977
 978    def column_parts(self, expression: exp.Column) -> str:
 979        return ".".join(
 980            self.sql(part)
 981            for part in (
 982                expression.args.get("catalog"),
 983                expression.args.get("db"),
 984                expression.args.get("table"),
 985                expression.args.get("this"),
 986            )
 987            if part
 988        )
 989
 990    def column_sql(self, expression: exp.Column) -> str:
 991        join_mark = " (+)" if expression.args.get("join_mark") else ""
 992
 993        if join_mark and not self.dialect.SUPPORTS_COLUMN_JOIN_MARKS:
 994            join_mark = ""
 995            self.unsupported("Outer join syntax using the (+) operator is not supported.")
 996
 997        return f"{self.column_parts(expression)}{join_mark}"
 998
 999    def columnposition_sql(self, expression: exp.ColumnPosition) -> str:
1000        this = self.sql(expression, "this")
1001        this = f" {this}" if this else ""
1002        position = self.sql(expression, "position")
1003        return f"{position}{this}"
1004
1005    def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
1006        column = self.sql(expression, "this")
1007        kind = self.sql(expression, "kind")
1008        constraints = self.expressions(expression, key="constraints", sep=" ", flat=True)
1009        exists = "IF NOT EXISTS " if expression.args.get("exists") else ""
1010        kind = f"{sep}{kind}" if kind else ""
1011        constraints = f" {constraints}" if constraints else ""
1012        position = self.sql(expression, "position")
1013        position = f" {position}" if position else ""
1014
1015        if expression.find(exp.ComputedColumnConstraint) and not self.COMPUTED_COLUMN_WITH_TYPE:
1016            kind = ""
1017
1018        return f"{exists}{column}{kind}{constraints}{position}"
1019
1020    def columnconstraint_sql(self, expression: exp.ColumnConstraint) -> str:
1021        this = self.sql(expression, "this")
1022        kind_sql = self.sql(expression, "kind").strip()
1023        return f"CONSTRAINT {this} {kind_sql}" if this else kind_sql
1024
1025    def computedcolumnconstraint_sql(self, expression: exp.ComputedColumnConstraint) -> str:
1026        this = self.sql(expression, "this")
1027        if expression.args.get("not_null"):
1028            persisted = " PERSISTED NOT NULL"
1029        elif expression.args.get("persisted"):
1030            persisted = " PERSISTED"
1031        else:
1032            persisted = ""
1033
1034        return f"AS {this}{persisted}"
1035
1036    def autoincrementcolumnconstraint_sql(self, _) -> str:
1037        return self.token_sql(TokenType.AUTO_INCREMENT)
1038
1039    def compresscolumnconstraint_sql(self, expression: exp.CompressColumnConstraint) -> str:
1040        if isinstance(expression.this, list):
1041            this = self.wrap(self.expressions(expression, key="this", flat=True))
1042        else:
1043            this = self.sql(expression, "this")
1044
1045        return f"COMPRESS {this}"
1046
1047    def generatedasidentitycolumnconstraint_sql(
1048        self, expression: exp.GeneratedAsIdentityColumnConstraint
1049    ) -> str:
1050        this = ""
1051        if expression.this is not None:
1052            on_null = " ON NULL" if expression.args.get("on_null") else ""
1053            this = " ALWAYS" if expression.this else f" BY DEFAULT{on_null}"
1054
1055        start = expression.args.get("start")
1056        start = f"START WITH {start}" if start else ""
1057        increment = expression.args.get("increment")
1058        increment = f" INCREMENT BY {increment}" if increment else ""
1059        minvalue = expression.args.get("minvalue")
1060        minvalue = f" MINVALUE {minvalue}" if minvalue else ""
1061        maxvalue = expression.args.get("maxvalue")
1062        maxvalue = f" MAXVALUE {maxvalue}" if maxvalue else ""
1063        cycle = expression.args.get("cycle")
1064        cycle_sql = ""
1065
1066        if cycle is not None:
1067            cycle_sql = f"{' NO' if not cycle else ''} CYCLE"
1068            cycle_sql = cycle_sql.strip() if not start and not increment else cycle_sql
1069
1070        sequence_opts = ""
1071        if start or increment or cycle_sql:
1072            sequence_opts = f"{start}{increment}{minvalue}{maxvalue}{cycle_sql}"
1073            sequence_opts = f" ({sequence_opts.strip()})"
1074
1075        expr = self.sql(expression, "expression")
1076        expr = f"({expr})" if expr else "IDENTITY"
1077
1078        return f"GENERATED{this} AS {expr}{sequence_opts}"
1079
1080    def generatedasrowcolumnconstraint_sql(
1081        self, expression: exp.GeneratedAsRowColumnConstraint
1082    ) -> str:
1083        start = "START" if expression.args.get("start") else "END"
1084        hidden = " HIDDEN" if expression.args.get("hidden") else ""
1085        return f"GENERATED ALWAYS AS ROW {start}{hidden}"
1086
1087    def periodforsystemtimeconstraint_sql(
1088        self, expression: exp.PeriodForSystemTimeConstraint
1089    ) -> str:
1090        return f"PERIOD FOR SYSTEM_TIME ({self.sql(expression, 'this')}, {self.sql(expression, 'expression')})"
1091
1092    def notnullcolumnconstraint_sql(self, expression: exp.NotNullColumnConstraint) -> str:
1093        return f"{'' if expression.args.get('allow_null') else 'NOT '}NULL"
1094
1095    def primarykeycolumnconstraint_sql(self, expression: exp.PrimaryKeyColumnConstraint) -> str:
1096        desc = expression.args.get("desc")
1097        if desc is not None:
1098            return f"PRIMARY KEY{' DESC' if desc else ' ASC'}"
1099        options = self.expressions(expression, key="options", flat=True, sep=" ")
1100        options = f" {options}" if options else ""
1101        return f"PRIMARY KEY{options}"
1102
1103    def uniquecolumnconstraint_sql(self, expression: exp.UniqueColumnConstraint) -> str:
1104        this = self.sql(expression, "this")
1105        this = f" {this}" if this else ""
1106        index_type = expression.args.get("index_type")
1107        index_type = f" USING {index_type}" if index_type else ""
1108        on_conflict = self.sql(expression, "on_conflict")
1109        on_conflict = f" {on_conflict}" if on_conflict else ""
1110        nulls_sql = " NULLS NOT DISTINCT" if expression.args.get("nulls") else ""
1111        options = self.expressions(expression, key="options", flat=True, sep=" ")
1112        options = f" {options}" if options else ""
1113        return f"UNIQUE{nulls_sql}{this}{index_type}{on_conflict}{options}"
1114
1115    def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
1116        return self.sql(expression, "this")
1117
1118    def create_sql(self, expression: exp.Create) -> str:
1119        kind = self.sql(expression, "kind")
1120        kind = self.dialect.INVERSE_CREATABLE_KIND_MAPPING.get(kind) or kind
1121        properties = expression.args.get("properties")
1122        properties_locs = self.locate_properties(properties) if properties else defaultdict()
1123
1124        this = self.createable_sql(expression, properties_locs)
1125
1126        properties_sql = ""
1127        if properties_locs.get(exp.Properties.Location.POST_SCHEMA) or properties_locs.get(
1128            exp.Properties.Location.POST_WITH
1129        ):
1130            properties_sql = self.sql(
1131                exp.Properties(
1132                    expressions=[
1133                        *properties_locs[exp.Properties.Location.POST_SCHEMA],
1134                        *properties_locs[exp.Properties.Location.POST_WITH],
1135                    ]
1136                )
1137            )
1138
1139            if properties_locs.get(exp.Properties.Location.POST_SCHEMA):
1140                properties_sql = self.sep() + properties_sql
1141            elif not self.pretty:
1142                # Standalone POST_WITH properties need a leading whitespace in non-pretty mode
1143                properties_sql = f" {properties_sql}"
1144
1145        begin = " BEGIN" if expression.args.get("begin") else ""
1146        end = " END" if expression.args.get("end") else ""
1147
1148        expression_sql = self.sql(expression, "expression")
1149        if expression_sql:
1150            expression_sql = f"{begin}{self.sep()}{expression_sql}{end}"
1151
1152            if self.CREATE_FUNCTION_RETURN_AS or not isinstance(expression.expression, exp.Return):
1153                postalias_props_sql = ""
1154                if properties_locs.get(exp.Properties.Location.POST_ALIAS):
1155                    postalias_props_sql = self.properties(
1156                        exp.Properties(
1157                            expressions=properties_locs[exp.Properties.Location.POST_ALIAS]
1158                        ),
1159                        wrapped=False,
1160                    )
1161                postalias_props_sql = f" {postalias_props_sql}" if postalias_props_sql else ""
1162                expression_sql = f" AS{postalias_props_sql}{expression_sql}"
1163
1164        postindex_props_sql = ""
1165        if properties_locs.get(exp.Properties.Location.POST_INDEX):
1166            postindex_props_sql = self.properties(
1167                exp.Properties(expressions=properties_locs[exp.Properties.Location.POST_INDEX]),
1168                wrapped=False,
1169                prefix=" ",
1170            )
1171
1172        indexes = self.expressions(expression, key="indexes", indent=False, sep=" ")
1173        indexes = f" {indexes}" if indexes else ""
1174        index_sql = indexes + postindex_props_sql
1175
1176        replace = " OR REPLACE" if expression.args.get("replace") else ""
1177        refresh = " OR REFRESH" if expression.args.get("refresh") else ""
1178        unique = " UNIQUE" if expression.args.get("unique") else ""
1179
1180        clustered = expression.args.get("clustered")
1181        if clustered is None:
1182            clustered_sql = ""
1183        elif clustered:
1184            clustered_sql = " CLUSTERED COLUMNSTORE"
1185        else:
1186            clustered_sql = " NONCLUSTERED COLUMNSTORE"
1187
1188        postcreate_props_sql = ""
1189        if properties_locs.get(exp.Properties.Location.POST_CREATE):
1190            postcreate_props_sql = self.properties(
1191                exp.Properties(expressions=properties_locs[exp.Properties.Location.POST_CREATE]),
1192                sep=" ",
1193                prefix=" ",
1194                wrapped=False,
1195            )
1196
1197        modifiers = "".join((clustered_sql, replace, refresh, unique, postcreate_props_sql))
1198
1199        postexpression_props_sql = ""
1200        if properties_locs.get(exp.Properties.Location.POST_EXPRESSION):
1201            postexpression_props_sql = self.properties(
1202                exp.Properties(
1203                    expressions=properties_locs[exp.Properties.Location.POST_EXPRESSION]
1204                ),
1205                sep=" ",
1206                prefix=" ",
1207                wrapped=False,
1208            )
1209
1210        concurrently = " CONCURRENTLY" if expression.args.get("concurrently") else ""
1211        exists_sql = " IF NOT EXISTS" if expression.args.get("exists") else ""
1212        no_schema_binding = (
1213            " WITH NO SCHEMA BINDING" if expression.args.get("no_schema_binding") else ""
1214        )
1215
1216        clone = self.sql(expression, "clone")
1217        clone = f" {clone}" if clone else ""
1218
1219        if kind in self.EXPRESSION_PRECEDES_PROPERTIES_CREATABLES:
1220            properties_expression = f"{expression_sql}{properties_sql}"
1221        else:
1222            properties_expression = f"{properties_sql}{expression_sql}"
1223
1224        expression_sql = f"CREATE{modifiers} {kind}{concurrently}{exists_sql} {this}{properties_expression}{postexpression_props_sql}{index_sql}{no_schema_binding}{clone}"
1225        return self.prepend_ctes(expression, expression_sql)
1226
1227    def sequenceproperties_sql(self, expression: exp.SequenceProperties) -> str:
1228        start = self.sql(expression, "start")
1229        start = f"START WITH {start}" if start else ""
1230        increment = self.sql(expression, "increment")
1231        increment = f" INCREMENT BY {increment}" if increment else ""
1232        minvalue = self.sql(expression, "minvalue")
1233        minvalue = f" MINVALUE {minvalue}" if minvalue else ""
1234        maxvalue = self.sql(expression, "maxvalue")
1235        maxvalue = f" MAXVALUE {maxvalue}" if maxvalue else ""
1236        owned = self.sql(expression, "owned")
1237        owned = f" OWNED BY {owned}" if owned else ""
1238
1239        cache = expression.args.get("cache")
1240        if cache is None:
1241            cache_str = ""
1242        elif cache is True:
1243            cache_str = " CACHE"
1244        else:
1245            cache_str = f" CACHE {cache}"
1246
1247        options = self.expressions(expression, key="options", flat=True, sep=" ")
1248        options = f" {options}" if options else ""
1249
1250        return f"{start}{increment}{minvalue}{maxvalue}{cache_str}{options}{owned}".lstrip()
1251
1252    def clone_sql(self, expression: exp.Clone) -> str:
1253        this = self.sql(expression, "this")
1254        shallow = "SHALLOW " if expression.args.get("shallow") else ""
1255        keyword = "COPY" if expression.args.get("copy") and self.SUPPORTS_TABLE_COPY else "CLONE"
1256        return f"{shallow}{keyword} {this}"
1257
1258    def describe_sql(self, expression: exp.Describe) -> str:
1259        style = expression.args.get("style")
1260        style = f" {style}" if style else ""
1261        partition = self.sql(expression, "partition")
1262        partition = f" {partition}" if partition else ""
1263        format = self.sql(expression, "format")
1264        format = f" {format}" if format else ""
1265
1266        return f"DESCRIBE{style}{format} {self.sql(expression, 'this')}{partition}"
1267
1268    def heredoc_sql(self, expression: exp.Heredoc) -> str:
1269        tag = self.sql(expression, "tag")
1270        return f"${tag}${self.sql(expression, 'this')}${tag}$"
1271
1272    def prepend_ctes(self, expression: exp.Expression, sql: str) -> str:
1273        with_ = self.sql(expression, "with")
1274        if with_:
1275            sql = f"{with_}{self.sep()}{sql}"
1276        return sql
1277
1278    def with_sql(self, expression: exp.With) -> str:
1279        sql = self.expressions(expression, flat=True)
1280        recursive = (
1281            "RECURSIVE "
1282            if self.CTE_RECURSIVE_KEYWORD_REQUIRED and expression.args.get("recursive")
1283            else ""
1284        )
1285        search = self.sql(expression, "search")
1286        search = f" {search}" if search else ""
1287
1288        return f"WITH {recursive}{sql}{search}"
1289
1290    def cte_sql(self, expression: exp.CTE) -> str:
1291        alias = expression.args.get("alias")
1292        if alias:
1293            alias.add_comments(expression.pop_comments())
1294
1295        alias_sql = self.sql(expression, "alias")
1296
1297        materialized = expression.args.get("materialized")
1298        if materialized is False:
1299            materialized = "NOT MATERIALIZED "
1300        elif materialized:
1301            materialized = "MATERIALIZED "
1302
1303        return f"{alias_sql} AS {materialized or ''}{self.wrap(expression)}"
1304
1305    def tablealias_sql(self, expression: exp.TableAlias) -> str:
1306        alias = self.sql(expression, "this")
1307        columns = self.expressions(expression, key="columns", flat=True)
1308        columns = f"({columns})" if columns else ""
1309
1310        if columns and not self.SUPPORTS_TABLE_ALIAS_COLUMNS:
1311            columns = ""
1312            self.unsupported("Named columns are not supported in table alias.")
1313
1314        if not alias and not self.dialect.UNNEST_COLUMN_ONLY:
1315            alias = self._next_name()
1316
1317        return f"{alias}{columns}"
1318
1319    def bitstring_sql(self, expression: exp.BitString) -> str:
1320        this = self.sql(expression, "this")
1321        if self.dialect.BIT_START:
1322            return f"{self.dialect.BIT_START}{this}{self.dialect.BIT_END}"
1323        return f"{int(this, 2)}"
1324
1325    def hexstring_sql(
1326        self, expression: exp.HexString, binary_function_repr: t.Optional[str] = None
1327    ) -> str:
1328        this = self.sql(expression, "this")
1329        is_integer_type = expression.args.get("is_integer")
1330
1331        if (is_integer_type and not self.dialect.HEX_STRING_IS_INTEGER_TYPE) or (
1332            not self.dialect.HEX_START and not binary_function_repr
1333        ):
1334            # Integer representation will be returned if:
1335            # - The read dialect treats the hex value as integer literal but not the write
1336            # - The transpilation is not supported (write dialect hasn't set HEX_START or the param flag)
1337            return f"{int(this, 16)}"
1338
1339        if not is_integer_type:
1340            # Read dialect treats the hex value as BINARY/BLOB
1341            if binary_function_repr:
1342                # The write dialect supports the transpilation to its equivalent BINARY/BLOB
1343                return self.func(binary_function_repr, exp.Literal.string(this))
1344            if self.dialect.HEX_STRING_IS_INTEGER_TYPE:
1345                # The write dialect does not support the transpilation, it'll treat the hex value as INTEGER
1346                self.unsupported("Unsupported transpilation from BINARY/BLOB hex string")
1347
1348        return f"{self.dialect.HEX_START}{this}{self.dialect.HEX_END}"
1349
1350    def bytestring_sql(self, expression: exp.ByteString) -> str:
1351        this = self.sql(expression, "this")
1352        if self.dialect.BYTE_START:
1353            return f"{self.dialect.BYTE_START}{this}{self.dialect.BYTE_END}"
1354        return this
1355
1356    def unicodestring_sql(self, expression: exp.UnicodeString) -> str:
1357        this = self.sql(expression, "this")
1358        escape = expression.args.get("escape")
1359
1360        if self.dialect.UNICODE_START:
1361            escape_substitute = r"\\\1"
1362            left_quote, right_quote = self.dialect.UNICODE_START, self.dialect.UNICODE_END
1363        else:
1364            escape_substitute = r"\\u\1"
1365            left_quote, right_quote = self.dialect.QUOTE_START, self.dialect.QUOTE_END
1366
1367        if escape:
1368            escape_pattern = re.compile(rf"{escape.name}(\d+)")
1369            escape_sql = f" UESCAPE {self.sql(escape)}" if self.SUPPORTS_UESCAPE else ""
1370        else:
1371            escape_pattern = ESCAPED_UNICODE_RE
1372            escape_sql = ""
1373
1374        if not self.dialect.UNICODE_START or (escape and not self.SUPPORTS_UESCAPE):
1375            this = escape_pattern.sub(escape_substitute, this)
1376
1377        return f"{left_quote}{this}{right_quote}{escape_sql}"
1378
1379    def rawstring_sql(self, expression: exp.RawString) -> str:
1380        string = expression.this
1381        if "\\" in self.dialect.tokenizer_class.STRING_ESCAPES:
1382            string = string.replace("\\", "\\\\")
1383
1384        string = self.escape_str(string, escape_backslash=False)
1385        return f"{self.dialect.QUOTE_START}{string}{self.dialect.QUOTE_END}"
1386
1387    def datatypeparam_sql(self, expression: exp.DataTypeParam) -> str:
1388        this = self.sql(expression, "this")
1389        specifier = self.sql(expression, "expression")
1390        specifier = f" {specifier}" if specifier and self.DATA_TYPE_SPECIFIERS_ALLOWED else ""
1391        return f"{this}{specifier}"
1392
1393    def datatype_sql(self, expression: exp.DataType) -> str:
1394        nested = ""
1395        values = ""
1396        interior = self.expressions(expression, flat=True)
1397
1398        type_value = expression.this
1399        if type_value == exp.DataType.Type.USERDEFINED and expression.args.get("kind"):
1400            type_sql = self.sql(expression, "kind")
1401        else:
1402            type_sql = (
1403                self.TYPE_MAPPING.get(type_value, type_value.value)
1404                if isinstance(type_value, exp.DataType.Type)
1405                else type_value
1406            )
1407
1408        if interior:
1409            if expression.args.get("nested"):
1410                nested = f"{self.STRUCT_DELIMITER[0]}{interior}{self.STRUCT_DELIMITER[1]}"
1411                if expression.args.get("values") is not None:
1412                    delimiters = ("[", "]") if type_value == exp.DataType.Type.ARRAY else ("(", ")")
1413                    values = self.expressions(expression, key="values", flat=True)
1414                    values = f"{delimiters[0]}{values}{delimiters[1]}"
1415            elif type_value == exp.DataType.Type.INTERVAL:
1416                nested = f" {interior}"
1417            else:
1418                nested = f"({interior})"
1419
1420        type_sql = f"{type_sql}{nested}{values}"
1421        if self.TZ_TO_WITH_TIME_ZONE and type_value in (
1422            exp.DataType.Type.TIMETZ,
1423            exp.DataType.Type.TIMESTAMPTZ,
1424        ):
1425            type_sql = f"{type_sql} WITH TIME ZONE"
1426
1427        return type_sql
1428
1429    def directory_sql(self, expression: exp.Directory) -> str:
1430        local = "LOCAL " if expression.args.get("local") else ""
1431        row_format = self.sql(expression, "row_format")
1432        row_format = f" {row_format}" if row_format else ""
1433        return f"{local}DIRECTORY {self.sql(expression, 'this')}{row_format}"
1434
1435    def delete_sql(self, expression: exp.Delete) -> str:
1436        this = self.sql(expression, "this")
1437        this = f" FROM {this}" if this else ""
1438        using = self.sql(expression, "using")
1439        using = f" USING {using}" if using else ""
1440        cluster = self.sql(expression, "cluster")
1441        cluster = f" {cluster}" if cluster else ""
1442        where = self.sql(expression, "where")
1443        returning = self.sql(expression, "returning")
1444        limit = self.sql(expression, "limit")
1445        tables = self.expressions(expression, key="tables")
1446        tables = f" {tables}" if tables else ""
1447        if self.RETURNING_END:
1448            expression_sql = f"{this}{using}{cluster}{where}{returning}{limit}"
1449        else:
1450            expression_sql = f"{returning}{this}{using}{cluster}{where}{limit}"
1451        return self.prepend_ctes(expression, f"DELETE{tables}{expression_sql}")
1452
1453    def drop_sql(self, expression: exp.Drop) -> str:
1454        this = self.sql(expression, "this")
1455        expressions = self.expressions(expression, flat=True)
1456        expressions = f" ({expressions})" if expressions else ""
1457        kind = expression.args["kind"]
1458        kind = self.dialect.INVERSE_CREATABLE_KIND_MAPPING.get(kind) or kind
1459        exists_sql = " IF EXISTS " if expression.args.get("exists") else " "
1460        concurrently_sql = " CONCURRENTLY" if expression.args.get("concurrently") else ""
1461        on_cluster = self.sql(expression, "cluster")
1462        on_cluster = f" {on_cluster}" if on_cluster else ""
1463        temporary = " TEMPORARY" if expression.args.get("temporary") else ""
1464        materialized = " MATERIALIZED" if expression.args.get("materialized") else ""
1465        cascade = " CASCADE" if expression.args.get("cascade") else ""
1466        constraints = " CONSTRAINTS" if expression.args.get("constraints") else ""
1467        purge = " PURGE" if expression.args.get("purge") else ""
1468        return f"DROP{temporary}{materialized} {kind}{concurrently_sql}{exists_sql}{this}{on_cluster}{expressions}{cascade}{constraints}{purge}"
1469
1470    def set_operation(self, expression: exp.SetOperation) -> str:
1471        op_type = type(expression)
1472        op_name = op_type.key.upper()
1473
1474        distinct = expression.args.get("distinct")
1475        if (
1476            distinct is False
1477            and op_type in (exp.Except, exp.Intersect)
1478            and not self.EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE
1479        ):
1480            self.unsupported(f"{op_name} ALL is not supported")
1481
1482        default_distinct = self.dialect.SET_OP_DISTINCT_BY_DEFAULT[op_type]
1483
1484        if distinct is None:
1485            distinct = default_distinct
1486            if distinct is None:
1487                self.unsupported(f"{op_name} requires DISTINCT or ALL to be specified")
1488
1489        if distinct is default_distinct:
1490            distinct_or_all = ""
1491        else:
1492            distinct_or_all = " DISTINCT" if distinct else " ALL"
1493
1494        side_kind = " ".join(filter(None, [expression.side, expression.kind]))
1495        side_kind = f"{side_kind} " if side_kind else ""
1496
1497        by_name = " BY NAME" if expression.args.get("by_name") else ""
1498        on = self.expressions(expression, key="on", flat=True)
1499        on = f" ON ({on})" if on else ""
1500
1501        return f"{side_kind}{op_name}{distinct_or_all}{by_name}{on}"
1502
1503    def set_operations(self, expression: exp.SetOperation) -> str:
1504        if not self.SET_OP_MODIFIERS:
1505            limit = expression.args.get("limit")
1506            order = expression.args.get("order")
1507
1508            if limit or order:
1509                select = self._move_ctes_to_top_level(
1510                    exp.subquery(expression, "_l_0", copy=False).select("*", copy=False)
1511                )
1512
1513                if limit:
1514                    select = select.limit(limit.pop(), copy=False)
1515                if order:
1516                    select = select.order_by(order.pop(), copy=False)
1517                return self.sql(select)
1518
1519        sqls: t.List[str] = []
1520        stack: t.List[t.Union[str, exp.Expression]] = [expression]
1521
1522        while stack:
1523            node = stack.pop()
1524
1525            if isinstance(node, exp.SetOperation):
1526                stack.append(node.expression)
1527                stack.append(
1528                    self.maybe_comment(
1529                        self.set_operation(node), comments=node.comments, separated=True
1530                    )
1531                )
1532                stack.append(node.this)
1533            else:
1534                sqls.append(self.sql(node))
1535
1536        this = self.sep().join(sqls)
1537        this = self.query_modifiers(expression, this)
1538        return self.prepend_ctes(expression, this)
1539
1540    def fetch_sql(self, expression: exp.Fetch) -> str:
1541        direction = expression.args.get("direction")
1542        direction = f" {direction}" if direction else ""
1543        count = self.sql(expression, "count")
1544        count = f" {count}" if count else ""
1545        limit_options = self.sql(expression, "limit_options")
1546        limit_options = f"{limit_options}" if limit_options else " ROWS ONLY"
1547        return f"{self.seg('FETCH')}{direction}{count}{limit_options}"
1548
1549    def limitoptions_sql(self, expression: exp.LimitOptions) -> str:
1550        percent = " PERCENT" if expression.args.get("percent") else ""
1551        rows = " ROWS" if expression.args.get("rows") else ""
1552        with_ties = " WITH TIES" if expression.args.get("with_ties") else ""
1553        if not with_ties and rows:
1554            with_ties = " ONLY"
1555        return f"{percent}{rows}{with_ties}"
1556
1557    def filter_sql(self, expression: exp.Filter) -> str:
1558        if self.AGGREGATE_FILTER_SUPPORTED:
1559            this = self.sql(expression, "this")
1560            where = self.sql(expression, "expression").strip()
1561            return f"{this} FILTER({where})"
1562
1563        agg = expression.this
1564        agg_arg = agg.this
1565        cond = expression.expression.this
1566        agg_arg.replace(exp.If(this=cond.copy(), true=agg_arg.copy()))
1567        return self.sql(agg)
1568
1569    def hint_sql(self, expression: exp.Hint) -> str:
1570        if not self.QUERY_HINTS:
1571            self.unsupported("Hints are not supported")
1572            return ""
1573
1574        return f" /*+ {self.expressions(expression, sep=self.QUERY_HINT_SEP).strip()} */"
1575
1576    def indexparameters_sql(self, expression: exp.IndexParameters) -> str:
1577        using = self.sql(expression, "using")
1578        using = f" USING {using}" if using else ""
1579        columns = self.expressions(expression, key="columns", flat=True)
1580        columns = f"({columns})" if columns else ""
1581        partition_by = self.expressions(expression, key="partition_by", flat=True)
1582        partition_by = f" PARTITION BY {partition_by}" if partition_by else ""
1583        where = self.sql(expression, "where")
1584        include = self.expressions(expression, key="include", flat=True)
1585        if include:
1586            include = f" INCLUDE ({include})"
1587        with_storage = self.expressions(expression, key="with_storage", flat=True)
1588        with_storage = f" WITH ({with_storage})" if with_storage else ""
1589        tablespace = self.sql(expression, "tablespace")
1590        tablespace = f" USING INDEX TABLESPACE {tablespace}" if tablespace else ""
1591        on = self.sql(expression, "on")
1592        on = f" ON {on}" if on else ""
1593
1594        return f"{using}{columns}{include}{with_storage}{tablespace}{partition_by}{where}{on}"
1595
1596    def index_sql(self, expression: exp.Index) -> str:
1597        unique = "UNIQUE " if expression.args.get("unique") else ""
1598        primary = "PRIMARY " if expression.args.get("primary") else ""
1599        amp = "AMP " if expression.args.get("amp") else ""
1600        name = self.sql(expression, "this")
1601        name = f"{name} " if name else ""
1602        table = self.sql(expression, "table")
1603        table = f"{self.INDEX_ON} {table}" if table else ""
1604
1605        index = "INDEX " if not table else ""
1606
1607        params = self.sql(expression, "params")
1608        return f"{unique}{primary}{amp}{index}{name}{table}{params}"
1609
1610    def identifier_sql(self, expression: exp.Identifier) -> str:
1611        text = expression.name
1612        lower = text.lower()
1613        text = lower if self.normalize and not expression.quoted else text
1614        text = text.replace(self._identifier_end, self._escaped_identifier_end)
1615        if (
1616            expression.quoted
1617            or self.dialect.can_identify(text, self.identify)
1618            or lower in self.RESERVED_KEYWORDS
1619            or (not self.dialect.IDENTIFIERS_CAN_START_WITH_DIGIT and text[:1].isdigit())
1620        ):
1621            text = f"{self._identifier_start}{text}{self._identifier_end}"
1622        return text
1623
1624    def hex_sql(self, expression: exp.Hex) -> str:
1625        text = self.func(self.HEX_FUNC, self.sql(expression, "this"))
1626        if self.dialect.HEX_LOWERCASE:
1627            text = self.func("LOWER", text)
1628
1629        return text
1630
1631    def lowerhex_sql(self, expression: exp.LowerHex) -> str:
1632        text = self.func(self.HEX_FUNC, self.sql(expression, "this"))
1633        if not self.dialect.HEX_LOWERCASE:
1634            text = self.func("LOWER", text)
1635        return text
1636
1637    def inputoutputformat_sql(self, expression: exp.InputOutputFormat) -> str:
1638        input_format = self.sql(expression, "input_format")
1639        input_format = f"INPUTFORMAT {input_format}" if input_format else ""
1640        output_format = self.sql(expression, "output_format")
1641        output_format = f"OUTPUTFORMAT {output_format}" if output_format else ""
1642        return self.sep().join((input_format, output_format))
1643
1644    def national_sql(self, expression: exp.National, prefix: str = "N") -> str:
1645        string = self.sql(exp.Literal.string(expression.name))
1646        return f"{prefix}{string}"
1647
1648    def partition_sql(self, expression: exp.Partition) -> str:
1649        partition_keyword = "SUBPARTITION" if expression.args.get("subpartition") else "PARTITION"
1650        return f"{partition_keyword}({self.expressions(expression, flat=True)})"
1651
1652    def properties_sql(self, expression: exp.Properties) -> str:
1653        root_properties = []
1654        with_properties = []
1655
1656        for p in expression.expressions:
1657            p_loc = self.PROPERTIES_LOCATION[p.__class__]
1658            if p_loc == exp.Properties.Location.POST_WITH:
1659                with_properties.append(p)
1660            elif p_loc == exp.Properties.Location.POST_SCHEMA:
1661                root_properties.append(p)
1662
1663        root_props = self.root_properties(exp.Properties(expressions=root_properties))
1664        with_props = self.with_properties(exp.Properties(expressions=with_properties))
1665
1666        if root_props and with_props and not self.pretty:
1667            with_props = " " + with_props
1668
1669        return root_props + with_props
1670
1671    def root_properties(self, properties: exp.Properties) -> str:
1672        if properties.expressions:
1673            return self.expressions(properties, indent=False, sep=" ")
1674        return ""
1675
1676    def properties(
1677        self,
1678        properties: exp.Properties,
1679        prefix: str = "",
1680        sep: str = ", ",
1681        suffix: str = "",
1682        wrapped: bool = True,
1683    ) -> str:
1684        if properties.expressions:
1685            expressions = self.expressions(properties, sep=sep, indent=False)
1686            if expressions:
1687                expressions = self.wrap(expressions) if wrapped else expressions
1688                return f"{prefix}{' ' if prefix.strip() else ''}{expressions}{suffix}"
1689        return ""
1690
1691    def with_properties(self, properties: exp.Properties) -> str:
1692        return self.properties(properties, prefix=self.seg(self.WITH_PROPERTIES_PREFIX, sep=""))
1693
1694    def locate_properties(self, properties: exp.Properties) -> t.DefaultDict:
1695        properties_locs = defaultdict(list)
1696        for p in properties.expressions:
1697            p_loc = self.PROPERTIES_LOCATION[p.__class__]
1698            if p_loc != exp.Properties.Location.UNSUPPORTED:
1699                properties_locs[p_loc].append(p)
1700            else:
1701                self.unsupported(f"Unsupported property {p.key}")
1702
1703        return properties_locs
1704
1705    def property_name(self, expression: exp.Property, string_key: bool = False) -> str:
1706        if isinstance(expression.this, exp.Dot):
1707            return self.sql(expression, "this")
1708        return f"'{expression.name}'" if string_key else expression.name
1709
1710    def property_sql(self, expression: exp.Property) -> str:
1711        property_cls = expression.__class__
1712        if property_cls == exp.Property:
1713            return f"{self.property_name(expression)}={self.sql(expression, 'value')}"
1714
1715        property_name = exp.Properties.PROPERTY_TO_NAME.get(property_cls)
1716        if not property_name:
1717            self.unsupported(f"Unsupported property {expression.key}")
1718
1719        return f"{property_name}={self.sql(expression, 'this')}"
1720
1721    def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
1722        if self.SUPPORTS_CREATE_TABLE_LIKE:
1723            options = " ".join(f"{e.name} {self.sql(e, 'value')}" for e in expression.expressions)
1724            options = f" {options}" if options else ""
1725
1726            like = f"LIKE {self.sql(expression, 'this')}{options}"
1727            if self.LIKE_PROPERTY_INSIDE_SCHEMA and not isinstance(expression.parent, exp.Schema):
1728                like = f"({like})"
1729
1730            return like
1731
1732        if expression.expressions:
1733            self.unsupported("Transpilation of LIKE property options is unsupported")
1734
1735        select = exp.select("*").from_(expression.this).limit(0)
1736        return f"AS {self.sql(select)}"
1737
1738    def fallbackproperty_sql(self, expression: exp.FallbackProperty) -> str:
1739        no = "NO " if expression.args.get("no") else ""
1740        protection = " PROTECTION" if expression.args.get("protection") else ""
1741        return f"{no}FALLBACK{protection}"
1742
1743    def journalproperty_sql(self, expression: exp.JournalProperty) -> str:
1744        no = "NO " if expression.args.get("no") else ""
1745        local = expression.args.get("local")
1746        local = f"{local} " if local else ""
1747        dual = "DUAL " if expression.args.get("dual") else ""
1748        before = "BEFORE " if expression.args.get("before") else ""
1749        after = "AFTER " if expression.args.get("after") else ""
1750        return f"{no}{local}{dual}{before}{after}JOURNAL"
1751
1752    def freespaceproperty_sql(self, expression: exp.FreespaceProperty) -> str:
1753        freespace = self.sql(expression, "this")
1754        percent = " PERCENT" if expression.args.get("percent") else ""
1755        return f"FREESPACE={freespace}{percent}"
1756
1757    def checksumproperty_sql(self, expression: exp.ChecksumProperty) -> str:
1758        if expression.args.get("default"):
1759            property = "DEFAULT"
1760        elif expression.args.get("on"):
1761            property = "ON"
1762        else:
1763            property = "OFF"
1764        return f"CHECKSUM={property}"
1765
1766    def mergeblockratioproperty_sql(self, expression: exp.MergeBlockRatioProperty) -> str:
1767        if expression.args.get("no"):
1768            return "NO MERGEBLOCKRATIO"
1769        if expression.args.get("default"):
1770            return "DEFAULT MERGEBLOCKRATIO"
1771
1772        percent = " PERCENT" if expression.args.get("percent") else ""
1773        return f"MERGEBLOCKRATIO={self.sql(expression, 'this')}{percent}"
1774
1775    def datablocksizeproperty_sql(self, expression: exp.DataBlocksizeProperty) -> str:
1776        default = expression.args.get("default")
1777        minimum = expression.args.get("minimum")
1778        maximum = expression.args.get("maximum")
1779        if default or minimum or maximum:
1780            if default:
1781                prop = "DEFAULT"
1782            elif minimum:
1783                prop = "MINIMUM"
1784            else:
1785                prop = "MAXIMUM"
1786            return f"{prop} DATABLOCKSIZE"
1787        units = expression.args.get("units")
1788        units = f" {units}" if units else ""
1789        return f"DATABLOCKSIZE={self.sql(expression, 'size')}{units}"
1790
1791    def blockcompressionproperty_sql(self, expression: exp.BlockCompressionProperty) -> str:
1792        autotemp = expression.args.get("autotemp")
1793        always = expression.args.get("always")
1794        default = expression.args.get("default")
1795        manual = expression.args.get("manual")
1796        never = expression.args.get("never")
1797
1798        if autotemp is not None:
1799            prop = f"AUTOTEMP({self.expressions(autotemp)})"
1800        elif always:
1801            prop = "ALWAYS"
1802        elif default:
1803            prop = "DEFAULT"
1804        elif manual:
1805            prop = "MANUAL"
1806        elif never:
1807            prop = "NEVER"
1808        return f"BLOCKCOMPRESSION={prop}"
1809
1810    def isolatedloadingproperty_sql(self, expression: exp.IsolatedLoadingProperty) -> str:
1811        no = expression.args.get("no")
1812        no = " NO" if no else ""
1813        concurrent = expression.args.get("concurrent")
1814        concurrent = " CONCURRENT" if concurrent else ""
1815        target = self.sql(expression, "target")
1816        target = f" {target}" if target else ""
1817        return f"WITH{no}{concurrent} ISOLATED LOADING{target}"
1818
1819    def partitionboundspec_sql(self, expression: exp.PartitionBoundSpec) -> str:
1820        if isinstance(expression.this, list):
1821            return f"IN ({self.expressions(expression, key='this', flat=True)})"
1822        if expression.this:
1823            modulus = self.sql(expression, "this")
1824            remainder = self.sql(expression, "expression")
1825            return f"WITH (MODULUS {modulus}, REMAINDER {remainder})"
1826
1827        from_expressions = self.expressions(expression, key="from_expressions", flat=True)
1828        to_expressions = self.expressions(expression, key="to_expressions", flat=True)
1829        return f"FROM ({from_expressions}) TO ({to_expressions})"
1830
1831    def partitionedofproperty_sql(self, expression: exp.PartitionedOfProperty) -> str:
1832        this = self.sql(expression, "this")
1833
1834        for_values_or_default = expression.expression
1835        if isinstance(for_values_or_default, exp.PartitionBoundSpec):
1836            for_values_or_default = f" FOR VALUES {self.sql(for_values_or_default)}"
1837        else:
1838            for_values_or_default = " DEFAULT"
1839
1840        return f"PARTITION OF {this}{for_values_or_default}"
1841
1842    def lockingproperty_sql(self, expression: exp.LockingProperty) -> str:
1843        kind = expression.args.get("kind")
1844        this = f" {self.sql(expression, 'this')}" if expression.this else ""
1845        for_or_in = expression.args.get("for_or_in")
1846        for_or_in = f" {for_or_in}" if for_or_in else ""
1847        lock_type = expression.args.get("lock_type")
1848        override = " OVERRIDE" if expression.args.get("override") else ""
1849        return f"LOCKING {kind}{this}{for_or_in} {lock_type}{override}"
1850
1851    def withdataproperty_sql(self, expression: exp.WithDataProperty) -> str:
1852        data_sql = f"WITH {'NO ' if expression.args.get('no') else ''}DATA"
1853        statistics = expression.args.get("statistics")
1854        statistics_sql = ""
1855        if statistics is not None:
1856            statistics_sql = f" AND {'NO ' if not statistics else ''}STATISTICS"
1857        return f"{data_sql}{statistics_sql}"
1858
1859    def withsystemversioningproperty_sql(self, expression: exp.WithSystemVersioningProperty) -> str:
1860        this = self.sql(expression, "this")
1861        this = f"HISTORY_TABLE={this}" if this else ""
1862        data_consistency: t.Optional[str] = self.sql(expression, "data_consistency")
1863        data_consistency = (
1864            f"DATA_CONSISTENCY_CHECK={data_consistency}" if data_consistency else None
1865        )
1866        retention_period: t.Optional[str] = self.sql(expression, "retention_period")
1867        retention_period = (
1868            f"HISTORY_RETENTION_PERIOD={retention_period}" if retention_period else None
1869        )
1870
1871        if this:
1872            on_sql = self.func("ON", this, data_consistency, retention_period)
1873        else:
1874            on_sql = "ON" if expression.args.get("on") else "OFF"
1875
1876        sql = f"SYSTEM_VERSIONING={on_sql}"
1877
1878        return f"WITH({sql})" if expression.args.get("with") else sql
1879
1880    def insert_sql(self, expression: exp.Insert) -> str:
1881        hint = self.sql(expression, "hint")
1882        overwrite = expression.args.get("overwrite")
1883
1884        if isinstance(expression.this, exp.Directory):
1885            this = " OVERWRITE" if overwrite else " INTO"
1886        else:
1887            this = self.INSERT_OVERWRITE if overwrite else " INTO"
1888
1889        stored = self.sql(expression, "stored")
1890        stored = f" {stored}" if stored else ""
1891        alternative = expression.args.get("alternative")
1892        alternative = f" OR {alternative}" if alternative else ""
1893        ignore = " IGNORE" if expression.args.get("ignore") else ""
1894        is_function = expression.args.get("is_function")
1895        if is_function:
1896            this = f"{this} FUNCTION"
1897        this = f"{this} {self.sql(expression, 'this')}"
1898
1899        exists = " IF EXISTS" if expression.args.get("exists") else ""
1900        where = self.sql(expression, "where")
1901        where = f"{self.sep()}REPLACE WHERE {where}" if where else ""
1902        expression_sql = f"{self.sep()}{self.sql(expression, 'expression')}"
1903        on_conflict = self.sql(expression, "conflict")
1904        on_conflict = f" {on_conflict}" if on_conflict else ""
1905        by_name = " BY NAME" if expression.args.get("by_name") else ""
1906        returning = self.sql(expression, "returning")
1907
1908        if self.RETURNING_END:
1909            expression_sql = f"{expression_sql}{on_conflict}{returning}"
1910        else:
1911            expression_sql = f"{returning}{expression_sql}{on_conflict}"
1912
1913        partition_by = self.sql(expression, "partition")
1914        partition_by = f" {partition_by}" if partition_by else ""
1915        settings = self.sql(expression, "settings")
1916        settings = f" {settings}" if settings else ""
1917
1918        source = self.sql(expression, "source")
1919        source = f"TABLE {source}" if source else ""
1920
1921        sql = f"INSERT{hint}{alternative}{ignore}{this}{stored}{by_name}{exists}{partition_by}{settings}{where}{expression_sql}{source}"
1922        return self.prepend_ctes(expression, sql)
1923
1924    def introducer_sql(self, expression: exp.Introducer) -> str:
1925        return f"{self.sql(expression, 'this')} {self.sql(expression, 'expression')}"
1926
1927    def kill_sql(self, expression: exp.Kill) -> str:
1928        kind = self.sql(expression, "kind")
1929        kind = f" {kind}" if kind else ""
1930        this = self.sql(expression, "this")
1931        this = f" {this}" if this else ""
1932        return f"KILL{kind}{this}"
1933
1934    def pseudotype_sql(self, expression: exp.PseudoType) -> str:
1935        return expression.name
1936
1937    def objectidentifier_sql(self, expression: exp.ObjectIdentifier) -> str:
1938        return expression.name
1939
1940    def onconflict_sql(self, expression: exp.OnConflict) -> str:
1941        conflict = "ON DUPLICATE KEY" if expression.args.get("duplicate") else "ON CONFLICT"
1942
1943        constraint = self.sql(expression, "constraint")
1944        constraint = f" ON CONSTRAINT {constraint}" if constraint else ""
1945
1946        conflict_keys = self.expressions(expression, key="conflict_keys", flat=True)
1947        conflict_keys = f"({conflict_keys}) " if conflict_keys else " "
1948        action = self.sql(expression, "action")
1949
1950        expressions = self.expressions(expression, flat=True)
1951        if expressions:
1952            set_keyword = "SET " if self.DUPLICATE_KEY_UPDATE_WITH_SET else ""
1953            expressions = f" {set_keyword}{expressions}"
1954
1955        where = self.sql(expression, "where")
1956        return f"{conflict}{constraint}{conflict_keys}{action}{expressions}{where}"
1957
1958    def returning_sql(self, expression: exp.Returning) -> str:
1959        return f"{self.seg('RETURNING')} {self.expressions(expression, flat=True)}"
1960
1961    def rowformatdelimitedproperty_sql(self, expression: exp.RowFormatDelimitedProperty) -> str:
1962        fields = self.sql(expression, "fields")
1963        fields = f" FIELDS TERMINATED BY {fields}" if fields else ""
1964        escaped = self.sql(expression, "escaped")
1965        escaped = f" ESCAPED BY {escaped}" if escaped else ""
1966        items = self.sql(expression, "collection_items")
1967        items = f" COLLECTION ITEMS TERMINATED BY {items}" if items else ""
1968        keys = self.sql(expression, "map_keys")
1969        keys = f" MAP KEYS TERMINATED BY {keys}" if keys else ""
1970        lines = self.sql(expression, "lines")
1971        lines = f" LINES TERMINATED BY {lines}" if lines else ""
1972        null = self.sql(expression, "null")
1973        null = f" NULL DEFINED AS {null}" if null else ""
1974        return f"ROW FORMAT DELIMITED{fields}{escaped}{items}{keys}{lines}{null}"
1975
1976    def withtablehint_sql(self, expression: exp.WithTableHint) -> str:
1977        return f"WITH ({self.expressions(expression, flat=True)})"
1978
1979    def indextablehint_sql(self, expression: exp.IndexTableHint) -> str:
1980        this = f"{self.sql(expression, 'this')} INDEX"
1981        target = self.sql(expression, "target")
1982        target = f" FOR {target}" if target else ""
1983        return f"{this}{target} ({self.expressions(expression, flat=True)})"
1984
1985    def historicaldata_sql(self, expression: exp.HistoricalData) -> str:
1986        this = self.sql(expression, "this")
1987        kind = self.sql(expression, "kind")
1988        expr = self.sql(expression, "expression")
1989        return f"{this} ({kind} => {expr})"
1990
1991    def table_parts(self, expression: exp.Table) -> str:
1992        return ".".join(
1993            self.sql(part)
1994            for part in (
1995                expression.args.get("catalog"),
1996                expression.args.get("db"),
1997                expression.args.get("this"),
1998            )
1999            if part is not None
2000        )
2001
2002    def table_sql(self, expression: exp.Table, sep: str = " AS ") -> str:
2003        table = self.table_parts(expression)
2004        only = "ONLY " if expression.args.get("only") else ""
2005        partition = self.sql(expression, "partition")
2006        partition = f" {partition}" if partition else ""
2007        version = self.sql(expression, "version")
2008        version = f" {version}" if version else ""
2009        alias = self.sql(expression, "alias")
2010        alias = f"{sep}{alias}" if alias else ""
2011
2012        sample = self.sql(expression, "sample")
2013        if self.dialect.ALIAS_POST_TABLESAMPLE:
2014            sample_pre_alias = sample
2015            sample_post_alias = ""
2016        else:
2017            sample_pre_alias = ""
2018            sample_post_alias = sample
2019
2020        hints = self.expressions(expression, key="hints", sep=" ")
2021        hints = f" {hints}" if hints and self.TABLE_HINTS else ""
2022        pivots = self.expressions(expression, key="pivots", sep="", flat=True)
2023        joins = self.indent(
2024            self.expressions(expression, key="joins", sep="", flat=True), skip_first=True
2025        )
2026        laterals = self.expressions(expression, key="laterals", sep="")
2027
2028        file_format = self.sql(expression, "format")
2029        if file_format:
2030            pattern = self.sql(expression, "pattern")
2031            pattern = f", PATTERN => {pattern}" if pattern else ""
2032            file_format = f" (FILE_FORMAT => {file_format}{pattern})"
2033
2034        ordinality = expression.args.get("ordinality") or ""
2035        if ordinality:
2036            ordinality = f" WITH ORDINALITY{alias}"
2037            alias = ""
2038
2039        when = self.sql(expression, "when")
2040        if when:
2041            table = f"{table} {when}"
2042
2043        changes = self.sql(expression, "changes")
2044        changes = f" {changes}" if changes else ""
2045
2046        rows_from = self.expressions(expression, key="rows_from")
2047        if rows_from:
2048            table = f"ROWS FROM {self.wrap(rows_from)}"
2049
2050        return f"{only}{table}{changes}{partition}{version}{file_format}{sample_pre_alias}{alias}{hints}{pivots}{sample_post_alias}{joins}{laterals}{ordinality}"
2051
2052    def tablefromrows_sql(self, expression: exp.TableFromRows) -> str:
2053        table = self.func("TABLE", expression.this)
2054        alias = self.sql(expression, "alias")
2055        alias = f" AS {alias}" if alias else ""
2056        sample = self.sql(expression, "sample")
2057        pivots = self.expressions(expression, key="pivots", sep="", flat=True)
2058        joins = self.indent(
2059            self.expressions(expression, key="joins", sep="", flat=True), skip_first=True
2060        )
2061        return f"{table}{alias}{pivots}{sample}{joins}"
2062
2063    def tablesample_sql(
2064        self,
2065        expression: exp.TableSample,
2066        tablesample_keyword: t.Optional[str] = None,
2067    ) -> str:
2068        method = self.sql(expression, "method")
2069        method = f"{method} " if method and self.TABLESAMPLE_WITH_METHOD else ""
2070        numerator = self.sql(expression, "bucket_numerator")
2071        denominator = self.sql(expression, "bucket_denominator")
2072        field = self.sql(expression, "bucket_field")
2073        field = f" ON {field}" if field else ""
2074        bucket = f"BUCKET {numerator} OUT OF {denominator}{field}" if numerator else ""
2075        seed = self.sql(expression, "seed")
2076        seed = f" {self.TABLESAMPLE_SEED_KEYWORD} ({seed})" if seed else ""
2077
2078        size = self.sql(expression, "size")
2079        if size and self.TABLESAMPLE_SIZE_IS_ROWS:
2080            size = f"{size} ROWS"
2081
2082        percent = self.sql(expression, "percent")
2083        if percent and not self.dialect.TABLESAMPLE_SIZE_IS_PERCENT:
2084            percent = f"{percent} PERCENT"
2085
2086        expr = f"{bucket}{percent}{size}"
2087        if self.TABLESAMPLE_REQUIRES_PARENS:
2088            expr = f"({expr})"
2089
2090        return f" {tablesample_keyword or self.TABLESAMPLE_KEYWORDS} {method}{expr}{seed}"
2091
2092    def pivot_sql(self, expression: exp.Pivot) -> str:
2093        expressions = self.expressions(expression, flat=True)
2094        direction = "UNPIVOT" if expression.unpivot else "PIVOT"
2095
2096        group = self.sql(expression, "group")
2097
2098        if expression.this:
2099            this = self.sql(expression, "this")
2100            if not expressions:
2101                return f"UNPIVOT {this}"
2102
2103            on = f"{self.seg('ON')} {expressions}"
2104            into = self.sql(expression, "into")
2105            into = f"{self.seg('INTO')} {into}" if into else ""
2106            using = self.expressions(expression, key="using", flat=True)
2107            using = f"{self.seg('USING')} {using}" if using else ""
2108            return f"{direction} {this}{on}{into}{using}{group}"
2109
2110        alias = self.sql(expression, "alias")
2111        alias = f" AS {alias}" if alias else ""
2112
2113        fields = self.expressions(
2114            expression,
2115            "fields",
2116            sep=" ",
2117            dynamic=True,
2118            new_line=True,
2119            skip_first=True,
2120            skip_last=True,
2121        )
2122
2123        include_nulls = expression.args.get("include_nulls")
2124        if include_nulls is not None:
2125            nulls = " INCLUDE NULLS " if include_nulls else " EXCLUDE NULLS "
2126        else:
2127            nulls = ""
2128
2129        default_on_null = self.sql(expression, "default_on_null")
2130        default_on_null = f" DEFAULT ON NULL ({default_on_null})" if default_on_null else ""
2131        return f"{self.seg(direction)}{nulls}({expressions} FOR {fields}{default_on_null}{group}){alias}"
2132
2133    def version_sql(self, expression: exp.Version) -> str:
2134        this = f"FOR {expression.name}"
2135        kind = expression.text("kind")
2136        expr = self.sql(expression, "expression")
2137        return f"{this} {kind} {expr}"
2138
2139    def tuple_sql(self, expression: exp.Tuple) -> str:
2140        return f"({self.expressions(expression, dynamic=True, new_line=True, skip_first=True, skip_last=True)})"
2141
2142    def update_sql(self, expression: exp.Update) -> str:
2143        this = self.sql(expression, "this")
2144        set_sql = self.expressions(expression, flat=True)
2145        from_sql = self.sql(expression, "from")
2146        where_sql = self.sql(expression, "where")
2147        returning = self.sql(expression, "returning")
2148        order = self.sql(expression, "order")
2149        limit = self.sql(expression, "limit")
2150        if self.RETURNING_END:
2151            expression_sql = f"{from_sql}{where_sql}{returning}"
2152        else:
2153            expression_sql = f"{returning}{from_sql}{where_sql}"
2154        sql = f"UPDATE {this} SET {set_sql}{expression_sql}{order}{limit}"
2155        return self.prepend_ctes(expression, sql)
2156
2157    def values_sql(self, expression: exp.Values, values_as_table: bool = True) -> str:
2158        values_as_table = values_as_table and self.VALUES_AS_TABLE
2159
2160        # The VALUES clause is still valid in an `INSERT INTO ..` statement, for example
2161        if values_as_table or not expression.find_ancestor(exp.From, exp.Join):
2162            args = self.expressions(expression)
2163            alias = self.sql(expression, "alias")
2164            values = f"VALUES{self.seg('')}{args}"
2165            values = (
2166                f"({values})"
2167                if self.WRAP_DERIVED_VALUES
2168                and (alias or isinstance(expression.parent, (exp.From, exp.Table)))
2169                else values
2170            )
2171            return f"{values} AS {alias}" if alias else values
2172
2173        # Converts `VALUES...` expression into a series of select unions.
2174        alias_node = expression.args.get("alias")
2175        column_names = alias_node and alias_node.columns
2176
2177        selects: t.List[exp.Query] = []
2178
2179        for i, tup in enumerate(expression.expressions):
2180            row = tup.expressions
2181
2182            if i == 0 and column_names:
2183                row = [
2184                    exp.alias_(value, column_name) for value, column_name in zip(row, column_names)
2185                ]
2186
2187            selects.append(exp.Select(expressions=row))
2188
2189        if self.pretty:
2190            # This may result in poor performance for large-cardinality `VALUES` tables, due to
2191            # the deep nesting of the resulting exp.Unions. If this is a problem, either increase
2192            # `sys.setrecursionlimit` to avoid RecursionErrors, or don't set `pretty`.
2193            query = reduce(lambda x, y: exp.union(x, y, distinct=False, copy=False), selects)
2194            return self.subquery_sql(query.subquery(alias_node and alias_node.this, copy=False))
2195
2196        alias = f" AS {self.sql(alias_node, 'this')}" if alias_node else ""
2197        unions = " UNION ALL ".join(self.sql(select) for select in selects)
2198        return f"({unions}){alias}"
2199
2200    def var_sql(self, expression: exp.Var) -> str:
2201        return self.sql(expression, "this")
2202
2203    @unsupported_args("expressions")
2204    def into_sql(self, expression: exp.Into) -> str:
2205        temporary = " TEMPORARY" if expression.args.get("temporary") else ""
2206        unlogged = " UNLOGGED" if expression.args.get("unlogged") else ""
2207        return f"{self.seg('INTO')}{temporary or unlogged} {self.sql(expression, 'this')}"
2208
2209    def from_sql(self, expression: exp.From) -> str:
2210        return f"{self.seg('FROM')} {self.sql(expression, 'this')}"
2211
2212    def groupingsets_sql(self, expression: exp.GroupingSets) -> str:
2213        grouping_sets = self.expressions(expression, indent=False)
2214        return f"GROUPING SETS {self.wrap(grouping_sets)}"
2215
2216    def rollup_sql(self, expression: exp.Rollup) -> str:
2217        expressions = self.expressions(expression, indent=False)
2218        return f"ROLLUP {self.wrap(expressions)}" if expressions else "WITH ROLLUP"
2219
2220    def cube_sql(self, expression: exp.Cube) -> str:
2221        expressions = self.expressions(expression, indent=False)
2222        return f"CUBE {self.wrap(expressions)}" if expressions else "WITH CUBE"
2223
2224    def group_sql(self, expression: exp.Group) -> str:
2225        group_by_all = expression.args.get("all")
2226        if group_by_all is True:
2227            modifier = " ALL"
2228        elif group_by_all is False:
2229            modifier = " DISTINCT"
2230        else:
2231            modifier = ""
2232
2233        group_by = self.op_expressions(f"GROUP BY{modifier}", expression)
2234
2235        grouping_sets = self.expressions(expression, key="grouping_sets")
2236        cube = self.expressions(expression, key="cube")
2237        rollup = self.expressions(expression, key="rollup")
2238
2239        groupings = csv(
2240            self.seg(grouping_sets) if grouping_sets else "",
2241            self.seg(cube) if cube else "",
2242            self.seg(rollup) if rollup else "",
2243            self.seg("WITH TOTALS") if expression.args.get("totals") else "",
2244            sep=self.GROUPINGS_SEP,
2245        )
2246
2247        if (
2248            expression.expressions
2249            and groupings
2250            and groupings.strip() not in ("WITH CUBE", "WITH ROLLUP")
2251        ):
2252            group_by = f"{group_by}{self.GROUPINGS_SEP}"
2253
2254        return f"{group_by}{groupings}"
2255
2256    def having_sql(self, expression: exp.Having) -> str:
2257        this = self.indent(self.sql(expression, "this"))
2258        return f"{self.seg('HAVING')}{self.sep()}{this}"
2259
2260    def connect_sql(self, expression: exp.Connect) -> str:
2261        start = self.sql(expression, "start")
2262        start = self.seg(f"START WITH {start}") if start else ""
2263        nocycle = " NOCYCLE" if expression.args.get("nocycle") else ""
2264        connect = self.sql(expression, "connect")
2265        connect = self.seg(f"CONNECT BY{nocycle} {connect}")
2266        return start + connect
2267
2268    def prior_sql(self, expression: exp.Prior) -> str:
2269        return f"PRIOR {self.sql(expression, 'this')}"
2270
2271    def join_sql(self, expression: exp.Join) -> str:
2272        if not self.SEMI_ANTI_JOIN_WITH_SIDE and expression.kind in ("SEMI", "ANTI"):
2273            side = None
2274        else:
2275            side = expression.side
2276
2277        op_sql = " ".join(
2278            op
2279            for op in (
2280                expression.method,
2281                "GLOBAL" if expression.args.get("global") else None,
2282                side,
2283                expression.kind,
2284                expression.hint if self.JOIN_HINTS else None,
2285            )
2286            if op
2287        )
2288        match_cond = self.sql(expression, "match_condition")
2289        match_cond = f" MATCH_CONDITION ({match_cond})" if match_cond else ""
2290        on_sql = self.sql(expression, "on")
2291        using = expression.args.get("using")
2292
2293        if not on_sql and using:
2294            on_sql = csv(*(self.sql(column) for column in using))
2295
2296        this = expression.this
2297        this_sql = self.sql(this)
2298
2299        exprs = self.expressions(expression)
2300        if exprs:
2301            this_sql = f"{this_sql},{self.seg(exprs)}"
2302
2303        if on_sql:
2304            on_sql = self.indent(on_sql, skip_first=True)
2305            space = self.seg(" " * self.pad) if self.pretty else " "
2306            if using:
2307                on_sql = f"{space}USING ({on_sql})"
2308            else:
2309                on_sql = f"{space}ON {on_sql}"
2310        elif not op_sql:
2311            if isinstance(this, exp.Lateral) and this.args.get("cross_apply") is not None:
2312                return f" {this_sql}"
2313
2314            return f", {this_sql}"
2315
2316        if op_sql != "STRAIGHT_JOIN":
2317            op_sql = f"{op_sql} JOIN" if op_sql else "JOIN"
2318
2319        pivots = self.expressions(expression, key="pivots", sep="", flat=True)
2320        return f"{self.seg(op_sql)} {this_sql}{match_cond}{on_sql}{pivots}"
2321
2322    def lambda_sql(self, expression: exp.Lambda, arrow_sep: str = "->", wrap: bool = True) -> str:
2323        args = self.expressions(expression, flat=True)
2324        args = f"({args})" if wrap and len(args.split(",")) > 1 else args
2325        return f"{args} {arrow_sep} {self.sql(expression, 'this')}"
2326
2327    def lateral_op(self, expression: exp.Lateral) -> str:
2328        cross_apply = expression.args.get("cross_apply")
2329
2330        # https://www.mssqltips.com/sqlservertip/1958/sql-server-cross-apply-and-outer-apply/
2331        if cross_apply is True:
2332            op = "INNER JOIN "
2333        elif cross_apply is False:
2334            op = "LEFT JOIN "
2335        else:
2336            op = ""
2337
2338        return f"{op}LATERAL"
2339
2340    def lateral_sql(self, expression: exp.Lateral) -> str:
2341        this = self.sql(expression, "this")
2342
2343        if expression.args.get("view"):
2344            alias = expression.args["alias"]
2345            columns = self.expressions(alias, key="columns", flat=True)
2346            table = f" {alias.name}" if alias.name else ""
2347            columns = f" AS {columns}" if columns else ""
2348            op_sql = self.seg(f"LATERAL VIEW{' OUTER' if expression.args.get('outer') else ''}")
2349            return f"{op_sql}{self.sep()}{this}{table}{columns}"
2350
2351        alias = self.sql(expression, "alias")
2352        alias = f" AS {alias}" if alias else ""
2353
2354        ordinality = expression.args.get("ordinality") or ""
2355        if ordinality:
2356            ordinality = f" WITH ORDINALITY{alias}"
2357            alias = ""
2358
2359        return f"{self.lateral_op(expression)} {this}{alias}{ordinality}"
2360
2361    def limit_sql(self, expression: exp.Limit, top: bool = False) -> str:
2362        this = self.sql(expression, "this")
2363
2364        args = [
2365            self._simplify_unless_literal(e) if self.LIMIT_ONLY_LITERALS else e
2366            for e in (expression.args.get(k) for k in ("offset", "expression"))
2367            if e
2368        ]
2369
2370        args_sql = ", ".join(self.sql(e) for e in args)
2371        args_sql = f"({args_sql})" if top and any(not e.is_number for e in args) else args_sql
2372        expressions = self.expressions(expression, flat=True)
2373        limit_options = self.sql(expression, "limit_options")
2374        expressions = f" BY {expressions}" if expressions else ""
2375
2376        return f"{this}{self.seg('TOP' if top else 'LIMIT')} {args_sql}{limit_options}{expressions}"
2377
2378    def offset_sql(self, expression: exp.Offset) -> str:
2379        this = self.sql(expression, "this")
2380        value = expression.expression
2381        value = self._simplify_unless_literal(value) if self.LIMIT_ONLY_LITERALS else value
2382        expressions = self.expressions(expression, flat=True)
2383        expressions = f" BY {expressions}" if expressions else ""
2384        return f"{this}{self.seg('OFFSET')} {self.sql(value)}{expressions}"
2385
2386    def setitem_sql(self, expression: exp.SetItem) -> str:
2387        kind = self.sql(expression, "kind")
2388        kind = f"{kind} " if kind else ""
2389        this = self.sql(expression, "this")
2390        expressions = self.expressions(expression)
2391        collate = self.sql(expression, "collate")
2392        collate = f" COLLATE {collate}" if collate else ""
2393        global_ = "GLOBAL " if expression.args.get("global") else ""
2394        return f"{global_}{kind}{this}{expressions}{collate}"
2395
2396    def set_sql(self, expression: exp.Set) -> str:
2397        expressions = f" {self.expressions(expression, flat=True)}"
2398        tag = " TAG" if expression.args.get("tag") else ""
2399        return f"{'UNSET' if expression.args.get('unset') else 'SET'}{tag}{expressions}"
2400
2401    def pragma_sql(self, expression: exp.Pragma) -> str:
2402        return f"PRAGMA {self.sql(expression, 'this')}"
2403
2404    def lock_sql(self, expression: exp.Lock) -> str:
2405        if not self.LOCKING_READS_SUPPORTED:
2406            self.unsupported("Locking reads using 'FOR UPDATE/SHARE' are not supported")
2407            return ""
2408
2409        lock_type = "FOR UPDATE" if expression.args["update"] else "FOR SHARE"
2410        expressions = self.expressions(expression, flat=True)
2411        expressions = f" OF {expressions}" if expressions else ""
2412        wait = expression.args.get("wait")
2413
2414        if wait is not None:
2415            if isinstance(wait, exp.Literal):
2416                wait = f" WAIT {self.sql(wait)}"
2417            else:
2418                wait = " NOWAIT" if wait else " SKIP LOCKED"
2419
2420        return f"{lock_type}{expressions}{wait or ''}"
2421
2422    def literal_sql(self, expression: exp.Literal) -> str:
2423        text = expression.this or ""
2424        if expression.is_string:
2425            text = f"{self.dialect.QUOTE_START}{self.escape_str(text)}{self.dialect.QUOTE_END}"
2426        return text
2427
2428    def escape_str(self, text: str, escape_backslash: bool = True) -> str:
2429        if self.dialect.ESCAPED_SEQUENCES:
2430            to_escaped = self.dialect.ESCAPED_SEQUENCES
2431            text = "".join(
2432                to_escaped.get(ch, ch) if escape_backslash or ch != "\\" else ch for ch in text
2433            )
2434
2435        return self._replace_line_breaks(text).replace(
2436            self.dialect.QUOTE_END, self._escaped_quote_end
2437        )
2438
2439    def loaddata_sql(self, expression: exp.LoadData) -> str:
2440        local = " LOCAL" if expression.args.get("local") else ""
2441        inpath = f" INPATH {self.sql(expression, 'inpath')}"
2442        overwrite = " OVERWRITE" if expression.args.get("overwrite") else ""
2443        this = f" INTO TABLE {self.sql(expression, 'this')}"
2444        partition = self.sql(expression, "partition")
2445        partition = f" {partition}" if partition else ""
2446        input_format = self.sql(expression, "input_format")
2447        input_format = f" INPUTFORMAT {input_format}" if input_format else ""
2448        serde = self.sql(expression, "serde")
2449        serde = f" SERDE {serde}" if serde else ""
2450        return f"LOAD DATA{local}{inpath}{overwrite}{this}{partition}{input_format}{serde}"
2451
2452    def null_sql(self, *_) -> str:
2453        return "NULL"
2454
2455    def boolean_sql(self, expression: exp.Boolean) -> str:
2456        return "TRUE" if expression.this else "FALSE"
2457
2458    def order_sql(self, expression: exp.Order, flat: bool = False) -> str:
2459        this = self.sql(expression, "this")
2460        this = f"{this} " if this else this
2461        siblings = "SIBLINGS " if expression.args.get("siblings") else ""
2462        return self.op_expressions(f"{this}ORDER {siblings}BY", expression, flat=this or flat)  # type: ignore
2463
2464    def withfill_sql(self, expression: exp.WithFill) -> str:
2465        from_sql = self.sql(expression, "from")
2466        from_sql = f" FROM {from_sql}" if from_sql else ""
2467        to_sql = self.sql(expression, "to")
2468        to_sql = f" TO {to_sql}" if to_sql else ""
2469        step_sql = self.sql(expression, "step")
2470        step_sql = f" STEP {step_sql}" if step_sql else ""
2471        interpolated_values = [
2472            f"{self.sql(e, 'alias')} AS {self.sql(e, 'this')}"
2473            if isinstance(e, exp.Alias)
2474            else self.sql(e, "this")
2475            for e in expression.args.get("interpolate") or []
2476        ]
2477        interpolate = (
2478            f" INTERPOLATE ({', '.join(interpolated_values)})" if interpolated_values else ""
2479        )
2480        return f"WITH FILL{from_sql}{to_sql}{step_sql}{interpolate}"
2481
2482    def cluster_sql(self, expression: exp.Cluster) -> str:
2483        return self.op_expressions("CLUSTER BY", expression)
2484
2485    def distribute_sql(self, expression: exp.Distribute) -> str:
2486        return self.op_expressions("DISTRIBUTE BY", expression)
2487
2488    def sort_sql(self, expression: exp.Sort) -> str:
2489        return self.op_expressions("SORT BY", expression)
2490
2491    def ordered_sql(self, expression: exp.Ordered) -> str:
2492        desc = expression.args.get("desc")
2493        asc = not desc
2494
2495        nulls_first = expression.args.get("nulls_first")
2496        nulls_last = not nulls_first
2497        nulls_are_large = self.dialect.NULL_ORDERING == "nulls_are_large"
2498        nulls_are_small = self.dialect.NULL_ORDERING == "nulls_are_small"
2499        nulls_are_last = self.dialect.NULL_ORDERING == "nulls_are_last"
2500
2501        this = self.sql(expression, "this")
2502
2503        sort_order = " DESC" if desc else (" ASC" if desc is False else "")
2504        nulls_sort_change = ""
2505        if nulls_first and (
2506            (asc and nulls_are_large) or (desc and nulls_are_small) or nulls_are_last
2507        ):
2508            nulls_sort_change = " NULLS FIRST"
2509        elif (
2510            nulls_last
2511            and ((asc and nulls_are_small) or (desc and nulls_are_large))
2512            and not nulls_are_last
2513        ):
2514            nulls_sort_change = " NULLS LAST"
2515
2516        # If the NULLS FIRST/LAST clause is unsupported, we add another sort key to simulate it
2517        if nulls_sort_change and not self.NULL_ORDERING_SUPPORTED:
2518            window = expression.find_ancestor(exp.Window, exp.Select)
2519            if isinstance(window, exp.Window) and window.args.get("spec"):
2520                self.unsupported(
2521                    f"'{nulls_sort_change.strip()}' translation not supported in window functions"
2522                )
2523                nulls_sort_change = ""
2524            elif self.NULL_ORDERING_SUPPORTED is False and (
2525                (asc and nulls_sort_change == " NULLS LAST")
2526                or (desc and nulls_sort_change == " NULLS FIRST")
2527            ):
2528                # BigQuery does not allow these ordering/nulls combinations when used under
2529                # an aggregation func or under a window containing one
2530                ancestor = expression.find_ancestor(exp.AggFunc, exp.Window, exp.Select)
2531
2532                if isinstance(ancestor, exp.Window):
2533                    ancestor = ancestor.this
2534                if isinstance(ancestor, exp.AggFunc):
2535                    self.unsupported(
2536                        f"'{nulls_sort_change.strip()}' translation not supported for aggregate functions with {sort_order} sort order"
2537                    )
2538                    nulls_sort_change = ""
2539            elif self.NULL_ORDERING_SUPPORTED is None:
2540                if expression.this.is_int:
2541                    self.unsupported(
2542                        f"'{nulls_sort_change.strip()}' translation not supported with positional ordering"
2543                    )
2544                elif not isinstance(expression.this, exp.Rand):
2545                    null_sort_order = " DESC" if nulls_sort_change == " NULLS FIRST" else ""
2546                    this = f"CASE WHEN {this} IS NULL THEN 1 ELSE 0 END{null_sort_order}, {this}"
2547                nulls_sort_change = ""
2548
2549        with_fill = self.sql(expression, "with_fill")
2550        with_fill = f" {with_fill}" if with_fill else ""
2551
2552        return f"{this}{sort_order}{nulls_sort_change}{with_fill}"
2553
2554    def matchrecognizemeasure_sql(self, expression: exp.MatchRecognizeMeasure) -> str:
2555        window_frame = self.sql(expression, "window_frame")
2556        window_frame = f"{window_frame} " if window_frame else ""
2557
2558        this = self.sql(expression, "this")
2559
2560        return f"{window_frame}{this}"
2561
2562    def matchrecognize_sql(self, expression: exp.MatchRecognize) -> str:
2563        partition = self.partition_by_sql(expression)
2564        order = self.sql(expression, "order")
2565        measures = self.expressions(expression, key="measures")
2566        measures = self.seg(f"MEASURES{self.seg(measures)}") if measures else ""
2567        rows = self.sql(expression, "rows")
2568        rows = self.seg(rows) if rows else ""
2569        after = self.sql(expression, "after")
2570        after = self.seg(after) if after else ""
2571        pattern = self.sql(expression, "pattern")
2572        pattern = self.seg(f"PATTERN ({pattern})") if pattern else ""
2573        definition_sqls = [
2574            f"{self.sql(definition, 'alias')} AS {self.sql(definition, 'this')}"
2575            for definition in expression.args.get("define", [])
2576        ]
2577        definitions = self.expressions(sqls=definition_sqls)
2578        define = self.seg(f"DEFINE{self.seg(definitions)}") if definitions else ""
2579        body = "".join(
2580            (
2581                partition,
2582                order,
2583                measures,
2584                rows,
2585                after,
2586                pattern,
2587                define,
2588            )
2589        )
2590        alias = self.sql(expression, "alias")
2591        alias = f" {alias}" if alias else ""
2592        return f"{self.seg('MATCH_RECOGNIZE')} {self.wrap(body)}{alias}"
2593
2594    def query_modifiers(self, expression: exp.Expression, *sqls: str) -> str:
2595        limit = expression.args.get("limit")
2596
2597        if self.LIMIT_FETCH == "LIMIT" and isinstance(limit, exp.Fetch):
2598            limit = exp.Limit(expression=exp.maybe_copy(limit.args.get("count")))
2599        elif self.LIMIT_FETCH == "FETCH" and isinstance(limit, exp.Limit):
2600            limit = exp.Fetch(direction="FIRST", count=exp.maybe_copy(limit.expression))
2601
2602        return csv(
2603            *sqls,
2604            *[self.sql(join) for join in expression.args.get("joins") or []],
2605            self.sql(expression, "match"),
2606            *[self.sql(lateral) for lateral in expression.args.get("laterals") or []],
2607            self.sql(expression, "prewhere"),
2608            self.sql(expression, "where"),
2609            self.sql(expression, "connect"),
2610            self.sql(expression, "group"),
2611            self.sql(expression, "having"),
2612            *[gen(self, expression) for gen in self.AFTER_HAVING_MODIFIER_TRANSFORMS.values()],
2613            self.sql(expression, "order"),
2614            *self.offset_limit_modifiers(expression, isinstance(limit, exp.Fetch), limit),
2615            *self.after_limit_modifiers(expression),
2616            self.options_modifier(expression),
2617            self.for_modifiers(expression),
2618            sep="",
2619        )
2620
2621    def options_modifier(self, expression: exp.Expression) -> str:
2622        options = self.expressions(expression, key="options")
2623        return f" {options}" if options else ""
2624
2625    def for_modifiers(self, expression: exp.Expression) -> str:
2626        for_modifiers = self.expressions(expression, key="for")
2627        return f"{self.sep()}FOR XML{self.seg(for_modifiers)}" if for_modifiers else ""
2628
2629    def queryoption_sql(self, expression: exp.QueryOption) -> str:
2630        self.unsupported("Unsupported query option.")
2631        return ""
2632
2633    def offset_limit_modifiers(
2634        self, expression: exp.Expression, fetch: bool, limit: t.Optional[exp.Fetch | exp.Limit]
2635    ) -> t.List[str]:
2636        return [
2637            self.sql(expression, "offset") if fetch else self.sql(limit),
2638            self.sql(limit) if fetch else self.sql(expression, "offset"),
2639        ]
2640
2641    def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
2642        locks = self.expressions(expression, key="locks", sep=" ")
2643        locks = f" {locks}" if locks else ""
2644        return [locks, self.sql(expression, "sample")]
2645
2646    def select_sql(self, expression: exp.Select) -> str:
2647        into = expression.args.get("into")
2648        if not self.SUPPORTS_SELECT_INTO and into:
2649            into.pop()
2650
2651        hint = self.sql(expression, "hint")
2652        distinct = self.sql(expression, "distinct")
2653        distinct = f" {distinct}" if distinct else ""
2654        kind = self.sql(expression, "kind")
2655
2656        limit = expression.args.get("limit")
2657        if isinstance(limit, exp.Limit) and self.LIMIT_IS_TOP:
2658            top = self.limit_sql(limit, top=True)
2659            limit.pop()
2660        else:
2661            top = ""
2662
2663        expressions = self.expressions(expression)
2664
2665        if kind:
2666            if kind in self.SELECT_KINDS:
2667                kind = f" AS {kind}"
2668            else:
2669                if kind == "STRUCT":
2670                    expressions = self.expressions(
2671                        sqls=[
2672                            self.sql(
2673                                exp.Struct(
2674                                    expressions=[
2675                                        exp.PropertyEQ(this=e.args.get("alias"), expression=e.this)
2676                                        if isinstance(e, exp.Alias)
2677                                        else e
2678                                        for e in expression.expressions
2679                                    ]
2680                                )
2681                            )
2682                        ]
2683                    )
2684                kind = ""
2685
2686        operation_modifiers = self.expressions(expression, key="operation_modifiers", sep=" ")
2687        operation_modifiers = f"{self.sep()}{operation_modifiers}" if operation_modifiers else ""
2688
2689        # We use LIMIT_IS_TOP as a proxy for whether DISTINCT should go first because tsql and Teradata
2690        # are the only dialects that use LIMIT_IS_TOP and both place DISTINCT first.
2691        top_distinct = f"{distinct}{hint}{top}" if self.LIMIT_IS_TOP else f"{top}{hint}{distinct}"
2692        expressions = f"{self.sep()}{expressions}" if expressions else expressions
2693        sql = self.query_modifiers(
2694            expression,
2695            f"SELECT{top_distinct}{operation_modifiers}{kind}{expressions}",
2696            self.sql(expression, "into", comment=False),
2697            self.sql(expression, "from", comment=False),
2698        )
2699
2700        # If both the CTE and SELECT clauses have comments, generate the latter earlier
2701        if expression.args.get("with"):
2702            sql = self.maybe_comment(sql, expression)
2703            expression.pop_comments()
2704
2705        sql = self.prepend_ctes(expression, sql)
2706
2707        if not self.SUPPORTS_SELECT_INTO and into:
2708            if into.args.get("temporary"):
2709                table_kind = " TEMPORARY"
2710            elif self.SUPPORTS_UNLOGGED_TABLES and into.args.get("unlogged"):
2711                table_kind = " UNLOGGED"
2712            else:
2713                table_kind = ""
2714            sql = f"CREATE{table_kind} TABLE {self.sql(into.this)} AS {sql}"
2715
2716        return sql
2717
2718    def schema_sql(self, expression: exp.Schema) -> str:
2719        this = self.sql(expression, "this")
2720        sql = self.schema_columns_sql(expression)
2721        return f"{this} {sql}" if this and sql else this or sql
2722
2723    def schema_columns_sql(self, expression: exp.Schema) -> str:
2724        if expression.expressions:
2725            return f"({self.sep('')}{self.expressions(expression)}{self.seg(')', sep='')}"
2726        return ""
2727
2728    def star_sql(self, expression: exp.Star) -> str:
2729        except_ = self.expressions(expression, key="except", flat=True)
2730        except_ = f"{self.seg(self.STAR_EXCEPT)} ({except_})" if except_ else ""
2731        replace = self.expressions(expression, key="replace", flat=True)
2732        replace = f"{self.seg('REPLACE')} ({replace})" if replace else ""
2733        rename = self.expressions(expression, key="rename", flat=True)
2734        rename = f"{self.seg('RENAME')} ({rename})" if rename else ""
2735        return f"*{except_}{replace}{rename}"
2736
2737    def parameter_sql(self, expression: exp.Parameter) -> str:
2738        this = self.sql(expression, "this")
2739        return f"{self.PARAMETER_TOKEN}{this}"
2740
2741    def sessionparameter_sql(self, expression: exp.SessionParameter) -> str:
2742        this = self.sql(expression, "this")
2743        kind = expression.text("kind")
2744        if kind:
2745            kind = f"{kind}."
2746        return f"@@{kind}{this}"
2747
2748    def placeholder_sql(self, expression: exp.Placeholder) -> str:
2749        return f"{self.NAMED_PLACEHOLDER_TOKEN}{expression.name}" if expression.this else "?"
2750
2751    def subquery_sql(self, expression: exp.Subquery, sep: str = " AS ") -> str:
2752        alias = self.sql(expression, "alias")
2753        alias = f"{sep}{alias}" if alias else ""
2754        sample = self.sql(expression, "sample")
2755        if self.dialect.ALIAS_POST_TABLESAMPLE and sample:
2756            alias = f"{sample}{alias}"
2757
2758            # Set to None so it's not generated again by self.query_modifiers()
2759            expression.set("sample", None)
2760
2761        pivots = self.expressions(expression, key="pivots", sep="", flat=True)
2762        sql = self.query_modifiers(expression, self.wrap(expression), alias, pivots)
2763        return self.prepend_ctes(expression, sql)
2764
2765    def qualify_sql(self, expression: exp.Qualify) -> str:
2766        this = self.indent(self.sql(expression, "this"))
2767        return f"{self.seg('QUALIFY')}{self.sep()}{this}"
2768
2769    def unnest_sql(self, expression: exp.Unnest) -> str:
2770        args = self.expressions(expression, flat=True)
2771
2772        alias = expression.args.get("alias")
2773        offset = expression.args.get("offset")
2774
2775        if self.UNNEST_WITH_ORDINALITY:
2776            if alias and isinstance(offset, exp.Expression):
2777                alias.append("columns", offset)
2778
2779        if alias and self.dialect.UNNEST_COLUMN_ONLY:
2780            columns = alias.columns
2781            alias = self.sql(columns[0]) if columns else ""
2782        else:
2783            alias = self.sql(alias)
2784
2785        alias = f" AS {alias}" if alias else alias
2786        if self.UNNEST_WITH_ORDINALITY:
2787            suffix = f" WITH ORDINALITY{alias}" if offset else alias
2788        else:
2789            if isinstance(offset, exp.Expression):
2790                suffix = f"{alias} WITH OFFSET AS {self.sql(offset)}"
2791            elif offset:
2792                suffix = f"{alias} WITH OFFSET"
2793            else:
2794                suffix = alias
2795
2796        return f"UNNEST({args}){suffix}"
2797
2798    def prewhere_sql(self, expression: exp.PreWhere) -> str:
2799        return ""
2800
2801    def where_sql(self, expression: exp.Where) -> str:
2802        this = self.indent(self.sql(expression, "this"))
2803        return f"{self.seg('WHERE')}{self.sep()}{this}"
2804
2805    def window_sql(self, expression: exp.Window) -> str:
2806        this = self.sql(expression, "this")
2807        partition = self.partition_by_sql(expression)
2808        order = expression.args.get("order")
2809        order = self.order_sql(order, flat=True) if order else ""
2810        spec = self.sql(expression, "spec")
2811        alias = self.sql(expression, "alias")
2812        over = self.sql(expression, "over") or "OVER"
2813
2814        this = f"{this} {'AS' if expression.arg_key == 'windows' else over}"
2815
2816        first = expression.args.get("first")
2817        if first is None:
2818            first = ""
2819        else:
2820            first = "FIRST" if first else "LAST"
2821
2822        if not partition and not order and not spec and alias:
2823            return f"{this} {alias}"
2824
2825        args = self.format_args(
2826            *[arg for arg in (alias, first, partition, order, spec) if arg], sep=" "
2827        )
2828        return f"{this} ({args})"
2829
2830    def partition_by_sql(self, expression: exp.Window | exp.MatchRecognize) -> str:
2831        partition = self.expressions(expression, key="partition_by", flat=True)
2832        return f"PARTITION BY {partition}" if partition else ""
2833
2834    def windowspec_sql(self, expression: exp.WindowSpec) -> str:
2835        kind = self.sql(expression, "kind")
2836        start = csv(self.sql(expression, "start"), self.sql(expression, "start_side"), sep=" ")
2837        end = (
2838            csv(self.sql(expression, "end"), self.sql(expression, "end_side"), sep=" ")
2839            or "CURRENT ROW"
2840        )
2841
2842        window_spec = f"{kind} BETWEEN {start} AND {end}"
2843
2844        exclude = self.sql(expression, "exclude")
2845        if exclude:
2846            if self.SUPPORTS_WINDOW_EXCLUDE:
2847                window_spec += f" EXCLUDE {exclude}"
2848            else:
2849                self.unsupported("EXCLUDE clause is not supported in the WINDOW clause")
2850
2851        return window_spec
2852
2853    def withingroup_sql(self, expression: exp.WithinGroup) -> str:
2854        this = self.sql(expression, "this")
2855        expression_sql = self.sql(expression, "expression")[1:]  # order has a leading space
2856        return f"{this} WITHIN GROUP ({expression_sql})"
2857
2858    def between_sql(self, expression: exp.Between) -> str:
2859        this = self.sql(expression, "this")
2860        low = self.sql(expression, "low")
2861        high = self.sql(expression, "high")
2862        return f"{this} BETWEEN {low} AND {high}"
2863
2864    def bracket_offset_expressions(
2865        self, expression: exp.Bracket, index_offset: t.Optional[int] = None
2866    ) -> t.List[exp.Expression]:
2867        return apply_index_offset(
2868            expression.this,
2869            expression.expressions,
2870            (index_offset or self.dialect.INDEX_OFFSET) - expression.args.get("offset", 0),
2871            dialect=self.dialect,
2872        )
2873
2874    def bracket_sql(self, expression: exp.Bracket) -> str:
2875        expressions = self.bracket_offset_expressions(expression)
2876        expressions_sql = ", ".join(self.sql(e) for e in expressions)
2877        return f"{self.sql(expression, 'this')}[{expressions_sql}]"
2878
2879    def all_sql(self, expression: exp.All) -> str:
2880        return f"ALL {self.wrap(expression)}"
2881
2882    def any_sql(self, expression: exp.Any) -> str:
2883        this = self.sql(expression, "this")
2884        if isinstance(expression.this, (*exp.UNWRAPPED_QUERIES, exp.Paren)):
2885            if isinstance(expression.this, exp.UNWRAPPED_QUERIES):
2886                this = self.wrap(this)
2887            return f"ANY{this}"
2888        return f"ANY {this}"
2889
2890    def exists_sql(self, expression: exp.Exists) -> str:
2891        return f"EXISTS{self.wrap(expression)}"
2892
2893    def case_sql(self, expression: exp.Case) -> str:
2894        this = self.sql(expression, "this")
2895        statements = [f"CASE {this}" if this else "CASE"]
2896
2897        for e in expression.args["ifs"]:
2898            statements.append(f"WHEN {self.sql(e, 'this')}")
2899            statements.append(f"THEN {self.sql(e, 'true')}")
2900
2901        default = self.sql(expression, "default")
2902
2903        if default:
2904            statements.append(f"ELSE {default}")
2905
2906        statements.append("END")
2907
2908        if self.pretty and self.too_wide(statements):
2909            return self.indent("\n".join(statements), skip_first=True, skip_last=True)
2910
2911        return " ".join(statements)
2912
2913    def constraint_sql(self, expression: exp.Constraint) -> str:
2914        this = self.sql(expression, "this")
2915        expressions = self.expressions(expression, flat=True)
2916        return f"CONSTRAINT {this} {expressions}"
2917
2918    def nextvaluefor_sql(self, expression: exp.NextValueFor) -> str:
2919        order = expression.args.get("order")
2920        order = f" OVER ({self.order_sql(order, flat=True)})" if order else ""
2921        return f"NEXT VALUE FOR {self.sql(expression, 'this')}{order}"
2922
2923    def extract_sql(self, expression: exp.Extract) -> str:
2924        from sqlglot.dialects.dialect import map_date_part
2925
2926        this = (
2927            map_date_part(expression.this, self.dialect)
2928            if self.NORMALIZE_EXTRACT_DATE_PARTS
2929            else expression.this
2930        )
2931        this_sql = self.sql(this) if self.EXTRACT_ALLOWS_QUOTES else this.name
2932        expression_sql = self.sql(expression, "expression")
2933
2934        return f"EXTRACT({this_sql} FROM {expression_sql})"
2935
2936    def trim_sql(self, expression: exp.Trim) -> str:
2937        trim_type = self.sql(expression, "position")
2938
2939        if trim_type == "LEADING":
2940            func_name = "LTRIM"
2941        elif trim_type == "TRAILING":
2942            func_name = "RTRIM"
2943        else:
2944            func_name = "TRIM"
2945
2946        return self.func(func_name, expression.this, expression.expression)
2947
2948    def convert_concat_args(self, expression: exp.Concat | exp.ConcatWs) -> t.List[exp.Expression]:
2949        args = expression.expressions
2950        if isinstance(expression, exp.ConcatWs):
2951            args = args[1:]  # Skip the delimiter
2952
2953        if self.dialect.STRICT_STRING_CONCAT and expression.args.get("safe"):
2954            args = [exp.cast(e, exp.DataType.Type.TEXT) for e in args]
2955
2956        if not self.dialect.CONCAT_COALESCE and expression.args.get("coalesce"):
2957            args = [exp.func("coalesce", e, exp.Literal.string("")) for e in args]
2958
2959        return args
2960
2961    def concat_sql(self, expression: exp.Concat) -> str:
2962        expressions = self.convert_concat_args(expression)
2963
2964        # Some dialects don't allow a single-argument CONCAT call
2965        if not self.SUPPORTS_SINGLE_ARG_CONCAT and len(expressions) == 1:
2966            return self.sql(expressions[0])
2967
2968        return self.func("CONCAT", *expressions)
2969
2970    def concatws_sql(self, expression: exp.ConcatWs) -> str:
2971        return self.func(
2972            "CONCAT_WS", seq_get(expression.expressions, 0), *self.convert_concat_args(expression)
2973        )
2974
2975    def check_sql(self, expression: exp.Check) -> str:
2976        this = self.sql(expression, key="this")
2977        return f"CHECK ({this})"
2978
2979    def foreignkey_sql(self, expression: exp.ForeignKey) -> str:
2980        expressions = self.expressions(expression, flat=True)
2981        expressions = f" ({expressions})" if expressions else ""
2982        reference = self.sql(expression, "reference")
2983        reference = f" {reference}" if reference else ""
2984        delete = self.sql(expression, "delete")
2985        delete = f" ON DELETE {delete}" if delete else ""
2986        update = self.sql(expression, "update")
2987        update = f" ON UPDATE {update}" if update else ""
2988        options = self.expressions(expression, key="options", flat=True, sep=" ")
2989        options = f" {options}" if options else ""
2990        return f"FOREIGN KEY{expressions}{reference}{delete}{update}{options}"
2991
2992    def primarykey_sql(self, expression: exp.ForeignKey) -> str:
2993        expressions = self.expressions(expression, flat=True)
2994        options = self.expressions(expression, key="options", flat=True, sep=" ")
2995        options = f" {options}" if options else ""
2996        return f"PRIMARY KEY ({expressions}){options}"
2997
2998    def if_sql(self, expression: exp.If) -> str:
2999        return self.case_sql(exp.Case(ifs=[expression], default=expression.args.get("false")))
3000
3001    def matchagainst_sql(self, expression: exp.MatchAgainst) -> str:
3002        modifier = expression.args.get("modifier")
3003        modifier = f" {modifier}" if modifier else ""
3004        return f"{self.func('MATCH', *expression.expressions)} AGAINST({self.sql(expression, 'this')}{modifier})"
3005
3006    def jsonkeyvalue_sql(self, expression: exp.JSONKeyValue) -> str:
3007        return f"{self.sql(expression, 'this')}{self.JSON_KEY_VALUE_PAIR_SEP} {self.sql(expression, 'expression')}"
3008
3009    def jsonpath_sql(self, expression: exp.JSONPath) -> str:
3010        path = self.expressions(expression, sep="", flat=True).lstrip(".")
3011
3012        if expression.args.get("escape"):
3013            path = self.escape_str(path)
3014
3015        if self.QUOTE_JSON_PATH:
3016            path = f"{self.dialect.QUOTE_START}{path}{self.dialect.QUOTE_END}"
3017
3018        return path
3019
3020    def json_path_part(self, expression: int | str | exp.JSONPathPart) -> str:
3021        if isinstance(expression, exp.JSONPathPart):
3022            transform = self.TRANSFORMS.get(expression.__class__)
3023            if not callable(transform):
3024                self.unsupported(f"Unsupported JSONPathPart type {expression.__class__.__name__}")
3025                return ""
3026
3027            return transform(self, expression)
3028
3029        if isinstance(expression, int):
3030            return str(expression)
3031
3032        if self._quote_json_path_key_using_brackets and self.JSON_PATH_SINGLE_QUOTE_ESCAPE:
3033            escaped = expression.replace("'", "\\'")
3034            escaped = f"\\'{expression}\\'"
3035        else:
3036            escaped = expression.replace('"', '\\"')
3037            escaped = f'"{escaped}"'
3038
3039        return escaped
3040
3041    def formatjson_sql(self, expression: exp.FormatJson) -> str:
3042        return f"{self.sql(expression, 'this')} FORMAT JSON"
3043
3044    def formatphrase_sql(self, expression: exp.FormatPhrase) -> str:
3045        # Output the Teradata column FORMAT override.
3046        # https://docs.teradata.com/r/Enterprise_IntelliFlex_VMware/SQL-Data-Types-and-Literals/Data-Type-Formats-and-Format-Phrases/FORMAT
3047        this = self.sql(expression, "this")
3048        fmt = self.sql(expression, "format")
3049        return f"{this} (FORMAT {fmt})"
3050
3051    def jsonobject_sql(self, expression: exp.JSONObject | exp.JSONObjectAgg) -> str:
3052        null_handling = expression.args.get("null_handling")
3053        null_handling = f" {null_handling}" if null_handling else ""
3054
3055        unique_keys = expression.args.get("unique_keys")
3056        if unique_keys is not None:
3057            unique_keys = f" {'WITH' if unique_keys else 'WITHOUT'} UNIQUE KEYS"
3058        else:
3059            unique_keys = ""
3060
3061        return_type = self.sql(expression, "return_type")
3062        return_type = f" RETURNING {return_type}" if return_type else ""
3063        encoding = self.sql(expression, "encoding")
3064        encoding = f" ENCODING {encoding}" if encoding else ""
3065
3066        return self.func(
3067            "JSON_OBJECT" if isinstance(expression, exp.JSONObject) else "JSON_OBJECTAGG",
3068            *expression.expressions,
3069            suffix=f"{null_handling}{unique_keys}{return_type}{encoding})",
3070        )
3071
3072    def jsonobjectagg_sql(self, expression: exp.JSONObjectAgg) -> str:
3073        return self.jsonobject_sql(expression)
3074
3075    def jsonarray_sql(self, expression: exp.JSONArray) -> str:
3076        null_handling = expression.args.get("null_handling")
3077        null_handling = f" {null_handling}" if null_handling else ""
3078        return_type = self.sql(expression, "return_type")
3079        return_type = f" RETURNING {return_type}" if return_type else ""
3080        strict = " STRICT" if expression.args.get("strict") else ""
3081        return self.func(
3082            "JSON_ARRAY", *expression.expressions, suffix=f"{null_handling}{return_type}{strict})"
3083        )
3084
3085    def jsonarrayagg_sql(self, expression: exp.JSONArrayAgg) -> str:
3086        this = self.sql(expression, "this")
3087        order = self.sql(expression, "order")
3088        null_handling = expression.args.get("null_handling")
3089        null_handling = f" {null_handling}" if null_handling else ""
3090        return_type = self.sql(expression, "return_type")
3091        return_type = f" RETURNING {return_type}" if return_type else ""
3092        strict = " STRICT" if expression.args.get("strict") else ""
3093        return self.func(
3094            "JSON_ARRAYAGG",
3095            this,
3096            suffix=f"{order}{null_handling}{return_type}{strict})",
3097        )
3098
3099    def jsoncolumndef_sql(self, expression: exp.JSONColumnDef) -> str:
3100        path = self.sql(expression, "path")
3101        path = f" PATH {path}" if path else ""
3102        nested_schema = self.sql(expression, "nested_schema")
3103
3104        if nested_schema:
3105            return f"NESTED{path} {nested_schema}"
3106
3107        this = self.sql(expression, "this")
3108        kind = self.sql(expression, "kind")
3109        kind = f" {kind}" if kind else ""
3110        return f"{this}{kind}{path}"
3111
3112    def jsonschema_sql(self, expression: exp.JSONSchema) -> str:
3113        return self.func("COLUMNS", *expression.expressions)
3114
3115    def jsontable_sql(self, expression: exp.JSONTable) -> str:
3116        this = self.sql(expression, "this")
3117        path = self.sql(expression, "path")
3118        path = f", {path}" if path else ""
3119        error_handling = expression.args.get("error_handling")
3120        error_handling = f" {error_handling}" if error_handling else ""
3121        empty_handling = expression.args.get("empty_handling")
3122        empty_handling = f" {empty_handling}" if empty_handling else ""
3123        schema = self.sql(expression, "schema")
3124        return self.func(
3125            "JSON_TABLE", this, suffix=f"{path}{error_handling}{empty_handling} {schema})"
3126        )
3127
3128    def openjsoncolumndef_sql(self, expression: exp.OpenJSONColumnDef) -> str:
3129        this = self.sql(expression, "this")
3130        kind = self.sql(expression, "kind")
3131        path = self.sql(expression, "path")
3132        path = f" {path}" if path else ""
3133        as_json = " AS JSON" if expression.args.get("as_json") else ""
3134        return f"{this} {kind}{path}{as_json}"
3135
3136    def openjson_sql(self, expression: exp.OpenJSON) -> str:
3137        this = self.sql(expression, "this")
3138        path = self.sql(expression, "path")
3139        path = f", {path}" if path else ""
3140        expressions = self.expressions(expression)
3141        with_ = (
3142            f" WITH ({self.seg(self.indent(expressions), sep='')}{self.seg(')', sep='')}"
3143            if expressions
3144            else ""
3145        )
3146        return f"OPENJSON({this}{path}){with_}"
3147
3148    def in_sql(self, expression: exp.In) -> str:
3149        query = expression.args.get("query")
3150        unnest = expression.args.get("unnest")
3151        field = expression.args.get("field")
3152        is_global = " GLOBAL" if expression.args.get("is_global") else ""
3153
3154        if query:
3155            in_sql = self.sql(query)
3156        elif unnest:
3157            in_sql = self.in_unnest_op(unnest)
3158        elif field:
3159            in_sql = self.sql(field)
3160        else:
3161            in_sql = f"({self.expressions(expression, dynamic=True, new_line=True, skip_first=True, skip_last=True)})"
3162
3163        return f"{self.sql(expression, 'this')}{is_global} IN {in_sql}"
3164
3165    def in_unnest_op(self, unnest: exp.Unnest) -> str:
3166        return f"(SELECT {self.sql(unnest)})"
3167
3168    def interval_sql(self, expression: exp.Interval) -> str:
3169        unit = self.sql(expression, "unit")
3170        if not self.INTERVAL_ALLOWS_PLURAL_FORM:
3171            unit = self.TIME_PART_SINGULARS.get(unit, unit)
3172        unit = f" {unit}" if unit else ""
3173
3174        if self.SINGLE_STRING_INTERVAL:
3175            this = expression.this.name if expression.this else ""
3176            return f"INTERVAL '{this}{unit}'" if this else f"INTERVAL{unit}"
3177
3178        this = self.sql(expression, "this")
3179        if this:
3180            unwrapped = isinstance(expression.this, self.UNWRAPPED_INTERVAL_VALUES)
3181            this = f" {this}" if unwrapped else f" ({this})"
3182
3183        return f"INTERVAL{this}{unit}"
3184
3185    def return_sql(self, expression: exp.Return) -> str:
3186        return f"RETURN {self.sql(expression, 'this')}"
3187
3188    def reference_sql(self, expression: exp.Reference) -> str:
3189        this = self.sql(expression, "this")
3190        expressions = self.expressions(expression, flat=True)
3191        expressions = f"({expressions})" if expressions else ""
3192        options = self.expressions(expression, key="options", flat=True, sep=" ")
3193        options = f" {options}" if options else ""
3194        return f"REFERENCES {this}{expressions}{options}"
3195
3196    def anonymous_sql(self, expression: exp.Anonymous) -> str:
3197        # We don't normalize qualified functions such as a.b.foo(), because they can be case-sensitive
3198        parent = expression.parent
3199        is_qualified = isinstance(parent, exp.Dot) and expression is parent.expression
3200        return self.func(
3201            self.sql(expression, "this"), *expression.expressions, normalize=not is_qualified
3202        )
3203
3204    def paren_sql(self, expression: exp.Paren) -> str:
3205        sql = self.seg(self.indent(self.sql(expression, "this")), sep="")
3206        return f"({sql}{self.seg(')', sep='')}"
3207
3208    def neg_sql(self, expression: exp.Neg) -> str:
3209        # This makes sure we don't convert "- - 5" to "--5", which is a comment
3210        this_sql = self.sql(expression, "this")
3211        sep = " " if this_sql[0] == "-" else ""
3212        return f"-{sep}{this_sql}"
3213
3214    def not_sql(self, expression: exp.Not) -> str:
3215        return f"NOT {self.sql(expression, 'this')}"
3216
3217    def alias_sql(self, expression: exp.Alias) -> str:
3218        alias = self.sql(expression, "alias")
3219        alias = f" AS {alias}" if alias else ""
3220        return f"{self.sql(expression, 'this')}{alias}"
3221
3222    def pivotalias_sql(self, expression: exp.PivotAlias) -> str:
3223        alias = expression.args["alias"]
3224
3225        parent = expression.parent
3226        pivot = parent and parent.parent
3227
3228        if isinstance(pivot, exp.Pivot) and pivot.unpivot:
3229            identifier_alias = isinstance(alias, exp.Identifier)
3230            literal_alias = isinstance(alias, exp.Literal)
3231
3232            if identifier_alias and not self.UNPIVOT_ALIASES_ARE_IDENTIFIERS:
3233                alias.replace(exp.Literal.string(alias.output_name))
3234            elif not identifier_alias and literal_alias and self.UNPIVOT_ALIASES_ARE_IDENTIFIERS:
3235                alias.replace(exp.to_identifier(alias.output_name))
3236
3237        return self.alias_sql(expression)
3238
3239    def aliases_sql(self, expression: exp.Aliases) -> str:
3240        return f"{self.sql(expression, 'this')} AS ({self.expressions(expression, flat=True)})"
3241
3242    def atindex_sql(self, expression: exp.AtTimeZone) -> str:
3243        this = self.sql(expression, "this")
3244        index = self.sql(expression, "expression")
3245        return f"{this} AT {index}"
3246
3247    def attimezone_sql(self, expression: exp.AtTimeZone) -> str:
3248        this = self.sql(expression, "this")
3249        zone = self.sql(expression, "zone")
3250        return f"{this} AT TIME ZONE {zone}"
3251
3252    def fromtimezone_sql(self, expression: exp.FromTimeZone) -> str:
3253        this = self.sql(expression, "this")
3254        zone = self.sql(expression, "zone")
3255        return f"{this} AT TIME ZONE {zone} AT TIME ZONE 'UTC'"
3256
3257    def add_sql(self, expression: exp.Add) -> str:
3258        return self.binary(expression, "+")
3259
3260    def and_sql(
3261        self, expression: exp.And, stack: t.Optional[t.List[str | exp.Expression]] = None
3262    ) -> str:
3263        return self.connector_sql(expression, "AND", stack)
3264
3265    def or_sql(
3266        self, expression: exp.Or, stack: t.Optional[t.List[str | exp.Expression]] = None
3267    ) -> str:
3268        return self.connector_sql(expression, "OR", stack)
3269
3270    def xor_sql(
3271        self, expression: exp.Xor, stack: t.Optional[t.List[str | exp.Expression]] = None
3272    ) -> str:
3273        return self.connector_sql(expression, "XOR", stack)
3274
3275    def connector_sql(
3276        self,
3277        expression: exp.Connector,
3278        op: str,
3279        stack: t.Optional[t.List[str | exp.Expression]] = None,
3280    ) -> str:
3281        if stack is not None:
3282            if expression.expressions:
3283                stack.append(self.expressions(expression, sep=f" {op} "))
3284            else:
3285                stack.append(expression.right)
3286                if expression.comments and self.comments:
3287                    for comment in expression.comments:
3288                        if comment:
3289                            op += f" /*{self.sanitize_comment(comment)}*/"
3290                stack.extend((op, expression.left))
3291            return op
3292
3293        stack = [expression]
3294        sqls: t.List[str] = []
3295        ops = set()
3296
3297        while stack:
3298            node = stack.pop()
3299            if isinstance(node, exp.Connector):
3300                ops.add(getattr(self, f"{node.key}_sql")(node, stack))
3301            else:
3302                sql = self.sql(node)
3303                if sqls and sqls[-1] in ops:
3304                    sqls[-1] += f" {sql}"
3305                else:
3306                    sqls.append(sql)
3307
3308        sep = "\n" if self.pretty and self.too_wide(sqls) else " "
3309        return sep.join(sqls)
3310
3311    def bitwiseand_sql(self, expression: exp.BitwiseAnd) -> str:
3312        return self.binary(expression, "&")
3313
3314    def bitwiseleftshift_sql(self, expression: exp.BitwiseLeftShift) -> str:
3315        return self.binary(expression, "<<")
3316
3317    def bitwisenot_sql(self, expression: exp.BitwiseNot) -> str:
3318        return f"~{self.sql(expression, 'this')}"
3319
3320    def bitwiseor_sql(self, expression: exp.BitwiseOr) -> str:
3321        return self.binary(expression, "|")
3322
3323    def bitwiserightshift_sql(self, expression: exp.BitwiseRightShift) -> str:
3324        return self.binary(expression, ">>")
3325
3326    def bitwisexor_sql(self, expression: exp.BitwiseXor) -> str:
3327        return self.binary(expression, "^")
3328
3329    def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
3330        format_sql = self.sql(expression, "format")
3331        format_sql = f" FORMAT {format_sql}" if format_sql else ""
3332        to_sql = self.sql(expression, "to")
3333        to_sql = f" {to_sql}" if to_sql else ""
3334        action = self.sql(expression, "action")
3335        action = f" {action}" if action else ""
3336        default = self.sql(expression, "default")
3337        default = f" DEFAULT {default} ON CONVERSION ERROR" if default else ""
3338        return f"{safe_prefix or ''}CAST({self.sql(expression, 'this')} AS{to_sql}{default}{format_sql}{action})"
3339
3340    def currentdate_sql(self, expression: exp.CurrentDate) -> str:
3341        zone = self.sql(expression, "this")
3342        return f"CURRENT_DATE({zone})" if zone else "CURRENT_DATE"
3343
3344    def collate_sql(self, expression: exp.Collate) -> str:
3345        if self.COLLATE_IS_FUNC:
3346            return self.function_fallback_sql(expression)
3347        return self.binary(expression, "COLLATE")
3348
3349    def command_sql(self, expression: exp.Command) -> str:
3350        return f"{self.sql(expression, 'this')} {expression.text('expression').strip()}"
3351
3352    def comment_sql(self, expression: exp.Comment) -> str:
3353        this = self.sql(expression, "this")
3354        kind = expression.args["kind"]
3355        materialized = " MATERIALIZED" if expression.args.get("materialized") else ""
3356        exists_sql = " IF EXISTS " if expression.args.get("exists") else " "
3357        expression_sql = self.sql(expression, "expression")
3358        return f"COMMENT{exists_sql}ON{materialized} {kind} {this} IS {expression_sql}"
3359
3360    def mergetreettlaction_sql(self, expression: exp.MergeTreeTTLAction) -> str:
3361        this = self.sql(expression, "this")
3362        delete = " DELETE" if expression.args.get("delete") else ""
3363        recompress = self.sql(expression, "recompress")
3364        recompress = f" RECOMPRESS {recompress}" if recompress else ""
3365        to_disk = self.sql(expression, "to_disk")
3366        to_disk = f" TO DISK {to_disk}" if to_disk else ""
3367        to_volume = self.sql(expression, "to_volume")
3368        to_volume = f" TO VOLUME {to_volume}" if to_volume else ""
3369        return f"{this}{delete}{recompress}{to_disk}{to_volume}"
3370
3371    def mergetreettl_sql(self, expression: exp.MergeTreeTTL) -> str:
3372        where = self.sql(expression, "where")
3373        group = self.sql(expression, "group")
3374        aggregates = self.expressions(expression, key="aggregates")
3375        aggregates = self.seg("SET") + self.seg(aggregates) if aggregates else ""
3376
3377        if not (where or group or aggregates) and len(expression.expressions) == 1:
3378            return f"TTL {self.expressions(expression, flat=True)}"
3379
3380        return f"TTL{self.seg(self.expressions(expression))}{where}{group}{aggregates}"
3381
3382    def transaction_sql(self, expression: exp.Transaction) -> str:
3383        return "BEGIN"
3384
3385    def commit_sql(self, expression: exp.Commit) -> str:
3386        chain = expression.args.get("chain")
3387        if chain is not None:
3388            chain = " AND CHAIN" if chain else " AND NO CHAIN"
3389
3390        return f"COMMIT{chain or ''}"
3391
3392    def rollback_sql(self, expression: exp.Rollback) -> str:
3393        savepoint = expression.args.get("savepoint")
3394        savepoint = f" TO {savepoint}" if savepoint else ""
3395        return f"ROLLBACK{savepoint}"
3396
3397    def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
3398        this = self.sql(expression, "this")
3399
3400        dtype = self.sql(expression, "dtype")
3401        if dtype:
3402            collate = self.sql(expression, "collate")
3403            collate = f" COLLATE {collate}" if collate else ""
3404            using = self.sql(expression, "using")
3405            using = f" USING {using}" if using else ""
3406            alter_set_type = self.ALTER_SET_TYPE + " " if self.ALTER_SET_TYPE else ""
3407            return f"ALTER COLUMN {this} {alter_set_type}{dtype}{collate}{using}"
3408
3409        default = self.sql(expression, "default")
3410        if default:
3411            return f"ALTER COLUMN {this} SET DEFAULT {default}"
3412
3413        comment = self.sql(expression, "comment")
3414        if comment:
3415            return f"ALTER COLUMN {this} COMMENT {comment}"
3416
3417        visible = expression.args.get("visible")
3418        if visible:
3419            return f"ALTER COLUMN {this} SET {visible}"
3420
3421        allow_null = expression.args.get("allow_null")
3422        drop = expression.args.get("drop")
3423
3424        if not drop and not allow_null:
3425            self.unsupported("Unsupported ALTER COLUMN syntax")
3426
3427        if allow_null is not None:
3428            keyword = "DROP" if drop else "SET"
3429            return f"ALTER COLUMN {this} {keyword} NOT NULL"
3430
3431        return f"ALTER COLUMN {this} DROP DEFAULT"
3432
3433    def alterindex_sql(self, expression: exp.AlterIndex) -> str:
3434        this = self.sql(expression, "this")
3435
3436        visible = expression.args.get("visible")
3437        visible_sql = "VISIBLE" if visible else "INVISIBLE"
3438
3439        return f"ALTER INDEX {this} {visible_sql}"
3440
3441    def alterdiststyle_sql(self, expression: exp.AlterDistStyle) -> str:
3442        this = self.sql(expression, "this")
3443        if not isinstance(expression.this, exp.Var):
3444            this = f"KEY DISTKEY {this}"
3445        return f"ALTER DISTSTYLE {this}"
3446
3447    def altersortkey_sql(self, expression: exp.AlterSortKey) -> str:
3448        compound = " COMPOUND" if expression.args.get("compound") else ""
3449        this = self.sql(expression, "this")
3450        expressions = self.expressions(expression, flat=True)
3451        expressions = f"({expressions})" if expressions else ""
3452        return f"ALTER{compound} SORTKEY {this or expressions}"
3453
3454    def alterrename_sql(self, expression: exp.AlterRename) -> str:
3455        if not self.RENAME_TABLE_WITH_DB:
3456            # Remove db from tables
3457            expression = expression.transform(
3458                lambda n: exp.table_(n.this) if isinstance(n, exp.Table) else n
3459            ).assert_is(exp.AlterRename)
3460        this = self.sql(expression, "this")
3461        return f"RENAME TO {this}"
3462
3463    def renamecolumn_sql(self, expression: exp.RenameColumn) -> str:
3464        exists = " IF EXISTS" if expression.args.get("exists") else ""
3465        old_column = self.sql(expression, "this")
3466        new_column = self.sql(expression, "to")
3467        return f"RENAME COLUMN{exists} {old_column} TO {new_column}"
3468
3469    def alterset_sql(self, expression: exp.AlterSet) -> str:
3470        exprs = self.expressions(expression, flat=True)
3471        if self.ALTER_SET_WRAPPED:
3472            exprs = f"({exprs})"
3473
3474        return f"SET {exprs}"
3475
3476    def alter_sql(self, expression: exp.Alter) -> str:
3477        actions = expression.args["actions"]
3478
3479        if not self.dialect.ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN and isinstance(
3480            actions[0], exp.ColumnDef
3481        ):
3482            actions_sql = self.expressions(expression, key="actions", flat=True)
3483            actions_sql = f"ADD {actions_sql}"
3484        else:
3485            actions_list = []
3486            for action in actions:
3487                if isinstance(action, (exp.ColumnDef, exp.Schema)):
3488                    action_sql = self.add_column_sql(action)
3489                else:
3490                    action_sql = self.sql(action)
3491                    if isinstance(action, exp.Query):
3492                        action_sql = f"AS {action_sql}"
3493
3494                actions_list.append(action_sql)
3495
3496            actions_sql = self.format_args(*actions_list).lstrip("\n")
3497
3498        exists = " IF EXISTS" if expression.args.get("exists") else ""
3499        on_cluster = self.sql(expression, "cluster")
3500        on_cluster = f" {on_cluster}" if on_cluster else ""
3501        only = " ONLY" if expression.args.get("only") else ""
3502        options = self.expressions(expression, key="options")
3503        options = f", {options}" if options else ""
3504        kind = self.sql(expression, "kind")
3505        not_valid = " NOT VALID" if expression.args.get("not_valid") else ""
3506
3507        return f"ALTER {kind}{exists}{only} {self.sql(expression, 'this')}{on_cluster}{self.sep()}{actions_sql}{not_valid}{options}"
3508
3509    def add_column_sql(self, expression: exp.Expression) -> str:
3510        sql = self.sql(expression)
3511        if isinstance(expression, exp.Schema):
3512            column_text = " COLUMNS"
3513        elif isinstance(expression, exp.ColumnDef) and self.ALTER_TABLE_INCLUDE_COLUMN_KEYWORD:
3514            column_text = " COLUMN"
3515        else:
3516            column_text = ""
3517
3518        return f"ADD{column_text} {sql}"
3519
3520    def droppartition_sql(self, expression: exp.DropPartition) -> str:
3521        expressions = self.expressions(expression)
3522        exists = " IF EXISTS " if expression.args.get("exists") else " "
3523        return f"DROP{exists}{expressions}"
3524
3525    def addconstraint_sql(self, expression: exp.AddConstraint) -> str:
3526        return f"ADD {self.expressions(expression, indent=False)}"
3527
3528    def addpartition_sql(self, expression: exp.AddPartition) -> str:
3529        exists = "IF NOT EXISTS " if expression.args.get("exists") else ""
3530        return f"ADD {exists}{self.sql(expression.this)}"
3531
3532    def distinct_sql(self, expression: exp.Distinct) -> str:
3533        this = self.expressions(expression, flat=True)
3534
3535        if not self.MULTI_ARG_DISTINCT and len(expression.expressions) > 1:
3536            case = exp.case()
3537            for arg in expression.expressions:
3538                case = case.when(arg.is_(exp.null()), exp.null())
3539            this = self.sql(case.else_(f"({this})"))
3540
3541        this = f" {this}" if this else ""
3542
3543        on = self.sql(expression, "on")
3544        on = f" ON {on}" if on else ""
3545        return f"DISTINCT{this}{on}"
3546
3547    def ignorenulls_sql(self, expression: exp.IgnoreNulls) -> str:
3548        return self._embed_ignore_nulls(expression, "IGNORE NULLS")
3549
3550    def respectnulls_sql(self, expression: exp.RespectNulls) -> str:
3551        return self._embed_ignore_nulls(expression, "RESPECT NULLS")
3552
3553    def havingmax_sql(self, expression: exp.HavingMax) -> str:
3554        this_sql = self.sql(expression, "this")
3555        expression_sql = self.sql(expression, "expression")
3556        kind = "MAX" if expression.args.get("max") else "MIN"
3557        return f"{this_sql} HAVING {kind} {expression_sql}"
3558
3559    def intdiv_sql(self, expression: exp.IntDiv) -> str:
3560        return self.sql(
3561            exp.Cast(
3562                this=exp.Div(this=expression.this, expression=expression.expression),
3563                to=exp.DataType(this=exp.DataType.Type.INT),
3564            )
3565        )
3566
3567    def dpipe_sql(self, expression: exp.DPipe) -> str:
3568        if self.dialect.STRICT_STRING_CONCAT and expression.args.get("safe"):
3569            return self.func(
3570                "CONCAT", *(exp.cast(e, exp.DataType.Type.TEXT) for e in expression.flatten())
3571            )
3572        return self.binary(expression, "||")
3573
3574    def div_sql(self, expression: exp.Div) -> str:
3575        l, r = expression.left, expression.right
3576
3577        if not self.dialect.SAFE_DIVISION and expression.args.get("safe"):
3578            r.replace(exp.Nullif(this=r.copy(), expression=exp.Literal.number(0)))
3579
3580        if self.dialect.TYPED_DIVISION and not expression.args.get("typed"):
3581            if not l.is_type(*exp.DataType.REAL_TYPES) and not r.is_type(*exp.DataType.REAL_TYPES):
3582                l.replace(exp.cast(l.copy(), to=exp.DataType.Type.DOUBLE))
3583
3584        elif not self.dialect.TYPED_DIVISION and expression.args.get("typed"):
3585            if l.is_type(*exp.DataType.INTEGER_TYPES) and r.is_type(*exp.DataType.INTEGER_TYPES):
3586                return self.sql(
3587                    exp.cast(
3588                        l / r,
3589                        to=exp.DataType.Type.BIGINT,
3590                    )
3591                )
3592
3593        return self.binary(expression, "/")
3594
3595    def safedivide_sql(self, expression: exp.SafeDivide) -> str:
3596        n = exp._wrap(expression.this, exp.Binary)
3597        d = exp._wrap(expression.expression, exp.Binary)
3598        return self.sql(exp.If(this=d.neq(0), true=n / d, false=exp.Null()))
3599
3600    def overlaps_sql(self, expression: exp.Overlaps) -> str:
3601        return self.binary(expression, "OVERLAPS")
3602
3603    def distance_sql(self, expression: exp.Distance) -> str:
3604        return self.binary(expression, "<->")
3605
3606    def dot_sql(self, expression: exp.Dot) -> str:
3607        return f"{self.sql(expression, 'this')}.{self.sql(expression, 'expression')}"
3608
3609    def eq_sql(self, expression: exp.EQ) -> str:
3610        return self.binary(expression, "=")
3611
3612    def propertyeq_sql(self, expression: exp.PropertyEQ) -> str:
3613        return self.binary(expression, ":=")
3614
3615    def escape_sql(self, expression: exp.Escape) -> str:
3616        return self.binary(expression, "ESCAPE")
3617
3618    def glob_sql(self, expression: exp.Glob) -> str:
3619        return self.binary(expression, "GLOB")
3620
3621    def gt_sql(self, expression: exp.GT) -> str:
3622        return self.binary(expression, ">")
3623
3624    def gte_sql(self, expression: exp.GTE) -> str:
3625        return self.binary(expression, ">=")
3626
3627    def ilike_sql(self, expression: exp.ILike) -> str:
3628        return self.binary(expression, "ILIKE")
3629
3630    def ilikeany_sql(self, expression: exp.ILikeAny) -> str:
3631        return self.binary(expression, "ILIKE ANY")
3632
3633    def is_sql(self, expression: exp.Is) -> str:
3634        if not self.IS_BOOL_ALLOWED and isinstance(expression.expression, exp.Boolean):
3635            return self.sql(
3636                expression.this if expression.expression.this else exp.not_(expression.this)
3637            )
3638        return self.binary(expression, "IS")
3639
3640    def like_sql(self, expression: exp.Like) -> str:
3641        return self.binary(expression, "LIKE")
3642
3643    def likeany_sql(self, expression: exp.LikeAny) -> str:
3644        return self.binary(expression, "LIKE ANY")
3645
3646    def similarto_sql(self, expression: exp.SimilarTo) -> str:
3647        return self.binary(expression, "SIMILAR TO")
3648
3649    def lt_sql(self, expression: exp.LT) -> str:
3650        return self.binary(expression, "<")
3651
3652    def lte_sql(self, expression: exp.LTE) -> str:
3653        return self.binary(expression, "<=")
3654
3655    def mod_sql(self, expression: exp.Mod) -> str:
3656        return self.binary(expression, "%")
3657
3658    def mul_sql(self, expression: exp.Mul) -> str:
3659        return self.binary(expression, "*")
3660
3661    def neq_sql(self, expression: exp.NEQ) -> str:
3662        return self.binary(expression, "<>")
3663
3664    def nullsafeeq_sql(self, expression: exp.NullSafeEQ) -> str:
3665        return self.binary(expression, "IS NOT DISTINCT FROM")
3666
3667    def nullsafeneq_sql(self, expression: exp.NullSafeNEQ) -> str:
3668        return self.binary(expression, "IS DISTINCT FROM")
3669
3670    def slice_sql(self, expression: exp.Slice) -> str:
3671        return self.binary(expression, ":")
3672
3673    def sub_sql(self, expression: exp.Sub) -> str:
3674        return self.binary(expression, "-")
3675
3676    def trycast_sql(self, expression: exp.TryCast) -> str:
3677        return self.cast_sql(expression, safe_prefix="TRY_")
3678
3679    def jsoncast_sql(self, expression: exp.JSONCast) -> str:
3680        return self.cast_sql(expression)
3681
3682    def try_sql(self, expression: exp.Try) -> str:
3683        if not self.TRY_SUPPORTED:
3684            self.unsupported("Unsupported TRY function")
3685            return self.sql(expression, "this")
3686
3687        return self.func("TRY", expression.this)
3688
3689    def log_sql(self, expression: exp.Log) -> str:
3690        this = expression.this
3691        expr = expression.expression
3692
3693        if self.dialect.LOG_BASE_FIRST is False:
3694            this, expr = expr, this
3695        elif self.dialect.LOG_BASE_FIRST is None and expr:
3696            if this.name in ("2", "10"):
3697                return self.func(f"LOG{this.name}", expr)
3698
3699            self.unsupported(f"Unsupported logarithm with base {self.sql(this)}")
3700
3701        return self.func("LOG", this, expr)
3702
3703    def use_sql(self, expression: exp.Use) -> str:
3704        kind = self.sql(expression, "kind")
3705        kind = f" {kind}" if kind else ""
3706        this = self.sql(expression, "this") or self.expressions(expression, flat=True)
3707        this = f" {this}" if this else ""
3708        return f"USE{kind}{this}"
3709
3710    def binary(self, expression: exp.Binary, op: str) -> str:
3711        sqls: t.List[str] = []
3712        stack: t.List[t.Union[str, exp.Expression]] = [expression]
3713        binary_type = type(expression)
3714
3715        while stack:
3716            node = stack.pop()
3717
3718            if type(node) is binary_type:
3719                op_func = node.args.get("operator")
3720                if op_func:
3721                    op = f"OPERATOR({self.sql(op_func)})"
3722
3723                stack.append(node.right)
3724                stack.append(f" {self.maybe_comment(op, comments=node.comments)} ")
3725                stack.append(node.left)
3726            else:
3727                sqls.append(self.sql(node))
3728
3729        return "".join(sqls)
3730
3731    def ceil_floor(self, expression: exp.Ceil | exp.Floor) -> str:
3732        to_clause = self.sql(expression, "to")
3733        if to_clause:
3734            return f"{expression.sql_name()}({self.sql(expression, 'this')} TO {to_clause})"
3735
3736        return self.function_fallback_sql(expression)
3737
3738    def function_fallback_sql(self, expression: exp.Func) -> str:
3739        args = []
3740
3741        for key in expression.arg_types:
3742            arg_value = expression.args.get(key)
3743
3744            if isinstance(arg_value, list):
3745                for value in arg_value:
3746                    args.append(value)
3747            elif arg_value is not None:
3748                args.append(arg_value)
3749
3750        if self.dialect.PRESERVE_ORIGINAL_NAMES:
3751            name = (expression._meta and expression.meta.get("name")) or expression.sql_name()
3752        else:
3753            name = expression.sql_name()
3754
3755        return self.func(name, *args)
3756
3757    def func(
3758        self,
3759        name: str,
3760        *args: t.Optional[exp.Expression | str],
3761        prefix: str = "(",
3762        suffix: str = ")",
3763        normalize: bool = True,
3764    ) -> str:
3765        name = self.normalize_func(name) if normalize else name
3766        return f"{name}{prefix}{self.format_args(*args)}{suffix}"
3767
3768    def format_args(self, *args: t.Optional[str | exp.Expression], sep: str = ", ") -> str:
3769        arg_sqls = tuple(
3770            self.sql(arg) for arg in args if arg is not None and not isinstance(arg, bool)
3771        )
3772        if self.pretty and self.too_wide(arg_sqls):
3773            return self.indent(
3774                "\n" + f"{sep.strip()}\n".join(arg_sqls) + "\n", skip_first=True, skip_last=True
3775            )
3776        return sep.join(arg_sqls)
3777
3778    def too_wide(self, args: t.Iterable) -> bool:
3779        return sum(len(arg) for arg in args) > self.max_text_width
3780
3781    def format_time(
3782        self,
3783        expression: exp.Expression,
3784        inverse_time_mapping: t.Optional[t.Dict[str, str]] = None,
3785        inverse_time_trie: t.Optional[t.Dict] = None,
3786    ) -> t.Optional[str]:
3787        return format_time(
3788            self.sql(expression, "format"),
3789            inverse_time_mapping or self.dialect.INVERSE_TIME_MAPPING,
3790            inverse_time_trie or self.dialect.INVERSE_TIME_TRIE,
3791        )
3792
3793    def expressions(
3794        self,
3795        expression: t.Optional[exp.Expression] = None,
3796        key: t.Optional[str] = None,
3797        sqls: t.Optional[t.Collection[str | exp.Expression]] = None,
3798        flat: bool = False,
3799        indent: bool = True,
3800        skip_first: bool = False,
3801        skip_last: bool = False,
3802        sep: str = ", ",
3803        prefix: str = "",
3804        dynamic: bool = False,
3805        new_line: bool = False,
3806    ) -> str:
3807        expressions = expression.args.get(key or "expressions") if expression else sqls
3808
3809        if not expressions:
3810            return ""
3811
3812        if flat:
3813            return sep.join(sql for sql in (self.sql(e) for e in expressions) if sql)
3814
3815        num_sqls = len(expressions)
3816        result_sqls = []
3817
3818        for i, e in enumerate(expressions):
3819            sql = self.sql(e, comment=False)
3820            if not sql:
3821                continue
3822
3823            comments = self.maybe_comment("", e) if isinstance(e, exp.Expression) else ""
3824
3825            if self.pretty:
3826                if self.leading_comma:
3827                    result_sqls.append(f"{sep if i > 0 else ''}{prefix}{sql}{comments}")
3828                else:
3829                    result_sqls.append(
3830                        f"{prefix}{sql}{(sep.rstrip() if comments else sep) if i + 1 < num_sqls else ''}{comments}"
3831                    )
3832            else:
3833                result_sqls.append(f"{prefix}{sql}{comments}{sep if i + 1 < num_sqls else ''}")
3834
3835        if self.pretty and (not dynamic or self.too_wide(result_sqls)):
3836            if new_line:
3837                result_sqls.insert(0, "")
3838                result_sqls.append("")
3839            result_sql = "\n".join(s.rstrip() for s in result_sqls)
3840        else:
3841            result_sql = "".join(result_sqls)
3842
3843        return (
3844            self.indent(result_sql, skip_first=skip_first, skip_last=skip_last)
3845            if indent
3846            else result_sql
3847        )
3848
3849    def op_expressions(self, op: str, expression: exp.Expression, flat: bool = False) -> str:
3850        flat = flat or isinstance(expression.parent, exp.Properties)
3851        expressions_sql = self.expressions(expression, flat=flat)
3852        if flat:
3853            return f"{op} {expressions_sql}"
3854        return f"{self.seg(op)}{self.sep() if expressions_sql else ''}{expressions_sql}"
3855
3856    def naked_property(self, expression: exp.Property) -> str:
3857        property_name = exp.Properties.PROPERTY_TO_NAME.get(expression.__class__)
3858        if not property_name:
3859            self.unsupported(f"Unsupported property {expression.__class__.__name__}")
3860        return f"{property_name} {self.sql(expression, 'this')}"
3861
3862    def tag_sql(self, expression: exp.Tag) -> str:
3863        return f"{expression.args.get('prefix')}{self.sql(expression.this)}{expression.args.get('postfix')}"
3864
3865    def token_sql(self, token_type: TokenType) -> str:
3866        return self.TOKEN_MAPPING.get(token_type, token_type.name)
3867
3868    def userdefinedfunction_sql(self, expression: exp.UserDefinedFunction) -> str:
3869        this = self.sql(expression, "this")
3870        expressions = self.no_identify(self.expressions, expression)
3871        expressions = (
3872            self.wrap(expressions) if expression.args.get("wrapped") else f" {expressions}"
3873        )
3874        return f"{this}{expressions}" if expressions.strip() != "" else this
3875
3876    def joinhint_sql(self, expression: exp.JoinHint) -> str:
3877        this = self.sql(expression, "this")
3878        expressions = self.expressions(expression, flat=True)
3879        return f"{this}({expressions})"
3880
3881    def kwarg_sql(self, expression: exp.Kwarg) -> str:
3882        return self.binary(expression, "=>")
3883
3884    def when_sql(self, expression: exp.When) -> str:
3885        matched = "MATCHED" if expression.args["matched"] else "NOT MATCHED"
3886        source = " BY SOURCE" if self.MATCHED_BY_SOURCE and expression.args.get("source") else ""
3887        condition = self.sql(expression, "condition")
3888        condition = f" AND {condition}" if condition else ""
3889
3890        then_expression = expression.args.get("then")
3891        if isinstance(then_expression, exp.Insert):
3892            this = self.sql(then_expression, "this")
3893            this = f"INSERT {this}" if this else "INSERT"
3894            then = self.sql(then_expression, "expression")
3895            then = f"{this} VALUES {then}" if then else this
3896        elif isinstance(then_expression, exp.Update):
3897            if isinstance(then_expression.args.get("expressions"), exp.Star):
3898                then = f"UPDATE {self.sql(then_expression, 'expressions')}"
3899            else:
3900                then = f"UPDATE SET{self.sep()}{self.expressions(then_expression)}"
3901        else:
3902            then = self.sql(then_expression)
3903        return f"WHEN {matched}{source}{condition} THEN {then}"
3904
3905    def whens_sql(self, expression: exp.Whens) -> str:
3906        return self.expressions(expression, sep=" ", indent=False)
3907
3908    def merge_sql(self, expression: exp.Merge) -> str:
3909        table = expression.this
3910        table_alias = ""
3911
3912        hints = table.args.get("hints")
3913        if hints and table.alias and isinstance(hints[0], exp.WithTableHint):
3914            # T-SQL syntax is MERGE ... <target_table> [WITH (<merge_hint>)] [[AS] table_alias]
3915            table_alias = f" AS {self.sql(table.args['alias'].pop())}"
3916
3917        this = self.sql(table)
3918        using = f"USING {self.sql(expression, 'using')}"
3919        on = f"ON {self.sql(expression, 'on')}"
3920        whens = self.sql(expression, "whens")
3921
3922        returning = self.sql(expression, "returning")
3923        if returning:
3924            whens = f"{whens}{returning}"
3925
3926        sep = self.sep()
3927
3928        return self.prepend_ctes(
3929            expression,
3930            f"MERGE INTO {this}{table_alias}{sep}{using}{sep}{on}{sep}{whens}",
3931        )
3932
3933    @unsupported_args("format")
3934    def tochar_sql(self, expression: exp.ToChar) -> str:
3935        return self.sql(exp.cast(expression.this, exp.DataType.Type.TEXT))
3936
3937    def tonumber_sql(self, expression: exp.ToNumber) -> str:
3938        if not self.SUPPORTS_TO_NUMBER:
3939            self.unsupported("Unsupported TO_NUMBER function")
3940            return self.sql(exp.cast(expression.this, exp.DataType.Type.DOUBLE))
3941
3942        fmt = expression.args.get("format")
3943        if not fmt:
3944            self.unsupported("Conversion format is required for TO_NUMBER")
3945            return self.sql(exp.cast(expression.this, exp.DataType.Type.DOUBLE))
3946
3947        return self.func("TO_NUMBER", expression.this, fmt)
3948
3949    def dictproperty_sql(self, expression: exp.DictProperty) -> str:
3950        this = self.sql(expression, "this")
3951        kind = self.sql(expression, "kind")
3952        settings_sql = self.expressions(expression, key="settings", sep=" ")
3953        args = f"({self.sep('')}{settings_sql}{self.seg(')', sep='')}" if settings_sql else "()"
3954        return f"{this}({kind}{args})"
3955
3956    def dictrange_sql(self, expression: exp.DictRange) -> str:
3957        this = self.sql(expression, "this")
3958        max = self.sql(expression, "max")
3959        min = self.sql(expression, "min")
3960        return f"{this}(MIN {min} MAX {max})"
3961
3962    def dictsubproperty_sql(self, expression: exp.DictSubProperty) -> str:
3963        return f"{self.sql(expression, 'this')} {self.sql(expression, 'value')}"
3964
3965    def duplicatekeyproperty_sql(self, expression: exp.DuplicateKeyProperty) -> str:
3966        return f"DUPLICATE KEY ({self.expressions(expression, flat=True)})"
3967
3968    # https://docs.starrocks.io/docs/sql-reference/sql-statements/table_bucket_part_index/CREATE_TABLE/
3969    def uniquekeyproperty_sql(self, expression: exp.UniqueKeyProperty) -> str:
3970        return f"UNIQUE KEY ({self.expressions(expression, flat=True)})"
3971
3972    # https://docs.starrocks.io/docs/sql-reference/sql-statements/data-definition/CREATE_TABLE/#distribution_desc
3973    def distributedbyproperty_sql(self, expression: exp.DistributedByProperty) -> str:
3974        expressions = self.expressions(expression, flat=True)
3975        expressions = f" {self.wrap(expressions)}" if expressions else ""
3976        buckets = self.sql(expression, "buckets")
3977        kind = self.sql(expression, "kind")
3978        buckets = f" BUCKETS {buckets}" if buckets else ""
3979        order = self.sql(expression, "order")
3980        return f"DISTRIBUTED BY {kind}{expressions}{buckets}{order}"
3981
3982    def oncluster_sql(self, expression: exp.OnCluster) -> str:
3983        return ""
3984
3985    def clusteredbyproperty_sql(self, expression: exp.ClusteredByProperty) -> str:
3986        expressions = self.expressions(expression, key="expressions", flat=True)
3987        sorted_by = self.expressions(expression, key="sorted_by", flat=True)
3988        sorted_by = f" SORTED BY ({sorted_by})" if sorted_by else ""
3989        buckets = self.sql(expression, "buckets")
3990        return f"CLUSTERED BY ({expressions}){sorted_by} INTO {buckets} BUCKETS"
3991
3992    def anyvalue_sql(self, expression: exp.AnyValue) -> str:
3993        this = self.sql(expression, "this")
3994        having = self.sql(expression, "having")
3995
3996        if having:
3997            this = f"{this} HAVING {'MAX' if expression.args.get('max') else 'MIN'} {having}"
3998
3999        return self.func("ANY_VALUE", this)
4000
4001    def querytransform_sql(self, expression: exp.QueryTransform) -> str:
4002        transform = self.func("TRANSFORM", *expression.expressions)
4003        row_format_before = self.sql(expression, "row_format_before")
4004        row_format_before = f" {row_format_before}" if row_format_before else ""
4005        record_writer = self.sql(expression, "record_writer")
4006        record_writer = f" RECORDWRITER {record_writer}" if record_writer else ""
4007        using = f" USING {self.sql(expression, 'command_script')}"
4008        schema = self.sql(expression, "schema")
4009        schema = f" AS {schema}" if schema else ""
4010        row_format_after = self.sql(expression, "row_format_after")
4011        row_format_after = f" {row_format_after}" if row_format_after else ""
4012        record_reader = self.sql(expression, "record_reader")
4013        record_reader = f" RECORDREADER {record_reader}" if record_reader else ""
4014        return f"{transform}{row_format_before}{record_writer}{using}{schema}{row_format_after}{record_reader}"
4015
4016    def indexconstraintoption_sql(self, expression: exp.IndexConstraintOption) -> str:
4017        key_block_size = self.sql(expression, "key_block_size")
4018        if key_block_size:
4019            return f"KEY_BLOCK_SIZE = {key_block_size}"
4020
4021        using = self.sql(expression, "using")
4022        if using:
4023            return f"USING {using}"
4024
4025        parser = self.sql(expression, "parser")
4026        if parser:
4027            return f"WITH PARSER {parser}"
4028
4029        comment = self.sql(expression, "comment")
4030        if comment:
4031            return f"COMMENT {comment}"
4032
4033        visible = expression.args.get("visible")
4034        if visible is not None:
4035            return "VISIBLE" if visible else "INVISIBLE"
4036
4037        engine_attr = self.sql(expression, "engine_attr")
4038        if engine_attr:
4039            return f"ENGINE_ATTRIBUTE = {engine_attr}"
4040
4041        secondary_engine_attr = self.sql(expression, "secondary_engine_attr")
4042        if secondary_engine_attr:
4043            return f"SECONDARY_ENGINE_ATTRIBUTE = {secondary_engine_attr}"
4044
4045        self.unsupported("Unsupported index constraint option.")
4046        return ""
4047
4048    def checkcolumnconstraint_sql(self, expression: exp.CheckColumnConstraint) -> str:
4049        enforced = " ENFORCED" if expression.args.get("enforced") else ""
4050        return f"CHECK ({self.sql(expression, 'this')}){enforced}"
4051
4052    def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
4053        kind = self.sql(expression, "kind")
4054        kind = f"{kind} INDEX" if kind else "INDEX"
4055        this = self.sql(expression, "this")
4056        this = f" {this}" if this else ""
4057        index_type = self.sql(expression, "index_type")
4058        index_type = f" USING {index_type}" if index_type else ""
4059        expressions = self.expressions(expression, flat=True)
4060        expressions = f" ({expressions})" if expressions else ""
4061        options = self.expressions(expression, key="options", sep=" ")
4062        options = f" {options}" if options else ""
4063        return f"{kind}{this}{index_type}{expressions}{options}"
4064
4065    def nvl2_sql(self, expression: exp.Nvl2) -> str:
4066        if self.NVL2_SUPPORTED:
4067            return self.function_fallback_sql(expression)
4068
4069        case = exp.Case().when(
4070            expression.this.is_(exp.null()).not_(copy=False),
4071            expression.args["true"],
4072            copy=False,
4073        )
4074        else_cond = expression.args.get("false")
4075        if else_cond:
4076            case.else_(else_cond, copy=False)
4077
4078        return self.sql(case)
4079
4080    def comprehension_sql(self, expression: exp.Comprehension) -> str:
4081        this = self.sql(expression, "this")
4082        expr = self.sql(expression, "expression")
4083        iterator = self.sql(expression, "iterator")
4084        condition = self.sql(expression, "condition")
4085        condition = f" IF {condition}" if condition else ""
4086        return f"{this} FOR {expr} IN {iterator}{condition}"
4087
4088    def columnprefix_sql(self, expression: exp.ColumnPrefix) -> str:
4089        return f"{self.sql(expression, 'this')}({self.sql(expression, 'expression')})"
4090
4091    def opclass_sql(self, expression: exp.Opclass) -> str:
4092        return f"{self.sql(expression, 'this')} {self.sql(expression, 'expression')}"
4093
4094    def predict_sql(self, expression: exp.Predict) -> str:
4095        model = self.sql(expression, "this")
4096        model = f"MODEL {model}"
4097        table = self.sql(expression, "expression")
4098        table = f"TABLE {table}" if not isinstance(expression.expression, exp.Subquery) else table
4099        parameters = self.sql(expression, "params_struct")
4100        return self.func("PREDICT", model, table, parameters or None)
4101
4102    def forin_sql(self, expression: exp.ForIn) -> str:
4103        this = self.sql(expression, "this")
4104        expression_sql = self.sql(expression, "expression")
4105        return f"FOR {this} DO {expression_sql}"
4106
4107    def refresh_sql(self, expression: exp.Refresh) -> str:
4108        this = self.sql(expression, "this")
4109        table = "" if isinstance(expression.this, exp.Literal) else "TABLE "
4110        return f"REFRESH {table}{this}"
4111
4112    def toarray_sql(self, expression: exp.ToArray) -> str:
4113        arg = expression.this
4114        if not arg.type:
4115            from sqlglot.optimizer.annotate_types import annotate_types
4116
4117            arg = annotate_types(arg, dialect=self.dialect)
4118
4119        if arg.is_type(exp.DataType.Type.ARRAY):
4120            return self.sql(arg)
4121
4122        cond_for_null = arg.is_(exp.null())
4123        return self.sql(exp.func("IF", cond_for_null, exp.null(), exp.array(arg, copy=False)))
4124
4125    def tsordstotime_sql(self, expression: exp.TsOrDsToTime) -> str:
4126        this = expression.this
4127        time_format = self.format_time(expression)
4128
4129        if time_format:
4130            return self.sql(
4131                exp.cast(
4132                    exp.StrToTime(this=this, format=expression.args["format"]),
4133                    exp.DataType.Type.TIME,
4134                )
4135            )
4136
4137        if isinstance(this, exp.TsOrDsToTime) or this.is_type(exp.DataType.Type.TIME):
4138            return self.sql(this)
4139
4140        return self.sql(exp.cast(this, exp.DataType.Type.TIME))
4141
4142    def tsordstotimestamp_sql(self, expression: exp.TsOrDsToTimestamp) -> str:
4143        this = expression.this
4144        if isinstance(this, exp.TsOrDsToTimestamp) or this.is_type(exp.DataType.Type.TIMESTAMP):
4145            return self.sql(this)
4146
4147        return self.sql(exp.cast(this, exp.DataType.Type.TIMESTAMP, dialect=self.dialect))
4148
4149    def tsordstodatetime_sql(self, expression: exp.TsOrDsToDatetime) -> str:
4150        this = expression.this
4151        if isinstance(this, exp.TsOrDsToDatetime) or this.is_type(exp.DataType.Type.DATETIME):
4152            return self.sql(this)
4153
4154        return self.sql(exp.cast(this, exp.DataType.Type.DATETIME, dialect=self.dialect))
4155
4156    def tsordstodate_sql(self, expression: exp.TsOrDsToDate) -> str:
4157        this = expression.this
4158        time_format = self.format_time(expression)
4159
4160        if time_format and time_format not in (self.dialect.TIME_FORMAT, self.dialect.DATE_FORMAT):
4161            return self.sql(
4162                exp.cast(
4163                    exp.StrToTime(this=this, format=expression.args["format"]),
4164                    exp.DataType.Type.DATE,
4165                )
4166            )
4167
4168        if isinstance(this, exp.TsOrDsToDate) or this.is_type(exp.DataType.Type.DATE):
4169            return self.sql(this)
4170
4171        return self.sql(exp.cast(this, exp.DataType.Type.DATE))
4172
4173    def unixdate_sql(self, expression: exp.UnixDate) -> str:
4174        return self.sql(
4175            exp.func(
4176                "DATEDIFF",
4177                expression.this,
4178                exp.cast(exp.Literal.string("1970-01-01"), exp.DataType.Type.DATE),
4179                "day",
4180            )
4181        )
4182
4183    def lastday_sql(self, expression: exp.LastDay) -> str:
4184        if self.LAST_DAY_SUPPORTS_DATE_PART:
4185            return self.function_fallback_sql(expression)
4186
4187        unit = expression.text("unit")
4188        if unit and unit != "MONTH":
4189            self.unsupported("Date parts are not supported in LAST_DAY.")
4190
4191        return self.func("LAST_DAY", expression.this)
4192
4193    def dateadd_sql(self, expression: exp.DateAdd) -> str:
4194        from sqlglot.dialects.dialect import unit_to_str
4195
4196        return self.func(
4197            "DATE_ADD", expression.this, expression.expression, unit_to_str(expression)
4198        )
4199
4200    def arrayany_sql(self, expression: exp.ArrayAny) -> str:
4201        if self.CAN_IMPLEMENT_ARRAY_ANY:
4202            filtered = exp.ArrayFilter(this=expression.this, expression=expression.expression)
4203            filtered_not_empty = exp.ArraySize(this=filtered).neq(0)
4204            original_is_empty = exp.ArraySize(this=expression.this).eq(0)
4205            return self.sql(exp.paren(original_is_empty.or_(filtered_not_empty)))
4206
4207        from sqlglot.dialects import Dialect
4208
4209        # SQLGlot's executor supports ARRAY_ANY, so we don't wanna warn for the SQLGlot dialect
4210        if self.dialect.__class__ != Dialect:
4211            self.unsupported("ARRAY_ANY is unsupported")
4212
4213        return self.function_fallback_sql(expression)
4214
4215    def struct_sql(self, expression: exp.Struct) -> str:
4216        expression.set(
4217            "expressions",
4218            [
4219                exp.alias_(e.expression, e.name if e.this.is_string else e.this)
4220                if isinstance(e, exp.PropertyEQ)
4221                else e
4222                for e in expression.expressions
4223            ],
4224        )
4225
4226        return self.function_fallback_sql(expression)
4227
4228    def partitionrange_sql(self, expression: exp.PartitionRange) -> str:
4229        low = self.sql(expression, "this")
4230        high = self.sql(expression, "expression")
4231
4232        return f"{low} TO {high}"
4233
4234    def truncatetable_sql(self, expression: exp.TruncateTable) -> str:
4235        target = "DATABASE" if expression.args.get("is_database") else "TABLE"
4236        tables = f" {self.expressions(expression)}"
4237
4238        exists = " IF EXISTS" if expression.args.get("exists") else ""
4239
4240        on_cluster = self.sql(expression, "cluster")
4241        on_cluster = f" {on_cluster}" if on_cluster else ""
4242
4243        identity = self.sql(expression, "identity")
4244        identity = f" {identity} IDENTITY" if identity else ""
4245
4246        option = self.sql(expression, "option")
4247        option = f" {option}" if option else ""
4248
4249        partition = self.sql(expression, "partition")
4250        partition = f" {partition}" if partition else ""
4251
4252        return f"TRUNCATE {target}{exists}{tables}{on_cluster}{identity}{option}{partition}"
4253
4254    # This transpiles T-SQL's CONVERT function
4255    # https://learn.microsoft.com/en-us/sql/t-sql/functions/cast-and-convert-transact-sql?view=sql-server-ver16
4256    def convert_sql(self, expression: exp.Convert) -> str:
4257        to = expression.this
4258        value = expression.expression
4259        style = expression.args.get("style")
4260        safe = expression.args.get("safe")
4261        strict = expression.args.get("strict")
4262
4263        if not to or not value:
4264            return ""
4265
4266        # Retrieve length of datatype and override to default if not specified
4267        if not seq_get(to.expressions, 0) and to.this in self.PARAMETERIZABLE_TEXT_TYPES:
4268            to = exp.DataType.build(to.this, expressions=[exp.Literal.number(30)], nested=False)
4269
4270        transformed: t.Optional[exp.Expression] = None
4271        cast = exp.Cast if strict else exp.TryCast
4272
4273        # Check whether a conversion with format (T-SQL calls this 'style') is applicable
4274        if isinstance(style, exp.Literal) and style.is_int:
4275            from sqlglot.dialects.tsql import TSQL
4276
4277            style_value = style.name
4278            converted_style = TSQL.CONVERT_FORMAT_MAPPING.get(style_value)
4279            if not converted_style:
4280                self.unsupported(f"Unsupported T-SQL 'style' value: {style_value}")
4281
4282            fmt = exp.Literal.string(converted_style)
4283
4284            if to.this == exp.DataType.Type.DATE:
4285                transformed = exp.StrToDate(this=value, format=fmt)
4286            elif to.this in (exp.DataType.Type.DATETIME, exp.DataType.Type.DATETIME2):
4287                transformed = exp.StrToTime(this=value, format=fmt)
4288            elif to.this in self.PARAMETERIZABLE_TEXT_TYPES:
4289                transformed = cast(this=exp.TimeToStr(this=value, format=fmt), to=to, safe=safe)
4290            elif to.this == exp.DataType.Type.TEXT:
4291                transformed = exp.TimeToStr(this=value, format=fmt)
4292
4293        if not transformed:
4294            transformed = cast(this=value, to=to, safe=safe)
4295
4296        return self.sql(transformed)
4297
4298    def _jsonpathkey_sql(self, expression: exp.JSONPathKey) -> str:
4299        this = expression.this
4300        if isinstance(this, exp.JSONPathWildcard):
4301            this = self.json_path_part(this)
4302            return f".{this}" if this else ""
4303
4304        if exp.SAFE_IDENTIFIER_RE.match(this):
4305            return f".{this}"
4306
4307        this = self.json_path_part(this)
4308        return (
4309            f"[{this}]"
4310            if self._quote_json_path_key_using_brackets and self.JSON_PATH_BRACKETED_KEY_SUPPORTED
4311            else f".{this}"
4312        )
4313
4314    def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str:
4315        this = self.json_path_part(expression.this)
4316        return f"[{this}]" if this else ""
4317
4318    def _simplify_unless_literal(self, expression: E) -> E:
4319        if not isinstance(expression, exp.Literal):
4320            from sqlglot.optimizer.simplify import simplify
4321
4322            expression = simplify(expression, dialect=self.dialect)
4323
4324        return expression
4325
4326    def _embed_ignore_nulls(self, expression: exp.IgnoreNulls | exp.RespectNulls, text: str) -> str:
4327        this = expression.this
4328        if isinstance(this, self.RESPECT_IGNORE_NULLS_UNSUPPORTED_EXPRESSIONS):
4329            self.unsupported(
4330                f"RESPECT/IGNORE NULLS is not supported for {type(this).key} in {self.dialect.__class__.__name__}"
4331            )
4332            return self.sql(this)
4333
4334        if self.IGNORE_NULLS_IN_FUNC and not expression.meta.get("inline"):
4335            # The first modifier here will be the one closest to the AggFunc's arg
4336            mods = sorted(
4337                expression.find_all(exp.HavingMax, exp.Order, exp.Limit),
4338                key=lambda x: 0
4339                if isinstance(x, exp.HavingMax)
4340                else (1 if isinstance(x, exp.Order) else 2),
4341            )
4342
4343            if mods:
4344                mod = mods[0]
4345                this = expression.__class__(this=mod.this.copy())
4346                this.meta["inline"] = True
4347                mod.this.replace(this)
4348                return self.sql(expression.this)
4349
4350            agg_func = expression.find(exp.AggFunc)
4351
4352            if agg_func:
4353                agg_func_sql = self.sql(agg_func, comment=False)[:-1] + f" {text})"
4354                return self.maybe_comment(agg_func_sql, comments=agg_func.comments)
4355
4356        return f"{self.sql(expression, 'this')} {text}"
4357
4358    def _replace_line_breaks(self, string: str) -> str:
4359        """We don't want to extra indent line breaks so we temporarily replace them with sentinels."""
4360        if self.pretty:
4361            return string.replace("\n", self.SENTINEL_LINE_BREAK)
4362        return string
4363
4364    def copyparameter_sql(self, expression: exp.CopyParameter) -> str:
4365        option = self.sql(expression, "this")
4366
4367        if expression.expressions:
4368            upper = option.upper()
4369
4370            # Snowflake FILE_FORMAT options are separated by whitespace
4371            sep = " " if upper == "FILE_FORMAT" else ", "
4372
4373            # Databricks copy/format options do not set their list of values with EQ
4374            op = " " if upper in ("COPY_OPTIONS", "FORMAT_OPTIONS") else " = "
4375            values = self.expressions(expression, flat=True, sep=sep)
4376            return f"{option}{op}({values})"
4377
4378        value = self.sql(expression, "expression")
4379
4380        if not value:
4381            return option
4382
4383        op = " = " if self.COPY_PARAMS_EQ_REQUIRED else " "
4384
4385        return f"{option}{op}{value}"
4386
4387    def credentials_sql(self, expression: exp.Credentials) -> str:
4388        cred_expr = expression.args.get("credentials")
4389        if isinstance(cred_expr, exp.Literal):
4390            # Redshift case: CREDENTIALS <string>
4391            credentials = self.sql(expression, "credentials")
4392            credentials = f"CREDENTIALS {credentials}" if credentials else ""
4393        else:
4394            # Snowflake case: CREDENTIALS = (...)
4395            credentials = self.expressions(expression, key="credentials", flat=True, sep=" ")
4396            credentials = f"CREDENTIALS = ({credentials})" if cred_expr is not None else ""
4397
4398        storage = self.sql(expression, "storage")
4399        storage = f"STORAGE_INTEGRATION = {storage}" if storage else ""
4400
4401        encryption = self.expressions(expression, key="encryption", flat=True, sep=" ")
4402        encryption = f" ENCRYPTION = ({encryption})" if encryption else ""
4403
4404        iam_role = self.sql(expression, "iam_role")
4405        iam_role = f"IAM_ROLE {iam_role}" if iam_role else ""
4406
4407        region = self.sql(expression, "region")
4408        region = f" REGION {region}" if region else ""
4409
4410        return f"{credentials}{storage}{encryption}{iam_role}{region}"
4411
4412    def copy_sql(self, expression: exp.Copy) -> str:
4413        this = self.sql(expression, "this")
4414        this = f" INTO {this}" if self.COPY_HAS_INTO_KEYWORD else f" {this}"
4415
4416        credentials = self.sql(expression, "credentials")
4417        credentials = self.seg(credentials) if credentials else ""
4418        kind = self.seg("FROM" if expression.args.get("kind") else "TO")
4419        files = self.expressions(expression, key="files", flat=True)
4420
4421        sep = ", " if self.dialect.COPY_PARAMS_ARE_CSV else " "
4422        params = self.expressions(
4423            expression,
4424            key="params",
4425            sep=sep,
4426            new_line=True,
4427            skip_last=True,
4428            skip_first=True,
4429            indent=self.COPY_PARAMS_ARE_WRAPPED,
4430        )
4431
4432        if params:
4433            if self.COPY_PARAMS_ARE_WRAPPED:
4434                params = f" WITH ({params})"
4435            elif not self.pretty:
4436                params = f" {params}"
4437
4438        return f"COPY{this}{kind} {files}{credentials}{params}"
4439
4440    def semicolon_sql(self, expression: exp.Semicolon) -> str:
4441        return ""
4442
4443    def datadeletionproperty_sql(self, expression: exp.DataDeletionProperty) -> str:
4444        on_sql = "ON" if expression.args.get("on") else "OFF"
4445        filter_col: t.Optional[str] = self.sql(expression, "filter_column")
4446        filter_col = f"FILTER_COLUMN={filter_col}" if filter_col else None
4447        retention_period: t.Optional[str] = self.sql(expression, "retention_period")
4448        retention_period = f"RETENTION_PERIOD={retention_period}" if retention_period else None
4449
4450        if filter_col or retention_period:
4451            on_sql = self.func("ON", filter_col, retention_period)
4452
4453        return f"DATA_DELETION={on_sql}"
4454
4455    def maskingpolicycolumnconstraint_sql(
4456        self, expression: exp.MaskingPolicyColumnConstraint
4457    ) -> str:
4458        this = self.sql(expression, "this")
4459        expressions = self.expressions(expression, flat=True)
4460        expressions = f" USING ({expressions})" if expressions else ""
4461        return f"MASKING POLICY {this}{expressions}"
4462
4463    def gapfill_sql(self, expression: exp.GapFill) -> str:
4464        this = self.sql(expression, "this")
4465        this = f"TABLE {this}"
4466        return self.func("GAP_FILL", this, *[v for k, v in expression.args.items() if k != "this"])
4467
4468    def scope_resolution(self, rhs: str, scope_name: str) -> str:
4469        return self.func("SCOPE_RESOLUTION", scope_name or None, rhs)
4470
4471    def scoperesolution_sql(self, expression: exp.ScopeResolution) -> str:
4472        this = self.sql(expression, "this")
4473        expr = expression.expression
4474
4475        if isinstance(expr, exp.Func):
4476            # T-SQL's CLR functions are case sensitive
4477            expr = f"{self.sql(expr, 'this')}({self.format_args(*expr.expressions)})"
4478        else:
4479            expr = self.sql(expression, "expression")
4480
4481        return self.scope_resolution(expr, this)
4482
4483    def parsejson_sql(self, expression: exp.ParseJSON) -> str:
4484        if self.PARSE_JSON_NAME is None:
4485            return self.sql(expression.this)
4486
4487        return self.func(self.PARSE_JSON_NAME, expression.this, expression.expression)
4488
4489    def rand_sql(self, expression: exp.Rand) -> str:
4490        lower = self.sql(expression, "lower")
4491        upper = self.sql(expression, "upper")
4492
4493        if lower and upper:
4494            return f"({upper} - {lower}) * {self.func('RAND', expression.this)} + {lower}"
4495        return self.func("RAND", expression.this)
4496
4497    def changes_sql(self, expression: exp.Changes) -> str:
4498        information = self.sql(expression, "information")
4499        information = f"INFORMATION => {information}"
4500        at_before = self.sql(expression, "at_before")
4501        at_before = f"{self.seg('')}{at_before}" if at_before else ""
4502        end = self.sql(expression, "end")
4503        end = f"{self.seg('')}{end}" if end else ""
4504
4505        return f"CHANGES ({information}){at_before}{end}"
4506
4507    def pad_sql(self, expression: exp.Pad) -> str:
4508        prefix = "L" if expression.args.get("is_left") else "R"
4509
4510        fill_pattern = self.sql(expression, "fill_pattern") or None
4511        if not fill_pattern and self.PAD_FILL_PATTERN_IS_REQUIRED:
4512            fill_pattern = "' '"
4513
4514        return self.func(f"{prefix}PAD", expression.this, expression.expression, fill_pattern)
4515
4516    def summarize_sql(self, expression: exp.Summarize) -> str:
4517        table = " TABLE" if expression.args.get("table") else ""
4518        return f"SUMMARIZE{table} {self.sql(expression.this)}"
4519
4520    def explodinggenerateseries_sql(self, expression: exp.ExplodingGenerateSeries) -> str:
4521        generate_series = exp.GenerateSeries(**expression.args)
4522
4523        parent = expression.parent
4524        if isinstance(parent, (exp.Alias, exp.TableAlias)):
4525            parent = parent.parent
4526
4527        if self.SUPPORTS_EXPLODING_PROJECTIONS and not isinstance(parent, (exp.Table, exp.Unnest)):
4528            return self.sql(exp.Unnest(expressions=[generate_series]))
4529
4530        if isinstance(parent, exp.Select):
4531            self.unsupported("GenerateSeries projection unnesting is not supported.")
4532
4533        return self.sql(generate_series)
4534
4535    def arrayconcat_sql(self, expression: exp.ArrayConcat, name: str = "ARRAY_CONCAT") -> str:
4536        exprs = expression.expressions
4537        if not self.ARRAY_CONCAT_IS_VAR_LEN:
4538            rhs = reduce(lambda x, y: exp.ArrayConcat(this=x, expressions=[y]), exprs)
4539        else:
4540            rhs = self.expressions(expression)
4541
4542        return self.func(name, expression.this, rhs or None)
4543
4544    def converttimezone_sql(self, expression: exp.ConvertTimezone) -> str:
4545        if self.SUPPORTS_CONVERT_TIMEZONE:
4546            return self.function_fallback_sql(expression)
4547
4548        source_tz = expression.args.get("source_tz")
4549        target_tz = expression.args.get("target_tz")
4550        timestamp = expression.args.get("timestamp")
4551
4552        if source_tz and timestamp:
4553            timestamp = exp.AtTimeZone(
4554                this=exp.cast(timestamp, exp.DataType.Type.TIMESTAMPNTZ), zone=source_tz
4555            )
4556
4557        expr = exp.AtTimeZone(this=timestamp, zone=target_tz)
4558
4559        return self.sql(expr)
4560
4561    def json_sql(self, expression: exp.JSON) -> str:
4562        this = self.sql(expression, "this")
4563        this = f" {this}" if this else ""
4564
4565        _with = expression.args.get("with")
4566
4567        if _with is None:
4568            with_sql = ""
4569        elif not _with:
4570            with_sql = " WITHOUT"
4571        else:
4572            with_sql = " WITH"
4573
4574        unique_sql = " UNIQUE KEYS" if expression.args.get("unique") else ""
4575
4576        return f"JSON{this}{with_sql}{unique_sql}"
4577
4578    def jsonvalue_sql(self, expression: exp.JSONValue) -> str:
4579        def _generate_on_options(arg: t.Any) -> str:
4580            return arg if isinstance(arg, str) else f"DEFAULT {self.sql(arg)}"
4581
4582        path = self.sql(expression, "path")
4583        returning = self.sql(expression, "returning")
4584        returning = f" RETURNING {returning}" if returning else ""
4585
4586        on_condition = self.sql(expression, "on_condition")
4587        on_condition = f" {on_condition}" if on_condition else ""
4588
4589        return self.func("JSON_VALUE", expression.this, f"{path}{returning}{on_condition}")
4590
4591    def conditionalinsert_sql(self, expression: exp.ConditionalInsert) -> str:
4592        else_ = "ELSE " if expression.args.get("else_") else ""
4593        condition = self.sql(expression, "expression")
4594        condition = f"WHEN {condition} THEN " if condition else else_
4595        insert = self.sql(expression, "this")[len("INSERT") :].strip()
4596        return f"{condition}{insert}"
4597
4598    def multitableinserts_sql(self, expression: exp.MultitableInserts) -> str:
4599        kind = self.sql(expression, "kind")
4600        expressions = self.seg(self.expressions(expression, sep=" "))
4601        res = f"INSERT {kind}{expressions}{self.seg(self.sql(expression, 'source'))}"
4602        return res
4603
4604    def oncondition_sql(self, expression: exp.OnCondition) -> str:
4605        # Static options like "NULL ON ERROR" are stored as strings, in contrast to "DEFAULT <expr> ON ERROR"
4606        empty = expression.args.get("empty")
4607        empty = (
4608            f"DEFAULT {empty} ON EMPTY"
4609            if isinstance(empty, exp.Expression)
4610            else self.sql(expression, "empty")
4611        )
4612
4613        error = expression.args.get("error")
4614        error = (
4615            f"DEFAULT {error} ON ERROR"
4616            if isinstance(error, exp.Expression)
4617            else self.sql(expression, "error")
4618        )
4619
4620        if error and empty:
4621            error = (
4622                f"{empty} {error}"
4623                if self.dialect.ON_CONDITION_EMPTY_BEFORE_ERROR
4624                else f"{error} {empty}"
4625            )
4626            empty = ""
4627
4628        null = self.sql(expression, "null")
4629
4630        return f"{empty}{error}{null}"
4631
4632    def jsonextractquote_sql(self, expression: exp.JSONExtractQuote) -> str:
4633        scalar = " ON SCALAR STRING" if expression.args.get("scalar") else ""
4634        return f"{self.sql(expression, 'option')} QUOTES{scalar}"
4635
4636    def jsonexists_sql(self, expression: exp.JSONExists) -> str:
4637        this = self.sql(expression, "this")
4638        path = self.sql(expression, "path")
4639
4640        passing = self.expressions(expression, "passing")
4641        passing = f" PASSING {passing}" if passing else ""
4642
4643        on_condition = self.sql(expression, "on_condition")
4644        on_condition = f" {on_condition}" if on_condition else ""
4645
4646        path = f"{path}{passing}{on_condition}"
4647
4648        return self.func("JSON_EXISTS", this, path)
4649
4650    def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
4651        array_agg = self.function_fallback_sql(expression)
4652
4653        # Add a NULL FILTER on the column to mimic the results going from a dialect that excludes nulls
4654        # on ARRAY_AGG (e.g Spark) to one that doesn't (e.g. DuckDB)
4655        if self.dialect.ARRAY_AGG_INCLUDES_NULLS and expression.args.get("nulls_excluded"):
4656            parent = expression.parent
4657            if isinstance(parent, exp.Filter):
4658                parent_cond = parent.expression.this
4659                parent_cond.replace(parent_cond.and_(expression.this.is_(exp.null()).not_()))
4660            else:
4661                this = expression.this
4662                # Do not add the filter if the input is not a column (e.g. literal, struct etc)
4663                if this.find(exp.Column):
4664                    # DISTINCT is already present in the agg function, do not propagate it to FILTER as well
4665                    this_sql = (
4666                        self.expressions(this)
4667                        if isinstance(this, exp.Distinct)
4668                        else self.sql(expression, "this")
4669                    )
4670
4671                    array_agg = f"{array_agg} FILTER(WHERE {this_sql} IS NOT NULL)"
4672
4673        return array_agg
4674
4675    def apply_sql(self, expression: exp.Apply) -> str:
4676        this = self.sql(expression, "this")
4677        expr = self.sql(expression, "expression")
4678
4679        return f"{this} APPLY({expr})"
4680
4681    def grant_sql(self, expression: exp.Grant) -> str:
4682        privileges_sql = self.expressions(expression, key="privileges", flat=True)
4683
4684        kind = self.sql(expression, "kind")
4685        kind = f" {kind}" if kind else ""
4686
4687        securable = self.sql(expression, "securable")
4688        securable = f" {securable}" if securable else ""
4689
4690        principals = self.expressions(expression, key="principals", flat=True)
4691
4692        grant_option = " WITH GRANT OPTION" if expression.args.get("grant_option") else ""
4693
4694        return f"GRANT {privileges_sql} ON{kind}{securable} TO {principals}{grant_option}"
4695
4696    def grantprivilege_sql(self, expression: exp.GrantPrivilege):
4697        this = self.sql(expression, "this")
4698        columns = self.expressions(expression, flat=True)
4699        columns = f"({columns})" if columns else ""
4700
4701        return f"{this}{columns}"
4702
4703    def grantprincipal_sql(self, expression: exp.GrantPrincipal):
4704        this = self.sql(expression, "this")
4705
4706        kind = self.sql(expression, "kind")
4707        kind = f"{kind} " if kind else ""
4708
4709        return f"{kind}{this}"
4710
4711    def columns_sql(self, expression: exp.Columns):
4712        func = self.function_fallback_sql(expression)
4713        if expression.args.get("unpack"):
4714            func = f"*{func}"
4715
4716        return func
4717
4718    def overlay_sql(self, expression: exp.Overlay):
4719        this = self.sql(expression, "this")
4720        expr = self.sql(expression, "expression")
4721        from_sql = self.sql(expression, "from")
4722        for_sql = self.sql(expression, "for")
4723        for_sql = f" FOR {for_sql}" if for_sql else ""
4724
4725        return f"OVERLAY({this} PLACING {expr} FROM {from_sql}{for_sql})"
4726
4727    @unsupported_args("format")
4728    def todouble_sql(self, expression: exp.ToDouble) -> str:
4729        return self.sql(exp.cast(expression.this, exp.DataType.Type.DOUBLE))
4730
4731    def string_sql(self, expression: exp.String) -> str:
4732        this = expression.this
4733        zone = expression.args.get("zone")
4734
4735        if zone:
4736            # This is a BigQuery specific argument for STRING(<timestamp_expr>, <time_zone>)
4737            # BigQuery stores timestamps internally as UTC, so ConvertTimezone is used with UTC
4738            # set for source_tz to transpile the time conversion before the STRING cast
4739            this = exp.ConvertTimezone(
4740                source_tz=exp.Literal.string("UTC"), target_tz=zone, timestamp=this
4741            )
4742
4743        return self.sql(exp.cast(this, exp.DataType.Type.VARCHAR))
4744
4745    def median_sql(self, expression: exp.Median):
4746        if not self.SUPPORTS_MEDIAN:
4747            return self.sql(
4748                exp.PercentileCont(this=expression.this, expression=exp.Literal.number(0.5))
4749            )
4750
4751        return self.function_fallback_sql(expression)
4752
4753    def overflowtruncatebehavior_sql(self, expression: exp.OverflowTruncateBehavior) -> str:
4754        filler = self.sql(expression, "this")
4755        filler = f" {filler}" if filler else ""
4756        with_count = "WITH COUNT" if expression.args.get("with_count") else "WITHOUT COUNT"
4757        return f"TRUNCATE{filler} {with_count}"
4758
4759    def unixseconds_sql(self, expression: exp.UnixSeconds) -> str:
4760        if self.SUPPORTS_UNIX_SECONDS:
4761            return self.function_fallback_sql(expression)
4762
4763        start_ts = exp.cast(
4764            exp.Literal.string("1970-01-01 00:00:00+00"), to=exp.DataType.Type.TIMESTAMPTZ
4765        )
4766
4767        return self.sql(
4768            exp.TimestampDiff(this=expression.this, expression=start_ts, unit=exp.var("SECONDS"))
4769        )
4770
4771    def arraysize_sql(self, expression: exp.ArraySize) -> str:
4772        dim = expression.expression
4773
4774        # For dialects that don't support the dimension arg, we can safely transpile it's default value (1st dimension)
4775        if dim and self.ARRAY_SIZE_DIM_REQUIRED is None:
4776            if not (dim.is_int and dim.name == "1"):
4777                self.unsupported("Cannot transpile dimension argument for ARRAY_LENGTH")
4778            dim = None
4779
4780        # If dimension is required but not specified, default initialize it
4781        if self.ARRAY_SIZE_DIM_REQUIRED and not dim:
4782            dim = exp.Literal.number(1)
4783
4784        return self.func(self.ARRAY_SIZE_NAME, expression.this, dim)
4785
4786    def attach_sql(self, expression: exp.Attach) -> str:
4787        this = self.sql(expression, "this")
4788        exists_sql = " IF NOT EXISTS" if expression.args.get("exists") else ""
4789        expressions = self.expressions(expression)
4790        expressions = f" ({expressions})" if expressions else ""
4791
4792        return f"ATTACH{exists_sql} {this}{expressions}"
4793
4794    def detach_sql(self, expression: exp.Detach) -> str:
4795        this = self.sql(expression, "this")
4796        # the DATABASE keyword is required if IF EXISTS is set
4797        # without it, DuckDB throws an error: Parser Error: syntax error at or near "exists" (Line Number: 1)
4798        # ref: https://duckdb.org/docs/stable/sql/statements/attach.html#detach-syntax
4799        exists_sql = " DATABASE IF EXISTS" if expression.args.get("exists") else ""
4800
4801        return f"DETACH{exists_sql} {this}"
4802
4803    def attachoption_sql(self, expression: exp.AttachOption) -> str:
4804        this = self.sql(expression, "this")
4805        value = self.sql(expression, "expression")
4806        value = f" {value}" if value else ""
4807        return f"{this}{value}"
4808
4809    def featuresattime_sql(self, expression: exp.FeaturesAtTime) -> str:
4810        this_sql = self.sql(expression, "this")
4811        if isinstance(expression.this, exp.Table):
4812            this_sql = f"TABLE {this_sql}"
4813
4814        return self.func(
4815            "FEATURES_AT_TIME",
4816            this_sql,
4817            expression.args.get("time"),
4818            expression.args.get("num_rows"),
4819            expression.args.get("ignore_feature_nulls"),
4820        )
4821
4822    def watermarkcolumnconstraint_sql(self, expression: exp.WatermarkColumnConstraint) -> str:
4823        return (
4824            f"WATERMARK FOR {self.sql(expression, 'this')} AS {self.sql(expression, 'expression')}"
4825        )
4826
4827    def encodeproperty_sql(self, expression: exp.EncodeProperty) -> str:
4828        encode = "KEY ENCODE" if expression.args.get("key") else "ENCODE"
4829        encode = f"{encode} {self.sql(expression, 'this')}"
4830
4831        properties = expression.args.get("properties")
4832        if properties:
4833            encode = f"{encode} {self.properties(properties)}"
4834
4835        return encode
4836
4837    def includeproperty_sql(self, expression: exp.IncludeProperty) -> str:
4838        this = self.sql(expression, "this")
4839        include = f"INCLUDE {this}"
4840
4841        column_def = self.sql(expression, "column_def")
4842        if column_def:
4843            include = f"{include} {column_def}"
4844
4845        alias = self.sql(expression, "alias")
4846        if alias:
4847            include = f"{include} AS {alias}"
4848
4849        return include
4850
4851    def xmlelement_sql(self, expression: exp.XMLElement) -> str:
4852        name = f"NAME {self.sql(expression, 'this')}"
4853        return self.func("XMLELEMENT", name, *expression.expressions)
4854
4855    def xmlkeyvalueoption_sql(self, expression: exp.XMLKeyValueOption) -> str:
4856        this = self.sql(expression, "this")
4857        expr = self.sql(expression, "expression")
4858        expr = f"({expr})" if expr else ""
4859        return f"{this}{expr}"
4860
4861    def partitionbyrangeproperty_sql(self, expression: exp.PartitionByRangeProperty) -> str:
4862        partitions = self.expressions(expression, "partition_expressions")
4863        create = self.expressions(expression, "create_expressions")
4864        return f"PARTITION BY RANGE {self.wrap(partitions)} {self.wrap(create)}"
4865
4866    def partitionbyrangepropertydynamic_sql(
4867        self, expression: exp.PartitionByRangePropertyDynamic
4868    ) -> str:
4869        start = self.sql(expression, "start")
4870        end = self.sql(expression, "end")
4871
4872        every = expression.args["every"]
4873        if isinstance(every, exp.Interval) and every.this.is_string:
4874            every.this.replace(exp.Literal.number(every.name))
4875
4876        return f"START {self.wrap(start)} END {self.wrap(end)} EVERY {self.wrap(self.sql(every))}"
4877
4878    def unpivotcolumns_sql(self, expression: exp.UnpivotColumns) -> str:
4879        name = self.sql(expression, "this")
4880        values = self.expressions(expression, flat=True)
4881
4882        return f"NAME {name} VALUE {values}"
4883
4884    def analyzesample_sql(self, expression: exp.AnalyzeSample) -> str:
4885        kind = self.sql(expression, "kind")
4886        sample = self.sql(expression, "sample")
4887        return f"SAMPLE {sample} {kind}"
4888
4889    def analyzestatistics_sql(self, expression: exp.AnalyzeStatistics) -> str:
4890        kind = self.sql(expression, "kind")
4891        option = self.sql(expression, "option")
4892        option = f" {option}" if option else ""
4893        this = self.sql(expression, "this")
4894        this = f" {this}" if this else ""
4895        columns = self.expressions(expression)
4896        columns = f" {columns}" if columns else ""
4897        return f"{kind}{option} STATISTICS{this}{columns}"
4898
4899    def analyzehistogram_sql(self, expression: exp.AnalyzeHistogram) -> str:
4900        this = self.sql(expression, "this")
4901        columns = self.expressions(expression)
4902        inner_expression = self.sql(expression, "expression")
4903        inner_expression = f" {inner_expression}" if inner_expression else ""
4904        update_options = self.sql(expression, "update_options")
4905        update_options = f" {update_options} UPDATE" if update_options else ""
4906        return f"{this} HISTOGRAM ON {columns}{inner_expression}{update_options}"
4907
4908    def analyzedelete_sql(self, expression: exp.AnalyzeDelete) -> str:
4909        kind = self.sql(expression, "kind")
4910        kind = f" {kind}" if kind else ""
4911        return f"DELETE{kind} STATISTICS"
4912
4913    def analyzelistchainedrows_sql(self, expression: exp.AnalyzeListChainedRows) -> str:
4914        inner_expression = self.sql(expression, "expression")
4915        return f"LIST CHAINED ROWS{inner_expression}"
4916
4917    def analyzevalidate_sql(self, expression: exp.AnalyzeValidate) -> str:
4918        kind = self.sql(expression, "kind")
4919        this = self.sql(expression, "this")
4920        this = f" {this}" if this else ""
4921        inner_expression = self.sql(expression, "expression")
4922        return f"VALIDATE {kind}{this}{inner_expression}"
4923
4924    def analyze_sql(self, expression: exp.Analyze) -> str:
4925        options = self.expressions(expression, key="options", sep=" ")
4926        options = f" {options}" if options else ""
4927        kind = self.sql(expression, "kind")
4928        kind = f" {kind}" if kind else ""
4929        this = self.sql(expression, "this")
4930        this = f" {this}" if this else ""
4931        mode = self.sql(expression, "mode")
4932        mode = f" {mode}" if mode else ""
4933        properties = self.sql(expression, "properties")
4934        properties = f" {properties}" if properties else ""
4935        partition = self.sql(expression, "partition")
4936        partition = f" {partition}" if partition else ""
4937        inner_expression = self.sql(expression, "expression")
4938        inner_expression = f" {inner_expression}" if inner_expression else ""
4939        return f"ANALYZE{options}{kind}{this}{partition}{mode}{inner_expression}{properties}"
4940
4941    def xmltable_sql(self, expression: exp.XMLTable) -> str:
4942        this = self.sql(expression, "this")
4943        namespaces = self.expressions(expression, key="namespaces")
4944        namespaces = f"XMLNAMESPACES({namespaces}), " if namespaces else ""
4945        passing = self.expressions(expression, key="passing")
4946        passing = f"{self.sep()}PASSING{self.seg(passing)}" if passing else ""
4947        columns = self.expressions(expression, key="columns")
4948        columns = f"{self.sep()}COLUMNS{self.seg(columns)}" if columns else ""
4949        by_ref = f"{self.sep()}RETURNING SEQUENCE BY REF" if expression.args.get("by_ref") else ""
4950        return f"XMLTABLE({self.sep('')}{self.indent(namespaces + this + passing + by_ref + columns)}{self.seg(')', sep='')}"
4951
4952    def xmlnamespace_sql(self, expression: exp.XMLNamespace) -> str:
4953        this = self.sql(expression, "this")
4954        return this if isinstance(expression.this, exp.Alias) else f"DEFAULT {this}"
4955
4956    def export_sql(self, expression: exp.Export) -> str:
4957        this = self.sql(expression, "this")
4958        connection = self.sql(expression, "connection")
4959        connection = f"WITH CONNECTION {connection} " if connection else ""
4960        options = self.sql(expression, "options")
4961        return f"EXPORT DATA {connection}{options} AS {this}"
4962
4963    def declare_sql(self, expression: exp.Declare) -> str:
4964        return f"DECLARE {self.expressions(expression, flat=True)}"
4965
4966    def declareitem_sql(self, expression: exp.DeclareItem) -> str:
4967        variable = self.sql(expression, "this")
4968        default = self.sql(expression, "default")
4969        default = f" = {default}" if default else ""
4970
4971        kind = self.sql(expression, "kind")
4972        if isinstance(expression.args.get("kind"), exp.Schema):
4973            kind = f"TABLE {kind}"
4974
4975        return f"{variable} AS {kind}{default}"
4976
4977    def recursivewithsearch_sql(self, expression: exp.RecursiveWithSearch) -> str:
4978        kind = self.sql(expression, "kind")
4979        this = self.sql(expression, "this")
4980        set = self.sql(expression, "expression")
4981        using = self.sql(expression, "using")
4982        using = f" USING {using}" if using else ""
4983
4984        kind_sql = kind if kind == "CYCLE" else f"SEARCH {kind} FIRST BY"
4985
4986        return f"{kind_sql} {this} SET {set}{using}"
4987
4988    def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
4989        params = self.expressions(expression, key="params", flat=True)
4990        return self.func(expression.name, *expression.expressions) + f"({params})"
4991
4992    def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
4993        return self.func(expression.name, *expression.expressions)
4994
4995    def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
4996        return self.anonymousaggfunc_sql(expression)
4997
4998    def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
4999        return self.parameterizedagg_sql(expression)
5000
5001    def show_sql(self, expression: exp.Show) -> str:
5002        self.unsupported("Unsupported SHOW statement")
5003        return ""
5004
5005    def get_put_sql(self, expression: exp.Put | exp.Get) -> str:
5006        # Snowflake GET/PUT statements:
5007        #   PUT <file> <internalStage> <properties>
5008        #   GET <internalStage> <file> <properties>
5009        props = expression.args.get("properties")
5010        props_sql = self.properties(props, prefix=" ", sep=" ", wrapped=False) if props else ""
5011        this = self.sql(expression, "this")
5012        target = self.sql(expression, "target")
5013
5014        if isinstance(expression, exp.Put):
5015            return f"PUT {this} {target}{props_sql}"
5016        else:
5017            return f"GET {target} {this}{props_sql}"
5018
5019    def translatecharacters_sql(self, expression: exp.TranslateCharacters):
5020        this = self.sql(expression, "this")
5021        expr = self.sql(expression, "expression")
5022        with_error = " WITH ERROR" if expression.args.get("with_error") else ""
5023        return f"TRANSLATE({this} USING {expr}{with_error})"
5024
5025    def decodecase_sql(self, expression: exp.DecodeCase) -> str:
5026        if self.SUPPORTS_DECODE_CASE:
5027            return self.func("DECODE", *expression.expressions)
5028
5029        expression, *expressions = expression.expressions
5030
5031        ifs = []
5032        for search, result in zip(expressions[::2], expressions[1::2]):
5033            if isinstance(search, exp.Literal):
5034                ifs.append(exp.If(this=expression.eq(search), true=result))
5035            elif isinstance(search, exp.Null):
5036                ifs.append(exp.If(this=expression.is_(exp.Null()), true=result))
5037            else:
5038                if isinstance(search, exp.Binary):
5039                    search = exp.paren(search)
5040
5041                cond = exp.or_(
5042                    expression.eq(search),
5043                    exp.and_(expression.is_(exp.Null()), search.is_(exp.Null()), copy=False),
5044                    copy=False,
5045                )
5046                ifs.append(exp.If(this=cond, true=result))
5047
5048        case = exp.Case(ifs=ifs, default=expressions[-1] if len(expressions) % 2 == 1 else None)
5049        return self.sql(case)