sqlglot.generator

   1from __future__ import annotations
   2
   3import logging
   4import typing as t
   5
   6from sqlglot import exp
   7from sqlglot.errors import ErrorLevel, UnsupportedError, concat_messages
   8from sqlglot.helper import apply_index_offset, csv, seq_get
   9from sqlglot.time import format_time
  10from sqlglot.tokens import TokenType
  11
  12logger = logging.getLogger("sqlglot")
  13
  14
  15class Generator:
  16    """
  17    Generator interprets the given syntax tree and produces a SQL string as an output.
  18
  19    Args:
  20        time_mapping (dict): the dictionary of custom time mappings in which the key
  21            represents a python time format and the output the target time format
  22        time_trie (trie): a trie of the time_mapping keys
  23        pretty (bool): if set to True the returned string will be formatted. Default: False.
  24        quote_start (str): specifies which starting character to use to delimit quotes. Default: '.
  25        quote_end (str): specifies which ending character to use to delimit quotes. Default: '.
  26        identifier_start (str): specifies which starting character to use to delimit identifiers. Default: ".
  27        identifier_end (str): specifies which ending character to use to delimit identifiers. Default: ".
  28        identify (bool): if set to True all identifiers will be delimited by the corresponding
  29            character.
  30        normalize (bool): if set to True all identifiers will lower cased
  31        string_escape (str): specifies a string escape character. Default: '.
  32        identifier_escape (str): specifies an identifier escape character. Default: ".
  33        pad (int): determines padding in a formatted string. Default: 2.
  34        indent (int): determines the size of indentation in a formatted string. Default: 4.
  35        unnest_column_only (bool): if true unnest table aliases are considered only as column aliases
  36        normalize_functions (str): normalize function names, "upper", "lower", or None
  37            Default: "upper"
  38        alias_post_tablesample (bool): if the table alias comes after tablesample
  39            Default: False
  40        unsupported_level (ErrorLevel): determines the generator's behavior when it encounters
  41            unsupported expressions. Default ErrorLevel.WARN.
  42        null_ordering (str): Indicates the default null ordering method to use if not explicitly set.
  43            Options are "nulls_are_small", "nulls_are_large", "nulls_are_last".
  44            Default: "nulls_are_small"
  45        max_unsupported (int): Maximum number of unsupported messages to include in a raised UnsupportedError.
  46            This is only relevant if unsupported_level is ErrorLevel.RAISE.
  47            Default: 3
  48        leading_comma (bool): if the the comma is leading or trailing in select statements
  49            Default: False
  50        max_text_width: The max number of characters in a segment before creating new lines in pretty mode.
  51            The default is on the smaller end because the length only represents a segment and not the true
  52            line length.
  53            Default: 80
  54        comments: Whether or not to preserve comments in the output SQL code.
  55            Default: True
  56    """
  57
  58    TRANSFORMS = {
  59        exp.DateAdd: lambda self, e: self.func(
  60            "DATE_ADD", e.this, e.expression, e.args.get("unit")
  61        ),
  62        exp.TsOrDsAdd: lambda self, e: self.func(
  63            "TS_OR_DS_ADD", e.this, e.expression, e.args.get("unit")
  64        ),
  65        exp.VarMap: lambda self, e: self.func("MAP", e.args["keys"], e.args["values"]),
  66        exp.CharacterSetProperty: lambda self, e: f"{'DEFAULT ' if e.args.get('default') else ''}CHARACTER SET={self.sql(e, 'this')}",
  67        exp.ExecuteAsProperty: lambda self, e: self.naked_property(e),
  68        exp.ExternalProperty: lambda self, e: "EXTERNAL",
  69        exp.LanguageProperty: lambda self, e: self.naked_property(e),
  70        exp.LocationProperty: lambda self, e: self.naked_property(e),
  71        exp.LogProperty: lambda self, e: f"{'NO ' if e.args.get('no') else ''}LOG",
  72        exp.MaterializedProperty: lambda self, e: "MATERIALIZED",
  73        exp.NoPrimaryIndexProperty: lambda self, e: "NO PRIMARY INDEX",
  74        exp.OnCommitProperty: lambda self, e: "ON COMMIT PRESERVE ROWS",
  75        exp.ReturnsProperty: lambda self, e: self.naked_property(e),
  76        exp.SetProperty: lambda self, e: f"{'MULTI' if e.args.get('multi') else ''}SET",
  77        exp.SqlSecurityProperty: lambda self, e: f"SQL SECURITY {'DEFINER' if e.args.get('definer') else 'INVOKER'}",
  78        exp.TemporaryProperty: lambda self, e: f"{'GLOBAL ' if e.args.get('global_') else ''}TEMPORARY",
  79        exp.TransientProperty: lambda self, e: "TRANSIENT",
  80        exp.VolatilityProperty: lambda self, e: e.name,
  81        exp.WithJournalTableProperty: lambda self, e: f"WITH JOURNAL TABLE={self.sql(e, 'this')}",
  82        exp.CaseSpecificColumnConstraint: lambda self, e: f"{'NOT ' if e.args.get('not_') else ''}CASESPECIFIC",
  83        exp.CharacterSetColumnConstraint: lambda self, e: f"CHARACTER SET {self.sql(e, 'this')}",
  84        exp.DateFormatColumnConstraint: lambda self, e: f"FORMAT {self.sql(e, 'this')}",
  85        exp.UppercaseColumnConstraint: lambda self, e: f"UPPERCASE",
  86        exp.TitleColumnConstraint: lambda self, e: f"TITLE {self.sql(e, 'this')}",
  87        exp.PathColumnConstraint: lambda self, e: f"PATH {self.sql(e, 'this')}",
  88        exp.CheckColumnConstraint: lambda self, e: f"CHECK ({self.sql(e, 'this')})",
  89        exp.CommentColumnConstraint: lambda self, e: f"COMMENT {self.sql(e, 'this')}",
  90        exp.CollateColumnConstraint: lambda self, e: f"COLLATE {self.sql(e, 'this')}",
  91        exp.EncodeColumnConstraint: lambda self, e: f"ENCODE {self.sql(e, 'this')}",
  92        exp.DefaultColumnConstraint: lambda self, e: f"DEFAULT {self.sql(e, 'this')}",
  93        exp.InlineLengthColumnConstraint: lambda self, e: f"INLINE LENGTH {self.sql(e, 'this')}",
  94    }
  95
  96    # Whether or not null ordering is supported in order by
  97    NULL_ORDERING_SUPPORTED = True
  98
  99    # Whether or not locking reads (i.e. SELECT ... FOR UPDATE/SHARE) are supported
 100    LOCKING_READS_SUPPORTED = False
 101
 102    # Always do union distinct or union all
 103    EXPLICIT_UNION = False
 104
 105    # Wrap derived values in parens, usually standard but spark doesn't support it
 106    WRAP_DERIVED_VALUES = True
 107
 108    # Whether or not create function uses an AS before the RETURN
 109    CREATE_FUNCTION_RETURN_AS = True
 110
 111    # Whether or not to treat the division operator "/" as integer division
 112    INTEGER_DIVISION = True
 113
 114    # Whether or not MERGE ... WHEN MATCHED BY SOURCE is allowed
 115    MATCHED_BY_SOURCE = True
 116
 117    TYPE_MAPPING = {
 118        exp.DataType.Type.NCHAR: "CHAR",
 119        exp.DataType.Type.NVARCHAR: "VARCHAR",
 120        exp.DataType.Type.MEDIUMTEXT: "TEXT",
 121        exp.DataType.Type.LONGTEXT: "TEXT",
 122        exp.DataType.Type.MEDIUMBLOB: "BLOB",
 123        exp.DataType.Type.LONGBLOB: "BLOB",
 124        exp.DataType.Type.INET: "INET",
 125    }
 126
 127    STAR_MAPPING = {
 128        "except": "EXCEPT",
 129        "replace": "REPLACE",
 130    }
 131
 132    TOKEN_MAPPING: t.Dict[TokenType, str] = {}
 133
 134    STRUCT_DELIMITER = ("<", ">")
 135
 136    PARAMETER_TOKEN = "@"
 137
 138    PROPERTIES_LOCATION = {
 139        exp.AfterJournalProperty: exp.Properties.Location.POST_NAME,
 140        exp.AlgorithmProperty: exp.Properties.Location.POST_CREATE,
 141        exp.AutoIncrementProperty: exp.Properties.Location.POST_SCHEMA,
 142        exp.BlockCompressionProperty: exp.Properties.Location.POST_NAME,
 143        exp.CharacterSetProperty: exp.Properties.Location.POST_SCHEMA,
 144        exp.ChecksumProperty: exp.Properties.Location.POST_NAME,
 145        exp.CollateProperty: exp.Properties.Location.POST_SCHEMA,
 146        exp.Cluster: exp.Properties.Location.POST_SCHEMA,
 147        exp.DataBlocksizeProperty: exp.Properties.Location.POST_NAME,
 148        exp.DefinerProperty: exp.Properties.Location.POST_CREATE,
 149        exp.DistKeyProperty: exp.Properties.Location.POST_SCHEMA,
 150        exp.DistStyleProperty: exp.Properties.Location.POST_SCHEMA,
 151        exp.EngineProperty: exp.Properties.Location.POST_SCHEMA,
 152        exp.ExecuteAsProperty: exp.Properties.Location.POST_SCHEMA,
 153        exp.ExternalProperty: exp.Properties.Location.POST_CREATE,
 154        exp.FallbackProperty: exp.Properties.Location.POST_NAME,
 155        exp.FileFormatProperty: exp.Properties.Location.POST_WITH,
 156        exp.FreespaceProperty: exp.Properties.Location.POST_NAME,
 157        exp.IsolatedLoadingProperty: exp.Properties.Location.POST_NAME,
 158        exp.JournalProperty: exp.Properties.Location.POST_NAME,
 159        exp.LanguageProperty: exp.Properties.Location.POST_SCHEMA,
 160        exp.LikeProperty: exp.Properties.Location.POST_SCHEMA,
 161        exp.LocationProperty: exp.Properties.Location.POST_SCHEMA,
 162        exp.LockingProperty: exp.Properties.Location.POST_ALIAS,
 163        exp.LogProperty: exp.Properties.Location.POST_NAME,
 164        exp.MaterializedProperty: exp.Properties.Location.POST_CREATE,
 165        exp.MergeBlockRatioProperty: exp.Properties.Location.POST_NAME,
 166        exp.NoPrimaryIndexProperty: exp.Properties.Location.POST_EXPRESSION,
 167        exp.OnCommitProperty: exp.Properties.Location.POST_EXPRESSION,
 168        exp.PartitionedByProperty: exp.Properties.Location.POST_WITH,
 169        exp.Property: exp.Properties.Location.POST_WITH,
 170        exp.ReturnsProperty: exp.Properties.Location.POST_SCHEMA,
 171        exp.RowFormatDelimitedProperty: exp.Properties.Location.POST_SCHEMA,
 172        exp.RowFormatSerdeProperty: exp.Properties.Location.POST_SCHEMA,
 173        exp.SchemaCommentProperty: exp.Properties.Location.POST_SCHEMA,
 174        exp.SerdeProperties: exp.Properties.Location.POST_SCHEMA,
 175        exp.SetProperty: exp.Properties.Location.POST_CREATE,
 176        exp.SortKeyProperty: exp.Properties.Location.POST_SCHEMA,
 177        exp.SqlSecurityProperty: exp.Properties.Location.POST_CREATE,
 178        exp.TableFormatProperty: exp.Properties.Location.POST_WITH,
 179        exp.TemporaryProperty: exp.Properties.Location.POST_CREATE,
 180        exp.TransientProperty: exp.Properties.Location.POST_CREATE,
 181        exp.VolatilityProperty: exp.Properties.Location.POST_SCHEMA,
 182        exp.WithDataProperty: exp.Properties.Location.POST_EXPRESSION,
 183        exp.WithJournalTableProperty: exp.Properties.Location.POST_NAME,
 184    }
 185
 186    WITH_SEPARATED_COMMENTS = (exp.Select, exp.From, exp.Where, exp.Binary)
 187    SENTINEL_LINE_BREAK = "__SQLGLOT__LB__"
 188
 189    __slots__ = (
 190        "time_mapping",
 191        "time_trie",
 192        "pretty",
 193        "quote_start",
 194        "quote_end",
 195        "identifier_start",
 196        "identifier_end",
 197        "identify",
 198        "normalize",
 199        "string_escape",
 200        "identifier_escape",
 201        "pad",
 202        "index_offset",
 203        "unnest_column_only",
 204        "alias_post_tablesample",
 205        "normalize_functions",
 206        "unsupported_level",
 207        "unsupported_messages",
 208        "null_ordering",
 209        "max_unsupported",
 210        "_indent",
 211        "_escaped_quote_end",
 212        "_escaped_identifier_end",
 213        "_leading_comma",
 214        "_max_text_width",
 215        "_comments",
 216    )
 217
 218    def __init__(
 219        self,
 220        time_mapping=None,
 221        time_trie=None,
 222        pretty=None,
 223        quote_start=None,
 224        quote_end=None,
 225        identifier_start=None,
 226        identifier_end=None,
 227        identify=False,
 228        normalize=False,
 229        string_escape=None,
 230        identifier_escape=None,
 231        pad=2,
 232        indent=2,
 233        index_offset=0,
 234        unnest_column_only=False,
 235        alias_post_tablesample=False,
 236        normalize_functions="upper",
 237        unsupported_level=ErrorLevel.WARN,
 238        null_ordering=None,
 239        max_unsupported=3,
 240        leading_comma=False,
 241        max_text_width=80,
 242        comments=True,
 243    ):
 244        import sqlglot
 245
 246        self.time_mapping = time_mapping or {}
 247        self.time_trie = time_trie
 248        self.pretty = pretty if pretty is not None else sqlglot.pretty
 249        self.quote_start = quote_start or "'"
 250        self.quote_end = quote_end or "'"
 251        self.identifier_start = identifier_start or '"'
 252        self.identifier_end = identifier_end or '"'
 253        self.identify = identify
 254        self.normalize = normalize
 255        self.string_escape = string_escape or "'"
 256        self.identifier_escape = identifier_escape or '"'
 257        self.pad = pad
 258        self.index_offset = index_offset
 259        self.unnest_column_only = unnest_column_only
 260        self.alias_post_tablesample = alias_post_tablesample
 261        self.normalize_functions = normalize_functions
 262        self.unsupported_level = unsupported_level
 263        self.unsupported_messages = []
 264        self.max_unsupported = max_unsupported
 265        self.null_ordering = null_ordering
 266        self._indent = indent
 267        self._escaped_quote_end = self.string_escape + self.quote_end
 268        self._escaped_identifier_end = self.identifier_escape + self.identifier_end
 269        self._leading_comma = leading_comma
 270        self._max_text_width = max_text_width
 271        self._comments = comments
 272
 273    def generate(self, expression: t.Optional[exp.Expression]) -> str:
 274        """
 275        Generates a SQL string by interpreting the given syntax tree.
 276
 277        Args
 278            expression: the syntax tree.
 279
 280        Returns
 281            the SQL string.
 282        """
 283        self.unsupported_messages = []
 284        sql = self.sql(expression).strip()
 285
 286        if self.unsupported_level == ErrorLevel.IGNORE:
 287            return sql
 288
 289        if self.unsupported_level == ErrorLevel.WARN:
 290            for msg in self.unsupported_messages:
 291                logger.warning(msg)
 292        elif self.unsupported_level == ErrorLevel.RAISE and self.unsupported_messages:
 293            raise UnsupportedError(concat_messages(self.unsupported_messages, self.max_unsupported))
 294
 295        if self.pretty:
 296            sql = sql.replace(self.SENTINEL_LINE_BREAK, "\n")
 297        return sql
 298
 299    def unsupported(self, message: str) -> None:
 300        if self.unsupported_level == ErrorLevel.IMMEDIATE:
 301            raise UnsupportedError(message)
 302        self.unsupported_messages.append(message)
 303
 304    def sep(self, sep: str = " ") -> str:
 305        return f"{sep.strip()}\n" if self.pretty else sep
 306
 307    def seg(self, sql: str, sep: str = " ") -> str:
 308        return f"{self.sep(sep)}{sql}"
 309
 310    def pad_comment(self, comment: str) -> str:
 311        comment = " " + comment if comment[0].strip() else comment
 312        comment = comment + " " if comment[-1].strip() else comment
 313        return comment
 314
 315    def maybe_comment(self, sql: str, expression: exp.Expression) -> str:
 316        comments = expression.comments if self._comments else None
 317
 318        if not comments:
 319            return sql
 320
 321        sep = "\n" if self.pretty else " "
 322        comments_sql = sep.join(
 323            f"/*{self.pad_comment(comment)}*/" for comment in comments if comment
 324        )
 325
 326        if not comments_sql:
 327            return sql
 328
 329        if isinstance(expression, self.WITH_SEPARATED_COMMENTS):
 330            return f"{comments_sql}{self.sep()}{sql}"
 331
 332        return f"{sql} {comments_sql}"
 333
 334    def wrap(self, expression: exp.Expression | str) -> str:
 335        this_sql = self.indent(
 336            self.sql(expression)
 337            if isinstance(expression, (exp.Select, exp.Union))
 338            else self.sql(expression, "this"),
 339            level=1,
 340            pad=0,
 341        )
 342        return f"({self.sep('')}{this_sql}{self.seg(')', sep='')}"
 343
 344    def no_identify(self, func: t.Callable[..., str], *args, **kwargs) -> str:
 345        original = self.identify
 346        self.identify = False
 347        result = func(*args, **kwargs)
 348        self.identify = original
 349        return result
 350
 351    def normalize_func(self, name: str) -> str:
 352        if self.normalize_functions == "upper":
 353            return name.upper()
 354        if self.normalize_functions == "lower":
 355            return name.lower()
 356        return name
 357
 358    def indent(
 359        self,
 360        sql: str,
 361        level: int = 0,
 362        pad: t.Optional[int] = None,
 363        skip_first: bool = False,
 364        skip_last: bool = False,
 365    ) -> str:
 366        if not self.pretty:
 367            return sql
 368
 369        pad = self.pad if pad is None else pad
 370        lines = sql.split("\n")
 371
 372        return "\n".join(
 373            line
 374            if (skip_first and i == 0) or (skip_last and i == len(lines) - 1)
 375            else f"{' ' * (level * self._indent + pad)}{line}"
 376            for i, line in enumerate(lines)
 377        )
 378
 379    def sql(
 380        self,
 381        expression: t.Optional[str | exp.Expression],
 382        key: t.Optional[str] = None,
 383        comment: bool = True,
 384    ) -> str:
 385        if not expression:
 386            return ""
 387
 388        if isinstance(expression, str):
 389            return expression
 390
 391        if key:
 392            return self.sql(expression.args.get(key))
 393
 394        transform = self.TRANSFORMS.get(expression.__class__)
 395
 396        if callable(transform):
 397            sql = transform(self, expression)
 398        elif transform:
 399            sql = transform
 400        elif isinstance(expression, exp.Expression):
 401            exp_handler_name = f"{expression.key}_sql"
 402
 403            if hasattr(self, exp_handler_name):
 404                sql = getattr(self, exp_handler_name)(expression)
 405            elif isinstance(expression, exp.Func):
 406                sql = self.function_fallback_sql(expression)
 407            elif isinstance(expression, exp.Property):
 408                sql = self.property_sql(expression)
 409            else:
 410                raise ValueError(f"Unsupported expression type {expression.__class__.__name__}")
 411        else:
 412            raise ValueError(f"Expected an Expression. Received {type(expression)}: {expression}")
 413
 414        return self.maybe_comment(sql, expression) if self._comments and comment else sql
 415
 416    def uncache_sql(self, expression: exp.Uncache) -> str:
 417        table = self.sql(expression, "this")
 418        exists_sql = " IF EXISTS" if expression.args.get("exists") else ""
 419        return f"UNCACHE TABLE{exists_sql} {table}"
 420
 421    def cache_sql(self, expression: exp.Cache) -> str:
 422        lazy = " LAZY" if expression.args.get("lazy") else ""
 423        table = self.sql(expression, "this")
 424        options = expression.args.get("options")
 425        options = f" OPTIONS({self.sql(options[0])} = {self.sql(options[1])})" if options else ""
 426        sql = self.sql(expression, "expression")
 427        sql = f" AS{self.sep()}{sql}" if sql else ""
 428        sql = f"CACHE{lazy} TABLE {table}{options}{sql}"
 429        return self.prepend_ctes(expression, sql)
 430
 431    def characterset_sql(self, expression: exp.CharacterSet) -> str:
 432        if isinstance(expression.parent, exp.Cast):
 433            return f"CHAR CHARACTER SET {self.sql(expression, 'this')}"
 434        default = "DEFAULT " if expression.args.get("default") else ""
 435        return f"{default}CHARACTER SET={self.sql(expression, 'this')}"
 436
 437    def column_sql(self, expression: exp.Column) -> str:
 438        return ".".join(
 439            self.sql(part)
 440            for part in (
 441                expression.args.get("catalog"),
 442                expression.args.get("db"),
 443                expression.args.get("table"),
 444                expression.args.get("this"),
 445            )
 446            if part
 447        )
 448
 449    def columndef_sql(self, expression: exp.ColumnDef) -> str:
 450        column = self.sql(expression, "this")
 451        kind = self.sql(expression, "kind")
 452        constraints = self.expressions(expression, key="constraints", sep=" ", flat=True)
 453        exists = "IF NOT EXISTS " if expression.args.get("exists") else ""
 454        kind = f" {kind}" if kind else ""
 455        constraints = f" {constraints}" if constraints else ""
 456
 457        return f"{exists}{column}{kind}{constraints}"
 458
 459    def columnconstraint_sql(self, expression: exp.ColumnConstraint) -> str:
 460        this = self.sql(expression, "this")
 461        kind_sql = self.sql(expression, "kind")
 462        return f"CONSTRAINT {this} {kind_sql}" if this else kind_sql
 463
 464    def autoincrementcolumnconstraint_sql(self, _) -> str:
 465        return self.token_sql(TokenType.AUTO_INCREMENT)
 466
 467    def compresscolumnconstraint_sql(self, expression: exp.CompressColumnConstraint) -> str:
 468        if isinstance(expression.this, list):
 469            this = self.wrap(self.expressions(expression, key="this", flat=True))
 470        else:
 471            this = self.sql(expression, "this")
 472
 473        return f"COMPRESS {this}"
 474
 475    def generatedasidentitycolumnconstraint_sql(
 476        self, expression: exp.GeneratedAsIdentityColumnConstraint
 477    ) -> str:
 478        this = ""
 479        if expression.this is not None:
 480            this = " ALWAYS " if expression.this else " BY DEFAULT "
 481        start = expression.args.get("start")
 482        start = f"START WITH {start}" if start else ""
 483        increment = expression.args.get("increment")
 484        increment = f" INCREMENT BY {increment}" if increment else ""
 485        minvalue = expression.args.get("minvalue")
 486        minvalue = f" MINVALUE {minvalue}" if minvalue else ""
 487        maxvalue = expression.args.get("maxvalue")
 488        maxvalue = f" MAXVALUE {maxvalue}" if maxvalue else ""
 489        cycle = expression.args.get("cycle")
 490        cycle_sql = ""
 491        if cycle is not None:
 492            cycle_sql = f"{' NO' if not cycle else ''} CYCLE"
 493            cycle_sql = cycle_sql.strip() if not start and not increment else cycle_sql
 494        sequence_opts = ""
 495        if start or increment or cycle_sql:
 496            sequence_opts = f"{start}{increment}{minvalue}{maxvalue}{cycle_sql}"
 497            sequence_opts = f" ({sequence_opts.strip()})"
 498        return f"GENERATED{this}AS IDENTITY{sequence_opts}"
 499
 500    def notnullcolumnconstraint_sql(self, expression: exp.NotNullColumnConstraint) -> str:
 501        return f"{'' if expression.args.get('allow_null') else 'NOT '}NULL"
 502
 503    def primarykeycolumnconstraint_sql(self, expression: exp.PrimaryKeyColumnConstraint) -> str:
 504        desc = expression.args.get("desc")
 505        if desc is not None:
 506            return f"PRIMARY KEY{' DESC' if desc else ' ASC'}"
 507        return f"PRIMARY KEY"
 508
 509    def uniquecolumnconstraint_sql(self, _) -> str:
 510        return "UNIQUE"
 511
 512    def create_sql(self, expression: exp.Create) -> str:
 513        kind = self.sql(expression, "kind").upper()
 514        properties = expression.args.get("properties")
 515        properties_exp = expression.copy()
 516        properties_locs = self.locate_properties(properties) if properties else {}
 517        if properties_locs.get(exp.Properties.Location.POST_SCHEMA) or properties_locs.get(
 518            exp.Properties.Location.POST_WITH
 519        ):
 520            properties_exp.set(
 521                "properties",
 522                exp.Properties(
 523                    expressions=[
 524                        *properties_locs[exp.Properties.Location.POST_SCHEMA],
 525                        *properties_locs[exp.Properties.Location.POST_WITH],
 526                    ]
 527                ),
 528            )
 529        if kind == "TABLE" and properties_locs.get(exp.Properties.Location.POST_NAME):
 530            this_name = self.sql(expression.this, "this")
 531            this_properties = self.properties(
 532                exp.Properties(expressions=properties_locs[exp.Properties.Location.POST_NAME]),
 533                wrapped=False,
 534            )
 535            this_schema = f"({self.expressions(expression.this)})"
 536            this = f"{this_name}, {this_properties} {this_schema}"
 537            properties_sql = ""
 538        else:
 539            this = self.sql(expression, "this")
 540            properties_sql = self.sql(properties_exp, "properties")
 541        begin = " BEGIN" if expression.args.get("begin") else ""
 542        expression_sql = self.sql(expression, "expression")
 543        if expression_sql:
 544            expression_sql = f"{begin}{self.sep()}{expression_sql}"
 545
 546            if self.CREATE_FUNCTION_RETURN_AS or not isinstance(expression.expression, exp.Return):
 547                if properties_locs.get(exp.Properties.Location.POST_ALIAS):
 548                    postalias_props_sql = self.properties(
 549                        exp.Properties(
 550                            expressions=properties_locs[exp.Properties.Location.POST_ALIAS]
 551                        ),
 552                        wrapped=False,
 553                    )
 554                    expression_sql = f" AS {postalias_props_sql}{expression_sql}"
 555                else:
 556                    expression_sql = f" AS{expression_sql}"
 557
 558        postindex_props_sql = ""
 559        if properties_locs.get(exp.Properties.Location.POST_INDEX):
 560            postindex_props_sql = self.properties(
 561                exp.Properties(expressions=properties_locs[exp.Properties.Location.POST_INDEX]),
 562                wrapped=False,
 563                prefix=" ",
 564            )
 565
 566        indexes = expression.args.get("indexes")
 567        if indexes:
 568            indexes_sql: t.List[str] = []
 569            for index in indexes:
 570                ind_unique = " UNIQUE" if index.args.get("unique") else ""
 571                ind_primary = " PRIMARY" if index.args.get("primary") else ""
 572                ind_amp = " AMP" if index.args.get("amp") else ""
 573                ind_name = f" {index.name}" if index.name else ""
 574                ind_columns = (
 575                    f' ({self.expressions(index, key="columns", flat=True)})'
 576                    if index.args.get("columns")
 577                    else ""
 578                )
 579                ind_sql = f"{ind_unique}{ind_primary}{ind_amp} INDEX{ind_name}{ind_columns}"
 580
 581                if indexes_sql:
 582                    indexes_sql.append(ind_sql)
 583                else:
 584                    indexes_sql.append(
 585                        f"{ind_sql}{postindex_props_sql}"
 586                        if index.args.get("primary")
 587                        else f"{postindex_props_sql}{ind_sql}"
 588                    )
 589
 590            index_sql = "".join(indexes_sql)
 591        else:
 592            index_sql = postindex_props_sql
 593
 594        replace = " OR REPLACE" if expression.args.get("replace") else ""
 595        unique = " UNIQUE" if expression.args.get("unique") else ""
 596        volatile = " VOLATILE" if expression.args.get("volatile") else ""
 597
 598        postcreate_props_sql = ""
 599        if properties_locs.get(exp.Properties.Location.POST_CREATE):
 600            postcreate_props_sql = self.properties(
 601                exp.Properties(expressions=properties_locs[exp.Properties.Location.POST_CREATE]),
 602                sep=" ",
 603                prefix=" ",
 604                wrapped=False,
 605            )
 606
 607        modifiers = "".join((replace, unique, volatile, postcreate_props_sql))
 608
 609        postexpression_props_sql = ""
 610        if properties_locs.get(exp.Properties.Location.POST_EXPRESSION):
 611            postexpression_props_sql = self.properties(
 612                exp.Properties(
 613                    expressions=properties_locs[exp.Properties.Location.POST_EXPRESSION]
 614                ),
 615                sep=" ",
 616                prefix=" ",
 617                wrapped=False,
 618            )
 619
 620        exists_sql = " IF NOT EXISTS" if expression.args.get("exists") else ""
 621        no_schema_binding = (
 622            " WITH NO SCHEMA BINDING" if expression.args.get("no_schema_binding") else ""
 623        )
 624
 625        expression_sql = f"CREATE{modifiers} {kind}{exists_sql} {this}{properties_sql}{expression_sql}{postexpression_props_sql}{index_sql}{no_schema_binding}"
 626        return self.prepend_ctes(expression, expression_sql)
 627
 628    def describe_sql(self, expression: exp.Describe) -> str:
 629        return f"DESCRIBE {self.sql(expression, 'this')}"
 630
 631    def prepend_ctes(self, expression: exp.Expression, sql: str) -> str:
 632        with_ = self.sql(expression, "with")
 633        if with_:
 634            sql = f"{with_}{self.sep()}{sql}"
 635        return sql
 636
 637    def with_sql(self, expression: exp.With) -> str:
 638        sql = self.expressions(expression, flat=True)
 639        recursive = "RECURSIVE " if expression.args.get("recursive") else ""
 640
 641        return f"WITH {recursive}{sql}"
 642
 643    def cte_sql(self, expression: exp.CTE) -> str:
 644        alias = self.sql(expression, "alias")
 645        return f"{alias} AS {self.wrap(expression)}"
 646
 647    def tablealias_sql(self, expression: exp.TableAlias) -> str:
 648        alias = self.sql(expression, "this")
 649        columns = self.expressions(expression, key="columns", flat=True)
 650        columns = f"({columns})" if columns else ""
 651        return f"{alias}{columns}"
 652
 653    def bitstring_sql(self, expression: exp.BitString) -> str:
 654        return self.sql(expression, "this")
 655
 656    def hexstring_sql(self, expression: exp.HexString) -> str:
 657        return self.sql(expression, "this")
 658
 659    def datatype_sql(self, expression: exp.DataType) -> str:
 660        type_value = expression.this
 661        type_sql = self.TYPE_MAPPING.get(type_value, type_value.value)
 662        nested = ""
 663        interior = self.expressions(expression, flat=True)
 664        values = ""
 665        if interior:
 666            if expression.args.get("nested"):
 667                nested = f"{self.STRUCT_DELIMITER[0]}{interior}{self.STRUCT_DELIMITER[1]}"
 668                if expression.args.get("values") is not None:
 669                    delimiters = ("[", "]") if type_value == exp.DataType.Type.ARRAY else ("(", ")")
 670                    values = (
 671                        f"{delimiters[0]}{self.expressions(expression, 'values')}{delimiters[1]}"
 672                    )
 673            else:
 674                nested = f"({interior})"
 675
 676        return f"{type_sql}{nested}{values}"
 677
 678    def directory_sql(self, expression: exp.Directory) -> str:
 679        local = "LOCAL " if expression.args.get("local") else ""
 680        row_format = self.sql(expression, "row_format")
 681        row_format = f" {row_format}" if row_format else ""
 682        return f"{local}DIRECTORY {self.sql(expression, 'this')}{row_format}"
 683
 684    def delete_sql(self, expression: exp.Delete) -> str:
 685        this = self.sql(expression, "this")
 686        this = f" FROM {this}" if this else ""
 687        using_sql = (
 688            f" USING {self.expressions(expression, 'using', sep=', USING ')}"
 689            if expression.args.get("using")
 690            else ""
 691        )
 692        where_sql = self.sql(expression, "where")
 693        returning = self.sql(expression, "returning")
 694        sql = f"DELETE{this}{using_sql}{where_sql}{returning}"
 695        return self.prepend_ctes(expression, sql)
 696
 697    def drop_sql(self, expression: exp.Drop) -> str:
 698        this = self.sql(expression, "this")
 699        kind = expression.args["kind"]
 700        exists_sql = " IF EXISTS " if expression.args.get("exists") else " "
 701        temporary = " TEMPORARY" if expression.args.get("temporary") else ""
 702        materialized = " MATERIALIZED" if expression.args.get("materialized") else ""
 703        cascade = " CASCADE" if expression.args.get("cascade") else ""
 704        return f"DROP{temporary}{materialized} {kind}{exists_sql}{this}{cascade}"
 705
 706    def except_sql(self, expression: exp.Except) -> str:
 707        return self.prepend_ctes(
 708            expression,
 709            self.set_operation(expression, self.except_op(expression)),
 710        )
 711
 712    def except_op(self, expression: exp.Except) -> str:
 713        return f"EXCEPT{'' if expression.args.get('distinct') else ' ALL'}"
 714
 715    def fetch_sql(self, expression: exp.Fetch) -> str:
 716        direction = expression.args.get("direction")
 717        direction = f" {direction.upper()}" if direction else ""
 718        count = expression.args.get("count")
 719        count = f" {count}" if count else ""
 720        return f"{self.seg('FETCH')}{direction}{count} ROWS ONLY"
 721
 722    def filter_sql(self, expression: exp.Filter) -> str:
 723        this = self.sql(expression, "this")
 724        where = self.sql(expression, "expression")[1:]  # where has a leading space
 725        return f"{this} FILTER({where})"
 726
 727    def hint_sql(self, expression: exp.Hint) -> str:
 728        if self.sql(expression, "this"):
 729            self.unsupported("Hints are not supported")
 730        return ""
 731
 732    def index_sql(self, expression: exp.Index) -> str:
 733        this = self.sql(expression, "this")
 734        table = self.sql(expression, "table")
 735        columns = self.sql(expression, "columns")
 736        return f"{this} ON {table} {columns}"
 737
 738    def identifier_sql(self, expression: exp.Identifier) -> str:
 739        text = expression.name
 740        text = text.lower() if self.normalize else text
 741        text = text.replace(self.identifier_end, self._escaped_identifier_end)
 742        if expression.args.get("quoted") or self.identify:
 743            text = f"{self.identifier_start}{text}{self.identifier_end}"
 744        return text
 745
 746    def national_sql(self, expression: exp.National) -> str:
 747        return f"N{self.sql(expression, 'this')}"
 748
 749    def partition_sql(self, expression: exp.Partition) -> str:
 750        return f"PARTITION({self.expressions(expression)})"
 751
 752    def properties_sql(self, expression: exp.Properties) -> str:
 753        root_properties = []
 754        with_properties = []
 755
 756        for p in expression.expressions:
 757            p_loc = self.PROPERTIES_LOCATION[p.__class__]
 758            if p_loc == exp.Properties.Location.POST_WITH:
 759                with_properties.append(p)
 760            elif p_loc == exp.Properties.Location.POST_SCHEMA:
 761                root_properties.append(p)
 762
 763        return self.root_properties(
 764            exp.Properties(expressions=root_properties)
 765        ) + self.with_properties(exp.Properties(expressions=with_properties))
 766
 767    def root_properties(self, properties: exp.Properties) -> str:
 768        if properties.expressions:
 769            return self.sep() + self.expressions(properties, indent=False, sep=" ")
 770        return ""
 771
 772    def properties(
 773        self,
 774        properties: exp.Properties,
 775        prefix: str = "",
 776        sep: str = ", ",
 777        suffix: str = "",
 778        wrapped: bool = True,
 779    ) -> str:
 780        if properties.expressions:
 781            expressions = self.expressions(properties, sep=sep, indent=False)
 782            expressions = self.wrap(expressions) if wrapped else expressions
 783            return f"{prefix}{' ' if prefix and prefix != ' ' else ''}{expressions}{suffix}"
 784        return ""
 785
 786    def with_properties(self, properties: exp.Properties) -> str:
 787        return self.properties(properties, prefix=self.seg("WITH"))
 788
 789    def locate_properties(
 790        self, properties: exp.Properties
 791    ) -> t.Dict[exp.Properties.Location, list[exp.Property]]:
 792        properties_locs: t.Dict[exp.Properties.Location, list[exp.Property]] = {
 793            key: [] for key in exp.Properties.Location
 794        }
 795
 796        for p in properties.expressions:
 797            p_loc = self.PROPERTIES_LOCATION[p.__class__]
 798            if p_loc == exp.Properties.Location.POST_NAME:
 799                properties_locs[exp.Properties.Location.POST_NAME].append(p)
 800            elif p_loc == exp.Properties.Location.POST_INDEX:
 801                properties_locs[exp.Properties.Location.POST_INDEX].append(p)
 802            elif p_loc == exp.Properties.Location.POST_SCHEMA:
 803                properties_locs[exp.Properties.Location.POST_SCHEMA].append(p)
 804            elif p_loc == exp.Properties.Location.POST_WITH:
 805                properties_locs[exp.Properties.Location.POST_WITH].append(p)
 806            elif p_loc == exp.Properties.Location.POST_CREATE:
 807                properties_locs[exp.Properties.Location.POST_CREATE].append(p)
 808            elif p_loc == exp.Properties.Location.POST_ALIAS:
 809                properties_locs[exp.Properties.Location.POST_ALIAS].append(p)
 810            elif p_loc == exp.Properties.Location.POST_EXPRESSION:
 811                properties_locs[exp.Properties.Location.POST_EXPRESSION].append(p)
 812            elif p_loc == exp.Properties.Location.UNSUPPORTED:
 813                self.unsupported(f"Unsupported property {p.key}")
 814
 815        return properties_locs
 816
 817    def property_sql(self, expression: exp.Property) -> str:
 818        property_cls = expression.__class__
 819        if property_cls == exp.Property:
 820            return f"{expression.name}={self.sql(expression, 'value')}"
 821
 822        property_name = exp.Properties.PROPERTY_TO_NAME.get(property_cls)
 823        if not property_name:
 824            self.unsupported(f"Unsupported property {expression.key}")
 825
 826        return f"{property_name}={self.sql(expression, 'this')}"
 827
 828    def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
 829        options = " ".join(f"{e.name} {self.sql(e, 'value')}" for e in expression.expressions)
 830        options = f" {options}" if options else ""
 831        return f"LIKE {self.sql(expression, 'this')}{options}"
 832
 833    def fallbackproperty_sql(self, expression: exp.FallbackProperty) -> str:
 834        no = "NO " if expression.args.get("no") else ""
 835        protection = " PROTECTION" if expression.args.get("protection") else ""
 836        return f"{no}FALLBACK{protection}"
 837
 838    def journalproperty_sql(self, expression: exp.JournalProperty) -> str:
 839        no = "NO " if expression.args.get("no") else ""
 840        dual = "DUAL " if expression.args.get("dual") else ""
 841        before = "BEFORE " if expression.args.get("before") else ""
 842        return f"{no}{dual}{before}JOURNAL"
 843
 844    def freespaceproperty_sql(self, expression: exp.FreespaceProperty) -> str:
 845        freespace = self.sql(expression, "this")
 846        percent = " PERCENT" if expression.args.get("percent") else ""
 847        return f"FREESPACE={freespace}{percent}"
 848
 849    def afterjournalproperty_sql(self, expression: exp.AfterJournalProperty) -> str:
 850        no = "NO " if expression.args.get("no") else ""
 851        dual = "DUAL " if expression.args.get("dual") else ""
 852        local = ""
 853        if expression.args.get("local") is not None:
 854            local = "LOCAL " if expression.args.get("local") else "NOT LOCAL "
 855        return f"{no}{dual}{local}AFTER JOURNAL"
 856
 857    def checksumproperty_sql(self, expression: exp.ChecksumProperty) -> str:
 858        if expression.args.get("default"):
 859            property = "DEFAULT"
 860        elif expression.args.get("on"):
 861            property = "ON"
 862        else:
 863            property = "OFF"
 864        return f"CHECKSUM={property}"
 865
 866    def mergeblockratioproperty_sql(self, expression: exp.MergeBlockRatioProperty) -> str:
 867        if expression.args.get("no"):
 868            return "NO MERGEBLOCKRATIO"
 869        if expression.args.get("default"):
 870            return "DEFAULT MERGEBLOCKRATIO"
 871
 872        percent = " PERCENT" if expression.args.get("percent") else ""
 873        return f"MERGEBLOCKRATIO={self.sql(expression, 'this')}{percent}"
 874
 875    def datablocksizeproperty_sql(self, expression: exp.DataBlocksizeProperty) -> str:
 876        default = expression.args.get("default")
 877        min = expression.args.get("min")
 878        if default is not None or min is not None:
 879            if default:
 880                property = "DEFAULT"
 881            elif min:
 882                property = "MINIMUM"
 883            else:
 884                property = "MAXIMUM"
 885            return f"{property} DATABLOCKSIZE"
 886        else:
 887            units = expression.args.get("units")
 888            units = f" {units}" if units else ""
 889            return f"DATABLOCKSIZE={self.sql(expression, 'size')}{units}"
 890
 891    def blockcompressionproperty_sql(self, expression: exp.BlockCompressionProperty) -> str:
 892        autotemp = expression.args.get("autotemp")
 893        always = expression.args.get("always")
 894        default = expression.args.get("default")
 895        manual = expression.args.get("manual")
 896        never = expression.args.get("never")
 897
 898        if autotemp is not None:
 899            property = f"AUTOTEMP({self.expressions(autotemp)})"
 900        elif always:
 901            property = "ALWAYS"
 902        elif default:
 903            property = "DEFAULT"
 904        elif manual:
 905            property = "MANUAL"
 906        elif never:
 907            property = "NEVER"
 908        return f"BLOCKCOMPRESSION={property}"
 909
 910    def isolatedloadingproperty_sql(self, expression: exp.IsolatedLoadingProperty) -> str:
 911        no = expression.args.get("no")
 912        no = " NO" if no else ""
 913        concurrent = expression.args.get("concurrent")
 914        concurrent = " CONCURRENT" if concurrent else ""
 915
 916        for_ = ""
 917        if expression.args.get("for_all"):
 918            for_ = " FOR ALL"
 919        elif expression.args.get("for_insert"):
 920            for_ = " FOR INSERT"
 921        elif expression.args.get("for_none"):
 922            for_ = " FOR NONE"
 923        return f"WITH{no}{concurrent} ISOLATED LOADING{for_}"
 924
 925    def lockingproperty_sql(self, expression: exp.LockingProperty) -> str:
 926        kind = expression.args.get("kind")
 927        this: str = f" {this}" if expression.this else ""
 928        for_or_in = expression.args.get("for_or_in")
 929        lock_type = expression.args.get("lock_type")
 930        override = " OVERRIDE" if expression.args.get("override") else ""
 931        return f"LOCKING {kind}{this} {for_or_in} {lock_type}{override}"
 932
 933    def withdataproperty_sql(self, expression: exp.WithDataProperty) -> str:
 934        data_sql = f"WITH {'NO ' if expression.args.get('no') else ''}DATA"
 935        statistics = expression.args.get("statistics")
 936        statistics_sql = ""
 937        if statistics is not None:
 938            statistics_sql = f" AND {'NO ' if not statistics else ''}STATISTICS"
 939        return f"{data_sql}{statistics_sql}"
 940
 941    def insert_sql(self, expression: exp.Insert) -> str:
 942        overwrite = expression.args.get("overwrite")
 943
 944        if isinstance(expression.this, exp.Directory):
 945            this = "OVERWRITE " if overwrite else "INTO "
 946        else:
 947            this = "OVERWRITE TABLE " if overwrite else "INTO "
 948
 949        alternative = expression.args.get("alternative")
 950        alternative = f" OR {alternative} " if alternative else " "
 951        this = f"{this}{self.sql(expression, 'this')}"
 952
 953        exists = " IF EXISTS " if expression.args.get("exists") else " "
 954        partition_sql = (
 955            self.sql(expression, "partition") if expression.args.get("partition") else ""
 956        )
 957        expression_sql = self.sql(expression, "expression")
 958        returning = self.sql(expression, "returning")
 959        sep = self.sep() if partition_sql else ""
 960        sql = f"INSERT{alternative}{this}{exists}{partition_sql}{sep}{expression_sql}{returning}"
 961        return self.prepend_ctes(expression, sql)
 962
 963    def intersect_sql(self, expression: exp.Intersect) -> str:
 964        return self.prepend_ctes(
 965            expression,
 966            self.set_operation(expression, self.intersect_op(expression)),
 967        )
 968
 969    def intersect_op(self, expression: exp.Intersect) -> str:
 970        return f"INTERSECT{'' if expression.args.get('distinct') else ' ALL'}"
 971
 972    def introducer_sql(self, expression: exp.Introducer) -> str:
 973        return f"{self.sql(expression, 'this')} {self.sql(expression, 'expression')}"
 974
 975    def pseudotype_sql(self, expression: exp.PseudoType) -> str:
 976        return expression.name.upper()
 977
 978    def returning_sql(self, expression: exp.Returning) -> str:
 979        return f"{self.seg('RETURNING')} {self.expressions(expression, flat=True)}"
 980
 981    def rowformatdelimitedproperty_sql(self, expression: exp.RowFormatDelimitedProperty) -> str:
 982        fields = expression.args.get("fields")
 983        fields = f" FIELDS TERMINATED BY {fields}" if fields else ""
 984        escaped = expression.args.get("escaped")
 985        escaped = f" ESCAPED BY {escaped}" if escaped else ""
 986        items = expression.args.get("collection_items")
 987        items = f" COLLECTION ITEMS TERMINATED BY {items}" if items else ""
 988        keys = expression.args.get("map_keys")
 989        keys = f" MAP KEYS TERMINATED BY {keys}" if keys else ""
 990        lines = expression.args.get("lines")
 991        lines = f" LINES TERMINATED BY {lines}" if lines else ""
 992        null = expression.args.get("null")
 993        null = f" NULL DEFINED AS {null}" if null else ""
 994        return f"ROW FORMAT DELIMITED{fields}{escaped}{items}{keys}{lines}{null}"
 995
 996    def table_sql(self, expression: exp.Table, sep: str = " AS ") -> str:
 997        table = ".".join(
 998            part
 999            for part in [
1000                self.sql(expression, "catalog"),
1001                self.sql(expression, "db"),
1002                self.sql(expression, "this"),
1003            ]
1004            if part
1005        )
1006
1007        alias = self.sql(expression, "alias")
1008        alias = f"{sep}{alias}" if alias else ""
1009        hints = self.expressions(expression, key="hints", sep=", ", flat=True)
1010        hints = f" WITH ({hints})" if hints else ""
1011        laterals = self.expressions(expression, key="laterals", sep="")
1012        joins = self.expressions(expression, key="joins", sep="")
1013        pivots = self.expressions(expression, key="pivots", sep="")
1014        system_time = expression.args.get("system_time")
1015        system_time = f" {self.sql(expression, 'system_time')}" if system_time else ""
1016
1017        return f"{table}{system_time}{alias}{hints}{laterals}{joins}{pivots}"
1018
1019    def tablesample_sql(self, expression: exp.TableSample, seed_prefix: str = "SEED") -> str:
1020        if self.alias_post_tablesample and expression.this.alias:
1021            this = self.sql(expression.this, "this")
1022            alias = f" AS {self.sql(expression.this, 'alias')}"
1023        else:
1024            this = self.sql(expression, "this")
1025            alias = ""
1026        method = self.sql(expression, "method")
1027        method = f"{method.upper()} " if method else ""
1028        numerator = self.sql(expression, "bucket_numerator")
1029        denominator = self.sql(expression, "bucket_denominator")
1030        field = self.sql(expression, "bucket_field")
1031        field = f" ON {field}" if field else ""
1032        bucket = f"BUCKET {numerator} OUT OF {denominator}{field}" if numerator else ""
1033        percent = self.sql(expression, "percent")
1034        percent = f"{percent} PERCENT" if percent else ""
1035        rows = self.sql(expression, "rows")
1036        rows = f"{rows} ROWS" if rows else ""
1037        size = self.sql(expression, "size")
1038        seed = self.sql(expression, "seed")
1039        seed = f" {seed_prefix} ({seed})" if seed else ""
1040        kind = expression.args.get("kind", "TABLESAMPLE")
1041        return f"{this} {kind} {method}({bucket}{percent}{rows}{size}){seed}{alias}"
1042
1043    def pivot_sql(self, expression: exp.Pivot) -> str:
1044        this = self.sql(expression, "this")
1045        alias = self.sql(expression, "alias")
1046        alias = f" AS {alias}" if alias else ""
1047        unpivot = expression.args.get("unpivot")
1048        direction = "UNPIVOT" if unpivot else "PIVOT"
1049        expressions = self.expressions(expression, key="expressions")
1050        field = self.sql(expression, "field")
1051        return f"{this} {direction}({expressions} FOR {field}){alias}"
1052
1053    def tuple_sql(self, expression: exp.Tuple) -> str:
1054        return f"({self.expressions(expression, flat=True)})"
1055
1056    def update_sql(self, expression: exp.Update) -> str:
1057        this = self.sql(expression, "this")
1058        set_sql = self.expressions(expression, flat=True)
1059        from_sql = self.sql(expression, "from")
1060        where_sql = self.sql(expression, "where")
1061        returning = self.sql(expression, "returning")
1062        sql = f"UPDATE {this} SET {set_sql}{from_sql}{where_sql}{returning}"
1063        return self.prepend_ctes(expression, sql)
1064
1065    def values_sql(self, expression: exp.Values) -> str:
1066        args = self.expressions(expression)
1067        alias = self.sql(expression, "alias")
1068        values = f"VALUES{self.seg('')}{args}"
1069        values = (
1070            f"({values})"
1071            if self.WRAP_DERIVED_VALUES and (alias or isinstance(expression.parent, exp.From))
1072            else values
1073        )
1074        return f"{values} AS {alias}" if alias else values
1075
1076    def var_sql(self, expression: exp.Var) -> str:
1077        return self.sql(expression, "this")
1078
1079    def into_sql(self, expression: exp.Into) -> str:
1080        temporary = " TEMPORARY" if expression.args.get("temporary") else ""
1081        unlogged = " UNLOGGED" if expression.args.get("unlogged") else ""
1082        return f"{self.seg('INTO')}{temporary or unlogged} {self.sql(expression, 'this')}"
1083
1084    def from_sql(self, expression: exp.From) -> str:
1085        expressions = self.expressions(expression, flat=True)
1086        return f"{self.seg('FROM')} {expressions}"
1087
1088    def group_sql(self, expression: exp.Group) -> str:
1089        group_by = self.op_expressions("GROUP BY", expression)
1090        grouping_sets = self.expressions(expression, key="grouping_sets", indent=False)
1091        grouping_sets = (
1092            f"{self.seg('GROUPING SETS')} {self.wrap(grouping_sets)}" if grouping_sets else ""
1093        )
1094
1095        cube = expression.args.get("cube", [])
1096        if seq_get(cube, 0) is True:
1097            return f"{group_by}{self.seg('WITH CUBE')}"
1098        else:
1099            cube_sql = self.expressions(expression, key="cube", indent=False)
1100            cube_sql = f"{self.seg('CUBE')} {self.wrap(cube_sql)}" if cube_sql else ""
1101
1102        rollup = expression.args.get("rollup", [])
1103        if seq_get(rollup, 0) is True:
1104            return f"{group_by}{self.seg('WITH ROLLUP')}"
1105        else:
1106            rollup_sql = self.expressions(expression, key="rollup", indent=False)
1107            rollup_sql = f"{self.seg('ROLLUP')} {self.wrap(rollup_sql)}" if rollup_sql else ""
1108
1109        groupings = csv(grouping_sets, cube_sql, rollup_sql, sep=",")
1110
1111        if expression.args.get("expressions") and groupings:
1112            group_by = f"{group_by},"
1113
1114        return f"{group_by}{groupings}"
1115
1116    def having_sql(self, expression: exp.Having) -> str:
1117        this = self.indent(self.sql(expression, "this"))
1118        return f"{self.seg('HAVING')}{self.sep()}{this}"
1119
1120    def join_sql(self, expression: exp.Join) -> str:
1121        op_sql = self.seg(
1122            " ".join(
1123                op
1124                for op in (
1125                    "NATURAL" if expression.args.get("natural") else None,
1126                    expression.side,
1127                    expression.kind,
1128                    "JOIN",
1129                )
1130                if op
1131            )
1132        )
1133        on_sql = self.sql(expression, "on")
1134        using = expression.args.get("using")
1135
1136        if not on_sql and using:
1137            on_sql = csv(*(self.sql(column) for column in using))
1138
1139        if on_sql:
1140            on_sql = self.indent(on_sql, skip_first=True)
1141            space = self.seg(" " * self.pad) if self.pretty else " "
1142            if using:
1143                on_sql = f"{space}USING ({on_sql})"
1144            else:
1145                on_sql = f"{space}ON {on_sql}"
1146
1147        expression_sql = self.sql(expression, "expression")
1148        this_sql = self.sql(expression, "this")
1149        return f"{expression_sql}{op_sql} {this_sql}{on_sql}"
1150
1151    def lambda_sql(self, expression: exp.Lambda, arrow_sep: str = "->") -> str:
1152        args = self.expressions(expression, flat=True)
1153        args = f"({args})" if len(args.split(",")) > 1 else args
1154        return f"{args} {arrow_sep} {self.sql(expression, 'this')}"
1155
1156    def lateral_sql(self, expression: exp.Lateral) -> str:
1157        this = self.sql(expression, "this")
1158
1159        if isinstance(expression.this, exp.Subquery):
1160            return f"LATERAL {this}"
1161
1162        if expression.args.get("view"):
1163            alias = expression.args["alias"]
1164            columns = self.expressions(alias, key="columns", flat=True)
1165            table = f" {alias.name}" if alias.name else ""
1166            columns = f" AS {columns}" if columns else ""
1167            op_sql = self.seg(f"LATERAL VIEW{' OUTER' if expression.args.get('outer') else ''}")
1168            return f"{op_sql}{self.sep()}{this}{table}{columns}"
1169
1170        alias = self.sql(expression, "alias")
1171        alias = f" AS {alias}" if alias else ""
1172        return f"LATERAL {this}{alias}"
1173
1174    def limit_sql(self, expression: exp.Limit) -> str:
1175        this = self.sql(expression, "this")
1176        return f"{this}{self.seg('LIMIT')} {self.sql(expression, 'expression')}"
1177
1178    def offset_sql(self, expression: exp.Offset) -> str:
1179        this = self.sql(expression, "this")
1180        return f"{this}{self.seg('OFFSET')} {self.sql(expression, 'expression')}"
1181
1182    def lock_sql(self, expression: exp.Lock) -> str:
1183        if self.LOCKING_READS_SUPPORTED:
1184            lock_type = "UPDATE" if expression.args["update"] else "SHARE"
1185            return self.seg(f"FOR {lock_type}")
1186
1187        self.unsupported("Locking reads using 'FOR UPDATE/SHARE' are not supported")
1188        return ""
1189
1190    def literal_sql(self, expression: exp.Literal) -> str:
1191        text = expression.this or ""
1192        if expression.is_string:
1193            text = text.replace(self.quote_end, self._escaped_quote_end)
1194            if self.pretty:
1195                text = text.replace("\n", self.SENTINEL_LINE_BREAK)
1196            text = f"{self.quote_start}{text}{self.quote_end}"
1197        return text
1198
1199    def loaddata_sql(self, expression: exp.LoadData) -> str:
1200        local = " LOCAL" if expression.args.get("local") else ""
1201        inpath = f" INPATH {self.sql(expression, 'inpath')}"
1202        overwrite = " OVERWRITE" if expression.args.get("overwrite") else ""
1203        this = f" INTO TABLE {self.sql(expression, 'this')}"
1204        partition = self.sql(expression, "partition")
1205        partition = f" {partition}" if partition else ""
1206        input_format = self.sql(expression, "input_format")
1207        input_format = f" INPUTFORMAT {input_format}" if input_format else ""
1208        serde = self.sql(expression, "serde")
1209        serde = f" SERDE {serde}" if serde else ""
1210        return f"LOAD DATA{local}{inpath}{overwrite}{this}{partition}{input_format}{serde}"
1211
1212    def null_sql(self, *_) -> str:
1213        return "NULL"
1214
1215    def boolean_sql(self, expression: exp.Boolean) -> str:
1216        return "TRUE" if expression.this else "FALSE"
1217
1218    def order_sql(self, expression: exp.Order, flat: bool = False) -> str:
1219        this = self.sql(expression, "this")
1220        this = f"{this} " if this else this
1221        return self.op_expressions(f"{this}ORDER BY", expression, flat=this or flat)  # type: ignore
1222
1223    def cluster_sql(self, expression: exp.Cluster) -> str:
1224        return self.op_expressions("CLUSTER BY", expression)
1225
1226    def distribute_sql(self, expression: exp.Distribute) -> str:
1227        return self.op_expressions("DISTRIBUTE BY", expression)
1228
1229    def sort_sql(self, expression: exp.Sort) -> str:
1230        return self.op_expressions("SORT BY", expression)
1231
1232    def ordered_sql(self, expression: exp.Ordered) -> str:
1233        desc = expression.args.get("desc")
1234        asc = not desc
1235
1236        nulls_first = expression.args.get("nulls_first")
1237        nulls_last = not nulls_first
1238        nulls_are_large = self.null_ordering == "nulls_are_large"
1239        nulls_are_small = self.null_ordering == "nulls_are_small"
1240        nulls_are_last = self.null_ordering == "nulls_are_last"
1241
1242        sort_order = " DESC" if desc else ""
1243        nulls_sort_change = ""
1244        if nulls_first and (
1245            (asc and nulls_are_large) or (desc and nulls_are_small) or nulls_are_last
1246        ):
1247            nulls_sort_change = " NULLS FIRST"
1248        elif (
1249            nulls_last
1250            and ((asc and nulls_are_small) or (desc and nulls_are_large))
1251            and not nulls_are_last
1252        ):
1253            nulls_sort_change = " NULLS LAST"
1254
1255        if nulls_sort_change and not self.NULL_ORDERING_SUPPORTED:
1256            self.unsupported(
1257                "Sorting in an ORDER BY on NULLS FIRST/NULLS LAST is not supported by this dialect"
1258            )
1259            nulls_sort_change = ""
1260
1261        return f"{self.sql(expression, 'this')}{sort_order}{nulls_sort_change}"
1262
1263    def matchrecognize_sql(self, expression: exp.MatchRecognize) -> str:
1264        partition = self.partition_by_sql(expression)
1265        order = self.sql(expression, "order")
1266        measures = self.sql(expression, "measures")
1267        measures = self.seg(f"MEASURES {measures}") if measures else ""
1268        rows = self.sql(expression, "rows")
1269        rows = self.seg(rows) if rows else ""
1270        after = self.sql(expression, "after")
1271        after = self.seg(after) if after else ""
1272        pattern = self.sql(expression, "pattern")
1273        pattern = self.seg(f"PATTERN ({pattern})") if pattern else ""
1274        define = self.sql(expression, "define")
1275        define = self.seg(f"DEFINE {define}") if define else ""
1276        body = "".join(
1277            (
1278                partition,
1279                order,
1280                measures,
1281                rows,
1282                after,
1283                pattern,
1284                define,
1285            )
1286        )
1287        return f"{self.seg('MATCH_RECOGNIZE')} {self.wrap(body)}"
1288
1289    def query_modifiers(self, expression: exp.Expression, *sqls: str) -> str:
1290        return csv(
1291            *sqls,
1292            *[self.sql(sql) for sql in expression.args.get("joins") or []],
1293            self.sql(expression, "match"),
1294            *[self.sql(sql) for sql in expression.args.get("laterals") or []],
1295            self.sql(expression, "where"),
1296            self.sql(expression, "group"),
1297            self.sql(expression, "having"),
1298            self.sql(expression, "qualify"),
1299            self.seg("WINDOW ") + self.expressions(expression, "windows", flat=True)
1300            if expression.args.get("windows")
1301            else "",
1302            self.sql(expression, "distribute"),
1303            self.sql(expression, "sort"),
1304            self.sql(expression, "cluster"),
1305            self.sql(expression, "order"),
1306            self.sql(expression, "limit"),
1307            self.sql(expression, "offset"),
1308            self.sql(expression, "lock"),
1309            self.sql(expression, "sample"),
1310            sep="",
1311        )
1312
1313    def select_sql(self, expression: exp.Select) -> str:
1314        hint = self.sql(expression, "hint")
1315        distinct = self.sql(expression, "distinct")
1316        distinct = f" {distinct}" if distinct else ""
1317        expressions = self.expressions(expression)
1318        expressions = f"{self.sep()}{expressions}" if expressions else expressions
1319        sql = self.query_modifiers(
1320            expression,
1321            f"SELECT{hint}{distinct}{expressions}",
1322            self.sql(expression, "into", comment=False),
1323            self.sql(expression, "from", comment=False),
1324        )
1325        return self.prepend_ctes(expression, sql)
1326
1327    def schema_sql(self, expression: exp.Schema) -> str:
1328        this = self.sql(expression, "this")
1329        this = f"{this} " if this else ""
1330        sql = f"({self.sep('')}{self.expressions(expression)}{self.seg(')', sep='')}"
1331        return f"{this}{sql}"
1332
1333    def star_sql(self, expression: exp.Star) -> str:
1334        except_ = self.expressions(expression, key="except", flat=True)
1335        except_ = f"{self.seg(self.STAR_MAPPING['except'])} ({except_})" if except_ else ""
1336        replace = self.expressions(expression, key="replace", flat=True)
1337        replace = f"{self.seg(self.STAR_MAPPING['replace'])} ({replace})" if replace else ""
1338        return f"*{except_}{replace}"
1339
1340    def structkwarg_sql(self, expression: exp.StructKwarg) -> str:
1341        return f"{self.sql(expression, 'this')} {self.sql(expression, 'expression')}"
1342
1343    def parameter_sql(self, expression: exp.Parameter) -> str:
1344        this = self.sql(expression, "this")
1345        this = f"{{{this}}}" if expression.args.get("wrapped") else f"{this}"
1346        return f"{self.PARAMETER_TOKEN}{this}"
1347
1348    def sessionparameter_sql(self, expression: exp.SessionParameter) -> str:
1349        this = self.sql(expression, "this")
1350        kind = expression.text("kind")
1351        if kind:
1352            kind = f"{kind}."
1353        return f"@@{kind}{this}"
1354
1355    def placeholder_sql(self, expression: exp.Placeholder) -> str:
1356        return f":{expression.name}" if expression.name else "?"
1357
1358    def subquery_sql(self, expression: exp.Subquery, sep: str = " AS ") -> str:
1359        alias = self.sql(expression, "alias")
1360        alias = f"{sep}{alias}" if alias else ""
1361
1362        sql = self.query_modifiers(
1363            expression,
1364            self.wrap(expression),
1365            self.expressions(expression, key="pivots", sep=" "),
1366            alias,
1367        )
1368
1369        return self.prepend_ctes(expression, sql)
1370
1371    def qualify_sql(self, expression: exp.Qualify) -> str:
1372        this = self.indent(self.sql(expression, "this"))
1373        return f"{self.seg('QUALIFY')}{self.sep()}{this}"
1374
1375    def union_sql(self, expression: exp.Union) -> str:
1376        return self.prepend_ctes(
1377            expression,
1378            self.set_operation(expression, self.union_op(expression)),
1379        )
1380
1381    def union_op(self, expression: exp.Union) -> str:
1382        kind = " DISTINCT" if self.EXPLICIT_UNION else ""
1383        kind = kind if expression.args.get("distinct") else " ALL"
1384        return f"UNION{kind}"
1385
1386    def unnest_sql(self, expression: exp.Unnest) -> str:
1387        args = self.expressions(expression, flat=True)
1388        alias = expression.args.get("alias")
1389        if alias and self.unnest_column_only:
1390            columns = alias.columns
1391            alias = self.sql(columns[0]) if columns else ""
1392        else:
1393            alias = self.sql(expression, "alias")
1394        alias = f" AS {alias}" if alias else alias
1395        ordinality = " WITH ORDINALITY" if expression.args.get("ordinality") else ""
1396        offset = expression.args.get("offset")
1397        offset = f" WITH OFFSET AS {self.sql(offset)}" if offset else ""
1398        return f"UNNEST({args}){ordinality}{alias}{offset}"
1399
1400    def where_sql(self, expression: exp.Where) -> str:
1401        this = self.indent(self.sql(expression, "this"))
1402        return f"{self.seg('WHERE')}{self.sep()}{this}"
1403
1404    def window_sql(self, expression: exp.Window) -> str:
1405        this = self.sql(expression, "this")
1406
1407        partition = self.partition_by_sql(expression)
1408
1409        order = expression.args.get("order")
1410        order_sql = self.order_sql(order, flat=True) if order else ""
1411
1412        partition_sql = partition + " " if partition and order else partition
1413
1414        spec = expression.args.get("spec")
1415        spec_sql = " " + self.window_spec_sql(spec) if spec else ""
1416
1417        alias = self.sql(expression, "alias")
1418        this = f"{this} {'AS' if expression.arg_key == 'windows' else 'OVER'}"
1419
1420        if not partition and not order and not spec and alias:
1421            return f"{this} {alias}"
1422
1423        window_args = alias + partition_sql + order_sql + spec_sql
1424
1425        return f"{this} ({window_args.strip()})"
1426
1427    def partition_by_sql(self, expression: exp.Window | exp.MatchRecognize) -> str:
1428        partition = self.expressions(expression, key="partition_by", flat=True)
1429        return f"PARTITION BY {partition}" if partition else ""
1430
1431    def window_spec_sql(self, expression: exp.WindowSpec) -> str:
1432        kind = self.sql(expression, "kind")
1433        start = csv(self.sql(expression, "start"), self.sql(expression, "start_side"), sep=" ")
1434        end = (
1435            csv(self.sql(expression, "end"), self.sql(expression, "end_side"), sep=" ")
1436            or "CURRENT ROW"
1437        )
1438        return f"{kind} BETWEEN {start} AND {end}"
1439
1440    def withingroup_sql(self, expression: exp.WithinGroup) -> str:
1441        this = self.sql(expression, "this")
1442        expression_sql = self.sql(expression, "expression")[1:]  # order has a leading space
1443        return f"{this} WITHIN GROUP ({expression_sql})"
1444
1445    def between_sql(self, expression: exp.Between) -> str:
1446        this = self.sql(expression, "this")
1447        low = self.sql(expression, "low")
1448        high = self.sql(expression, "high")
1449        return f"{this} BETWEEN {low} AND {high}"
1450
1451    def bracket_sql(self, expression: exp.Bracket) -> str:
1452        expressions = apply_index_offset(expression.expressions, self.index_offset)
1453        expressions_sql = ", ".join(self.sql(e) for e in expressions)
1454
1455        return f"{self.sql(expression, 'this')}[{expressions_sql}]"
1456
1457    def all_sql(self, expression: exp.All) -> str:
1458        return f"ALL {self.wrap(expression)}"
1459
1460    def any_sql(self, expression: exp.Any) -> str:
1461        this = self.sql(expression, "this")
1462        if isinstance(expression.this, exp.Subqueryable):
1463            this = self.wrap(this)
1464        return f"ANY {this}"
1465
1466    def exists_sql(self, expression: exp.Exists) -> str:
1467        return f"EXISTS{self.wrap(expression)}"
1468
1469    def case_sql(self, expression: exp.Case) -> str:
1470        this = self.sql(expression, "this")
1471        statements = [f"CASE {this}" if this else "CASE"]
1472
1473        for e in expression.args["ifs"]:
1474            statements.append(f"WHEN {self.sql(e, 'this')}")
1475            statements.append(f"THEN {self.sql(e, 'true')}")
1476
1477        default = self.sql(expression, "default")
1478
1479        if default:
1480            statements.append(f"ELSE {default}")
1481
1482        statements.append("END")
1483
1484        if self.pretty and self.text_width(statements) > self._max_text_width:
1485            return self.indent("\n".join(statements), skip_first=True, skip_last=True)
1486
1487        return " ".join(statements)
1488
1489    def constraint_sql(self, expression: exp.Constraint) -> str:
1490        this = self.sql(expression, "this")
1491        expressions = self.expressions(expression, flat=True)
1492        return f"CONSTRAINT {this} {expressions}"
1493
1494    def extract_sql(self, expression: exp.Extract) -> str:
1495        this = self.sql(expression, "this")
1496        expression_sql = self.sql(expression, "expression")
1497        return f"EXTRACT({this} FROM {expression_sql})"
1498
1499    def trim_sql(self, expression: exp.Trim) -> str:
1500        trim_type = self.sql(expression, "position")
1501
1502        if trim_type == "LEADING":
1503            return self.func("LTRIM", expression.this)
1504        elif trim_type == "TRAILING":
1505            return self.func("RTRIM", expression.this)
1506        else:
1507            return self.func("TRIM", expression.this, expression.expression)
1508
1509    def concat_sql(self, expression: exp.Concat) -> str:
1510        if len(expression.expressions) == 1:
1511            return self.sql(expression.expressions[0])
1512        return self.function_fallback_sql(expression)
1513
1514    def check_sql(self, expression: exp.Check) -> str:
1515        this = self.sql(expression, key="this")
1516        return f"CHECK ({this})"
1517
1518    def foreignkey_sql(self, expression: exp.ForeignKey) -> str:
1519        expressions = self.expressions(expression, flat=True)
1520        reference = self.sql(expression, "reference")
1521        reference = f" {reference}" if reference else ""
1522        delete = self.sql(expression, "delete")
1523        delete = f" ON DELETE {delete}" if delete else ""
1524        update = self.sql(expression, "update")
1525        update = f" ON UPDATE {update}" if update else ""
1526        return f"FOREIGN KEY ({expressions}){reference}{delete}{update}"
1527
1528    def primarykey_sql(self, expression: exp.ForeignKey) -> str:
1529        expressions = self.expressions(expression, flat=True)
1530        options = self.expressions(expression, "options", flat=True, sep=" ")
1531        options = f" {options}" if options else ""
1532        return f"PRIMARY KEY ({expressions}){options}"
1533
1534    def unique_sql(self, expression: exp.Unique) -> str:
1535        columns = self.expressions(expression, key="expressions")
1536        return f"UNIQUE ({columns})"
1537
1538    def if_sql(self, expression: exp.If) -> str:
1539        return self.case_sql(
1540            exp.Case(ifs=[expression.copy()], default=expression.args.get("false"))
1541        )
1542
1543    def in_sql(self, expression: exp.In) -> str:
1544        query = expression.args.get("query")
1545        unnest = expression.args.get("unnest")
1546        field = expression.args.get("field")
1547        is_global = " GLOBAL" if expression.args.get("is_global") else ""
1548
1549        if query:
1550            in_sql = self.wrap(query)
1551        elif unnest:
1552            in_sql = self.in_unnest_op(unnest)
1553        elif field:
1554            in_sql = self.sql(field)
1555        else:
1556            in_sql = f"({self.expressions(expression, flat=True)})"
1557
1558        return f"{self.sql(expression, 'this')}{is_global} IN {in_sql}"
1559
1560    def in_unnest_op(self, unnest: exp.Unnest) -> str:
1561        return f"(SELECT {self.sql(unnest)})"
1562
1563    def interval_sql(self, expression: exp.Interval) -> str:
1564        this = expression.args.get("this")
1565        if this:
1566            this = (
1567                f" {this}"
1568                if isinstance(this, exp.Literal) or isinstance(this, exp.Paren)
1569                else f" ({this})"
1570            )
1571        else:
1572            this = ""
1573        unit = self.sql(expression, "unit")
1574        unit = f" {unit}" if unit else ""
1575        return f"INTERVAL{this}{unit}"
1576
1577    def return_sql(self, expression: exp.Return) -> str:
1578        return f"RETURN {self.sql(expression, 'this')}"
1579
1580    def reference_sql(self, expression: exp.Reference) -> str:
1581        this = self.sql(expression, "this")
1582        expressions = self.expressions(expression, flat=True)
1583        expressions = f"({expressions})" if expressions else ""
1584        options = self.expressions(expression, "options", flat=True, sep=" ")
1585        options = f" {options}" if options else ""
1586        return f"REFERENCES {this}{expressions}{options}"
1587
1588    def anonymous_sql(self, expression: exp.Anonymous) -> str:
1589        return self.func(expression.name, *expression.expressions)
1590
1591    def paren_sql(self, expression: exp.Paren) -> str:
1592        if isinstance(expression.unnest(), exp.Select):
1593            sql = self.wrap(expression)
1594        else:
1595            sql = self.seg(self.indent(self.sql(expression, "this")), sep="")
1596            sql = f"({sql}{self.seg(')', sep='')}"
1597
1598        return self.prepend_ctes(expression, sql)
1599
1600    def neg_sql(self, expression: exp.Neg) -> str:
1601        # This makes sure we don't convert "- - 5" to "--5", which is a comment
1602        this_sql = self.sql(expression, "this")
1603        sep = " " if this_sql[0] == "-" else ""
1604        return f"-{sep}{this_sql}"
1605
1606    def not_sql(self, expression: exp.Not) -> str:
1607        return f"NOT {self.sql(expression, 'this')}"
1608
1609    def alias_sql(self, expression: exp.Alias) -> str:
1610        to_sql = self.sql(expression, "alias")
1611        to_sql = f" AS {to_sql}" if to_sql else ""
1612        return f"{self.sql(expression, 'this')}{to_sql}"
1613
1614    def aliases_sql(self, expression: exp.Aliases) -> str:
1615        return f"{self.sql(expression, 'this')} AS ({self.expressions(expression, flat=True)})"
1616
1617    def attimezone_sql(self, expression: exp.AtTimeZone) -> str:
1618        this = self.sql(expression, "this")
1619        zone = self.sql(expression, "zone")
1620        return f"{this} AT TIME ZONE {zone}"
1621
1622    def add_sql(self, expression: exp.Add) -> str:
1623        return self.binary(expression, "+")
1624
1625    def and_sql(self, expression: exp.And) -> str:
1626        return self.connector_sql(expression, "AND")
1627
1628    def connector_sql(self, expression: exp.Connector, op: str) -> str:
1629        if not self.pretty:
1630            return self.binary(expression, op)
1631
1632        sqls = tuple(self.sql(e) for e in expression.flatten(unnest=False))
1633        sep = "\n" if self.text_width(sqls) > self._max_text_width else " "
1634        return f"{sep}{op} ".join(sqls)
1635
1636    def bitwiseand_sql(self, expression: exp.BitwiseAnd) -> str:
1637        return self.binary(expression, "&")
1638
1639    def bitwiseleftshift_sql(self, expression: exp.BitwiseLeftShift) -> str:
1640        return self.binary(expression, "<<")
1641
1642    def bitwisenot_sql(self, expression: exp.BitwiseNot) -> str:
1643        return f"~{self.sql(expression, 'this')}"
1644
1645    def bitwiseor_sql(self, expression: exp.BitwiseOr) -> str:
1646        return self.binary(expression, "|")
1647
1648    def bitwiserightshift_sql(self, expression: exp.BitwiseRightShift) -> str:
1649        return self.binary(expression, ">>")
1650
1651    def bitwisexor_sql(self, expression: exp.BitwiseXor) -> str:
1652        return self.binary(expression, "^")
1653
1654    def cast_sql(self, expression: exp.Cast) -> str:
1655        return f"CAST({self.sql(expression, 'this')} AS {self.sql(expression, 'to')})"
1656
1657    def currentdate_sql(self, expression: exp.CurrentDate) -> str:
1658        zone = self.sql(expression, "this")
1659        return f"CURRENT_DATE({zone})" if zone else "CURRENT_DATE"
1660
1661    def collate_sql(self, expression: exp.Collate) -> str:
1662        return self.binary(expression, "COLLATE")
1663
1664    def command_sql(self, expression: exp.Command) -> str:
1665        return f"{self.sql(expression, 'this').upper()} {expression.text('expression').strip()}"
1666
1667    def comment_sql(self, expression: exp.Comment) -> str:
1668        this = self.sql(expression, "this")
1669        kind = expression.args["kind"]
1670        exists_sql = " IF EXISTS " if expression.args.get("exists") else " "
1671        expression_sql = self.sql(expression, "expression")
1672        return f"COMMENT{exists_sql}ON {kind} {this} IS {expression_sql}"
1673
1674    def transaction_sql(self, *_) -> str:
1675        return "BEGIN"
1676
1677    def commit_sql(self, expression: exp.Commit) -> str:
1678        chain = expression.args.get("chain")
1679        if chain is not None:
1680            chain = " AND CHAIN" if chain else " AND NO CHAIN"
1681
1682        return f"COMMIT{chain or ''}"
1683
1684    def rollback_sql(self, expression: exp.Rollback) -> str:
1685        savepoint = expression.args.get("savepoint")
1686        savepoint = f" TO {savepoint}" if savepoint else ""
1687        return f"ROLLBACK{savepoint}"
1688
1689    def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
1690        this = self.sql(expression, "this")
1691
1692        dtype = self.sql(expression, "dtype")
1693        if dtype:
1694            collate = self.sql(expression, "collate")
1695            collate = f" COLLATE {collate}" if collate else ""
1696            using = self.sql(expression, "using")
1697            using = f" USING {using}" if using else ""
1698            return f"ALTER COLUMN {this} TYPE {dtype}{collate}{using}"
1699
1700        default = self.sql(expression, "default")
1701        if default:
1702            return f"ALTER COLUMN {this} SET DEFAULT {default}"
1703
1704        if not expression.args.get("drop"):
1705            self.unsupported("Unsupported ALTER COLUMN syntax")
1706
1707        return f"ALTER COLUMN {this} DROP DEFAULT"
1708
1709    def renametable_sql(self, expression: exp.RenameTable) -> str:
1710        this = self.sql(expression, "this")
1711        return f"RENAME TO {this}"
1712
1713    def altertable_sql(self, expression: exp.AlterTable) -> str:
1714        actions = expression.args["actions"]
1715
1716        if isinstance(actions[0], exp.ColumnDef):
1717            actions = self.expressions(expression, "actions", prefix="ADD COLUMN ")
1718        elif isinstance(actions[0], exp.Schema):
1719            actions = self.expressions(expression, "actions", prefix="ADD COLUMNS ")
1720        elif isinstance(actions[0], exp.Delete):
1721            actions = self.expressions(expression, "actions", flat=True)
1722        else:
1723            actions = self.expressions(expression, "actions")
1724
1725        exists = " IF EXISTS" if expression.args.get("exists") else ""
1726        return f"ALTER TABLE{exists} {self.sql(expression, 'this')} {actions}"
1727
1728    def droppartition_sql(self, expression: exp.DropPartition) -> str:
1729        expressions = self.expressions(expression)
1730        exists = " IF EXISTS " if expression.args.get("exists") else " "
1731        return f"DROP{exists}{expressions}"
1732
1733    def addconstraint_sql(self, expression: exp.AddConstraint) -> str:
1734        this = self.sql(expression, "this")
1735        expression_ = self.sql(expression, "expression")
1736        add_constraint = f"ADD CONSTRAINT {this}" if this else "ADD"
1737
1738        enforced = expression.args.get("enforced")
1739        if enforced is not None:
1740            return f"{add_constraint} CHECK ({expression_}){' ENFORCED' if enforced else ''}"
1741
1742        return f"{add_constraint} {expression_}"
1743
1744    def distinct_sql(self, expression: exp.Distinct) -> str:
1745        this = self.expressions(expression, flat=True)
1746        this = f" {this}" if this else ""
1747
1748        on = self.sql(expression, "on")
1749        on = f" ON {on}" if on else ""
1750        return f"DISTINCT{this}{on}"
1751
1752    def ignorenulls_sql(self, expression: exp.IgnoreNulls) -> str:
1753        return f"{self.sql(expression, 'this')} IGNORE NULLS"
1754
1755    def respectnulls_sql(self, expression: exp.RespectNulls) -> str:
1756        return f"{self.sql(expression, 'this')} RESPECT NULLS"
1757
1758    def intdiv_sql(self, expression: exp.IntDiv) -> str:
1759        div = self.binary(expression, "/")
1760        return self.sql(exp.Cast(this=div, to=exp.DataType.build("INT")))
1761
1762    def dpipe_sql(self, expression: exp.DPipe) -> str:
1763        return self.binary(expression, "||")
1764
1765    def div_sql(self, expression: exp.Div) -> str:
1766        div = self.binary(expression, "/")
1767
1768        if not self.INTEGER_DIVISION:
1769            return self.sql(exp.Cast(this=div, to=exp.DataType.build("INT")))
1770
1771        return div
1772
1773    def floatdiv_sql(self, expression: exp.FloatDiv) -> str:
1774        if self.INTEGER_DIVISION:
1775            this = exp.Cast(this=expression.this, to=exp.DataType.build("DOUBLE"))
1776            return self.div_sql(exp.Div(this=this, expression=expression.expression))
1777
1778        return self.binary(expression, "/")
1779
1780    def overlaps_sql(self, expression: exp.Overlaps) -> str:
1781        return self.binary(expression, "OVERLAPS")
1782
1783    def distance_sql(self, expression: exp.Distance) -> str:
1784        return self.binary(expression, "<->")
1785
1786    def dot_sql(self, expression: exp.Dot) -> str:
1787        return f"{self.sql(expression, 'this')}.{self.sql(expression, 'expression')}"
1788
1789    def eq_sql(self, expression: exp.EQ) -> str:
1790        return self.binary(expression, "=")
1791
1792    def escape_sql(self, expression: exp.Escape) -> str:
1793        return self.binary(expression, "ESCAPE")
1794
1795    def glob_sql(self, expression: exp.Glob) -> str:
1796        return self.binary(expression, "GLOB")
1797
1798    def gt_sql(self, expression: exp.GT) -> str:
1799        return self.binary(expression, ">")
1800
1801    def gte_sql(self, expression: exp.GTE) -> str:
1802        return self.binary(expression, ">=")
1803
1804    def ilike_sql(self, expression: exp.ILike) -> str:
1805        return self.binary(expression, "ILIKE")
1806
1807    def is_sql(self, expression: exp.Is) -> str:
1808        return self.binary(expression, "IS")
1809
1810    def like_sql(self, expression: exp.Like) -> str:
1811        return self.binary(expression, "LIKE")
1812
1813    def similarto_sql(self, expression: exp.SimilarTo) -> str:
1814        return self.binary(expression, "SIMILAR TO")
1815
1816    def lt_sql(self, expression: exp.LT) -> str:
1817        return self.binary(expression, "<")
1818
1819    def lte_sql(self, expression: exp.LTE) -> str:
1820        return self.binary(expression, "<=")
1821
1822    def mod_sql(self, expression: exp.Mod) -> str:
1823        return self.binary(expression, "%")
1824
1825    def mul_sql(self, expression: exp.Mul) -> str:
1826        return self.binary(expression, "*")
1827
1828    def neq_sql(self, expression: exp.NEQ) -> str:
1829        return self.binary(expression, "<>")
1830
1831    def nullsafeeq_sql(self, expression: exp.NullSafeEQ) -> str:
1832        return self.binary(expression, "IS NOT DISTINCT FROM")
1833
1834    def nullsafeneq_sql(self, expression: exp.NullSafeNEQ) -> str:
1835        return self.binary(expression, "IS DISTINCT FROM")
1836
1837    def or_sql(self, expression: exp.Or) -> str:
1838        return self.connector_sql(expression, "OR")
1839
1840    def slice_sql(self, expression: exp.Slice) -> str:
1841        return self.binary(expression, ":")
1842
1843    def sub_sql(self, expression: exp.Sub) -> str:
1844        return self.binary(expression, "-")
1845
1846    def trycast_sql(self, expression: exp.TryCast) -> str:
1847        return f"TRY_CAST({self.sql(expression, 'this')} AS {self.sql(expression, 'to')})"
1848
1849    def use_sql(self, expression: exp.Use) -> str:
1850        kind = self.sql(expression, "kind")
1851        kind = f" {kind}" if kind else ""
1852        this = self.sql(expression, "this")
1853        this = f" {this}" if this else ""
1854        return f"USE{kind}{this}"
1855
1856    def binary(self, expression: exp.Binary, op: str) -> str:
1857        return f"{self.sql(expression, 'this')} {op} {self.sql(expression, 'expression')}"
1858
1859    def function_fallback_sql(self, expression: exp.Func) -> str:
1860        args = []
1861        for arg_value in expression.args.values():
1862            if isinstance(arg_value, list):
1863                for value in arg_value:
1864                    args.append(value)
1865            else:
1866                args.append(arg_value)
1867
1868        return self.func(expression.sql_name(), *args)
1869
1870    def func(self, name: str, *args: t.Optional[exp.Expression | str]) -> str:
1871        return f"{self.normalize_func(name)}({self.format_args(*args)})"
1872
1873    def format_args(self, *args: t.Optional[str | exp.Expression]) -> str:
1874        arg_sqls = tuple(self.sql(arg) for arg in args if arg is not None)
1875        if self.pretty and self.text_width(arg_sqls) > self._max_text_width:
1876            return self.indent("\n" + f",\n".join(arg_sqls) + "\n", skip_first=True, skip_last=True)
1877        return ", ".join(arg_sqls)
1878
1879    def text_width(self, args: t.Iterable) -> int:
1880        return sum(len(arg) for arg in args)
1881
1882    def format_time(self, expression: exp.Expression) -> t.Optional[str]:
1883        return format_time(self.sql(expression, "format"), self.time_mapping, self.time_trie)
1884
1885    def expressions(
1886        self,
1887        expression: exp.Expression,
1888        key: t.Optional[str] = None,
1889        flat: bool = False,
1890        indent: bool = True,
1891        sep: str = ", ",
1892        prefix: str = "",
1893    ) -> str:
1894        expressions = expression.args.get(key or "expressions")
1895
1896        if not expressions:
1897            return ""
1898
1899        if flat:
1900            return sep.join(self.sql(e) for e in expressions)
1901
1902        num_sqls = len(expressions)
1903
1904        # These are calculated once in case we have the leading_comma / pretty option set, correspondingly
1905        pad = " " * self.pad
1906        stripped_sep = sep.strip()
1907
1908        result_sqls = []
1909        for i, e in enumerate(expressions):
1910            sql = self.sql(e, comment=False)
1911            comments = self.maybe_comment("", e) if isinstance(e, exp.Expression) else ""
1912
1913            if self.pretty:
1914                if self._leading_comma:
1915                    result_sqls.append(f"{sep if i > 0 else pad}{prefix}{sql}{comments}")
1916                else:
1917                    result_sqls.append(
1918                        f"{prefix}{sql}{stripped_sep if i + 1 < num_sqls else ''}{comments}"
1919                    )
1920            else:
1921                result_sqls.append(f"{prefix}{sql}{comments}{sep if i + 1 < num_sqls else ''}")
1922
1923        result_sql = "\n".join(result_sqls) if self.pretty else "".join(result_sqls)
1924        return self.indent(result_sql, skip_first=False) if indent else result_sql
1925
1926    def op_expressions(self, op: str, expression: exp.Expression, flat: bool = False) -> str:
1927        flat = flat or isinstance(expression.parent, exp.Properties)
1928        expressions_sql = self.expressions(expression, flat=flat)
1929        if flat:
1930            return f"{op} {expressions_sql}"
1931        return f"{self.seg(op)}{self.sep() if expressions_sql else ''}{expressions_sql}"
1932
1933    def naked_property(self, expression: exp.Property) -> str:
1934        property_name = exp.Properties.PROPERTY_TO_NAME.get(expression.__class__)
1935        if not property_name:
1936            self.unsupported(f"Unsupported property {expression.__class__.__name__}")
1937        return f"{property_name} {self.sql(expression, 'this')}"
1938
1939    def set_operation(self, expression: exp.Expression, op: str) -> str:
1940        this = self.sql(expression, "this")
1941        op = self.seg(op)
1942        return self.query_modifiers(
1943            expression, f"{this}{op}{self.sep()}{self.sql(expression, 'expression')}"
1944        )
1945
1946    def tag_sql(self, expression: exp.Tag) -> str:
1947        return f"{expression.args.get('prefix')}{self.sql(expression.this)}{expression.args.get('postfix')}"
1948
1949    def token_sql(self, token_type: TokenType) -> str:
1950        return self.TOKEN_MAPPING.get(token_type, token_type.name)
1951
1952    def userdefinedfunction_sql(self, expression: exp.UserDefinedFunction) -> str:
1953        this = self.sql(expression, "this")
1954        expressions = self.no_identify(self.expressions, expression)
1955        expressions = (
1956            self.wrap(expressions) if expression.args.get("wrapped") else f" {expressions}"
1957        )
1958        return f"{this}{expressions}"
1959
1960    def joinhint_sql(self, expression: exp.JoinHint) -> str:
1961        this = self.sql(expression, "this")
1962        expressions = self.expressions(expression, flat=True)
1963        return f"{this}({expressions})"
1964
1965    def kwarg_sql(self, expression: exp.Kwarg) -> str:
1966        return self.binary(expression, "=>")
1967
1968    def when_sql(self, expression: exp.When) -> str:
1969        matched = "MATCHED" if expression.args["matched"] else "NOT MATCHED"
1970        source = " BY SOURCE" if self.MATCHED_BY_SOURCE and expression.args.get("source") else ""
1971        condition = self.sql(expression, "condition")
1972        condition = f" AND {condition}" if condition else ""
1973
1974        then_expression = expression.args.get("then")
1975        if isinstance(then_expression, exp.Insert):
1976            then = f"INSERT {self.sql(then_expression, 'this')}"
1977            if "expression" in then_expression.args:
1978                then += f" VALUES {self.sql(then_expression, 'expression')}"
1979        elif isinstance(then_expression, exp.Update):
1980            if isinstance(then_expression.args.get("expressions"), exp.Star):
1981                then = f"UPDATE {self.sql(then_expression, 'expressions')}"
1982            else:
1983                then = f"UPDATE SET {self.expressions(then_expression, flat=True)}"
1984        else:
1985            then = self.sql(then_expression)
1986        return f"WHEN {matched}{source}{condition} THEN {then}"
1987
1988    def merge_sql(self, expression: exp.Merge) -> str:
1989        this = self.sql(expression, "this")
1990        using = f"USING {self.sql(expression, 'using')}"
1991        on = f"ON {self.sql(expression, 'on')}"
1992        return f"MERGE INTO {this} {using} {on} {self.expressions(expression, sep=' ')}"