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    json_extract = parser.build_extract_json_with_path(exp.JSONExtract)(args, dialect)
309    json_extract.set("json_query", True)
310    return json_extract
311
312
313def _build_datetrunc(args: list) -> exp.TimestampTrunc:
314    unit = seq_get(args, 0)
315    this = seq_get(args, 1)
316
317    if this and this.is_string:
318        this = exp.cast(this, exp.DType.DATETIME2)
319
320    return exp.TimestampTrunc(this=this, unit=unit)
321
322
323class TSQLParser(parser.Parser):
324    SET_REQUIRES_ASSIGNMENT_DELIMITER = False
325    LOG_DEFAULTS_TO_LN = True
326    STRING_ALIASES = True
327    NO_PAREN_IF_COMMANDS = False
328    UNPIVOT_VALUE_COLUMNS_FIRST = True
329
330    NO_PAREN_FUNCTIONS = {
331        **parser.Parser.NO_PAREN_FUNCTIONS,
332        TokenType.SESSION_USER: exp.SessionUser,
333    }
334
335    QUERY_MODIFIER_PARSERS = {
336        **parser.Parser.QUERY_MODIFIER_PARSERS,
337        TokenType.OPTION: lambda self: ("options", self._parse_options()),
338        TokenType.FOR: lambda self: ("for_", self._parse_for()),
339    }
340
341    # T-SQL does not allow BEGIN to be used as an identifier
342    ID_VAR_TOKENS = parser.Parser.ID_VAR_TOKENS - {TokenType.BEGIN}
343    ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {TokenType.BEGIN}
344    TABLE_ALIAS_TOKENS = (parser.Parser.TABLE_ALIAS_TOKENS | {TokenType.ANTI, TokenType.SEMI}) - {
345        TokenType.BEGIN
346    }
347    COMMENT_TABLE_ALIAS_TOKENS = parser.Parser.COMMENT_TABLE_ALIAS_TOKENS - {TokenType.BEGIN}
348    UPDATE_ALIAS_TOKENS = parser.Parser.UPDATE_ALIAS_TOKENS - {TokenType.BEGIN}
349
350    FUNCTIONS = {
351        **parser.Parser.FUNCTIONS,
352        "ATN2": exp.Atan2.from_arg_list,
353        "CHARINDEX": lambda args: exp.StrPosition(
354            this=seq_get(args, 1),
355            substr=seq_get(args, 0),
356            position=seq_get(args, 2),
357        ),
358        "COUNT": lambda args: exp.Count(this=seq_get(args, 0), expressions=args[1:], big_int=False),
359        "COUNT_BIG": lambda args: exp.Count(
360            this=seq_get(args, 0), expressions=args[1:], big_int=True
361        ),
362        "DATEADD": build_date_delta(exp.DateAdd, unit_mapping=DATE_DELTA_INTERVAL),
363        "DATEDIFF": _build_date_delta(exp.DateDiff, unit_mapping=DATE_DELTA_INTERVAL),
364        "DATEDIFF_BIG": _build_date_delta(
365            exp.DateDiff, unit_mapping=DATE_DELTA_INTERVAL, big_int=True
366        ),
367        "DATENAME": _build_formatted_time(exp.TimeToStr, full_format_mapping=True),
368        "DATETIMEFROMPARTS": _build_datetimefromparts,
369        "DAY": lambda args: exp.Day(
370            this=exp.TsOrDsToDate(
371                this=seq_get(args, 0), default_date=exp.Literal.string("1900-01-01")
372            )
373        ),
374        "EOMONTH": _build_eomonth,
375        "FORMAT": _build_format,
376        "GETDATE": exp.CurrentTimestamp.from_arg_list,
377        "HASHBYTES": _build_hashbytes,
378        "ISNULL": lambda args: build_coalesce(args=args, is_null=True),
379        "JSON_QUERY": _build_json_query,
380        "JSON_VALUE": parser.build_extract_json_with_path(exp.JSONExtractScalar),
381        "LEN": _build_with_arg_as_text(exp.Length),
382        "LEFT": _build_with_arg_as_text(exp.Left),
383        "MONTH": lambda args: exp.Month(
384            this=exp.TsOrDsToDate(
385                this=seq_get(args, 0), default_date=exp.Literal.string("1900-01-01")
386            )
387        ),
388        "NEWID": exp.Uuid.from_arg_list,
389        "RIGHT": _build_with_arg_as_text(exp.Right),
390        "PARSENAME": _build_parsename,
391        "REPLICATE": exp.Repeat.from_arg_list,
392        "SCHEMA_NAME": exp.CurrentSchema.from_arg_list,
393        "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),
394        "SYSDATETIME": exp.CurrentTimestamp.from_arg_list,
395        "SUSER_NAME": exp.CurrentUser.from_arg_list,
396        "SUSER_SNAME": exp.CurrentUser.from_arg_list,
397        "SYSDATETIMEOFFSET": exp.CurrentTimestampLTZ.from_arg_list,
398        "SYSTEM_USER": exp.CurrentUser.from_arg_list,
399        "TIMEFROMPARTS": _build_timefromparts,
400        "DATETRUNC": _build_datetrunc,
401        "YEAR": lambda args: exp.Year(
402            this=exp.TsOrDsToDate(
403                this=seq_get(args, 0), default_date=exp.Literal.string("1900-01-01")
404            )
405        ),
406    }
407
408    JOIN_HINTS = {"LOOP", "HASH", "MERGE", "REMOTE"}
409
410    PROCEDURE_OPTIONS = dict.fromkeys(
411        ("ENCRYPTION", "RECOMPILE", "SCHEMABINDING", "NATIVE_COMPILATION", "EXECUTE"), tuple()
412    )
413
414    COLUMN_DEFINITION_MODES: t.ClassVar = {"OUT", "OUTPUT", "READONLY"}
415
416    RETURNS_TABLE_TOKENS: t.ClassVar = parser.Parser.ID_VAR_TOKENS - {
417        TokenType.TABLE,
418        *parser.Parser.TYPE_TOKENS,
419    }
420
421    STATEMENT_PARSERS = {
422        **parser.Parser.STATEMENT_PARSERS,
423        TokenType.EXECUTE: lambda self: self._parse_execute(),
424    }
425
426    RANGE_PARSERS = {
427        **parser.Parser.RANGE_PARSERS,
428        TokenType.DCOLON: lambda self, this: self.expression(
429            exp.ScopeResolution(
430                this=this, expression=self._parse_function() or self._parse_var(any_token=True)
431            )
432        ),
433    }
434
435    NO_PAREN_FUNCTION_PARSERS = {
436        **parser.Parser.NO_PAREN_FUNCTION_PARSERS,
437        "NEXT": lambda self: self._parse_next_value_for(),
438    }
439
440    FUNCTION_PARSERS = {
441        **parser.Parser.FUNCTION_PARSERS,
442        "JSON_ARRAYAGG": lambda self: self.expression(
443            exp.JSONArrayAgg(
444                this=self._parse_bitwise(),
445                order=self._parse_order(),
446                null_handling=self._parse_on_handling("NULL", "NULL", "ABSENT"),
447            )
448        ),
449        "DATEPART": lambda self: self._parse_datepart(),
450    }
451
452    # The DCOLON (::) operator serves as a scope resolution (exp.ScopeResolution) operator in T-SQL
453    COLUMN_OPERATORS = {
454        **parser.Parser.COLUMN_OPERATORS,
455        TokenType.DCOLON: lambda self, this, to: (
456            self.expression(exp.Cast(this=this, to=to))
457            if isinstance(to, exp.DataType) and to.this != exp.DType.USERDEFINED
458            else self.expression(exp.ScopeResolution(this=this, expression=to))
459        ),
460    }
461
462    SET_OP_MODIFIERS = {"offset"}
463
464    ODBC_DATETIME_LITERALS = {
465        "d": exp.Date,
466        "t": exp.Time,
467        "ts": exp.Timestamp,
468    }
469
470    def _parse_execute(self) -> exp.Execute:
471        return_status = None
472        index = self._index
473        if self._match(TokenType.PARAMETER):
474            param = self._parse_parameter()
475            if self._match(TokenType.EQ):
476                return_status = param
477            else:
478                self._retreat(index)
479
480        execute = self.expression(
481            exp.Execute(
482                this=self._parse_table(schema=True),
483                expressions=self._parse_csv(self._parse_expression),
484                return_status=return_status,
485            )
486        )
487
488        if execute.name.lower() == "sp_executesql":
489            execute = self.expression(exp.ExecuteSql(**execute.args))
490
491        return execute
492
493    def _parse_datepart(self) -> exp.Extract:
494        this = self._parse_var(tokens=[TokenType.IDENTIFIER])
495        expression = self._match(TokenType.COMMA) and self._parse_bitwise()
496        name = map_date_part(this, self.dialect)
497
498        return self.expression(exp.Extract(this=name, expression=expression))
499
500    def _parse_alter_table_set(self) -> exp.AlterSet:
501        return self._parse_wrapped(super()._parse_alter_table_set)
502
503    def _parse_wrapped_select(self, table: bool = False) -> exp.Expr | None:
504        if self._match(TokenType.MERGE):
505            comments = self._prev_comments
506            merge = self._parse_merge()
507            merge.add_comments(comments, prepend=True)
508            return merge
509
510        return super()._parse_wrapped_select(table=table)
511
512    def _parse_dcolon(self) -> exp.Expr | None:
513        # We want to use _parse_types() if the first token after :: is a known type,
514        # otherwise we could parse something like x::varchar(max) into a function
515        if self._match_set(self.TYPE_TOKENS, advance=False):
516            return self._parse_types()
517
518        return self._parse_function() or self._parse_types()
519
520    def _parse_options(self) -> list[exp.Expr] | None:
521        if not self._match(TokenType.OPTION):
522            return None
523
524        def _parse_option() -> exp.Expr | None:
525            option = self._parse_var_from_options(OPTIONS)
526            if not option:
527                return None
528
529            self._match(TokenType.EQ)
530            return self.expression(
531                exp.QueryOption(this=option, expression=self._parse_primary_or_var())
532            )
533
534        return self._parse_wrapped_csv(_parse_option)
535
536    def _parse_key_value_option(self) -> exp.XMLKeyValueOption:
537        this = self._parse_primary_or_var()
538        if self._match(TokenType.L_PAREN, advance=False):
539            expression = self._parse_wrapped(self._parse_string)
540        else:
541            expression = None
542
543        return exp.XMLKeyValueOption(this=this, expression=expression)
544
545    def _parse_for_clause_option(self, options: parser.OPTIONS_TYPE) -> exp.Expr | None:
546        return self.expression(
547            exp.QueryOption(
548                this=self._parse_var_from_options(options, raise_unmatched=False)
549                or self._parse_key_value_option()
550            )
551        )
552
553    def _parse_for(self) -> exp.ForClause | None:
554        if self._match_pair(TokenType.FOR, TokenType.XML):
555            return self.expression(
556                exp.ForClause(
557                    kind="XML",
558                    expressions=self._parse_csv(
559                        lambda: self._parse_for_clause_option(FOR_XML_OPTIONS)
560                    ),
561                )
562            )
563
564        if self._match_pair(TokenType.FOR, TokenType.JSON):
565            return self.expression(
566                exp.ForClause(
567                    kind="JSON",
568                    expressions=self._parse_csv(
569                        lambda: self._parse_for_clause_option(FOR_JSON_OPTIONS)
570                    ),
571                )
572            )
573
574        # FOR BROWSE — bare keyword, no options. BROWSE has no dedicated TokenType.
575        if self._match_text_seq("FOR", "BROWSE"):
576            return self.expression(exp.ForClause(kind="BROWSE"))
577
578        return None
579
580    def _parse_projections(
581        self,
582    ) -> tuple[list[exp.Expr], list[exp.Expr] | None]:
583        """
584        T-SQL supports the syntax alias = expression in the SELECT's projection list,
585        so we transform all parsed Selects to convert their EQ projections into Aliases.
586
587        See: https://learn.microsoft.com/en-us/sql/t-sql/queries/select-clause-transact-sql?view=sql-server-ver16#syntax
588        """
589        projections, _ = super()._parse_projections()
590        return [
591            (
592                exp.alias_(projection.expression, projection.this.this, copy=False)
593                if isinstance(projection, exp.EQ) and isinstance(projection.this, exp.Column)
594                else projection
595            )
596            for projection in projections
597        ], None
598
599    def _parse_commit_or_rollback(self) -> exp.Commit | exp.Rollback:
600        """Applies to SQL Server and Azure SQL Database
601        COMMIT [ { TRAN | TRANSACTION }
602            [ transaction_name | @tran_name_variable ] ]
603            [ WITH ( DELAYED_DURABILITY = { OFF | ON } ) ]
604
605        ROLLBACK { TRAN | TRANSACTION }
606            [ transaction_name | @tran_name_variable
607            | savepoint_name | @savepoint_variable ]
608        """
609        rollback = self._prev.token_type == TokenType.ROLLBACK
610
611        self._match_texts(("TRAN", "TRANSACTION"))
612        this = self._parse_id_var()
613
614        if rollback:
615            return self.expression(exp.Rollback(this=this))
616
617        durability = None
618        if self._match_pair(TokenType.WITH, TokenType.L_PAREN):
619            self._match_text_seq("DELAYED_DURABILITY")
620            self._match(TokenType.EQ)
621
622            if self._match_text_seq("OFF"):
623                durability = False
624            else:
625                self._match(TokenType.ON)
626                durability = True
627
628            self._match_r_paren()
629
630        return self.expression(exp.Commit(this=this, durability=durability))
631
632    def _parse_transaction(self) -> exp.Transaction | exp.Command:
633        """Applies to SQL Server and Azure SQL Database
634        BEGIN { TRAN | TRANSACTION }
635        [ { transaction_name | @tran_name_variable }
636        [ WITH MARK [ 'description' ] ]
637        ]
638        """
639        if self._match_texts(("TRAN", "TRANSACTION")):
640            transaction = self.expression(exp.Transaction(this=self._parse_id_var()))
641            if self._match_text_seq("WITH", "MARK"):
642                transaction.set("mark", self._parse_string())
643
644            return transaction
645
646        return self._parse_as_command(self._prev)
647
648    def _parse_returns(self) -> exp.ReturnsProperty:
649        table = self._parse_id_var(any_token=False, tokens=self.RETURNS_TABLE_TOKENS)
650        returns = super()._parse_returns()
651        returns.set("table", table)
652        return returns
653
654    def _parse_convert(self, strict: bool, safe: bool | None = None) -> exp.Expr | None:
655        this = self._parse_types()
656        self._match(TokenType.COMMA)
657        args = [this, *self._parse_csv(self._parse_assignment)]
658        convert = exp.Convert.from_arg_list(args)
659        convert.set("safe", safe)
660        return convert
661
662    def _parse_column_def(
663        self, this: exp.Expr | None, computed_column: bool = True
664    ) -> exp.Expr | None:
665        this = super()._parse_column_def(this=this, computed_column=computed_column)
666        if not this:
667            return None
668        if self._match(TokenType.EQ):
669            this.set("default", self._parse_disjunction())
670        if self._match_texts(self.COLUMN_DEFINITION_MODES):
671            this.set("output", self._prev.text)
672        return this
673
674    def _parse_user_defined_function(self, kind: TokenType | None = None) -> exp.Expr | None:
675        this = super()._parse_user_defined_function(kind=kind)
676
677        if kind == TokenType.FUNCTION or isinstance(this, exp.UserDefinedFunction):
678            return this
679
680        if kind == TokenType.PROCEDURE and this:
681            expressions = this.expressions
682            if not (
683                expressions or self._match_set((TokenType.ALIAS, TokenType.WITH), advance=False)
684            ):
685                expressions = self._parse_csv(self._parse_function_parameter)
686
687            return self.expression(
688                exp.StoredProcedure(
689                    this=this if isinstance(this, exp.Table) else this.this,
690                    expressions=expressions,
691                    wrapped=this.args.get("wrapped"),
692                )
693            )
694
695        return self.expression(exp.UserDefinedFunction(this=this))
696
697    def _parse_into(self) -> exp.Into | None:
698        into = super()._parse_into()
699
700        table = isinstance(into, exp.Into) and into.find(exp.Table)
701        if isinstance(table, exp.Table):
702            table_identifier = table.this
703            if table_identifier.args.get("temporary"):
704                # Promote the temporary property from the Identifier to the Into expression
705                t.cast(exp.Into, into).set("temporary", True)
706
707        return into
708
709    def _parse_id_var(
710        self,
711        any_token: bool = True,
712        tokens: Collection[TokenType] | None = None,
713    ) -> exp.Expr | None:
714        is_temporary = self._match(TokenType.HASH)
715        is_global = is_temporary and self._match(TokenType.HASH)
716
717        this = super()._parse_id_var(any_token=any_token, tokens=tokens)
718        if this:
719            if is_global:
720                this.set("global_", True)
721            elif is_temporary:
722                this.set("temporary", True)
723
724        return this
725
726    def _parse_table_parts(
727        self,
728        schema: bool = False,
729        is_db_reference: bool = False,
730        wildcard: bool = False,
731        fast: bool = False,
732    ) -> exp.Table | exp.Dot | None:
733        table = super()._parse_table_parts(
734            schema=schema,
735            is_db_reference=is_db_reference,
736            wildcard=wildcard,
737            fast=fast,
738        )
739        if (
740            isinstance(table, exp.Table)
741            and isinstance(table.this, exp.Identifier)
742            and (table_name := table.name).startswith("#")
743        ):
744            if table_name.startswith("##"):
745                table.this.set("this", table_name[2:])
746                table.this.set("global_", True)
747            else:
748                table.this.set("this", table_name[1:])
749                table.this.set("temporary", True)
750
751        return table
752
753    def _parse_create(self) -> exp.Create | exp.Command:
754        create = super()._parse_create()
755
756        if isinstance(create, exp.Create):
757            table = create.this.this if isinstance(create.this, exp.Schema) else create.this
758            if isinstance(table, exp.Table) and table.this and table.this.args.get("temporary"):
759                if not create.args.get("properties"):
760                    create.set("properties", exp.Properties(expressions=[]))
761
762                create.args["properties"].append("expressions", exp.TemporaryProperty())
763
764        return create
765
766    def _parse_if(self) -> exp.Expr | None:
767        this = self._parse_condition()
768        true = self._parse_block()
769
770        false = self._match(TokenType.ELSE) and self._parse_block()
771
772        return self.expression(exp.IfBlock(this=this, true=true, false=false))
773
774    def _parse_unique(self) -> exp.UniqueColumnConstraint:
775        if self._match_texts(("CLUSTERED", "NONCLUSTERED")):
776            this = self.CONSTRAINT_PARSERS[self._prev.text.upper()](self)
777        else:
778            this = self._parse_schema(self._parse_id_var(any_token=False))
779
780        return self.expression(exp.UniqueColumnConstraint(this=this))
781
782    def _parse_update(self) -> exp.Update:
783        expression = super()._parse_update()
784        expression.set("options", self._parse_options())
785        return expression
786
787    def _parse_partition(self) -> exp.Partition | None:
788        if not self._match_text_seq("WITH", "(", "PARTITIONS"):
789            return None
790
791        def parse_range():
792            low = self._parse_bitwise()
793            high = self._parse_bitwise() if self._match_text_seq("TO") else None
794
795            return self.expression(exp.PartitionRange(this=low, expression=high)) if high else low
796
797        partition = self.expression(exp.Partition(expressions=self._parse_wrapped_csv(parse_range)))
798
799        self._match_r_paren()
800
801        return partition
802
803    def _parse_alter_table_alter(self) -> exp.Expr | None:
804        expression = super()._parse_alter_table_alter()
805
806        if expression is not None:
807            collation = expression.args.get("collate")
808            if isinstance(collation, exp.Column) and isinstance(collation.this, exp.Identifier):
809                identifier = collation.this
810                collation.set("this", exp.Var(this=identifier.name))
811
812            if expression.args.get("dtype"):
813                if self._match_pair(TokenType.NOT, TokenType.NULL):
814                    expression.set("allow_null", False)
815                elif self._match(TokenType.NULL):
816                    expression.set("allow_null", True)
817
818        return expression
819
820    def _parse_primary_key_part(self) -> exp.Expr | None:
821        return self._parse_ordered()