sqlglot.parsers.tsql

  1from __future__ import annotations
  2
  3import datetime
  4import re
  5import typing as t
  6
  7from sqlglot import exp, parser
  8from sqlglot.dialects.dialect import (
  9    Dialect,
 10    build_date_delta,
 11    map_date_part,
 12)
 13from sqlglot.helper import seq_get
 14from sqlglot.parser import build_coalesce
 15from sqlglot.time import format_time
 16from sqlglot.tokens import TokenType
 17
 18if t.TYPE_CHECKING:
 19    from sqlglot._typing import E
 20    from collections.abc import Collection
 21
 22FULL_FORMAT_TIME_MAPPING = {
 23    "weekday": "%A",
 24    "dw": "%A",
 25    "w": "%A",
 26    "month": "%B",
 27    "mm": "%B",
 28    "m": "%B",
 29}
 30
 31DATE_DELTA_INTERVAL = {
 32    "year": "year",
 33    "yyyy": "year",
 34    "yy": "year",
 35    "quarter": "quarter",
 36    "qq": "quarter",
 37    "q": "quarter",
 38    "month": "month",
 39    "mm": "month",
 40    "m": "month",
 41    "week": "week",
 42    "ww": "week",
 43    "wk": "week",
 44    "day": "day",
 45    "dd": "day",
 46    "d": "day",
 47}
 48
 49DATE_FMT_RE = re.compile("([dD]{1,2})|([mM]{1,2})|([yY]{1,4})|([hH]{1,2})|([sS]{1,2})")
 50
 51# N = Numeric, C=Currency
 52TRANSPILE_SAFE_NUMBER_FMT = {"N", "C"}
 53
 54DEFAULT_START_DATE = datetime.date(1900, 1, 1)
 55
 56# Unsupported options:
 57# - OPTIMIZE FOR ( @variable_name { UNKNOWN | = <literal_constant> } [ , ...n ] )
 58# - TABLE HINT
 59OPTIONS: parser.OPTIONS_TYPE = {
 60    **dict.fromkeys(
 61        (
 62            "DISABLE_OPTIMIZED_PLAN_FORCING",
 63            "FAST",
 64            "IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX",
 65            "LABEL",
 66            "MAXDOP",
 67            "MAXRECURSION",
 68            "MAX_GRANT_PERCENT",
 69            "MIN_GRANT_PERCENT",
 70            "NO_PERFORMANCE_SPOOL",
 71            "QUERYTRACEON",
 72            "RECOMPILE",
 73        ),
 74        tuple(),
 75    ),
 76    "CONCAT": ("UNION",),
 77    "DISABLE": ("EXTERNALPUSHDOWN", "SCALEOUTEXECUTION"),
 78    "EXPAND": ("VIEWS",),
 79    "FORCE": ("EXTERNALPUSHDOWN", "ORDER", "SCALEOUTEXECUTION"),
 80    "HASH": ("GROUP", "JOIN", "UNION"),
 81    "KEEP": ("PLAN",),
 82    "KEEPFIXED": ("PLAN",),
 83    "LOOP": ("JOIN",),
 84    "MERGE": ("JOIN", "UNION"),
 85    "OPTIMIZE": (("FOR", "UNKNOWN"),),
 86    "ORDER": ("GROUP",),
 87    "PARAMETERIZATION": ("FORCED", "SIMPLE"),
 88    "ROBUST": ("PLAN",),
 89    "USE": ("PLAN",),
 90}
 91
 92
 93FOR_XML_OPTIONS: parser.OPTIONS_TYPE = {
 94    **dict.fromkeys(
 95        (
 96            "AUTO",
 97            "EXPLICIT",
 98            "TYPE",
 99        ),
100        tuple(),
101    ),
102    "ELEMENTS": (
103        "XSINIL",
104        "ABSENT",
105    ),
106    "BINARY": ("BASE64",),
107}
108
109
110# FOR JSON { AUTO | PATH } [, ROOT [ ( 'name' ) ] ] [, INCLUDE_NULL_VALUES ]
111#                          [, WITHOUT_ARRAY_WRAPPER ]
112# https://learn.microsoft.com/en-us/sql/relational-databases/json/format-query-results-as-json-with-for-json-sql-server
113FOR_JSON_OPTIONS: parser.OPTIONS_TYPE = dict.fromkeys(
114    (
115        "AUTO",
116        "PATH",
117        "INCLUDE_NULL_VALUES",
118        "WITHOUT_ARRAY_WRAPPER",
119    ),
120    tuple(),
121)
122
123
124OPTIONS_THAT_REQUIRE_EQUAL = ("MAX_GRANT_PERCENT", "MIN_GRANT_PERCENT", "LABEL")
125
126
127def _build_formatted_time(
128    exp_class: type[E], full_format_mapping: bool | None = None
129) -> t.Callable[[list], E]:
130    def _builder(args: list) -> E:
131        fmt = seq_get(args, 0)
132        if isinstance(fmt, exp.Expr):
133            from sqlglot.dialects.tsql import TSQL
134
135            fmt = exp.Literal.string(
136                format_time(
137                    fmt.name.lower(),
138                    (
139                        {**TSQL.TIME_MAPPING, **FULL_FORMAT_TIME_MAPPING}
140                        if full_format_mapping
141                        else TSQL.TIME_MAPPING
142                    ),
143                )
144            )
145
146        this = seq_get(args, 1)
147        if isinstance(this, exp.Expr):
148            this = exp.cast(this, exp.DType.DATETIME2)
149
150        return exp_class(this=this, format=fmt)
151
152    return _builder
153
154
155def _build_format(args: list) -> exp.NumberToStr | exp.TimeToStr:
156    this = seq_get(args, 0)
157    fmt = seq_get(args, 1)
158    culture = seq_get(args, 2)
159
160    number_fmt = fmt and (fmt.name in TRANSPILE_SAFE_NUMBER_FMT or not DATE_FMT_RE.search(fmt.name))
161
162    if number_fmt:
163        return exp.NumberToStr(this=this, format=fmt, culture=culture)
164
165    if fmt:
166        from sqlglot.dialects.tsql import TSQL
167
168        fmt = exp.Literal.string(
169            format_time(fmt.name, TSQL.FORMAT_TIME_MAPPING)
170            if len(fmt.name) == 1
171            else format_time(fmt.name, TSQL.TIME_MAPPING)
172        )
173
174    return exp.TimeToStr(this=this, format=fmt, culture=culture)
175
176
177def _build_eomonth(args: list) -> exp.LastDay:
178    date = exp.TsOrDsToDate(this=seq_get(args, 0))
179    month_lag = seq_get(args, 1)
180
181    if month_lag is None:
182        this: exp.Expr = date
183    else:
184        unit = DATE_DELTA_INTERVAL.get("month")
185        this = exp.DateAdd(this=date, expression=month_lag, unit=unit and exp.var(unit))
186
187    return exp.LastDay(this=this)
188
189
190def _build_hashbytes(args: list) -> exp.Expr:
191    kind, data = args
192    kind = kind.name.upper() if kind.is_string else ""
193
194    if kind == "MD5":
195        args.pop(0)
196        return exp.MD5(this=data)
197    if kind in ("SHA", "SHA1"):
198        args.pop(0)
199        return exp.SHA(this=data)
200    if kind == "SHA2_256":
201        return exp.SHA2(this=data, length=exp.Literal.number(256))
202    if kind == "SHA2_512":
203        return exp.SHA2(this=data, length=exp.Literal.number(512))
204
205    return exp.func("HASHBYTES", *args)
206
207
208def _build_date_delta(
209    exp_class: type[E], unit_mapping: dict[str, str] | None = None, big_int: bool = False
210) -> t.Callable[[list], E]:
211    def _builder(args: list) -> E:
212        unit = seq_get(args, 0)
213        if unit and unit_mapping:
214            unit = exp.var(unit_mapping.get(unit.name.lower(), unit.name))
215
216        start_date = seq_get(args, 1)
217        if start_date and start_date.is_number:
218            # Numeric types are valid DATETIME values
219            if start_date.is_int:
220                adds = DEFAULT_START_DATE + datetime.timedelta(days=start_date.to_py())
221                start_date = exp.Literal.string(adds.strftime("%F"))
222            else:
223                # We currently don't handle float values, i.e. they're not converted to equivalent DATETIMEs.
224                # This is not a problem when generating T-SQL code, it is when transpiling to other dialects.
225                return exp_class(
226                    this=seq_get(args, 2), expression=start_date, unit=unit, big_int=big_int
227                )
228
229        return exp_class(
230            this=exp.TimeStrToTime(this=seq_get(args, 2)),
231            expression=exp.TimeStrToTime(this=start_date),
232            unit=unit,
233            big_int=big_int,
234        )
235
236    return _builder
237
238
239# https://learn.microsoft.com/en-us/sql/t-sql/functions/datetimefromparts-transact-sql?view=sql-server-ver16#syntax
240def _build_datetimefromparts(args: list) -> exp.TimestampFromParts:
241    return exp.TimestampFromParts(
242        year=seq_get(args, 0),
243        month=seq_get(args, 1),
244        day=seq_get(args, 2),
245        hour=seq_get(args, 3),
246        min=seq_get(args, 4),
247        sec=seq_get(args, 5),
248        milli=seq_get(args, 6),
249    )
250
251
252# https://learn.microsoft.com/en-us/sql/t-sql/functions/timefromparts-transact-sql?view=sql-server-ver16#syntax
253def _build_timefromparts(args: list) -> exp.TimeFromParts:
254    return exp.TimeFromParts(
255        hour=seq_get(args, 0),
256        min=seq_get(args, 1),
257        sec=seq_get(args, 2),
258        fractions=seq_get(args, 3),
259        precision=seq_get(args, 4),
260    )
261
262
263def _build_with_arg_as_text(
264    klass: type[exp.Expr],
265) -> t.Callable[[list[exp.Expr]], exp.Expr]:
266    def _parse(args: list[exp.Expr]) -> exp.Expr:
267        this = seq_get(args, 0)
268
269        if this and not this.is_string:
270            this = exp.cast(this, exp.DType.TEXT)
271
272        expression = seq_get(args, 1)
273        kwargs = {"this": this}
274
275        if expression:
276            kwargs["expression"] = expression
277
278        return klass(**kwargs)
279
280    return _parse
281
282
283# https://learn.microsoft.com/en-us/sql/t-sql/functions/parsename-transact-sql?view=sql-server-ver16
284def _build_parsename(args: list) -> exp.SplitPart | exp.Anonymous:
285    # PARSENAME(...) will be stored into exp.SplitPart if:
286    # - All args are literals
287    # - The part index (2nd arg) is <= 4 (max valid value, otherwise TSQL returns NULL)
288    if len(args) == 2 and all(isinstance(arg, exp.Literal) for arg in args):
289        this = args[0]
290        part_index = args[1]
291        split_count = len(this.name.split("."))
292        if split_count <= 4:
293            return exp.SplitPart(
294                this=this,
295                delimiter=exp.Literal.string("."),
296                part_index=exp.Literal.number(split_count + 1 - part_index.to_py()),
297            )
298
299    return exp.Anonymous(this="PARSENAME", expressions=args)
300
301
302def _build_json_query(args: list, dialect: Dialect) -> exp.JSONExtract:
303    if len(args) == 1:
304        # The default value for path is '$'. As a result, if you don't provide a
305        # value for path, JSON_QUERY returns the input expression.
306        args.append(exp.Literal.string("$"))
307
308    return parser.build_extract_json_with_path(exp.JSONExtract)(args, dialect)
309
310
311def _build_datetrunc(args: list) -> exp.TimestampTrunc:
312    unit = seq_get(args, 0)
313    this = seq_get(args, 1)
314
315    if this and this.is_string:
316        this = exp.cast(this, exp.DType.DATETIME2)
317
318    return exp.TimestampTrunc(this=this, unit=unit)
319
320
321class TSQLParser(parser.Parser):
322    SET_REQUIRES_ASSIGNMENT_DELIMITER = False
323    LOG_DEFAULTS_TO_LN = True
324    STRING_ALIASES = True
325    NO_PAREN_IF_COMMANDS = False
326    UNPIVOT_VALUE_COLUMNS_FIRST = True
327
328    NO_PAREN_FUNCTIONS = {
329        **parser.Parser.NO_PAREN_FUNCTIONS,
330        TokenType.SESSION_USER: exp.SessionUser,
331    }
332
333    QUERY_MODIFIER_PARSERS = {
334        **parser.Parser.QUERY_MODIFIER_PARSERS,
335        TokenType.OPTION: lambda self: ("options", self._parse_options()),
336        TokenType.FOR: lambda self: ("for_", self._parse_for()),
337    }
338
339    # T-SQL does not allow BEGIN to be used as an identifier
340    ID_VAR_TOKENS = parser.Parser.ID_VAR_TOKENS - {TokenType.BEGIN}
341    ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {TokenType.BEGIN}
342    TABLE_ALIAS_TOKENS = (parser.Parser.TABLE_ALIAS_TOKENS | {TokenType.ANTI, TokenType.SEMI}) - {
343        TokenType.BEGIN
344    }
345    COMMENT_TABLE_ALIAS_TOKENS = parser.Parser.COMMENT_TABLE_ALIAS_TOKENS - {TokenType.BEGIN}
346    UPDATE_ALIAS_TOKENS = parser.Parser.UPDATE_ALIAS_TOKENS - {TokenType.BEGIN}
347
348    FUNCTIONS = {
349        **parser.Parser.FUNCTIONS,
350        "ATN2": exp.Atan2.from_arg_list,
351        "CHARINDEX": lambda args: exp.StrPosition(
352            this=seq_get(args, 1),
353            substr=seq_get(args, 0),
354            position=seq_get(args, 2),
355        ),
356        "COUNT": lambda args: exp.Count(this=seq_get(args, 0), expressions=args[1:], big_int=False),
357        "COUNT_BIG": lambda args: exp.Count(
358            this=seq_get(args, 0), expressions=args[1:], big_int=True
359        ),
360        "DATEADD": build_date_delta(exp.DateAdd, unit_mapping=DATE_DELTA_INTERVAL),
361        "DATEDIFF": _build_date_delta(exp.DateDiff, unit_mapping=DATE_DELTA_INTERVAL),
362        "DATEDIFF_BIG": _build_date_delta(
363            exp.DateDiff, unit_mapping=DATE_DELTA_INTERVAL, big_int=True
364        ),
365        "DATENAME": _build_formatted_time(exp.TimeToStr, full_format_mapping=True),
366        "DATETIMEFROMPARTS": _build_datetimefromparts,
367        "DAY": lambda args: exp.Day(
368            this=exp.TsOrDsToDate(
369                this=seq_get(args, 0), default_date=exp.Literal.string("1900-01-01")
370            )
371        ),
372        "EOMONTH": _build_eomonth,
373        "FORMAT": _build_format,
374        "GETDATE": exp.CurrentTimestamp.from_arg_list,
375        "HASHBYTES": _build_hashbytes,
376        "ISNULL": lambda args: build_coalesce(args=args, is_null=True),
377        "JSON_QUERY": _build_json_query,
378        "JSON_VALUE": parser.build_extract_json_with_path(exp.JSONExtractScalar),
379        "LEN": _build_with_arg_as_text(exp.Length),
380        "LEFT": _build_with_arg_as_text(exp.Left),
381        "MONTH": lambda args: exp.Month(
382            this=exp.TsOrDsToDate(
383                this=seq_get(args, 0), default_date=exp.Literal.string("1900-01-01")
384            )
385        ),
386        "NEWID": exp.Uuid.from_arg_list,
387        "RIGHT": _build_with_arg_as_text(exp.Right),
388        "PARSENAME": _build_parsename,
389        "REPLICATE": exp.Repeat.from_arg_list,
390        "SCHEMA_NAME": exp.CurrentSchema.from_arg_list,
391        "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),
392        "SYSDATETIME": exp.CurrentTimestamp.from_arg_list,
393        "SUSER_NAME": exp.CurrentUser.from_arg_list,
394        "SUSER_SNAME": exp.CurrentUser.from_arg_list,
395        "SYSDATETIMEOFFSET": exp.CurrentTimestampLTZ.from_arg_list,
396        "SYSTEM_USER": exp.CurrentUser.from_arg_list,
397        "TIMEFROMPARTS": _build_timefromparts,
398        "DATETRUNC": _build_datetrunc,
399        "YEAR": lambda args: exp.Year(
400            this=exp.TsOrDsToDate(
401                this=seq_get(args, 0), default_date=exp.Literal.string("1900-01-01")
402            )
403        ),
404    }
405
406    JOIN_HINTS = {"LOOP", "HASH", "MERGE", "REMOTE"}
407
408    PROCEDURE_OPTIONS = dict.fromkeys(
409        ("ENCRYPTION", "RECOMPILE", "SCHEMABINDING", "NATIVE_COMPILATION", "EXECUTE"), tuple()
410    )
411
412    COLUMN_DEFINITION_MODES = {"OUT", "OUTPUT", "READONLY"}
413
414    RETURNS_TABLE_TOKENS = parser.Parser.ID_VAR_TOKENS - {
415        TokenType.TABLE,
416        *parser.Parser.TYPE_TOKENS,
417    }
418
419    STATEMENT_PARSERS = {
420        **parser.Parser.STATEMENT_PARSERS,
421        TokenType.EXECUTE: lambda self: self._parse_execute(),
422    }
423
424    RANGE_PARSERS = {
425        **parser.Parser.RANGE_PARSERS,
426        TokenType.DCOLON: lambda self, this: self.expression(
427            exp.ScopeResolution(
428                this=this, expression=self._parse_function() or self._parse_var(any_token=True)
429            )
430        ),
431    }
432
433    NO_PAREN_FUNCTION_PARSERS = {
434        **parser.Parser.NO_PAREN_FUNCTION_PARSERS,
435        "NEXT": lambda self: self._parse_next_value_for(),
436    }
437
438    FUNCTION_PARSERS = {
439        **parser.Parser.FUNCTION_PARSERS,
440        "JSON_ARRAYAGG": lambda self: self.expression(
441            exp.JSONArrayAgg(
442                this=self._parse_bitwise(),
443                order=self._parse_order(),
444                null_handling=self._parse_on_handling("NULL", "NULL", "ABSENT"),
445            )
446        ),
447        "DATEPART": lambda self: self._parse_datepart(),
448    }
449
450    # The DCOLON (::) operator serves as a scope resolution (exp.ScopeResolution) operator in T-SQL
451    COLUMN_OPERATORS = {
452        **parser.Parser.COLUMN_OPERATORS,
453        TokenType.DCOLON: lambda self, this, to: (
454            self.expression(exp.Cast(this=this, to=to))
455            if isinstance(to, exp.DataType) and to.this != exp.DType.USERDEFINED
456            else self.expression(exp.ScopeResolution(this=this, expression=to))
457        ),
458    }
459
460    SET_OP_MODIFIERS = {"offset"}
461
462    ODBC_DATETIME_LITERALS = {
463        "d": exp.Date,
464        "t": exp.Time,
465        "ts": exp.Timestamp,
466    }
467
468    def _parse_execute(self) -> exp.Execute:
469        return_status = None
470        index = self._index
471        if self._match(TokenType.PARAMETER):
472            param = self._parse_parameter()
473            if self._match(TokenType.EQ):
474                return_status = param
475            else:
476                self._retreat(index)
477
478        execute = self.expression(
479            exp.Execute(
480                this=self._parse_table(schema=True),
481                expressions=self._parse_csv(self._parse_expression),
482                return_status=return_status,
483            )
484        )
485
486        if execute.name.lower() == "sp_executesql":
487            execute = self.expression(exp.ExecuteSql(**execute.args))
488
489        return execute
490
491    def _parse_datepart(self) -> exp.Extract:
492        this = self._parse_var(tokens=[TokenType.IDENTIFIER])
493        expression = self._match(TokenType.COMMA) and self._parse_bitwise()
494        name = map_date_part(this, self.dialect)
495
496        return self.expression(exp.Extract(this=name, expression=expression))
497
498    def _parse_alter_table_set(self) -> exp.AlterSet:
499        return self._parse_wrapped(super()._parse_alter_table_set)
500
501    def _parse_wrapped_select(self, table: bool = False) -> exp.Expr | None:
502        if self._match(TokenType.MERGE):
503            comments = self._prev_comments
504            merge = self._parse_merge()
505            merge.add_comments(comments, prepend=True)
506            return merge
507
508        return super()._parse_wrapped_select(table=table)
509
510    def _parse_dcolon(self) -> exp.Expr | None:
511        # We want to use _parse_types() if the first token after :: is a known type,
512        # otherwise we could parse something like x::varchar(max) into a function
513        if self._match_set(self.TYPE_TOKENS, advance=False):
514            return self._parse_types()
515
516        return self._parse_function() or self._parse_types()
517
518    def _parse_options(self) -> list[exp.Expr] | None:
519        if not self._match(TokenType.OPTION):
520            return None
521
522        def _parse_option() -> exp.Expr | None:
523            option = self._parse_var_from_options(OPTIONS)
524            if not option:
525                return None
526
527            self._match(TokenType.EQ)
528            return self.expression(
529                exp.QueryOption(this=option, expression=self._parse_primary_or_var())
530            )
531
532        return self._parse_wrapped_csv(_parse_option)
533
534    def _parse_key_value_option(self) -> exp.XMLKeyValueOption:
535        this = self._parse_primary_or_var()
536        if self._match(TokenType.L_PAREN, advance=False):
537            expression = self._parse_wrapped(self._parse_string)
538        else:
539            expression = None
540
541        return exp.XMLKeyValueOption(this=this, expression=expression)
542
543    def _parse_for_clause_option(self, options: parser.OPTIONS_TYPE) -> exp.Expr | None:
544        return self.expression(
545            exp.QueryOption(
546                this=self._parse_var_from_options(options, raise_unmatched=False)
547                or self._parse_key_value_option()
548            )
549        )
550
551    def _parse_for(self) -> exp.ForClause | None:
552        if self._match_pair(TokenType.FOR, TokenType.XML):
553            return self.expression(
554                exp.ForClause(
555                    kind="XML",
556                    expressions=self._parse_csv(
557                        lambda: self._parse_for_clause_option(FOR_XML_OPTIONS)
558                    ),
559                )
560            )
561
562        if self._match_pair(TokenType.FOR, TokenType.JSON):
563            return self.expression(
564                exp.ForClause(
565                    kind="JSON",
566                    expressions=self._parse_csv(
567                        lambda: self._parse_for_clause_option(FOR_JSON_OPTIONS)
568                    ),
569                )
570            )
571
572        # FOR BROWSE — bare keyword, no options. BROWSE has no dedicated TokenType.
573        if self._match_text_seq("FOR", "BROWSE"):
574            return self.expression(exp.ForClause(kind="BROWSE"))
575
576        return None
577
578    def _parse_projections(
579        self,
580    ) -> tuple[list[exp.Expr], list[exp.Expr] | None]:
581        """
582        T-SQL supports the syntax alias = expression in the SELECT's projection list,
583        so we transform all parsed Selects to convert their EQ projections into Aliases.
584
585        See: https://learn.microsoft.com/en-us/sql/t-sql/queries/select-clause-transact-sql?view=sql-server-ver16#syntax
586        """
587        projections, _ = super()._parse_projections()
588        return [
589            (
590                exp.alias_(projection.expression, projection.this.this, copy=False)
591                if isinstance(projection, exp.EQ) and isinstance(projection.this, exp.Column)
592                else projection
593            )
594            for projection in projections
595        ], None
596
597    def _parse_commit_or_rollback(self) -> exp.Commit | exp.Rollback:
598        """Applies to SQL Server and Azure SQL Database
599        COMMIT [ { TRAN | TRANSACTION }
600            [ transaction_name | @tran_name_variable ] ]
601            [ WITH ( DELAYED_DURABILITY = { OFF | ON } ) ]
602
603        ROLLBACK { TRAN | TRANSACTION }
604            [ transaction_name | @tran_name_variable
605            | savepoint_name | @savepoint_variable ]
606        """
607        rollback = self._prev.token_type == TokenType.ROLLBACK
608
609        self._match_texts(("TRAN", "TRANSACTION"))
610        this = self._parse_id_var()
611
612        if rollback:
613            return self.expression(exp.Rollback(this=this))
614
615        durability = None
616        if self._match_pair(TokenType.WITH, TokenType.L_PAREN):
617            self._match_text_seq("DELAYED_DURABILITY")
618            self._match(TokenType.EQ)
619
620            if self._match_text_seq("OFF"):
621                durability = False
622            else:
623                self._match(TokenType.ON)
624                durability = True
625
626            self._match_r_paren()
627
628        return self.expression(exp.Commit(this=this, durability=durability))
629
630    def _parse_transaction(self) -> exp.Transaction | exp.Command:
631        """Applies to SQL Server and Azure SQL Database
632        BEGIN { TRAN | TRANSACTION }
633        [ { transaction_name | @tran_name_variable }
634        [ WITH MARK [ 'description' ] ]
635        ]
636        """
637        if self._match_texts(("TRAN", "TRANSACTION")):
638            transaction = self.expression(exp.Transaction(this=self._parse_id_var()))
639            if self._match_text_seq("WITH", "MARK"):
640                transaction.set("mark", self._parse_string())
641
642            return transaction
643
644        return self._parse_as_command(self._prev)
645
646    def _parse_returns(self) -> exp.ReturnsProperty:
647        table = self._parse_id_var(any_token=False, tokens=self.RETURNS_TABLE_TOKENS)
648        returns = super()._parse_returns()
649        returns.set("table", table)
650        return returns
651
652    def _parse_convert(self, strict: bool, safe: bool | None = None) -> exp.Expr | None:
653        this = self._parse_types()
654        self._match(TokenType.COMMA)
655        args = [this, *self._parse_csv(self._parse_assignment)]
656        convert = exp.Convert.from_arg_list(args)
657        convert.set("safe", safe)
658        return convert
659
660    def _parse_column_def(
661        self, this: exp.Expr | None, computed_column: bool = True
662    ) -> exp.Expr | None:
663        this = super()._parse_column_def(this=this, computed_column=computed_column)
664        if not this:
665            return None
666        if self._match(TokenType.EQ):
667            this.set("default", self._parse_disjunction())
668        if self._match_texts(self.COLUMN_DEFINITION_MODES):
669            this.set("output", self._prev.text)
670        return this
671
672    def _parse_user_defined_function(self, kind: TokenType | None = None) -> exp.Expr | None:
673        this = super()._parse_user_defined_function(kind=kind)
674
675        if kind == TokenType.FUNCTION or isinstance(this, exp.UserDefinedFunction):
676            return this
677
678        if kind == TokenType.PROCEDURE and this:
679            expressions = this.expressions
680            if not (
681                expressions or self._match_set((TokenType.ALIAS, TokenType.WITH), advance=False)
682            ):
683                expressions = self._parse_csv(self._parse_function_parameter)
684
685            return self.expression(
686                exp.StoredProcedure(
687                    this=this if isinstance(this, exp.Table) else this.this,
688                    expressions=expressions,
689                    wrapped=this.args.get("wrapped"),
690                )
691            )
692
693        return self.expression(exp.UserDefinedFunction(this=this))
694
695    def _parse_into(self) -> exp.Into | None:
696        into = super()._parse_into()
697
698        table = isinstance(into, exp.Into) and into.find(exp.Table)
699        if isinstance(table, exp.Table):
700            table_identifier = table.this
701            if table_identifier.args.get("temporary"):
702                # Promote the temporary property from the Identifier to the Into expression
703                t.cast(exp.Into, into).set("temporary", True)
704
705        return into
706
707    def _parse_id_var(
708        self,
709        any_token: bool = True,
710        tokens: Collection[TokenType] | None = None,
711    ) -> exp.Expr | None:
712        is_temporary = self._match(TokenType.HASH)
713        is_global = is_temporary and self._match(TokenType.HASH)
714
715        this = super()._parse_id_var(any_token=any_token, tokens=tokens)
716        if this:
717            if is_global:
718                this.set("global_", True)
719            elif is_temporary:
720                this.set("temporary", True)
721
722        return this
723
724    def _parse_table_parts(
725        self,
726        schema: bool = False,
727        is_db_reference: bool = False,
728        wildcard: bool = False,
729        fast: bool = False,
730    ) -> exp.Table | exp.Dot | None:
731        table = super()._parse_table_parts(
732            schema=schema,
733            is_db_reference=is_db_reference,
734            wildcard=wildcard,
735            fast=fast,
736        )
737        if (
738            isinstance(table, exp.Table)
739            and isinstance(table.this, exp.Identifier)
740            and (table_name := table.name).startswith("#")
741        ):
742            if table_name.startswith("##"):
743                table.this.set("this", table_name[2:])
744                table.this.set("global_", True)
745            else:
746                table.this.set("this", table_name[1:])
747                table.this.set("temporary", True)
748
749        return table
750
751    def _parse_create(self) -> exp.Create | exp.Command:
752        create = super()._parse_create()
753
754        if isinstance(create, exp.Create):
755            table = create.this.this if isinstance(create.this, exp.Schema) else create.this
756            if isinstance(table, exp.Table) and table.this and table.this.args.get("temporary"):
757                if not create.args.get("properties"):
758                    create.set("properties", exp.Properties(expressions=[]))
759
760                create.args["properties"].append("expressions", exp.TemporaryProperty())
761
762        return create
763
764    def _parse_if(self) -> exp.Expr | None:
765        this = self._parse_condition()
766        true = self._parse_block()
767
768        false = self._match(TokenType.ELSE) and self._parse_block()
769
770        return self.expression(exp.IfBlock(this=this, true=true, false=false))
771
772    def _parse_unique(self) -> exp.UniqueColumnConstraint:
773        if self._match_texts(("CLUSTERED", "NONCLUSTERED")):
774            this = self.CONSTRAINT_PARSERS[self._prev.text.upper()](self)
775        else:
776            this = self._parse_schema(self._parse_id_var(any_token=False))
777
778        return self.expression(exp.UniqueColumnConstraint(this=this))
779
780    def _parse_update(self) -> exp.Update:
781        expression = super()._parse_update()
782        expression.set("options", self._parse_options())
783        return expression
784
785    def _parse_partition(self) -> exp.Partition | None:
786        if not self._match_text_seq("WITH", "(", "PARTITIONS"):
787            return None
788
789        def parse_range():
790            low = self._parse_bitwise()
791            high = self._parse_bitwise() if self._match_text_seq("TO") else None
792
793            return self.expression(exp.PartitionRange(this=low, expression=high)) if high else low
794
795        partition = self.expression(exp.Partition(expressions=self._parse_wrapped_csv(parse_range)))
796
797        self._match_r_paren()
798
799        return partition
800
801    def _parse_alter_table_alter(self) -> exp.Expr | None:
802        expression = super()._parse_alter_table_alter()
803
804        if expression is not None:
805            collation = expression.args.get("collate")
806            if isinstance(collation, exp.Column) and isinstance(collation.this, exp.Identifier):
807                identifier = collation.this
808                collation.set("this", exp.Var(this=identifier.name))
809
810        return expression
811
812    def _parse_primary_key_part(self) -> exp.Expr | None:
813        return self._parse_ordered()