sqlglot.parsers.duckdb

  1from __future__ import annotations
  2
  3import typing as t
  4
  5from sqlglot import exp, parser
  6from sqlglot.trie import new_trie
  7from sqlglot.dialects.dialect import (
  8    binary_from_function,
  9    build_default_decimal_type,
 10    build_formatted_time,
 11    build_regexp_extract,
 12    date_trunc_to_time,
 13    pivot_column_names,
 14)
 15from sqlglot.helper import seq_get
 16from sqlglot.parser import IsPredicatePrecedence, binary_range_parser
 17from sqlglot.tokens import TokenType
 18from collections.abc import Collection
 19
 20
 21def _build_list_sort(name: str, desc: bool = False) -> t.Callable[[list], exp.Expr]:
 22    # Orders are case-insensitive strings, e.g. LIST_SORT(x, 'desc', 'nulls first'), and NULLs default to last
 23    def _builder(args: list) -> exp.Expr:
 24        orders = [exp.Literal.string("DESC"), *args[1:]] if desc else args[1:]
 25        order_name = _list_sort_order_name(seq_get(orders, 0), "ASC")
 26        null_order_name = _list_sort_order_name(seq_get(orders, 1), "NULLS LAST")
 27        valid = order_name in ("ASC", "DESC") and null_order_name in ("NULLS FIRST", "NULLS LAST")
 28        if not valid:
 29            return exp.Anonymous(this=name, expressions=args)
 30
 31        return exp.ArraySort(
 32            this=seq_get(args, 0),
 33            asc=exp.false() if order_name == "DESC" else None,
 34            nulls_first=exp.Boolean(this=null_order_name == "NULLS FIRST"),
 35        )
 36
 37    return _builder
 38
 39
 40def _list_sort_order_name(order: exp.Expr | None, default: str) -> str | None:
 41    if order is None:
 42        return default
 43    return order.name.upper() if order.is_string else None
 44
 45
 46def _build_array_prepend(args: list) -> exp.Expr:
 47    return exp.ArrayPrepend(this=seq_get(args, 1), expression=seq_get(args, 0))
 48
 49
 50def _build_date_diff(args: list) -> exp.Expr:
 51    unit = seq_get(args, 0)
 52
 53    # DATE_DIFF counts the unit boundaries crossed, e.g. one month from 2026-01-31 to 2026-02-01,
 54    # except for WEEK, which counts whole 7-day spans
 55    date_part_boundary = (
 56        isinstance(unit, (exp.Literal, exp.Var)) and unit.name.upper() not in ("WEEK", "WEEKS", "W")
 57    ) or None
 58
 59    return exp.DateDiff(
 60        this=seq_get(args, 2),
 61        expression=seq_get(args, 1),
 62        unit=unit,
 63        date_part_boundary=date_part_boundary,
 64    )
 65
 66
 67def _build_generate_series(end_exclusive: bool = False) -> t.Callable[[list], exp.GenerateSeries]:
 68    def _builder(args: list) -> exp.GenerateSeries:
 69        # Check https://duckdb.org/docs/sql/functions/nested.html#range-functions
 70        if len(args) == 1:
 71            # DuckDB uses 0 as a default for the series' start when it's omitted
 72            args.insert(0, exp.Literal.number("0"))
 73
 74        gen_series = exp.GenerateSeries.from_arg_list(args)
 75        gen_series.set("is_end_exclusive", end_exclusive)
 76
 77        return gen_series
 78
 79    return _builder
 80
 81
 82def _build_make_timestamp(args: list) -> exp.Expr:
 83    if len(args) == 1:
 84        return exp.UnixToTime(this=seq_get(args, 0), scale=exp.UnixToTime.MICROS)
 85
 86    return exp.TimestampFromParts(
 87        year=seq_get(args, 0),
 88        month=seq_get(args, 1),
 89        day=seq_get(args, 2),
 90        hour=seq_get(args, 3),
 91        min=seq_get(args, 4),
 92        sec=seq_get(args, 5),
 93    )
 94
 95
 96def _show_parser(*args: t.Any, **kwargs: t.Any) -> t.Callable[[DuckDBParser], exp.Show]:
 97    def _parse(self: DuckDBParser) -> exp.Show:
 98        return self._parse_show_duckdb(*args, **kwargs)
 99
100    return _parse
101
102
103def _convert_text_type(dtype: exp.DataType) -> exp.DataType:
104    dtype.set("expressions", None)
105    return dtype
106
107
108_parse_regexp_like = binary_range_parser(exp.RegexpLike)
109_parse_regexp_full_match = binary_range_parser(exp.RegexpFullMatch)
110
111
112class DuckDBParser(parser.Parser):
113    SUPPORTS_TABLE_QUERY = True
114
115    IS_PREDICATE_PRECEDENCE = IsPredicatePrecedence.LOW
116
117    MAP_KEYS_ARE_ARBITRARY_EXPRESSIONS = True
118    PIVOT_COLUMN_NAMING = "agg_name_if_aliased_or_multiple"
119
120    SUPPORTS_DIRECTED_JOIN = False
121
122    JOIN_KINDS = parser.Parser.JOIN_KINDS - {TokenType.STRAIGHT_JOIN}
123
124    NO_PAREN_FUNCTIONS = {
125        **parser.Parser.NO_PAREN_FUNCTIONS,
126        TokenType.LOCALTIME: exp.Localtime,
127        TokenType.LOCALTIMESTAMP: exp.Localtimestamp,
128        TokenType.CURRENT_CATALOG: exp.CurrentCatalog,
129        TokenType.SESSION_USER: exp.SessionUser,
130    }
131
132    BITWISE = {k: v for k, v in parser.Parser.BITWISE.items() if k != TokenType.CARET}
133
134    COLUMN_OPERATORS = {
135        k: v
136        for k, v in parser.Parser.COLUMN_OPERATORS.items()
137        if k not in (TokenType.ARROW, TokenType.DARROW)
138    }
139
140    JSON_OPERATORS = {
141        TokenType.ARROW: parser.build_json_extract,
142        TokenType.DARROW: parser.build_json_extract_scalar,
143    }
144
145    RANGE_PARSERS = {
146        **parser.Parser.RANGE_PARSERS,
147        TokenType.DAMP: binary_range_parser(exp.ArrayOverlaps),
148        TokenType.TILDE: lambda self, this: self._parse_tilde(this),
149    }
150
151    EXPONENT = {
152        **parser.Parser.EXPONENT,
153        TokenType.CARET: exp.Pow,
154        TokenType.DSTAR: exp.Pow,
155    }
156
157    FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "STRUCT_PACK"}
158
159    SHOW_PARSERS = {
160        "TABLES": _show_parser("TABLES"),
161        "ALL TABLES": _show_parser("ALL TABLES"),
162    }
163
164    FUNCTIONS = {
165        **{k: v for k, v in parser.Parser.FUNCTIONS.items() if k not in ("DATE_SUB", "GLOB")},
166        **dict.fromkeys(
167            ("ARRAY_DISTINCT", "LIST_DISTINCT"),
168            lambda args: exp.ArrayDistinct(this=seq_get(args, 0), check_null=False),
169        ),
170        "ANY_VALUE": lambda args: exp.IgnoreNulls(this=exp.AnyValue.from_arg_list(args)),
171        "ARRAY_PREPEND": _build_array_prepend,
172        "ARRAY_REVERSE_SORT": _build_list_sort("ARRAY_REVERSE_SORT", desc=True),
173        "ARRAY_INTERSECT": lambda args: exp.ArrayIntersect(expressions=args),
174        "ARRAY_SORT": _build_list_sort("ARRAY_SORT"),
175        "ARRAY_SLICE": lambda args: exp.ArraySlice(
176            this=seq_get(args, 0),
177            start=seq_get(args, 1),
178            end=seq_get(args, 2),
179            step=seq_get(args, 3),
180            is_length=False,
181        ),
182        "BIT_AND": exp.BitwiseAndAgg.from_arg_list,
183        "BIT_OR": exp.BitwiseOrAgg.from_arg_list,
184        "BIT_XOR": exp.BitwiseXorAgg.from_arg_list,
185        "CURRENT_LOCALTIMESTAMP": exp.Localtimestamp.from_arg_list,
186        "DATEDIFF": _build_date_diff,
187        "DATE_DIFF": _build_date_diff,
188        "DATE_TRUNC": date_trunc_to_time,
189        "DATETRUNC": date_trunc_to_time,
190        "DECODE": lambda args: exp.Decode(
191            this=seq_get(args, 0), charset=exp.Literal.string("utf-8")
192        ),
193        "EDITDIST3": exp.Levenshtein.from_arg_list,
194        "ENCODE": lambda args: exp.Encode(
195            this=seq_get(args, 0), charset=exp.Literal.string("utf-8")
196        ),
197        "EPOCH": exp.TimeToUnix.from_arg_list,
198        "EPOCH_MS": lambda args: exp.UnixToTime(this=seq_get(args, 0), scale=exp.UnixToTime.MILLIS),
199        "FROM_HEX": exp.Unhex.from_arg_list,
200        "GENERATE_SERIES": _build_generate_series(),
201        "GET_CURRENT_TIME": exp.CurrentTime.from_arg_list,
202        "GET_BIT": lambda args: exp.Getbit(
203            this=seq_get(args, 0), expression=seq_get(args, 1), zero_is_msb=True
204        ),
205        "JARO_WINKLER_SIMILARITY": exp.JarowinklerSimilarity.from_arg_list,
206        "JSON": exp.ParseJSON.from_arg_list,
207        "JSON_ARRAY": lambda args: exp.JSONArray(expressions=args),
208        "JSON_EXTRACT_PATH": parser.build_extract_json_with_path(exp.JSONExtract),
209        "JSON_EXTRACT_STRING": parser.build_extract_json_with_path(exp.JSONExtractScalar),
210        "LIST": exp.ArrayAgg.from_arg_list,
211        "LIST_APPEND": exp.ArrayAppend.from_arg_list,
212        "LIST_CONCAT": parser.build_array_concat,
213        "LIST_CONTAINS": exp.ArrayContains.from_arg_list,
214        "LIST_COSINE_DISTANCE": exp.CosineDistance.from_arg_list,
215        "LIST_DISTANCE": exp.EuclideanDistance.from_arg_list,
216        "LIST_FILTER": exp.ArrayFilter.from_arg_list,
217        "LIST_HAS": exp.ArrayContains.from_arg_list,
218        "LIST_HAS_ANY": exp.ArrayOverlaps.from_arg_list,
219        "LIST_MAX": exp.ArrayMax.from_arg_list,
220        "LIST_MIN": exp.ArrayMin.from_arg_list,
221        "LIST_PREPEND": _build_array_prepend,
222        "LIST_REVERSE_SORT": _build_list_sort("LIST_REVERSE_SORT", desc=True),
223        "LIST_SORT": _build_list_sort("LIST_SORT"),
224        "LIST_TRANSFORM": exp.Transform.from_arg_list,
225        "LIST_VALUE": lambda args: exp.Array(
226            expressions=args, value_constructor=len(args) == 1 and isinstance(args[0], exp.Query)
227        ),
228        "MAKE_DATE": exp.DateFromParts.from_arg_list,
229        "MAKE_TIME": exp.TimeFromParts.from_arg_list,
230        "MAKE_TIMESTAMP": _build_make_timestamp,
231        "QUANTILE_CONT": exp.PercentileCont.from_arg_list,
232        "QUANTILE_DISC": exp.PercentileDisc.from_arg_list,
233        "RANGE": _build_generate_series(end_exclusive=True),
234        "REGEXP_EXTRACT": build_regexp_extract(exp.RegexpExtract),
235        "REGEXP_EXTRACT_ALL": build_regexp_extract(exp.RegexpExtractAll),
236        "REGEXP_MATCHES": exp.RegexpLike.from_arg_list,
237        "REGEXP_REPLACE": lambda args: exp.RegexpReplace(
238            this=seq_get(args, 0),
239            expression=seq_get(args, 1),
240            replacement=seq_get(args, 2),
241            modifiers=seq_get(args, 3),
242            single_replace=True,
243        ),
244        "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
245        "STRFTIME": build_formatted_time(exp.TimeToStr),
246        "STRING_SPLIT": exp.Split.from_arg_list,
247        "STRING_SPLIT_REGEX": exp.RegexpSplit.from_arg_list,
248        "STRING_TO_ARRAY": exp.Split.from_arg_list,
249        "STRPTIME": build_formatted_time(exp.StrToTime),
250        "STRUCT_PACK": exp.Struct.from_arg_list,
251        "STR_SPLIT": exp.Split.from_arg_list,
252        "STR_SPLIT_REGEX": exp.RegexpSplit.from_arg_list,
253        "TODAY": exp.CurrentDate.from_arg_list,
254        "TIME_BUCKET": exp.DateBin.from_arg_list,
255        "TO_TIMESTAMP": exp.UnixToTime.from_arg_list,
256        "UNNEST": exp.Explode.from_arg_list,
257        "VERSION": exp.CurrentVersion.from_arg_list,
258        "XOR": binary_from_function(exp.BitwiseXor),
259    }
260
261    FUNCTION_PARSERS = {
262        **{k: v for k, v in parser.Parser.FUNCTION_PARSERS.items() if k != "DECODE"},
263        **dict.fromkeys(
264            ("GROUP_CONCAT", "LISTAGG", "STRINGAGG"), lambda self: self._parse_string_agg()
265        ),
266        "APPROX_QUANTILE": lambda self: self._parse_distinct_arg_function(exp.ApproxQuantile),
267        "MAX": lambda self: self._parse_min_max(exp.Max),
268        "MIN": lambda self: self._parse_min_max(exp.Min),
269        "QUANTILE": lambda self: self._parse_distinct_arg_function(exp.Quantile),
270        "QUANTILE_CONT": lambda self: self._parse_distinct_arg_function(exp.PercentileCont),
271        "QUANTILE_DISC": lambda self: self._parse_distinct_arg_function(exp.PercentileDisc),
272    }
273
274    NO_PAREN_FUNCTION_PARSERS = {
275        **parser.Parser.NO_PAREN_FUNCTION_PARSERS,
276        "MAP": lambda self: self._parse_map(),
277        "@": lambda self: exp.Abs(this=self._parse_bitwise()),
278    }
279
280    PLACEHOLDER_PARSERS = {
281        **parser.Parser.PLACEHOLDER_PARSERS,
282        TokenType.PARAMETER: lambda self: (
283            self.expression(
284                exp.Placeholder(
285                    this=self._identifier_expression(quoted=True)
286                    if self._prev.token_type == TokenType.IDENTIFIER
287                    else self._prev.text
288                )
289            )
290            if self._match(TokenType.NUMBER) or self._match_set(self.ID_VAR_TOKENS)
291            else None
292        ),
293    }
294
295    TYPE_CONVERTERS = {
296        # https://duckdb.org/docs/sql/data_types/numeric
297        exp.DType.DECIMAL: build_default_decimal_type(precision=18, scale=3),
298        # https://duckdb.org/docs/sql/data_types/text
299        exp.DType.TEXT: _convert_text_type,
300    }
301
302    STATEMENT_PARSERS = {
303        **parser.Parser.STATEMENT_PARSERS,
304        TokenType.ATTACH: lambda self: self._parse_attach_detach(),
305        TokenType.CONNECT: lambda self: self.expression(
306            exp.ConnectTo(this=self._parse_string() or self._parse_id_var())
307        ),
308        TokenType.DETACH: lambda self: self._parse_attach_detach(is_attach=False),
309        TokenType.DISCONNECT: lambda self: self.expression(exp.Disconnect()),
310        TokenType.FORCE: lambda self: self._parse_force(),
311        TokenType.INSTALL: lambda self: self._parse_install(),
312        TokenType.SHOW: lambda self: self._parse_show(),
313    }
314
315    SET_PARSERS = {
316        **parser.Parser.SET_PARSERS,
317        "VARIABLE": lambda self: self._parse_set_item_assignment("VARIABLE"),
318    }
319
320    SHOW_TRIE = new_trie(key.split(" ") for key in SHOW_PARSERS)
321    SET_TRIE = new_trie(key.split(" ") for key in SET_PARSERS)
322
323    def _parse_min_max(self, func: type[exp.Min] | type[exp.Max]) -> exp.Min | exp.Max:
324        expression = self._parse_distinct_arg_function(func)
325        if len(expression.expressions) > 1:
326            self.raise_error(f"Expected at most 2 arguments for {func.__name__}")
327        expression.set("count", seq_get(expression.expressions, 0))
328        expression.set("expressions", None)
329        return expression
330
331    def _parse_tilde(self, this: exp.Expr | None) -> exp.Expr | None:
332        # ~ and !~ match anywhere in the string since DuckDB 2.0, and the whole string before it
333        # https://duckdb.org/docs/2.0/sql/functions/pattern_matching
334        if self.dialect.version >= (2, 0):
335            return _parse_regexp_like(self, this)
336        return _parse_regexp_full_match(self, this)
337
338    def _parse_trigger_execute(self) -> exp.Expr | None:
339        body = self._try_parse(self._parse_statement)
340        return body if not self._curr else None
341
342    def _parse_function_properties(self) -> exp.Properties | None:
343        if self._match(TokenType.TABLE):
344            return exp.Properties(
345                expressions=[
346                    exp.ReturnsProperty(
347                        this=exp.Schema(this=exp.var("TABLE")),
348                        is_table=True,
349                    ),
350                ]
351            )
352        return super()._parse_function_properties()
353
354    def _parse_lambda(self, alias: bool = False) -> exp.Expr | None:
355        index = self._index
356        if not self._match_text_seq("LAMBDA"):
357            return super()._parse_lambda(alias=alias)
358
359        expressions = self._parse_csv(self._parse_lambda_arg)
360        if not self._match(TokenType.COLON):
361            self._retreat(index)
362            return None
363
364        this = self._replace_lambda(self._parse_assignment(), expressions)
365        return self.expression(exp.Lambda(this=this, expressions=expressions))
366
367    def _parse_expression(self) -> exp.Expr | None:
368        # DuckDB supports prefix aliases, e.g. foo: 1
369        if self._next.token_type == TokenType.COLON:
370            alias = self._parse_id_var(tokens=self.ALIAS_TOKENS)
371            self._match(TokenType.COLON)
372            comments = self._prev_comments
373
374            this = self._parse_assignment()
375            if isinstance(this, exp.Expr):
376                # Moves the comment next to the alias in `alias: expr /* comment */`
377                comments += this.pop_comments() or []
378
379            return self.expression(exp.Alias(this=this, alias=alias), comments=comments)
380
381        return super()._parse_expression()
382
383    def _parse_table(
384        self,
385        schema: bool = False,
386        joins: bool = False,
387        alias_tokens: Collection[TokenType] | None = None,
388        parse_bracket: bool = False,
389        is_db_reference: bool = False,
390        parse_partition: bool = False,
391        consume_pipe: bool = False,
392    ) -> exp.Expr | None:
393        # DuckDB supports prefix aliases, e.g. FROM foo: bar
394        if self._next.token_type == TokenType.COLON:
395            alias = self._parse_table_alias(alias_tokens=alias_tokens or self.TABLE_ALIAS_TOKENS)
396            self._match(TokenType.COLON)
397            comments = self._prev_comments
398        else:
399            alias = None
400            comments = []
401
402        table = super()._parse_table(
403            schema=schema,
404            joins=joins,
405            alias_tokens=alias_tokens,
406            parse_bracket=parse_bracket,
407            is_db_reference=is_db_reference,
408            parse_partition=parse_partition,
409        )
410        if isinstance(table, exp.Expr) and isinstance(alias, exp.TableAlias):
411            # Moves the comment next to the alias in `alias: table /* comment */`
412            comments += table.pop_comments() or []
413            alias.comments = alias.pop_comments() + comments
414            table.set("alias", alias)
415
416        return table
417
418    def _parse_table_alias(
419        self, alias_tokens: Collection[TokenType] | None = None
420    ) -> exp.TableAlias | None:
421        if (
422            self._match_text_seq("NEAREST", advance=False)
423            and self._next.token_type == TokenType.NUMBER
424        ) or self._match_text_seq("APPROX", "NEAREST", advance=False):
425            return None
426
427        return super()._parse_table_alias(alias_tokens=alias_tokens)
428
429    def _parse_join(
430        self,
431        skip_join_token: bool = False,
432        parse_bracket: bool = False,
433        alias_tokens: Collection[TokenType] | None = None,
434    ) -> exp.Join | None:
435        join_type = None
436        if self._match_text_seq("JOIN", "BY", "(", "TYPE"):
437            join_type = self._parse_var(any_token=True)
438            self._match_r_paren()
439            skip_join_token = True
440
441        join = super()._parse_join(
442            skip_join_token=skip_join_token,
443            parse_bracket=parse_bracket,
444            alias_tokens=alias_tokens,
445        )
446        if not join:
447            return join
448
449        if join_type:
450            parts = join_type.name.upper().removesuffix("_JOIN").split("_")
451            if parts[0] in ("LEFT", "RIGHT", "FULL"):
452                join.set("side", parts.pop(0))
453            join.set("kind", " ".join(parts) or None)
454
455        approximate = self._match_text_seq("APPROX", "NEAREST")
456        if approximate or self._match_text_seq("NEAREST"):
457            count = self._parse_number()
458
459            if not self._match_text_seq("BY"):
460                self.raise_error("Expected BY after NEAREST count")
461            if not self._match_texts(("DISTANCE", "SIMILARITY")):
462                self.raise_error("Expected DISTANCE or SIMILARITY after BY")
463
464            similarity = self._prev.text.upper() == "SIMILARITY"
465            join.set(
466                "nearest",
467                self.expression(
468                    exp.Nearest(
469                        this=self._parse_disjunction(),
470                        count=count,
471                        approximate=approximate,
472                        similarity=similarity,
473                    )
474                ),
475            )
476
477        return join
478
479    def _parse_table_sample(self, as_modifier: bool = False) -> exp.TableSample | None:
480        # https://duckdb.org/docs/sql/samples.html
481        sample = super()._parse_table_sample(as_modifier=as_modifier)
482        if sample and not sample.args.get("method"):
483            if sample.args.get("size"):
484                sample.set("method", exp.var("RESERVOIR"))
485            else:
486                sample.set("method", exp.var("SYSTEM"))
487
488        return sample
489
490    def _parse_bracket(self, this: exp.Expr | None = None) -> exp.Expr | None:
491        bracket = super()._parse_bracket(this)
492
493        if self.dialect.version < (1, 2) and isinstance(bracket, exp.Bracket):
494            # https://duckdb.org/2025/02/05/announcing-duckdb-120.html#breaking-changes
495            bracket.set("returns_list_for_maps", True)
496
497        return bracket
498
499    def _parse_map(self) -> exp.ToMap | exp.Map:
500        if self._match(TokenType.L_BRACE, advance=False):
501            return self.expression(exp.ToMap(this=self._parse_bracket()))
502
503        args = self._parse_wrapped_csv(self._parse_assignment)
504        return self.expression(exp.Map(keys=seq_get(args, 0), values=seq_get(args, 1)))
505
506    def _parse_struct_types(self, type_required: bool = False) -> exp.Expr | None:
507        return self._parse_field_def()
508
509    def _pivot_column_names(self, aggregations: list[exp.Expr]) -> list[str]:
510        if len(aggregations) == 1:
511            return super()._pivot_column_names(aggregations)
512        return pivot_column_names(aggregations, dialect="duckdb")
513
514    def _parse_attach_detach(self, is_attach: bool = True) -> exp.Attach | exp.Detach:
515        def _parse_attach_option() -> exp.AttachOption:
516            return self.expression(
517                exp.AttachOption(
518                    this=self._parse_var(any_token=True),
519                    expression=self._parse_field(any_token=True),
520                )
521            )
522
523        self._match(TokenType.DATABASE)
524        exists = self._parse_exists(not_=is_attach)
525        this = self._parse_alias(self._parse_primary_or_var(), explicit=True)
526
527        if self._match(TokenType.L_PAREN, advance=False):
528            expressions = self._parse_wrapped_csv(_parse_attach_option)
529        else:
530            expressions = None
531
532        return (
533            self.expression(exp.Attach(this=this, exists=exists, expressions=expressions))
534            if is_attach
535            else self.expression(exp.Detach(this=this, exists=exists))
536        )
537
538    def _parse_show_duckdb(self, this: str) -> exp.Show:
539        from_ = self._parse_table(schema=True) if self._match(TokenType.FROM) else None
540        return self.expression(exp.Show(this=this, from_=from_))
541
542    def _parse_force(self) -> exp.Install | exp.Command:
543        # FORCE can only be followed by INSTALL or CHECKPOINT
544        # In the case of CHECKPOINT, we fallback
545        if not self._match(TokenType.INSTALL):
546            return self._parse_as_command(self._prev)
547
548        return self._parse_install(force=True)
549
550    def _parse_install(self, force: bool = False) -> exp.Install:
551        return self.expression(
552            exp.Install(
553                this=self._parse_id_var(),
554                from_=self._parse_var_or_string() if self._match(TokenType.FROM) else None,
555                force=force,
556            )
557        )
558
559    def _parse_primary(self) -> exp.Expr | None:
560        if self._match_pair(TokenType.HASH, TokenType.NUMBER):
561            return exp.PositionalColumn(this=exp.Literal.number(self._prev.text))
562
563        return super()._parse_primary()