sqlglot.dialects.tsql

   1from __future__ import annotations
   2
   3import datetime
   4import re
   5import typing as t
   6
   7from sqlglot import exp, generator, parser, tokens, transforms
   8from sqlglot.dialects.dialect import (
   9    Dialect,
  10    NormalizationStrategy,
  11    any_value_to_max_sql,
  12    date_delta_sql,
  13    datestrtodate_sql,
  14    generatedasidentitycolumnconstraint_sql,
  15    max_or_greatest,
  16    min_or_least,
  17    build_date_delta,
  18    rename_func,
  19    timestrtotime_sql,
  20    trim_sql,
  21)
  22from sqlglot.helper import seq_get
  23from sqlglot.time import format_time
  24from sqlglot.tokens import TokenType
  25
  26if t.TYPE_CHECKING:
  27    from sqlglot._typing import E
  28
  29FULL_FORMAT_TIME_MAPPING = {
  30    "weekday": "%A",
  31    "dw": "%A",
  32    "w": "%A",
  33    "month": "%B",
  34    "mm": "%B",
  35    "m": "%B",
  36}
  37
  38DATE_DELTA_INTERVAL = {
  39    "year": "year",
  40    "yyyy": "year",
  41    "yy": "year",
  42    "quarter": "quarter",
  43    "qq": "quarter",
  44    "q": "quarter",
  45    "month": "month",
  46    "mm": "month",
  47    "m": "month",
  48    "week": "week",
  49    "ww": "week",
  50    "wk": "week",
  51    "day": "day",
  52    "dd": "day",
  53    "d": "day",
  54}
  55
  56
  57DATE_FMT_RE = re.compile("([dD]{1,2})|([mM]{1,2})|([yY]{1,4})|([hH]{1,2})|([sS]{1,2})")
  58
  59# N = Numeric, C=Currency
  60TRANSPILE_SAFE_NUMBER_FMT = {"N", "C"}
  61
  62DEFAULT_START_DATE = datetime.date(1900, 1, 1)
  63
  64BIT_TYPES = {exp.EQ, exp.NEQ, exp.Is, exp.In, exp.Select, exp.Alias}
  65
  66# Unsupported options:
  67# - OPTIMIZE FOR ( @variable_name { UNKNOWN | = <literal_constant> } [ , ...n ] )
  68# - TABLE HINT
  69OPTIONS: parser.OPTIONS_TYPE = {
  70    **dict.fromkeys(
  71        (
  72            "DISABLE_OPTIMIZED_PLAN_FORCING",
  73            "FAST",
  74            "IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX",
  75            "LABEL",
  76            "MAXDOP",
  77            "MAXRECURSION",
  78            "MAX_GRANT_PERCENT",
  79            "MIN_GRANT_PERCENT",
  80            "NO_PERFORMANCE_SPOOL",
  81            "QUERYTRACEON",
  82            "RECOMPILE",
  83        ),
  84        tuple(),
  85    ),
  86    "CONCAT": ("UNION",),
  87    "DISABLE": ("EXTERNALPUSHDOWN", "SCALEOUTEXECUTION"),
  88    "EXPAND": ("VIEWS",),
  89    "FORCE": ("EXTERNALPUSHDOWN", "ORDER", "SCALEOUTEXECUTION"),
  90    "HASH": ("GROUP", "JOIN", "UNION"),
  91    "KEEP": ("PLAN",),
  92    "KEEPFIXED": ("PLAN",),
  93    "LOOP": ("JOIN",),
  94    "MERGE": ("JOIN", "UNION"),
  95    "OPTIMIZE": (("FOR", "UNKNOWN"),),
  96    "ORDER": ("GROUP",),
  97    "PARAMETERIZATION": ("FORCED", "SIMPLE"),
  98    "ROBUST": ("PLAN",),
  99    "USE": ("PLAN",),
 100}
 101
 102OPTIONS_THAT_REQUIRE_EQUAL = ("MAX_GRANT_PERCENT", "MIN_GRANT_PERCENT", "LABEL")
 103
 104
 105def _build_formatted_time(
 106    exp_class: t.Type[E], full_format_mapping: t.Optional[bool] = None
 107) -> t.Callable[[t.List], E]:
 108    def _builder(args: t.List) -> E:
 109        assert len(args) == 2
 110
 111        return exp_class(
 112            this=exp.cast(args[1], exp.DataType.Type.DATETIME),
 113            format=exp.Literal.string(
 114                format_time(
 115                    args[0].name.lower(),
 116                    (
 117                        {**TSQL.TIME_MAPPING, **FULL_FORMAT_TIME_MAPPING}
 118                        if full_format_mapping
 119                        else TSQL.TIME_MAPPING
 120                    ),
 121                )
 122            ),
 123        )
 124
 125    return _builder
 126
 127
 128def _build_format(args: t.List) -> exp.NumberToStr | exp.TimeToStr:
 129    this = seq_get(args, 0)
 130    fmt = seq_get(args, 1)
 131    culture = seq_get(args, 2)
 132
 133    number_fmt = fmt and (fmt.name in TRANSPILE_SAFE_NUMBER_FMT or not DATE_FMT_RE.search(fmt.name))
 134
 135    if number_fmt:
 136        return exp.NumberToStr(this=this, format=fmt, culture=culture)
 137
 138    if fmt:
 139        fmt = exp.Literal.string(
 140            format_time(fmt.name, TSQL.FORMAT_TIME_MAPPING)
 141            if len(fmt.name) == 1
 142            else format_time(fmt.name, TSQL.TIME_MAPPING)
 143        )
 144
 145    return exp.TimeToStr(this=this, format=fmt, culture=culture)
 146
 147
 148def _build_eomonth(args: t.List) -> exp.LastDay:
 149    date = exp.TsOrDsToDate(this=seq_get(args, 0))
 150    month_lag = seq_get(args, 1)
 151
 152    if month_lag is None:
 153        this: exp.Expression = date
 154    else:
 155        unit = DATE_DELTA_INTERVAL.get("month")
 156        this = exp.DateAdd(this=date, expression=month_lag, unit=unit and exp.var(unit))
 157
 158    return exp.LastDay(this=this)
 159
 160
 161def _build_hashbytes(args: t.List) -> exp.Expression:
 162    kind, data = args
 163    kind = kind.name.upper() if kind.is_string else ""
 164
 165    if kind == "MD5":
 166        args.pop(0)
 167        return exp.MD5(this=data)
 168    if kind in ("SHA", "SHA1"):
 169        args.pop(0)
 170        return exp.SHA(this=data)
 171    if kind == "SHA2_256":
 172        return exp.SHA2(this=data, length=exp.Literal.number(256))
 173    if kind == "SHA2_512":
 174        return exp.SHA2(this=data, length=exp.Literal.number(512))
 175
 176    return exp.func("HASHBYTES", *args)
 177
 178
 179DATEPART_ONLY_FORMATS = {"DW", "HOUR", "QUARTER"}
 180
 181
 182def _format_sql(self: TSQL.Generator, expression: exp.NumberToStr | exp.TimeToStr) -> str:
 183    fmt = expression.args["format"]
 184
 185    if not isinstance(expression, exp.NumberToStr):
 186        if fmt.is_string:
 187            mapped_fmt = format_time(fmt.name, TSQL.INVERSE_TIME_MAPPING)
 188
 189            name = (mapped_fmt or "").upper()
 190            if name in DATEPART_ONLY_FORMATS:
 191                return self.func("DATEPART", name, expression.this)
 192
 193            fmt_sql = self.sql(exp.Literal.string(mapped_fmt))
 194        else:
 195            fmt_sql = self.format_time(expression) or self.sql(fmt)
 196    else:
 197        fmt_sql = self.sql(fmt)
 198
 199    return self.func("FORMAT", expression.this, fmt_sql, expression.args.get("culture"))
 200
 201
 202def _string_agg_sql(self: TSQL.Generator, expression: exp.GroupConcat) -> str:
 203    this = expression.this
 204    distinct = expression.find(exp.Distinct)
 205    if distinct:
 206        # exp.Distinct can appear below an exp.Order or an exp.GroupConcat expression
 207        self.unsupported("T-SQL STRING_AGG doesn't support DISTINCT.")
 208        this = distinct.pop().expressions[0]
 209
 210    order = ""
 211    if isinstance(expression.this, exp.Order):
 212        if expression.this.this:
 213            this = expression.this.this.pop()
 214        order = f" WITHIN GROUP ({self.sql(expression.this)[1:]})"  # Order has a leading space
 215
 216    separator = expression.args.get("separator") or exp.Literal.string(",")
 217    return f"STRING_AGG({self.format_args(this, separator)}){order}"
 218
 219
 220def _build_date_delta(
 221    exp_class: t.Type[E], unit_mapping: t.Optional[t.Dict[str, str]] = None
 222) -> t.Callable[[t.List], E]:
 223    def _builder(args: t.List) -> E:
 224        unit = seq_get(args, 0)
 225        if unit and unit_mapping:
 226            unit = exp.var(unit_mapping.get(unit.name.lower(), unit.name))
 227
 228        start_date = seq_get(args, 1)
 229        if start_date and start_date.is_number:
 230            # Numeric types are valid DATETIME values
 231            if start_date.is_int:
 232                adds = DEFAULT_START_DATE + datetime.timedelta(days=int(start_date.this))
 233                start_date = exp.Literal.string(adds.strftime("%F"))
 234            else:
 235                # We currently don't handle float values, i.e. they're not converted to equivalent DATETIMEs.
 236                # This is not a problem when generating T-SQL code, it is when transpiling to other dialects.
 237                return exp_class(this=seq_get(args, 2), expression=start_date, unit=unit)
 238
 239        return exp_class(
 240            this=exp.TimeStrToTime(this=seq_get(args, 2)),
 241            expression=exp.TimeStrToTime(this=start_date),
 242            unit=unit,
 243        )
 244
 245    return _builder
 246
 247
 248def qualify_derived_table_outputs(expression: exp.Expression) -> exp.Expression:
 249    """Ensures all (unnamed) output columns are aliased for CTEs and Subqueries."""
 250    alias = expression.args.get("alias")
 251
 252    if (
 253        isinstance(expression, (exp.CTE, exp.Subquery))
 254        and isinstance(alias, exp.TableAlias)
 255        and not alias.columns
 256    ):
 257        from sqlglot.optimizer.qualify_columns import qualify_outputs
 258
 259        # We keep track of the unaliased column projection indexes instead of the expressions
 260        # themselves, because the latter are going to be replaced by new nodes when the aliases
 261        # are added and hence we won't be able to reach these newly added Alias parents
 262        query = expression.this
 263        unaliased_column_indexes = (
 264            i for i, c in enumerate(query.selects) if isinstance(c, exp.Column) and not c.alias
 265        )
 266
 267        qualify_outputs(query)
 268
 269        # Preserve the quoting information of columns for newly added Alias nodes
 270        query_selects = query.selects
 271        for select_index in unaliased_column_indexes:
 272            alias = query_selects[select_index]
 273            column = alias.this
 274            if isinstance(column.this, exp.Identifier):
 275                alias.args["alias"].set("quoted", column.this.quoted)
 276
 277    return expression
 278
 279
 280# https://learn.microsoft.com/en-us/sql/t-sql/functions/datetimefromparts-transact-sql?view=sql-server-ver16#syntax
 281def _build_datetimefromparts(args: t.List) -> exp.TimestampFromParts:
 282    return exp.TimestampFromParts(
 283        year=seq_get(args, 0),
 284        month=seq_get(args, 1),
 285        day=seq_get(args, 2),
 286        hour=seq_get(args, 3),
 287        min=seq_get(args, 4),
 288        sec=seq_get(args, 5),
 289        milli=seq_get(args, 6),
 290    )
 291
 292
 293# https://learn.microsoft.com/en-us/sql/t-sql/functions/timefromparts-transact-sql?view=sql-server-ver16#syntax
 294def _build_timefromparts(args: t.List) -> exp.TimeFromParts:
 295    return exp.TimeFromParts(
 296        hour=seq_get(args, 0),
 297        min=seq_get(args, 1),
 298        sec=seq_get(args, 2),
 299        fractions=seq_get(args, 3),
 300        precision=seq_get(args, 4),
 301    )
 302
 303
 304def _build_with_arg_as_text(
 305    klass: t.Type[exp.Expression],
 306) -> t.Callable[[t.List[exp.Expression]], exp.Expression]:
 307    def _parse(args: t.List[exp.Expression]) -> exp.Expression:
 308        this = seq_get(args, 0)
 309
 310        if this and not this.is_string:
 311            this = exp.cast(this, exp.DataType.Type.TEXT)
 312
 313        expression = seq_get(args, 1)
 314        kwargs = {"this": this}
 315
 316        if expression:
 317            kwargs["expression"] = expression
 318
 319        return klass(**kwargs)
 320
 321    return _parse
 322
 323
 324def _json_extract_sql(
 325    self: TSQL.Generator, expression: exp.JSONExtract | exp.JSONExtractScalar
 326) -> str:
 327    json_query = self.func("JSON_QUERY", expression.this, expression.expression)
 328    json_value = self.func("JSON_VALUE", expression.this, expression.expression)
 329    return self.func("ISNULL", json_query, json_value)
 330
 331
 332class TSQL(Dialect):
 333    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
 334    TIME_FORMAT = "'yyyy-mm-dd hh:mm:ss'"
 335    SUPPORTS_SEMI_ANTI_JOIN = False
 336    LOG_BASE_FIRST = False
 337    TYPED_DIVISION = True
 338    CONCAT_COALESCE = True
 339
 340    TIME_MAPPING = {
 341        "year": "%Y",
 342        "dayofyear": "%j",
 343        "day": "%d",
 344        "dy": "%d",
 345        "y": "%Y",
 346        "week": "%W",
 347        "ww": "%W",
 348        "wk": "%W",
 349        "hour": "%h",
 350        "hh": "%I",
 351        "minute": "%M",
 352        "mi": "%M",
 353        "n": "%M",
 354        "second": "%S",
 355        "ss": "%S",
 356        "s": "%-S",
 357        "millisecond": "%f",
 358        "ms": "%f",
 359        "weekday": "%W",
 360        "dw": "%W",
 361        "month": "%m",
 362        "mm": "%M",
 363        "m": "%-M",
 364        "Y": "%Y",
 365        "YYYY": "%Y",
 366        "YY": "%y",
 367        "MMMM": "%B",
 368        "MMM": "%b",
 369        "MM": "%m",
 370        "M": "%-m",
 371        "dddd": "%A",
 372        "dd": "%d",
 373        "d": "%-d",
 374        "HH": "%H",
 375        "H": "%-H",
 376        "h": "%-I",
 377        "S": "%f",
 378        "yyyy": "%Y",
 379        "yy": "%y",
 380    }
 381
 382    CONVERT_FORMAT_MAPPING = {
 383        "0": "%b %d %Y %-I:%M%p",
 384        "1": "%m/%d/%y",
 385        "2": "%y.%m.%d",
 386        "3": "%d/%m/%y",
 387        "4": "%d.%m.%y",
 388        "5": "%d-%m-%y",
 389        "6": "%d %b %y",
 390        "7": "%b %d, %y",
 391        "8": "%H:%M:%S",
 392        "9": "%b %d %Y %-I:%M:%S:%f%p",
 393        "10": "mm-dd-yy",
 394        "11": "yy/mm/dd",
 395        "12": "yymmdd",
 396        "13": "%d %b %Y %H:%M:ss:%f",
 397        "14": "%H:%M:%S:%f",
 398        "20": "%Y-%m-%d %H:%M:%S",
 399        "21": "%Y-%m-%d %H:%M:%S.%f",
 400        "22": "%m/%d/%y %-I:%M:%S %p",
 401        "23": "%Y-%m-%d",
 402        "24": "%H:%M:%S",
 403        "25": "%Y-%m-%d %H:%M:%S.%f",
 404        "100": "%b %d %Y %-I:%M%p",
 405        "101": "%m/%d/%Y",
 406        "102": "%Y.%m.%d",
 407        "103": "%d/%m/%Y",
 408        "104": "%d.%m.%Y",
 409        "105": "%d-%m-%Y",
 410        "106": "%d %b %Y",
 411        "107": "%b %d, %Y",
 412        "108": "%H:%M:%S",
 413        "109": "%b %d %Y %-I:%M:%S:%f%p",
 414        "110": "%m-%d-%Y",
 415        "111": "%Y/%m/%d",
 416        "112": "%Y%m%d",
 417        "113": "%d %b %Y %H:%M:%S:%f",
 418        "114": "%H:%M:%S:%f",
 419        "120": "%Y-%m-%d %H:%M:%S",
 420        "121": "%Y-%m-%d %H:%M:%S.%f",
 421    }
 422
 423    FORMAT_TIME_MAPPING = {
 424        "y": "%B %Y",
 425        "d": "%m/%d/%Y",
 426        "H": "%-H",
 427        "h": "%-I",
 428        "s": "%Y-%m-%d %H:%M:%S",
 429        "D": "%A,%B,%Y",
 430        "f": "%A,%B,%Y %-I:%M %p",
 431        "F": "%A,%B,%Y %-I:%M:%S %p",
 432        "g": "%m/%d/%Y %-I:%M %p",
 433        "G": "%m/%d/%Y %-I:%M:%S %p",
 434        "M": "%B %-d",
 435        "m": "%B %-d",
 436        "O": "%Y-%m-%dT%H:%M:%S",
 437        "u": "%Y-%M-%D %H:%M:%S%z",
 438        "U": "%A, %B %D, %Y %H:%M:%S%z",
 439        "T": "%-I:%M:%S %p",
 440        "t": "%-I:%M",
 441        "Y": "%a %Y",
 442    }
 443
 444    class Tokenizer(tokens.Tokenizer):
 445        IDENTIFIERS = [("[", "]"), '"']
 446        QUOTES = ["'", '"']
 447        HEX_STRINGS = [("0x", ""), ("0X", "")]
 448        VAR_SINGLE_TOKENS = {"@", "$", "#"}
 449
 450        KEYWORDS = {
 451            **tokens.Tokenizer.KEYWORDS,
 452            "DATETIME2": TokenType.DATETIME,
 453            "DATETIMEOFFSET": TokenType.TIMESTAMPTZ,
 454            "DECLARE": TokenType.COMMAND,
 455            "EXEC": TokenType.COMMAND,
 456            "IMAGE": TokenType.IMAGE,
 457            "MONEY": TokenType.MONEY,
 458            "NTEXT": TokenType.TEXT,
 459            "PRINT": TokenType.COMMAND,
 460            "PROC": TokenType.PROCEDURE,
 461            "REAL": TokenType.FLOAT,
 462            "ROWVERSION": TokenType.ROWVERSION,
 463            "SMALLDATETIME": TokenType.DATETIME,
 464            "SMALLMONEY": TokenType.SMALLMONEY,
 465            "SQL_VARIANT": TokenType.VARIANT,
 466            "TOP": TokenType.TOP,
 467            "TIMESTAMP": TokenType.ROWVERSION,
 468            "UNIQUEIDENTIFIER": TokenType.UNIQUEIDENTIFIER,
 469            "UPDATE STATISTICS": TokenType.COMMAND,
 470            "XML": TokenType.XML,
 471            "OUTPUT": TokenType.RETURNING,
 472            "SYSTEM_USER": TokenType.CURRENT_USER,
 473            "FOR SYSTEM_TIME": TokenType.TIMESTAMP_SNAPSHOT,
 474            "OPTION": TokenType.OPTION,
 475        }
 476
 477    class Parser(parser.Parser):
 478        SET_REQUIRES_ASSIGNMENT_DELIMITER = False
 479        LOG_DEFAULTS_TO_LN = True
 480        ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN = False
 481        STRING_ALIASES = True
 482        NO_PAREN_IF_COMMANDS = False
 483
 484        QUERY_MODIFIER_PARSERS = {
 485            **parser.Parser.QUERY_MODIFIER_PARSERS,
 486            TokenType.OPTION: lambda self: ("options", self._parse_options()),
 487        }
 488
 489        FUNCTIONS = {
 490            **parser.Parser.FUNCTIONS,
 491            "CHARINDEX": lambda args: exp.StrPosition(
 492                this=seq_get(args, 1),
 493                substr=seq_get(args, 0),
 494                position=seq_get(args, 2),
 495            ),
 496            "DATEADD": build_date_delta(exp.DateAdd, unit_mapping=DATE_DELTA_INTERVAL),
 497            "DATEDIFF": _build_date_delta(exp.DateDiff, unit_mapping=DATE_DELTA_INTERVAL),
 498            "DATENAME": _build_formatted_time(exp.TimeToStr, full_format_mapping=True),
 499            "DATEPART": _build_formatted_time(exp.TimeToStr),
 500            "DATETIMEFROMPARTS": _build_datetimefromparts,
 501            "EOMONTH": _build_eomonth,
 502            "FORMAT": _build_format,
 503            "GETDATE": exp.CurrentTimestamp.from_arg_list,
 504            "HASHBYTES": _build_hashbytes,
 505            "ISNULL": exp.Coalesce.from_arg_list,
 506            "JSON_QUERY": parser.build_extract_json_with_path(exp.JSONExtract),
 507            "JSON_VALUE": parser.build_extract_json_with_path(exp.JSONExtractScalar),
 508            "LEN": _build_with_arg_as_text(exp.Length),
 509            "LEFT": _build_with_arg_as_text(exp.Left),
 510            "RIGHT": _build_with_arg_as_text(exp.Right),
 511            "REPLICATE": exp.Repeat.from_arg_list,
 512            "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),
 513            "SYSDATETIME": exp.CurrentTimestamp.from_arg_list,
 514            "SUSER_NAME": exp.CurrentUser.from_arg_list,
 515            "SUSER_SNAME": exp.CurrentUser.from_arg_list,
 516            "SYSTEM_USER": exp.CurrentUser.from_arg_list,
 517            "TIMEFROMPARTS": _build_timefromparts,
 518        }
 519
 520        JOIN_HINTS = {"LOOP", "HASH", "MERGE", "REMOTE"}
 521
 522        RETURNS_TABLE_TOKENS = parser.Parser.ID_VAR_TOKENS - {
 523            TokenType.TABLE,
 524            *parser.Parser.TYPE_TOKENS,
 525        }
 526
 527        STATEMENT_PARSERS = {
 528            **parser.Parser.STATEMENT_PARSERS,
 529            TokenType.END: lambda self: self._parse_command(),
 530        }
 531
 532        def _parse_options(self) -> t.Optional[t.List[exp.Expression]]:
 533            if not self._match(TokenType.OPTION):
 534                return None
 535
 536            def _parse_option() -> t.Optional[exp.Expression]:
 537                option = self._parse_var_from_options(OPTIONS)
 538                if not option:
 539                    return None
 540
 541                self._match(TokenType.EQ)
 542                return self.expression(
 543                    exp.QueryOption, this=option, expression=self._parse_primary_or_var()
 544                )
 545
 546            return self._parse_wrapped_csv(_parse_option)
 547
 548        def _parse_projections(self) -> t.List[exp.Expression]:
 549            """
 550            T-SQL supports the syntax alias = expression in the SELECT's projection list,
 551            so we transform all parsed Selects to convert their EQ projections into Aliases.
 552
 553            See: https://learn.microsoft.com/en-us/sql/t-sql/queries/select-clause-transact-sql?view=sql-server-ver16#syntax
 554            """
 555            return [
 556                (
 557                    exp.alias_(projection.expression, projection.this.this, copy=False)
 558                    if isinstance(projection, exp.EQ) and isinstance(projection.this, exp.Column)
 559                    else projection
 560                )
 561                for projection in super()._parse_projections()
 562            ]
 563
 564        def _parse_commit_or_rollback(self) -> exp.Commit | exp.Rollback:
 565            """Applies to SQL Server and Azure SQL Database
 566            COMMIT [ { TRAN | TRANSACTION }
 567                [ transaction_name | @tran_name_variable ] ]
 568                [ WITH ( DELAYED_DURABILITY = { OFF | ON } ) ]
 569
 570            ROLLBACK { TRAN | TRANSACTION }
 571                [ transaction_name | @tran_name_variable
 572                | savepoint_name | @savepoint_variable ]
 573            """
 574            rollback = self._prev.token_type == TokenType.ROLLBACK
 575
 576            self._match_texts(("TRAN", "TRANSACTION"))
 577            this = self._parse_id_var()
 578
 579            if rollback:
 580                return self.expression(exp.Rollback, this=this)
 581
 582            durability = None
 583            if self._match_pair(TokenType.WITH, TokenType.L_PAREN):
 584                self._match_text_seq("DELAYED_DURABILITY")
 585                self._match(TokenType.EQ)
 586
 587                if self._match_text_seq("OFF"):
 588                    durability = False
 589                else:
 590                    self._match(TokenType.ON)
 591                    durability = True
 592
 593                self._match_r_paren()
 594
 595            return self.expression(exp.Commit, this=this, durability=durability)
 596
 597        def _parse_transaction(self) -> exp.Transaction | exp.Command:
 598            """Applies to SQL Server and Azure SQL Database
 599            BEGIN { TRAN | TRANSACTION }
 600            [ { transaction_name | @tran_name_variable }
 601            [ WITH MARK [ 'description' ] ]
 602            ]
 603            """
 604            if self._match_texts(("TRAN", "TRANSACTION")):
 605                transaction = self.expression(exp.Transaction, this=self._parse_id_var())
 606                if self._match_text_seq("WITH", "MARK"):
 607                    transaction.set("mark", self._parse_string())
 608
 609                return transaction
 610
 611            return self._parse_as_command(self._prev)
 612
 613        def _parse_returns(self) -> exp.ReturnsProperty:
 614            table = self._parse_id_var(any_token=False, tokens=self.RETURNS_TABLE_TOKENS)
 615            returns = super()._parse_returns()
 616            returns.set("table", table)
 617            return returns
 618
 619        def _parse_convert(
 620            self, strict: bool, safe: t.Optional[bool] = None
 621        ) -> t.Optional[exp.Expression]:
 622            this = self._parse_types()
 623            self._match(TokenType.COMMA)
 624            args = [this, *self._parse_csv(self._parse_conjunction)]
 625            convert = exp.Convert.from_arg_list(args)
 626            convert.set("safe", safe)
 627            convert.set("strict", strict)
 628            return convert
 629
 630        def _parse_user_defined_function(
 631            self, kind: t.Optional[TokenType] = None
 632        ) -> t.Optional[exp.Expression]:
 633            this = super()._parse_user_defined_function(kind=kind)
 634
 635            if (
 636                kind == TokenType.FUNCTION
 637                or isinstance(this, exp.UserDefinedFunction)
 638                or self._match(TokenType.ALIAS, advance=False)
 639            ):
 640                return this
 641
 642            expressions = self._parse_csv(self._parse_function_parameter)
 643            return self.expression(exp.UserDefinedFunction, this=this, expressions=expressions)
 644
 645        def _parse_id_var(
 646            self,
 647            any_token: bool = True,
 648            tokens: t.Optional[t.Collection[TokenType]] = None,
 649        ) -> t.Optional[exp.Expression]:
 650            is_temporary = self._match(TokenType.HASH)
 651            is_global = is_temporary and self._match(TokenType.HASH)
 652
 653            this = super()._parse_id_var(any_token=any_token, tokens=tokens)
 654            if this:
 655                if is_global:
 656                    this.set("global", True)
 657                elif is_temporary:
 658                    this.set("temporary", True)
 659
 660            return this
 661
 662        def _parse_create(self) -> exp.Create | exp.Command:
 663            create = super()._parse_create()
 664
 665            if isinstance(create, exp.Create):
 666                table = create.this.this if isinstance(create.this, exp.Schema) else create.this
 667                if isinstance(table, exp.Table) and table.this.args.get("temporary"):
 668                    if not create.args.get("properties"):
 669                        create.set("properties", exp.Properties(expressions=[]))
 670
 671                    create.args["properties"].append("expressions", exp.TemporaryProperty())
 672
 673            return create
 674
 675        def _parse_if(self) -> t.Optional[exp.Expression]:
 676            index = self._index
 677
 678            if self._match_text_seq("OBJECT_ID"):
 679                self._parse_wrapped_csv(self._parse_string)
 680                if self._match_text_seq("IS", "NOT", "NULL") and self._match(TokenType.DROP):
 681                    return self._parse_drop(exists=True)
 682                self._retreat(index)
 683
 684            return super()._parse_if()
 685
 686        def _parse_unique(self) -> exp.UniqueColumnConstraint:
 687            if self._match_texts(("CLUSTERED", "NONCLUSTERED")):
 688                this = self.CONSTRAINT_PARSERS[self._prev.text.upper()](self)
 689            else:
 690                this = self._parse_schema(self._parse_id_var(any_token=False))
 691
 692            return self.expression(exp.UniqueColumnConstraint, this=this)
 693
 694        def _parse_partition(self) -> t.Optional[exp.Partition]:
 695            if not self._match_text_seq("WITH", "(", "PARTITIONS"):
 696                return None
 697
 698            def parse_range():
 699                low = self._parse_bitwise()
 700                high = self._parse_bitwise() if self._match_text_seq("TO") else None
 701
 702                return (
 703                    self.expression(exp.PartitionRange, this=low, expression=high) if high else low
 704                )
 705
 706            partition = self.expression(
 707                exp.Partition, expressions=self._parse_wrapped_csv(parse_range)
 708            )
 709
 710            self._match_r_paren()
 711
 712            return partition
 713
 714    class Generator(generator.Generator):
 715        LIMIT_IS_TOP = True
 716        QUERY_HINTS = False
 717        RETURNING_END = False
 718        NVL2_SUPPORTED = False
 719        ALTER_TABLE_INCLUDE_COLUMN_KEYWORD = False
 720        LIMIT_FETCH = "FETCH"
 721        COMPUTED_COLUMN_WITH_TYPE = False
 722        CTE_RECURSIVE_KEYWORD_REQUIRED = False
 723        ENSURE_BOOLS = True
 724        NULL_ORDERING_SUPPORTED = None
 725        SUPPORTS_SINGLE_ARG_CONCAT = False
 726        TABLESAMPLE_SEED_KEYWORD = "REPEATABLE"
 727        SUPPORTS_SELECT_INTO = True
 728        JSON_PATH_BRACKETED_KEY_SUPPORTED = False
 729        SUPPORTS_TO_NUMBER = False
 730        OUTER_UNION_MODIFIERS = False
 731        COPY_PARAMS_EQ_REQUIRED = True
 732
 733        EXPRESSIONS_WITHOUT_NESTED_CTES = {
 734            exp.Delete,
 735            exp.Insert,
 736            exp.Merge,
 737            exp.Select,
 738            exp.Subquery,
 739            exp.Union,
 740            exp.Update,
 741        }
 742
 743        SUPPORTED_JSON_PATH_PARTS = {
 744            exp.JSONPathKey,
 745            exp.JSONPathRoot,
 746            exp.JSONPathSubscript,
 747        }
 748
 749        TYPE_MAPPING = {
 750            **generator.Generator.TYPE_MAPPING,
 751            exp.DataType.Type.BOOLEAN: "BIT",
 752            exp.DataType.Type.DECIMAL: "NUMERIC",
 753            exp.DataType.Type.DATETIME: "DATETIME2",
 754            exp.DataType.Type.DOUBLE: "FLOAT",
 755            exp.DataType.Type.INT: "INTEGER",
 756            exp.DataType.Type.TEXT: "VARCHAR(MAX)",
 757            exp.DataType.Type.TIMESTAMP: "DATETIME2",
 758            exp.DataType.Type.TIMESTAMPTZ: "DATETIMEOFFSET",
 759            exp.DataType.Type.VARIANT: "SQL_VARIANT",
 760            exp.DataType.Type.ROWVERSION: "ROWVERSION",
 761        }
 762
 763        TYPE_MAPPING.pop(exp.DataType.Type.NCHAR)
 764        TYPE_MAPPING.pop(exp.DataType.Type.NVARCHAR)
 765
 766        TRANSFORMS = {
 767            **generator.Generator.TRANSFORMS,
 768            exp.AnyValue: any_value_to_max_sql,
 769            exp.ArrayToString: rename_func("STRING_AGG"),
 770            exp.AutoIncrementColumnConstraint: lambda *_: "IDENTITY",
 771            exp.DateAdd: date_delta_sql("DATEADD"),
 772            exp.DateDiff: date_delta_sql("DATEDIFF"),
 773            exp.CTE: transforms.preprocess([qualify_derived_table_outputs]),
 774            exp.CurrentDate: rename_func("GETDATE"),
 775            exp.CurrentTimestamp: rename_func("GETDATE"),
 776            exp.DateStrToDate: datestrtodate_sql,
 777            exp.Extract: rename_func("DATEPART"),
 778            exp.GeneratedAsIdentityColumnConstraint: generatedasidentitycolumnconstraint_sql,
 779            exp.GroupConcat: _string_agg_sql,
 780            exp.If: rename_func("IIF"),
 781            exp.JSONExtract: _json_extract_sql,
 782            exp.JSONExtractScalar: _json_extract_sql,
 783            exp.LastDay: lambda self, e: self.func("EOMONTH", e.this),
 784            exp.Max: max_or_greatest,
 785            exp.MD5: lambda self, e: self.func("HASHBYTES", exp.Literal.string("MD5"), e.this),
 786            exp.Min: min_or_least,
 787            exp.NumberToStr: _format_sql,
 788            exp.ParseJSON: lambda self, e: self.sql(e, "this"),
 789            exp.Select: transforms.preprocess(
 790                [
 791                    transforms.eliminate_distinct_on,
 792                    transforms.eliminate_semi_and_anti_joins,
 793                    transforms.eliminate_qualify,
 794                ]
 795            ),
 796            exp.StrPosition: lambda self, e: self.func(
 797                "CHARINDEX", e.args.get("substr"), e.this, e.args.get("position")
 798            ),
 799            exp.Subquery: transforms.preprocess([qualify_derived_table_outputs]),
 800            exp.SHA: lambda self, e: self.func("HASHBYTES", exp.Literal.string("SHA1"), e.this),
 801            exp.SHA2: lambda self, e: self.func(
 802                "HASHBYTES", exp.Literal.string(f"SHA2_{e.args.get('length', 256)}"), e.this
 803            ),
 804            exp.TemporaryProperty: lambda self, e: "",
 805            exp.TimeStrToTime: timestrtotime_sql,
 806            exp.TimeToStr: _format_sql,
 807            exp.Trim: trim_sql,
 808            exp.TsOrDsAdd: date_delta_sql("DATEADD", cast=True),
 809            exp.TsOrDsDiff: date_delta_sql("DATEDIFF"),
 810        }
 811
 812        TRANSFORMS.pop(exp.ReturnsProperty)
 813
 814        PROPERTIES_LOCATION = {
 815            **generator.Generator.PROPERTIES_LOCATION,
 816            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
 817        }
 818
 819        def select_sql(self, expression: exp.Select) -> str:
 820            if expression.args.get("offset"):
 821                if not expression.args.get("order"):
 822                    # ORDER BY is required in order to use OFFSET in a query, so we use
 823                    # a noop order by, since we don't really care about the order.
 824                    # See: https://www.microsoftpressstore.com/articles/article.aspx?p=2314819
 825                    expression.order_by(exp.select(exp.null()).subquery(), copy=False)
 826
 827                limit = expression.args.get("limit")
 828                if isinstance(limit, exp.Limit):
 829                    # TOP and OFFSET can't be combined, we need use FETCH instead of TOP
 830                    # we replace here because otherwise TOP would be generated in select_sql
 831                    limit.replace(exp.Fetch(direction="FIRST", count=limit.expression))
 832
 833            return super().select_sql(expression)
 834
 835        def convert_sql(self, expression: exp.Convert) -> str:
 836            name = "TRY_CONVERT" if expression.args.get("safe") else "CONVERT"
 837            return self.func(
 838                name, expression.this, expression.expression, expression.args.get("style")
 839            )
 840
 841        def queryoption_sql(self, expression: exp.QueryOption) -> str:
 842            option = self.sql(expression, "this")
 843            value = self.sql(expression, "expression")
 844            if value:
 845                optional_equal_sign = "= " if option in OPTIONS_THAT_REQUIRE_EQUAL else ""
 846                return f"{option} {optional_equal_sign}{value}"
 847            return option
 848
 849        def lateral_op(self, expression: exp.Lateral) -> str:
 850            cross_apply = expression.args.get("cross_apply")
 851            if cross_apply is True:
 852                return "CROSS APPLY"
 853            if cross_apply is False:
 854                return "OUTER APPLY"
 855
 856            # TODO: perhaps we can check if the parent is a Join and transpile it appropriately
 857            self.unsupported("LATERAL clause is not supported.")
 858            return "LATERAL"
 859
 860        def timefromparts_sql(self, expression: exp.TimeFromParts) -> str:
 861            nano = expression.args.get("nano")
 862            if nano is not None:
 863                nano.pop()
 864                self.unsupported("Specifying nanoseconds is not supported in TIMEFROMPARTS.")
 865
 866            if expression.args.get("fractions") is None:
 867                expression.set("fractions", exp.Literal.number(0))
 868            if expression.args.get("precision") is None:
 869                expression.set("precision", exp.Literal.number(0))
 870
 871            return rename_func("TIMEFROMPARTS")(self, expression)
 872
 873        def timestampfromparts_sql(self, expression: exp.TimestampFromParts) -> str:
 874            zone = expression.args.get("zone")
 875            if zone is not None:
 876                zone.pop()
 877                self.unsupported("Time zone is not supported in DATETIMEFROMPARTS.")
 878
 879            nano = expression.args.get("nano")
 880            if nano is not None:
 881                nano.pop()
 882                self.unsupported("Specifying nanoseconds is not supported in DATETIMEFROMPARTS.")
 883
 884            if expression.args.get("milli") is None:
 885                expression.set("milli", exp.Literal.number(0))
 886
 887            return rename_func("DATETIMEFROMPARTS")(self, expression)
 888
 889        def setitem_sql(self, expression: exp.SetItem) -> str:
 890            this = expression.this
 891            if isinstance(this, exp.EQ) and not isinstance(this.left, exp.Parameter):
 892                # T-SQL does not use '=' in SET command, except when the LHS is a variable.
 893                return f"{self.sql(this.left)} {self.sql(this.right)}"
 894
 895            return super().setitem_sql(expression)
 896
 897        def boolean_sql(self, expression: exp.Boolean) -> str:
 898            if type(expression.parent) in BIT_TYPES:
 899                return "1" if expression.this else "0"
 900
 901            return "(1 = 1)" if expression.this else "(1 = 0)"
 902
 903        def is_sql(self, expression: exp.Is) -> str:
 904            if isinstance(expression.expression, exp.Boolean):
 905                return self.binary(expression, "=")
 906            return self.binary(expression, "IS")
 907
 908        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
 909            sql = self.sql(expression, "this")
 910            properties = expression.args.get("properties")
 911
 912            if sql[:1] != "#" and any(
 913                isinstance(prop, exp.TemporaryProperty)
 914                for prop in (properties.expressions if properties else [])
 915            ):
 916                sql = f"[#{sql[1:]}" if sql.startswith("[") else f"#{sql}"
 917
 918            return sql
 919
 920        def create_sql(self, expression: exp.Create) -> str:
 921            kind = expression.kind
 922            exists = expression.args.pop("exists", None)
 923            sql = super().create_sql(expression)
 924
 925            like_property = expression.find(exp.LikeProperty)
 926            if like_property:
 927                ctas_expression = like_property.this
 928            else:
 929                ctas_expression = expression.expression
 930
 931            table = expression.find(exp.Table)
 932
 933            # Convert CTAS statement to SELECT .. INTO ..
 934            if kind == "TABLE" and ctas_expression:
 935                ctas_with = ctas_expression.args.get("with")
 936                if ctas_with:
 937                    ctas_with = ctas_with.pop()
 938
 939                if isinstance(ctas_expression, exp.UNWRAPPED_QUERIES):
 940                    ctas_expression = ctas_expression.subquery()
 941
 942                select_into = exp.select("*").from_(exp.alias_(ctas_expression, "temp", table=True))
 943                select_into.set("into", exp.Into(this=table))
 944                select_into.set("with", ctas_with)
 945
 946                if like_property:
 947                    select_into.limit(0, copy=False)
 948
 949                sql = self.sql(select_into)
 950
 951            if exists:
 952                identifier = self.sql(exp.Literal.string(exp.table_name(table) if table else ""))
 953                sql = self.sql(exp.Literal.string(sql))
 954                if kind == "SCHEMA":
 955                    sql = f"""IF NOT EXISTS (SELECT * FROM information_schema.schemata WHERE schema_name = {identifier}) EXEC({sql})"""
 956                elif kind == "TABLE":
 957                    assert table
 958                    where = exp.and_(
 959                        exp.column("table_name").eq(table.name),
 960                        exp.column("table_schema").eq(table.db) if table.db else None,
 961                        exp.column("table_catalog").eq(table.catalog) if table.catalog else None,
 962                    )
 963                    sql = f"""IF NOT EXISTS (SELECT * FROM information_schema.tables WHERE {where}) EXEC({sql})"""
 964                elif kind == "INDEX":
 965                    index = self.sql(exp.Literal.string(expression.this.text("this")))
 966                    sql = f"""IF NOT EXISTS (SELECT * FROM sys.indexes WHERE object_id = object_id({identifier}) AND name = {index}) EXEC({sql})"""
 967            elif expression.args.get("replace"):
 968                sql = sql.replace("CREATE OR REPLACE ", "CREATE OR ALTER ", 1)
 969
 970            return self.prepend_ctes(expression, sql)
 971
 972        def offset_sql(self, expression: exp.Offset) -> str:
 973            return f"{super().offset_sql(expression)} ROWS"
 974
 975        def version_sql(self, expression: exp.Version) -> str:
 976            name = "SYSTEM_TIME" if expression.name == "TIMESTAMP" else expression.name
 977            this = f"FOR {name}"
 978            expr = expression.expression
 979            kind = expression.text("kind")
 980            if kind in ("FROM", "BETWEEN"):
 981                args = expr.expressions
 982                sep = "TO" if kind == "FROM" else "AND"
 983                expr_sql = f"{self.sql(seq_get(args, 0))} {sep} {self.sql(seq_get(args, 1))}"
 984            else:
 985                expr_sql = self.sql(expr)
 986
 987            expr_sql = f" {expr_sql}" if expr_sql else ""
 988            return f"{this} {kind}{expr_sql}"
 989
 990        def returnsproperty_sql(self, expression: exp.ReturnsProperty) -> str:
 991            table = expression.args.get("table")
 992            table = f"{table} " if table else ""
 993            return f"RETURNS {table}{self.sql(expression, 'this')}"
 994
 995        def returning_sql(self, expression: exp.Returning) -> str:
 996            into = self.sql(expression, "into")
 997            into = self.seg(f"INTO {into}") if into else ""
 998            return f"{self.seg('OUTPUT')} {self.expressions(expression, flat=True)}{into}"
 999
1000        def transaction_sql(self, expression: exp.Transaction) -> str:
1001            this = self.sql(expression, "this")
1002            this = f" {this}" if this else ""
1003            mark = self.sql(expression, "mark")
1004            mark = f" WITH MARK {mark}" if mark else ""
1005            return f"BEGIN TRANSACTION{this}{mark}"
1006
1007        def commit_sql(self, expression: exp.Commit) -> str:
1008            this = self.sql(expression, "this")
1009            this = f" {this}" if this else ""
1010            durability = expression.args.get("durability")
1011            durability = (
1012                f" WITH (DELAYED_DURABILITY = {'ON' if durability else 'OFF'})"
1013                if durability is not None
1014                else ""
1015            )
1016            return f"COMMIT TRANSACTION{this}{durability}"
1017
1018        def rollback_sql(self, expression: exp.Rollback) -> str:
1019            this = self.sql(expression, "this")
1020            this = f" {this}" if this else ""
1021            return f"ROLLBACK TRANSACTION{this}"
1022
1023        def identifier_sql(self, expression: exp.Identifier) -> str:
1024            identifier = super().identifier_sql(expression)
1025
1026            if expression.args.get("global"):
1027                identifier = f"##{identifier}"
1028            elif expression.args.get("temporary"):
1029                identifier = f"#{identifier}"
1030
1031            return identifier
1032
1033        def constraint_sql(self, expression: exp.Constraint) -> str:
1034            this = self.sql(expression, "this")
1035            expressions = self.expressions(expression, flat=True, sep=" ")
1036            return f"CONSTRAINT {this} {expressions}"
1037
1038        def length_sql(self, expression: exp.Length) -> str:
1039            return self._uncast_text(expression, "LEN")
1040
1041        def right_sql(self, expression: exp.Right) -> str:
1042            return self._uncast_text(expression, "RIGHT")
1043
1044        def left_sql(self, expression: exp.Left) -> str:
1045            return self._uncast_text(expression, "LEFT")
1046
1047        def _uncast_text(self, expression: exp.Expression, name: str) -> str:
1048            this = expression.this
1049            if isinstance(this, exp.Cast) and this.is_type(exp.DataType.Type.TEXT):
1050                this_sql = self.sql(this, "this")
1051            else:
1052                this_sql = self.sql(this)
1053            expression_sql = self.sql(expression, "expression")
1054            return self.func(name, this_sql, expression_sql if expression_sql else None)
1055
1056        def partition_sql(self, expression: exp.Partition) -> str:
1057            return f"WITH (PARTITIONS({self.expressions(expression, flat=True)}))"
1058
1059        def altertable_sql(self, expression: exp.AlterTable) -> str:
1060            action = seq_get(expression.args.get("actions") or [], 0)
1061            if isinstance(action, exp.RenameTable):
1062                return f"EXEC sp_rename '{self.sql(expression.this)}', '{action.this.name}'"
1063            return super().altertable_sql(expression)