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