sqlglot.generator

   1from __future__ import annotations
   2
   3import logging
   4import re
   5import typing as t
   6from collections import defaultdict
   7from decimal import Decimal
   8from functools import reduce, wraps
   9
  10from sqlglot import exp
  11from sqlglot.errors import ErrorLevel, UnsupportedError, concat_messages
  12from sqlglot.expressions import apply_index_offset
  13from sqlglot.expressions.core import maybe_parse
  14from sqlglot.helper import csv, name_sequence, seq_get
  15from sqlglot.jsonpath import ALL_JSON_PATH_PARTS, JSON_PATH_PART_TRANSFORMS
  16from sqlglot.time import format_time
  17from sqlglot.tokens import TokenType
  18
  19if t.TYPE_CHECKING:
  20    from sqlglot._typing import E
  21    from sqlglot.dialects.dialect import DialectType
  22
  23    G = t.TypeVar("G", bound="Generator")
  24    GeneratorMethod = t.Callable[[G, E], str]
  25
  26logger = logging.getLogger("sqlglot")
  27
  28_HIGH_BYTE_RE = re.compile(r"[\x80-\xff]")
  29
  30ESCAPED_UNICODE_RE = re.compile(r"\\(\d+)")
  31UNSUPPORTED_TEMPLATE = "Argument '{}' is not supported for expression '{}' when targeting {}."
  32
  33
  34def unsupported_args(
  35    *args: str | tuple[str, str],
  36) -> t.Callable[[GeneratorMethod], GeneratorMethod]:
  37    """
  38    Decorator that can be used to mark certain args of an `Expr` subclass as unsupported.
  39    It expects a sequence of argument names or pairs of the form (argument_name, diagnostic_msg).
  40    """
  41    diagnostic_by_arg: dict[str, str | None] = {}
  42    for arg in args:
  43        if isinstance(arg, str):
  44            diagnostic_by_arg[arg] = None
  45        else:
  46            diagnostic_by_arg[arg[0]] = arg[1]
  47
  48    def decorator(func: GeneratorMethod) -> GeneratorMethod:
  49        @wraps(func)
  50        def _func(generator: G, expression: E) -> str:
  51            expression_name = expression.__class__.__name__
  52            dialect_name = generator.dialect.__class__.__name__
  53
  54            for arg_name, diagnostic in diagnostic_by_arg.items():
  55                if expression.args.get(arg_name):
  56                    diagnostic = diagnostic or UNSUPPORTED_TEMPLATE.format(
  57                        arg_name, expression_name, dialect_name
  58                    )
  59                    generator.unsupported(diagnostic)
  60
  61            return func(generator, expression)
  62
  63        return _func
  64
  65    return decorator
  66
  67
  68AFTER_HAVING_MODIFIER_TRANSFORMS: dict[str, t.Any] = {
  69    "windows": lambda self, e: (
  70        self.seg("WINDOW ") + self.expressions(e, key="windows", flat=True)
  71        if e.args.get("windows")
  72        else ""
  73    ),
  74    "qualify": lambda self, e: self.sql(e, "qualify"),
  75}
  76
  77
  78_DISPATCH_CACHE: dict[type[Generator], dict[type[exp.Expr], t.Callable[..., str]]] = {}
  79
  80
  81def _build_dispatch(
  82    cls: type[Generator],
  83) -> dict[type[exp.Expr], t.Callable[..., str]]:
  84    dispatch: dict[type[exp.Expr], t.Callable[..., str]] = dict(cls.TRANSFORMS)
  85
  86    for attr_name in dir(cls):
  87        if not attr_name.endswith("_sql") or attr_name.startswith("_"):
  88            continue
  89
  90        expr_key = attr_name[:-4]
  91        expr_cls = exp.EXPR_CLASSES.get(expr_key)
  92
  93        if expr_cls and expr_cls not in dispatch:
  94            dispatch[expr_cls] = getattr(cls, attr_name)
  95
  96    return dispatch
  97
  98
  99class Generator:
 100    """
 101    Generator converts a given syntax tree to the corresponding SQL string.
 102
 103    Args:
 104        pretty: Whether to format the produced SQL string.
 105            Default: False.
 106        identify: Determines when an identifier should be quoted. Possible values are:
 107            False (default): Never quote, except in cases where it's mandatory by the dialect.
 108            True: Always quote except for specials cases.
 109            'safe': Only quote identifiers that are case insensitive.
 110        normalize: Whether to normalize identifiers to lowercase.
 111            Default: False.
 112        pad: The pad size in a formatted string. For example, this affects the indentation of
 113            a projection in a query, relative to its nesting level.
 114            Default: 2.
 115        indent: The indentation size in a formatted string. For example, this affects the
 116            indentation of subqueries and filters under a `WHERE` clause.
 117            Default: 2.
 118        normalize_functions: How to normalize function names. Possible values are:
 119            "upper" or True (default): Convert names to uppercase.
 120            "lower": Convert names to lowercase.
 121            False: Disables function name normalization.
 122        unsupported_level: Determines the generator's behavior when it encounters unsupported expressions.
 123            Default ErrorLevel.WARN.
 124        max_unsupported: Maximum number of unsupported messages to include in a raised UnsupportedError.
 125            This is only relevant if unsupported_level is ErrorLevel.RAISE.
 126            Default: 3
 127        leading_comma: Whether the comma is leading or trailing in select expressions.
 128            This is only relevant when generating in pretty mode.
 129            Default: False
 130        max_text_width: The max number of characters in a segment before creating new lines in pretty mode.
 131            The default is on the smaller end because the length only represents a segment and not the true
 132            line length.
 133            Default: 80
 134        comments: Whether to preserve comments in the output SQL code.
 135            Default: True
 136    """
 137
 138    TRANSFORMS: t.ClassVar[dict[type[exp.Expr], t.Callable[..., str]]] = {
 139        **JSON_PATH_PART_TRANSFORMS,
 140        exp.Adjacent: lambda self, e: self.binary(e, "-|-"),
 141        exp.AllowedValuesProperty: lambda self, e: (
 142            f"ALLOWED_VALUES {self.expressions(e, flat=True)}"
 143        ),
 144        exp.AnalyzeColumns: lambda self, e: self.sql(e, "this"),
 145        exp.AnalyzeWith: lambda self, e: self.expressions(e, prefix="WITH ", sep=" "),
 146        exp.ArrayContainedBy: lambda self, e: self.binary(e, "<@"),
 147        exp.ArrayContainsAll: lambda self, e: self.binary(e, "@>"),
 148        exp.ArrayOverlaps: lambda self, e: self.binary(e, "&&"),
 149        exp.AssumeColumnConstraint: lambda self, e: f"ASSUME ({self.sql(e, 'this')})",
 150        exp.AutoRefreshProperty: lambda self, e: f"AUTO REFRESH {self.sql(e, 'this')}",
 151        exp.BackupProperty: lambda self, e: f"BACKUP {self.sql(e, 'this')}",
 152        exp.BinaryColumnConstraint: lambda *_: "BINARY",
 153        exp.CaseSpecificColumnConstraint: lambda _, e: (
 154            f"{'NOT ' if e.args.get('not_') else ''}CASESPECIFIC"
 155        ),
 156        exp.CalledOnNullInputProperty: lambda *_: "CALLED ON NULL INPUT",
 157        exp.Ceil: lambda self, e: self.ceil_floor(e),
 158        exp.CharacterSetColumnConstraint: lambda self, e: f"CHARACTER SET {self.sql(e, 'this')}",
 159        exp.CharacterSetProperty: lambda self, e: (
 160            f"{'DEFAULT ' if e.args.get('default') else ''}CHARACTER SET={self.sql(e, 'this')}"
 161        ),
 162        exp.ClusteredColumnConstraint: lambda self, e: (
 163            f"CLUSTERED ({self.expressions(e, 'this', indent=False)})"
 164        ),
 165        exp.CollateColumnConstraint: lambda self, e: f"COLLATE {self.sql(e, 'this')}",
 166        exp.CommentColumnConstraint: lambda self, e: f"COMMENT {self.sql(e, 'this')}",
 167        exp.ConnectByRoot: lambda self, e: f"CONNECT_BY_ROOT {self.sql(e, 'this')}",
 168        exp.ConvertToCharset: lambda self, e: self.func(
 169            "CONVERT", e.this, e.args["dest"], e.args.get("source")
 170        ),
 171        exp.CopyGrantsProperty: lambda *_: "COPY GRANTS",
 172        exp.CopyTagsProperty: lambda *_: "COPY TAGS",
 173        exp.CredentialsProperty: lambda self, e: (
 174            f"CREDENTIALS=({self.expressions(e, 'expressions', sep=' ')})"
 175        ),
 176        exp.CurrentCatalog: lambda *_: "CURRENT_CATALOG",
 177        exp.SessionUser: lambda *_: "SESSION_USER",
 178        exp.DateFormatColumnConstraint: lambda self, e: f"FORMAT {self.sql(e, 'this')}",
 179        exp.DefaultColumnConstraint: lambda self, e: f"DEFAULT {self.sql(e, 'this')}",
 180        exp.ApiProperty: lambda *_: "API",
 181        exp.ApplicationProperty: lambda *_: "APPLICATION",
 182        exp.CatalogProperty: lambda *_: "CATALOG",
 183        exp.ComputeProperty: lambda *_: "COMPUTE",
 184        exp.DatabaseProperty: lambda *_: "DATABASE",
 185        exp.DynamicProperty: lambda *_: "DYNAMIC",
 186        exp.EmptyProperty: lambda *_: "EMPTY",
 187        exp.EncodeColumnConstraint: lambda self, e: f"ENCODE {self.sql(e, 'this')}",
 188        exp.EndStatement: lambda *_: "END",
 189        exp.EnviromentProperty: lambda self, e: f"ENVIRONMENT ({self.expressions(e, flat=True)})",
 190        exp.HandlerProperty: lambda self, e: f"HANDLER {self.sql(e, 'this')}",
 191        exp.ParameterStyleProperty: lambda self, e: f"PARAMETER STYLE {self.sql(e, 'this')}",
 192        exp.EphemeralColumnConstraint: lambda self, e: (
 193            f"EPHEMERAL{(' ' + self.sql(e, 'this')) if e.this else ''}"
 194        ),
 195        exp.ExcludeColumnConstraint: lambda self, e: f"EXCLUDE {self.sql(e, 'this').lstrip()}",
 196        exp.ExecuteAsProperty: lambda self, e: self.naked_property(e),
 197        exp.Except: lambda self, e: self.set_operations(e),
 198        exp.ExternalProperty: lambda *_: "EXTERNAL",
 199        exp.Floor: lambda self, e: self.ceil_floor(e),
 200        exp.Get: lambda self, e: self.get_put_sql(e),
 201        exp.GlobalProperty: lambda *_: "GLOBAL",
 202        exp.HeapProperty: lambda *_: "HEAP",
 203        exp.HybridProperty: lambda *_: "HYBRID",
 204        exp.IcebergProperty: lambda *_: "ICEBERG",
 205        exp.IgnoreGrantsProperty: lambda *_: "IGNORE GRANTS",
 206        exp.InheritsProperty: lambda self, e: f"INHERITS ({self.expressions(e, flat=True)})",
 207        exp.InlineLengthColumnConstraint: lambda self, e: f"INLINE LENGTH {self.sql(e, 'this')}",
 208        exp.InputModelProperty: lambda self, e: f"INPUT{self.sql(e, 'this')}",
 209        exp.Intersect: lambda self, e: self.set_operations(e),
 210        exp.IntervalSpan: lambda self, e: f"{self.sql(e, 'this')} TO {self.sql(e, 'expression')}",
 211        exp.Int64: lambda self, e: self.sql(exp.cast(e.this, exp.DType.BIGINT)),
 212        exp.JSONBContainsAnyTopKeys: lambda self, e: self.binary(e, "?|"),
 213        exp.JSONBContainsAllTopKeys: lambda self, e: self.binary(e, "?&"),
 214        exp.JSONBContainsTopKey: lambda self, e: self.binary(e, "?"),
 215        exp.JSONBDeleteAtPath: lambda self, e: self.binary(e, "#-"),
 216        exp.JSONBPathExists: lambda self, e: self.binary(e, "@?"),
 217        exp.JSONObject: lambda self, e: self._jsonobject_sql(e),
 218        exp.JSONObjectAgg: lambda self, e: self._jsonobject_sql(e),
 219        exp.LanguageProperty: lambda self, e: self.naked_property(e),
 220        exp.LocationProperty: lambda self, e: self.naked_property(e),
 221        exp.LogProperty: lambda _, e: f"{'NO ' if e.args.get('no') else ''}LOG",
 222        exp.MaskingProperty: lambda *_: "MASKING",
 223        exp.MaterializedProperty: lambda *_: "MATERIALIZED",
 224        exp.NetFunc: lambda self, e: f"NET.{self.sql(e, 'this')}",
 225        exp.NetworkProperty: lambda *_: "NETWORK",
 226        exp.NonClusteredColumnConstraint: lambda self, e: (
 227            f"NONCLUSTERED ({self.expressions(e, 'this', indent=False)})"
 228        ),
 229        exp.NoPrimaryIndexProperty: lambda *_: "NO PRIMARY INDEX",
 230        exp.NotForReplicationColumnConstraint: lambda *_: "NOT FOR REPLICATION",
 231        exp.OnCommitProperty: lambda _, e: (
 232            f"ON COMMIT {'DELETE' if e.args.get('delete') else 'PRESERVE'} ROWS"
 233        ),
 234        exp.OnProperty: lambda self, e: f"ON {self.sql(e, 'this')}",
 235        exp.OnUpdateColumnConstraint: lambda self, e: f"ON UPDATE {self.sql(e, 'this')}",
 236        exp.Operator: lambda self, e: self.binary(e, ""),  # The operator is produced in `binary`
 237        exp.OutputModelProperty: lambda self, e: f"OUTPUT{self.sql(e, 'this')}",
 238        exp.ExtendsLeft: lambda self, e: self.binary(e, "&<"),
 239        exp.ExtendsRight: lambda self, e: self.binary(e, "&>"),
 240        exp.PathColumnConstraint: lambda self, e: f"PATH {self.sql(e, 'this')}",
 241        exp.PartitionedByBucket: lambda self, e: self.func("BUCKET", e.this, e.expression),
 242        exp.PartitionByTruncate: lambda self, e: self.func("TRUNCATE", e.this, e.expression),
 243        exp.PivotAny: lambda self, e: f"ANY{self.sql(e, 'this')}",
 244        exp.PositionalColumn: lambda self, e: f"#{self.sql(e, 'this')}",
 245        exp.ProjectionPolicyColumnConstraint: lambda self, e: (
 246            f"PROJECTION POLICY {self.sql(e, 'this')}"
 247        ),
 248        exp.InvisibleColumnConstraint: lambda self, e: "INVISIBLE",
 249        exp.ZeroFillColumnConstraint: lambda self, e: "ZEROFILL",
 250        exp.Put: lambda self, e: self.get_put_sql(e),
 251        exp.RemoteWithConnectionModelProperty: lambda self, e: (
 252            f"REMOTE WITH CONNECTION {self.sql(e, 'this')}"
 253        ),
 254        exp.ReturnsProperty: lambda self, e: (
 255            "RETURNS NULL ON NULL INPUT" if e.args.get("null") else self.naked_property(e)
 256        ),
 257        exp.RowAccessProperty: lambda *_: "ROW ACCESS",
 258        exp.SafeFunc: lambda self, e: f"SAFE.{self.sql(e, 'this')}",
 259        exp.SampleProperty: lambda self, e: f"SAMPLE BY {self.sql(e, 'this')}",
 260        exp.SecureProperty: lambda *_: "SECURE",
 261        exp.SecurityIntegrationProperty: lambda *_: "SECURITY",
 262        exp.SetConfigProperty: lambda self, e: self.sql(e, "this"),
 263        exp.SetProperty: lambda _, e: f"{'MULTI' if e.args.get('multi') else ''}SET",
 264        exp.SettingsProperty: lambda self, e: f"SETTINGS{self.seg('')}{(self.expressions(e))}",
 265        exp.SharingProperty: lambda self, e: f"SHARING={self.sql(e, 'this')}",
 266        exp.SqlReadWriteProperty: lambda _, e: e.name,
 267        exp.SqlSecurityProperty: lambda self, e: f"SQL SECURITY {self.sql(e, 'this')}",
 268        exp.StabilityProperty: lambda _, e: e.name,
 269        exp.Stream: lambda self, e: f"STREAM {self.sql(e, 'this')}",
 270        exp.StreamingTableProperty: lambda *_: "STREAMING",
 271        exp.StrictProperty: lambda *_: "STRICT",
 272        exp.SwapTable: lambda self, e: f"SWAP WITH {self.sql(e, 'this')}",
 273        exp.TableColumn: lambda self, e: self.sql(e.this),
 274        exp.Tags: lambda self, e: f"TAG ({self.expressions(e, flat=True)})",
 275        exp.TemporaryProperty: lambda *_: "TEMPORARY",
 276        exp.TitleColumnConstraint: lambda self, e: f"TITLE {self.sql(e, 'this')}",
 277        exp.ToMap: lambda self, e: f"MAP {self.sql(e, 'this')}",
 278        exp.ToTableProperty: lambda self, e: f"TO {self.sql(e.this)}",
 279        exp.TransformModelProperty: lambda self, e: self.func("TRANSFORM", *e.expressions),
 280        exp.TransientProperty: lambda *_: "TRANSIENT",
 281        exp.VirtualProperty: lambda *_: "VIRTUAL",
 282        exp.TriggerExecute: lambda self, e: f"EXECUTE FUNCTION {self.sql(e, 'this')}",
 283        exp.Union: lambda self, e: self.set_operations(e),
 284        exp.UnloggedProperty: lambda *_: "UNLOGGED",
 285        exp.UsingTemplateProperty: lambda self, e: f"USING TEMPLATE {self.sql(e, 'this')}",
 286        exp.UsingData: lambda self, e: f"USING DATA {self.sql(e, 'this')}",
 287        exp.UppercaseColumnConstraint: lambda *_: "UPPERCASE",
 288        exp.UtcDate: lambda self, e: self.sql(exp.CurrentDate(this=exp.Literal.string("UTC"))),
 289        exp.UtcTime: lambda self, e: self.sql(exp.CurrentTime(this=exp.Literal.string("UTC"))),
 290        exp.UtcTimestamp: lambda self, e: self.sql(
 291            exp.CurrentTimestamp(this=exp.Literal.string("UTC"))
 292        ),
 293        exp.Variadic: lambda self, e: f"VARIADIC {self.sql(e, 'this')}",
 294        exp.VarMap: lambda self, e: self.func("MAP", e.args["keys"], e.args["values"]),
 295        exp.ViewAttributeProperty: lambda self, e: f"WITH {self.sql(e, 'this')}",
 296        exp.VolatileProperty: lambda *_: "VOLATILE",
 297        exp.WithJournalTableProperty: lambda self, e: f"WITH JOURNAL TABLE={self.sql(e, 'this')}",
 298        exp.WithProcedureOptions: lambda self, e: f"WITH {self.expressions(e, flat=True)}",
 299        exp.WithSchemaBindingProperty: lambda self, e: f"WITH SCHEMA {self.sql(e, 'this')}",
 300        exp.WithOperator: lambda self, e: f"{self.sql(e, 'this')} WITH {self.sql(e, 'op')}",
 301        exp.WithoutRowidProperty: lambda *_: "WITHOUT ROWID",
 302        exp.ForceProperty: lambda *_: "FORCE",
 303    }
 304
 305    # Whether null ordering is supported in order by
 306    # True: Full Support, None: No support, False: No support for certain cases
 307    # such as window specifications, aggregate functions etc
 308    NULL_ORDERING_SUPPORTED: bool | None = True
 309
 310    # Window functions that support NULLS FIRST/LAST
 311    WINDOW_FUNCS_WITH_NULL_ORDERING: t.ClassVar[tuple[type[exp.Expression], ...]] = ()
 312
 313    # Whether ignore nulls is inside the agg or outside.
 314    # FIRST(x IGNORE NULLS) OVER vs FIRST (x) IGNORE NULLS OVER
 315    IGNORE_NULLS_IN_FUNC = False
 316
 317    # Whether IGNORE NULLS is placed before ORDER BY in the agg.
 318    # FIRST(x IGNORE NULLS ORDER BY y) vs FIRST(x ORDER BY y IGNORE NULLS)
 319    IGNORE_NULLS_BEFORE_ORDER = True
 320
 321    # Whether locking reads (i.e. SELECT ... FOR UPDATE/SHARE) are supported
 322    LOCKING_READS_SUPPORTED = False
 323
 324    # Whether the EXCEPT and INTERSECT operations can return duplicates
 325    EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE = True
 326
 327    # Wrap derived values in parens, usually standard but spark doesn't support it
 328    WRAP_DERIVED_VALUES = True
 329
 330    # Whether create function uses an AS before the RETURN
 331    CREATE_FUNCTION_RETURN_AS = True
 332
 333    # Whether MERGE ... WHEN MATCHED BY SOURCE is allowed
 334    MATCHED_BY_SOURCE = True
 335
 336    # Whether MERGE ... WHEN MATCHED/NOT MATCHED THEN UPDATE/INSERT ... WHERE is supported
 337    SUPPORTS_MERGE_WHERE = False
 338
 339    # Whether MERGE uses ALL BY NAME instead of a star to update or insert all columns
 340    MERGE_ALL_BY_NAME = False
 341
 342    # Whether the INTERVAL expression works only with values like '1 day'
 343    SINGLE_STRING_INTERVAL = False
 344
 345    # Whether the plural form of date parts like day (i.e. "days") is supported in INTERVALs
 346    INTERVAL_ALLOWS_PLURAL_FORM = True
 347
 348    # Whether intervals in a REFRESH schedule (AutoRefreshProperty) are generated without the
 349    # INTERVAL keyword, e.g. ClickHouse's REFRESH EVERY 30 SECOND
 350    AUTO_REFRESH_BARE_INTERVALS = False
 351
 352    # Whether limit and fetch are supported (possible values: "ALL", "LIMIT", "FETCH")
 353    LIMIT_FETCH = "ALL"
 354
 355    # Whether limit and fetch allows expressions or just limits
 356    LIMIT_ONLY_LITERALS = False
 357
 358    # Whether a table is allowed to be renamed with a db
 359    RENAME_TABLE_WITH_DB = True
 360
 361    # The separator for grouping sets and rollups
 362    GROUPINGS_SEP = ","
 363
 364    # Whether GROUPING SETS can follow GROUP BY expressions without a comma
 365    SUPPORTS_GROUPING_SETS_AS_SUFFIX = False
 366
 367    # The string used for creating an index on a table
 368    INDEX_ON = "ON"
 369
 370    # Separator for IN/OUT parameter mode (Oracle uses " " for "IN OUT", PostgreSQL uses "" for "INOUT")
 371    INOUT_SEPARATOR = " "
 372
 373    # Whether join hints should be generated
 374    JOIN_HINTS = True
 375
 376    # Whether directed joins are supported
 377    DIRECTED_JOINS = False
 378
 379    # Whether top-k distance/similarity joins are supported
 380    SUPPORTS_NEAREST_JOIN = False
 381
 382    # Whether table hints should be generated
 383    TABLE_HINTS = True
 384
 385    # Whether query hints should be generated
 386    QUERY_HINTS = True
 387
 388    # What kind of separator to use for query hints
 389    QUERY_HINT_SEP = ", "
 390
 391    # Whether comparing against booleans (e.g. x IS TRUE) is supported
 392    IS_BOOL_ALLOWED = True
 393
 394    # Whether casting a fractional number to an integer rounds it instead of truncating it
 395    CAST_TO_INT_ROUNDS = False
 396
 397    # Whether the native integer division operator returns NULL for a zero divisor instead of raising
 398    SAFE_INT_DIVISION = False
 399
 400    # Whether to include the "SET" keyword in the "INSERT ... ON DUPLICATE KEY UPDATE" statement
 401    DUPLICATE_KEY_UPDATE_WITH_SET = True
 402
 403    # Whether to generate the limit as TOP <value> instead of LIMIT <value>
 404    LIMIT_IS_TOP = False
 405
 406    # Whether to generate INSERT INTO ... RETURNING or INSERT INTO RETURNING ...
 407    RETURNING_END = True
 408
 409    # Whether to generate an unquoted value for EXTRACT's date part argument
 410    EXTRACT_ALLOWS_QUOTES = True
 411
 412    # Whether TIMETZ / TIMESTAMPTZ will be generated using the "WITH TIME ZONE" syntax
 413    TZ_TO_WITH_TIME_ZONE = False
 414
 415    # Whether the NVL2 function is supported
 416    NVL2_SUPPORTED = True
 417
 418    # https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax
 419    SELECT_KINDS: tuple[str, ...] = ("STRUCT", "VALUE")
 420
 421    # Whether VALUES statements can be used as derived tables.
 422    # MySQL 5 and Redshift do not allow this, so when False, it will convert
 423    # SELECT * VALUES into SELECT UNION
 424    VALUES_AS_TABLE = True
 425
 426    # Whether COLUMN/COLUMNS keywords are included when adding columns with ALTER TABLE.
 427    ALTER_TABLE_INCLUDE_COLUMN_KEYWORD = True
 428
 429    # Whether ALTER TABLE mutli-column additions are wrapped in parentheses.
 430    ALTER_TABLE_ADD_COLUMNS_WRAPPED = True
 431
 432    # UNNEST WITH ORDINALITY (presto) instead of UNNEST WITH OFFSET (bigquery)
 433    UNNEST_WITH_ORDINALITY = True
 434
 435    # Whether JOIN sides (LEFT, RIGHT) are supported in conjunction with SEMI/ANTI join kinds
 436    SEMI_ANTI_JOIN_WITH_SIDE = True
 437
 438    # Whether to include the type of a computed column in the CREATE DDL
 439    COMPUTED_COLUMN_WITH_TYPE = True
 440
 441    # Whether CREATE TABLE .. COPY .. is supported. False means we'll generate CLONE instead of COPY
 442    SUPPORTS_TABLE_COPY = True
 443
 444    # Whether parentheses are required around the table sample's expression
 445    TABLESAMPLE_REQUIRES_PARENS = True
 446
 447    # Whether a table sample clause's size needs to be followed by the ROWS keyword
 448    TABLESAMPLE_SIZE_IS_ROWS = True
 449
 450    # The keyword(s) to use when generating a sample clause
 451    TABLESAMPLE_KEYWORDS = "TABLESAMPLE"
 452
 453    # Whether the TABLESAMPLE clause supports a method name, like BERNOULLI
 454    TABLESAMPLE_WITH_METHOD = True
 455
 456    # The keyword to use when specifying the seed of a sample clause
 457    TABLESAMPLE_SEED_KEYWORD = "SEED"
 458
 459    # Whether the historical data clause (AT ... / BEFORE ...) is generated after the table alias
 460    HISTORICAL_DATA_POST_ALIAS = False
 461
 462    # Whether COLLATE is a function instead of a binary operator
 463    COLLATE_IS_FUNC = False
 464
 465    # Whether data types support additional specifiers like e.g. CHAR or BYTE (oracle)
 466    DATA_TYPE_SPECIFIERS_ALLOWED = False
 467
 468    # Whether conditions require booleans WHERE x = 0 vs WHERE x
 469    ENSURE_BOOLS = False
 470
 471    # Whether the "RECURSIVE" keyword is required when defining recursive CTEs
 472    CTE_RECURSIVE_KEYWORD_REQUIRED = True
 473
 474    # Whether CONCAT requires >1 arguments
 475    SUPPORTS_SINGLE_ARG_CONCAT = True
 476
 477    # Whether LAST_DAY function supports a date part argument
 478    LAST_DAY_SUPPORTS_DATE_PART = True
 479
 480    # Whether named columns are allowed in table aliases
 481    SUPPORTS_TABLE_ALIAS_COLUMNS = True
 482
 483    # Whether named columns are allowed in CTE definitions
 484    SUPPORTS_NAMED_CTE_COLUMNS = True
 485
 486    # Whether UNPIVOT aliases are Identifiers (False means they're Literals)
 487    UNPIVOT_ALIASES_ARE_IDENTIFIERS = True
 488
 489    # Whether a (UN)PIVOT's alias is introduced with AS (Oracle rejects it, ORA-03048)
 490    PIVOT_ALIAS_WITH_AS = True
 491
 492    # What delimiter to use for separating JSON key/value pairs
 493    JSON_KEY_VALUE_PAIR_SEP = ":"
 494
 495    # INSERT OVERWRITE TABLE x override
 496    INSERT_OVERWRITE = " OVERWRITE TABLE"
 497
 498    # Whether the SELECT .. INTO syntax is used instead of CTAS
 499    SUPPORTS_SELECT_INTO = False
 500
 501    # Whether UNLOGGED tables can be created
 502    SUPPORTS_UNLOGGED_TABLES = False
 503
 504    # Whether the CREATE TABLE LIKE statement is supported
 505    SUPPORTS_CREATE_TABLE_LIKE = True
 506
 507    # Whether ALTER TABLE ... MODIFY COLUMN column-redefinition syntax is supported
 508    SUPPORTS_MODIFY_COLUMN = False
 509
 510    # Whether ALTER TABLE ... CHANGE COLUMN column-rename-and-redefine syntax is supported
 511    SUPPORTS_CHANGE_COLUMN = False
 512
 513    # Whether ALTER COLUMN can set a column's nullability together with its type
 514    SUPPORTS_ALTER_COLUMN_NULLABILITY = False
 515
 516    # Whether ALTER COLUMN IF EXISTS is supported
 517    SUPPORTS_ALTER_COLUMN_IF_EXISTS = False
 518
 519    # Whether the LikeProperty needs to be specified inside of the schema clause
 520    LIKE_PROPERTY_INSIDE_SCHEMA = False
 521
 522    # Whether DISTINCT can be followed by multiple args in an AggFunc. If not, it will be
 523    # transpiled into a series of CASE-WHEN-ELSE, ultimately using a tuple conseisting of the args
 524    MULTI_ARG_DISTINCT = True
 525
 526    # Whether the JSON extraction operators expect a value of type JSON
 527    JSON_TYPE_REQUIRED_FOR_EXTRACTION = False
 528
 529    # Whether bracketed keys like ["foo"] are supported in JSON paths
 530    JSON_PATH_BRACKETED_KEY_SUPPORTED = True
 531
 532    # Whether to escape keys using single quotes in JSON paths
 533    JSON_PATH_SINGLE_QUOTE_ESCAPE = False
 534
 535    # Whether a quoted JSON path key (e.g. from a quoted identifier or ['key'] bracket) must be
 536    # rendered in bracket form to preserve its case-sensitivity, even if it would otherwise match
 537    # SAFE_JSON_PATH_KEY_RE and render as a bare dotted key. Needed for dialects like Databricks
 538    # where a bare colon key is case-insensitive but a bracketed key is case-sensitive.
 539    JSON_PATH_KEY_QUOTED_FORCES_BRACKETS = False
 540
 541    # The JSONPathPart expressions supported by this dialect
 542    SUPPORTED_JSON_PATH_PARTS: t.ClassVar = ALL_JSON_PATH_PARTS.copy()
 543
 544    # Whether any(f(x) for x in array) can be implemented by this dialect
 545    CAN_IMPLEMENT_ARRAY_ANY = False
 546
 547    # Whether the function TO_NUMBER is supported
 548    SUPPORTS_TO_NUMBER = True
 549
 550    # Whether EXCLUDE in window specification is supported
 551    SUPPORTS_WINDOW_EXCLUDE = False
 552
 553    # Whether or not set op modifiers apply to the outer set op or select.
 554    # SELECT * FROM x UNION SELECT * FROM y LIMIT 1
 555    # True means limit 1 happens after the set op, False means it it happens on y.
 556    SET_OP_MODIFIERS = True
 557
 558    # Whether a SELECT operand can have a branch-local LIMIT/TOP without parentheses.
 559    SET_OP_LIMITS = False
 560
 561    # Whether set operation operands can be parenthesized without a SELECT wrapper.
 562    SET_OP_PARENTHESIZED_OPERANDS = True
 563
 564    # Whether parameters from COPY statement are wrapped in parentheses
 565    COPY_PARAMS_ARE_WRAPPED = True
 566
 567    # Whether values of params are set with "=" token or empty space
 568    COPY_PARAMS_EQ_REQUIRED = False
 569
 570    # Whether COPY statement has INTO keyword
 571    COPY_HAS_INTO_KEYWORD = True
 572
 573    # Whether the conditional TRY(expression) function is supported
 574    TRY_SUPPORTED = True
 575
 576    # Whether the UESCAPE syntax in unicode strings is supported
 577    SUPPORTS_UESCAPE = True
 578
 579    # Function used to replace escaped unicode codes in unicode strings
 580    UNICODE_SUBSTITUTE: t.ClassVar[t.Any] = None
 581
 582    # The keyword to use when generating a star projection with excluded columns
 583    STAR_EXCEPT = "EXCEPT"
 584
 585    # The HEX function name
 586    HEX_FUNC = "HEX"
 587
 588    # Function that constructs a binary value from a hex-encoded byte string.
 589    BYTE_STRING_FUNCTION = ""
 590
 591    # The keywords to use when prefixing & separating WITH based properties
 592    WITH_PROPERTIES_PREFIX = "WITH"
 593
 594    # Whether to quote the generated expression of exp.JsonPath
 595    QUOTE_JSON_PATH = True
 596
 597    # Whether the text pattern/fill (3rd) parameter of RPAD()/LPAD() is optional (defaults to space)
 598    PAD_FILL_PATTERN_IS_REQUIRED = False
 599
 600    # Whether a projection can explode into multiple rows, e.g. by unnesting an array.
 601    SUPPORTS_EXPLODING_PROJECTIONS = True
 602
 603    # Whether ARRAY_CONCAT can be generated with varlen args or if it should be reduced to 2-arg version
 604    ARRAY_CONCAT_IS_VAR_LEN = True
 605
 606    # Whether CONVERT_TIMEZONE() is supported; if not, it will be generated as exp.AtTimeZone
 607    SUPPORTS_CONVERT_TIMEZONE = False
 608
 609    # Whether MEDIAN(expr) is supported; if not, it will be generated as PERCENTILE_CONT(expr, 0.5)
 610    SUPPORTS_MEDIAN = True
 611
 612    # Whether UNIX_SECONDS(timestamp) is supported
 613    SUPPORTS_UNIX_SECONDS = False
 614
 615    # Whether to wrap <props> in `AlterSet`, e.g., ALTER ... SET (<props>)
 616    ALTER_SET_WRAPPED = False
 617
 618    # Whether to normalize the date parts in EXTRACT(<date_part> FROM <expr>) into a common representation
 619    # For instance, to extract the day of week in ISO semantics, one can use ISODOW, DAYOFWEEKISO etc depending on the dialect.
 620    # TODO: The normalization should be done by default once we've tested it across all dialects.
 621    NORMALIZE_EXTRACT_DATE_PARTS = False
 622
 623    # The name to generate for the JSONPath expression. If `None`, only `this` will be generated
 624    PARSE_JSON_NAME: str | None = "PARSE_JSON"
 625
 626    # The function name of the exp.ArraySize expression
 627    ARRAY_SIZE_NAME: str = "ARRAY_LENGTH"
 628
 629    # The syntax to use when altering the type of a column
 630    ALTER_SET_TYPE = "SET DATA TYPE"
 631
 632    # Whether exp.ArraySize should generate the dimension arg too (valid for Postgres & DuckDB)
 633    # None -> Doesn't support it at all
 634    # False (DuckDB) -> Has backwards-compatible support, but preferably generated without
 635    # True (Postgres) -> Explicitly requires it
 636    ARRAY_SIZE_DIM_REQUIRED: bool | None = None
 637
 638    # Whether a multi-argument DECODE(...) function is supported. If not, a CASE expression is generated
 639    SUPPORTS_DECODE_CASE = True
 640
 641    # Whether SYMMETRIC and ASYMMETRIC flags are supported with BETWEEN expression
 642    SUPPORTS_BETWEEN_FLAGS = False
 643
 644    # Whether LIKE and ILIKE support quantifiers such as LIKE ANY/ALL/SOME
 645    SUPPORTS_LIKE_QUANTIFIERS = True
 646
 647    # Prefix which is appended to exp.Table expressions in MATCH AGAINST
 648    MATCH_AGAINST_TABLE_PREFIX: str | None = None
 649
 650    # Whether to include the VARIABLE keyword for SET assignments
 651    SET_ASSIGNMENT_REQUIRES_VARIABLE_KEYWORD = False
 652
 653    # The keyword to use for default value assignment in DECLARE statements
 654    DECLARE_DEFAULT_ASSIGNMENT = "="
 655
 656    # Whether FROM is supported in UPDATE statements or if joins must be generated instead, e.g:
 657    # Supported (Postgres, Doris etc): UPDATE t1 SET t1.a = t2.b FROM t2
 658    # Unsupported (MySQL, SingleStore): UPDATE t1 JOIN t2 ON TRUE SET t1.a = t2.b
 659    UPDATE_STATEMENT_SUPPORTS_FROM = True
 660
 661    # Whether SELECT *, ... EXCLUDE requires wrapping in a subquery for transpilation.
 662    STAR_EXCLUDE_REQUIRES_DERIVED_TABLE = True
 663
 664    # Whether DROP and ALTER statements against Iceberg tables include 'ICEBERG', e.g.:
 665    # - Snowflake: DROP ICEBERG TABLE a.b;
 666    # - DuckDB:    DROP TABLE a.b;
 667    SUPPORTS_DROP_ALTER_ICEBERG_PROPERTY = True
 668
 669    TYPE_MAPPING: t.ClassVar = {
 670        exp.DType.DATETIME2: "TIMESTAMP",
 671        exp.DType.NCHAR: "CHAR",
 672        exp.DType.NVARCHAR: "VARCHAR",
 673        exp.DType.MEDIUMTEXT: "TEXT",
 674        exp.DType.LONGTEXT: "TEXT",
 675        exp.DType.TINYTEXT: "TEXT",
 676        exp.DType.BLOB: "VARBINARY",
 677        exp.DType.MEDIUMBLOB: "BLOB",
 678        exp.DType.LONGBLOB: "BLOB",
 679        exp.DType.TINYBLOB: "BLOB",
 680        exp.DType.INET: "INET",
 681        exp.DType.ROWVERSION: "VARBINARY",
 682        exp.DType.SMALLDATETIME: "TIMESTAMP",
 683    }
 684
 685    UNSUPPORTED_TYPES: t.ClassVar[set[exp.DType]] = set()
 686
 687    # mapping of DType to its default parameters, bounds
 688    TYPE_PARAM_SETTINGS: t.ClassVar[
 689        dict[exp.DType, tuple[tuple[int, ...], tuple[int | None, ...]]]
 690    ] = {}
 691
 692    TIME_PART_SINGULARS: t.ClassVar = {
 693        "MICROSECONDS": "MICROSECOND",
 694        "SECONDS": "SECOND",
 695        "MINUTES": "MINUTE",
 696        "HOURS": "HOUR",
 697        "DAYS": "DAY",
 698        "WEEKS": "WEEK",
 699        "MONTHS": "MONTH",
 700        "QUARTERS": "QUARTER",
 701        "YEARS": "YEAR",
 702    }
 703
 704    AFTER_HAVING_MODIFIER_TRANSFORMS: t.ClassVar = {
 705        "cluster": lambda self, e: self.sql(e, "cluster"),
 706        "distribute": lambda self, e: self.sql(e, "distribute"),
 707        "sort": lambda self, e: self.sql(e, "sort"),
 708        **AFTER_HAVING_MODIFIER_TRANSFORMS,
 709    }
 710
 711    TOKEN_MAPPING: t.ClassVar[dict[TokenType, str]] = {}
 712
 713    STRUCT_DELIMITER: t.ClassVar = ("<", ">")
 714
 715    PARAMETER_TOKEN = "@"
 716    NAMED_PLACEHOLDER_TOKEN = ":"
 717
 718    EXPRESSION_PRECEDES_PROPERTIES_CREATABLES: t.ClassVar[set[str]] = set()
 719
 720    PROPERTIES_LOCATION: t.ClassVar = {
 721        exp.AggregateKeyProperty: exp.Properties.Location.POST_SCHEMA,
 722        exp.AllowedValuesProperty: exp.Properties.Location.POST_SCHEMA,
 723        exp.AlgorithmProperty: exp.Properties.Location.POST_CREATE,
 724        exp.ApiProperty: exp.Properties.Location.POST_CREATE,
 725        exp.ApplicationProperty: exp.Properties.Location.POST_CREATE,
 726        exp.AutoIncrementProperty: exp.Properties.Location.POST_SCHEMA,
 727        exp.AutoRefreshProperty: exp.Properties.Location.POST_SCHEMA,
 728        exp.BackupProperty: exp.Properties.Location.POST_SCHEMA,
 729        exp.BlockCompressionProperty: exp.Properties.Location.POST_NAME,
 730        exp.CalledOnNullInputProperty: exp.Properties.Location.POST_SCHEMA,
 731        exp.CatalogProperty: exp.Properties.Location.POST_CREATE,
 732        exp.CharacterSetProperty: exp.Properties.Location.POST_SCHEMA,
 733        exp.ChecksumProperty: exp.Properties.Location.POST_NAME,
 734        exp.CollateProperty: exp.Properties.Location.POST_SCHEMA,
 735        exp.ComputeProperty: exp.Properties.Location.POST_CREATE,
 736        exp.CopyGrantsProperty: exp.Properties.Location.POST_SCHEMA,
 737        exp.CopyTagsProperty: exp.Properties.Location.POST_SCHEMA,
 738        exp.Cluster: exp.Properties.Location.POST_SCHEMA,
 739        exp.ClusteredByProperty: exp.Properties.Location.POST_SCHEMA,
 740        exp.ClusterProperty: exp.Properties.Location.POST_SCHEMA,
 741        exp.DistributedByProperty: exp.Properties.Location.POST_SCHEMA,
 742        exp.DuplicateKeyProperty: exp.Properties.Location.POST_SCHEMA,
 743        exp.DataBlocksizeProperty: exp.Properties.Location.POST_NAME,
 744        exp.DatabaseProperty: exp.Properties.Location.POST_CREATE,
 745        exp.DataDeletionProperty: exp.Properties.Location.POST_SCHEMA,
 746        exp.DefinerProperty: exp.Properties.Location.POST_CREATE,
 747        exp.DictRange: exp.Properties.Location.POST_SCHEMA,
 748        exp.DictProperty: exp.Properties.Location.POST_SCHEMA,
 749        exp.DynamicProperty: exp.Properties.Location.POST_CREATE,
 750        exp.DistKeyProperty: exp.Properties.Location.UNSUPPORTED,
 751        exp.DistStyleProperty: exp.Properties.Location.UNSUPPORTED,
 752        exp.EmptyProperty: exp.Properties.Location.POST_SCHEMA,
 753        exp.EncodeProperty: exp.Properties.Location.POST_EXPRESSION,
 754        exp.EngineProperty: exp.Properties.Location.POST_SCHEMA,
 755        exp.EnviromentProperty: exp.Properties.Location.POST_SCHEMA,
 756        exp.HandlerProperty: exp.Properties.Location.POST_SCHEMA,
 757        exp.ParameterStyleProperty: exp.Properties.Location.POST_SCHEMA,
 758        exp.ExecuteAsProperty: exp.Properties.Location.POST_SCHEMA,
 759        exp.ExternalProperty: exp.Properties.Location.POST_CREATE,
 760        exp.FallbackProperty: exp.Properties.Location.POST_NAME,
 761        exp.FileFormatProperty: exp.Properties.Location.POST_WITH,
 762        exp.FreespaceProperty: exp.Properties.Location.POST_NAME,
 763        exp.GlobalProperty: exp.Properties.Location.POST_CREATE,
 764        exp.HeapProperty: exp.Properties.Location.POST_WITH,
 765        exp.HybridProperty: exp.Properties.Location.POST_CREATE,
 766        exp.InheritsProperty: exp.Properties.Location.POST_SCHEMA,
 767        exp.IcebergProperty: exp.Properties.Location.POST_CREATE,
 768        exp.IgnoreGrantsProperty: exp.Properties.Location.POST_SCHEMA,
 769        exp.IncludeProperty: exp.Properties.Location.POST_SCHEMA,
 770        exp.InputModelProperty: exp.Properties.Location.POST_SCHEMA,
 771        exp.InteractiveProperty: exp.Properties.Location.UNSUPPORTED,
 772        exp.IsolatedLoadingProperty: exp.Properties.Location.POST_NAME,
 773        exp.JournalProperty: exp.Properties.Location.POST_NAME,
 774        exp.LanguageProperty: exp.Properties.Location.POST_SCHEMA,
 775        exp.LikeProperty: exp.Properties.Location.POST_SCHEMA,
 776        exp.LocationProperty: exp.Properties.Location.POST_SCHEMA,
 777        exp.LockProperty: exp.Properties.Location.POST_SCHEMA,
 778        exp.LockingProperty: exp.Properties.Location.POST_ALIAS,
 779        exp.LogProperty: exp.Properties.Location.POST_NAME,
 780        exp.MaskingProperty: exp.Properties.Location.POST_CREATE,
 781        exp.MaterializedProperty: exp.Properties.Location.POST_CREATE,
 782        exp.MergeBlockRatioProperty: exp.Properties.Location.POST_NAME,
 783        exp.ModuleProperty: exp.Properties.Location.POST_SCHEMA,
 784        exp.NetworkProperty: exp.Properties.Location.POST_CREATE,
 785        exp.NoPrimaryIndexProperty: exp.Properties.Location.POST_EXPRESSION,
 786        exp.OnProperty: exp.Properties.Location.POST_SCHEMA,
 787        exp.OnCommitProperty: exp.Properties.Location.POST_EXPRESSION,
 788        exp.OptionsProperty: exp.Properties.Location.UNSUPPORTED,
 789        exp.Order: exp.Properties.Location.POST_SCHEMA,
 790        exp.OutputModelProperty: exp.Properties.Location.POST_SCHEMA,
 791        exp.PartitionedByProperty: exp.Properties.Location.POST_WITH,
 792        exp.PartitionedOfProperty: exp.Properties.Location.POST_SCHEMA,
 793        exp.PhysicalProperty: exp.Properties.Location.UNSUPPORTED,
 794        exp.PrimaryKey: exp.Properties.Location.POST_SCHEMA,
 795        exp.Property: exp.Properties.Location.POST_WITH,
 796        exp.RefreshTriggerProperty: exp.Properties.Location.POST_SCHEMA,
 797        exp.RemoteWithConnectionModelProperty: exp.Properties.Location.POST_SCHEMA,
 798        exp.ReturnsProperty: exp.Properties.Location.POST_SCHEMA,
 799        exp.RollupProperty: exp.Properties.Location.UNSUPPORTED,
 800        exp.RowAccessProperty: exp.Properties.Location.UNSUPPORTED,
 801        exp.RowFormatProperty: exp.Properties.Location.POST_SCHEMA,
 802        exp.RowFormatDelimitedProperty: exp.Properties.Location.POST_SCHEMA,
 803        exp.RowFormatSerdeProperty: exp.Properties.Location.POST_SCHEMA,
 804        exp.SampleProperty: exp.Properties.Location.POST_SCHEMA,
 805        exp.SchemaCommentProperty: exp.Properties.Location.POST_SCHEMA,
 806        exp.SecureProperty: exp.Properties.Location.POST_CREATE,
 807        exp.SecurityIntegrationProperty: exp.Properties.Location.POST_CREATE,
 808        exp.SerdeProperties: exp.Properties.Location.POST_SCHEMA,
 809        exp.Set: exp.Properties.Location.POST_SCHEMA,
 810        exp.SettingsProperty: exp.Properties.Location.POST_SCHEMA,
 811        exp.SetProperty: exp.Properties.Location.POST_CREATE,
 812        exp.SetConfigProperty: exp.Properties.Location.POST_SCHEMA,
 813        exp.SharingProperty: exp.Properties.Location.POST_EXPRESSION,
 814        exp.SequenceProperties: exp.Properties.Location.POST_EXPRESSION,
 815        exp.TriggerProperties: exp.Properties.Location.POST_EXPRESSION,
 816        exp.SortKeyProperty: exp.Properties.Location.UNSUPPORTED,
 817        exp.SqlReadWriteProperty: exp.Properties.Location.POST_SCHEMA,
 818        exp.SqlSecurityProperty: exp.Properties.Location.POST_SCHEMA,
 819        exp.StabilityProperty: exp.Properties.Location.POST_SCHEMA,
 820        exp.StorageHandlerProperty: exp.Properties.Location.POST_SCHEMA,
 821        exp.StorageProperty: exp.Properties.Location.UNSUPPORTED,
 822        exp.StreamingTableProperty: exp.Properties.Location.POST_CREATE,
 823        exp.StrictProperty: exp.Properties.Location.POST_SCHEMA,
 824        exp.Tags: exp.Properties.Location.POST_WITH,
 825        exp.TableSpaceProperty: exp.Properties.Location.UNSUPPORTED,
 826        exp.TemporaryProperty: exp.Properties.Location.POST_CREATE,
 827        exp.ToTableProperty: exp.Properties.Location.POST_SCHEMA,
 828        exp.TransientProperty: exp.Properties.Location.POST_CREATE,
 829        exp.TransformModelProperty: exp.Properties.Location.POST_SCHEMA,
 830        exp.MergeTreeTTL: exp.Properties.Location.POST_SCHEMA,
 831        exp.UnloggedProperty: exp.Properties.Location.POST_CREATE,
 832        exp.UsingProperty: exp.Properties.Location.POST_EXPRESSION,
 833        exp.UsingTemplateProperty: exp.Properties.Location.POST_SCHEMA,
 834        exp.ViewAttributeProperty: exp.Properties.Location.POST_SCHEMA,
 835        exp.VirtualProperty: exp.Properties.Location.POST_CREATE,
 836        exp.VolatileProperty: exp.Properties.Location.POST_CREATE,
 837        exp.WithDataProperty: exp.Properties.Location.POST_EXPRESSION,
 838        exp.WithJournalTableProperty: exp.Properties.Location.POST_NAME,
 839        exp.WithProcedureOptions: exp.Properties.Location.POST_SCHEMA,
 840        exp.WithSchemaBindingProperty: exp.Properties.Location.POST_SCHEMA,
 841        exp.WithSystemVersioningProperty: exp.Properties.Location.POST_SCHEMA,
 842        exp.WithoutRowidProperty: exp.Properties.Location.UNSUPPORTED,
 843        exp.ForceProperty: exp.Properties.Location.POST_CREATE,
 844    }
 845
 846    # Keywords that can't be used as unquoted identifier names
 847    RESERVED_KEYWORDS: t.ClassVar[set[str]] = set()
 848
 849    # Exprs whose comments are separated from them for better formatting
 850    WITH_SEPARATED_COMMENTS: t.ClassVar[tuple[type[exp.Expr], ...]] = (
 851        exp.Command,
 852        exp.Create,
 853        exp.Describe,
 854        exp.Delete,
 855        exp.Drop,
 856        exp.From,
 857        exp.Insert,
 858        exp.Join,
 859        exp.MultitableInserts,
 860        exp.Order,
 861        exp.Group,
 862        exp.Having,
 863        exp.Select,
 864        exp.SetOperation,
 865        exp.Update,
 866        exp.Where,
 867        exp.With,
 868    )
 869
 870    # Exprs that should not have their comments generated in maybe_comment
 871    EXCLUDE_COMMENTS: t.ClassVar[tuple[type[exp.Expr], ...]] = (
 872        exp.Binary,
 873        exp.SetOperation,
 874    )
 875
 876    # Exprs that can remain unwrapped when appearing in the context of an INTERVAL
 877    UNWRAPPED_INTERVAL_VALUES: t.ClassVar[tuple[type[exp.Expr], ...]] = (
 878        exp.Column,
 879        exp.Literal,
 880        exp.Neg,
 881        exp.Paren,
 882    )
 883
 884    PARAMETERIZABLE_TEXT_TYPES: t.ClassVar = {
 885        exp.DType.NVARCHAR,
 886        exp.DType.VARCHAR,
 887        exp.DType.CHAR,
 888        exp.DType.NCHAR,
 889    }
 890
 891    # Exprs that need to have all CTEs under them bubbled up to them
 892    EXPRESSIONS_WITHOUT_NESTED_CTES: t.ClassVar[set[type[exp.Expr]]] = set()
 893
 894    RESPECT_IGNORE_NULLS_UNSUPPORTED_EXPRESSIONS: t.ClassVar[tuple[type[exp.Expr], ...]] = ()
 895
 896    MOD_OPERATOR = "%"
 897
 898    # Infix operators that bind at least as tightly as %, so a Mod on their right side needs parentheses
 899    MOD_PAREN_PARENT_TYPES: t.ClassVar[tuple[type[exp.Expr], ...]] = (
 900        exp.Mul,
 901        exp.Div,
 902        exp.IntDiv,
 903        exp.Mod,
 904    )
 905
 906    # ALTER options that follow the others without a comma, e.g. MySQL's
 907    # ENGINE=InnoDB PARTITION BY LIST (...) or StarRocks' PARTITION BY ... DISTRIBUTED BY ...
 908    ALTER_PARTITION_OPTIONS: t.ClassVar[tuple[type[exp.Expr], ...]] = ()
 909
 910    SAFE_JSON_PATH_KEY_RE: t.ClassVar = exp.SAFE_IDENTIFIER_RE
 911
 912    SENTINEL_LINE_BREAK = "__SQLGLOT__LB__"
 913
 914    __slots__ = (
 915        "pretty",
 916        "identify",
 917        "normalize",
 918        "pad",
 919        "_indent",
 920        "normalize_functions",
 921        "unsupported_level",
 922        "max_unsupported",
 923        "leading_comma",
 924        "max_text_width",
 925        "comments",
 926        "dialect",
 927        "unsupported_messages",
 928        "_escaped_quote_end",
 929        "_escaped_byte_quote_end",
 930        "_escaped_identifier_end",
 931        "_identifier_escaped_sequences",
 932        "_next_name",
 933        "_identifier_start",
 934        "_identifier_end",
 935        "_quote_json_path_key_using_brackets",
 936        "_dispatch",
 937    )
 938
 939    def __init__(
 940        self,
 941        pretty: bool | int | None = None,
 942        identify: str | bool = False,
 943        normalize: bool = False,
 944        pad: int = 2,
 945        indent: int = 2,
 946        normalize_functions: str | bool | None = None,
 947        unsupported_level: ErrorLevel = ErrorLevel.WARN,
 948        max_unsupported: int = 3,
 949        leading_comma: bool = False,
 950        max_text_width: int = 80,
 951        comments: bool = True,
 952        dialect: DialectType = None,
 953    ):
 954        import sqlglot
 955        import sqlglot.dialects.dialect
 956
 957        self.pretty = pretty if pretty is not None else sqlglot.pretty
 958        self.identify = identify
 959        self.normalize = normalize
 960        self.pad = pad
 961        self._indent = indent
 962        self.unsupported_level = unsupported_level
 963        self.max_unsupported = max_unsupported
 964        self.leading_comma = leading_comma
 965        self.max_text_width = max_text_width
 966        self.comments = comments
 967        self.dialect = sqlglot.dialects.dialect.Dialect.get_or_raise(dialect)
 968
 969        # This is both a Dialect property and a Generator argument, so we prioritize the latter
 970        self.normalize_functions = (
 971            self.dialect.NORMALIZE_FUNCTIONS if normalize_functions is None else normalize_functions
 972        )
 973
 974        self.unsupported_messages: list[str] = []
 975        self._escaped_quote_end: str = (
 976            self.dialect.tokenizer_class.STRING_ESCAPES[0] + self.dialect.QUOTE_END
 977        )
 978        self._escaped_byte_quote_end: str = (
 979            self.dialect.tokenizer_class.STRING_ESCAPES[0] + self.dialect.BYTE_END
 980            if self.dialect.BYTE_END
 981            else ""
 982        )
 983        self._escaped_identifier_end = self.dialect.IDENTIFIER_END * 2
 984        self._identifier_escaped_sequences = self.dialect.IDENTIFIER_ESCAPED_SEQUENCES
 985
 986        self._next_name = name_sequence("_t")
 987
 988        self._identifier_start = self.dialect.IDENTIFIER_START
 989        self._identifier_end = self.dialect.IDENTIFIER_END
 990
 991        self._quote_json_path_key_using_brackets = True
 992
 993        cls = type(self)
 994        dispatch = _DISPATCH_CACHE.get(cls)
 995        if dispatch is None:
 996            dispatch = _build_dispatch(cls)
 997            _DISPATCH_CACHE[cls] = dispatch
 998        self._dispatch = dispatch
 999
1000    def generate(self, expression: exp.Expr, copy: bool = True) -> str:
1001        """
1002        Generates the SQL string corresponding to the given syntax tree.
1003
1004        Args:
1005            expression: The syntax tree.
1006            copy: Whether to copy the expression. The generator performs mutations so
1007                it is safer to copy.
1008
1009        Returns:
1010            The SQL string corresponding to `expression`.
1011        """
1012        if copy:
1013            expression = expression.copy()
1014
1015        expression = self.preprocess(expression)
1016
1017        self.unsupported_messages = []
1018        sql = self.sql(expression).strip()
1019
1020        if self.pretty:
1021            sql = sql.replace(self.SENTINEL_LINE_BREAK, "\n")
1022
1023        if self.unsupported_level == ErrorLevel.IGNORE:
1024            return sql
1025
1026        if self.unsupported_level == ErrorLevel.WARN:
1027            for msg in self.unsupported_messages:
1028                logger.warning(msg)
1029        elif self.unsupported_level == ErrorLevel.RAISE and self.unsupported_messages:
1030            raise UnsupportedError(concat_messages(self.unsupported_messages, self.max_unsupported))
1031
1032        return sql
1033
1034    def preprocess(self, expression: exp.Expr) -> exp.Expr:
1035        """Apply generic preprocessing transformations to a given expression."""
1036        expression = self._move_ctes_to_top_level(expression)
1037
1038        if self.ENSURE_BOOLS:
1039            import sqlglot.transforms
1040
1041            expression = sqlglot.transforms.ensure_bools(expression)
1042
1043        return expression
1044
1045    def _move_ctes_to_top_level(self, expression: E) -> E:
1046        if (
1047            not expression.parent
1048            and type(expression) in self.EXPRESSIONS_WITHOUT_NESTED_CTES
1049            and any(node.parent is not expression for node in expression.find_all(exp.With))
1050        ):
1051            import sqlglot.transforms
1052
1053            expression = sqlglot.transforms.move_ctes_to_top_level(expression)
1054        return expression
1055
1056    def unsupported(self, message: str) -> None:
1057        if self.unsupported_level == ErrorLevel.IMMEDIATE:
1058            raise UnsupportedError(message)
1059        self.unsupported_messages.append(message)
1060
1061    def sep(self, sep: str = " ") -> str:
1062        return f"{sep.strip()}\n" if self.pretty else sep
1063
1064    def seg(self, sql: str, sep: str = " ") -> str:
1065        return f"{self.sep(sep)}{sql}"
1066
1067    def sanitize_comment(self, comment: str) -> str:
1068        comment = " " + comment if comment[0].strip() else comment
1069        comment = comment + " " if comment[-1].strip() else comment
1070
1071        # Escape block comment markers to prevent premature closure or unintended nesting.
1072        # This is necessary because single-line comments (--) are converted to block comments
1073        # (/* */) on output, and any */ in the original text would close the comment early.
1074        comment = comment.replace("*/", "* /").replace("/*", "/ *")
1075
1076        return comment
1077
1078    def maybe_comment(
1079        self,
1080        sql: str,
1081        expression: exp.Expr | None = None,
1082        comments: list[str] | None = None,
1083        separated: bool = False,
1084    ) -> str:
1085        comments = (
1086            ((expression and expression.comments) if comments is None else comments)  # type: ignore
1087            if self.comments
1088            else None
1089        )
1090
1091        if not comments or isinstance(expression, self.EXCLUDE_COMMENTS):
1092            return sql
1093
1094        comments_list = [
1095            f"/*{self._replace_line_breaks(self.sanitize_comment(comment))}*/"
1096            for comment in comments
1097            if comment
1098        ]
1099
1100        if not comments_list:
1101            return sql
1102
1103        if separated or isinstance(expression, self.WITH_SEPARATED_COMMENTS):
1104            comments_sql = self.sep().join(comments_list)
1105            return (
1106                f"{self.sep()}{comments_sql}{sql}"
1107                if not sql or sql[0].isspace()
1108                else f"{comments_sql}{self.sep()}{sql}"
1109            )
1110
1111        return f"{sql} {' '.join(comments_list)}"
1112
1113    def wrap(self, expression: exp.Expr | str) -> str:
1114        this_sql = (
1115            self.sql(expression)
1116            if isinstance(expression, exp.UNWRAPPED_QUERIES)
1117            else self.sql(expression, "this")
1118        )
1119        if not this_sql:
1120            return "()"
1121
1122        this_sql = self.indent(this_sql, level=1, pad=0)
1123        return f"({self.sep('')}{this_sql}{self.seg(')', sep='')}"
1124
1125    def no_identify(self, func: t.Callable[..., str], *args, **kwargs) -> str:
1126        original = self.identify
1127        self.identify = False
1128        result = func(*args, **kwargs)
1129        self.identify = original
1130        return result
1131
1132    def normalize_func(self, name: str) -> str:
1133        if self.normalize_functions == "upper" or self.normalize_functions is True:
1134            return name.upper()
1135        if self.normalize_functions == "lower":
1136            return name.lower()
1137        return name
1138
1139    def indent(
1140        self,
1141        sql: str,
1142        level: int = 0,
1143        pad: int | None = None,
1144        skip_first: bool = False,
1145        skip_last: bool = False,
1146    ) -> str:
1147        if not self.pretty or not sql:
1148            return sql
1149
1150        pad = self.pad if pad is None else pad
1151        lines = sql.split("\n")
1152
1153        return "\n".join(
1154            (
1155                line
1156                if (skip_first and i == 0) or (skip_last and i == len(lines) - 1)
1157                else f"{' ' * (level * self._indent + pad)}{line}"
1158            )
1159            for i, line in enumerate(lines)
1160        )
1161
1162    def sql(
1163        self,
1164        expression: str | exp.Expr | None,
1165        key: str | None = None,
1166        comment: bool = True,
1167    ) -> str:
1168        if not expression:
1169            return ""
1170
1171        if isinstance(expression, str):
1172            return expression
1173
1174        if key:
1175            value = expression.args.get(key)
1176            if value:
1177                return self.sql(value)
1178            return ""
1179
1180        handler = self._dispatch.get(expression.__class__)
1181
1182        if handler:
1183            sql = handler(self, expression)
1184        elif isinstance(expression, exp.Func):
1185            sql = self.function_fallback_sql(expression)
1186        elif isinstance(expression, exp.Property):
1187            sql = self.property_sql(expression)
1188        else:
1189            raise ValueError(f"Unsupported expression type {expression.__class__.__name__}")
1190
1191        return self.maybe_comment(sql, expression) if self.comments and comment else sql
1192
1193    def uncache_sql(self, expression: exp.Uncache) -> str:
1194        table = self.sql(expression, "this")
1195        exists_sql = " IF EXISTS" if expression.args.get("exists") else ""
1196        return f"UNCACHE TABLE{exists_sql} {table}"
1197
1198    def cache_sql(self, expression: exp.Cache) -> str:
1199        lazy = " LAZY" if expression.args.get("lazy") else ""
1200        table = self.sql(expression, "this")
1201        options = expression.args.get("options")
1202        options = f" OPTIONS({self.sql(options[0])} = {self.sql(options[1])})" if options else ""
1203        sql = self.sql(expression, "expression")
1204        sql = f" AS{self.sep()}{sql}" if sql else ""
1205        sql = f"CACHE{lazy} TABLE {table}{options}{sql}"
1206        return self.prepend_ctes(expression, sql)
1207
1208    def characterset_sql(self, expression: exp.CharacterSet) -> str:
1209        default = "DEFAULT " if expression.args.get("default") else ""
1210        return f"{default}CHARACTER SET={self.sql(expression, 'this')}"
1211
1212    def column_parts(self, expression: exp.Column) -> str:
1213        if expression.args.get("shadow") and self.dialect.PROJECTION_ALIASES_SHADOW_SOURCE_NAMES:
1214            # The qualifier would be captured by a colliding projection alias (see qualify_columns)
1215            return self.sql(expression, "this")
1216
1217        return ".".join(
1218            self.sql(part)
1219            for part in (
1220                expression.args.get("catalog"),
1221                expression.args.get("db"),
1222                expression.args.get("table"),
1223                expression.args.get("this"),
1224            )
1225            if part
1226        )
1227
1228    def column_sql(self, expression: exp.Column) -> str:
1229        join_mark = " (+)" if expression.args.get("join_mark") else ""
1230
1231        if join_mark and not self.dialect.SUPPORTS_COLUMN_JOIN_MARKS:
1232            join_mark = ""
1233            self.unsupported("Outer join syntax using the (+) operator is not supported.")
1234
1235        return f"{self.column_parts(expression)}{join_mark}"
1236
1237    def pseudocolumn_sql(self, expression: exp.Pseudocolumn) -> str:
1238        return self.column_sql(expression)
1239
1240    def columnposition_sql(self, expression: exp.ColumnPosition) -> str:
1241        this = self.sql(expression, "this")
1242        this = f" {this}" if this else ""
1243        position = self.sql(expression, "position")
1244        return f"{position}{this}"
1245
1246    def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
1247        column = self.sql(expression, "this")
1248        kind = self.sql(expression, "kind")
1249        constraints = self.expressions(expression, key="constraints", sep=" ", flat=True)
1250        exists = "IF NOT EXISTS " if expression.args.get("exists") else ""
1251        kind = f"{sep}{kind}" if kind else ""
1252        constraints = f" {constraints}" if constraints else ""
1253        position = self.sql(expression, "position")
1254        position = f" {position}" if position else ""
1255
1256        if expression.find(exp.ComputedColumnConstraint) and not self.COMPUTED_COLUMN_WITH_TYPE:
1257            kind = ""
1258
1259        return f"{exists}{column}{kind}{constraints}{position}"
1260
1261    def columnconstraint_sql(self, expression: exp.ColumnConstraint) -> str:
1262        this = self.sql(expression, "this")
1263        kind_sql = self.sql(expression, "kind").strip()
1264        return f"CONSTRAINT {this} {kind_sql}" if this else kind_sql
1265
1266    def computedcolumnconstraint_sql(self, expression: exp.ComputedColumnConstraint) -> str:
1267        this = self.sql(expression, "this")
1268        if expression.args.get("not_null"):
1269            persisted = " PERSISTED NOT NULL"
1270        elif expression.args.get("persisted"):
1271            persisted = " PERSISTED"
1272        else:
1273            persisted = ""
1274
1275        return f"AS {this}{persisted}"
1276
1277    def autoincrementcolumnconstraint_sql(self, _: exp.AutoIncrementColumnConstraint) -> str:
1278        return self.token_sql(TokenType.AUTO_INCREMENT)
1279
1280    def compresscolumnconstraint_sql(self, expression: exp.CompressColumnConstraint) -> str:
1281        if isinstance(expression.this, list):
1282            this = self.wrap(self.expressions(expression, key="this", flat=True))
1283        else:
1284            this = self.sql(expression, "this")
1285
1286        return f"COMPRESS {this}"
1287
1288    def generatedasidentitycolumnconstraint_sql(
1289        self, expression: exp.GeneratedAsIdentityColumnConstraint
1290    ) -> str:
1291        this = ""
1292        if expression.this is not None:
1293            on_null = " ON NULL" if expression.args.get("on_null") else ""
1294            this = " ALWAYS" if expression.this else f" BY DEFAULT{on_null}"
1295
1296        start = expression.args.get("start")
1297        start = f"START WITH {start}" if start else ""
1298        increment = expression.args.get("increment")
1299        increment = f" INCREMENT BY {increment}" if increment else ""
1300        minvalue = expression.args.get("minvalue")
1301        minvalue = f" MINVALUE {minvalue}" if minvalue else ""
1302        maxvalue = expression.args.get("maxvalue")
1303        maxvalue = f" MAXVALUE {maxvalue}" if maxvalue else ""
1304        cycle = expression.args.get("cycle")
1305        cycle_sql = ""
1306
1307        if cycle is not None:
1308            cycle_sql = f"{' NO' if not cycle else ''} CYCLE"
1309            cycle_sql = cycle_sql.strip() if not start and not increment else cycle_sql
1310
1311        sequence_opts = ""
1312        if start or increment or cycle_sql:
1313            sequence_opts = f"{start}{increment}{minvalue}{maxvalue}{cycle_sql}"
1314            sequence_opts = f" ({sequence_opts.strip()})"
1315
1316        expr = self.sql(expression, "expression")
1317        expr = f"({expr})" if expr else "IDENTITY"
1318
1319        return f"GENERATED{this} AS {expr}{sequence_opts}"
1320
1321    def generatedasrowcolumnconstraint_sql(
1322        self, expression: exp.GeneratedAsRowColumnConstraint
1323    ) -> str:
1324        start = "START" if expression.args.get("start") else "END"
1325        hidden = " HIDDEN" if expression.args.get("hidden") else ""
1326        return f"GENERATED ALWAYS AS ROW {start}{hidden}"
1327
1328    def periodforsystemtimeconstraint_sql(
1329        self, expression: exp.PeriodForSystemTimeConstraint
1330    ) -> str:
1331        return f"PERIOD FOR SYSTEM_TIME ({self.sql(expression, 'this')}, {self.sql(expression, 'expression')})"
1332
1333    def notnullcolumnconstraint_sql(self, expression: exp.NotNullColumnConstraint) -> str:
1334        return f"{'' if expression.args.get('allow_null') else 'NOT '}NULL"
1335
1336    def primarykeycolumnconstraint_sql(self, expression: exp.PrimaryKeyColumnConstraint) -> str:
1337        desc = expression.args.get("desc")
1338        if desc is not None:
1339            return f"PRIMARY KEY{' DESC' if desc else ' ASC'}"
1340        options = self.expressions(expression, key="options", flat=True, sep=" ")
1341        options = f" {options}" if options else ""
1342        include = self.sql(expression, "include")
1343        return f"PRIMARY KEY{include}{options}"
1344
1345    def uniquecolumnconstraint_sql(self, expression: exp.UniqueColumnConstraint) -> str:
1346        this = self.sql(expression, "this")
1347        this = f" {this}" if this else ""
1348        index_type = expression.args.get("index_type")
1349        index_type = f" USING {index_type}" if index_type else ""
1350        on_conflict = self.sql(expression, "on_conflict")
1351        on_conflict = f" {on_conflict}" if on_conflict else ""
1352        nulls_sql = " NULLS NOT DISTINCT" if expression.args.get("nulls") else ""
1353        options = self.expressions(expression, key="options", flat=True, sep=" ")
1354        options = f" {options}" if options else ""
1355        include = self.sql(expression, "include")
1356        return f"UNIQUE{nulls_sql}{this}{index_type}{on_conflict}{include}{options}"
1357
1358    def inoutcolumnconstraint_sql(self, expression: exp.InOutColumnConstraint) -> str:
1359        input_ = expression.args.get("input_")
1360        output = expression.args.get("output")
1361        variadic = expression.args.get("variadic")
1362
1363        # VARIADIC is mutually exclusive with IN/OUT/INOUT
1364        if variadic:
1365            return "VARIADIC"
1366
1367        if input_ and output:
1368            return f"IN{self.INOUT_SEPARATOR}OUT"
1369        if input_:
1370            return "IN"
1371        if output:
1372            return "OUT"
1373
1374        return ""
1375
1376    def createable_sql(self, expression: exp.Create, locations: defaultdict) -> str:
1377        return self.sql(expression, "this")
1378
1379    def create_sql(self, expression: exp.Create) -> str:
1380        kind = self.sql(expression, "kind")
1381        kind = self.dialect.INVERSE_CREATABLE_KIND_MAPPING.get(kind) or kind
1382
1383        properties = expression.args.get("properties")
1384
1385        if (
1386            kind == "TRIGGER"
1387            and properties
1388            and properties.expressions
1389            and isinstance(properties.expressions[0], exp.TriggerProperties)
1390            and properties.expressions[0].args.get("constraint")
1391        ):
1392            kind = f"CONSTRAINT {kind}"
1393
1394        properties_locs = self.locate_properties(properties) if properties else defaultdict()
1395
1396        this = self.createable_sql(expression, properties_locs)
1397
1398        properties_sql = ""
1399        if properties_locs.get(exp.Properties.Location.POST_SCHEMA) or properties_locs.get(
1400            exp.Properties.Location.POST_WITH
1401        ):
1402            props_ast = exp.Properties(
1403                expressions=[
1404                    *properties_locs[exp.Properties.Location.POST_SCHEMA],
1405                    *properties_locs[exp.Properties.Location.POST_WITH],
1406                ]
1407            )
1408            props_ast.parent = expression
1409            properties_sql = self.sql(props_ast)
1410
1411            if properties_locs.get(exp.Properties.Location.POST_SCHEMA):
1412                properties_sql = self.sep() + properties_sql
1413            elif not self.pretty:
1414                # Standalone POST_WITH properties need a leading whitespace in non-pretty mode
1415                properties_sql = f" {properties_sql}"
1416
1417        begin = " BEGIN" if expression.args.get("begin") else ""
1418
1419        expression_sql = self.sql(expression, "expression")
1420        if expression_sql:
1421            expression_sql = f"{begin}{self.sep()}{expression_sql}"
1422
1423            if not isinstance(expression.expression, exp.MacroOverloads) and (
1424                self.CREATE_FUNCTION_RETURN_AS or not isinstance(expression.expression, exp.Return)
1425            ):
1426                postalias_props_sql = ""
1427                if properties_locs.get(exp.Properties.Location.POST_ALIAS):
1428                    postalias_props_sql = self.properties(
1429                        exp.Properties(
1430                            expressions=properties_locs[exp.Properties.Location.POST_ALIAS]
1431                        ),
1432                        wrapped=False,
1433                    )
1434                postalias_props_sql = f" {postalias_props_sql}" if postalias_props_sql else ""
1435                expression_sql = f" AS{postalias_props_sql}{expression_sql}"
1436
1437        postindex_props_sql = ""
1438        if properties_locs.get(exp.Properties.Location.POST_INDEX):
1439            postindex_props_sql = self.properties(
1440                exp.Properties(expressions=properties_locs[exp.Properties.Location.POST_INDEX]),
1441                wrapped=False,
1442                prefix=" ",
1443            )
1444
1445        indexes = self.expressions(expression, key="indexes", indent=False, sep=" ")
1446        indexes = f" {indexes}" if indexes else ""
1447        index_sql = indexes + postindex_props_sql
1448
1449        replace = " OR REPLACE" if expression.args.get("replace") else ""
1450        refresh = " OR REFRESH" if expression.args.get("refresh") else ""
1451        unique = " UNIQUE" if expression.args.get("unique") else ""
1452
1453        clustered = expression.args.get("clustered")
1454        if clustered is None:
1455            clustered_sql = ""
1456        elif clustered:
1457            clustered_sql = " CLUSTERED COLUMNSTORE"
1458        else:
1459            clustered_sql = " NONCLUSTERED COLUMNSTORE"
1460
1461        postcreate_props_sql = ""
1462        if properties_locs.get(exp.Properties.Location.POST_CREATE):
1463            postcreate_props_sql = self.properties(
1464                exp.Properties(expressions=properties_locs[exp.Properties.Location.POST_CREATE]),
1465                sep=" ",
1466                prefix=" ",
1467                wrapped=False,
1468            )
1469
1470        modifiers = "".join((clustered_sql, replace, refresh, unique, postcreate_props_sql))
1471
1472        postexpression_props_sql = ""
1473        if properties_locs.get(exp.Properties.Location.POST_EXPRESSION):
1474            postexpression_props_sql = self.properties(
1475                exp.Properties(
1476                    expressions=properties_locs[exp.Properties.Location.POST_EXPRESSION]
1477                ),
1478                sep=" ",
1479                prefix=" ",
1480                wrapped=False,
1481            )
1482
1483        concurrently = " CONCURRENTLY" if expression.args.get("concurrently") else ""
1484        exists_sql = " IF NOT EXISTS" if expression.args.get("exists") else ""
1485        no_schema_binding = (
1486            " WITH NO SCHEMA BINDING" if expression.args.get("no_schema_binding") else ""
1487        )
1488
1489        clone = self.sql(expression, "clone")
1490        clone = f" {clone}" if clone else ""
1491
1492        if kind in self.EXPRESSION_PRECEDES_PROPERTIES_CREATABLES:
1493            properties_expression = f"{expression_sql}{properties_sql}"
1494        else:
1495            properties_expression = f"{properties_sql}{expression_sql}"
1496
1497        expression_sql = f"CREATE{modifiers} {kind}{concurrently}{exists_sql} {this}{properties_expression}{postexpression_props_sql}{index_sql}{no_schema_binding}{clone}"
1498        return self.prepend_ctes(expression, expression_sql)
1499
1500    def sequenceproperties_sql(self, expression: exp.SequenceProperties) -> str:
1501        start = self.sql(expression, "start")
1502        start = f"START WITH {start}" if start else ""
1503        increment = self.sql(expression, "increment")
1504        increment = f" INCREMENT BY {increment}" if increment else ""
1505        minvalue = self.sql(expression, "minvalue")
1506        minvalue = f" MINVALUE {minvalue}" if minvalue else ""
1507        maxvalue = self.sql(expression, "maxvalue")
1508        maxvalue = f" MAXVALUE {maxvalue}" if maxvalue else ""
1509        owned = self.sql(expression, "owned")
1510        owned = f" OWNED BY {owned}" if owned else ""
1511
1512        cache = expression.args.get("cache")
1513        if cache is None:
1514            cache_str = ""
1515        elif cache is True:
1516            cache_str = " CACHE"
1517        else:
1518            cache_str = f" CACHE {cache}"
1519
1520        options = self.expressions(expression, key="options", flat=True, sep=" ")
1521        options = f" {options}" if options else ""
1522
1523        return f"{start}{increment}{minvalue}{maxvalue}{cache_str}{options}{owned}".lstrip()
1524
1525    def triggerproperties_sql(self, expression: exp.TriggerProperties) -> str:
1526        timing = expression.args.get("timing", "")
1527        events = " OR ".join(self.sql(event) for event in expression.args.get("events") or [])
1528        timing_events = f"{timing} {events}".strip() if timing or events else ""
1529
1530        parts = [timing_events, "ON", self.sql(expression, "table")]
1531
1532        if referenced_table := expression.args.get("referenced_table"):
1533            parts.extend(["FROM", self.sql(referenced_table)])
1534
1535        if deferrable := expression.args.get("deferrable"):
1536            parts.append(deferrable)
1537
1538        if initially := expression.args.get("initially"):
1539            parts.append(f"INITIALLY {initially}")
1540
1541        if referencing := expression.args.get("referencing"):
1542            parts.append(self.sql(referencing))
1543
1544        if for_each := expression.args.get("for_each"):
1545            parts.append(f"FOR EACH {for_each}")
1546
1547        if when := expression.args.get("when"):
1548            parts.append(f"WHEN ({self.sql(when)})")
1549
1550        parts.append(self.sql(expression, "execute"))
1551
1552        return self.sep().join(parts)
1553
1554    def triggerreferencing_sql(self, expression: exp.TriggerReferencing) -> str:
1555        parts = []
1556
1557        if old_alias := expression.args.get("old"):
1558            parts.append(f"OLD TABLE AS {self.sql(old_alias)}")
1559
1560        if new_alias := expression.args.get("new"):
1561            parts.append(f"NEW TABLE AS {self.sql(new_alias)}")
1562
1563        return f"REFERENCING {' '.join(parts)}"
1564
1565    def triggerevent_sql(self, expression: exp.TriggerEvent) -> str:
1566        columns = expression.args.get("columns")
1567        if columns:
1568            return f"{expression.this} OF {self.expressions(expression, key='columns', flat=True)}"
1569
1570        return self.sql(expression, "this")
1571
1572    def clone_sql(self, expression: exp.Clone) -> str:
1573        this = self.sql(expression, "this")
1574        shallow = "SHALLOW " if expression.args.get("shallow") else ""
1575        keyword = "COPY" if expression.args.get("copy") and self.SUPPORTS_TABLE_COPY else "CLONE"
1576        return f"{shallow}{keyword} {this}"
1577
1578    def describe_sql(self, expression: exp.Describe) -> str:
1579        style = expression.args.get("style")
1580        style = f" {style}" if style else ""
1581        partition = self.sql(expression, "partition")
1582        partition = f" {partition}" if partition else ""
1583        format = self.sql(expression, "format")
1584        format = f" {format}" if format else ""
1585        as_json = " AS JSON" if expression.args.get("as_json") else ""
1586
1587        return f"DESCRIBE{style}{format} {self.sql(expression, 'this')}{partition}{as_json}"
1588
1589    def heredoc_sql(self, expression: exp.Heredoc) -> str:
1590        tag = self.sql(expression, "tag")
1591        return f"${tag}${self.sql(expression, 'this')}${tag}$"
1592
1593    def prepend_ctes(self, expression: exp.Expr, sql: str) -> str:
1594        with_ = self.sql(expression, "with_")
1595        if with_:
1596            sql = f"{with_}{self.sep()}{sql}"
1597        return sql
1598
1599    def with_sql(self, expression: exp.With) -> str:
1600        udfs = self.expressions(expression, key="udfs", flat=True)
1601        udfs = f"WITH {udfs}" if udfs else ""
1602
1603        sql = self.expressions(expression, flat=True)
1604
1605        recursive = (
1606            "RECURSIVE "
1607            if self.CTE_RECURSIVE_KEYWORD_REQUIRED and expression.args.get("recursive")
1608            else ""
1609        )
1610        search = self.sql(expression, "search")
1611        search = f" {search}" if search else ""
1612        cycle = self.sql(expression, "cycle")
1613        cycle = f" {cycle}" if cycle else ""
1614
1615        sql = f"WITH {recursive}{sql}{search}{cycle}" if sql else ""
1616        return f"{udfs} {sql}" if udfs and sql else f"{udfs}{sql}"
1617
1618    def cte_sql(self, expression: exp.CTE) -> str:
1619        alias = expression.args.get("alias")
1620        if alias:
1621            alias.add_comments(expression.pop_comments())
1622
1623        alias_sql = self.sql(expression, "alias")
1624
1625        materialized = expression.args.get("materialized")
1626        if materialized is False:
1627            materialized = "NOT MATERIALIZED "
1628        elif materialized:
1629            materialized = "MATERIALIZED "
1630
1631        key_expressions = self.expressions(expression, key="key_expressions", flat=True)
1632        key_expressions = f" USING KEY ({key_expressions})" if key_expressions else ""
1633
1634        return f"{alias_sql}{key_expressions} AS {materialized or ''}{self.wrap(expression)}"
1635
1636    def tablealias_sql(self, expression: exp.TableAlias) -> str:
1637        alias = self.sql(expression, "this")
1638        columns = self.expressions(expression, key="columns", flat=True)
1639        columns = f"({columns})" if columns else ""
1640
1641        if (
1642            columns
1643            and not self.SUPPORTS_TABLE_ALIAS_COLUMNS
1644            and not (self.SUPPORTS_NAMED_CTE_COLUMNS and isinstance(expression.parent, exp.CTE))
1645        ):
1646            columns = ""
1647            self.unsupported("Named columns are not supported in table alias.")
1648
1649        if not alias and not self.dialect.UNNEST_COLUMN_ONLY:
1650            alias = self._next_name()
1651
1652        return f"{alias}{columns}"
1653
1654    def bitstring_sql(self, expression: exp.BitString) -> str:
1655        this = self.sql(expression, "this")
1656        if self.dialect.BIT_START:
1657            return f"{self.dialect.BIT_START}{this}{self.dialect.BIT_END}"
1658        return f"{int(this, 2)}"
1659
1660    def hexstring_sql(
1661        self, expression: exp.HexString, binary_function_repr: str | None = None
1662    ) -> str:
1663        this = self.sql(expression, "this")
1664        is_integer_type = expression.args.get("is_integer")
1665
1666        if (is_integer_type and not self.dialect.HEX_STRING_IS_INTEGER_TYPE) or (
1667            not self.dialect.HEX_START and not binary_function_repr
1668        ):
1669            # Integer representation will be returned if:
1670            # - The read dialect treats the hex value as integer literal but not the write
1671            # - The transpilation is not supported (write dialect hasn't set HEX_START or the param flag)
1672            return f"{int(this, 16)}"
1673
1674        if not is_integer_type:
1675            # Read dialect treats the hex value as BINARY/BLOB
1676            if binary_function_repr:
1677                # The write dialect supports the transpilation to its equivalent BINARY/BLOB
1678                return self.func(binary_function_repr, exp.Literal.string(this))
1679            if self.dialect.HEX_STRING_IS_INTEGER_TYPE:
1680                # The write dialect does not support the transpilation, it'll treat the hex value as INTEGER
1681                self.unsupported("Unsupported transpilation from BINARY/BLOB hex string")
1682
1683        return f"{self.dialect.HEX_START}{this}{self.dialect.HEX_END}"
1684
1685    def bytestring_sql(self, expression: exp.ByteString) -> str:
1686        this = self.sql(expression, "this")
1687        is_bytes = bool(expression.args.get("is_bytes"))
1688        if is_bytes and self.BYTE_STRING_FUNCTION:
1689            # Hex digits can be quoted directly without escaping.
1690            return self.func(self.BYTE_STRING_FUNCTION, f"'{this.encode('latin-1').hex()}'")
1691
1692        if self.dialect.BYTE_START:
1693            escaped_byte_string = self.escape_str(
1694                this,
1695                escape_backslash=bool(
1696                    self.dialect.tokenizer_class.NUMERIC_ESCAPES
1697                    or self.dialect.tokenizer_class.DROP_UNKNOWN_ESCAPES
1698                ),
1699                delimiter=self.dialect.BYTE_END,
1700                escaped_delimiter=self._escaped_byte_quote_end,
1701                is_byte_string=True,
1702                is_bytes=is_bytes,
1703            )
1704            delimited_byte_string = (
1705                f"{self.dialect.BYTE_START}{escaped_byte_string}{self.dialect.BYTE_END}"
1706            )
1707            if is_bytes and not self.dialect.BYTE_STRING_IS_BYTES_TYPE:
1708                return self.sql(
1709                    exp.cast(delimited_byte_string, exp.DType.BINARY, dialect=self.dialect)
1710                )
1711            if not is_bytes and self.dialect.BYTE_STRING_IS_BYTES_TYPE:
1712                return self.sql(
1713                    exp.cast(delimited_byte_string, exp.DType.VARCHAR, dialect=self.dialect)
1714                )
1715
1716            return delimited_byte_string
1717
1718        if "\\" in self.dialect.tokenizer_class.STRING_ESCAPES:
1719            return self.sql(exp.Literal.string(this))
1720
1721        self.unsupported(f"Byte strings are not supported for {self.dialect.__class__.__name__}")
1722        return ""
1723
1724    def unicodestring_sql(self, expression: exp.UnicodeString) -> str:
1725        this = self.sql(expression, "this")
1726        escape = expression.args.get("escape")
1727        unicode_start = self.dialect.UNICODE_START
1728
1729        if unicode_start:
1730            escape_substitute = r"\\\1"
1731            left_quote, right_quote = unicode_start, self.dialect.UNICODE_END or ""
1732        else:
1733            escape_substitute = r"\\u\1"
1734            left_quote, right_quote = self.dialect.QUOTE_START, self.dialect.QUOTE_END
1735
1736        if escape:
1737            escape_pattern = re.compile(rf"{escape.name}(\d+)")
1738            escape_sql = f" UESCAPE {self.sql(escape)}" if self.SUPPORTS_UESCAPE else ""
1739        else:
1740            escape_pattern = ESCAPED_UNICODE_RE
1741            escape_sql = ""
1742
1743        if not unicode_start or (escape and not self.SUPPORTS_UESCAPE):
1744            this = escape_pattern.sub(self.UNICODE_SUBSTITUTE or escape_substitute, this)
1745
1746        if unicode_start:
1747            # A Unicode literal only escapes its delimiter by doubling it; the escape character
1748            # introduces a code point, so the dialect's ordinary string escapes don't apply here
1749            this = self._replace_line_breaks(this).replace(right_quote, right_quote * 2)
1750        else:
1751            this = self.escape_str(this, escape_backslash=False)
1752
1753        return f"{left_quote}{this}{right_quote}{escape_sql}"
1754
1755    def rawstring_sql(self, expression: exp.RawString) -> str:
1756        string = expression.this
1757        if "\\" in self.dialect.tokenizer_class.STRING_ESCAPES:
1758            string = string.replace("\\", "\\\\")
1759
1760        string = self.escape_str(string, escape_backslash=False)
1761        return f"{self.dialect.QUOTE_START}{string}{self.dialect.QUOTE_END}"
1762
1763    def datatypeparam_sql(self, expression: exp.DataTypeParam) -> str:
1764        this = self.sql(expression, "this")
1765        specifier = self.sql(expression, "expression")
1766        specifier = f" {specifier}" if specifier and self.DATA_TYPE_SPECIFIERS_ALLOWED else ""
1767        return f"{this}{specifier}"
1768
1769    def datatype_param_bound_limiter(
1770        self,
1771        expression: exp.DataType,
1772        type_value: exp.DType,
1773        defaults: tuple[int, ...],
1774        bounds: tuple[int | None, ...],
1775    ) -> exp.DataType:
1776        params = expression.expressions
1777
1778        if not params:
1779            if defaults:
1780                expression.set(
1781                    "expressions",
1782                    [exp.DataTypeParam(this=exp.Literal.number(d)) for d in defaults],
1783                )
1784            return expression
1785
1786        if not bounds:
1787            return expression
1788
1789        for i, param in enumerate(params):
1790            bound = bounds[i] if i < len(bounds) else None
1791            if bound is None:
1792                continue
1793
1794            param_value = param.this if isinstance(param, exp.DataTypeParam) else param
1795            value = (
1796                param_value.to_py()
1797                if isinstance(param_value, exp.Literal) and param_value.is_number
1798                else None
1799            )
1800            if isinstance(value, (int, Decimal)) and value > bound:
1801                self.unsupported(
1802                    f"{type_value.value} parameter {param_value.name} exceeds "
1803                    f"{self.dialect.__class__.__name__}'s maximum of {bound}; capping"
1804                )
1805                params[i] = exp.DataTypeParam(this=exp.Literal.number(bound))
1806
1807        return expression
1808
1809    def datatype_sql(self, expression: exp.DataType) -> str:
1810        nested = ""
1811        values = ""
1812
1813        expr_nested = expression.args.get("nested")
1814        type_value = expression.this
1815
1816        if (
1817            not expr_nested
1818            and isinstance(type_value, exp.DType)
1819            and (settings := self.TYPE_PARAM_SETTINGS.get(type_value))
1820        ):
1821            expression = self.datatype_param_bound_limiter(expression, type_value, *settings)
1822
1823        interior = (
1824            self.expressions(
1825                expression, dynamic=True, new_line=True, skip_first=True, skip_last=True
1826            )
1827            if expr_nested and self.pretty
1828            else self.expressions(expression, flat=True)
1829        )
1830
1831        if type_value in self.UNSUPPORTED_TYPES:
1832            self.unsupported(
1833                f"Data type {type_value.value} is not supported when targeting {self.dialect.__class__.__name__}"
1834            )
1835
1836        type_sql: t.Any = ""
1837        if type_value == exp.DType.USERDEFINED and expression.args.get("kind"):
1838            type_sql = self.sql(expression, "kind")
1839        elif type_value == exp.DType.CHARACTER_SET:
1840            char = f"CHAR({interior})" if interior else "CHAR"
1841            return f"{char} CHARACTER SET {self.sql(expression, 'kind')}"
1842        else:
1843            type_sql = (
1844                self.TYPE_MAPPING.get(type_value, type_value.value)
1845                if isinstance(type_value, exp.DType)
1846                else type_value
1847            )
1848
1849        if interior:
1850            if expr_nested:
1851                nested = f"{self.STRUCT_DELIMITER[0]}{interior}{self.STRUCT_DELIMITER[1]}"
1852                if expression.args.get("values") is not None:
1853                    delimiters = ("[", "]") if type_value == exp.DType.ARRAY else ("(", ")")
1854                    values = self.expressions(expression, key="values", flat=True)
1855                    values = f"{delimiters[0]}{values}{delimiters[1]}"
1856            elif type_value == exp.DType.INTERVAL:
1857                nested = f" {interior}"
1858            else:
1859                nested = f"({interior})"
1860
1861        type_sql = f"{type_sql}{nested}{values}"
1862        if self.TZ_TO_WITH_TIME_ZONE and type_value in (
1863            exp.DType.TIMETZ,
1864            exp.DType.TIMESTAMPTZ,
1865        ):
1866            type_sql = f"{type_sql} WITH TIME ZONE"
1867
1868        collate = self.sql(expression, "collate")
1869        if collate:
1870            type_sql = f"{type_sql} COLLATE {collate}"
1871
1872        return type_sql
1873
1874    def directory_sql(self, expression: exp.Directory) -> str:
1875        local = "LOCAL " if expression.args.get("local") else ""
1876        row_format = self.sql(expression, "row_format")
1877        row_format = f" {row_format}" if row_format else ""
1878        return f"{local}DIRECTORY {self.sql(expression, 'this')}{row_format}"
1879
1880    def delete_sql(self, expression: exp.Delete) -> str:
1881        hint = self.sql(expression, "hint")
1882        this = self.sql(expression, "this")
1883        this = f" FROM {this}" if this else ""
1884        using = self.expressions(expression, key="using")
1885        using = f" USING {using}" if using else ""
1886        cluster = self.sql(expression, "cluster")
1887        cluster = f" {cluster}" if cluster else ""
1888        where = self.sql(expression, "where")
1889        returning = self.sql(expression, "returning")
1890        order = self.sql(expression, "order")
1891        limit = self.sql(expression, "limit")
1892        tables = self.expressions(expression, key="tables")
1893        tables = f" {tables}" if tables else ""
1894        if self.RETURNING_END:
1895            expression_sql = f"{this}{using}{cluster}{where}{returning}{order}{limit}"
1896        else:
1897            expression_sql = f"{returning}{this}{using}{cluster}{where}{order}{limit}"
1898        return self.prepend_ctes(expression, f"DELETE{hint}{tables}{expression_sql}")
1899
1900    def drop_sql(self, expression: exp.Drop) -> str:
1901        tables = self.expressions(expression, key="tables", flat=True)
1902        expressions = self.expressions(expression, flat=True)
1903        expressions = f" ({expressions})" if expressions else ""
1904        kind = expression.args["kind"]
1905        kind = self.dialect.INVERSE_CREATABLE_KIND_MAPPING.get(kind) or kind
1906        iceberg = (
1907            " ICEBERG"
1908            if expression.args.get("iceberg") and self.SUPPORTS_DROP_ALTER_ICEBERG_PROPERTY
1909            else ""
1910        )
1911        exists_sql = " IF EXISTS " if expression.args.get("exists") else " "
1912        concurrently_sql = " CONCURRENTLY" if expression.args.get("concurrently") else ""
1913        on_cluster = self.sql(expression, "cluster")
1914        on_cluster = f" {on_cluster}" if on_cluster else ""
1915        temporary = " TEMPORARY" if expression.args.get("temporary") else ""
1916        materialized = " MATERIALIZED" if expression.args.get("materialized") else ""
1917        cascade = " CASCADE" if expression.args.get("cascade") else ""
1918        restrict = " RESTRICT" if expression.args.get("restrict") else ""
1919        constraints = " CONSTRAINTS" if expression.args.get("constraints") else ""
1920        purge = " PURGE" if expression.args.get("purge") else ""
1921        sync = " SYNC" if expression.args.get("sync") else ""
1922        force = " FORCE" if expression.args.get("force") else ""
1923        return f"DROP{temporary}{materialized}{iceberg} {kind}{concurrently_sql}{exists_sql}{tables}{on_cluster}{expressions}{cascade}{restrict}{constraints}{purge}{sync}{force}"
1924
1925    def set_operation(self, expression: exp.SetOperation) -> str:
1926        op_type = type(expression)
1927        op_name = op_type.key.upper()
1928
1929        distinct = expression.args.get("distinct")
1930        if (
1931            distinct is False
1932            and op_type in (exp.Except, exp.Intersect)
1933            and not self.EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE
1934        ):
1935            self.unsupported(f"{op_name} ALL is not supported")
1936
1937        default_distinct = self.dialect.SET_OP_DISTINCT_BY_DEFAULT[op_type]
1938
1939        if distinct is None:
1940            distinct = default_distinct
1941            if distinct is None:
1942                self.unsupported(f"{op_name} requires DISTINCT or ALL to be specified")
1943
1944        if distinct is default_distinct:
1945            distinct_or_all = ""
1946        else:
1947            distinct_or_all = " DISTINCT" if distinct else " ALL"
1948
1949        side_kind = " ".join(filter(None, [expression.side, expression.kind]))
1950        side_kind = f"{side_kind} " if side_kind else ""
1951
1952        by_name = " BY NAME" if expression.args.get("by_name") else ""
1953        on = self.expressions(expression, key="on", flat=True)
1954        on = f" ON ({on})" if on else ""
1955
1956        return f"{side_kind}{op_name}{distinct_or_all}{by_name}{on}"
1957
1958    def set_operations(self, expression: exp.SetOperation) -> str:
1959        if not self.SET_OP_MODIFIERS:
1960            limit = expression.args.get("limit")
1961            order = expression.args.get("order")
1962            offset = expression.args.get("offset")
1963
1964            if limit or order or offset:
1965                select = self._move_ctes_to_top_level(
1966                    exp.subquery(expression, "_l_0", copy=False).select("*", copy=False)
1967                )
1968
1969                for arg in ("limit", "order", "offset"):
1970                    if value := expression.args.get(arg):
1971                        select.set(arg, value.pop())
1972                return self.sql(select)
1973
1974        sqls: list[str] = []
1975        stack: list[str | exp.Expr | int | None] = [expression]
1976        depth = 0
1977        open_parens = ""
1978
1979        while stack:
1980            node = stack.pop()
1981
1982            if isinstance(node, int):
1983                # Closes a plain grouping opened below, restoring its depth
1984                depth = node
1985                sqls[-1] += self.sep("") + self.indent(")", level=depth, pad=0)
1986            elif isinstance(node, exp.SetOperation):
1987                stack.append(node.expression)
1988                stack.append(
1989                    self.maybe_comment(
1990                        self.set_operation(node), comments=node.comments, separated=True
1991                    )
1992                )
1993                left = node.this
1994                if (
1995                    not self.SET_OP_PARENTHESIZED_OPERANDS
1996                    and not self.dialect.INTERSECT_BINDS_TIGHTER_THAN_UNION_AND_EXCEPT
1997                ):
1998                    # Left grouping is implicit, so skip the `SELECT * FROM (...)` wrapper:
1999                    # it renames duplicate columns and deepens recursion. Inner CTEs and
2000                    # modifiers still need the wrapper.
2001                    wrappers: list[exp.Subquery] = []
2002                    inner = left
2003                    while isinstance(inner, exp.Subquery) and inner.is_wrapper:
2004                        wrappers.append(inner)
2005                        inner = inner.this
2006
2007                    if (
2008                        isinstance(inner, exp.SetOperation)
2009                        and not inner.args.get("with_")
2010                        and not any(inner.args.get(key) for key in exp.QUERY_MODIFIERS)
2011                    ):
2012                        for wrapper in wrappers:
2013                            inner.add_comments(wrapper.pop_comments())
2014                        left = inner
2015                elif (
2016                    self.SET_OP_PARENTHESIZED_OPERANDS
2017                    and isinstance(left, exp.Subquery)
2018                    and left.is_wrapper
2019                    and not left.comments
2020                    and isinstance(left.this, exp.SetOperation)
2021                    and not left.this.args.get("with_")
2022                    and not any(left.this.args.get(key) for key in exp.QUERY_MODIFIERS)
2023                ):
2024                    # Write a plain grouping's parentheses here rather than recursing through
2025                    # subquery_sql: left-to-right chains nest one grouping per INTERSECT, and
2026                    # long ones would exhaust the stack. The depth pushed here marks the close.
2027                    open_parens += self.indent("(", level=depth, pad=0) + self.sep("")
2028                    stack.append(depth)
2029                    depth += 1
2030                    left = left.this
2031                stack.append(left)
2032            else:
2033                if (
2034                    not self.SET_OP_LIMITS
2035                    and isinstance(node, exp.Select)
2036                    and node.args.get("limit")
2037                ):
2038                    node = node.subquery(copy=False)
2039                    if not self.SET_OP_PARENTHESIZED_OPERANDS:
2040                        node = exp.select("*").from_(node, copy=False)
2041                elif (
2042                    not self.SET_OP_PARENTHESIZED_OPERANDS
2043                    and isinstance(node, exp.Subquery)
2044                    and isinstance(node.unnest(), exp.SetOperation)
2045                ):
2046                    node = exp.select("*").from_(node, copy=False)
2047                sqls.append(open_parens + self.indent(self.sql(node), level=depth, pad=0))
2048                open_parens = ""
2049
2050        this = self.sep().join(sqls)
2051        this = self.query_modifiers(expression, this)
2052        return self.prepend_ctes(expression, this)
2053
2054    def fetch_sql(self, expression: exp.Fetch) -> str:
2055        direction = expression.args.get("direction")
2056        direction = f" {direction}" if direction else ""
2057        count = self.sql(expression, "count")
2058        count = f" {count}" if count else ""
2059        limit_options = self.sql(expression, "limit_options")
2060        limit_options = f"{limit_options}" if limit_options else " ROWS ONLY"
2061        return f"{self.seg('FETCH')}{direction}{count}{limit_options}"
2062
2063    def limitoptions_sql(self, expression: exp.LimitOptions) -> str:
2064        percent = " PERCENT" if expression.args.get("percent") else ""
2065        rows = " ROWS" if expression.args.get("rows") else ""
2066        with_ties = " WITH TIES" if expression.args.get("with_ties") else ""
2067        if not with_ties and rows:
2068            with_ties = " ONLY"
2069        return f"{percent}{rows}{with_ties}"
2070
2071    def filter_sql(self, expression: exp.Filter) -> str:
2072        this = self.sql(expression, "this")
2073        where = self.sql(expression, "expression").strip()
2074        return f"{this} FILTER({where})"
2075
2076    def per_sql(self, expression: exp.Per) -> str:
2077        keys = ", ".join(
2078            f"{self.sql(key, 'this')} {self.sql(key, 'with_fill')}"
2079            if isinstance(key, exp.Ordered) and key.args.get("with_fill")
2080            else self.sql(key)
2081            for key in expression.expressions
2082        )
2083        return f"{self.sql(expression, 'this')} PER ({keys})"
2084
2085    def hint_sql(self, expression: exp.Hint) -> str:
2086        if not self.QUERY_HINTS:
2087            self.unsupported("Hints are not supported")
2088            return ""
2089
2090        return f" /*+ {self.expressions(expression, sep=self.QUERY_HINT_SEP).strip()} */"
2091
2092    def indexparameters_sql(self, expression: exp.IndexParameters) -> str:
2093        using = self.sql(expression, "using")
2094        using = f" USING {using}" if using else ""
2095        columns = self.expressions(expression, key="columns", flat=True)
2096        columns = f"({columns})" if columns else ""
2097        partition_by = self.expressions(expression, key="partition_by", flat=True)
2098        partition_by = f" PARTITION BY {partition_by}" if partition_by else ""
2099        where = self.sql(expression, "where")
2100        include = self.expressions(expression, key="include", flat=True)
2101        if include:
2102            include = f" INCLUDE ({include})"
2103        with_storage = self.expressions(expression, key="with_storage", flat=True)
2104        with_storage = f" WITH ({with_storage})" if with_storage else ""
2105        tablespace = self.sql(expression, "tablespace")
2106        if tablespace:
2107            prefix = "" if isinstance(expression.parent, exp.Index) else " USING INDEX"
2108            tablespace = f"{prefix} TABLESPACE {tablespace}"
2109        on = self.sql(expression, "on")
2110        on = f" ON {on}" if on else ""
2111
2112        return f"{using}{columns}{include}{with_storage}{tablespace}{partition_by}{where}{on}"
2113
2114    def index_sql(self, expression: exp.Index) -> str:
2115        unique = "UNIQUE " if expression.args.get("unique") else ""
2116        primary = "PRIMARY " if expression.args.get("primary") else ""
2117        amp = "AMP " if expression.args.get("amp") else ""
2118        name = self.sql(expression, "this")
2119        name = f"{name} " if name else ""
2120        table = self.sql(expression, "table")
2121        table = f"{self.INDEX_ON} {table}" if table else ""
2122
2123        index = "INDEX " if not table else ""
2124
2125        params = self.sql(expression, "params")
2126        return f"{unique}{primary}{amp}{index}{name}{table}{params}"
2127
2128    def dynamicidentifier_sql(self, expression: exp.DynamicIdentifier) -> str:
2129        this = expression.this
2130        if this and this.is_string:
2131            resolved = maybe_parse(this.name).sql(self.dialect)
2132            if "expressions" in expression.args:
2133                # `IDENTIFIER(...)` invoked as a function, e.g. `IDENTIFIER('my_func')(1, 2)`
2134                # We can't safely emit the call to other dialects since name/arg semantics may differ
2135                self.unsupported(
2136                    "Transpiling dynamically-invoked IDENTIFIER() functions is unsupported"
2137                )
2138            return resolved
2139        self.unsupported("IDENTIFIER() with non-literal arguments is not supported")
2140        return self.func("IDENTIFIER", this)
2141
2142    def identifier_sql(self, expression: exp.Identifier) -> str:
2143        text = expression.name
2144        lower = text.lower()
2145        quoted = expression.quoted
2146        text = lower if self.normalize and not quoted else text
2147        if self._identifier_escaped_sequences:
2148            for char, escaped in self._identifier_escaped_sequences.items():
2149                text = text.replace(char, escaped)
2150        text = text.replace(self._identifier_end, self._escaped_identifier_end)
2151        if (
2152            quoted
2153            or self.dialect.can_quote(expression, self.identify)
2154            or lower in self.RESERVED_KEYWORDS
2155            or (not self.dialect.IDENTIFIERS_CAN_START_WITH_DIGIT and text[:1].isdigit())
2156        ):
2157            text = (
2158                f"{self._identifier_start}{self._replace_line_breaks(text)}{self._identifier_end}"
2159            )
2160        return text
2161
2162    def hex_sql(self, expression: exp.Hex) -> str:
2163        text = self.func(self.HEX_FUNC, self.sql(expression, "this"))
2164        if self.dialect.HEX_LOWERCASE:
2165            text = self.func("LOWER", text)
2166
2167        return text
2168
2169    def lowerhex_sql(self, expression: exp.LowerHex) -> str:
2170        text = self.func(self.HEX_FUNC, self.sql(expression, "this"))
2171        if not self.dialect.HEX_LOWERCASE:
2172            text = self.func("LOWER", text)
2173        return text
2174
2175    def inputoutputformat_sql(self, expression: exp.InputOutputFormat) -> str:
2176        input_format = self.sql(expression, "input_format")
2177        input_format = f"INPUTFORMAT {input_format}" if input_format else ""
2178        output_format = self.sql(expression, "output_format")
2179        output_format = f"OUTPUTFORMAT {output_format}" if output_format else ""
2180        return self.sep().join((input_format, output_format))
2181
2182    def national_sql(self, expression: exp.National, prefix: str = "N") -> str:
2183        string = self.sql(exp.Literal.string(expression.name))
2184        return f"{prefix}{string}"
2185
2186    def partition_sql(self, expression: exp.Partition) -> str:
2187        partition_keyword = "SUBPARTITION" if expression.args.get("subpartition") else "PARTITION"
2188        return f"{partition_keyword}({self.expressions(expression, flat=True)})"
2189
2190    def properties_sql(self, expression: exp.Properties) -> str:
2191        root_properties = []
2192        with_properties = []
2193
2194        for p in expression.expressions:
2195            p_loc = self.PROPERTIES_LOCATION[p.__class__]
2196            if p_loc == exp.Properties.Location.POST_WITH:
2197                with_properties.append(p)
2198            elif p_loc == exp.Properties.Location.POST_SCHEMA:
2199                root_properties.append(p)
2200
2201        root_props_ast = exp.Properties(expressions=root_properties)
2202        root_props_ast.parent = expression.parent
2203
2204        with_props_ast = exp.Properties(expressions=with_properties)
2205        with_props_ast.parent = expression.parent
2206
2207        root_props = self.root_properties(root_props_ast)
2208        with_props = self.with_properties(with_props_ast)
2209
2210        if root_props and with_props and not self.pretty:
2211            with_props = " " + with_props
2212
2213        return root_props + with_props
2214
2215    def root_properties(self, properties: exp.Properties) -> str:
2216        if properties.expressions:
2217            return self.expressions(properties, indent=False, sep=" ")
2218        return ""
2219
2220    def properties(
2221        self,
2222        properties: exp.Properties,
2223        prefix: str = "",
2224        sep: str = ", ",
2225        suffix: str = "",
2226        wrapped: bool = True,
2227    ) -> str:
2228        if properties.expressions:
2229            expressions = self.expressions(properties, sep=sep, indent=False)
2230            if expressions:
2231                expressions = self.wrap(expressions) if wrapped else expressions
2232                return f"{prefix}{' ' if prefix.strip() else ''}{expressions}{suffix}"
2233        return ""
2234
2235    def with_properties(self, properties: exp.Properties) -> str:
2236        return self.properties(properties, prefix=self.seg(self.WITH_PROPERTIES_PREFIX, sep=""))
2237
2238    def locate_properties(self, properties: exp.Properties) -> defaultdict:
2239        properties_locs = defaultdict(list)
2240        for p in properties.expressions:
2241            p_loc = self.PROPERTIES_LOCATION[p.__class__]
2242            if p_loc != exp.Properties.Location.UNSUPPORTED:
2243                properties_locs[p_loc].append(p)
2244            else:
2245                self.unsupported(f"Unsupported property {p.key}")
2246
2247        return properties_locs
2248
2249    def property_name(self, expression: exp.Property, string_key: bool = False) -> str:
2250        if isinstance(expression.this, exp.Dot):
2251            return self.sql(expression, "this")
2252        return self.sql(exp.Literal.string(expression.name)) if string_key else expression.name
2253
2254    def property_sql(self, expression: exp.Property) -> str:
2255        property_cls = expression.__class__
2256        if property_cls == exp.Property:
2257            return f"{self.property_name(expression)}={self.sql(expression, 'value')}"
2258
2259        property_name = exp.Properties.PROPERTY_TO_NAME.get(property_cls)
2260        if not property_name:
2261            self.unsupported(f"Unsupported property {expression.key}")
2262            return ""
2263
2264        return f"{property_name}={self.sql(expression, 'this')}"
2265
2266    def uuidproperty_sql(self, expression: exp.UuidProperty) -> str:
2267        return f"UUID {self.sql(expression, 'this')}"
2268
2269    def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
2270        if self.SUPPORTS_CREATE_TABLE_LIKE:
2271            options = " ".join(f"{e.name} {self.sql(e, 'value')}" for e in expression.expressions)
2272            options = f" {options}" if options else ""
2273
2274            like = f"LIKE {self.sql(expression, 'this')}{options}"
2275            if self.LIKE_PROPERTY_INSIDE_SCHEMA and not isinstance(expression.parent, exp.Schema):
2276                like = f"({like})"
2277
2278            return like
2279
2280        if expression.expressions:
2281            self.unsupported("Transpilation of LIKE property options is unsupported")
2282
2283        select = exp.select("*").from_(expression.this).limit(0)
2284        return f"AS {self.sql(select)}"
2285
2286    def fallbackproperty_sql(self, expression: exp.FallbackProperty) -> str:
2287        no = "NO " if expression.args.get("no") else ""
2288        protection = " PROTECTION" if expression.args.get("protection") else ""
2289        return f"{no}FALLBACK{protection}"
2290
2291    def journalproperty_sql(self, expression: exp.JournalProperty) -> str:
2292        no = "NO " if expression.args.get("no") else ""
2293        local = expression.args.get("local")
2294        local = f"{local} " if local else ""
2295        dual = "DUAL " if expression.args.get("dual") else ""
2296        before = "BEFORE " if expression.args.get("before") else ""
2297        after = "AFTER " if expression.args.get("after") else ""
2298        return f"{no}{local}{dual}{before}{after}JOURNAL"
2299
2300    def freespaceproperty_sql(self, expression: exp.FreespaceProperty) -> str:
2301        freespace = self.sql(expression, "this")
2302        percent = " PERCENT" if expression.args.get("percent") else ""
2303        return f"FREESPACE={freespace}{percent}"
2304
2305    def checksumproperty_sql(self, expression: exp.ChecksumProperty) -> str:
2306        if expression.args.get("default"):
2307            property = "DEFAULT"
2308        elif expression.args.get("on"):
2309            property = "ON"
2310        else:
2311            property = "OFF"
2312        return f"CHECKSUM={property}"
2313
2314    def mergeblockratioproperty_sql(self, expression: exp.MergeBlockRatioProperty) -> str:
2315        if expression.args.get("no"):
2316            return "NO MERGEBLOCKRATIO"
2317        if expression.args.get("default"):
2318            return "DEFAULT MERGEBLOCKRATIO"
2319
2320        percent = " PERCENT" if expression.args.get("percent") else ""
2321        return f"MERGEBLOCKRATIO={self.sql(expression, 'this')}{percent}"
2322
2323    def moduleproperty_sql(self, expression: exp.ModuleProperty) -> str:
2324        expressions = self.expressions(expression, flat=True)
2325        expressions = f"({expressions})" if expressions else ""
2326        return f"USING {self.sql(expression, 'this')}{expressions}"
2327
2328    def datablocksizeproperty_sql(self, expression: exp.DataBlocksizeProperty) -> str:
2329        default = expression.args.get("default")
2330        minimum = expression.args.get("minimum")
2331        maximum = expression.args.get("maximum")
2332        if default or minimum or maximum:
2333            if default:
2334                prop = "DEFAULT"
2335            elif minimum:
2336                prop = "MINIMUM"
2337            else:
2338                prop = "MAXIMUM"
2339            return f"{prop} DATABLOCKSIZE"
2340        units = expression.args.get("units")
2341        units = f" {units}" if units else ""
2342        return f"DATABLOCKSIZE={self.sql(expression, 'size')}{units}"
2343
2344    def blockcompressionproperty_sql(self, expression: exp.BlockCompressionProperty) -> str:
2345        autotemp = expression.args.get("autotemp")
2346        always = expression.args.get("always")
2347        default = expression.args.get("default")
2348        manual = expression.args.get("manual")
2349        never = expression.args.get("never")
2350
2351        if autotemp is not None:
2352            prop = f"AUTOTEMP({self.expressions(autotemp)})"
2353        elif always:
2354            prop = "ALWAYS"
2355        elif default:
2356            prop = "DEFAULT"
2357        elif manual:
2358            prop = "MANUAL"
2359        elif never:
2360            prop = "NEVER"
2361        return f"BLOCKCOMPRESSION={prop}"
2362
2363    def isolatedloadingproperty_sql(self, expression: exp.IsolatedLoadingProperty) -> str:
2364        no = expression.args.get("no")
2365        no = " NO" if no else ""
2366        concurrent = expression.args.get("concurrent")
2367        concurrent = " CONCURRENT" if concurrent else ""
2368        target = self.sql(expression, "target")
2369        target = f" {target}" if target else ""
2370        return f"WITH{no}{concurrent} ISOLATED LOADING{target}"
2371
2372    def partitionboundspec_sql(self, expression: exp.PartitionBoundSpec) -> str:
2373        if isinstance(expression.this, list):
2374            return f"IN ({self.expressions(expression, key='this', flat=True)})"
2375        if expression.this:
2376            modulus = self.sql(expression, "this")
2377            remainder = self.sql(expression, "expression")
2378            return f"WITH (MODULUS {modulus}, REMAINDER {remainder})"
2379
2380        from_expressions = self.expressions(expression, key="from_expressions", flat=True)
2381        to_expressions = self.expressions(expression, key="to_expressions", flat=True)
2382        return f"FROM ({from_expressions}) TO ({to_expressions})"
2383
2384    def partitionedofproperty_sql(self, expression: exp.PartitionedOfProperty) -> str:
2385        this = self.sql(expression, "this")
2386
2387        for_values_or_default = expression.expression
2388        if isinstance(for_values_or_default, exp.PartitionBoundSpec):
2389            for_values_or_default = f" FOR VALUES {self.sql(for_values_or_default)}"
2390        else:
2391            for_values_or_default = " DEFAULT"
2392
2393        return f"PARTITION OF {this}{for_values_or_default}"
2394
2395    def lockingproperty_sql(self, expression: exp.LockingProperty) -> str:
2396        kind = expression.args.get("kind")
2397        this = f" {self.sql(expression, 'this')}" if expression.this else ""
2398        for_or_in = expression.args.get("for_or_in")
2399        for_or_in = f" {for_or_in}" if for_or_in else ""
2400        lock_type = expression.args.get("lock_type")
2401        override = " OVERRIDE" if expression.args.get("override") else ""
2402        return f"LOCKING {kind}{this}{for_or_in} {lock_type}{override}"
2403
2404    def lockingstatement_sql(self, expression: exp.LockingStatement) -> str:
2405        self.unsupported("LOCKING request modifier is not supported")
2406        return self.sql(expression, "expression")
2407
2408    def withdataproperty_sql(self, expression: exp.WithDataProperty) -> str:
2409        data_sql = f"WITH {'NO ' if expression.args.get('no') else ''}DATA"
2410        statistics = expression.args.get("statistics")
2411        statistics_sql = ""
2412        if statistics is not None:
2413            statistics_sql = f" AND {'NO ' if not statistics else ''}STATISTICS"
2414        return f"{data_sql}{statistics_sql}"
2415
2416    def withsystemversioningproperty_sql(self, expression: exp.WithSystemVersioningProperty) -> str:
2417        this = self.sql(expression, "this")
2418        this = f"HISTORY_TABLE={this}" if this else ""
2419        data_consistency: str | None = self.sql(expression, "data_consistency")
2420        data_consistency = (
2421            f"DATA_CONSISTENCY_CHECK={data_consistency}" if data_consistency else None
2422        )
2423        retention_period: str | None = self.sql(expression, "retention_period")
2424        retention_period = (
2425            f"HISTORY_RETENTION_PERIOD={retention_period}" if retention_period else None
2426        )
2427
2428        if this:
2429            on_sql = self.func("ON", this, data_consistency, retention_period)
2430        else:
2431            on_sql = "ON" if expression.args.get("on") else "OFF"
2432
2433        sql = f"SYSTEM_VERSIONING={on_sql}"
2434
2435        return f"WITH({sql})" if expression.args.get("with_") else sql
2436
2437    def insert_sql(self, expression: exp.Insert) -> str:
2438        hint = self.sql(expression, "hint")
2439        overwrite = expression.args.get("overwrite")
2440
2441        if isinstance(expression.this, exp.Directory):
2442            this = " OVERWRITE" if overwrite else " INTO"
2443        else:
2444            this = self.INSERT_OVERWRITE if overwrite else " INTO"
2445
2446        stored = self.sql(expression, "stored")
2447        stored = f" {stored}" if stored else ""
2448        alternative = expression.args.get("alternative")
2449        alternative = f" OR {alternative}" if alternative else ""
2450        ignore = " IGNORE" if expression.args.get("ignore") else ""
2451        is_function = expression.args.get("is_function")
2452        if is_function:
2453            this = f"{this} FUNCTION"
2454        this = f"{this} {self.sql(expression, 'this')}"
2455
2456        exists = " IF EXISTS" if expression.args.get("exists") else ""
2457        where = self.sql(expression, "where")
2458        where = f"{self.sep()}REPLACE WHERE {where}" if where else ""
2459        using = self.expressions(expression, key="using", flat=True)
2460        using = f"{self.sep()}REPLACE USING ({using})" if using else ""
2461        expression_sql = f"{self.sep()}{self.sql(expression, 'expression')}"
2462        on_conflict = self.sql(expression, "conflict")
2463        on_conflict = f" {on_conflict}" if on_conflict else ""
2464        by_name = " BY NAME" if expression.args.get("by_name") else ""
2465        default_values = "DEFAULT VALUES" if expression.args.get("default") else ""
2466        returning = self.sql(expression, "returning")
2467
2468        if self.RETURNING_END:
2469            expression_sql = f"{expression_sql}{on_conflict}{default_values}{returning}"
2470        else:
2471            expression_sql = f"{returning}{expression_sql}{on_conflict}"
2472
2473        partition_by = self.sql(expression, "partition")
2474        partition_by = f" {partition_by}" if partition_by else ""
2475        settings = self.sql(expression, "settings")
2476        settings = f" {settings}" if settings else ""
2477
2478        source = self.sql(expression, "source")
2479        source = f"TABLE {source}" if source else ""
2480
2481        sql = f"INSERT{hint}{alternative}{ignore}{this}{stored}{by_name}{exists}{partition_by}{settings}{where}{using}{expression_sql}{source}"
2482        return self.prepend_ctes(expression, sql)
2483
2484    def introducer_sql(self, expression: exp.Introducer) -> str:
2485        return f"{self.sql(expression, 'this')} {self.sql(expression, 'expression')}"
2486
2487    def kill_sql(self, expression: exp.Kill) -> str:
2488        kind = self.sql(expression, "kind")
2489        kind = f" {kind}" if kind else ""
2490        this = self.sql(expression, "this")
2491        this = f" {this}" if this else ""
2492        return f"KILL{kind}{this}"
2493
2494    def pseudotype_sql(self, expression: exp.PseudoType) -> str:
2495        return expression.name
2496
2497    def objectidentifier_sql(self, expression: exp.ObjectIdentifier) -> str:
2498        return expression.name
2499
2500    def onconflict_sql(self, expression: exp.OnConflict) -> str:
2501        conflict = "ON DUPLICATE KEY" if expression.args.get("duplicate") else "ON CONFLICT"
2502
2503        constraint = self.sql(expression, "constraint")
2504        constraint = f" ON CONSTRAINT {constraint}" if constraint else ""
2505
2506        conflict_keys = self.expressions(expression, key="conflict_keys", flat=True)
2507        if conflict_keys:
2508            conflict_keys = f"({conflict_keys})"
2509
2510        index_predicate = self.sql(expression, "index_predicate")
2511        conflict_keys = f"{conflict_keys}{index_predicate} "
2512
2513        action = self.sql(expression, "action")
2514
2515        expressions = self.expressions(expression, flat=True)
2516        if expressions:
2517            set_keyword = "SET " if self.DUPLICATE_KEY_UPDATE_WITH_SET else ""
2518            expressions = f" {set_keyword}{expressions}"
2519
2520        where = self.sql(expression, "where")
2521        return f"{conflict}{constraint}{conflict_keys}{action}{expressions}{where}"
2522
2523    def returning_sql(self, expression: exp.Returning) -> str:
2524        return f"{self.seg('RETURNING')} {self.expressions(expression, flat=True)}"
2525
2526    def rowformatdelimitedproperty_sql(self, expression: exp.RowFormatDelimitedProperty) -> str:
2527        fields = self.sql(expression, "fields")
2528        fields = f" FIELDS TERMINATED BY {fields}" if fields else ""
2529        escaped = self.sql(expression, "escaped")
2530        escaped = f" ESCAPED BY {escaped}" if escaped else ""
2531        items = self.sql(expression, "collection_items")
2532        items = f" COLLECTION ITEMS TERMINATED BY {items}" if items else ""
2533        keys = self.sql(expression, "map_keys")
2534        keys = f" MAP KEYS TERMINATED BY {keys}" if keys else ""
2535        lines = self.sql(expression, "lines")
2536        lines = f" LINES TERMINATED BY {lines}" if lines else ""
2537        null = self.sql(expression, "null")
2538        null = f" NULL DEFINED AS {null}" if null else ""
2539        return f"ROW FORMAT DELIMITED{fields}{escaped}{items}{keys}{lines}{null}"
2540
2541    def withtablehint_sql(self, expression: exp.WithTableHint) -> str:
2542        return f"WITH ({self.expressions(expression, flat=True)})"
2543
2544    def indextablehint_sql(self, expression: exp.IndexTableHint) -> str:
2545        this = f"{self.sql(expression, 'this')} INDEX"
2546        target = self.sql(expression, "target")
2547        target = f" FOR {target}" if target else ""
2548        return f"{this}{target} ({self.expressions(expression, flat=True)})"
2549
2550    def historicaldata_sql(self, expression: exp.HistoricalData) -> str:
2551        this = self.sql(expression, "this")
2552        kind = self.sql(expression, "kind")
2553        expr = self.sql(expression, "expression")
2554        return f"{this} ({kind} => {expr})"
2555
2556    def table_parts(self, expression: exp.Table) -> str:
2557        return ".".join(
2558            self.sql(part)
2559            for part in (
2560                expression.args.get("catalog"),
2561                expression.args.get("db"),
2562                expression.args.get("this"),
2563            )
2564            if part is not None
2565        )
2566
2567    def table_sql(self, expression: exp.Table, sep: str = " AS ") -> str:
2568        table = self.table_parts(expression)
2569        only = "ONLY " if expression.args.get("only") else ""
2570        partition = self.sql(expression, "partition")
2571        partition = f" {partition}" if partition else ""
2572        version = self.sql(expression, "version")
2573        version = f" {version}" if version else ""
2574        alias = self.sql(expression, "alias")
2575        alias = f"{sep}{alias}" if alias else ""
2576
2577        sample = self.sql(expression, "sample")
2578        post_alias = ""
2579        pre_alias = ""
2580
2581        if self.dialect.ALIAS_POST_TABLESAMPLE:
2582            pre_alias = sample
2583        else:
2584            post_alias = sample
2585
2586        if self.dialect.ALIAS_POST_VERSION:
2587            pre_alias = f"{pre_alias}{version}"
2588        else:
2589            post_alias = f"{post_alias}{version}"
2590
2591        hints = self.expressions(expression, key="hints", sep=" ")
2592        hints = f" {hints}" if hints and self.TABLE_HINTS else ""
2593        pivots = self.expressions(expression, key="pivots", sep="", flat=True)
2594        joins = self.indent(
2595            self.expressions(expression, key="joins", sep="", flat=True), skip_first=True
2596        )
2597        laterals = self.expressions(expression, key="laterals", sep="")
2598
2599        file_format = self.sql(expression, "format")
2600        pattern = self.sql(expression, "pattern")
2601        if file_format:
2602            pattern = f", PATTERN => {pattern}" if pattern else ""
2603            file_format = f" (FILE_FORMAT => {file_format}{pattern})"
2604        elif pattern:
2605            file_format = f" (PATTERN => {pattern})"
2606
2607        ordinality = expression.args.get("ordinality") or ""
2608        if ordinality:
2609            ordinality = f" WITH ORDINALITY{alias}"
2610            alias = ""
2611
2612        when = self.sql(expression, "when")
2613        if when:
2614            if self.HISTORICAL_DATA_POST_ALIAS:
2615                alias = f"{alias} {when}"
2616            else:
2617                table = f"{table} {when}"
2618
2619        changes = self.sql(expression, "changes")
2620        changes = f" {changes}" if changes else ""
2621
2622        rows_from = self.expressions(expression, key="rows_from")
2623        if rows_from:
2624            table = f"ROWS FROM {self.wrap(rows_from)}"
2625
2626        indexed = expression.args.get("indexed")
2627        if indexed is not None:
2628            indexed = f" INDEXED BY {self.sql(indexed)}" if indexed else " NOT INDEXED"
2629        else:
2630            indexed = ""
2631
2632        return f"{only}{table}{changes}{partition}{file_format}{pre_alias}{alias}{indexed}{hints}{pivots}{post_alias}{joins}{laterals}{ordinality}"
2633
2634    def tablefromrows_sql(self, expression: exp.TableFromRows) -> str:
2635        table = self.func("TABLE", expression.this)
2636        alias = self.sql(expression, "alias")
2637        alias = f" AS {alias}" if alias else ""
2638        sample = self.sql(expression, "sample")
2639        pivots = self.expressions(expression, key="pivots", sep="", flat=True)
2640        joins = self.indent(
2641            self.expressions(expression, key="joins", sep="", flat=True), skip_first=True
2642        )
2643        return f"{table}{alias}{pivots}{sample}{joins}"
2644
2645    def tablesample_sql(
2646        self,
2647        expression: exp.TableSample,
2648        tablesample_keyword: str | None = None,
2649    ) -> str:
2650        if expression.expressions:
2651            self.unsupported("Multiple sample sets are not supported")
2652            return ""
2653
2654        method = self.sql(expression, "method")
2655        method = f"{method} " if method and self.TABLESAMPLE_WITH_METHOD else ""
2656        numerator = self.sql(expression, "bucket_numerator")
2657        denominator = self.sql(expression, "bucket_denominator")
2658        field = self.sql(expression, "bucket_field")
2659        field = f" ON {field}" if field else ""
2660        bucket = f"BUCKET {numerator} OUT OF {denominator}{field}" if numerator else ""
2661        seed = self.sql(expression, "seed")
2662        seed = f" {self.TABLESAMPLE_SEED_KEYWORD} ({seed})" if seed else ""
2663
2664        size = self.sql(expression, "size")
2665        if size and self.TABLESAMPLE_SIZE_IS_ROWS:
2666            size = f"{size} ROWS"
2667
2668        percent = self.sql(expression, "percent")
2669        if percent and not self.dialect.TABLESAMPLE_SIZE_IS_PERCENT:
2670            percent = f"{percent} PERCENT"
2671
2672        expr = f"{bucket}{percent}{size}"
2673        if self.TABLESAMPLE_REQUIRES_PARENS:
2674            expr = f"({expr})"
2675
2676        return f" {tablesample_keyword or self.TABLESAMPLE_KEYWORDS} {method}{expr}{seed}"
2677
2678    def _pivot_in_value_aliases(self, expression: exp.Pivot) -> list[exp.Expression] | None:
2679        # Returns the rewritten field.expressions list with PivotAlias wrappers injected where
2680        # the stored column name differs from the target dialect's natural output.
2681        columns = expression.args.get("columns")
2682        if not columns or len(expression.fields) != 1:
2683            return None
2684
2685        args = expression.args
2686        parser_cls = self.dialect.parser_class
2687
2688        tgt_identify_pivot_strings = parser_cls.IDENTIFY_PIVOT_STRINGS
2689        tgt_prefixed_pivot_columns = parser_cls.PREFIXED_PIVOT_COLUMNS
2690        tgt_pivot_column_naming = parser_cls.PIVOT_COLUMN_NAMING
2691
2692        src_identify_pivot_strings = args.get("identify_pivot_strings", tgt_identify_pivot_strings)
2693        src_prefixed_pivot_columns = args.get("prefixed_pivot_columns", tgt_prefixed_pivot_columns)
2694        src_pivot_column_naming = args.get("pivot_column_naming", tgt_pivot_column_naming)
2695
2696        if (
2697            src_identify_pivot_strings == tgt_identify_pivot_strings
2698            and src_prefixed_pivot_columns == tgt_prefixed_pivot_columns
2699            and src_pivot_column_naming == tgt_pivot_column_naming
2700        ):
2701            return None
2702
2703        in_exprs = expression.fields[0].expressions
2704        step = len(columns) // len(in_exprs)
2705
2706        # Derive the per-value suffix from the first stored column vs the first IN-list value.
2707        # This correctly handles dialects (e.g. Spark single-agg) that ignore agg aliases.
2708        first_base = in_exprs[0].sql() if src_identify_pivot_strings else in_exprs[0].alias_or_name
2709        first_stored = columns[0].name
2710
2711        # exit if only suffix matches, not prefix. (e.g. BigQuery, which cannot be fixed)
2712        if not first_stored.startswith(first_base):
2713            return None
2714
2715        suffix = first_stored[len(first_base) :]
2716
2717        # Whether the target dialect would append an agg-name suffix for this pivot.
2718        # Spark single-agg uniquely drops the agg alias entirely.
2719        target_has_suffix = (
2720            len(expression.expressions) > 1 or tgt_pivot_column_naming != "agg_name_if_multiple"
2721        ) and any(a.alias for a in expression.expressions)
2722        source_has_suffix = suffix != ""
2723
2724        new_exprs: list[exp.Expression] = []
2725        modified = False
2726        for val_idx, e in enumerate(in_exprs):
2727            if isinstance(e, exp.PivotAlias):
2728                new_exprs.append(e)
2729                continue
2730
2731            i = val_idx * step
2732            stored_full = columns[i].name
2733            stored_value = stored_full[: -len(suffix)] if suffix else stored_full
2734            target_value = e.sql() if tgt_identify_pivot_strings else e.alias_or_name
2735
2736            # Source had a suffix, but target won't apply one
2737            if source_has_suffix and not target_has_suffix:
2738                new_exprs.append(
2739                    exp.PivotAlias(this=e, alias=exp.to_identifier(stored_full, quoted=True))
2740                )
2741                modified = True
2742            # Value-part mismatch (e.g. Snowflake's literal-style values vs others).
2743            elif stored_value != target_value:
2744                new_exprs.append(
2745                    exp.PivotAlias(this=e, alias=exp.to_identifier(stored_value, quoted=True))
2746                )
2747                modified = True
2748            else:
2749                new_exprs.append(e)
2750
2751        return new_exprs if modified else None
2752
2753    def pivot_sql(self, expression: exp.Pivot) -> str:
2754        expressions = self.expressions(expression, flat=True)
2755        direction = "UNPIVOT" if expression.unpivot else "PIVOT"
2756
2757        group = self.sql(expression, "group")
2758
2759        if expression.this:
2760            this = self.sql(expression, "this")
2761            if not expressions:
2762                sql = f"UNPIVOT {this}"
2763            else:
2764                on = f"{self.seg('ON')} {expressions}"
2765                into = self.sql(expression, "into")
2766                into = f"{self.seg('INTO')} {into}" if into else ""
2767                using = self.expressions(expression, key="using", flat=True)
2768                using = f"{self.seg('USING')} {using}" if using else ""
2769                sql = f"{direction} {this}{on}{into}{using}{group}"
2770            return self.prepend_ctes(expression, sql)
2771
2772        if not expression.unpivot:
2773            # Wrap IN-list values with explicit aliases where the target dialect would differ
2774            new_field_exprs = self._pivot_in_value_aliases(expression)
2775            if new_field_exprs is not None:
2776                expression.fields[0].set("expressions", new_field_exprs)
2777
2778        alias = self.sql(expression, "alias")
2779        if alias:
2780            alias = f" AS {alias}" if self.PIVOT_ALIAS_WITH_AS else f" {alias}"
2781
2782        fields = self.expressions(
2783            expression,
2784            "fields",
2785            sep=" ",
2786            dynamic=True,
2787            new_line=True,
2788            skip_first=True,
2789            skip_last=True,
2790        )
2791
2792        include_nulls = expression.args.get("include_nulls")
2793        if include_nulls is not None:
2794            nulls = " INCLUDE NULLS " if include_nulls else " EXCLUDE NULLS "
2795        else:
2796            nulls = ""
2797
2798        default_on_null = self.sql(expression, "default_on_null")
2799        default_on_null = f" DEFAULT ON NULL ({default_on_null})" if default_on_null else ""
2800        sql = f"{self.seg(direction)}{nulls}({expressions} FOR {fields}{default_on_null}{group}){alias}"
2801        return self.prepend_ctes(expression, sql)
2802
2803    def version_sql(self, expression: exp.Version) -> str:
2804        this = f"FOR {expression.name}"
2805        kind = expression.text("kind")
2806        expr = self.sql(expression, "expression")
2807        return f"{this} {kind} {expr}"
2808
2809    def tuple_sql(self, expression: exp.Tuple) -> str:
2810        return f"({self.expressions(expression, dynamic=True, new_line=True, skip_first=True, skip_last=True)})"
2811
2812    def _update_from_joins_sql(self, expression: exp.Update) -> tuple[str, str]:
2813        """
2814        Returns (join_sql, from_sql) for UPDATE statements.
2815        - join_sql: placed after UPDATE table, before SET
2816        - from_sql: placed after SET clause (standard position)
2817        Dialects like MySQL need to convert FROM to JOIN syntax.
2818        """
2819        if self.UPDATE_STATEMENT_SUPPORTS_FROM or not (from_expr := expression.args.get("from_")):
2820            return ("", self.sql(expression, "from_"))
2821
2822        # Qualify unqualified columns in SET clause with the target table
2823        # MySQL requires qualified column names in multi-table UPDATE to avoid ambiguity
2824        target_table = expression.this
2825        if isinstance(target_table, exp.Table):
2826            target_name = exp.to_identifier(target_table.alias_or_name)
2827            for eq in expression.expressions:
2828                col = eq.this
2829                if isinstance(col, exp.Column) and not col.table:
2830                    col.set("table", target_name)
2831
2832        table = from_expr.this
2833        if nested_joins := table.args.get("joins", []):
2834            table.set("joins", None)
2835
2836        join_sql = self.sql(exp.Join(this=table, on=exp.true()))
2837        for nested in nested_joins:
2838            if not nested.args.get("on") and not nested.args.get("using"):
2839                nested.set("on", exp.true())
2840            join_sql += self.sql(nested)
2841
2842        return (join_sql, "")
2843
2844    def update_sql(self, expression: exp.Update) -> str:
2845        hint = self.sql(expression, "hint")
2846        this = self.sql(expression, "this")
2847        join_sql, from_sql = self._update_from_joins_sql(expression)
2848        set_sql = self.expressions(expression, flat=True)
2849        where_sql = self.sql(expression, "where")
2850        returning = self.sql(expression, "returning")
2851        order = self.sql(expression, "order")
2852        limit = self.sql(expression, "limit")
2853        if self.RETURNING_END:
2854            expression_sql = f"{from_sql}{where_sql}{returning}"
2855        else:
2856            expression_sql = f"{returning}{from_sql}{where_sql}"
2857        options = self.expressions(expression, key="options")
2858        options = f" OPTION({options})" if options else ""
2859        sql = f"UPDATE{hint} {this}{join_sql} SET {set_sql}{expression_sql}{order}{limit}{options}"
2860        return self.prepend_ctes(expression, sql)
2861
2862    def values_sql(self, expression: exp.Values, values_as_table: bool = True) -> str:
2863        values_as_table = values_as_table and self.VALUES_AS_TABLE
2864
2865        # The VALUES clause is still valid in an `INSERT INTO ..` statement, for example
2866        if values_as_table or not expression.find_ancestor(exp.From, exp.Join):
2867            args = self.expressions(expression)
2868            alias = self.sql(expression, "alias")
2869            values = f"VALUES{self.seg('')}{args}"
2870            values = (
2871                f"({values})"
2872                if self.WRAP_DERIVED_VALUES
2873                and (alias or isinstance(expression.parent, (exp.From, exp.Table)))
2874                else values
2875            )
2876            values = self.query_modifiers(expression, values)
2877            pivots = self.expressions(expression, key="pivots", sep="", flat=True)
2878            return f"{values} AS {alias}{pivots}" if alias else f"{values}{pivots}"
2879
2880        # Converts `VALUES...` expression into a series of select unions.
2881        alias_node = expression.args.get("alias")
2882        column_names = alias_node and alias_node.columns
2883
2884        selects: list[exp.Query] = []
2885
2886        for i, tup in enumerate(expression.expressions):
2887            row = tup.expressions
2888
2889            if i == 0 and column_names:
2890                row = [
2891                    exp.alias_(value, column_name) for value, column_name in zip(row, column_names)
2892                ]
2893
2894            selects.append(exp.Select(expressions=row))
2895
2896        if self.pretty:
2897            # This may result in poor performance for large-cardinality `VALUES` tables, due to
2898            # the deep nesting of the resulting exp.Unions. If this is a problem, either increase
2899            # `sys.setrecursionlimit` to avoid RecursionErrors, or don't set `pretty`.
2900            query = reduce(lambda x, y: exp.union(x, y, distinct=False, copy=False), selects)
2901            for key in ("order", "limit", "offset"):
2902                if value := expression.args.get(key):
2903                    query.set(key, value.pop())
2904            subquery = query.subquery(alias_node and alias_node.this, copy=False)
2905            subquery.set("pivots", expression.args.pop("pivots", None))
2906            return self.subquery_sql(subquery)
2907
2908        alias = f" AS {self.sql(alias_node, 'this')}" if alias_node else ""
2909        unions = " UNION ALL ".join(self.sql(select) for select in selects)
2910        pivots = self.expressions(expression, key="pivots", sep="", flat=True)
2911        return f"({self.query_modifiers(expression, unions)}){alias}{pivots}"
2912
2913    def var_sql(self, expression: exp.Var) -> str:
2914        return self.sql(expression, "this")
2915
2916    @unsupported_args("expressions")
2917    def into_sql(self, expression: exp.Into) -> str:
2918        temporary = " TEMPORARY" if expression.args.get("temporary") else ""
2919        unlogged = " UNLOGGED" if expression.args.get("unlogged") else ""
2920        return f"{self.seg('INTO')}{temporary or unlogged} {self.sql(expression, 'this')}"
2921
2922    def from_sql(self, expression: exp.From) -> str:
2923        return f"{self.seg('FROM')} {self.sql(expression, 'this')}"
2924
2925    def groupingsets_sql(self, expression: exp.GroupingSets) -> str:
2926        grouping_sets = self.expressions(expression, indent=False)
2927        return f"GROUPING SETS {self.wrap(grouping_sets)}"
2928
2929    def rollup_sql(self, expression: exp.Rollup) -> str:
2930        expressions = self.expressions(expression, indent=False)
2931        return f"ROLLUP {self.wrap(expressions)}" if expressions else "WITH ROLLUP"
2932
2933    def rollupindex_sql(self, expression: exp.RollupIndex) -> str:
2934        this = self.sql(expression, "this")
2935
2936        columns = self.expressions(expression, flat=True)
2937
2938        from_sql = self.sql(expression, "from_index")
2939        from_sql = f" FROM {from_sql}" if from_sql else ""
2940
2941        properties = expression.args.get("properties")
2942        properties_sql = (
2943            f" {self.properties(properties, prefix='PROPERTIES')}" if properties else ""
2944        )
2945
2946        return f"{this}({columns}){from_sql}{properties_sql}"
2947
2948    def rollupproperty_sql(self, expression: exp.RollupProperty) -> str:
2949        return f"ROLLUP ({self.expressions(expression, flat=True)})"
2950
2951    def cube_sql(self, expression: exp.Cube) -> str:
2952        expressions = self.expressions(expression, indent=False)
2953        return f"CUBE {self.wrap(expressions)}" if expressions else "WITH CUBE"
2954
2955    def group_sql(self, expression: exp.Group) -> str:
2956        group_by_all = expression.args.get("all")
2957        if group_by_all is True:
2958            modifier = " ALL"
2959        elif group_by_all is False:
2960            modifier = " DISTINCT"
2961        else:
2962            modifier = ""
2963
2964        group_by = self.op_expressions(f"GROUP BY{modifier}", expression)
2965
2966        grouping_sets = self.expressions(expression, key="grouping_sets")
2967        cube = self.expressions(expression, key="cube")
2968        rollup = self.expressions(expression, key="rollup")
2969
2970        groupings = csv(
2971            self.seg(grouping_sets) if grouping_sets else "",
2972            self.seg(cube) if cube else "",
2973            self.seg(rollup) if rollup else "",
2974            self.seg("WITH TOTALS") if expression.args.get("totals") else "",
2975            sep=self.GROUPINGS_SEP,
2976        )
2977
2978        if (
2979            expression.expressions
2980            and groupings
2981            and groupings.strip() not in ("WITH CUBE", "WITH ROLLUP")
2982        ):
2983            add_separator = True
2984
2985            if grouping_sets:
2986                if self.SUPPORTS_GROUPING_SETS_AS_SUFFIX:
2987                    add_separator = False
2988                else:
2989                    self.unsupported(
2990                        "GROUPING SETS without a comma after GROUP BY expressions is not supported"
2991                    )
2992
2993            if add_separator:
2994                group_by = f"{group_by}{self.GROUPINGS_SEP}"
2995
2996        return f"{group_by}{groupings}"
2997
2998    def having_sql(self, expression: exp.Having) -> str:
2999        this = self.indent(self.sql(expression, "this"))
3000        return f"{self.seg('HAVING')}{self.sep()}{this}"
3001
3002    def connectto_sql(self, expression: exp.ConnectTo) -> str:
3003        return f"CONNECT {self.sql(expression, 'this')}"
3004
3005    def disconnect_sql(self, expression: exp.Disconnect) -> str:
3006        return "DISCONNECT"
3007
3008    def connect_sql(self, expression: exp.Connect) -> str:
3009        start = self.sql(expression, "start")
3010        start = self.seg(f"START WITH {start}") if start else ""
3011        nocycle = " NOCYCLE" if expression.args.get("nocycle") else ""
3012        connect = self.sql(expression, "connect")
3013        connect = self.seg(f"CONNECT BY{nocycle} {connect}")
3014        return start + connect
3015
3016    def prior_sql(self, expression: exp.Prior) -> str:
3017        return f"PRIOR {self.sql(expression, 'this')}"
3018
3019    def join_sql(self, expression: exp.Join, join_op: str | None = None) -> str:
3020        if not self.SEMI_ANTI_JOIN_WITH_SIDE and expression.kind in ("SEMI", "ANTI"):
3021            side = None
3022        else:
3023            side = expression.side
3024
3025        op_sql = " ".join(
3026            op
3027            for op in (
3028                expression.method,
3029                "GLOBAL" if expression.args.get("global_") else None,
3030                side,
3031                expression.kind,
3032                expression.hint if self.JOIN_HINTS else None,
3033                "DIRECTED" if expression.args.get("directed") and self.DIRECTED_JOINS else None,
3034            )
3035            if op
3036        )
3037        match_cond = self.sql(expression, "match_condition")
3038        match_cond = f" MATCH_CONDITION ({match_cond})" if match_cond else ""
3039        nearest = self.sql(expression, "nearest")
3040        nearest = f" {nearest}" if nearest else ""
3041        on_sql = self.sql(expression, "on")
3042        using = expression.args.get("using")
3043
3044        if not on_sql and using:
3045            on_sql = csv(*(self.sql(column) for column in using))
3046
3047        this = expression.this
3048        this_sql = self.sql(this)
3049
3050        exprs = self.expressions(expression)
3051        if exprs:
3052            this_sql = f"{this_sql},{self.seg(exprs)}"
3053
3054        if on_sql:
3055            on_sql = self.indent(on_sql, skip_first=True)
3056            space = self.seg(" " * self.pad) if self.pretty else " "
3057            if using:
3058                on_sql = f"{space}USING ({on_sql})"
3059            else:
3060                on_sql = f"{space}ON {on_sql}"
3061        elif not op_sql and not nearest:
3062            if isinstance(this, exp.Lateral) and this.args.get("cross_apply") is not None:
3063                return f" {this_sql}"
3064
3065            return f", {this_sql}"
3066
3067        if join_op:
3068            op_sql = join_op
3069        elif op_sql != "STRAIGHT_JOIN":
3070            op_sql = f"{op_sql} JOIN" if op_sql else "JOIN"
3071
3072        pivots = self.expressions(expression, key="pivots", sep="", flat=True)
3073        return f"{self.seg(op_sql)} {this_sql}{match_cond}{nearest}{on_sql}{pivots}"
3074
3075    def nearest_sql(self, expression: exp.Nearest) -> str:
3076        if not self.SUPPORTS_NEAREST_JOIN:
3077            self.unsupported("NEAREST joins are not supported")
3078
3079        approximate = "APPROX " if expression.args.get("approximate") else ""
3080        metric = "SIMILARITY" if expression.args.get("similarity") else "DISTANCE"
3081        return f"{approximate}NEAREST {self.sql(expression, 'count')} BY {metric} {self.sql(expression, 'this')}"
3082
3083    def lambda_sql(self, expression: exp.Lambda, arrow_sep: str = "->", wrap: bool = True) -> str:
3084        args = self.expressions(expression, flat=True)
3085        args = f"({args})" if wrap and len(args.split(",")) > 1 else args
3086        return f"{args} {arrow_sep} {self.sql(expression, 'this')}"
3087
3088    def lateral_op(self, expression: exp.Lateral) -> str:
3089        cross_apply = expression.args.get("cross_apply")
3090
3091        # https://www.mssqltips.com/sqlservertip/1958/sql-server-cross-apply-and-outer-apply/
3092        if cross_apply is True:
3093            op = "INNER JOIN "
3094        elif cross_apply is False:
3095            op = "LEFT JOIN "
3096        else:
3097            op = ""
3098
3099        return f"{op}LATERAL"
3100
3101    def lateral_sql(self, expression: exp.Lateral) -> str:
3102        this = self.sql(expression, "this")
3103
3104        if expression.args.get("view"):
3105            alias = expression.args["alias"]
3106            columns = self.expressions(alias, key="columns", flat=True)
3107            table = f" {alias.name}" if alias.name else ""
3108            columns = f" AS {columns}" if columns else ""
3109            op_sql = self.seg(f"LATERAL VIEW{' OUTER' if expression.args.get('outer') else ''}")
3110            return f"{op_sql}{self.sep()}{this}{table}{columns}"
3111
3112        table_alias = expression.args.get("alias")
3113        offset = expression.this.args.get("offset")
3114
3115        if (
3116            self.UNNEST_WITH_ORDINALITY
3117            and table_alias
3118            and isinstance(expression.this, exp.Unnest)
3119            and isinstance(offset, exp.Identifier)
3120        ):
3121            # UNNEST ... WITH ORDINALITY stores the ordinality column's name in Unnest.offset
3122            table_alias = table_alias.copy()
3123            table_alias.append("columns", offset.copy())
3124
3125        alias = self.sql(table_alias)
3126        alias = f" AS {alias}" if alias else ""
3127
3128        ordinality = expression.args.get("ordinality") or ""
3129        if ordinality:
3130            ordinality = f" WITH ORDINALITY{alias}"
3131            alias = ""
3132
3133        return f"{self.lateral_op(expression)} {this}{alias}{ordinality}"
3134
3135    def limit_sql(self, expression: exp.Limit, top: bool = False) -> str:
3136        this = self.sql(expression, "this")
3137
3138        if expression.is_limit_all and not self.dialect.SUPPORTS_LIMIT_ALL:
3139            return this
3140
3141        args = [
3142            self._simplify_unless_literal(e) if self.LIMIT_ONLY_LITERALS else e
3143            for e in (expression.args.get(k) for k in ("offset", "expression"))
3144            if e
3145        ]
3146
3147        args_sql = ", ".join(self.sql(e) for e in args)
3148        args_sql = f"({args_sql})" if top and any(not e.is_number for e in args) else args_sql
3149        expressions = self.expressions(expression, flat=True)
3150        limit_options = self.sql(expression, "limit_options")
3151        expressions = f" BY {expressions}" if expressions else ""
3152
3153        return f"{this}{self.seg('TOP' if top else 'LIMIT')} {args_sql}{limit_options}{expressions}"
3154
3155    def offset_sql(self, expression: exp.Offset) -> str:
3156        this = self.sql(expression, "this")
3157        value = expression.expression
3158        value = self._simplify_unless_literal(value) if self.LIMIT_ONLY_LITERALS else value
3159        expressions = self.expressions(expression, flat=True)
3160        expressions = f" BY {expressions}" if expressions else ""
3161        return f"{this}{self.seg('OFFSET')} {self.sql(value)}{expressions}"
3162
3163    def setitem_sql(self, expression: exp.SetItem) -> str:
3164        kind = self.sql(expression, "kind")
3165        if not self.SET_ASSIGNMENT_REQUIRES_VARIABLE_KEYWORD and kind == "VARIABLE":
3166            kind = ""
3167        else:
3168            kind = f"{kind} " if kind else ""
3169        this = self.sql(expression, "this")
3170        expressions = self.expressions(expression)
3171        collate = self.sql(expression, "collate")
3172        collate = f" COLLATE {collate}" if collate else ""
3173        global_ = "GLOBAL " if expression.args.get("global_") else ""
3174        return f"{global_}{kind}{this}{expressions}{collate}"
3175
3176    def set_sql(self, expression: exp.Set) -> str:
3177        expressions = f" {self.expressions(expression, flat=True)}"
3178        tag = " TAG" if expression.args.get("tag") else ""
3179        return f"{'UNSET' if expression.args.get('unset') else 'SET'}{tag}{expressions}"
3180
3181    def queryband_sql(self, expression: exp.QueryBand) -> str:
3182        this = self.sql(expression, "this")
3183        update = " UPDATE" if expression.args.get("update") else ""
3184        scope = self.sql(expression, "scope")
3185        scope = f" FOR {scope}" if scope else ""
3186
3187        return f"QUERY_BAND = {this}{update}{scope}"
3188
3189    def pragma_sql(self, expression: exp.Pragma) -> str:
3190        return f"PRAGMA {self.sql(expression, 'this')}"
3191
3192    def lock_sql(self, expression: exp.Lock) -> str:
3193        if not self.LOCKING_READS_SUPPORTED:
3194            self.unsupported("Locking reads using 'FOR UPDATE/SHARE' are not supported")
3195            return ""
3196
3197        update = expression.args["update"]
3198        key = expression.args.get("key")
3199        if update:
3200            lock_type = "FOR NO KEY UPDATE" if key else "FOR UPDATE"
3201        else:
3202            lock_type = "FOR KEY SHARE" if key else "FOR SHARE"
3203        expressions = self.expressions(expression, flat=True)
3204        expressions = f" OF {expressions}" if expressions else ""
3205        wait = expression.args.get("wait")
3206
3207        if wait is not None:
3208            if isinstance(wait, exp.Literal):
3209                wait = f" WAIT {self.sql(wait)}"
3210            else:
3211                wait = " NOWAIT" if wait else " SKIP LOCKED"
3212
3213        return f"{lock_type}{expressions}{wait or ''}"
3214
3215    def literal_sql(self, expression: exp.Literal) -> str:
3216        text = expression.this or ""
3217        if expression.is_string:
3218            text = f"{self.dialect.QUOTE_START}{self.escape_str(text)}{self.dialect.QUOTE_END}"
3219        return text
3220
3221    def escape_str(
3222        self,
3223        text: str,
3224        escape_backslash: bool = True,
3225        delimiter: str | None = None,
3226        escaped_delimiter: str | None = None,
3227        is_byte_string: bool = False,
3228        is_bytes: bool = False,
3229    ) -> str:
3230        if is_byte_string:
3231            supports_escape_sequences = self.dialect.BYTE_STRINGS_SUPPORT_ESCAPED_SEQUENCES
3232        else:
3233            supports_escape_sequences = self.dialect.STRINGS_SUPPORT_ESCAPED_SEQUENCES
3234
3235        if supports_escape_sequences:
3236            text = "".join(
3237                self.dialect.ESCAPED_SEQUENCES.get(ch, ch) if escape_backslash or ch != "\\" else ch
3238                for ch in text
3239            )
3240
3241            if is_bytes and "x" in self.dialect.tokenizer_class.NUMERIC_ESCAPES:
3242                # Escape high bytes so they aren't re-encoded as UTF-8 characters.
3243                text = _HIGH_BYTE_RE.sub(lambda m: f"\\x{ord(m.group()):02x}", text)
3244
3245        delimiter = delimiter or self.dialect.QUOTE_END
3246        escaped_delimiter = escaped_delimiter or self._escaped_quote_end
3247
3248        return self._replace_line_breaks(text).replace(delimiter, escaped_delimiter)
3249
3250    def loaddata_sql(self, expression: exp.LoadData) -> str:
3251        is_overwrite = expression.args.get("overwrite")
3252        overwrite = " OVERWRITE" if is_overwrite else ""
3253        this = self.sql(expression, "this")
3254
3255        files = expression.args.get("files")
3256        if files:
3257            files_sql = self.expressions(files, flat=True)
3258            files_sql = f"FILES{self.wrap(files_sql)}"
3259            if is_overwrite:
3260                this = f" {this}"
3261            elif expression.args.get("temp"):
3262                this = f" INTO TEMP TABLE {this}"
3263            else:
3264                this = f" INTO TABLE {this}"
3265            return f"LOAD DATA{overwrite}{this} FROM {files_sql}"
3266
3267        local = " LOCAL" if expression.args.get("local") else ""
3268        inpath = f" INPATH {self.sql(expression, 'inpath')}"
3269        this = f" INTO TABLE {this}"
3270        partition = self.sql(expression, "partition")
3271        partition = f" {partition}" if partition else ""
3272        input_format = self.sql(expression, "input_format")
3273        input_format = f" INPUTFORMAT {input_format}" if input_format else ""
3274        serde = self.sql(expression, "serde")
3275        serde = f" SERDE {serde}" if serde else ""
3276        return f"LOAD DATA{local}{inpath}{overwrite}{this}{partition}{input_format}{serde}"
3277
3278    def null_sql(self, *_) -> str:
3279        return "NULL"
3280
3281    def boolean_sql(self, expression: exp.Boolean) -> str:
3282        return "TRUE" if expression.this else "FALSE"
3283
3284    def booland_sql(self, expression: exp.Booland) -> str:
3285        return f"(({self.sql(expression, 'this')}) AND ({self.sql(expression, 'expression')}))"
3286
3287    def boolor_sql(self, expression: exp.Boolor) -> str:
3288        return f"(({self.sql(expression, 'this')}) OR ({self.sql(expression, 'expression')}))"
3289
3290    def order_sql(self, expression: exp.Order, flat: bool = False) -> str:
3291        this = self.sql(expression, "this")
3292        this = f"{this} " if this else this
3293        siblings = "SIBLINGS " if expression.args.get("siblings") else ""
3294        return self.op_expressions(f"{this}ORDER {siblings}BY", expression, flat=bool(this) or flat)
3295
3296    def withfill_sql(self, expression: exp.WithFill) -> str:
3297        from_sql = self.sql(expression, "from_")
3298        from_sql = f" FROM {from_sql}" if from_sql else ""
3299        to_sql = self.sql(expression, "to")
3300        to_sql = f" TO {to_sql}" if to_sql else ""
3301        step_sql = self.sql(expression, "step")
3302        step_sql = f" STEP {step_sql}" if step_sql else ""
3303        interpolated_values = [
3304            f"{self.sql(e, 'alias')} AS {self.sql(e, 'this')}"
3305            if isinstance(e, exp.Alias)
3306            else self.sql(e, "this")
3307            for e in expression.args.get("interpolate") or []
3308        ]
3309        interpolate = (
3310            f" INTERPOLATE ({', '.join(interpolated_values)})" if interpolated_values else ""
3311        )
3312        return f"WITH FILL{from_sql}{to_sql}{step_sql}{interpolate}"
3313
3314    def cluster_sql(self, expression: exp.Cluster) -> str:
3315        return self.op_expressions("CLUSTER BY", expression)
3316
3317    def clusterproperty_sql(self, expression: exp.ClusterProperty) -> str:
3318        if expression.this:
3319            self.unsupported(f"Unsupported CLUSTER BY {self.sql(expression, 'this')}")
3320            return ""
3321        expressions = self.expressions(expression, flat=True)
3322        return f"CLUSTER BY ({expressions})"
3323
3324    def distribute_sql(self, expression: exp.Distribute) -> str:
3325        return self.op_expressions("DISTRIBUTE BY", expression)
3326
3327    def sort_sql(self, expression: exp.Sort) -> str:
3328        return self.op_expressions("SORT BY", expression)
3329
3330    def _resolve_ordered_for_null_ordering_simulation(
3331        self, expression: exp.Ordered
3332    ) -> exp.Expr | None:
3333        """Resolve a bare ORDER BY name against the enclosing SELECT projection.
3334
3335        Returns the underlying expression of the uniquely-matching projection
3336        (Alias-stripped) for substitution into the NULLS FIRST/LAST CASE
3337        simulation, since the CASE is evaluated in FROM-clause scope rather
3338        than alias scope (MySQL error 1052). Returns None if no safe
3339        substitution applies, leaving the original behaviour unchanged.
3340        """
3341        this = expression.this
3342        if not (isinstance(this, exp.Column) and not this.table):
3343            return None
3344
3345        # Only a query's own ORDER BY can reference its projection aliases
3346        order = expression.parent
3347        ancestor = order.parent if isinstance(order, exp.Order) else None
3348        if not isinstance(ancestor, exp.Select):
3349            return None
3350
3351        column_name = this.name
3352        matched: list[exp.Expr] = [
3353            p.this if isinstance(p, exp.Alias) else p
3354            for p in ancestor.selects
3355            if p.output_name == column_name
3356        ]
3357        match = matched[0] if len(matched) == 1 else None
3358
3359        # Skip the substitution when it would be identical to the existing
3360        # reference (e.g. ``SELECT col FROM t ORDER BY col``).
3361        if isinstance(match, exp.Column) and not match.table and match.name == column_name:
3362            return None
3363
3364        return match
3365
3366    def ordered_sql(self, expression: exp.Ordered) -> str:
3367        desc = expression.args.get("desc")
3368        asc = not desc
3369
3370        nulls_first = expression.args.get("nulls_first")
3371        nulls_last = not nulls_first
3372        nulls_are_large = self.dialect.NULL_ORDERING == "nulls_are_large"
3373        nulls_are_small = self.dialect.NULL_ORDERING == "nulls_are_small"
3374        nulls_are_last = self.dialect.NULL_ORDERING == "nulls_are_last"
3375
3376        this = self.sql(expression, "this")
3377
3378        sort_order = " DESC" if desc else (" ASC" if desc is False else "")
3379        nulls_sort_change = ""
3380        if nulls_first and (
3381            (asc and nulls_are_large) or (desc and nulls_are_small) or nulls_are_last
3382        ):
3383            nulls_sort_change = " NULLS FIRST"
3384        elif (
3385            nulls_last
3386            and ((asc and nulls_are_small) or (desc and nulls_are_large))
3387            and not nulls_are_last
3388        ):
3389            nulls_sort_change = " NULLS LAST"
3390
3391        # If the NULLS FIRST/LAST clause is unsupported, we add another sort key to simulate it
3392        if nulls_sort_change and not self.NULL_ORDERING_SUPPORTED:
3393            window = expression.find_ancestor(exp.Window, exp.Select)
3394
3395            if isinstance(window, exp.Window):
3396                window_this = window.this
3397                if isinstance(window_this, (exp.IgnoreNulls, exp.RespectNulls)):
3398                    window_this = window_this.this
3399                spec = window.args.get("spec")
3400            else:
3401                window_this = None
3402                spec = None
3403
3404            # Some window functions (e.g. LAST_VALUE, RANK) support NULLS FIRST/LAST
3405            # without a spec or with a ROWS spec, but not with RANGE
3406            if not (
3407                isinstance(window_this, self.WINDOW_FUNCS_WITH_NULL_ORDERING)
3408                and (not spec or spec.text("kind").upper() == "ROWS")
3409            ):
3410                if window_this and spec:
3411                    self.unsupported(
3412                        f"'{nulls_sort_change.strip()}' translation not supported in window function {window_this.sql_name()}"
3413                    )
3414                    nulls_sort_change = ""
3415                elif self.NULL_ORDERING_SUPPORTED is False and (
3416                    (asc and nulls_sort_change == " NULLS LAST")
3417                    or (desc and nulls_sort_change == " NULLS FIRST")
3418                ):
3419                    # BigQuery does not allow these ordering/nulls combinations when used under
3420                    # an aggregation func or under a window containing one
3421                    ancestor = expression.find_ancestor(exp.AggFunc, exp.Window, exp.Select)
3422
3423                    if isinstance(ancestor, exp.Window):
3424                        ancestor = ancestor.this
3425                    if isinstance(ancestor, exp.AggFunc):
3426                        self.unsupported(
3427                            f"'{nulls_sort_change.strip()}' translation not supported for aggregate function {ancestor.sql_name()} with {sort_order} sort order"
3428                        )
3429                        nulls_sort_change = ""
3430                elif self.NULL_ORDERING_SUPPORTED is None:
3431                    if expression.this.is_int:
3432                        self.unsupported(
3433                            f"'{nulls_sort_change.strip()}' translation not supported with positional ordering"
3434                        )
3435                    elif not isinstance(expression.this, exp.Rand):
3436                        resolved = self._resolve_ordered_for_null_ordering_simulation(expression)
3437                        target = self.sql(resolved) if resolved is not None else this
3438                        null_sort_order = " DESC" if nulls_sort_change == " NULLS FIRST" else ""
3439                        this = f"CASE WHEN {target} IS NULL THEN 1 ELSE 0 END{null_sort_order}, {target}"
3440                    nulls_sort_change = ""
3441
3442        with_fill = self.sql(expression, "with_fill")
3443        with_fill = f" {with_fill}" if with_fill else ""
3444
3445        return f"{this}{sort_order}{nulls_sort_change}{with_fill}"
3446
3447    def matchrecognizemeasure_sql(self, expression: exp.MatchRecognizeMeasure) -> str:
3448        window_frame = self.sql(expression, "window_frame")
3449        window_frame = f"{window_frame} " if window_frame else ""
3450
3451        this = self.sql(expression, "this")
3452
3453        return f"{window_frame}{this}"
3454
3455    def matchrecognize_sql(self, expression: exp.MatchRecognize) -> str:
3456        partition = self.partition_by_sql(expression)
3457        order = self.sql(expression, "order")
3458        measures = self.expressions(expression, key="measures")
3459        measures = self.seg(f"MEASURES{self.seg(measures)}") if measures else ""
3460        rows = self.sql(expression, "rows")
3461        rows = self.seg(rows) if rows else ""
3462        after = self.sql(expression, "after")
3463        after = self.seg(after) if after else ""
3464        pattern = self.sql(expression, "pattern")
3465        pattern = self.seg(f"PATTERN ({pattern})") if pattern else ""
3466        definition_sqls = [
3467            f"{self.sql(definition, 'alias')} AS {self.sql(definition, 'this')}"
3468            for definition in expression.args.get("define", [])
3469        ]
3470        definitions = self.expressions(sqls=definition_sqls)
3471        define = self.seg(f"DEFINE{self.seg(definitions)}") if definitions else ""
3472        body = "".join(
3473            (
3474                partition,
3475                order,
3476                measures,
3477                rows,
3478                after,
3479                pattern,
3480                define,
3481            )
3482        )
3483        alias = self.sql(expression, "alias")
3484        alias = f" {alias}" if alias else ""
3485        return f"{self.seg('MATCH_RECOGNIZE')} {self.wrap(body)}{alias}"
3486
3487    def query_modifiers(self, expression: exp.Expr, *sqls: str) -> str:
3488        limit = expression.args.get("limit")
3489
3490        if self.LIMIT_FETCH == "LIMIT" and isinstance(limit, exp.Fetch):
3491            count = limit.args.get("count")
3492            # "FETCH FIRST ROWS ONLY" without a count means one row per the SQL
3493            # standard; emitting a bare "LIMIT" here would produce invalid SQL.
3494            limit = exp.Limit(
3495                expression=exp.maybe_copy(count) if count is not None else exp.Literal.number(1)
3496            )
3497        elif (
3498            self.LIMIT_FETCH == "FETCH" and isinstance(limit, exp.Limit) and not limit.is_limit_all
3499        ):
3500            limit = exp.Fetch(direction="FIRST", count=exp.maybe_copy(limit.expression))
3501
3502        return csv(
3503            *sqls,
3504            *[self.sql(join) for join in expression.args.get("joins") or []],
3505            self.sql(expression, "match"),
3506            *[self.sql(lateral) for lateral in expression.args.get("laterals") or []],
3507            self.sql(expression, "prewhere"),
3508            self.sql(expression, "where"),
3509            self.sql(expression, "connect"),
3510            self.sql(expression, "group"),
3511            self.sql(expression, "having"),
3512            *[gen(self, expression) for gen in self.AFTER_HAVING_MODIFIER_TRANSFORMS.values()],
3513            self.sql(expression, "order"),
3514            *self.offset_limit_modifiers(expression, isinstance(limit, exp.Fetch), limit),
3515            *self.after_limit_modifiers(expression),
3516            self.sql(expression, "for_"),
3517            self.options_modifier(expression),
3518            sep="",
3519        )
3520
3521    def options_modifier(self, expression: exp.Expr) -> str:
3522        options = self.expressions(expression, key="options")
3523        return f" {options}" if options else ""
3524
3525    def forclause_sql(self, expression: exp.ForClause) -> str:
3526        kind = expression.args["kind"]
3527        if kind == "BROWSE":
3528            return f"{self.sep()}FOR BROWSE"
3529        # FOR XML/JSON always carry at least AUTO/PATH. An empty rendering means
3530        # the target dialect doesn't support QueryOption, so we drop the clause.
3531        options = self.expressions(expression, key="expressions")
3532        if not options:
3533            return ""
3534        return f"{self.sep()}FOR {kind}{self.seg(options)}"
3535
3536    def queryoption_sql(self, expression: exp.QueryOption) -> str:
3537        self.unsupported("Unsupported query option.")
3538        return ""
3539
3540    def offset_limit_modifiers(
3541        self, expression: exp.Expr, fetch: bool, limit: exp.Fetch | exp.Limit | None
3542    ) -> list[str]:
3543        return [
3544            self.sql(expression, "offset") if fetch else self.sql(limit),
3545            self.sql(limit) if fetch else self.sql(expression, "offset"),
3546        ]
3547
3548    def after_limit_modifiers(self, expression: exp.Expr) -> list[str]:
3549        locks = self.expressions(expression, key="locks", sep=" ")
3550        locks = f" {locks}" if locks else ""
3551        return [locks, self.sql(expression, "sample")]
3552
3553    def select_sql(self, expression: exp.Select) -> str:
3554        into = expression.args.get("into")
3555        if not self.SUPPORTS_SELECT_INTO and into:
3556            into.pop()
3557
3558        hint = self.sql(expression, "hint")
3559        distinct = self.sql(expression, "distinct")
3560        distinct = f" {distinct}" if distinct else ""
3561        kind = self.sql(expression, "kind")
3562
3563        limit = expression.args.get("limit")
3564        if isinstance(limit, exp.Limit) and self.LIMIT_IS_TOP:
3565            top = self.limit_sql(limit, top=True)
3566            limit.pop()
3567        else:
3568            top = ""
3569
3570        expressions = self.expressions(expression)
3571
3572        if kind:
3573            if kind in self.SELECT_KINDS:
3574                kind = f" AS {kind}"
3575            else:
3576                if kind == "STRUCT":
3577                    expressions = self.expressions(
3578                        sqls=[
3579                            self.sql(
3580                                exp.Struct(
3581                                    expressions=[
3582                                        exp.PropertyEQ(this=e.args.get("alias"), expression=e.this)
3583                                        if isinstance(e, exp.Alias)
3584                                        else e
3585                                        for e in expression.expressions
3586                                    ]
3587                                )
3588                            )
3589                        ]
3590                    )
3591                kind = ""
3592
3593        operation_modifiers = self.expressions(expression, key="operation_modifiers", sep=" ")
3594        operation_modifiers = f"{self.sep()}{operation_modifiers}" if operation_modifiers else ""
3595
3596        exclude = expression.args.get("exclude")
3597
3598        if not self.STAR_EXCLUDE_REQUIRES_DERIVED_TABLE and exclude:
3599            exclude_sql = self.expressions(sqls=exclude, flat=True)
3600            expressions = f"{expressions}{self.seg('EXCLUDE')} ({exclude_sql})"
3601
3602        # We use LIMIT_IS_TOP as a proxy for whether DISTINCT should go first because tsql and Teradata
3603        # are the only dialects that use LIMIT_IS_TOP and both place DISTINCT first.
3604        top_distinct = f"{distinct}{hint}{top}" if self.LIMIT_IS_TOP else f"{top}{hint}{distinct}"
3605        expressions = f"{self.sep()}{expressions}" if expressions else expressions
3606        sql = self.query_modifiers(
3607            expression,
3608            f"SELECT{top_distinct}{operation_modifiers}{kind}{expressions}",
3609            self.sql(expression, "into", comment=False),
3610            self.sql(expression, "from_", comment=False),
3611        )
3612
3613        # If both the CTE and SELECT clauses have comments, generate the latter earlier
3614        if expression.args.get("with_"):
3615            sql = self.maybe_comment(sql, expression)
3616            expression.pop_comments()
3617
3618        sql = self.prepend_ctes(expression, sql)
3619
3620        if self.STAR_EXCLUDE_REQUIRES_DERIVED_TABLE and exclude:
3621            expression.set("exclude", None)
3622            subquery = expression.subquery(copy=False)
3623            star = exp.Star(except_=exclude)
3624            sql = self.sql(exp.select(star).from_(subquery, copy=False))
3625
3626        if not self.SUPPORTS_SELECT_INTO and into:
3627            if into.args.get("temporary"):
3628                table_kind = " TEMPORARY"
3629            elif self.SUPPORTS_UNLOGGED_TABLES and into.args.get("unlogged"):
3630                table_kind = " UNLOGGED"
3631            else:
3632                table_kind = ""
3633            sql = f"CREATE{table_kind} TABLE {self.sql(into.this)} AS {sql}"
3634
3635        return sql
3636
3637    def schema_sql(self, expression: exp.Schema) -> str:
3638        this = self.sql(expression, "this")
3639        sql = self.schema_columns_sql(expression)
3640        return f"{this} {sql}" if this and sql else this or sql
3641
3642    def schema_columns_sql(self, expression: exp.Expr) -> str:
3643        if expression.expressions:
3644            return f"({self.sep('')}{self.expressions(expression)}{self.seg(')', sep='')}"
3645        return ""
3646
3647    def star_sql(self, expression: exp.Star) -> str:
3648        except_ = self.expressions(expression, key="except_", flat=True)
3649        except_ = f"{self.seg(self.STAR_EXCEPT)} ({except_})" if except_ else ""
3650        replace = self.expressions(expression, key="replace", flat=True)
3651        replace = f"{self.seg('REPLACE')} ({replace})" if replace else ""
3652        rename = self.expressions(expression, key="rename", flat=True)
3653        rename = f"{self.seg('RENAME')} ({rename})" if rename else ""
3654        ilike = self.sql(expression, "ilike")
3655        ilike = f"{self.seg('ILIKE')} {ilike}" if ilike else ""
3656        return f"*{ilike}{except_}{replace}{rename}"
3657
3658    def parameter_sql(self, expression: exp.Parameter) -> str:
3659        this = self.sql(expression, "this")
3660        return f"{self.PARAMETER_TOKEN}{this}"
3661
3662    def sessionparameter_sql(self, expression: exp.SessionParameter) -> str:
3663        this = self.sql(expression, "this")
3664        kind = expression.text("kind")
3665        if kind:
3666            kind = f"{kind}."
3667        return f"@@{kind}{this}"
3668
3669    def placeholder_sql(self, expression: exp.Placeholder) -> str:
3670        return f"{self.NAMED_PLACEHOLDER_TOKEN}{expression.name}" if expression.this else "?"
3671
3672    def subquery_sql(self, expression: exp.Subquery, sep: str = " AS ") -> str:
3673        alias = self.sql(expression, "alias")
3674        alias = f"{sep}{alias}" if alias else ""
3675        sample = self.sql(expression, "sample")
3676        if self.dialect.ALIAS_POST_TABLESAMPLE and sample:
3677            alias = f"{sample}{alias}"
3678
3679            # Set to None so it's not generated again by self.query_modifiers()
3680            expression.set("sample", None)
3681
3682        pivots = self.expressions(expression, key="pivots", sep="", flat=True)
3683        sql = self.query_modifiers(expression, self.wrap(expression), alias, pivots)
3684        return self.prepend_ctes(expression, sql)
3685
3686    def qualify_sql(self, expression: exp.Qualify) -> str:
3687        this = self.indent(self.sql(expression, "this"))
3688        return f"{self.seg('QUALIFY')}{self.sep()}{this}"
3689
3690    def unnest_sql(self, expression: exp.Unnest) -> str:
3691        args = self.expressions(expression, flat=True)
3692
3693        alias = expression.args.get("alias")
3694        offset = expression.args.get("offset")
3695
3696        if self.UNNEST_WITH_ORDINALITY:
3697            if alias and isinstance(offset, exp.Expr):
3698                alias.append("columns", offset)
3699                expression.set("offset", None)
3700
3701        if alias and self.dialect.UNNEST_COLUMN_ONLY:
3702            columns = alias.columns
3703            alias = self.sql(columns[0]) if columns else ""
3704        else:
3705            alias = self.sql(alias)
3706
3707        alias = f" AS {alias}" if alias else alias
3708        if self.UNNEST_WITH_ORDINALITY:
3709            suffix = f" WITH ORDINALITY{alias}" if offset else alias
3710        else:
3711            if isinstance(offset, exp.Expr):
3712                suffix = f"{alias} WITH OFFSET AS {self.sql(offset)}"
3713            elif offset:
3714                suffix = f"{alias} WITH OFFSET"
3715            else:
3716                suffix = alias
3717
3718        return f"UNNEST({args}){suffix}"
3719
3720    def prewhere_sql(self, expression: exp.PreWhere) -> str:
3721        return ""
3722
3723    def where_sql(self, expression: exp.Where) -> str:
3724        this = self.indent(self.sql(expression, "this"))
3725        return f"{self.seg('WHERE')}{self.sep()}{this}"
3726
3727    def window_sql(self, expression: exp.Window) -> str:
3728        this = self.sql(expression, "this")
3729        partition = self.partition_by_sql(expression)
3730        order = expression.args.get("order")
3731        order = self.order_sql(order, flat=True) if order else ""
3732        spec = self.sql(expression, "spec")
3733        alias = self.sql(expression, "alias")
3734        over = self.sql(expression, "over") or "OVER"
3735
3736        this = f"{this} {'AS' if expression.arg_key == 'windows' else over}"
3737
3738        first = expression.args.get("first")
3739        if first is None:
3740            first = ""
3741        else:
3742            first = "FIRST" if first else "LAST"
3743
3744        if not partition and not order and not spec and alias:
3745            # WINDOW w2 AS w1 is unparseable in DuckDB/Postgres; parens are required.
3746            if expression.arg_key == "windows":
3747                return f"{this} ({alias})"
3748            return f"{this} {alias}"
3749
3750        args = self.format_args(
3751            *[arg for arg in (alias, first, partition, order, spec) if arg], sep=" "
3752        )
3753        return f"{this} ({args})"
3754
3755    def partition_by_sql(self, expression: exp.Window | exp.MatchRecognize) -> str:
3756        partition = self.expressions(expression, key="partition_by", flat=True)
3757        return f"PARTITION BY {partition}" if partition else ""
3758
3759    def partitionbyexcluding_sql(self, expression: exp.PartitionByExcluding) -> str:
3760        return f"EXCLUDING {self.expressions(expression, flat=True)}"
3761
3762    def windowspec_sql(self, expression: exp.WindowSpec) -> str:
3763        kind = self.sql(expression, "kind")
3764        start = csv(self.sql(expression, "start"), self.sql(expression, "start_side"), sep=" ")
3765        end = (
3766            csv(self.sql(expression, "end"), self.sql(expression, "end_side"), sep=" ")
3767            or "CURRENT ROW"
3768        )
3769
3770        window_spec = f"{kind} BETWEEN {start} AND {end}"
3771
3772        exclude = self.sql(expression, "exclude")
3773        if exclude:
3774            if self.SUPPORTS_WINDOW_EXCLUDE:
3775                window_spec += f" EXCLUDE {exclude}"
3776            else:
3777                self.unsupported("EXCLUDE clause is not supported in the WINDOW clause")
3778
3779        return window_spec
3780
3781    def withingroup_sql(self, expression: exp.WithinGroup) -> str:
3782        this = self.sql(expression, "this")
3783        expression_sql = self.sql(expression, "expression")[1:]  # order has a leading space
3784        return f"{this} WITHIN GROUP ({expression_sql})"
3785
3786    def between_sql(self, expression: exp.Between) -> str:
3787        this = self.sql(expression, "this")
3788        low = self.sql(expression, "low")
3789        high = self.sql(expression, "high")
3790        symmetric = expression.args.get("symmetric")
3791
3792        if symmetric and not self.SUPPORTS_BETWEEN_FLAGS:
3793            return f"({this} BETWEEN {low} AND {high} OR {this} BETWEEN {high} AND {low})"
3794
3795        flag = (
3796            " SYMMETRIC"
3797            if symmetric
3798            else " ASYMMETRIC"
3799            if symmetric is False and self.SUPPORTS_BETWEEN_FLAGS
3800            else ""  # silently drop ASYMMETRIC – semantics identical
3801        )
3802        return f"{this} BETWEEN{flag} {low} AND {high}"
3803
3804    def bracket_offset_expressions(
3805        self, expression: exp.Bracket, index_offset: int | None = None
3806    ) -> list[exp.Expr]:
3807        if expression.args.get("json_access"):
3808            return expression.expressions
3809
3810        return apply_index_offset(
3811            expression.this,
3812            expression.expressions,
3813            (index_offset or self.dialect.INDEX_OFFSET) - expression.args.get("offset", 0),
3814            dialect=self.dialect,
3815        )
3816
3817    def bracket_sql(self, expression: exp.Bracket) -> str:
3818        expressions = self.bracket_offset_expressions(expression)
3819        expressions_sql = ", ".join(self.sql(e) for e in expressions)
3820        return f"{self.sql(expression, 'this')}[{expressions_sql}]"
3821
3822    def all_sql(self, expression: exp.All) -> str:
3823        this = self.sql(expression, "this")
3824        if not isinstance(expression.this, (exp.Tuple, exp.Paren)):
3825            this = self.wrap(this)
3826        return f"ALL {this}"
3827
3828    def any_sql(self, expression: exp.Any) -> str:
3829        this = self.sql(expression, "this")
3830        if isinstance(expression.this, (*exp.UNWRAPPED_QUERIES, exp.Paren)):
3831            if isinstance(expression.this, exp.UNWRAPPED_QUERIES):
3832                this = self.wrap(this)
3833            return f"ANY{this}"
3834        return f"ANY {this}"
3835
3836    def exists_sql(self, expression: exp.Exists) -> str:
3837        return f"EXISTS{self.wrap(expression)}"
3838
3839    def case_sql(self, expression: exp.Case) -> str:
3840        this = self.sql(expression, "this")
3841        statements = [f"CASE {this}" if this else "CASE"]
3842
3843        for e in expression.args["ifs"]:
3844            statements.append(f"WHEN {self.sql(e, 'this')}")
3845            statements.append(f"THEN {self.sql(e, 'true')}")
3846
3847        default = self.sql(expression, "default")
3848
3849        if default:
3850            statements.append(f"ELSE {default}")
3851
3852        statements.append("END")
3853
3854        if self.pretty and self.too_wide(statements):
3855            return self.indent("\n".join(statements), skip_first=True, skip_last=True)
3856
3857        return " ".join(statements)
3858
3859    def constraint_sql(self, expression: exp.Constraint) -> str:
3860        this = self.sql(expression, "this")
3861        expressions = self.expressions(expression, flat=True)
3862        return f"CONSTRAINT {this} {expressions}"
3863
3864    def nextvaluefor_sql(self, expression: exp.NextValueFor) -> str:
3865        order = expression.args.get("order")
3866        order = f" OVER ({self.order_sql(order, flat=True)})" if order else ""
3867        return f"NEXT VALUE FOR {self.sql(expression, 'this')}{order}"
3868
3869    def extract_sql(self, expression: exp.Extract) -> str:
3870        import sqlglot.dialects.dialect
3871
3872        this = (
3873            sqlglot.dialects.dialect.map_date_part(expression.this, self.dialect)
3874            if self.NORMALIZE_EXTRACT_DATE_PARTS
3875            else expression.this
3876        )
3877        if self.EXTRACT_ALLOWS_QUOTES:
3878            this_sql = self.sql(this)
3879        elif isinstance(this, exp.WeekStart):
3880            this_sql = self.weekstart_name(this)
3881        else:
3882            this_sql = this.name
3883        expression_sql = self.sql(expression, "expression")
3884
3885        return f"EXTRACT({this_sql} FROM {expression_sql})"
3886
3887    def trim_sql(self, expression: exp.Trim) -> str:
3888        trim_type = self.sql(expression, "position")
3889
3890        if trim_type == "LEADING":
3891            func_name = "LTRIM"
3892        elif trim_type == "TRAILING":
3893            func_name = "RTRIM"
3894        else:
3895            func_name = "TRIM"
3896
3897        return self.func(func_name, expression.this, expression.expression)
3898
3899    def convert_concat_args(self, expression: exp.Func) -> list[exp.Expr]:
3900        args = expression.expressions
3901        if isinstance(expression, exp.ConcatWs):
3902            args = args[1:]  # Skip the delimiter
3903
3904        if self.dialect.STRICT_STRING_CONCAT and expression.args.get("safe"):
3905            args = [exp.cast(e, exp.DType.TEXT) for e in args]
3906
3907        concat_coalesce = (
3908            self.dialect.CONCAT_WS_COALESCE
3909            if isinstance(expression, exp.ConcatWs)
3910            else self.dialect.CONCAT_COALESCE
3911        )
3912
3913        if not concat_coalesce and expression.args.get("coalesce"):
3914
3915            def _wrap_with_coalesce(e: exp.Expr) -> exp.Expr:
3916                if not e.type:
3917                    import sqlglot.optimizer.annotate_types
3918
3919                    e = sqlglot.optimizer.annotate_types.annotate_types(e, dialect=self.dialect)
3920
3921                if e.is_string or e.is_type(exp.DType.ARRAY):
3922                    return e
3923
3924                return exp.func("coalesce", e, exp.Literal.string(""))
3925
3926            args = [_wrap_with_coalesce(e) for e in args]
3927
3928        return args
3929
3930    def concat_sql(self, expression: exp.Concat) -> str:
3931        if self.dialect.CONCAT_COALESCE and not expression.args.get("coalesce"):
3932            # Dialect's CONCAT function coalesces NULLs to empty strings, but the expression does not.
3933            # Transpile to double pipe operators, which typically returns NULL if any args are NULL
3934            # instead of coalescing them to empty string.
3935            import sqlglot.dialects.dialect
3936
3937            return sqlglot.dialects.dialect.concat_to_dpipe_sql(self, expression)
3938
3939        expressions = self.convert_concat_args(expression)
3940
3941        # Some dialects don't allow a single-argument CONCAT call
3942        if not self.SUPPORTS_SINGLE_ARG_CONCAT and len(expressions) == 1:
3943            return self.sql(expressions[0])
3944
3945        return self.func("CONCAT", *expressions)
3946
3947    def concatws_sql(self, expression: exp.ConcatWs) -> str:
3948        if self.dialect.CONCAT_WS_COALESCE and not expression.args.get("coalesce"):
3949            # Dialect's CONCAT_WS function skips NULL args, but the expression does not.
3950            # Wrap the entire call in a CASE expression that returns NULL if any input IS NULL.
3951            all_args = expression.expressions
3952            expression.set("coalesce", True)
3953            return self.sql(
3954                exp.case()
3955                .when(exp.or_(*(arg.is_(exp.null()) for arg in all_args)), exp.null())
3956                .else_(expression)
3957            )
3958
3959        return self.func(
3960            "CONCAT_WS", seq_get(expression.expressions, 0), *self.convert_concat_args(expression)
3961        )
3962
3963    def check_sql(self, expression: exp.Check) -> str:
3964        this = self.sql(expression, key="this")
3965        return f"CHECK ({this})"
3966
3967    def foreignkey_sql(self, expression: exp.ForeignKey) -> str:
3968        this = self.sql(expression, "this")
3969        this = f" {this}" if this else ""
3970        expressions = self.expressions(expression, flat=True)
3971        expressions = f" ({expressions})" if expressions else ""
3972        reference = self.sql(expression, "reference")
3973        reference = f" {reference}" if reference else ""
3974        delete = self.sql(expression, "delete")
3975        delete = f" ON DELETE {delete}" if delete else ""
3976        update = self.sql(expression, "update")
3977        update = f" ON UPDATE {update}" if update else ""
3978        options = self.expressions(expression, key="options", flat=True, sep=" ")
3979        options = f" {options}" if options else ""
3980        return f"FOREIGN KEY{this}{expressions}{reference}{delete}{update}{options}"
3981
3982    def primarykey_sql(self, expression: exp.PrimaryKey) -> str:
3983        this = self.sql(expression, "this")
3984        this = f" {this}" if this else ""
3985        expressions = self.expressions(expression, flat=True)
3986        include = self.sql(expression, "include")
3987        options = self.expressions(expression, key="options", flat=True, sep=" ")
3988        options = f" {options}" if options else ""
3989        return f"PRIMARY KEY{this} ({expressions}){include}{options}"
3990
3991    def timeserieskey_sql(self, expression: exp.TimeseriesKey) -> str:
3992        self.unsupported("TIMESERIES primary key columns are not supported")
3993        return self.sql(expression, "this")
3994
3995    def if_sql(self, expression: exp.If) -> str:
3996        return self.case_sql(exp.Case(ifs=[expression], default=expression.args.get("false")))
3997
3998    def matchagainst_sql(self, expression: exp.MatchAgainst) -> str:
3999        if self.MATCH_AGAINST_TABLE_PREFIX:
4000            expressions = []
4001            for expr in expression.expressions:
4002                if isinstance(expr, exp.Table):
4003                    expressions.append(f"TABLE {self.sql(expr)}")
4004                else:
4005                    expressions.append(expr)
4006        else:
4007            expressions = expression.expressions
4008
4009        modifier = expression.args.get("modifier")
4010        modifier = f" {modifier}" if modifier else ""
4011        return (
4012            f"{self.func('MATCH', *expressions)} AGAINST({self.sql(expression, 'this')}{modifier})"
4013        )
4014
4015    def jsonkeyvalue_sql(self, expression: exp.JSONKeyValue) -> str:
4016        return f"{self.sql(expression, 'this')}{self.JSON_KEY_VALUE_PAIR_SEP} {self.sql(expression, 'expression')}"
4017
4018    def jsonpath_sql(self, expression: exp.JSONPath) -> str:
4019        path = self.expressions(expression, sep="", flat=True).lstrip(".")
4020
4021        if self.QUOTE_JSON_PATH:
4022            path = self.escape_str(path)
4023            path = f"{self.dialect.QUOTE_START}{path}{self.dialect.QUOTE_END}"
4024
4025        return path
4026
4027    def json_path_part(self, expression: int | str | exp.JSONPathPart) -> str:
4028        if isinstance(expression, exp.JSONPathPart):
4029            transform = self.TRANSFORMS.get(expression.__class__)
4030            if not callable(transform):
4031                self.unsupported(f"Unsupported JSONPathPart type {expression.__class__.__name__}")
4032                return ""
4033
4034            return transform(self, expression)
4035
4036        if isinstance(expression, int):
4037            return str(expression)
4038
4039        if self._quote_json_path_key_using_brackets and self.JSON_PATH_SINGLE_QUOTE_ESCAPE:
4040            escaped = expression.replace("'", "\\'")
4041            escaped = f"'{escaped}'"
4042        else:
4043            escaped = expression.replace('"', '\\"')
4044            escaped = f'"{escaped}"'
4045
4046        return escaped
4047
4048    def formatjson_sql(self, expression: exp.FormatJson) -> str:
4049        return f"{self.sql(expression, 'this')} FORMAT JSON"
4050
4051    def formatphrase_sql(self, expression: exp.FormatPhrase) -> str:
4052        # Output the Teradata column FORMAT override.
4053        # https://docs.teradata.com/r/Enterprise_IntelliFlex_VMware/SQL-Data-Types-and-Literals/Data-Type-Formats-and-Format-Phrases/FORMAT
4054        this = self.sql(expression, "this")
4055        fmt = self.sql(expression, "format")
4056        return f"{this} (FORMAT {fmt})"
4057
4058    def teradatatitle_sql(self, expression: exp.TeradataTitle) -> str:
4059        self.unsupported("Teradata TITLE display headings are not supported")
4060        return self.sql(expression, "this")
4061
4062    def _jsonobject_sql(
4063        self, expression: exp.JSONObject | exp.JSONObjectAgg, name: str = ""
4064    ) -> str:
4065        null_handling = expression.args.get("null_handling")
4066        null_handling = f" {null_handling}" if null_handling else ""
4067
4068        unique_keys = expression.args.get("unique_keys")
4069        if unique_keys is not None:
4070            unique_keys = f" {'WITH' if unique_keys else 'WITHOUT'} UNIQUE KEYS"
4071        else:
4072            unique_keys = ""
4073
4074        return_type = self.sql(expression, "return_type")
4075        return_type = f" RETURNING {return_type}" if return_type else ""
4076        encoding = self.sql(expression, "encoding")
4077        encoding = f" ENCODING {encoding}" if encoding else ""
4078
4079        if not name:
4080            name = "JSON_OBJECT" if isinstance(expression, exp.JSONObject) else "JSON_OBJECTAGG"
4081
4082        return self.func(
4083            name,
4084            *expression.expressions,
4085            suffix=f"{null_handling}{unique_keys}{return_type}{encoding})",
4086        )
4087
4088    def jsonarray_sql(self, expression: exp.JSONArray) -> str:
4089        null_handling = expression.args.get("null_handling")
4090        null_handling = f" {null_handling}" if null_handling else ""
4091        return_type = self.sql(expression, "return_type")
4092        return_type = f" RETURNING {return_type}" if return_type else ""
4093        strict = " STRICT" if expression.args.get("strict") else ""
4094        return self.func(
4095            "JSON_ARRAY", *expression.expressions, suffix=f"{null_handling}{return_type}{strict})"
4096        )
4097
4098    def jsonarrayagg_sql(self, expression: exp.JSONArrayAgg) -> str:
4099        this = self.sql(expression, "this")
4100        order = self.sql(expression, "order")
4101        null_handling = expression.args.get("null_handling")
4102        null_handling = f" {null_handling}" if null_handling else ""
4103        return_type = self.sql(expression, "return_type")
4104        return_type = f" RETURNING {return_type}" if return_type else ""
4105        strict = " STRICT" if expression.args.get("strict") else ""
4106        return self.func(
4107            "JSON_ARRAYAGG",
4108            this,
4109            suffix=f"{order}{null_handling}{return_type}{strict})",
4110        )
4111
4112    def jsoncolumndef_sql(self, expression: exp.JSONColumnDef) -> str:
4113        path = self.sql(expression, "path")
4114        path = f" PATH {path}" if path else ""
4115        nested_schema = self.sql(expression, "nested_schema")
4116
4117        if nested_schema:
4118            return f"NESTED{path} {nested_schema}"
4119
4120        this = self.sql(expression, "this")
4121        kind = self.sql(expression, "kind")
4122        kind = f" {kind}" if kind else ""
4123        format_json = " FORMAT JSON" if expression.args.get("format_json") else ""
4124
4125        ordinality = " FOR ORDINALITY" if expression.args.get("ordinality") else ""
4126        return f"{this}{kind}{format_json}{path}{ordinality}"
4127
4128    def jsonschema_sql(self, expression: exp.JSONSchema) -> str:
4129        return self.func("COLUMNS", *expression.expressions)
4130
4131    def jsontable_sql(self, expression: exp.JSONTable) -> str:
4132        this = self.sql(expression, "this")
4133        path = self.sql(expression, "path")
4134        path = f", {path}" if path else ""
4135        error_handling = expression.args.get("error_handling")
4136        error_handling = f" {error_handling}" if error_handling else ""
4137        empty_handling = expression.args.get("empty_handling")
4138        empty_handling = f" {empty_handling}" if empty_handling else ""
4139        schema = self.sql(expression, "schema")
4140        return self.func(
4141            "JSON_TABLE", this, suffix=f"{path}{error_handling}{empty_handling} {schema})"
4142        )
4143
4144    def openjsoncolumndef_sql(self, expression: exp.OpenJSONColumnDef) -> str:
4145        this = self.sql(expression, "this")
4146        kind = self.sql(expression, "kind")
4147        path = self.sql(expression, "path")
4148        path = f" {path}" if path else ""
4149        as_json = " AS JSON" if expression.args.get("as_json") else ""
4150        return f"{this} {kind}{path}{as_json}"
4151
4152    def openjson_sql(self, expression: exp.OpenJSON) -> str:
4153        this = self.sql(expression, "this")
4154        path = self.sql(expression, "path")
4155        path = f", {path}" if path else ""
4156        expressions = self.expressions(expression)
4157        with_ = (
4158            f" WITH ({self.seg(self.indent(expressions), sep='')}{self.seg(')', sep='')}"
4159            if expressions
4160            else ""
4161        )
4162        return f"OPENJSON({this}{path}){with_}"
4163
4164    def in_sql(self, expression: exp.In) -> str:
4165        query = expression.args.get("query")
4166        unnest = expression.args.get("unnest")
4167        field = expression.args.get("field")
4168        is_global = " GLOBAL" if expression.args.get("is_global") else ""
4169
4170        if query:
4171            in_sql = self.sql(query)
4172        elif unnest:
4173            in_sql = self.in_unnest_op(unnest)
4174        elif field:
4175            in_sql = self.sql(field)
4176        else:
4177            in_sql = f"({self.expressions(expression, dynamic=True, new_line=True, skip_first=True, skip_last=True)})"
4178
4179        return f"{self.sql(expression, 'this')}{is_global} IN {in_sql}"
4180
4181    def in_unnest_op(self, unnest: exp.Unnest) -> str:
4182        return f"(SELECT {self.sql(unnest)})"
4183
4184    def interval_sql(self, expression: exp.Interval) -> str:
4185        include_keyword = not self.AUTO_REFRESH_BARE_INTERVALS or not isinstance(
4186            expression.find_ancestor(exp.AutoRefreshProperty, exp.Select),
4187            exp.AutoRefreshProperty,
4188        )
4189        interval_keyword = "INTERVAL" if include_keyword else ""
4190        unit_expression = expression.args.get("unit")
4191        unit = self.sql(unit_expression) if unit_expression else ""
4192        if not self.INTERVAL_ALLOWS_PLURAL_FORM:
4193            unit = self.TIME_PART_SINGULARS.get(unit, unit)
4194        unit = f" {unit}" if unit else ""
4195
4196        if self.SINGLE_STRING_INTERVAL:
4197            this = expression.this.name if expression.this else ""
4198            if this:
4199                interval_keyword = f"{interval_keyword} " if interval_keyword else ""
4200                if unit_expression and isinstance(unit_expression, exp.IntervalSpan):
4201                    return f"{interval_keyword}{self.sql(exp.Literal.string(this))}{unit}"
4202                return f"{interval_keyword}{self.sql(exp.Literal.string(f'{this}{unit}'))}"
4203            return f"{interval_keyword}{unit}"
4204
4205        this = self.sql(expression, "this")
4206        if this:
4207            if not include_keyword and expression.this.is_string:
4208                this = expression.this.name
4209            if not isinstance(expression.this, self.UNWRAPPED_INTERVAL_VALUES):
4210                this = f"({this})"
4211            if include_keyword:
4212                this = f" {this}"
4213
4214        return f"{interval_keyword}{this}{unit}"
4215
4216    def return_sql(self, expression: exp.Return) -> str:
4217        return f"RETURN {self.sql(expression, 'this')}"
4218
4219    def reference_sql(self, expression: exp.Reference) -> str:
4220        this = self.sql(expression, "this")
4221        expressions = self.expressions(expression, flat=True)
4222        expressions = f"({expressions})" if expressions else ""
4223        options = self.expressions(expression, key="options", flat=True, sep=" ")
4224        options = f" {options}" if options else ""
4225        return f"REFERENCES {this}{expressions}{options}"
4226
4227    def anonymous_sql(self, expression: exp.Anonymous) -> str:
4228        # We don't normalize qualified functions such as a.b.foo(), because they can be case-sensitive
4229        parent = expression.parent
4230        is_qualified = isinstance(parent, exp.Dot) and expression is parent.expression
4231
4232        return self.func(
4233            self.sql(expression, "this"), *expression.expressions, normalize=not is_qualified
4234        )
4235
4236    def paren_sql(self, expression: exp.Paren) -> str:
4237        sql = self.seg(self.indent(self.sql(expression, "this")), sep="")
4238        return f"({sql}{self.seg(')', sep='')}"
4239
4240    def neg_sql(self, expression: exp.Neg) -> str:
4241        # This makes sure we don't convert "- - 5" to "--5", which is a comment
4242        this_sql = self.sql(expression, "this")
4243        sep = " " if this_sql[0] == "-" else ""
4244        return f"-{sep}{this_sql}"
4245
4246    def not_sql(self, expression: exp.Not) -> str:
4247        return f"NOT {self.sql(expression, 'this')}"
4248
4249    def alias_sql(self, expression: exp.Alias) -> str:
4250        alias = self.sql(expression, "alias")
4251        alias = f" AS {alias}" if alias else ""
4252        return f"{self.sql(expression, 'this')}{alias}"
4253
4254    def pivotalias_sql(self, expression: exp.PivotAlias) -> str:
4255        alias = expression.args["alias"]
4256
4257        parent = expression.parent
4258        pivot = parent and parent.parent
4259
4260        if isinstance(pivot, exp.Pivot) and pivot.unpivot:
4261            identifier_alias = isinstance(alias, exp.Identifier)
4262            literal_alias = isinstance(alias, exp.Literal)
4263
4264            if identifier_alias and not self.UNPIVOT_ALIASES_ARE_IDENTIFIERS:
4265                alias.replace(exp.Literal.string(alias.output_name))
4266            elif not identifier_alias and literal_alias and self.UNPIVOT_ALIASES_ARE_IDENTIFIERS:
4267                alias.replace(exp.to_identifier(alias.output_name))
4268
4269        return self.alias_sql(expression)
4270
4271    def aliases_sql(self, expression: exp.Aliases) -> str:
4272        return f"{self.sql(expression, 'this')} AS ({self.expressions(expression, flat=True)})"
4273
4274    def atindex_sql(self, expression: exp.AtIndex) -> str:
4275        this = self.sql(expression, "this")
4276        index = self.sql(expression, "expression")
4277        return f"{this} AT {index}"
4278
4279    def attimezone_sql(self, expression: exp.AtTimeZone) -> str:
4280        this = self.sql(expression, "this")
4281        zone = self.sql(expression, "zone")
4282        return f"{this} AT TIME ZONE {zone}"
4283
4284    def fromtimezone_sql(self, expression: exp.FromTimeZone) -> str:
4285        this = self.sql(expression, "this")
4286        zone = self.sql(expression, "zone")
4287        return f"{this} AT TIME ZONE {zone} AT TIME ZONE 'UTC'"
4288
4289    def fromiso8601date_sql(self, expression: exp.FromISO8601Date) -> str:
4290        return self.sql(exp.cast(expression.this, exp.DType.DATE))
4291
4292    def fromiso8601timestamp_sql(self, expression: exp.FromISO8601Timestamp) -> str:
4293        return self.sql(exp.cast(expression.this, exp.DType.TIMESTAMPTZ))
4294
4295    def fromiso8601timestampnanos_sql(self, expression: exp.FromISO8601TimestampNanos) -> str:
4296        return self.sql(exp.cast(expression.this, exp.DType.TIMESTAMPTZ))
4297
4298    def add_sql(self, expression: exp.Add) -> str:
4299        return self.binary(expression, "+")
4300
4301    def and_sql(self, expression: exp.And, stack: list[str | exp.Expr] | None = None) -> str:
4302        return self.connector_sql(expression, "AND", stack)
4303
4304    def or_sql(self, expression: exp.Or, stack: list[str | exp.Expr] | None = None) -> str:
4305        return self.connector_sql(expression, "OR", stack)
4306
4307    def xor_sql(self, expression: exp.Xor, stack: list[str | exp.Expr] | None = None) -> str:
4308        return self.connector_sql(expression, "XOR", stack)
4309
4310    def connector_sql(
4311        self,
4312        expression: exp.Connector,
4313        op: str,
4314        stack: list[str | exp.Expr] | None = None,
4315    ) -> str:
4316        if stack is not None:
4317            stack.append(expression.right)
4318            if expression.comments and self.comments:
4319                op = self.maybe_comment(op, comments=expression.comments)
4320
4321            stack.extend((op, expression.left))
4322            return op
4323
4324        stack = [expression]
4325        sqls: list[str] = []
4326        ops = set()
4327
4328        while stack:
4329            node = stack.pop()
4330            if isinstance(node, exp.Connector):
4331                ops.add(getattr(self, f"{node.key}_sql")(node, stack))
4332            else:
4333                sql = self.sql(node)
4334                if sqls and sqls[-1] in ops:
4335                    sqls[-1] += f" {sql}"
4336                else:
4337                    sqls.append(sql)
4338
4339        sep = "\n" if self.pretty and self.too_wide(sqls) else " "
4340        return sep.join(sqls)
4341
4342    def bitwiseand_sql(self, expression: exp.BitwiseAnd) -> str:
4343        return self.binary(expression, "&")
4344
4345    def bitwiseleftshift_sql(self, expression: exp.BitwiseLeftShift) -> str:
4346        return self.binary(expression, "<<")
4347
4348    def bitwisenot_sql(self, expression: exp.BitwiseNot) -> str:
4349        return f"~{self.sql(expression, 'this')}"
4350
4351    def bitwiseor_sql(self, expression: exp.BitwiseOr) -> str:
4352        return self.binary(expression, "|")
4353
4354    def bitwiserightshift_sql(self, expression: exp.BitwiseRightShift) -> str:
4355        return self.binary(expression, ">>")
4356
4357    def bitwisexor_sql(self, expression: exp.BitwiseXor) -> str:
4358        return self.binary(expression, "^")
4359
4360    def cast_sql(self, expression: exp.Cast, safe_prefix: str | None = None) -> str:
4361        format_sql = self.sql(expression, "format")
4362        format_sql = f" FORMAT {format_sql}" if format_sql else ""
4363        to_sql = self.sql(expression, "to")
4364        to_sql = f" {to_sql}" if to_sql else ""
4365        action = self.sql(expression, "action")
4366        action = f" {action}" if action else ""
4367        default = self.sql(expression, "default")
4368        default = f" DEFAULT {default} ON CONVERSION ERROR" if default else ""
4369        return f"{safe_prefix or ''}CAST({self.sql(expression, 'this')} AS{to_sql}{default}{format_sql}{action})"
4370
4371    # Base implementation that excludes safe, zone, and target_type metadata args
4372    def strtotime_sql(self, expression: exp.StrToTime) -> str:
4373        return self.func("STR_TO_TIME", expression.this, expression.args.get("format"))
4374
4375    # Base implementation that excludes the safe and default_year metadata args
4376    def strtodate_sql(self, expression: exp.StrToDate) -> str:
4377        return self.func("STR_TO_DATE", expression.this, expression.args.get("format"))
4378
4379    def parsedatetime_sql(self, expression: exp.ParseDatetime) -> str:
4380        return self.func(
4381            "PARSE_DATETIME",
4382            expression.this,
4383            expression.args.get("format"),
4384            expression.args.get("zone"),
4385        )
4386
4387    def currentdate_sql(self, expression: exp.CurrentDate) -> str:
4388        zone = self.sql(expression, "this")
4389        return f"CURRENT_DATE({zone})" if zone else "CURRENT_DATE"
4390
4391    def collate_sql(self, expression: exp.Collate) -> str:
4392        if self.COLLATE_IS_FUNC:
4393            return self.function_fallback_sql(expression)
4394        return self.binary(expression, "COLLATE")
4395
4396    def command_sql(self, expression: exp.Command) -> str:
4397        return f"{self.sql(expression, 'this')} {expression.text('expression').strip()}"
4398
4399    def comment_sql(self, expression: exp.Comment) -> str:
4400        this = self.sql(expression, "this")
4401        kind = expression.args["kind"]
4402        materialized = " MATERIALIZED" if expression.args.get("materialized") else ""
4403        exists_sql = " IF EXISTS " if expression.args.get("exists") else " "
4404        expression_sql = self.sql(expression, "expression")
4405        return f"COMMENT{exists_sql}ON{materialized} {kind} {this} IS {expression_sql}"
4406
4407    def mergetreettlaction_sql(self, expression: exp.MergeTreeTTLAction) -> str:
4408        this = self.sql(expression, "this")
4409        delete = " DELETE" if expression.args.get("delete") else ""
4410        recompress = self.sql(expression, "recompress")
4411        recompress = f" RECOMPRESS {recompress}" if recompress else ""
4412        to_disk = self.sql(expression, "to_disk")
4413        to_disk = f" TO DISK {to_disk}" if to_disk else ""
4414        to_volume = self.sql(expression, "to_volume")
4415        to_volume = f" TO VOLUME {to_volume}" if to_volume else ""
4416        return f"{this}{delete}{recompress}{to_disk}{to_volume}"
4417
4418    def mergetreettl_sql(self, expression: exp.MergeTreeTTL) -> str:
4419        where = self.sql(expression, "where")
4420        group = self.sql(expression, "group")
4421        aggregates = self.expressions(expression, key="aggregates")
4422        aggregates = self.seg("SET") + self.seg(aggregates) if aggregates else ""
4423
4424        if not (where or group or aggregates) and len(expression.expressions) == 1:
4425            return f"TTL {self.expressions(expression, flat=True)}"
4426
4427        return f"TTL{self.seg(self.expressions(expression))}{where}{group}{aggregates}"
4428
4429    def transaction_sql(self, expression: exp.Transaction) -> str:
4430        modes = self.expressions(expression, key="modes")
4431        modes = f" {modes}" if modes else ""
4432        return f"BEGIN{modes}"
4433
4434    def commit_sql(self, expression: exp.Commit) -> str:
4435        chain = expression.args.get("chain")
4436        if chain is not None:
4437            chain = " AND CHAIN" if chain else " AND NO CHAIN"
4438
4439        return f"COMMIT{chain or ''}"
4440
4441    def rollback_sql(self, expression: exp.Rollback) -> str:
4442        savepoint = expression.args.get("savepoint")
4443        savepoint = f" TO {savepoint}" if savepoint else ""
4444        return f"ROLLBACK{savepoint}"
4445
4446    def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
4447        this = self.sql(expression, "this")
4448
4449        exists = ""
4450        if expression.args.get("exists"):
4451            if self.SUPPORTS_ALTER_COLUMN_IF_EXISTS:
4452                exists = " IF EXISTS"
4453            else:
4454                self.unsupported("ALTER COLUMN IF EXISTS is not supported by this dialect")
4455
4456        dtype = self.sql(expression, "dtype")
4457        if dtype:
4458            collate = self.sql(expression, "collate")
4459            collate = f" COLLATE {collate}" if collate else ""
4460            using = self.sql(expression, "using")
4461            using = f" USING {using}" if using else ""
4462            alter_set_type = self.ALTER_SET_TYPE + " " if self.ALTER_SET_TYPE else ""
4463            null_constraint = self._alter_column_null_constraint_sql(expression)
4464
4465            return (
4466                f"ALTER COLUMN{exists} {this} {alter_set_type}{dtype}"
4467                f"{collate}{using}{null_constraint}"
4468            )
4469
4470        default = self.sql(expression, "default")
4471        if default:
4472            return f"ALTER COLUMN{exists} {this} SET DEFAULT {default}"
4473
4474        comment = self.sql(expression, "comment")
4475        if comment:
4476            return f"ALTER COLUMN{exists} {this} COMMENT {comment}"
4477
4478        visible = expression.args.get("visible")
4479        if visible:
4480            return f"ALTER COLUMN{exists} {this} SET {visible}"
4481
4482        allow_null = expression.args.get("allow_null")
4483        drop = expression.args.get("drop")
4484
4485        if not drop and not allow_null:
4486            self.unsupported("Unsupported ALTER COLUMN syntax")
4487
4488        if allow_null is not None:
4489            keyword = "DROP" if drop else "SET"
4490            return f"ALTER COLUMN{exists} {this} {keyword} NOT NULL"
4491
4492        return f"ALTER COLUMN{exists} {this} DROP DEFAULT"
4493
4494    def _alter_column_null_constraint_sql(self, expression: exp.AlterColumn) -> str:
4495        allow_null = expression.args.get("allow_null")
4496        if allow_null is None:
4497            return ""
4498
4499        if not self.SUPPORTS_ALTER_COLUMN_NULLABILITY:
4500            self.unsupported("ALTER COLUMN cannot set nullability along with a type")
4501            return ""
4502
4503        return " NULL" if allow_null else " NOT NULL"
4504
4505    def modifycolumn_sql(self, expression: exp.ModifyColumn) -> str:
4506        this = self.sql(expression, "this")
4507        rename_from = self.sql(expression, "rename_from")
4508        if rename_from:
4509            if not self.SUPPORTS_CHANGE_COLUMN:
4510                self.unsupported("CHANGE COLUMN is not supported in this dialect")
4511            return f"CHANGE COLUMN {rename_from} {this}"
4512        if not self.SUPPORTS_MODIFY_COLUMN:
4513            self.unsupported("MODIFY COLUMN is not supported in this dialect")
4514        return f"MODIFY COLUMN {this}"
4515
4516    def alterindex_sql(self, expression: exp.AlterIndex) -> str:
4517        this = self.sql(expression, "this")
4518
4519        visible = expression.args.get("visible")
4520        visible_sql = "VISIBLE" if visible else "INVISIBLE"
4521
4522        return f"ALTER INDEX {this} {visible_sql}"
4523
4524    def alterdiststyle_sql(self, expression: exp.AlterDistStyle) -> str:
4525        this = self.sql(expression, "this")
4526        if not isinstance(expression.this, exp.Var):
4527            this = f"KEY DISTKEY {this}"
4528        return f"ALTER DISTSTYLE {this}"
4529
4530    def altersortkey_sql(self, expression: exp.AlterSortKey) -> str:
4531        compound = " COMPOUND" if expression.args.get("compound") else ""
4532        this = self.sql(expression, "this")
4533        expressions = self.expressions(expression, flat=True)
4534        expressions = f"({expressions})" if expressions else ""
4535        return f"ALTER{compound} SORTKEY {this or expressions}"
4536
4537    def alterrename_sql(self, expression: exp.AlterRename, include_to: bool = True) -> str:
4538        if not self.RENAME_TABLE_WITH_DB:
4539            # Remove db from tables
4540            expression = expression.transform(
4541                lambda n: exp.table_(n.this) if isinstance(n, exp.Table) else n
4542            ).assert_is(exp.AlterRename)
4543        this = self.sql(expression, "this")
4544        to_kw = " TO" if include_to else ""
4545        return f"RENAME{to_kw} {this}"
4546
4547    def renamecolumn_sql(self, expression: exp.RenameColumn) -> str:
4548        exists = " IF EXISTS" if expression.args.get("exists") else ""
4549        old_column = self.sql(expression, "this")
4550        new_column = self.sql(expression, "to")
4551        return f"RENAME COLUMN{exists} {old_column} TO {new_column}"
4552
4553    def alterset_sql(self, expression: exp.AlterSet) -> str:
4554        exprs = self.expressions(expression, flat=True)
4555        if self.ALTER_SET_WRAPPED:
4556            exprs = f"({exprs})"
4557
4558        return f"SET {exprs}"
4559
4560    def alter_sql(self, expression: exp.Alter) -> str:
4561        actions = expression.actions
4562
4563        if (
4564            not self.dialect.ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN
4565            and actions
4566            and isinstance(actions[0], exp.ColumnDef)
4567        ):
4568            actions_sql = self.expressions(expression, key="actions", flat=True)
4569            actions_sql = f"ADD {actions_sql}"
4570        else:
4571            actions_list = []
4572            for action in actions:
4573                if isinstance(action, (exp.ColumnDef, exp.Schema)):
4574                    action_sql = self.add_column_sql(action)
4575                else:
4576                    action_sql = self.sql(action)
4577                    if isinstance(action, exp.Query):
4578                        action_sql = f"AS {action_sql}"
4579
4580                actions_list.append(action_sql)
4581
4582            actions_sql = self.format_args(*actions_list).lstrip("\n")
4583
4584        iceberg = (
4585            "ICEBERG "
4586            if expression.args.get("iceberg") and self.SUPPORTS_DROP_ALTER_ICEBERG_PROPERTY
4587            else ""
4588        )
4589        exists = " IF EXISTS" if expression.args.get("exists") else ""
4590        on_cluster = self.sql(expression, "cluster")
4591        on_cluster = f" {on_cluster}" if on_cluster else ""
4592        only = " ONLY" if expression.args.get("only") else ""
4593        options = expression.args.get("options") or []
4594        options_sql = self.expressions(
4595            sqls=[o for o in options if not isinstance(o, self.ALTER_PARTITION_OPTIONS)]
4596        )
4597        options_sql = f", {options_sql}" if options_sql and actions_sql else options_sql
4598        partitions_sql = self.expressions(
4599            sqls=[o for o in options if isinstance(o, self.ALTER_PARTITION_OPTIONS)],
4600            sep=" ",
4601            flat=True,
4602        )
4603        if partitions_sql and (actions_sql or options_sql):
4604            partitions_sql = f" {partitions_sql}"
4605        kind = self.sql(expression, "kind")
4606        not_valid = " NOT VALID" if expression.args.get("not_valid") else ""
4607        check = " WITH CHECK" if expression.args.get("check") else ""
4608        cascade = (
4609            " CASCADE"
4610            if expression.args.get("cascade") and self.dialect.ALTER_TABLE_SUPPORTS_CASCADE
4611            else ""
4612        )
4613        this = self.sql(expression, "this")
4614        this = f" {this}" if this else ""
4615
4616        return f"ALTER {iceberg}{kind}{exists}{only}{this}{on_cluster}{check}{self.sep()}{actions_sql}{not_valid}{options_sql}{partitions_sql}{cascade}"
4617
4618    def altersession_sql(self, expression: exp.AlterSession) -> str:
4619        items_sql = self.expressions(expression, flat=True)
4620        keyword = "UNSET" if expression.args.get("unset") else "SET"
4621        return f"{keyword} {items_sql}"
4622
4623    def add_column_sql(self, expression: exp.Expr) -> str:
4624        column_text = ""
4625        if self.ALTER_TABLE_INCLUDE_COLUMN_KEYWORD:
4626            if isinstance(expression, exp.ColumnDef):
4627                column_text = " COLUMN"
4628            elif isinstance(expression, exp.Schema):
4629                column_text = " COLUMNS"
4630
4631        if isinstance(expression, exp.Schema) and not self.ALTER_TABLE_ADD_COLUMNS_WRAPPED:
4632            sql = self.expressions(expression, flat=True)
4633        else:
4634            sql = self.sql(expression)
4635
4636        return f"ADD{column_text} {sql}"
4637
4638    def droppartition_sql(self, expression: exp.DropPartition) -> str:
4639        expressions = self.expressions(expression)
4640        exists = " IF EXISTS " if expression.args.get("exists") else " "
4641        return f"DROP{exists}{expressions}"
4642
4643    def dropprimarykey_sql(self, expression: exp.DropPrimaryKey) -> str:
4644        return "DROP PRIMARY KEY"
4645
4646    def addconstraint_sql(self, expression: exp.AddConstraint) -> str:
4647        return f"ADD {self.expressions(expression, indent=False)}"
4648
4649    def replacecolumns_sql(self, expression: exp.ReplaceColumns) -> str:
4650        return f"REPLACE COLUMNS ({self.expressions(expression, flat=True)})"
4651
4652    def addpartition_sql(self, expression: exp.AddPartition) -> str:
4653        exists = "IF NOT EXISTS " if expression.args.get("exists") else ""
4654        location = self.sql(expression, "location")
4655        location = f" {location}" if location else ""
4656        return f"ADD {exists}{self.sql(expression.this)}{location}"
4657
4658    def distinct_sql(self, expression: exp.Distinct) -> str:
4659        this = self.expressions(expression, flat=True)
4660
4661        if not self.MULTI_ARG_DISTINCT and len(expression.expressions) > 1:
4662            case = exp.case()
4663            for arg in expression.expressions:
4664                case = case.when(arg.is_(exp.null()), exp.null())
4665            this = self.sql(case.else_(f"({this})"))
4666
4667        this = f" {this}" if this else ""
4668
4669        on = self.sql(expression, "on")
4670        on = f" ON {on}" if on else ""
4671        return f"DISTINCT{this}{on}"
4672
4673    def ignorenulls_sql(self, expression: exp.IgnoreNulls) -> str:
4674        return self._embed_ignore_nulls(expression, "IGNORE NULLS")
4675
4676    def respectnulls_sql(self, expression: exp.RespectNulls) -> str:
4677        return self._embed_ignore_nulls(expression, "RESPECT NULLS")
4678
4679    def havingmax_sql(self, expression: exp.HavingMax) -> str:
4680        this_sql = self.sql(expression, "this")
4681        expression_sql = self.sql(expression, "expression")
4682        kind = "MAX" if expression.args.get("max") else "MIN"
4683        return f"{this_sql} HAVING {kind} {expression_sql}"
4684
4685    def intdiv_sql(self, expression: exp.IntDiv) -> str:
4686        return self._truncated_div_sql(expression.this, expression.expression)
4687
4688    def _truncated_div_sql(self, this: exp.Expr, divisor: exp.Expr) -> str:
4689        div: exp.Expr = exp.Div(this=this, expression=divisor)
4690        if self.CAST_TO_INT_ROUNDS:
4691            div = exp.Trunc(this=div)
4692
4693        return self.sql(exp.Cast(this=div, to=exp.DataType(this=exp.DType.BIGINT)))
4694
4695    def dpipe_sql(self, expression: exp.DPipe) -> str:
4696        if self.dialect.STRICT_STRING_CONCAT and expression.args.get("safe"):
4697            return self.func("CONCAT", *(exp.cast(e, exp.DType.TEXT) for e in expression.flatten()))
4698        return self.binary(expression, "||")
4699
4700    def nullif_zero_divisor(self, expression: exp.Div | exp.Mod) -> None:
4701        if not self.dialect.SAFE_DIVISION and expression.args.get("safe"):
4702            divisor = expression.right
4703            divisor.replace(exp.Nullif(this=divisor.copy(), expression=exp.Literal.number(0)))
4704
4705    def div_sql(self, expression: exp.Div) -> str:
4706        l, r = expression.left, expression.right
4707        self.nullif_zero_divisor(expression)
4708
4709        if self.dialect.TYPED_DIVISION and not expression.args.get("typed"):
4710            if not l.is_type(*exp.DataType.REAL_TYPES) and not r.is_type(*exp.DataType.REAL_TYPES):
4711                l.replace(exp.cast(l.copy(), to=exp.DType.DOUBLE))
4712
4713        elif not self.dialect.TYPED_DIVISION and expression.args.get("typed"):
4714            if l.is_type(*exp.DataType.INTEGER_TYPES) and r.is_type(*exp.DataType.INTEGER_TYPES):
4715                # Native integer division depends on the target's operand types, which may differ
4716                # from the source's (e.g. FLOOR(int) is DOUBLE in DuckDB), unless the operands are
4717                # integer literals or casts
4718                if all(e.is_int or isinstance(e, exp.Cast) for e in (l, r)) and (
4719                    expression.args.get("safe") or not self.SAFE_INT_DIVISION
4720                ):
4721                    return self.sql(exp.IntDiv(this=l, expression=expression.right))
4722                return self._truncated_div_sql(l, expression.right)
4723
4724        return self.binary(expression, "/")
4725
4726    def safedivide_sql(self, expression: exp.SafeDivide) -> str:
4727        n = exp._wrap(expression.this, exp.Binary)
4728        d = exp._wrap(expression.expression, exp.Binary)
4729        return self.sql(exp.If(this=d.neq(0), true=n / d, false=exp.Null()))
4730
4731    def overlaps_sql(self, expression: exp.Overlaps) -> str:
4732        return self.binary(expression, "OVERLAPS")
4733
4734    def distance_sql(self, expression: exp.Distance) -> str:
4735        return self.binary(expression, "<->")
4736
4737    def distancend_sql(self, expression: exp.DistanceNd) -> str:
4738        return self.binary(expression, "<<->>")
4739
4740    def dot_sql(self, expression: exp.Dot) -> str:
4741        return f"{self.sql(expression, 'this')}.{self.sql(expression, 'expression')}"
4742
4743    def eq_sql(self, expression: exp.EQ) -> str:
4744        return self.binary(expression, "=")
4745
4746    def propertyeq_sql(self, expression: exp.PropertyEQ) -> str:
4747        return self.binary(expression, ":=")
4748
4749    def escape_sql(self, expression: exp.Escape) -> str:
4750        this = expression.this
4751        if (
4752            isinstance(this, (exp.Like, exp.ILike))
4753            and isinstance(this.expression, (exp.All, exp.Any))
4754            and not self.SUPPORTS_LIKE_QUANTIFIERS
4755        ):
4756            return self._like_sql(this, escape=expression)
4757        return self.binary(expression, "ESCAPE")
4758
4759    def glob_sql(self, expression: exp.Glob) -> str:
4760        return self.binary(expression, "GLOB")
4761
4762    def gt_sql(self, expression: exp.GT) -> str:
4763        return self.binary(expression, ">")
4764
4765    def gte_sql(self, expression: exp.GTE) -> str:
4766        return self.binary(expression, ">=")
4767
4768    def is_sql(self, expression: exp.Is) -> str:
4769        negate = expression.args.get("negate")
4770        if not self.IS_BOOL_ALLOWED and isinstance(expression.expression, exp.Boolean):
4771            positive = bool(expression.expression.this) != bool(negate)
4772            return self.sql(expression.this if positive else exp.not_(expression.this))
4773        return self.binary(expression, "IS NOT" if negate else "IS")
4774
4775    def _like_sql(
4776        self,
4777        expression: exp.Like | exp.ILike,
4778        escape: exp.Escape | None = None,
4779    ) -> str:
4780        this = expression.this
4781        rhs = expression.expression
4782
4783        if isinstance(expression, exp.Like):
4784            exp_class: type[exp.Like | exp.ILike] = exp.Like
4785            op = "LIKE"
4786        else:
4787            exp_class = exp.ILike
4788            op = "ILIKE"
4789
4790        if expression.args.get("negate"):
4791            op = f"NOT {op}"
4792
4793        if isinstance(rhs, (exp.All, exp.Any)) and not self.SUPPORTS_LIKE_QUANTIFIERS:
4794            exprs = rhs.this.unnest()
4795
4796            if isinstance(exprs, exp.Tuple):
4797                exprs = exprs.expressions
4798            else:
4799                exprs = [exprs]
4800
4801            connective = exp.or_ if isinstance(rhs, exp.Any) else exp.and_
4802
4803            def _make_like(expr: exp.Expression) -> exp.Expression:
4804                like: exp.Expression = exp_class(
4805                    this=this, expression=expr, negate=expression.args.get("negate")
4806                )
4807                if escape:
4808                    like = exp.Escape(this=like, expression=escape.expression.copy())
4809                return like
4810
4811            like_expr: exp.Expr = _make_like(exprs[0])
4812            for expr in exprs[1:]:
4813                like_expr = connective(like_expr, _make_like(expr), copy=False)
4814
4815            parent = escape.parent if escape else expression.parent
4816            if not isinstance(parent, (type(like_expr), exp.Paren)) and isinstance(
4817                parent, exp.Condition
4818            ):
4819                like_expr = exp.paren(like_expr, copy=False)
4820
4821            return self.sql(like_expr)
4822
4823        return self.binary(expression, op)
4824
4825    def like_sql(self, expression: exp.Like) -> str:
4826        return self._like_sql(expression)
4827
4828    def ilike_sql(self, expression: exp.ILike) -> str:
4829        return self._like_sql(expression)
4830
4831    def match_sql(self, expression: exp.Match) -> str:
4832        if expression.args.get("kind") or expression.args.get("analyzer"):
4833            self.unsupported("MATCH variants and USING ANALYZER are not supported in this dialect")
4834        return self.binary(expression, "MATCH")
4835
4836    def similarto_sql(self, expression: exp.SimilarTo) -> str:
4837        return self.binary(expression, "SIMILAR TO")
4838
4839    def lt_sql(self, expression: exp.LT) -> str:
4840        return self.binary(expression, "<")
4841
4842    def lte_sql(self, expression: exp.LTE) -> str:
4843        return self.binary(expression, "<=")
4844
4845    def mod_sql(self, expression: exp.Mod) -> str:
4846        self.nullif_zero_divisor(expression)
4847        this = self.sql(expression, "this")
4848        expr = self.sql(expression, "expression")
4849        sql = f"{this} {self.maybe_comment(self.MOD_OPERATOR, comments=expression.comments)} {expr}"
4850
4851        parent = expression.parent
4852        if isinstance(parent, self.MOD_PAREN_PARENT_TYPES) and parent.expression is expression:
4853            return f"({sql})"
4854
4855        return sql
4856
4857    def mul_sql(self, expression: exp.Mul) -> str:
4858        return self.binary(expression, "*")
4859
4860    def neq_sql(self, expression: exp.NEQ) -> str:
4861        return self.binary(expression, "<>")
4862
4863    def nullsafeeq_sql(self, expression: exp.NullSafeEQ) -> str:
4864        return self.binary(expression, "IS NOT DISTINCT FROM")
4865
4866    def nullsafeneq_sql(self, expression: exp.NullSafeNEQ) -> str:
4867        return self.binary(expression, "IS DISTINCT FROM")
4868
4869    def sub_sql(self, expression: exp.Sub) -> str:
4870        return self.binary(expression, "-")
4871
4872    def trycast_sql(self, expression: exp.TryCast) -> str:
4873        return self.cast_sql(expression, safe_prefix="TRY_")
4874
4875    def jsoncast_sql(self, expression: exp.JSONCast) -> str:
4876        return self.cast_sql(expression)
4877
4878    def try_sql(self, expression: exp.Try) -> str:
4879        if not self.TRY_SUPPORTED:
4880            self.unsupported("Unsupported TRY function")
4881            return self.sql(expression, "this")
4882
4883        return self.func("TRY", expression.this)
4884
4885    def log_sql(self, expression: exp.Log) -> str:
4886        this = expression.this
4887        expr = expression.expression
4888
4889        if self.dialect.LOG_BASE_FIRST is False:
4890            this, expr = expr, this
4891        elif self.dialect.LOG_BASE_FIRST is None and expr:
4892            if this.name in ("2", "10"):
4893                return self.func(f"LOG{this.name}", expr)
4894
4895            self.unsupported(f"Unsupported logarithm with base {self.sql(this)}")
4896
4897        return self.func("LOG", this, expr)
4898
4899    def use_sql(self, expression: exp.Use) -> str:
4900        kind = self.sql(expression, "kind")
4901        kind = f" {kind}" if kind else ""
4902        this = self.sql(expression, "this") or self.expressions(expression, flat=True)
4903        this = f" {this}" if this else ""
4904        return f"USE{kind}{this}"
4905
4906    def binary(self, expression: exp.Binary, op: str) -> str:
4907        sqls: list[str] = []
4908        stack: list[None | str | exp.Expr] = [expression]
4909        binary_type = type(expression)
4910        is_is = binary_type is exp.Is and op in ("IS", "IS NOT")
4911        negate = expression.args.get("negate")
4912
4913        while stack:
4914            node = stack.pop()
4915
4916            if type(node) is binary_type and (
4917                node is expression
4918                or (is_is and not isinstance(node.expression, exp.Boolean))
4919                or node.args.get("negate") == negate
4920            ):
4921                op_func = node.args.get("operator")
4922                if op_func:
4923                    op = f"OPERATOR({self.sql(op_func)})"
4924                elif is_is:
4925                    op = "IS NOT" if node.args.get("negate") else "IS"
4926
4927                stack.append(node.args.get("expression"))
4928                stack.append(f" {self.maybe_comment(op, comments=node.comments)} ")
4929                stack.append(node.args.get("this"))
4930            else:
4931                sqls.append(self.sql(node))
4932
4933        return "".join(sqls)
4934
4935    def ceil_floor(self, expression: exp.Ceil | exp.Floor) -> str:
4936        to_clause = self.sql(expression, "to")
4937        if to_clause:
4938            return f"{expression.sql_name()}({self.sql(expression, 'this')} TO {to_clause})"
4939
4940        return self.function_fallback_sql(expression)
4941
4942    def function_fallback_sql(self, expression: exp.Func) -> str:
4943        args = []
4944
4945        for key in expression.arg_types:
4946            arg_value = expression.args.get(key)
4947
4948            if isinstance(arg_value, list):
4949                for value in arg_value:
4950                    args.append(value)
4951            elif arg_value is not None:
4952                args.append(arg_value)
4953
4954        return self.func(self.function_name(expression), *args)
4955
4956    def function_name(self, expression: exp.Func) -> str:
4957        name_key = self.dialect.ORIGINAL_NAME_META_KEY
4958        return (expression.meta_get(name_key) if name_key else None) or expression.sql_name()
4959
4960    def func(
4961        self,
4962        name: str,
4963        *args: t.Any,
4964        prefix: str = "(",
4965        suffix: str = ")",
4966        normalize: bool = True,
4967    ) -> str:
4968        name = self.normalize_func(name) if normalize else name
4969        return f"{name}{prefix}{self.format_args(*args)}{suffix}"
4970
4971    def format_args(self, *args: t.Any, sep: str = ", ") -> str:
4972        arg_sqls = tuple(
4973            self.sql(arg) for arg in args if arg is not None and not isinstance(arg, bool)
4974        )
4975        if self.pretty and self.too_wide(arg_sqls):
4976            return self.indent(
4977                "\n" + f"{sep.strip()}\n".join(arg_sqls) + "\n", skip_first=True, skip_last=True
4978            )
4979        return sep.join(arg_sqls)
4980
4981    def too_wide(self, args: t.Iterable) -> bool:
4982        return sum(len(arg) for arg in args) > self.max_text_width
4983
4984    def format_time(
4985        self,
4986        expression: exp.Expr,
4987        inverse_time_mapping: dict[str, str] | None = None,
4988        inverse_time_trie: dict | None = None,
4989    ) -> str | None:
4990        return format_time(
4991            self.sql(expression, "format"),
4992            inverse_time_mapping or self.dialect.INVERSE_TIME_MAPPING,
4993            inverse_time_trie or self.dialect.INVERSE_TIME_TRIE,
4994        )
4995
4996    def expressions(
4997        self,
4998        expression: exp.Expr | None = None,
4999        key: str | None = None,
5000        sqls: t.Collection[str | exp.Expr] | None = None,
5001        flat: bool = False,
5002        indent: bool = True,
5003        skip_first: bool = False,
5004        skip_last: bool = False,
5005        sep: str = ", ",
5006        prefix: str = "",
5007        dynamic: bool = False,
5008        new_line: bool = False,
5009    ) -> str:
5010        expressions = expression.args.get(key or "expressions") if expression else sqls
5011
5012        if not expressions:
5013            return ""
5014
5015        if flat:
5016            return sep.join(sql for sql in (self.sql(e) for e in expressions) if sql)
5017
5018        num_sqls = len(expressions)
5019        result_sqls = []
5020
5021        for i, e in enumerate(expressions):
5022            sql = self.sql(e, comment=False)
5023            if not sql:
5024                continue
5025
5026            comments = self.maybe_comment("", e) if isinstance(e, exp.Expr) else ""
5027
5028            if self.pretty:
5029                if self.leading_comma:
5030                    result_sqls.append(f"{sep if i > 0 else ''}{prefix}{sql}{comments}")
5031                else:
5032                    result_sqls.append(
5033                        f"{prefix}{sql}{(sep.rstrip() if comments else sep) if i + 1 < num_sqls else ''}{comments}"
5034                    )
5035            else:
5036                result_sqls.append(f"{prefix}{sql}{comments}{sep if i + 1 < num_sqls else ''}")
5037
5038        if self.pretty and (not dynamic or self.too_wide(result_sqls)):
5039            if new_line:
5040                result_sqls.insert(0, "")
5041                result_sqls.append("")
5042            result_sql = "\n".join(s.rstrip() for s in result_sqls)
5043        else:
5044            result_sql = "".join(result_sqls)
5045
5046        return (
5047            self.indent(result_sql, skip_first=skip_first, skip_last=skip_last)
5048            if indent
5049            else result_sql
5050        )
5051
5052    def op_expressions(self, op: str, expression: exp.Expr, flat: bool = False) -> str:
5053        flat = flat or isinstance(expression.parent, exp.Properties)
5054        expressions_sql = self.expressions(expression, flat=flat)
5055        if flat:
5056            return f"{op} {expressions_sql}"
5057        return f"{self.seg(op)}{self.sep() if expressions_sql else ''}{expressions_sql}"
5058
5059    def naked_property(self, expression: exp.Property) -> str:
5060        property_name = exp.Properties.PROPERTY_TO_NAME.get(expression.__class__)
5061        if not property_name:
5062            self.unsupported(f"Unsupported property {expression.__class__.__name__}")
5063        return f"{property_name} {self.sql(expression, 'this')}"
5064
5065    def tag_sql(self, expression: exp.Tag) -> str:
5066        return f"{expression.args.get('prefix')}{self.sql(expression.this)}{expression.args.get('postfix')}"
5067
5068    def token_sql(self, token_type: TokenType) -> str:
5069        return self.TOKEN_MAPPING.get(token_type, token_type.name)
5070
5071    def userdefinedfunction_sql(self, expression: exp.UserDefinedFunction) -> str:
5072        this = self.sql(expression, "this")
5073        expressions = self.no_identify(self.expressions, expression)
5074        expressions = (
5075            self.wrap(expressions) if expression.args.get("wrapped") else f" {expressions}"
5076        )
5077        return f"{this}{expressions}" if expressions.strip() != "" else this
5078
5079    def macrooverloads_sql(self, expression: exp.MacroOverloads) -> str:
5080        return self.expressions(expression, flat=True)
5081
5082    def macrooverload_sql(self, expression: exp.MacroOverload) -> str:
5083        params = self.no_identify(self.expressions, expression, flat=True)
5084        body = self.sql(expression, "this")
5085        prefix = "TABLE " if expression.args.get("is_table") else ""
5086        return f"({params}) AS {prefix}{body}"
5087
5088    def joinhint_sql(self, expression: exp.JoinHint) -> str:
5089        this = self.sql(expression, "this")
5090        expressions = self.expressions(expression, flat=True)
5091        return f"{this}({expressions})"
5092
5093    def kwarg_sql(self, expression: exp.Kwarg) -> str:
5094        return self.binary(expression, "=>")
5095
5096    def when_sql(self, expression: exp.When) -> str:
5097        matched = "MATCHED" if expression.args["matched"] else "NOT MATCHED"
5098        source = " BY SOURCE" if self.MATCHED_BY_SOURCE and expression.args.get("source") else ""
5099        condition = self.sql(expression, "condition")
5100        condition = f" AND {condition}" if condition else ""
5101
5102        then_expression = expression.args.get("then")
5103        if isinstance(then_expression, exp.Insert):
5104            this = (
5105                "ALL BY NAME"
5106                if self.MERGE_ALL_BY_NAME and isinstance(then_expression.this, exp.Star)
5107                else self.sql(then_expression, "this")
5108            )
5109            this = f"INSERT {this}" if this else "INSERT"
5110            then = self.sql(then_expression, "expression")
5111            then = f"{this} VALUES {then}" if then else this
5112        elif isinstance(then_expression, exp.Update):
5113            if isinstance(then_expression.args.get("expressions"), exp.Star):
5114                then = (
5115                    "UPDATE ALL BY NAME"
5116                    if self.MERGE_ALL_BY_NAME
5117                    else f"UPDATE {self.sql(then_expression, 'expressions')}"
5118                )
5119            elif (
5120                self.MERGE_ALL_BY_NAME
5121                and len(then_expression.expressions) == 1
5122                and isinstance(then_expression.expressions[0], exp.Star)
5123            ):
5124                then = "UPDATE ALL BY NAME"
5125            else:
5126                expressions_sql = self.expressions(then_expression)
5127                then = f"UPDATE SET{self.sep()}{expressions_sql}" if expressions_sql else "UPDATE"
5128        else:
5129            then = self.sql(then_expression)
5130
5131        if isinstance(then_expression, (exp.Insert, exp.Update)):
5132            where = self.sql(then_expression, "where")
5133            if where and not self.SUPPORTS_MERGE_WHERE:
5134                kind = "INSERT" if isinstance(then_expression, exp.Insert) else "UPDATE"
5135                self.unsupported(f"WHERE clause in MERGE {kind} is not supported")
5136                where = ""
5137            then = f"{then}{where}"
5138        return f"WHEN {matched}{source}{condition} THEN {then}"
5139
5140    def whens_sql(self, expression: exp.Whens) -> str:
5141        return self.expressions(expression, sep=" ", indent=False)
5142
5143    def merge_sql(self, expression: exp.Merge) -> str:
5144        table = expression.this
5145        table_alias = ""
5146
5147        hints = table.args.get("hints")
5148        if hints and table.alias and isinstance(hints[0], exp.WithTableHint):
5149            # T-SQL syntax is MERGE ... <target_table> [WITH (<merge_hint>)] [[AS] table_alias]
5150            table_alias = f" AS {self.sql(table.args['alias'].pop())}"
5151
5152        this = self.sql(table)
5153        using = f"USING {self.sql(expression, 'using')}"
5154        whens = self.sql(expression, "whens")
5155
5156        on = self.sql(expression, "on")
5157        on = f"ON {on}" if on else ""
5158
5159        if not on:
5160            on = self.expressions(expression, key="using_cond")
5161            on = f"USING ({on})" if on else ""
5162
5163        returning = self.sql(expression, "returning")
5164        if returning:
5165            whens = f"{whens}{returning}"
5166
5167        sep = self.sep()
5168
5169        return self.prepend_ctes(
5170            expression,
5171            f"MERGE INTO {this}{table_alias}{sep}{using}{sep}{on}{sep}{whens}",
5172        )
5173
5174    @unsupported_args("format")
5175    def tochar_sql(self, expression: exp.ToChar) -> str:
5176        return self.sql(exp.cast(expression.this, exp.DType.TEXT))
5177
5178    @unsupported_args("default")
5179    def tonumber_sql(self, expression: exp.ToNumber) -> str:
5180        if not self.SUPPORTS_TO_NUMBER:
5181            self.unsupported("Unsupported TO_NUMBER function")
5182            return self._tonumber_cast_sql(expression)
5183
5184        fmt = expression.args.get("format")
5185        if not fmt:
5186            self.unsupported("Conversion format is required for TO_NUMBER")
5187            return self._tonumber_cast_sql(expression)
5188
5189        return self.func("TO_NUMBER", expression.this, fmt)
5190
5191    def _tonumber_cast_sql(self, expression: exp.ToNumber) -> str:
5192        if expression.args.get("safe"):
5193            return self.sql(exp.TryCast(this=expression.this, to=exp.DataType.build("DOUBLE")))
5194        return self.sql(exp.cast(expression.this, exp.DType.DOUBLE))
5195
5196    def dictproperty_sql(self, expression: exp.DictProperty) -> str:
5197        this = self.sql(expression, "this")
5198        kind = self.sql(expression, "kind")
5199        settings_sql = self.expressions(expression, key="settings", sep=" ")
5200        args = f"({self.sep('')}{settings_sql}{self.seg(')', sep='')}" if settings_sql else "()"
5201        return f"{this}({kind}{args})"
5202
5203    def dictrange_sql(self, expression: exp.DictRange) -> str:
5204        this = self.sql(expression, "this")
5205        max = self.sql(expression, "max")
5206        min = self.sql(expression, "min")
5207        return f"{this}(MIN {min} MAX {max})"
5208
5209    def dictsubproperty_sql(self, expression: exp.DictSubProperty) -> str:
5210        return f"{self.sql(expression, 'this')} {self.sql(expression, 'value')}"
5211
5212    def aggregatekeyproperty_sql(self, expression: exp.AggregateKeyProperty) -> str:
5213        return f"AGGREGATE KEY ({self.expressions(expression, flat=True)})"
5214
5215    def duplicatekeyproperty_sql(self, expression: exp.DuplicateKeyProperty) -> str:
5216        return f"DUPLICATE KEY ({self.expressions(expression, flat=True)})"
5217
5218    # https://docs.starrocks.io/docs/sql-reference/sql-statements/table_bucket_part_index/CREATE_TABLE/
5219    def uniquekeyproperty_sql(
5220        self, expression: exp.UniqueKeyProperty, prefix: str = "UNIQUE KEY"
5221    ) -> str:
5222        return f"{prefix} ({self.expressions(expression, flat=True)})"
5223
5224    # https://docs.starrocks.io/docs/sql-reference/sql-statements/data-definition/CREATE_TABLE/#distribution_desc
5225    def distributedbyproperty_sql(self, expression: exp.DistributedByProperty) -> str:
5226        expressions = self.expressions(expression, flat=True)
5227        expressions = f" {self.wrap(expressions)}" if expressions else ""
5228        buckets = self.sql(expression, "buckets")
5229        kind = self.sql(expression, "kind")
5230        buckets = f" BUCKETS {buckets}" if buckets else ""
5231        order = self.sql(expression, "order")
5232        return f"DISTRIBUTED BY {kind}{expressions}{buckets}{order}"
5233
5234    def oncluster_sql(self, expression: exp.OnCluster) -> str:
5235        return ""
5236
5237    def clusteredbyproperty_sql(self, expression: exp.ClusteredByProperty) -> str:
5238        expressions = self.expressions(expression, key="expressions", flat=True)
5239        sorted_by = self.expressions(expression, key="sorted_by", flat=True)
5240        sorted_by = f" SORTED BY ({sorted_by})" if sorted_by else ""
5241        buckets = self.sql(expression, "buckets")
5242        return f"CLUSTERED BY ({expressions}){sorted_by} INTO {buckets} BUCKETS"
5243
5244    def anyvalue_sql(self, expression: exp.AnyValue) -> str:
5245        this = self.sql(expression, "this")
5246        having = self.sql(expression, "having")
5247
5248        if having:
5249            this = f"{this} HAVING {'MAX' if expression.args.get('max') else 'MIN'} {having}"
5250
5251        return self.func("ANY_VALUE", this)
5252
5253    def querytransform_sql(self, expression: exp.QueryTransform) -> str:
5254        transform = self.func("TRANSFORM", *expression.expressions)
5255        row_format_before = self.sql(expression, "row_format_before")
5256        row_format_before = f" {row_format_before}" if row_format_before else ""
5257        record_writer = self.sql(expression, "record_writer")
5258        record_writer = f" RECORDWRITER {record_writer}" if record_writer else ""
5259        using = f" USING {self.sql(expression, 'command_script')}"
5260        schema = self.sql(expression, "schema")
5261        schema = f" AS {schema}" if schema else ""
5262        row_format_after = self.sql(expression, "row_format_after")
5263        row_format_after = f" {row_format_after}" if row_format_after else ""
5264        record_reader = self.sql(expression, "record_reader")
5265        record_reader = f" RECORDREADER {record_reader}" if record_reader else ""
5266        return f"{transform}{row_format_before}{record_writer}{using}{schema}{row_format_after}{record_reader}"
5267
5268    def indexconstraintoption_sql(self, expression: exp.IndexConstraintOption) -> str:
5269        key_block_size = self.sql(expression, "key_block_size")
5270        if key_block_size:
5271            return f"KEY_BLOCK_SIZE = {key_block_size}"
5272
5273        using = self.sql(expression, "using")
5274        if using:
5275            return f"USING {using}"
5276
5277        parser = self.sql(expression, "parser")
5278        if parser:
5279            return f"WITH PARSER {parser}"
5280
5281        comment = self.sql(expression, "comment")
5282        if comment:
5283            return f"COMMENT {comment}"
5284
5285        visible = expression.args.get("visible")
5286        if visible is not None:
5287            return "VISIBLE" if visible else "INVISIBLE"
5288
5289        engine_attr = self.sql(expression, "engine_attr")
5290        if engine_attr:
5291            return f"ENGINE_ATTRIBUTE = {engine_attr}"
5292
5293        secondary_engine_attr = self.sql(expression, "secondary_engine_attr")
5294        if secondary_engine_attr:
5295            return f"SECONDARY_ENGINE_ATTRIBUTE = {secondary_engine_attr}"
5296
5297        self.unsupported("Unsupported index constraint option.")
5298        return ""
5299
5300    def checkcolumnconstraint_sql(self, expression: exp.CheckColumnConstraint) -> str:
5301        enforced = " ENFORCED" if expression.args.get("enforced") else ""
5302        return f"CHECK ({self.sql(expression, 'this')}){enforced}"
5303
5304    def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
5305        kind = self.sql(expression, "kind")
5306        kind = f"{kind} INDEX" if kind else "INDEX"
5307        this = self.sql(expression, "this")
5308        this = f" {this}" if this else ""
5309        index_type = self.sql(expression, "index_type")
5310        index_type = f" USING {index_type}" if index_type else ""
5311        expressions = self.expressions(expression, flat=True)
5312        expressions = f" ({expressions})" if expressions else ""
5313        options = self.expressions(expression, key="options", sep=" ")
5314        options = f" {options}" if options else ""
5315        return f"{kind}{this}{index_type}{expressions}{options}"
5316
5317    def nvl2_sql(self, expression: exp.Nvl2) -> str:
5318        if self.NVL2_SUPPORTED:
5319            return self.function_fallback_sql(expression)
5320
5321        case = exp.Case().when(
5322            expression.this.is_(exp.null()).not_(copy=False),
5323            expression.args["true"],
5324            copy=False,
5325        )
5326        else_cond = expression.args.get("false")
5327        if else_cond:
5328            case.else_(else_cond, copy=False)
5329
5330        return self.sql(case)
5331
5332    def nthvalue_sql(self, expression: exp.NthValue) -> str:
5333        if expression.args.get("from_first") is False:
5334            self.unsupported("NTH_VALUE FROM LAST is not supported")
5335
5336        return self.function_fallback_sql(expression)
5337
5338    def comprehension_sql(self, expression: exp.Comprehension) -> str:
5339        this = self.sql(expression, "this")
5340        expr = self.sql(expression, "expression")
5341        position = self.sql(expression, "position")
5342        position = f", {position}" if position else ""
5343        iterator = self.sql(expression, "iterator")
5344        condition = self.sql(expression, "condition")
5345        condition = f" IF {condition}" if condition else ""
5346        return f"{this} FOR {expr}{position} IN {iterator}{condition}"
5347
5348    def columnprefix_sql(self, expression: exp.ColumnPrefix) -> str:
5349        return f"{self.sql(expression, 'this')}({self.sql(expression, 'expression')})"
5350
5351    def opclass_sql(self, expression: exp.Opclass) -> str:
5352        return f"{self.sql(expression, 'this')} {self.sql(expression, 'expression')}"
5353
5354    def _ml_sql(self, expression: exp.Func, name: str) -> str:
5355        model = self.sql(expression, "this")
5356        model = f"MODEL {model}"
5357        expr = expression.expression
5358        if expr:
5359            expr_sql = self.sql(expression, "expression")
5360            expr_sql = f"TABLE {expr_sql}" if isinstance(expr, exp.Table) else expr_sql
5361        else:
5362            expr_sql = None
5363
5364        parameters = self.sql(expression, "params_struct") or None
5365
5366        return self.func(name, model, expr_sql, parameters)
5367
5368    def predict_sql(self, expression: exp.Predict) -> str:
5369        return self._ml_sql(expression, "PREDICT")
5370
5371    def generateembedding_sql(self, expression: exp.GenerateEmbedding) -> str:
5372        name = "GENERATE_TEXT_EMBEDDING" if expression.args.get("is_text") else "GENERATE_EMBEDDING"
5373        return self._ml_sql(expression, name)
5374
5375    def generatetext_sql(self, expression: exp.GenerateText) -> str:
5376        return self._ml_sql(expression, "GENERATE_TEXT")
5377
5378    def generatetable_sql(self, expression: exp.GenerateTable) -> str:
5379        return self._ml_sql(expression, "GENERATE_TABLE")
5380
5381    def generatebool_sql(self, expression: exp.GenerateBool) -> str:
5382        return self._ml_sql(expression, "GENERATE_BOOL")
5383
5384    def generateint_sql(self, expression: exp.GenerateInt) -> str:
5385        return self._ml_sql(expression, "GENERATE_INT")
5386
5387    def generatedouble_sql(self, expression: exp.GenerateDouble) -> str:
5388        return self._ml_sql(expression, "GENERATE_DOUBLE")
5389
5390    def mltranslate_sql(self, expression: exp.MLTranslate) -> str:
5391        return self._ml_sql(expression, "TRANSLATE")
5392
5393    def mlforecast_sql(self, expression: exp.MLForecast) -> str:
5394        return self._ml_sql(expression, "FORECAST")
5395
5396    def aiforecast_sql(self, expression: exp.AIForecast) -> str:
5397        this_sql = self.sql(expression, "this")
5398        if isinstance(expression.this, exp.Table):
5399            this_sql = f"TABLE {this_sql}"
5400
5401        return self.func(
5402            "FORECAST",
5403            this_sql,
5404            expression.args.get("data_col"),
5405            expression.args.get("timestamp_col"),
5406            expression.args.get("model"),
5407            expression.args.get("id_cols"),
5408            expression.args.get("horizon"),
5409            expression.args.get("forecast_end_timestamp"),
5410            expression.args.get("confidence_level"),
5411            expression.args.get("output_historical_time_series"),
5412            expression.args.get("context_window"),
5413        )
5414
5415    def featuresattime_sql(self, expression: exp.FeaturesAtTime) -> str:
5416        this_sql = self.sql(expression, "this")
5417        if isinstance(expression.this, exp.Table):
5418            this_sql = f"TABLE {this_sql}"
5419
5420        return self.func(
5421            "FEATURES_AT_TIME",
5422            this_sql,
5423            expression.args.get("time"),
5424            expression.args.get("num_rows"),
5425            expression.args.get("ignore_feature_nulls"),
5426        )
5427
5428    def vectorsearch_sql(self, expression: exp.VectorSearch) -> str:
5429        this_sql = self.sql(expression, "this")
5430        if isinstance(expression.this, exp.Table):
5431            this_sql = f"TABLE {this_sql}"
5432
5433        query_table = self.sql(expression, "query_table")
5434        if isinstance(expression.args["query_table"], exp.Table):
5435            query_table = f"TABLE {query_table}"
5436
5437        return self.func(
5438            "VECTOR_SEARCH",
5439            this_sql,
5440            expression.args.get("column_to_search"),
5441            query_table,
5442            expression.args.get("query_column_to_search"),
5443            expression.args.get("top_k"),
5444            expression.args.get("distance_type"),
5445            expression.args.get("options"),
5446        )
5447
5448    def forin_sql(self, expression: exp.ForIn) -> str:
5449        this = self.sql(expression, "this")
5450        expression_sql = self.sql(expression, "expression")
5451        return f"FOR {this} DO {expression_sql}"
5452
5453    @unsupported_args("partition_start", "partition_end", "force", "mode")
5454    def refresh_sql(self, expression: exp.Refresh) -> str:
5455        this = self.sql(expression, "this")
5456        kind = "" if isinstance(expression.this, exp.Literal) else f"{expression.text('kind')} "
5457        return f"REFRESH {kind}{this}"
5458
5459    def toarray_sql(self, expression: exp.ToArray) -> str:
5460        arg = expression.this
5461        if not arg.type:
5462            import sqlglot.optimizer.annotate_types
5463
5464            arg = sqlglot.optimizer.annotate_types.annotate_types(arg, dialect=self.dialect)
5465
5466        if arg.is_type(exp.DType.ARRAY):
5467            return self.sql(arg)
5468
5469        cond_for_null = arg.is_(exp.null())
5470        return self.sql(exp.func("IF", cond_for_null, exp.null(), exp.array(arg, copy=False)))
5471
5472    def tsordstotime_sql(self, expression: exp.TsOrDsToTime) -> str:
5473        this = expression.this
5474        time_format = self.format_time(expression)
5475
5476        if time_format:
5477            return self.sql(
5478                exp.cast(
5479                    exp.StrToTime(this=this, format=expression.args["format"]),
5480                    exp.DType.TIME,
5481                )
5482            )
5483
5484        if isinstance(this, exp.TsOrDsToTime) or this.is_type(exp.DType.TIME):
5485            return self.sql(this)
5486
5487        return self.sql(exp.cast(this, exp.DType.TIME))
5488
5489    def tsordstotimestamp_sql(self, expression: exp.TsOrDsToTimestamp) -> str:
5490        this = expression.this
5491        if isinstance(this, exp.TsOrDsToTimestamp) or this.is_type(exp.DType.TIMESTAMP):
5492            return self.sql(this)
5493
5494        return self.sql(exp.cast(this, exp.DType.TIMESTAMP, dialect=self.dialect))
5495
5496    def tsordstodatetime_sql(self, expression: exp.TsOrDsToDatetime) -> str:
5497        this = expression.this
5498        if isinstance(this, exp.TsOrDsToDatetime) or this.is_type(exp.DType.DATETIME):
5499            return self.sql(this)
5500
5501        return self.sql(exp.cast(this, exp.DType.DATETIME, dialect=self.dialect))
5502
5503    def tsordstodate_sql(self, expression: exp.TsOrDsToDate) -> str:
5504        this = expression.this
5505        time_format = self.format_time(expression)
5506        safe = expression.args.get("safe")
5507        if time_format and time_format not in (self.dialect.TIME_FORMAT, self.dialect.DATE_FORMAT):
5508            return self.sql(
5509                exp.cast(
5510                    exp.StrToTime(this=this, format=expression.args["format"], safe=safe),
5511                    exp.DType.DATE,
5512                )
5513            )
5514
5515        if isinstance(this, exp.TsOrDsToDate) or this.is_type(exp.DType.DATE):
5516            return self.sql(this)
5517
5518        if safe:
5519            return self.sql(exp.TryCast(this=this, to=exp.DataType(this=exp.DType.DATE)))
5520
5521        return self.sql(exp.cast(this, exp.DType.DATE))
5522
5523    def unixdate_sql(self, expression: exp.UnixDate) -> str:
5524        return self.sql(
5525            exp.func(
5526                "DATEDIFF",
5527                expression.this,
5528                exp.cast(exp.Literal.string("1970-01-01"), exp.DType.DATE),
5529                "day",
5530            )
5531        )
5532
5533    def lastday_sql(self, expression: exp.LastDay) -> str:
5534        if self.LAST_DAY_SUPPORTS_DATE_PART:
5535            return self.function_fallback_sql(expression)
5536
5537        unit = expression.args.get("unit")
5538        if unit and unit.name.upper() != "MONTH":
5539            self.unsupported("Date parts are not supported in LAST_DAY.")
5540
5541        return self.func("LAST_DAY", expression.this)
5542
5543    def dateadd_sql(self, expression: exp.DateAdd) -> str:
5544        import sqlglot.dialects.dialect
5545
5546        return self.func(
5547            "DATE_ADD",
5548            expression.this,
5549            expression.expression,
5550            sqlglot.dialects.dialect.unit_to_str(expression),
5551        )
5552
5553    def arrayinsert_sql(self, expression: exp.ArrayInsert, index_offset: int = 0) -> str:
5554        this = expression.this
5555        position = expression.args["position"]
5556        offset = index_offset - (expression.args.get("offset") or 0)
5557
5558        if offset:
5559            if position.is_int:
5560                value = position.to_py()
5561                if value >= 0:
5562                    position = exp.Literal.number(value + offset)
5563                elif offset < 0 and value == -1:
5564                    # 1-based -1 appends, which a 0-based position can only express as the size
5565                    position = exp.ArraySize(this=this.copy())
5566                else:
5567                    # Negative positions count from the end, so they shift in the opposite
5568                    # direction, e.g. 0-based -1 (before the last element) is 1-based -2
5569                    position = exp.Literal.number(value - offset)
5570            else:
5571                self.unsupported("ARRAY_INSERT position can only be converted if it's a literal")
5572
5573        return self.func("ARRAY_INSERT", this, position, expression.expression)
5574
5575    def arrayany_sql(self, expression: exp.ArrayAny) -> str:
5576        if self.CAN_IMPLEMENT_ARRAY_ANY:
5577            filtered = exp.ArrayFilter(this=expression.this, expression=expression.expression)
5578            filtered_not_empty = exp.ArraySize(this=filtered).neq(0)
5579            original_is_empty = exp.ArraySize(this=expression.this).eq(0)
5580            return self.sql(exp.paren(original_is_empty.or_(filtered_not_empty)))
5581
5582        import sqlglot.dialects.dialect
5583
5584        # SQLGlot's executor supports ARRAY_ANY, so we don't wanna warn for the SQLGlot dialect
5585        if self.dialect.__class__ != sqlglot.dialects.dialect.Dialect:
5586            self.unsupported("ARRAY_ANY is unsupported")
5587
5588        return self.function_fallback_sql(expression)
5589
5590    def struct_sql(self, expression: exp.Struct) -> str:
5591        expression.set(
5592            "expressions",
5593            [
5594                exp.alias_(e.expression, e.name if e.this.is_string else e.this)
5595                if isinstance(e, exp.PropertyEQ)
5596                else e
5597                for e in expression.expressions
5598            ],
5599        )
5600
5601        return self.function_fallback_sql(expression)
5602
5603    def partitionrange_sql(self, expression: exp.PartitionRange) -> str:
5604        low = self.sql(expression, "this")
5605        high = self.sql(expression, "expression")
5606
5607        return f"{low} TO {high}"
5608
5609    def truncatetable_sql(self, expression: exp.TruncateTable) -> str:
5610        target = "DATABASE" if expression.args.get("is_database") else "TABLE"
5611        tables = f" {self.expressions(expression)}"
5612
5613        exists = " IF EXISTS" if expression.args.get("exists") else ""
5614
5615        on_cluster = self.sql(expression, "cluster")
5616        on_cluster = f" {on_cluster}" if on_cluster else ""
5617
5618        identity = self.sql(expression, "identity")
5619        identity = f" {identity} IDENTITY" if identity else ""
5620
5621        option = self.sql(expression, "option")
5622        option = f" {option}" if option else ""
5623
5624        partition = self.sql(expression, "partition")
5625        partition = f" {partition}" if partition else ""
5626
5627        return f"TRUNCATE {target}{exists}{tables}{on_cluster}{identity}{option}{partition}"
5628
5629    # This transpiles T-SQL's CONVERT function
5630    # https://learn.microsoft.com/en-us/sql/t-sql/functions/cast-and-convert-transact-sql?view=sql-server-ver16
5631    def convert_sql(self, expression: exp.Convert) -> str:
5632        to = expression.this
5633        value = expression.expression
5634        style = expression.args.get("style")
5635        safe = expression.args.get("safe")
5636        strict = expression.args.get("strict")
5637
5638        if not to or not value:
5639            return ""
5640
5641        # Retrieve length of datatype and override to default if not specified
5642        if not seq_get(to.expressions, 0) and to.this in self.PARAMETERIZABLE_TEXT_TYPES:
5643            to = exp.DataType.build(to.this, expressions=[exp.Literal.number(30)], nested=False)
5644
5645        transformed: exp.Expr | None = None
5646        cast = exp.Cast if strict else exp.TryCast
5647
5648        # Check whether a conversion with format (T-SQL calls this 'style') is applicable
5649        if isinstance(style, exp.Literal) and style.is_int:
5650            import sqlglot.dialects.tsql
5651
5652            style_value = style.name
5653            converted_style = sqlglot.dialects.tsql.TSQL.CONVERT_FORMAT_MAPPING.get(style_value)
5654            if not converted_style:
5655                self.unsupported(f"Unsupported T-SQL 'style' value: {style_value}")
5656
5657            fmt = exp.Literal.string(converted_style)
5658
5659            if to.this == exp.DType.DATE:
5660                transformed = exp.StrToDate(this=value, format=fmt)
5661            elif to.this in (exp.DType.DATETIME, exp.DType.DATETIME2):
5662                transformed = exp.StrToTime(this=value, format=fmt)
5663            elif to.this in self.PARAMETERIZABLE_TEXT_TYPES:
5664                transformed = cast(this=exp.TimeToStr(this=value, format=fmt), to=to, safe=safe)
5665            elif to.this == exp.DType.TEXT:
5666                transformed = exp.TimeToStr(this=value, format=fmt)
5667
5668        if not transformed:
5669            transformed = cast(this=value, to=to, safe=safe)
5670
5671        return self.sql(transformed)
5672
5673    def _jsonpathkey_sql(self, expression: exp.JSONPathKey) -> str:
5674        this = expression.this
5675        if isinstance(this, exp.JSONPathWildcard):
5676            this = self.json_path_part(this)
5677            return f".{this}" if this else ""
5678
5679        quoted = expression.args.get("quoted")
5680        if not (
5681            quoted and self.JSON_PATH_KEY_QUOTED_FORCES_BRACKETS
5682        ) and self.SAFE_JSON_PATH_KEY_RE.match(this):
5683            return f".{this}"
5684
5685        this = self.json_path_part(this)
5686
5687        return (
5688            f"[{this}]"
5689            if self._quote_json_path_key_using_brackets and self.JSON_PATH_BRACKETED_KEY_SUPPORTED
5690            else f".{this}"
5691        )
5692
5693    def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str:
5694        this = self.json_path_part(expression.this)
5695        return f"[{this}]" if this else ""
5696
5697    def _simplify_unless_literal(self, expression: E) -> E:
5698        if not isinstance(expression, exp.Literal):
5699            import sqlglot.optimizer.simplify
5700
5701            expression = sqlglot.optimizer.simplify.simplify(expression, dialect=self.dialect)
5702
5703        return expression
5704
5705    def _embed_ignore_nulls(self, expression: exp.IgnoreNulls | exp.RespectNulls, text: str) -> str:
5706        this = expression.this
5707        if isinstance(this, self.RESPECT_IGNORE_NULLS_UNSUPPORTED_EXPRESSIONS):
5708            self.unsupported(
5709                f"RESPECT/IGNORE NULLS is not supported for {type(this).key} in {self.dialect.__class__.__name__}"
5710            )
5711            return self.sql(this)
5712
5713        if self.IGNORE_NULLS_IN_FUNC and not expression.meta_get("inline"):
5714            if self.IGNORE_NULLS_BEFORE_ORDER:
5715                from sqlglot.optimizer.scope import find_all_in_scope
5716
5717                # The first modifier here will be the one closest to the AggFunc's arg
5718                mods = sorted(
5719                    find_all_in_scope(expression, exp.HavingMax, exp.Order, exp.Limit),
5720                    key=lambda x: (
5721                        0
5722                        if isinstance(x, exp.HavingMax)
5723                        else (1 if isinstance(x, exp.Order) else 2)
5724                    ),
5725                )
5726
5727                if mods:
5728                    mod = mods[0]
5729                    this = expression.__class__(this=mod.this.copy())
5730                    this.meta["inline"] = True
5731                    mod.this.replace(this)
5732                    return self.sql(expression.this)
5733
5734            agg_func = expression.find(exp.AggFunc)
5735
5736            if agg_func:
5737                agg_func_sql = self.sql(agg_func, comment=False)[:-1] + f" {text})"
5738                return self.maybe_comment(agg_func_sql, comments=agg_func.comments)
5739
5740        return f"{self.sql(expression, 'this')} {text}"
5741
5742    def _replace_line_breaks(self, string: str) -> str:
5743        """We don't want to extra indent line breaks so we temporarily replace them with sentinels."""
5744        if self.pretty:
5745            return string.replace("\n", self.SENTINEL_LINE_BREAK)
5746        return string
5747
5748    def copyparameter_sql(self, expression: exp.CopyParameter) -> str:
5749        option = self.sql(expression, "this")
5750
5751        if expression.expressions:
5752            upper = option.upper()
5753
5754            # Snowflake FILE_FORMAT options are separated by whitespace
5755            sep = " " if upper == "FILE_FORMAT" else ", "
5756
5757            # Databricks copy/format options do not set their list of values with EQ
5758            op = " " if upper in ("COPY_OPTIONS", "FORMAT_OPTIONS") else " = "
5759            values = self.expressions(expression, flat=True, sep=sep)
5760            return f"{option}{op}({values})"
5761
5762        value = self.sql(expression, "expression")
5763
5764        if not value:
5765            return option
5766
5767        op = " = " if self.COPY_PARAMS_EQ_REQUIRED else " "
5768
5769        return f"{option}{op}{value}"
5770
5771    def credentials_sql(self, expression: exp.Credentials) -> str:
5772        cred_expr = expression.args.get("credentials")
5773        if isinstance(cred_expr, exp.Literal):
5774            # Redshift case: CREDENTIALS <string>
5775            credentials = self.sql(expression, "credentials")
5776            credentials = f"CREDENTIALS {credentials}" if credentials else ""
5777        else:
5778            # Snowflake case: CREDENTIALS = (...)
5779            credentials = self.expressions(expression, key="credentials", flat=True, sep=" ")
5780            credentials = f"CREDENTIALS = ({credentials})" if cred_expr is not None else ""
5781
5782        storage = self.sql(expression, "storage")
5783        storage = f"STORAGE_INTEGRATION = {storage}" if storage else ""
5784
5785        encryption = self.expressions(expression, key="encryption", flat=True, sep=" ")
5786        encryption = f" ENCRYPTION = ({encryption})" if encryption else ""
5787
5788        iam_role = self.sql(expression, "iam_role")
5789        iam_role = f"IAM_ROLE {iam_role}" if iam_role else ""
5790
5791        region = self.sql(expression, "region")
5792        region = f" REGION {region}" if region else ""
5793
5794        return f"{credentials}{storage}{encryption}{iam_role}{region}"
5795
5796    def copy_sql(self, expression: exp.Copy) -> str:
5797        this = self.sql(expression, "this")
5798        this = f" INTO {this}" if self.COPY_HAS_INTO_KEYWORD else f" {this}"
5799
5800        credentials = self.sql(expression, "credentials")
5801        credentials = self.seg(credentials) if credentials else ""
5802        files = self.expressions(expression, key="files", flat=True)
5803        kind = self.seg("FROM" if expression.args.get("kind") else "TO") if files else ""
5804
5805        sep = ", " if self.dialect.COPY_PARAMS_ARE_CSV else " "
5806        params = self.expressions(
5807            expression,
5808            key="params",
5809            sep=sep,
5810            new_line=True,
5811            skip_last=True,
5812            skip_first=True,
5813            indent=self.COPY_PARAMS_ARE_WRAPPED,
5814        )
5815
5816        if params:
5817            if self.COPY_PARAMS_ARE_WRAPPED:
5818                params = f" WITH ({params})"
5819            elif not self.pretty and (files or credentials):
5820                params = f" {params}"
5821
5822        return f"COPY{this}{kind} {files}{credentials}{params}"
5823
5824    def semicolon_sql(self, expression: exp.Semicolon) -> str:
5825        return ""
5826
5827    def datadeletionproperty_sql(self, expression: exp.DataDeletionProperty) -> str:
5828        on_sql = "ON" if expression.args.get("on") else "OFF"
5829        filter_col: str | None = self.sql(expression, "filter_column")
5830        filter_col = f"FILTER_COLUMN={filter_col}" if filter_col else None
5831        retention_period: str | None = self.sql(expression, "retention_period")
5832        retention_period = f"RETENTION_PERIOD={retention_period}" if retention_period else None
5833
5834        if filter_col or retention_period:
5835            on_sql = self.func("ON", filter_col, retention_period)
5836
5837        return f"DATA_DELETION={on_sql}"
5838
5839    def maskingpolicycolumnconstraint_sql(
5840        self, expression: exp.MaskingPolicyColumnConstraint
5841    ) -> str:
5842        this = self.sql(expression, "this")
5843        expressions = self.expressions(expression, flat=True)
5844        expressions = f" USING ({expressions})" if expressions else ""
5845        return f"MASKING POLICY {this}{expressions}"
5846
5847    def gapfill_sql(self, expression: exp.GapFill) -> str:
5848        this = self.sql(expression, "this")
5849        this = f"TABLE {this}"
5850        return self.func("GAP_FILL", this, *[v for k, v in expression.args.items() if k != "this"])
5851
5852    def scope_resolution(self, rhs: str, scope_name: str) -> str:
5853        return self.func("SCOPE_RESOLUTION", scope_name or None, rhs)
5854
5855    def scoperesolution_sql(self, expression: exp.ScopeResolution) -> str:
5856        this = self.sql(expression, "this")
5857        expr = expression.expression
5858
5859        if isinstance(expr, exp.Func):
5860            # T-SQL's CLR functions are case sensitive
5861            expr = f"{self.sql(expr, 'this')}({self.format_args(*expr.expressions)})"
5862        else:
5863            expr = self.sql(expression, "expression")
5864
5865        return self.scope_resolution(expr, this)
5866
5867    def parsejson_sql(self, expression: exp.ParseJSON) -> str:
5868        if self.PARSE_JSON_NAME is None:
5869            return self.sql(expression.this)
5870
5871        return self.func(self.PARSE_JSON_NAME, expression.this, expression.expression)
5872
5873    def rand_sql(self, expression: exp.Rand) -> str:
5874        lower = self.sql(expression, "lower")
5875        upper = self.sql(expression, "upper")
5876
5877        if lower and upper:
5878            return f"({upper} - {lower}) * {self.func('RAND', expression.this)} + {lower}"
5879        return self.func("RAND", expression.this)
5880
5881    def changes_sql(self, expression: exp.Changes) -> str:
5882        information = self.sql(expression, "information")
5883        information = f"INFORMATION => {information}"
5884        at_before = self.sql(expression, "at_before")
5885        at_before = f"{self.seg('')}{at_before}" if at_before else ""
5886        end = self.sql(expression, "end")
5887        end = f"{self.seg('')}{end}" if end else ""
5888
5889        return f"CHANGES ({information}){at_before}{end}"
5890
5891    def pad_sql(self, expression: exp.Pad) -> str:
5892        prefix = "L" if expression.args.get("is_left") else "R"
5893
5894        fill_pattern = self.sql(expression, "fill_pattern") or None
5895        if not fill_pattern and self.PAD_FILL_PATTERN_IS_REQUIRED:
5896            fill_pattern = "' '"
5897
5898        return self.func(f"{prefix}PAD", expression.this, expression.expression, fill_pattern)
5899
5900    def summarize_sql(self, expression: exp.Summarize) -> str:
5901        table = " TABLE" if expression.args.get("table") else ""
5902        return f"SUMMARIZE{table} {self.sql(expression.this)}"
5903
5904    def explodinggenerateseries_sql(self, expression: exp.ExplodingGenerateSeries) -> str:
5905        generate_series = exp.GenerateSeries(**expression.args)
5906
5907        parent = expression.parent
5908        if isinstance(parent, (exp.Alias, exp.TableAlias)):
5909            parent = parent.parent
5910
5911        if self.SUPPORTS_EXPLODING_PROJECTIONS and not isinstance(parent, (exp.Table, exp.Unnest)):
5912            return self.sql(exp.Unnest(expressions=[generate_series]))
5913
5914        if isinstance(parent, exp.Select):
5915            self.unsupported("GenerateSeries projection unnesting is not supported.")
5916
5917        return self.sql(generate_series)
5918
5919    def converttimezone_sql(self, expression: exp.ConvertTimezone) -> str:
5920        if self.SUPPORTS_CONVERT_TIMEZONE:
5921            return self.function_fallback_sql(expression)
5922
5923        source_tz = expression.args.get("source_tz")
5924        target_tz = expression.args.get("target_tz")
5925        timestamp = expression.args.get("timestamp")
5926
5927        if source_tz and timestamp:
5928            timestamp = exp.AtTimeZone(
5929                this=exp.cast(timestamp, exp.DType.TIMESTAMPNTZ), zone=source_tz
5930            )
5931
5932        expr = exp.AtTimeZone(this=timestamp, zone=target_tz)
5933
5934        return self.sql(expr)
5935
5936    def json_sql(self, expression: exp.JSON) -> str:
5937        this = self.sql(expression, "this")
5938        this = f" {this}" if this else ""
5939
5940        _with = expression.args.get("with_")
5941
5942        if _with is None:
5943            with_sql = ""
5944        elif not _with:
5945            with_sql = " WITHOUT"
5946        else:
5947            with_sql = " WITH"
5948
5949        unique_sql = " UNIQUE KEYS" if expression.args.get("unique") else ""
5950
5951        return f"JSON{this}{with_sql}{unique_sql}"
5952
5953    def jsonvalue_sql(self, expression: exp.JSONValue) -> str:
5954        path = self.sql(expression, "path")
5955        returning = self.sql(expression, "returning")
5956        returning = f" RETURNING {returning}" if returning else ""
5957
5958        on_condition = self.sql(expression, "on_condition")
5959        on_condition = f" {on_condition}" if on_condition else ""
5960
5961        return self.func("JSON_VALUE", expression.this, f"{path}{returning}{on_condition}")
5962
5963    def skipjsoncolumn_sql(self, expression: exp.SkipJSONColumn) -> str:
5964        regexp = " REGEXP" if expression.args.get("regexp") else ""
5965        return f"SKIP{regexp} {self.sql(expression.expression)}"
5966
5967    def conditionalinsert_sql(self, expression: exp.ConditionalInsert) -> str:
5968        else_ = "ELSE " if expression.args.get("else_") else ""
5969        condition = self.sql(expression, "expression")
5970        condition = f"WHEN {condition} THEN " if condition else else_
5971        insert = self.sql(expression, "this")[len("INSERT") :].strip()
5972        return f"{condition}{insert}"
5973
5974    def multitableinserts_sql(self, expression: exp.MultitableInserts) -> str:
5975        kind = self.sql(expression, "kind")
5976        source = self.sql(expression, "source")
5977
5978        if kind:
5979            expressions = self.seg(self.expressions(expression, sep=" "))
5980            sql = f"INSERT {kind}{expressions}{self.seg(source)}"
5981        else:
5982            # If kind isn't present, we have Hive's FROM-first form:
5983            # FROM x INSERT ... SELECT ... [INSERT ... SELECT ...]
5984            inserts = self.sep().join(self.sql(e) for e in expression.expressions)
5985            sql = f"FROM {source}{self.seg(inserts)}"
5986
5987        return self.prepend_ctes(expression, sql)
5988
5989    def oncondition_sql(self, expression: exp.OnCondition) -> str:
5990        # Static options like "NULL ON ERROR" are stored as strings, in contrast to "DEFAULT <expr> ON ERROR"
5991        empty = expression.args.get("empty")
5992        empty = (
5993            f"DEFAULT {empty} ON EMPTY"
5994            if isinstance(empty, exp.Expr)
5995            else self.sql(expression, "empty")
5996        )
5997
5998        error = expression.args.get("error")
5999        error = (
6000            f"DEFAULT {error} ON ERROR"
6001            if isinstance(error, exp.Expr)
6002            else self.sql(expression, "error")
6003        )
6004
6005        if error and empty:
6006            error = (
6007                f"{empty} {error}"
6008                if self.dialect.ON_CONDITION_EMPTY_BEFORE_ERROR
6009                else f"{error} {empty}"
6010            )
6011            empty = ""
6012
6013        null = self.sql(expression, "null")
6014
6015        return f"{empty}{error}{null}"
6016
6017    def jsonextractquote_sql(self, expression: exp.JSONExtractQuote) -> str:
6018        scalar = " ON SCALAR STRING" if expression.args.get("scalar") else ""
6019        return f"{self.sql(expression, 'option')} QUOTES{scalar}"
6020
6021    def jsonexists_sql(self, expression: exp.JSONExists) -> str:
6022        this = self.sql(expression, "this")
6023        path = self.sql(expression, "path")
6024
6025        passing = self.expressions(expression, "passing")
6026        passing = f" PASSING {passing}" if passing else ""
6027
6028        on_condition = self.sql(expression, "on_condition")
6029        on_condition = f" {on_condition}" if on_condition else ""
6030
6031        path = f"{path}{passing}{on_condition}"
6032
6033        return self.func("JSON_EXISTS", this, path)
6034
6035    def _add_arrayagg_null_filter(
6036        self,
6037        array_agg_sql: str,
6038        array_agg_expr: exp.ArrayAgg,
6039        column_expr: exp.Expr,
6040    ) -> str:
6041        """
6042        Add NULL filter to ARRAY_AGG if dialect requires it.
6043
6044        Args:
6045            array_agg_sql: The generated ARRAY_AGG SQL string
6046            array_agg_expr: The ArrayAgg expression node
6047            column_expr: The column/expression to filter (before ORDER BY wrapping)
6048
6049        Returns:
6050            SQL string with FILTER clause added if needed
6051        """
6052        # Add a NULL FILTER on the column to mimic the results going from a dialect that excludes nulls
6053        # on ARRAY_AGG (e.g Spark) to one that doesn't (e.g. DuckDB)
6054        if not (
6055            self.dialect.ARRAY_AGG_INCLUDES_NULLS and array_agg_expr.args.get("nulls_excluded")
6056        ):
6057            return array_agg_sql
6058
6059        parent = array_agg_expr.parent
6060        if isinstance(parent, exp.Filter):
6061            parent_cond = parent.expression.this
6062            parent_cond.replace(parent_cond.and_(column_expr.is_(exp.null()).not_()))
6063        elif column_expr.find(exp.Column):
6064            # Do not add the filter if the input is not a column (e.g. literal, struct etc)
6065            # DISTINCT is already present in the agg function, do not propagate it to FILTER as well
6066            this_sql = (
6067                self.expressions(column_expr)
6068                if isinstance(column_expr, exp.Distinct)
6069                else self.sql(column_expr)
6070            )
6071            array_agg_sql = f"{array_agg_sql} FILTER(WHERE {this_sql} IS NOT NULL)"
6072
6073        return array_agg_sql
6074
6075    @unsupported_args("count")
6076    def min_sql(self, expression: exp.Min) -> str:
6077        return self.function_fallback_sql(expression)
6078
6079    @unsupported_args("count")
6080    def max_sql(self, expression: exp.Max) -> str:
6081        return self.function_fallback_sql(expression)
6082
6083    def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
6084        array_agg = self.function_fallback_sql(expression)
6085        column_expr = expression.this
6086        if isinstance(column_expr, exp.Order):
6087            column_expr = column_expr.this
6088
6089        return self._add_arrayagg_null_filter(array_agg, expression, column_expr)
6090
6091    def timeslice_sql(self, expression: exp.TimeSlice) -> str:
6092        # Only the SQLGlot dialect serializes the internal origin for round-tripping.
6093        origin = expression.args.get("origin") if self.dialect == "" else None
6094        kind = expression.args.get("kind")
6095        if origin is not None and kind is None:
6096            kind = exp.Literal.string("START")
6097
6098        return self.func(
6099            "TIME_SLICE", expression.this, expression.expression, expression.unit, kind, origin
6100        )
6101
6102    def slice_sql(self, expression: exp.Slice) -> str:
6103        if "[" in self.dialect.tokenizer_class._IDENTIFIERS:
6104            self.unsupported("Slices are not supported")
6105
6106        step = self.sql(expression, "step")
6107        # An omitted end is written as `-` before a step, since `::` is the cast operator
6108        end = self.sql(expression.expression) or ("-" if step else "")
6109        begin = self.sql(expression.this)
6110
6111        sql = f"{end}:{step}" if step else end
6112        return f"{begin}:{sql}" if sql else f"{begin}:"
6113
6114    def apply_sql(self, expression: exp.Apply) -> str:
6115        this = self.sql(expression, "this")
6116        expr = self.sql(expression, "expression")
6117
6118        return f"{this} APPLY({expr})"
6119
6120    def _grant_or_revoke_sql(
6121        self,
6122        expression: exp.Grant | exp.Revoke,
6123        keyword: str,
6124        preposition: str,
6125        grant_option_prefix: str = "",
6126        grant_option_suffix: str = "",
6127    ) -> str:
6128        privileges_sql = self.expressions(expression, key="privileges", flat=True)
6129
6130        kind = self.sql(expression, "kind")
6131        kind = f" {kind}" if kind else ""
6132
6133        securable = self.sql(expression, "securable")
6134        securable = f" {securable}" if securable else ""
6135
6136        principals = self.expressions(expression, key="principals", flat=True)
6137
6138        if not expression.args.get("grant_option"):
6139            grant_option_prefix = grant_option_suffix = ""
6140
6141        # cascade for revoke only
6142        cascade = self.sql(expression, "cascade")
6143        cascade = f" {cascade}" if cascade else ""
6144
6145        return f"{keyword} {grant_option_prefix}{privileges_sql} ON{kind}{securable} {preposition} {principals}{grant_option_suffix}{cascade}"
6146
6147    def grant_sql(self, expression: exp.Grant) -> str:
6148        return self._grant_or_revoke_sql(
6149            expression,
6150            keyword="GRANT",
6151            preposition="TO",
6152            grant_option_suffix=" WITH GRANT OPTION",
6153        )
6154
6155    def revoke_sql(self, expression: exp.Revoke) -> str:
6156        return self._grant_or_revoke_sql(
6157            expression,
6158            keyword="REVOKE",
6159            preposition="FROM",
6160            grant_option_prefix="GRANT OPTION FOR ",
6161        )
6162
6163    def grantprivilege_sql(self, expression: exp.GrantPrivilege) -> str:
6164        this = self.sql(expression, "this")
6165        columns = self.expressions(expression, flat=True)
6166        columns = f"({columns})" if columns else ""
6167
6168        return f"{this}{columns}"
6169
6170    def grantprincipal_sql(self, expression: exp.GrantPrincipal) -> str:
6171        this = self.sql(expression, "this")
6172
6173        kind = self.sql(expression, "kind")
6174        kind = f"{kind} " if kind else ""
6175
6176        return f"{kind}{this}"
6177
6178    def columns_sql(self, expression: exp.Columns) -> str:
6179        func = self.function_fallback_sql(expression)
6180        if expression.args.get("unpack"):
6181            func = f"*{func}"
6182
6183        return func
6184
6185    def overlay_sql(self, expression: exp.Overlay) -> str:
6186        this = self.sql(expression, "this")
6187        expr = self.sql(expression, "expression")
6188        from_sql = self.sql(expression, "from_")
6189        for_sql = self.sql(expression, "for_")
6190        for_sql = f" FOR {for_sql}" if for_sql else ""
6191
6192        return f"OVERLAY({this} PLACING {expr} FROM {from_sql}{for_sql})"
6193
6194    @unsupported_args("format")
6195    def todouble_sql(self, expression: exp.ToDouble) -> str:
6196        cast = exp.TryCast if expression.args.get("safe") else exp.Cast
6197        return self.sql(cast(this=expression.this, to=exp.DType.DOUBLE.into_expr()))
6198
6199    def string_sql(self, expression: exp.String) -> str:
6200        this = expression.this
6201        zone = expression.args.get("zone")
6202
6203        if zone:
6204            # This is a BigQuery specific argument for STRING(<timestamp_expr>, <time_zone>)
6205            # BigQuery stores timestamps internally as UTC, so ConvertTimezone is used with UTC
6206            # set for source_tz to transpile the time conversion before the STRING cast
6207            this = exp.ConvertTimezone(
6208                source_tz=exp.Literal.string("UTC"), target_tz=zone, timestamp=this
6209            )
6210
6211        return self.sql(exp.cast(this, exp.DType.VARCHAR))
6212
6213    def median_sql(self, expression: exp.Median) -> str:
6214        if not self.SUPPORTS_MEDIAN:
6215            return self.sql(
6216                exp.PercentileCont(this=expression.this, expression=exp.Literal.number(0.5))
6217            )
6218
6219        return self.function_fallback_sql(expression)
6220
6221    def overflowtruncatebehavior_sql(self, expression: exp.OverflowTruncateBehavior) -> str:
6222        filler = self.sql(expression, "this")
6223        filler = f" {filler}" if filler else ""
6224        with_count = "WITH COUNT" if expression.args.get("with_count") else "WITHOUT COUNT"
6225        return f"TRUNCATE{filler} {with_count}"
6226
6227    def unixseconds_sql(self, expression: exp.UnixSeconds) -> str:
6228        if self.SUPPORTS_UNIX_SECONDS:
6229            return self.function_fallback_sql(expression)
6230
6231        start_ts = exp.cast(exp.Literal.string("1970-01-01 00:00:00+00"), to=exp.DType.TIMESTAMPTZ)
6232
6233        return self.sql(
6234            exp.TimestampDiff(this=expression.this, expression=start_ts, unit=exp.var("SECONDS"))
6235        )
6236
6237    def arraysort_sql(self, expression: exp.ArraySort) -> str:
6238        asc = expression.args.get("asc")
6239        nulls_first = expression.args.get("nulls_first")
6240        if (asc and asc != exp.true()) or (nulls_first and nulls_first != exp.false()):
6241            self.unsupported("ARRAY_SORT only sorts ascending with NULLs last")
6242        return self.func("ARRAY_SORT", expression.this, expression.expression)
6243
6244    def arraysize_sql(self, expression: exp.ArraySize) -> str:
6245        dim = expression.expression
6246
6247        # For dialects that don't support the dimension arg, we can safely transpile it's default value (1st dimension)
6248        if dim and self.ARRAY_SIZE_DIM_REQUIRED is None:
6249            if not (dim.is_int and dim.name == "1"):
6250                self.unsupported("Cannot transpile dimension argument for ARRAY_LENGTH")
6251            dim = None
6252
6253        # If dimension is required but not specified, default initialize it
6254        if self.ARRAY_SIZE_DIM_REQUIRED and not dim:
6255            dim = exp.Literal.number(1)
6256
6257        return self.func(self.ARRAY_SIZE_NAME, expression.this, dim)
6258
6259    def attach_sql(self, expression: exp.Attach) -> str:
6260        this = self.sql(expression, "this")
6261        exists_sql = " IF NOT EXISTS" if expression.args.get("exists") else ""
6262        expressions = self.expressions(expression)
6263        expressions = f" ({expressions})" if expressions else ""
6264
6265        return f"ATTACH{exists_sql} {this}{expressions}"
6266
6267    def detach_sql(self, expression: exp.Detach) -> str:
6268        kind = self.sql(expression, "kind")
6269        kind = f" {kind}" if kind else ""
6270        # the DATABASE keyword is required if IF EXISTS is set for DuckDB
6271        # ref: https://duckdb.org/docs/stable/sql/statements/attach.html#detach-syntax
6272        exists = " IF EXISTS" if expression.args.get("exists") else ""
6273        if exists:
6274            kind = kind or " DATABASE"
6275
6276        this = self.sql(expression, "this")
6277        this = f" {this}" if this else ""
6278        cluster = self.sql(expression, "cluster")
6279        cluster = f" {cluster}" if cluster else ""
6280        permanent = " PERMANENTLY" if expression.args.get("permanent") else ""
6281        sync = " SYNC" if expression.args.get("sync") else ""
6282        return f"DETACH{kind}{exists}{this}{cluster}{permanent}{sync}"
6283
6284    def attachoption_sql(self, expression: exp.AttachOption) -> str:
6285        this = self.sql(expression, "this")
6286        value = self.sql(expression, "expression")
6287        value = f" {value}" if value else ""
6288        return f"{this}{value}"
6289
6290    def watermarkcolumnconstraint_sql(self, expression: exp.WatermarkColumnConstraint) -> str:
6291        return (
6292            f"WATERMARK FOR {self.sql(expression, 'this')} AS {self.sql(expression, 'expression')}"
6293        )
6294
6295    def encodeproperty_sql(self, expression: exp.EncodeProperty) -> str:
6296        encode = "KEY ENCODE" if expression.args.get("key") else "ENCODE"
6297        encode = f"{encode} {self.sql(expression, 'this')}"
6298
6299        properties = expression.args.get("properties")
6300        if properties:
6301            encode = f"{encode} {self.properties(properties)}"
6302
6303        return encode
6304
6305    def includeproperty_sql(self, expression: exp.IncludeProperty) -> str:
6306        this = self.sql(expression, "this")
6307        include = f"INCLUDE {this}"
6308
6309        column_def = self.sql(expression, "column_def")
6310        if column_def:
6311            include = f"{include} {column_def}"
6312
6313        alias = self.sql(expression, "alias")
6314        if alias:
6315            include = f"{include} AS {alias}"
6316
6317        return include
6318
6319    def xmlelement_sql(self, expression: exp.XMLElement) -> str:
6320        prefix = "EVALNAME" if expression.args.get("evalname") else "NAME"
6321        name = f"{prefix} {self.sql(expression, 'this')}"
6322        return self.func("XMLELEMENT", name, *expression.expressions)
6323
6324    def xmlkeyvalueoption_sql(self, expression: exp.XMLKeyValueOption) -> str:
6325        this = self.sql(expression, "this")
6326        expr = self.sql(expression, "expression")
6327        expr = f"({expr})" if expr else ""
6328        return f"{this}{expr}"
6329
6330    def partitionbyrangeproperty_sql(self, expression: exp.PartitionByRangeProperty) -> str:
6331        partitions = self.expressions(expression, "partition_expressions")
6332        create = self.expressions(expression, "create_expressions")
6333        return f"PARTITION BY RANGE {self.wrap(partitions)} {self.wrap(create)}"
6334
6335    def partitionbyrangepropertydynamic_sql(
6336        self, expression: exp.PartitionByRangePropertyDynamic
6337    ) -> str:
6338        start = self.sql(expression, "start")
6339        end = self.sql(expression, "end")
6340
6341        every = expression.args["every"]
6342        if isinstance(every, exp.Interval) and every.this.is_string:
6343            every.this.replace(exp.Literal.number(every.name))
6344
6345        return f"START {self.wrap(start)} END {self.wrap(end)} EVERY {self.wrap(self.sql(every))}"
6346
6347    def unpivotcolumns_sql(self, expression: exp.UnpivotColumns) -> str:
6348        name = self.sql(expression, "this")
6349        values = self.expressions(expression, flat=True)
6350
6351        return f"NAME {name} VALUE {values}"
6352
6353    def analyzesample_sql(self, expression: exp.AnalyzeSample) -> str:
6354        kind = self.sql(expression, "kind")
6355        sample = self.sql(expression, "sample")
6356        return f"SAMPLE {sample} {kind}"
6357
6358    def analyzestatistics_sql(self, expression: exp.AnalyzeStatistics) -> str:
6359        kind = self.sql(expression, "kind")
6360        option = self.sql(expression, "option")
6361        option = f" {option}" if option else ""
6362        this = self.sql(expression, "this")
6363        this = f" {this}" if this else ""
6364        columns = self.expressions(expression)
6365        columns = f" {columns}" if columns else ""
6366        return f"{kind}{option} STATISTICS{this}{columns}"
6367
6368    def analyzehistogram_sql(self, expression: exp.AnalyzeHistogram) -> str:
6369        this = self.sql(expression, "this")
6370        columns = self.expressions(expression)
6371        inner_expression = self.sql(expression, "expression")
6372        inner_expression = f" {inner_expression}" if inner_expression else ""
6373        update_options = self.sql(expression, "update_options")
6374        update_options = f" {update_options} UPDATE" if update_options else ""
6375        return f"{this} HISTOGRAM ON {columns}{inner_expression}{update_options}"
6376
6377    def analyzedelete_sql(self, expression: exp.AnalyzeDelete) -> str:
6378        kind = self.sql(expression, "kind")
6379        kind = f" {kind}" if kind else ""
6380        return f"DELETE{kind} STATISTICS"
6381
6382    def analyzelistchainedrows_sql(self, expression: exp.AnalyzeListChainedRows) -> str:
6383        inner_expression = self.sql(expression, "expression")
6384        return f"LIST CHAINED ROWS{inner_expression}"
6385
6386    def analyzevalidate_sql(self, expression: exp.AnalyzeValidate) -> str:
6387        kind = self.sql(expression, "kind")
6388        this = self.sql(expression, "this")
6389        this = f" {this}" if this else ""
6390        inner_expression = self.sql(expression, "expression")
6391        return f"VALIDATE {kind}{this}{inner_expression}"
6392
6393    def analyze_sql(self, expression: exp.Analyze) -> str:
6394        options = self.expressions(expression, key="options", sep=" ")
6395        options = f" {options}" if options else ""
6396        kind = self.sql(expression, "kind")
6397        kind = f" {kind}" if kind else ""
6398        tables = self.expressions(expression, key="tables", flat=True)
6399        tables = f" {tables}" if tables else ""
6400        mode = self.sql(expression, "mode")
6401        mode = f" {mode}" if mode else ""
6402        properties = self.sql(expression, "properties")
6403        properties = f" {properties}" if properties else ""
6404        partition = self.sql(expression, "partition")
6405        partition = f" {partition}" if partition else ""
6406        inner_expression = self.sql(expression, "expression")
6407        inner_expression = f" {inner_expression}" if inner_expression else ""
6408        return f"ANALYZE{options}{kind}{tables}{partition}{mode}{inner_expression}{properties}"
6409
6410    def xmltable_sql(self, expression: exp.XMLTable) -> str:
6411        this = self.sql(expression, "this")
6412        namespaces = self.expressions(expression, key="namespaces")
6413        namespaces = f"XMLNAMESPACES({namespaces}), " if namespaces else ""
6414        passing = self.expressions(expression, key="passing")
6415        passing = f"{self.sep()}PASSING{self.seg(passing)}" if passing else ""
6416        columns = self.expressions(expression, key="columns")
6417        columns = f"{self.sep()}COLUMNS{self.seg(columns)}" if columns else ""
6418        by_ref = f"{self.sep()}RETURNING SEQUENCE BY REF" if expression.args.get("by_ref") else ""
6419        return f"XMLTABLE({self.sep('')}{self.indent(namespaces + this + passing + by_ref + columns)}{self.seg(')', sep='')}"
6420
6421    def xmlnamespace_sql(self, expression: exp.XMLNamespace) -> str:
6422        this = self.sql(expression, "this")
6423        return this if isinstance(expression.this, exp.Alias) else f"DEFAULT {this}"
6424
6425    def export_sql(self, expression: exp.Export) -> str:
6426        this = self.sql(expression, "this")
6427        connection = self.sql(expression, "connection")
6428        connection = f"WITH CONNECTION {connection} " if connection else ""
6429        options = self.sql(expression, "options")
6430        return f"EXPORT DATA {connection}{options} AS {this}"
6431
6432    def declare_sql(self, expression: exp.Declare) -> str:
6433        replace = "OR REPLACE " if expression.args.get("replace") else ""
6434        return f"DECLARE {replace}{self.expressions(expression, flat=True)}"
6435
6436    def declareitem_sql(self, expression: exp.DeclareItem) -> str:
6437        variables = self.expressions(expression, "this")
6438        default = self.sql(expression, "default")
6439        default = f" {self.DECLARE_DEFAULT_ASSIGNMENT} {default}" if default else ""
6440
6441        kind = self.sql(expression, "kind")
6442        if isinstance(expression.args.get("kind"), exp.Schema):
6443            kind = f"TABLE {kind}"
6444
6445        kind = f" {kind}" if kind else ""
6446
6447        return f"{variables}{kind}{default}"
6448
6449    def recursivewithsearch_sql(self, expression: exp.RecursiveWithSearch) -> str:
6450        kind = self.sql(expression, "kind")
6451        this = self.sql(expression, "this")
6452        set = self.sql(expression, "expression")
6453        to = self.sql(expression, "to")
6454        to = f" TO {to}" if to else ""
6455        default = self.sql(expression, "default")
6456        default = f" DEFAULT {default}" if default else ""
6457        using = self.sql(expression, "using")
6458        using = f" USING {using}" if using else ""
6459
6460        kind_sql = kind if kind == "CYCLE" else f"SEARCH {kind} FIRST BY"
6461
6462        return f"{kind_sql} {this} SET {set}{to}{default}{using}"
6463
6464    def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
6465        params = self.expressions(expression, key="params", flat=True)
6466        return self.func(expression.name, *expression.expressions) + f"({params})"
6467
6468    def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
6469        return self.func(expression.name, *expression.expressions)
6470
6471    def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
6472        return self.anonymousaggfunc_sql(expression)
6473
6474    def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
6475        return self.parameterizedagg_sql(expression)
6476
6477    def show_sql(self, expression: exp.Show) -> str:
6478        self.unsupported("Unsupported SHOW statement")
6479        return ""
6480
6481    def install_sql(self, expression: exp.Install) -> str:
6482        self.unsupported("Unsupported INSTALL statement")
6483        return ""
6484
6485    def liststage_sql(self, expression: exp.ListStage) -> str:
6486        pattern = self.sql(expression, "pattern")
6487        pattern = f" PATTERN = {pattern}" if pattern else ""
6488        return f"LIST {self.sql(expression, 'this')}{pattern}"
6489
6490    def get_put_sql(self, expression: exp.Put | exp.Get) -> str:
6491        # Snowflake GET/PUT statements:
6492        #   PUT <file> <internalStage> <properties>
6493        #   GET <internalStage> <file> <properties>
6494        props = expression.args.get("properties")
6495        props_sql = self.properties(props, prefix=" ", sep=" ", wrapped=False) if props else ""
6496        this = self.sql(expression, "this")
6497        target = self.sql(expression, "target")
6498
6499        if isinstance(expression, exp.Put):
6500            return f"PUT {this} {target}{props_sql}"
6501        else:
6502            return f"GET {target} {this}{props_sql}"
6503
6504    def translatecharacters_sql(self, expression: exp.TranslateCharacters) -> str:
6505        this = self.sql(expression, "this")
6506        expr = self.sql(expression, "expression")
6507        with_error = " WITH ERROR" if expression.args.get("with_error") else ""
6508        return f"TRANSLATE({this} USING {expr}{with_error})"
6509
6510    def decodecase_sql(self, expression: exp.DecodeCase) -> str:
6511        if self.SUPPORTS_DECODE_CASE:
6512            return self.func("DECODE", *expression.expressions)
6513
6514        decode_expr, *expressions = expression.expressions
6515
6516        ifs = []
6517        for search, result in zip(expressions[::2], expressions[1::2]):
6518            if isinstance(search, exp.Literal):
6519                ifs.append(exp.If(this=decode_expr.eq(search), true=result))
6520            elif isinstance(search, exp.Null):
6521                ifs.append(exp.If(this=decode_expr.is_(exp.Null()), true=result))
6522            else:
6523                if isinstance(search, exp.Binary):
6524                    search = exp.paren(search)
6525
6526                cond = exp.or_(
6527                    decode_expr.eq(search),
6528                    exp.and_(decode_expr.is_(exp.Null()), search.is_(exp.Null()), copy=False),
6529                    copy=False,
6530                )
6531                ifs.append(exp.If(this=cond, true=result))
6532
6533        case = exp.Case(ifs=ifs, default=expressions[-1] if len(expressions) % 2 == 1 else None)
6534        return self.sql(case)
6535
6536    def semanticview_sql(self, expression: exp.SemanticView) -> str:
6537        this = self.sql(expression, "this")
6538        this = self.seg(this, sep="")
6539        dimensions = self.expressions(
6540            expression, "dimensions", dynamic=True, skip_first=True, skip_last=True
6541        )
6542        dimensions = self.seg(f"DIMENSIONS {dimensions}") if dimensions else ""
6543        metrics = self.expressions(
6544            expression, "metrics", dynamic=True, skip_first=True, skip_last=True
6545        )
6546        metrics = self.seg(f"METRICS {metrics}") if metrics else ""
6547        facts = self.expressions(expression, "facts", dynamic=True, skip_first=True, skip_last=True)
6548        facts = self.seg(f"FACTS {facts}") if facts else ""
6549        where = self.sql(expression, "where")
6550        where = self.seg(f"WHERE {where}") if where else ""
6551        body = self.indent(this + metrics + dimensions + facts + where, skip_first=True)
6552        return f"SEMANTIC_VIEW({body}{self.seg(')', sep='')}"
6553
6554    def getextract_sql(self, expression: exp.GetExtract) -> str:
6555        this = expression.this
6556        expr = expression.expression
6557
6558        if not this.type or not expression.type:
6559            import sqlglot.optimizer.annotate_types
6560
6561            this = sqlglot.optimizer.annotate_types.annotate_types(this, dialect=self.dialect)
6562
6563        if this.is_type(*(exp.DType.ARRAY, exp.DType.MAP)):
6564            return self.sql(exp.Bracket(this=this, expressions=[expr]))
6565
6566        return self.sql(exp.JSONExtract(this=this, expression=self.dialect.to_json_path(expr)))
6567
6568    def datefromunixdate_sql(self, expression: exp.DateFromUnixDate) -> str:
6569        return self.sql(
6570            exp.DateAdd(
6571                this=exp.cast(exp.Literal.string("1970-01-01"), exp.DType.DATE),
6572                expression=expression.this,
6573                unit=exp.var("DAY"),
6574            )
6575        )
6576
6577    def space_sql(self: Generator, expression: exp.Space) -> str:
6578        return self.sql(exp.Repeat(this=exp.Literal.string(" "), times=expression.this))
6579
6580    def buildproperty_sql(self, expression: exp.BuildProperty) -> str:
6581        return f"BUILD {self.sql(expression, 'this')}"
6582
6583    def refreshtriggerproperty_sql(self, expression: exp.RefreshTriggerProperty) -> str:
6584        method = self.sql(expression, "method")
6585        kind = expression.args.get("kind")
6586        if not kind:
6587            return f"REFRESH {method}"
6588
6589        every = self.sql(expression, "every")
6590        unit = self.sql(expression, "unit")
6591        every = f" EVERY {every} {unit}" if every else ""
6592        starts = self.sql(expression, "starts")
6593        starts = f" STARTS {starts}" if starts else ""
6594
6595        return f"REFRESH {method} ON {kind}{every}{starts}"
6596
6597    def modelattribute_sql(self, expression: exp.ModelAttribute) -> str:
6598        self.unsupported("The model!attribute syntax is not supported")
6599        return ""
6600
6601    def directorystage_sql(self, expression: exp.DirectoryStage) -> str:
6602        return self.func("DIRECTORY", expression.this)
6603
6604    def uuid_sql(self, expression: exp.Uuid) -> str:
6605        is_string = expression.args.get("is_string", False)
6606        uuid_func_sql = self.func("UUID")
6607
6608        if is_string and not self.dialect.UUID_IS_STRING_TYPE:
6609            return self.sql(exp.cast(uuid_func_sql, exp.DType.VARCHAR, dialect=self.dialect))
6610
6611        return uuid_func_sql
6612
6613    def initcap_sql(self, expression: exp.Initcap) -> str:
6614        delimiters = expression.expression
6615
6616        if delimiters:
6617            # do not generate delimiters arg if we are round-tripping from default delimiters
6618            if (
6619                delimiters.is_string
6620                and delimiters.this == self.dialect.INITCAP_DEFAULT_DELIMITER_CHARS
6621            ):
6622                delimiters = None
6623            elif not self.dialect.INITCAP_SUPPORTS_CUSTOM_DELIMITERS:
6624                self.unsupported("INITCAP does not support custom delimiters")
6625                delimiters = None
6626
6627        return self.func("INITCAP", expression.this, delimiters)
6628
6629    def localtime_sql(self, expression: exp.Localtime) -> str:
6630        this = expression.this
6631        return self.func("LOCALTIME", this) if this else "LOCALTIME"
6632
6633    def localtimestamp_sql(self, expression: exp.Localtimestamp) -> str:
6634        this = expression.this
6635        return self.func("LOCALTIMESTAMP", this) if this else "LOCALTIMESTAMP"
6636
6637    def weekstart_name(self, expression: exp.WeekStart) -> str:
6638        import sqlglot.dialects.dialect
6639
6640        # WEEK(<day>) is BigQuery-only syntax, so it degrades to the plain WEEK unit
6641        this = expression.this.name.upper()
6642
6643        dow_from_week_start_day = sqlglot.dialects.dialect.WEEK_START_DAY_TO_DOW.get(this)
6644        dow_from_week_offset = sqlglot.dialects.dialect.week_offset_to_dow(self.dialect.WEEK_OFFSET)
6645
6646        if dow_from_week_start_day != dow_from_week_offset:
6647            self.unsupported(
6648                f"WEEK({this}) is not supported; falling back to the default week start day"
6649            )
6650
6651        return "WEEK"
6652
6653    def weekstart_sql(self, expression: exp.WeekStart) -> str:
6654        name = self.weekstart_name(expression)
6655
6656        # DateTrunc stores string literal units, whereas TimeUnit expressions store keywords
6657        if isinstance(expression.parent, exp.DateTrunc):
6658            return self.sql(exp.Literal.string(name))
6659
6660        return name
6661
6662    def chr_sql(self, expression: exp.Chr, name: str = "CHR") -> str:
6663        this = self.expressions(expression)
6664        charset = self.sql(expression, "charset")
6665        using = f" USING {charset}" if charset else ""
6666        return self.func(name, this + using)
6667
6668    def weightstring_sql(self, expression: exp.WeightString) -> str:
6669        to = self.sql(expression, "to")
6670        to = f" AS {to}" if to else ""
6671        return self.func("WEIGHT_STRING", f"{self.sql(expression, 'this')}{to}")
6672
6673    def block_sql(self, expression: exp.Block) -> str:
6674        expressions = self.expressions(expression, sep="; ", flat=True)
6675        begin = "BEGIN " if expression.args.get("begin") else ""
6676        return f"{begin}{expressions}" if expressions else ""
6677
6678    def functionspecification_sql(self, expression: exp.FunctionSpecification) -> str:
6679        self.unsupported("Unsupported Inline UDFs syntax")
6680        return ""
6681
6682    def storedprocedure_sql(self, expression: exp.StoredProcedure) -> str:
6683        self.unsupported("Unsupported Stored Procedure syntax")
6684        return ""
6685
6686    def ifblock_sql(self, expression: exp.IfBlock) -> str:
6687        self.unsupported("Unsupported If block syntax")
6688        return ""
6689
6690    def casestatement_sql(self, expression: exp.CaseStatement) -> str:
6691        self.unsupported("Unsupported Case statement syntax")
6692        return ""
6693
6694    def whileblock_sql(self, expression: exp.WhileBlock) -> str:
6695        self.unsupported("Unsupported While block syntax")
6696        return ""
6697
6698    def loopblock_sql(self, expression: exp.LoopBlock) -> str:
6699        self.unsupported("Unsupported Loop block syntax")
6700        return ""
6701
6702    def repeatblock_sql(self, expression: exp.RepeatBlock) -> str:
6703        self.unsupported("Unsupported Repeat block syntax")
6704        return ""
6705
6706    def leave_sql(self, expression: exp.Leave) -> str:
6707        self.unsupported("Unsupported Leave syntax")
6708        return ""
6709
6710    def iterate_sql(self, expression: exp.Iterate) -> str:
6711        self.unsupported("Unsupported Iterate syntax")
6712        return ""
6713
6714    def execute_sql(self, expression: exp.Execute) -> str:
6715        self.unsupported("Unsupported Execute syntax")
6716        return ""
6717
6718    def executesql_sql(self, expression: exp.ExecuteSql) -> str:
6719        self.unsupported("Unsupported Execute syntax")
6720        return ""
6721
6722    def altermodifysqlsecurity_sql(self, expression: exp.AlterModifySqlSecurity) -> str:
6723        props = self.expressions(expression, sep=" ")
6724        return f"MODIFY {props}"
6725
6726    def usingproperty_sql(self, expression: exp.UsingProperty) -> str:
6727        kind = expression.args.get("kind")
6728        return f"USING {kind} {self.sql(expression, 'this')}"
6729
6730    def renameindex_sql(self, expression: exp.RenameIndex) -> str:
6731        this = self.sql(expression, "this")
6732        to = self.sql(expression, "to")
6733        return f"RENAME INDEX {this} TO {to}"