sqlglot.generator

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