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