Edit on GitHub

sqlglot.parsers.duckdb

View Source

  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 binary_range_parser
 17from sqlglot.tokens import TokenType
 18from collections.abc import Collection
 19
 20
 21def _build_sort_array_desc(args: list) -> exp.Expr:
 22    return exp.SortArray(this=seq_get(args, 0), asc=exp.false())
 23
 24
 25def _build_array_prepend(args: list) -> exp.Expr:
 26    return exp.ArrayPrepend(this=seq_get(args, 1), expression=seq_get(args, 0))
 27
 28
 29def _build_date_diff(args: list) -> exp.Expr:
 30    return exp.DateDiff(this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0))
 31
 32
 33def _build_generate_series(end_exclusive: bool = False) -> t.Callable[[list], exp.GenerateSeries]:
 34    def _builder(args: list) -> exp.GenerateSeries:
 35        # Check https://duckdb.org/docs/sql/functions/nested.html#range-functions
 36        if len(args) == 1:
 37            # DuckDB uses 0 as a default for the series' start when it's omitted
 38            args.insert(0, exp.Literal.number("0"))
 39
 40        gen_series = exp.GenerateSeries.from_arg_list(args)
 41        gen_series.set("is_end_exclusive", end_exclusive)
 42
 43        return gen_series
 44
 45    return _builder
 46
 47
 48def _build_make_timestamp(args: list) -> exp.Expr:
 49    if len(args) == 1:
 50        return exp.UnixToTime(this=seq_get(args, 0), scale=exp.UnixToTime.MICROS)
 51
 52    return exp.TimestampFromParts(
 53        year=seq_get(args, 0),
 54        month=seq_get(args, 1),
 55        day=seq_get(args, 2),
 56        hour=seq_get(args, 3),
 57        min=seq_get(args, 4),
 58        sec=seq_get(args, 5),
 59    )
 60
 61
 62def _show_parser(*args: t.Any, **kwargs: t.Any) -> t.Callable[[DuckDBParser], exp.Show]:
 63    def _parse(self: DuckDBParser) -> exp.Show:
 64        return self._parse_show_duckdb(*args, **kwargs)
 65
 66    return _parse
 67
 68
 69class DuckDBParser(parser.Parser):
 70    MAP_KEYS_ARE_ARBITRARY_EXPRESSIONS = True
 71
 72    NO_PAREN_FUNCTIONS = {
 73        **parser.Parser.NO_PAREN_FUNCTIONS,
 74        TokenType.LOCALTIME: exp.Localtime,
 75        TokenType.LOCALTIMESTAMP: exp.Localtimestamp,
 76        TokenType.CURRENT_CATALOG: exp.CurrentCatalog,
 77        TokenType.SESSION_USER: exp.SessionUser,
 78    }
 79
 80    BITWISE = {k: v for k, v in parser.Parser.BITWISE.items() if k != TokenType.CARET}
 81
 82    RANGE_PARSERS = {
 83        **parser.Parser.RANGE_PARSERS,
 84        TokenType.DAMP: binary_range_parser(exp.ArrayOverlaps),
 85        TokenType.CARET_AT: binary_range_parser(exp.StartsWith),
 86        TokenType.TILDE: binary_range_parser(exp.RegexpFullMatch),
 87    }
 88
 89    EXPONENT = {
 90        **parser.Parser.EXPONENT,
 91        TokenType.CARET: exp.Pow,
 92        TokenType.DSTAR: exp.Pow,
 93    }
 94
 95    FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "STRUCT_PACK"}
 96
 97    SHOW_PARSERS = {
 98        "TABLES": _show_parser("TABLES"),
 99        "ALL TABLES": _show_parser("ALL TABLES"),
100    }
101
102    FUNCTIONS = {
103        **{k: v for k, v in parser.Parser.FUNCTIONS.items() if k not in ("DATE_SUB", "GLOB")},
104        "ANY_VALUE": lambda args: exp.IgnoreNulls(this=exp.AnyValue.from_arg_list(args)),
105        "ARRAY_PREPEND": _build_array_prepend,
106        "ARRAY_REVERSE_SORT": _build_sort_array_desc,
107        "ARRAY_INTERSECT": lambda args: exp.ArrayIntersect(expressions=args),
108        "ARRAY_SORT": exp.SortArray.from_arg_list,
109        "BIT_AND": exp.BitwiseAndAgg.from_arg_list,
110        "BIT_OR": exp.BitwiseOrAgg.from_arg_list,
111        "BIT_XOR": exp.BitwiseXorAgg.from_arg_list,
112        "CURRENT_LOCALTIMESTAMP": exp.Localtimestamp.from_arg_list,
113        "DATEDIFF": _build_date_diff,
114        "DATE_DIFF": _build_date_diff,
115        "DATE_TRUNC": date_trunc_to_time,
116        "DATETRUNC": date_trunc_to_time,
117        "DECODE": lambda args: exp.Decode(
118            this=seq_get(args, 0), charset=exp.Literal.string("utf-8")
119        ),
120        "EDITDIST3": exp.Levenshtein.from_arg_list,
121        "ENCODE": lambda args: exp.Encode(
122            this=seq_get(args, 0), charset=exp.Literal.string("utf-8")
123        ),
124        "EPOCH": exp.TimeToUnix.from_arg_list,
125        "EPOCH_MS": lambda args: exp.UnixToTime(this=seq_get(args, 0), scale=exp.UnixToTime.MILLIS),
126        "GENERATE_SERIES": _build_generate_series(),
127        "GET_CURRENT_TIME": exp.CurrentTime.from_arg_list,
128        "GET_BIT": lambda args: exp.Getbit(
129            this=seq_get(args, 0), expression=seq_get(args, 1), zero_is_msb=True
130        ),
131        "JARO_WINKLER_SIMILARITY": exp.JarowinklerSimilarity.from_arg_list,
132        "JSON": exp.ParseJSON.from_arg_list,
133        "JSON_ARRAY": lambda args: exp.JSONArray(expressions=args),
134        "JSON_EXTRACT_PATH": parser.build_extract_json_with_path(exp.JSONExtract),
135        "JSON_EXTRACT_STRING": parser.build_extract_json_with_path(exp.JSONExtractScalar),
136        "LIST_APPEND": exp.ArrayAppend.from_arg_list,
137        "LIST_CONCAT": parser.build_array_concat,
138        "LIST_CONTAINS": exp.ArrayContains.from_arg_list,
139        "LIST_COSINE_DISTANCE": exp.CosineDistance.from_arg_list,
140        "LIST_DISTANCE": exp.EuclideanDistance.from_arg_list,
141        "LIST_FILTER": exp.ArrayFilter.from_arg_list,
142        "LIST_HAS": exp.ArrayContains.from_arg_list,
143        "LIST_HAS_ANY": exp.ArrayOverlaps.from_arg_list,
144        "LIST_MAX": exp.ArrayMax.from_arg_list,
145        "LIST_MIN": exp.ArrayMin.from_arg_list,
146        "LIST_PREPEND": _build_array_prepend,
147        "LIST_REVERSE_SORT": _build_sort_array_desc,
148        "LIST_SORT": exp.SortArray.from_arg_list,
149        "LIST_TRANSFORM": exp.Transform.from_arg_list,
150        "LIST_VALUE": lambda args: exp.Array(expressions=args),
151        "MAKE_DATE": exp.DateFromParts.from_arg_list,
152        "MAKE_TIME": exp.TimeFromParts.from_arg_list,
153        "MAKE_TIMESTAMP": _build_make_timestamp,
154        "QUANTILE_CONT": exp.PercentileCont.from_arg_list,
155        "QUANTILE_DISC": exp.PercentileDisc.from_arg_list,
156        "RANGE": _build_generate_series(end_exclusive=True),
157        "REGEXP_EXTRACT": build_regexp_extract(exp.RegexpExtract),
158        "REGEXP_EXTRACT_ALL": build_regexp_extract(exp.RegexpExtractAll),
159        "REGEXP_MATCHES": exp.RegexpLike.from_arg_list,
160        "REGEXP_REPLACE": lambda args: exp.RegexpReplace(
161            this=seq_get(args, 0),
162            expression=seq_get(args, 1),
163            replacement=seq_get(args, 2),
164            modifiers=seq_get(args, 3),
165            single_replace=True,
166        ),
167        "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
168        "STRFTIME": build_formatted_time(exp.TimeToStr, "duckdb"),
169        "STRING_SPLIT": exp.Split.from_arg_list,
170        "STRING_SPLIT_REGEX": exp.RegexpSplit.from_arg_list,
171        "STRING_TO_ARRAY": exp.Split.from_arg_list,
172        "STRPTIME": build_formatted_time(exp.StrToTime, "duckdb"),
173        "STRUCT_PACK": exp.Struct.from_arg_list,
174        "STR_SPLIT": exp.Split.from_arg_list,
175        "STR_SPLIT_REGEX": exp.RegexpSplit.from_arg_list,
176        "TODAY": exp.CurrentDate.from_arg_list,
177        "TIME_BUCKET": exp.DateBin.from_arg_list,
178        "TO_TIMESTAMP": exp.UnixToTime.from_arg_list,
179        "UNNEST": exp.Explode.from_arg_list,
180        "VERSION": exp.CurrentVersion.from_arg_list,
181        "XOR": binary_from_function(exp.BitwiseXor),
182    }
183
184    FUNCTION_PARSERS = {
185        **{k: v for k, v in parser.Parser.FUNCTION_PARSERS.items() if k != "DECODE"},
186        **dict.fromkeys(
187            ("GROUP_CONCAT", "LISTAGG", "STRINGAGG"), lambda self: self._parse_string_agg()
188        ),
189    }
190
191    NO_PAREN_FUNCTION_PARSERS = {
192        **parser.Parser.NO_PAREN_FUNCTION_PARSERS,
193        "MAP": lambda self: self._parse_map(),
194        "@": lambda self: exp.Abs(this=self._parse_bitwise()),
195    }
196
197    PLACEHOLDER_PARSERS = {
198        **parser.Parser.PLACEHOLDER_PARSERS,
199        TokenType.PARAMETER: lambda self: (
200            self.expression(exp.Placeholder(this=self._prev.text))
201            if self._match(TokenType.NUMBER) or self._match_set(self.ID_VAR_TOKENS)
202            else None
203        ),
204    }
205
206    TYPE_CONVERTERS = {
207        # https://duckdb.org/docs/sql/data_types/numeric
208        exp.DType.DECIMAL: build_default_decimal_type(precision=18, scale=3),
209        # https://duckdb.org/docs/sql/data_types/text
210        exp.DType.TEXT: lambda dtype: exp.DType.TEXT.into_expr(),
211    }
212
213    STATEMENT_PARSERS = {
214        **parser.Parser.STATEMENT_PARSERS,
215        TokenType.ATTACH: lambda self: self._parse_attach_detach(),
216        TokenType.DETACH: lambda self: self._parse_attach_detach(is_attach=False),
217        TokenType.FORCE: lambda self: self._parse_force(),
218        TokenType.INSTALL: lambda self: self._parse_install(),
219        TokenType.SHOW: lambda self: self._parse_show(),
220    }
221
222    SET_PARSERS = {
223        **parser.Parser.SET_PARSERS,
224        "VARIABLE": lambda self: self._parse_set_item_assignment("VARIABLE"),
225    }
226
227    SHOW_TRIE = new_trie(key.split(" ") for key in SHOW_PARSERS)
228    SET_TRIE = new_trie(key.split(" ") for key in SET_PARSERS)
229
230    def _parse_function_properties(self) -> exp.Properties | None:
231        if self._match(TokenType.TABLE):
232            return exp.Properties(
233                expressions=[
234                    exp.ReturnsProperty(
235                        this=exp.Schema(this=exp.var("TABLE")),
236                        is_table=True,
237                    ),
238                ]
239            )
240        return super()._parse_function_properties()
241
242    def _parse_lambda(self, alias: bool = False) -> exp.Expr | None:
243        index = self._index
244        if not self._match_text_seq("LAMBDA"):
245            return super()._parse_lambda(alias=alias)
246
247        expressions = self._parse_csv(self._parse_lambda_arg)
248        if not self._match(TokenType.COLON):
249            self._retreat(index)
250            return None
251
252        this = self._replace_lambda(self._parse_assignment(), expressions)
253        return self.expression(exp.Lambda(this=this, expressions=expressions, colon=True))
254
255    def _parse_expression(self) -> exp.Expr | None:
256        # DuckDB supports prefix aliases, e.g. foo: 1
257        if self._next.token_type == TokenType.COLON:
258            alias = self._parse_id_var(tokens=self.ALIAS_TOKENS)
259            self._match(TokenType.COLON)
260            comments = self._prev_comments
261
262            this = self._parse_assignment()
263            if isinstance(this, exp.Expr):
264                # Moves the comment next to the alias in `alias: expr /* comment */`
265                comments += this.pop_comments() or []
266
267            return self.expression(exp.Alias(this=this, alias=alias), comments=comments)
268
269        return super()._parse_expression()
270
271    def _parse_table(
272        self,
273        schema: bool = False,
274        joins: bool = False,
275        alias_tokens: Collection[TokenType] | None = None,
276        parse_bracket: bool = False,
277        is_db_reference: bool = False,
278        parse_partition: bool = False,
279        consume_pipe: bool = False,
280    ) -> exp.Expr | None:
281        # DuckDB supports prefix aliases, e.g. FROM foo: bar
282        if self._next.token_type == TokenType.COLON:
283            alias = self._parse_table_alias(alias_tokens=alias_tokens or self.TABLE_ALIAS_TOKENS)
284            self._match(TokenType.COLON)
285            comments = self._prev_comments
286        else:
287            alias = None
288            comments = []
289
290        table = super()._parse_table(
291            schema=schema,
292            joins=joins,
293            alias_tokens=alias_tokens,
294            parse_bracket=parse_bracket,
295            is_db_reference=is_db_reference,
296            parse_partition=parse_partition,
297        )
298        if isinstance(table, exp.Expr) and isinstance(alias, exp.TableAlias):
299            # Moves the comment next to the alias in `alias: table /* comment */`
300            comments += table.pop_comments() or []
301            alias.comments = alias.pop_comments() + comments
302            table.set("alias", alias)
303
304        return table
305
306    def _parse_table_sample(self, as_modifier: bool = False) -> exp.TableSample | None:
307        # https://duckdb.org/docs/sql/samples.html
308        sample = super()._parse_table_sample(as_modifier=as_modifier)
309        if sample and not sample.args.get("method"):
310            if sample.args.get("size"):
311                sample.set("method", exp.var("RESERVOIR"))
312            else:
313                sample.set("method", exp.var("SYSTEM"))
314
315        return sample
316
317    def _parse_bracket(self, this: exp.Expr | None = None) -> exp.Expr | None:
318        bracket = super()._parse_bracket(this)
319
320        if self.dialect.version < (1, 2) and isinstance(bracket, exp.Bracket):
321            # https://duckdb.org/2025/02/05/announcing-duckdb-120.html#breaking-changes
322            bracket.set("returns_list_for_maps", True)
323
324        return bracket
325
326    def _parse_map(self) -> exp.ToMap | exp.Map:
327        if self._match(TokenType.L_BRACE, advance=False):
328            return self.expression(exp.ToMap(this=self._parse_bracket()))
329
330        args = self._parse_wrapped_csv(self._parse_assignment)
331        return self.expression(exp.Map(keys=seq_get(args, 0), values=seq_get(args, 1)))
332
333    def _parse_struct_types(self, type_required: bool = False) -> exp.Expr | None:
334        return self._parse_field_def()
335
336    def _pivot_column_names(self, aggregations: list[exp.Expr]) -> list[str]:
337        if len(aggregations) == 1:
338            return super()._pivot_column_names(aggregations)
339        return pivot_column_names(aggregations, dialect="duckdb")
340
341    def _parse_attach_detach(self, is_attach: bool = True) -> exp.Attach | exp.Detach:
342        def _parse_attach_option() -> exp.AttachOption:
343            return self.expression(
344                exp.AttachOption(
345                    this=self._parse_var(any_token=True),
346                    expression=self._parse_field(any_token=True),
347                )
348            )
349
350        self._match(TokenType.DATABASE)
351        exists = self._parse_exists(not_=is_attach)
352        this = self._parse_alias(self._parse_primary_or_var(), explicit=True)
353
354        if self._match(TokenType.L_PAREN, advance=False):
355            expressions = self._parse_wrapped_csv(_parse_attach_option)
356        else:
357            expressions = None
358
359        return (
360            self.expression(exp.Attach(this=this, exists=exists, expressions=expressions))
361            if is_attach
362            else self.expression(exp.Detach(this=this, exists=exists))
363        )
364
365    def _parse_show_duckdb(self, this: str) -> exp.Show:
366        from_ = self._parse_table(schema=True) if self._match(TokenType.FROM) else None
367        return self.expression(exp.Show(this=this, from_=from_))
368
369    def _parse_force(self) -> exp.Install | exp.Command:
370        # FORCE can only be followed by INSTALL or CHECKPOINT
371        # In the case of CHECKPOINT, we fallback
372        if not self._match(TokenType.INSTALL):
373            return self._parse_as_command(self._prev)
374
375        return self._parse_install(force=True)
376
377    def _parse_install(self, force: bool = False) -> exp.Install:
378        return self.expression(
379            exp.Install(
380                this=self._parse_id_var(),
381                from_=self._parse_var_or_string() if self._match(TokenType.FROM) else None,
382                force=force,
383            )
384        )
385
386    def _parse_primary(self) -> exp.Expr | None:
387        if self._match_pair(TokenType.HASH, TokenType.NUMBER):
388            return exp.PositionalColumn(this=exp.Literal.number(self._prev.text))
389
390        return super()._parse_primary()

class DuckDBParser(sqlglot.parser.Parser): View Source

 70class DuckDBParser(parser.Parser):
 71    MAP_KEYS_ARE_ARBITRARY_EXPRESSIONS = True
 72
 73    NO_PAREN_FUNCTIONS = {
 74        **parser.Parser.NO_PAREN_FUNCTIONS,
 75        TokenType.LOCALTIME: exp.Localtime,
 76        TokenType.LOCALTIMESTAMP: exp.Localtimestamp,
 77        TokenType.CURRENT_CATALOG: exp.CurrentCatalog,
 78        TokenType.SESSION_USER: exp.SessionUser,
 79    }
 80
 81    BITWISE = {k: v for k, v in parser.Parser.BITWISE.items() if k != TokenType.CARET}
 82
 83    RANGE_PARSERS = {
 84        **parser.Parser.RANGE_PARSERS,
 85        TokenType.DAMP: binary_range_parser(exp.ArrayOverlaps),
 86        TokenType.CARET_AT: binary_range_parser(exp.StartsWith),
 87        TokenType.TILDE: binary_range_parser(exp.RegexpFullMatch),
 88    }
 89
 90    EXPONENT = {
 91        **parser.Parser.EXPONENT,
 92        TokenType.CARET: exp.Pow,
 93        TokenType.DSTAR: exp.Pow,
 94    }
 95
 96    FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "STRUCT_PACK"}
 97
 98    SHOW_PARSERS = {
 99        "TABLES": _show_parser("TABLES"),
100        "ALL TABLES": _show_parser("ALL TABLES"),
101    }
102
103    FUNCTIONS = {
104        **{k: v for k, v in parser.Parser.FUNCTIONS.items() if k not in ("DATE_SUB", "GLOB")},
105        "ANY_VALUE": lambda args: exp.IgnoreNulls(this=exp.AnyValue.from_arg_list(args)),
106        "ARRAY_PREPEND": _build_array_prepend,
107        "ARRAY_REVERSE_SORT": _build_sort_array_desc,
108        "ARRAY_INTERSECT": lambda args: exp.ArrayIntersect(expressions=args),
109        "ARRAY_SORT": exp.SortArray.from_arg_list,
110        "BIT_AND": exp.BitwiseAndAgg.from_arg_list,
111        "BIT_OR": exp.BitwiseOrAgg.from_arg_list,
112        "BIT_XOR": exp.BitwiseXorAgg.from_arg_list,
113        "CURRENT_LOCALTIMESTAMP": exp.Localtimestamp.from_arg_list,
114        "DATEDIFF": _build_date_diff,
115        "DATE_DIFF": _build_date_diff,
116        "DATE_TRUNC": date_trunc_to_time,
117        "DATETRUNC": date_trunc_to_time,
118        "DECODE": lambda args: exp.Decode(
119            this=seq_get(args, 0), charset=exp.Literal.string("utf-8")
120        ),
121        "EDITDIST3": exp.Levenshtein.from_arg_list,
122        "ENCODE": lambda args: exp.Encode(
123            this=seq_get(args, 0), charset=exp.Literal.string("utf-8")
124        ),
125        "EPOCH": exp.TimeToUnix.from_arg_list,
126        "EPOCH_MS": lambda args: exp.UnixToTime(this=seq_get(args, 0), scale=exp.UnixToTime.MILLIS),
127        "GENERATE_SERIES": _build_generate_series(),
128        "GET_CURRENT_TIME": exp.CurrentTime.from_arg_list,
129        "GET_BIT": lambda args: exp.Getbit(
130            this=seq_get(args, 0), expression=seq_get(args, 1), zero_is_msb=True
131        ),
132        "JARO_WINKLER_SIMILARITY": exp.JarowinklerSimilarity.from_arg_list,
133        "JSON": exp.ParseJSON.from_arg_list,
134        "JSON_ARRAY": lambda args: exp.JSONArray(expressions=args),
135        "JSON_EXTRACT_PATH": parser.build_extract_json_with_path(exp.JSONExtract),
136        "JSON_EXTRACT_STRING": parser.build_extract_json_with_path(exp.JSONExtractScalar),
137        "LIST_APPEND": exp.ArrayAppend.from_arg_list,
138        "LIST_CONCAT": parser.build_array_concat,
139        "LIST_CONTAINS": exp.ArrayContains.from_arg_list,
140        "LIST_COSINE_DISTANCE": exp.CosineDistance.from_arg_list,
141        "LIST_DISTANCE": exp.EuclideanDistance.from_arg_list,
142        "LIST_FILTER": exp.ArrayFilter.from_arg_list,
143        "LIST_HAS": exp.ArrayContains.from_arg_list,
144        "LIST_HAS_ANY": exp.ArrayOverlaps.from_arg_list,
145        "LIST_MAX": exp.ArrayMax.from_arg_list,
146        "LIST_MIN": exp.ArrayMin.from_arg_list,
147        "LIST_PREPEND": _build_array_prepend,
148        "LIST_REVERSE_SORT": _build_sort_array_desc,
149        "LIST_SORT": exp.SortArray.from_arg_list,
150        "LIST_TRANSFORM": exp.Transform.from_arg_list,
151        "LIST_VALUE": lambda args: exp.Array(expressions=args),
152        "MAKE_DATE": exp.DateFromParts.from_arg_list,
153        "MAKE_TIME": exp.TimeFromParts.from_arg_list,
154        "MAKE_TIMESTAMP": _build_make_timestamp,
155        "QUANTILE_CONT": exp.PercentileCont.from_arg_list,
156        "QUANTILE_DISC": exp.PercentileDisc.from_arg_list,
157        "RANGE": _build_generate_series(end_exclusive=True),
158        "REGEXP_EXTRACT": build_regexp_extract(exp.RegexpExtract),
159        "REGEXP_EXTRACT_ALL": build_regexp_extract(exp.RegexpExtractAll),
160        "REGEXP_MATCHES": exp.RegexpLike.from_arg_list,
161        "REGEXP_REPLACE": lambda args: exp.RegexpReplace(
162            this=seq_get(args, 0),
163            expression=seq_get(args, 1),
164            replacement=seq_get(args, 2),
165            modifiers=seq_get(args, 3),
166            single_replace=True,
167        ),
168        "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
169        "STRFTIME": build_formatted_time(exp.TimeToStr, "duckdb"),
170        "STRING_SPLIT": exp.Split.from_arg_list,
171        "STRING_SPLIT_REGEX": exp.RegexpSplit.from_arg_list,
172        "STRING_TO_ARRAY": exp.Split.from_arg_list,
173        "STRPTIME": build_formatted_time(exp.StrToTime, "duckdb"),
174        "STRUCT_PACK": exp.Struct.from_arg_list,
175        "STR_SPLIT": exp.Split.from_arg_list,
176        "STR_SPLIT_REGEX": exp.RegexpSplit.from_arg_list,
177        "TODAY": exp.CurrentDate.from_arg_list,
178        "TIME_BUCKET": exp.DateBin.from_arg_list,
179        "TO_TIMESTAMP": exp.UnixToTime.from_arg_list,
180        "UNNEST": exp.Explode.from_arg_list,
181        "VERSION": exp.CurrentVersion.from_arg_list,
182        "XOR": binary_from_function(exp.BitwiseXor),
183    }
184
185    FUNCTION_PARSERS = {
186        **{k: v for k, v in parser.Parser.FUNCTION_PARSERS.items() if k != "DECODE"},
187        **dict.fromkeys(
188            ("GROUP_CONCAT", "LISTAGG", "STRINGAGG"), lambda self: self._parse_string_agg()
189        ),
190    }
191
192    NO_PAREN_FUNCTION_PARSERS = {
193        **parser.Parser.NO_PAREN_FUNCTION_PARSERS,
194        "MAP": lambda self: self._parse_map(),
195        "@": lambda self: exp.Abs(this=self._parse_bitwise()),
196    }
197
198    PLACEHOLDER_PARSERS = {
199        **parser.Parser.PLACEHOLDER_PARSERS,
200        TokenType.PARAMETER: lambda self: (
201            self.expression(exp.Placeholder(this=self._prev.text))
202            if self._match(TokenType.NUMBER) or self._match_set(self.ID_VAR_TOKENS)
203            else None
204        ),
205    }
206
207    TYPE_CONVERTERS = {
208        # https://duckdb.org/docs/sql/data_types/numeric
209        exp.DType.DECIMAL: build_default_decimal_type(precision=18, scale=3),
210        # https://duckdb.org/docs/sql/data_types/text
211        exp.DType.TEXT: lambda dtype: exp.DType.TEXT.into_expr(),
212    }
213
214    STATEMENT_PARSERS = {
215        **parser.Parser.STATEMENT_PARSERS,
216        TokenType.ATTACH: lambda self: self._parse_attach_detach(),
217        TokenType.DETACH: lambda self: self._parse_attach_detach(is_attach=False),
218        TokenType.FORCE: lambda self: self._parse_force(),
219        TokenType.INSTALL: lambda self: self._parse_install(),
220        TokenType.SHOW: lambda self: self._parse_show(),
221    }
222
223    SET_PARSERS = {
224        **parser.Parser.SET_PARSERS,
225        "VARIABLE": lambda self: self._parse_set_item_assignment("VARIABLE"),
226    }
227
228    SHOW_TRIE = new_trie(key.split(" ") for key in SHOW_PARSERS)
229    SET_TRIE = new_trie(key.split(" ") for key in SET_PARSERS)
230
231    def _parse_function_properties(self) -> exp.Properties | None:
232        if self._match(TokenType.TABLE):
233            return exp.Properties(
234                expressions=[
235                    exp.ReturnsProperty(
236                        this=exp.Schema(this=exp.var("TABLE")),
237                        is_table=True,
238                    ),
239                ]
240            )
241        return super()._parse_function_properties()
242
243    def _parse_lambda(self, alias: bool = False) -> exp.Expr | None:
244        index = self._index
245        if not self._match_text_seq("LAMBDA"):
246            return super()._parse_lambda(alias=alias)
247
248        expressions = self._parse_csv(self._parse_lambda_arg)
249        if not self._match(TokenType.COLON):
250            self._retreat(index)
251            return None
252
253        this = self._replace_lambda(self._parse_assignment(), expressions)
254        return self.expression(exp.Lambda(this=this, expressions=expressions, colon=True))
255
256    def _parse_expression(self) -> exp.Expr | None:
257        # DuckDB supports prefix aliases, e.g. foo: 1
258        if self._next.token_type == TokenType.COLON:
259            alias = self._parse_id_var(tokens=self.ALIAS_TOKENS)
260            self._match(TokenType.COLON)
261            comments = self._prev_comments
262
263            this = self._parse_assignment()
264            if isinstance(this, exp.Expr):
265                # Moves the comment next to the alias in `alias: expr /* comment */`
266                comments += this.pop_comments() or []
267
268            return self.expression(exp.Alias(this=this, alias=alias), comments=comments)
269
270        return super()._parse_expression()
271
272    def _parse_table(
273        self,
274        schema: bool = False,
275        joins: bool = False,
276        alias_tokens: Collection[TokenType] | None = None,
277        parse_bracket: bool = False,
278        is_db_reference: bool = False,
279        parse_partition: bool = False,
280        consume_pipe: bool = False,
281    ) -> exp.Expr | None:
282        # DuckDB supports prefix aliases, e.g. FROM foo: bar
283        if self._next.token_type == TokenType.COLON:
284            alias = self._parse_table_alias(alias_tokens=alias_tokens or self.TABLE_ALIAS_TOKENS)
285            self._match(TokenType.COLON)
286            comments = self._prev_comments
287        else:
288            alias = None
289            comments = []
290
291        table = super()._parse_table(
292            schema=schema,
293            joins=joins,
294            alias_tokens=alias_tokens,
295            parse_bracket=parse_bracket,
296            is_db_reference=is_db_reference,
297            parse_partition=parse_partition,
298        )
299        if isinstance(table, exp.Expr) and isinstance(alias, exp.TableAlias):
300            # Moves the comment next to the alias in `alias: table /* comment */`
301            comments += table.pop_comments() or []
302            alias.comments = alias.pop_comments() + comments
303            table.set("alias", alias)
304
305        return table
306
307    def _parse_table_sample(self, as_modifier: bool = False) -> exp.TableSample | None:
308        # https://duckdb.org/docs/sql/samples.html
309        sample = super()._parse_table_sample(as_modifier=as_modifier)
310        if sample and not sample.args.get("method"):
311            if sample.args.get("size"):
312                sample.set("method", exp.var("RESERVOIR"))
313            else:
314                sample.set("method", exp.var("SYSTEM"))
315
316        return sample
317
318    def _parse_bracket(self, this: exp.Expr | None = None) -> exp.Expr | None:
319        bracket = super()._parse_bracket(this)
320
321        if self.dialect.version < (1, 2) and isinstance(bracket, exp.Bracket):
322            # https://duckdb.org/2025/02/05/announcing-duckdb-120.html#breaking-changes
323            bracket.set("returns_list_for_maps", True)
324
325        return bracket
326
327    def _parse_map(self) -> exp.ToMap | exp.Map:
328        if self._match(TokenType.L_BRACE, advance=False):
329            return self.expression(exp.ToMap(this=self._parse_bracket()))
330
331        args = self._parse_wrapped_csv(self._parse_assignment)
332        return self.expression(exp.Map(keys=seq_get(args, 0), values=seq_get(args, 1)))
333
334    def _parse_struct_types(self, type_required: bool = False) -> exp.Expr | None:
335        return self._parse_field_def()
336
337    def _pivot_column_names(self, aggregations: list[exp.Expr]) -> list[str]:
338        if len(aggregations) == 1:
339            return super()._pivot_column_names(aggregations)
340        return pivot_column_names(aggregations, dialect="duckdb")
341
342    def _parse_attach_detach(self, is_attach: bool = True) -> exp.Attach | exp.Detach:
343        def _parse_attach_option() -> exp.AttachOption:
344            return self.expression(
345                exp.AttachOption(
346                    this=self._parse_var(any_token=True),
347                    expression=self._parse_field(any_token=True),
348                )
349            )
350
351        self._match(TokenType.DATABASE)
352        exists = self._parse_exists(not_=is_attach)
353        this = self._parse_alias(self._parse_primary_or_var(), explicit=True)
354
355        if self._match(TokenType.L_PAREN, advance=False):
356            expressions = self._parse_wrapped_csv(_parse_attach_option)
357        else:
358            expressions = None
359
360        return (
361            self.expression(exp.Attach(this=this, exists=exists, expressions=expressions))
362            if is_attach
363            else self.expression(exp.Detach(this=this, exists=exists))
364        )
365
366    def _parse_show_duckdb(self, this: str) -> exp.Show:
367        from_ = self._parse_table(schema=True) if self._match(TokenType.FROM) else None
368        return self.expression(exp.Show(this=this, from_=from_))
369
370    def _parse_force(self) -> exp.Install | exp.Command:
371        # FORCE can only be followed by INSTALL or CHECKPOINT
372        # In the case of CHECKPOINT, we fallback
373        if not self._match(TokenType.INSTALL):
374            return self._parse_as_command(self._prev)
375
376        return self._parse_install(force=True)
377
378    def _parse_install(self, force: bool = False) -> exp.Install:
379        return self.expression(
380            exp.Install(
381                this=self._parse_id_var(),
382                from_=self._parse_var_or_string() if self._match(TokenType.FROM) else None,
383                force=force,
384            )
385        )
386
387    def _parse_primary(self) -> exp.Expr | None:
388        if self._match_pair(TokenType.HASH, TokenType.NUMBER):
389            return exp.PositionalColumn(this=exp.Literal.number(self._prev.text))
390
391        return super()._parse_primary()

Parser consumes a list of tokens produced by the Tokenizer and produces a parsed syntax tree.

Arguments:

error_level: The desired error level. Default: ErrorLevel.IMMEDIATE
error_message_context: The amount of context to capture from a query string when displaying the error message (in number of characters). Default: 100
max_errors: Maximum number of error messages to include in a raised ParseError. This is only relevant if error_level is ErrorLevel.RAISE. Default: 3
max_nodes: Maximum number of AST nodes to prevent memory exhaustion. Set to -1 (default) to disable the check.

MAP_KEYS_ARE_ARBITRARY_EXPRESSIONS = True

NO_PAREN_FUNCTIONS = {<TokenType.CURRENT_DATE: 244>: <class 'sqlglot.expressions.temporal.CurrentDate'>, <TokenType.CURRENT_DATETIME: 245>: <class 'sqlglot.expressions.temporal.CurrentDate'>, <TokenType.CURRENT_TIME: 247>: <class 'sqlglot.expressions.temporal.CurrentTime'>, <TokenType.CURRENT_TIMESTAMP: 248>: <class 'sqlglot.expressions.temporal.CurrentTimestamp'>, <TokenType.CURRENT_USER: 249>: <class 'sqlglot.expressions.functions.CurrentUser'>, <TokenType.CURRENT_ROLE: 250>: <class 'sqlglot.expressions.functions.CurrentRole'>, <TokenType.LOCALTIME: 177>: <class 'sqlglot.expressions.temporal.Localtime'>, <TokenType.LOCALTIMESTAMP: 178>: <class 'sqlglot.expressions.temporal.Localtimestamp'>, <TokenType.CURRENT_CATALOG: 251>: <class 'sqlglot.expressions.functions.CurrentCatalog'>, <TokenType.SESSION_USER: 59>: <class 'sqlglot.expressions.functions.SessionUser'>}

BITWISE = {<TokenType.AMP: 36>: <class 'sqlglot.expressions.core.BitwiseAnd'>, <TokenType.PIPE: 39>: <class 'sqlglot.expressions.core.BitwiseOr'>}

RANGE_PARSERS = {<TokenType.AT_GT: 54>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.BETWEEN: 228>: <function Parser.<lambda>>, <TokenType.GLOB: 284>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.ILIKE: 292>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IN: 293>: <function Parser.<lambda>>, <TokenType.IRLIKE: 304>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IS: 305>: <function Parser.<lambda>>, <TokenType.LIKE: 315>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.LT_AT: 53>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.OVERLAPS: 346>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.RLIKE: 376>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.SIMILAR_TO: 391>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.FOR: 276>: <function Parser.<lambda>>, <TokenType.QMARK_AMP: 66>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.QMARK_PIPE: 67>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.HASH_DASH: 68>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.ADJACENT: 63>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.OPERATOR: 337>: <function Parser.<lambda>>, <TokenType.AMP_LT: 61>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.AMP_GT: 62>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.DAMP: 60>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.CARET_AT: 43>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.TILDE: 44>: <function binary_range_parser.<locals>._parse_binary_range>}

EXPONENT = {<TokenType.CARET: 42>: <class 'sqlglot.expressions.core.Pow'>, <TokenType.DSTAR: 65>: <class 'sqlglot.expressions.core.Pow'>}

FUNCTIONS_WITH_ALIASED_ARGS = {'STRUCT', 'STRUCT_PACK'}

SHOW_PARSERS = {'TABLES': <function _show_parser.<locals>._parse>, 'ALL TABLES': <function _show_parser.<locals>._parse>}

FUNCTIONS = {'AI_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.AIAgg'>>, 'AI_CLASSIFY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIClassify'>>, 'AI_EMBED': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIEmbed'>>, 'A_I_FORECAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIForecast'>>, 'AI_GENERATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIGenerate'>>, 'AI_SIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AISimilarity'>>, 'AI_SUMMARIZE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.AISummarizeAgg'>>, 'ABS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Abs'>>, 'ACOS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Acos'>>, 'ACOSH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Acosh'>>, 'ADD_MONTHS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.AddMonths'>>, 'AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.And'>>, 'ANONYMOUS_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.AnonymousAggFunc'>>, 'ANY_VALUE': <function DuckDBParser.<lambda>>, 'APPLY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Apply'>>, 'APPROX_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.ApproxDistinct'>>, 'APPROX_COUNT_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.ApproxDistinct'>>, 'APPROX_PERCENTILE_ACCUMULATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxPercentileAccumulate'>>, 'APPROX_PERCENTILE_COMBINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxPercentileCombine'>>, 'APPROX_PERCENTILE_ESTIMATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxPercentileEstimate'>>, 'APPROX_QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxQuantile'>>, 'APPROX_QUANTILES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxQuantiles'>>, 'APPROX_TOP_K': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopK'>>, 'APPROX_TOP_K_ACCUMULATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopKAccumulate'>>, 'APPROX_TOP_K_COMBINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopKCombine'>>, 'APPROX_TOP_K_ESTIMATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopKEstimate'>>, 'APPROX_TOP_SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopSum'>>, 'APPROXIMATE_SIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproximateSimilarity'>>, 'APPROXIMATE_JACCARD_INDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproximateSimilarity'>>, 'ARG_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMax'>>, 'ARGMAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMax'>>, 'MAX_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMax'>>, 'ARG_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMin'>>, 'ARGMIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMin'>>, 'MIN_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMin'>>, 'ARRAY': <function Parser.<lambda>>, 'ARRAY_AGG': <function Parser.<lambda>>, 'ARRAY_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayAll'>>, 'ARRAY_ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayAny'>>, 'ARRAY_APPEND': <function build_array_append>, 'ARRAY_COMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayCompact'>>, 'ARRAY_CONCAT': <function build_array_concat>, 'ARRAY_CAT': <function build_array_concat>, 'ARRAY_CONCAT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArrayConcatAgg'>>, 'ARRAY_CONSTRUCT_COMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayConstructCompact'>>, 'ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContains'>>, 'ARRAY_HAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContains'>>, 'ARRAY_CONTAINS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContainsAll'>>, 'ARRAY_HAS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContainsAll'>>, 'ARRAY_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayDistinct'>>, 'ARRAY_EXCEPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayExcept'>>, 'FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayFilter'>>, 'ARRAY_FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayFilter'>>, 'ARRAY_FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayFirst'>>, 'ARRAY_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayInsert'>>, 'ARRAY_INTERSECT': <function DuckDBParser.<lambda>>, 'ARRAY_INTERSECTION': <function Parser.<lambda>>, 'ARRAY_LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayLast'>>, 'ARRAY_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayMax'>>, 'ARRAY_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayMin'>>, 'ARRAY_OVERLAPS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayOverlaps'>>, 'ARRAY_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayPosition'>>, 'ARRAY_PREPEND': <function _build_array_prepend>, 'ARRAY_REMOVE': <function build_array_remove>, 'ARRAY_REMOVE_AT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayRemoveAt'>>, 'ARRAY_REVERSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayReverse'>>, 'ARRAY_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySize'>>, 'ARRAY_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySize'>>, 'ARRAY_SLICE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySlice'>>, 'ARRAY_SORT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.SortArray'>>, 'ARRAY_SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySum'>>, 'ARRAY_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayToString'>>, 'ARRAY_JOIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayToString'>>, 'ARRAY_UNION_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArrayUnionAgg'>>, 'ARRAY_UNIQUE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArrayUniqueAgg'>>, 'ARRAYS_ZIP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraysZip'>>, 'ASCII': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Ascii'>>, 'ASIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Asin'>>, 'ASINH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Asinh'>>, 'ATAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Atan'>>, 'ATAN2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Atan2'>>, 'ATANH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Atanh'>>, 'AVG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Avg'>>, 'BASE64_DECODE_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Base64DecodeBinary'>>, 'BASE64_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Base64DecodeString'>>, 'BASE64_ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Base64Encode'>>, 'BIT_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.BitLength'>>, 'BITMAP_BIT_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapBitPosition'>>, 'BITMAP_BUCKET_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapBucketNumber'>>, 'BITMAP_CONSTRUCT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapConstructAgg'>>, 'BITMAP_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapCount'>>, 'BITMAP_OR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapOrAgg'>>, 'BITWISE_AND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseAndAgg'>>, 'BITWISE_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseCount'>>, 'BITWISE_OR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseOrAgg'>>, 'BITWISE_XOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseXorAgg'>>, 'BOOLAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Booland'>>, 'BOOLNOT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Boolnot'>>, 'BOOLOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Boolor'>>, 'BOOLXOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BoolxorAgg'>>, 'BYTE_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ByteLength'>>, 'CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Case'>>, 'CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Cast'>>, 'CAST_TO_STR_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CastToStrType'>>, 'CBRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cbrt'>>, 'CEIL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Ceil'>>, 'CEILING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Ceil'>>, 'CHECK_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.CheckJson'>>, 'CHECK_XML': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CheckXml'>>, 'CHR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Chr'>>, 'CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Chr'>>, 'CITY_HASH64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.CityHash64'>>, 'COALESCE': <function build_coalesce>, 'IFNULL': <function build_coalesce>, 'NVL': <function build_coalesce>, 'CODE_POINTS_TO_BYTES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.CodePointsToBytes'>>, 'CODE_POINTS_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.CodePointsToString'>>, 'COLLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Collate'>>, 'COLLATION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Collation'>>, 'COLUMNS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Columns'>>, 'COMBINED_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.CombinedAggFunc'>>, 'COMBINED_PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.CombinedParameterizedAgg'>>, 'COMPRESS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Compress'>>, 'CONCAT': <function Parser.<lambda>>, 'CONCAT_WS': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ConnectByRoot'>>, 'CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Contains'>>, 'CONVERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Convert'>>, 'CONVERT_TIMEZONE': <function build_convert_timezone>, 'CONVERT_TO_CHARSET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ConvertToCharset'>>, 'CORR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Corr'>>, 'COS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cos'>>, 'COSH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cosh'>>, 'COSINE_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.CosineDistance'>>, 'COT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cot'>>, 'COTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Coth'>>, 'COUNT': <function Parser.<lambda>>, 'COUNT_IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CountIf'>>, 'COUNTIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CountIf'>>, 'COVAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CovarPop'>>, 'COVAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CovarSamp'>>, 'CSC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Csc'>>, 'CSCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Csch'>>, 'CUME_DIST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CumeDist'>>, 'CURRENT_ACCOUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentAccount'>>, 'CURRENT_ACCOUNT_NAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentAccountName'>>, 'CURRENT_AVAILABLE_ROLES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentAvailableRoles'>>, 'CURRENT_CATALOG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentCatalog'>>, 'CURRENT_CLIENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentClient'>>, 'CURRENT_DATABASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentDatabase'>>, 'CURRENT_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentDate'>>, 'CURRENT_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentDatetime'>>, 'CURRENT_IP_ADDRESS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentIpAddress'>>, 'CURRENT_ORGANIZATION_NAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentOrganizationName'>>, 'CURRENT_ORGANIZATION_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentOrganizationUser'>>, 'CURRENT_REGION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentRegion'>>, 'CURRENT_ROLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentRole'>>, 'CURRENT_ROLE_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentRoleType'>>, 'CURRENT_SCHEMA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSchema'>>, 'CURRENT_SCHEMAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSchemas'>>, 'CURRENT_SECONDARY_ROLES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSecondaryRoles'>>, 'CURRENT_SESSION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSession'>>, 'CURRENT_STATEMENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentStatement'>>, 'CURRENT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTime'>>, 'CURRENT_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTimestamp'>>, 'CURRENT_TIMESTAMP_L_T_Z': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTimestampLTZ'>>, 'CURRENT_TIMEZONE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTimezone'>>, 'CURRENT_TRANSACTION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentTransaction'>>, 'CURRENT_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentUser'>>, 'CURRENT_VERSION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentVersion'>>, 'CURRENT_WAREHOUSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentWarehouse'>>, 'DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Date'>>, 'DATE_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateAdd'>>, 'DATE_BIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateBin'>>, 'DATEDIFF': <function _build_date_diff>, 'DATE_DIFF': <function _build_date_diff>, 'DATE_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateFromParts'>>, 'DATEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateFromParts'>>, 'DATE_FROM_UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateFromUnixDate'>>, 'DATE_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateStrToDate'>>, 'DATE_TO_DATE_STR': <function Parser.<lambda>>, 'DATE_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateToDi'>>, 'DATE_TRUNC': <function date_trunc_to_time>, 'DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Datetime'>>, 'DATETIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeAdd'>>, 'DATETIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeDiff'>>, 'DATETIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeSub'>>, 'DATETIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeTrunc'>>, 'DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Day'>>, 'DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfMonth'>>, 'DAYOFMONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfMonth'>>, 'DAY_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeek'>>, 'DAYOFWEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeek'>>, 'DAYOFWEEK_ISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeekIso'>>, 'ISODOW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeekIso'>>, 'DAY_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfYear'>>, 'DAYOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfYear'>>, 'DAYNAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Dayname'>>, 'DECODE': <function DuckDBParser.<lambda>>, 'DECODE_CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.DecodeCase'>>, 'DECOMPRESS_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.DecompressBinary'>>, 'DECOMPRESS_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.DecompressString'>>, 'DECRYPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Decrypt'>>, 'DECRYPT_RAW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.DecryptRaw'>>, 'DEGREES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Degrees'>>, 'DENSE_RANK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.DenseRank'>>, 'DI_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DiToDate'>>, 'DOT_PRODUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.DotProduct'>>, 'ELT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Elt'>>, 'ENCODE': <function DuckDBParser.<lambda>>, 'ENCRYPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Encrypt'>>, 'ENCRYPT_RAW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.EncryptRaw'>>, 'ENDS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.EndsWith'>>, 'ENDSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.EndsWith'>>, 'EQUAL_NULL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.EqualNull'>>, 'EUCLIDEAN_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.EuclideanDistance'>>, 'EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Exists'>>, 'EXP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Exp'>>, 'EXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Explode'>>, 'EXPLODING_GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ExplodingGenerateSeries'>>, 'EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Extract'>>, 'FACTORIAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Factorial'>>, 'FARM_FINGERPRINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FarmFingerprint'>>, 'FARMFINGERPRINT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FarmFingerprint'>>, 'FEATURES_AT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.FeaturesAtTime'>>, 'FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.First'>>, 'FIRST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.FirstValue'>>, 'FLATTEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Flatten'>>, 'FLOAT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Float64'>>, 'FLOOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Floor'>>, 'FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Format'>>, 'FROM_BASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FromBase'>>, 'FROM_BASE32': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FromBase32'>>, 'FROM_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FromBase64'>>, 'FROM_ISO8601_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.FromISO8601Timestamp'>>, 'GAP_FILL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.GapFill'>>, 'GENERATE_BOOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateBool'>>, 'GENERATE_DATE_ARRAY': <function Parser.<lambda>>, 'GENERATE_DOUBLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateDouble'>>, 'GENERATE_EMBEDDING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateEmbedding'>>, 'GENERATE_INT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateInt'>>, 'GENERATE_SERIES': <function _build_generate_series.<locals>._builder>, 'GENERATE_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateTable'>>, 'GENERATE_TEXT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateText'>>, 'GENERATE_TIMESTAMP_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.GenerateTimestampArray'>>, 'GENERATOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Generator'>>, 'GET_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.GetExtract'>>, 'GETBIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Getbit'>>, 'GET_BIT': <function DuckDBParser.<lambda>>, 'GREATEST': <function Parser.<lambda>>, 'GROUP_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.GroupConcat'>>, 'GROUPING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Grouping'>>, 'GROUPING_ID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.GroupingId'>>, 'HASH_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.HashAgg'>>, 'HEX': <function build_hex>, 'HEX_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.HexDecodeString'>>, 'HEX_ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.HexEncode'>>, 'HLL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Hll'>>, 'HOST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Host'>>, 'HOUR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Hour'>>, 'IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.If'>>, 'IIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.If'>>, 'INITCAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Initcap'>>, 'INLINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Inline'>>, 'INT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Int64'>>, 'IS_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.IsArray'>>, 'IS_ASCII': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.IsAscii'>>, 'IS_INF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsInf'>>, 'ISINF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsInf'>>, 'IS_NAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsNan'>>, 'ISNAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsNan'>>, 'IS_NULL_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.IsNullValue'>>, 'J_S_O_N_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArray'>>, 'J_S_O_N_ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayAgg'>>, 'JSON_ARRAY_APPEND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayAppend'>>, 'JSON_ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayContains'>>, 'JSON_ARRAY_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayInsert'>>, 'JSONB_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBContains'>>, 'J_S_O_N_B_CONTAINS_ALL_TOP_KEYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBContainsAllTopKeys'>>, 'J_S_O_N_B_CONTAINS_ANY_TOP_KEYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBContainsAnyTopKeys'>>, 'J_S_O_N_B_DELETE_AT_PATH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBDeleteAtPath'>>, 'JSONB_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBExists'>>, 'JSONB_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBExtract'>>, 'JSONB_EXTRACT_SCALAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBExtractScalar'>>, 'J_S_O_N_B_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBObjectAgg'>>, 'J_S_O_N_BOOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBool'>>, 'J_S_O_N_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.JSONCast'>>, 'J_S_O_N_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONExists'>>, 'JSON_EXTRACT': <function build_extract_json_with_path.<locals>._builder>, 'JSON_EXTRACT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONExtractArray'>>, 'JSON_EXTRACT_SCALAR': <function build_extract_json_with_path.<locals>._builder>, 'JSON_FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONFormat'>>, 'JSON_KEYS': <function Parser.<lambda>>, 'J_S_O_N_KEYS_AT_DEPTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONKeysAtDepth'>>, 'J_S_O_N_OBJECT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONObject'>>, 'J_S_O_N_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONObjectAgg'>>, 'JSON_REMOVE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONRemove'>>, 'JSON_SET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONSet'>>, 'JSON_STRIP_NULLS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONStripNulls'>>, 'J_S_O_N_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONTable'>>, 'JSON_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONType'>>, 'J_S_O_N_VALUE_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.query.JSONValueArray'>>, 'JAROWINKLER_SIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.JarowinklerSimilarity'>>, 'JUSTIFY_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.JustifyDays'>>, 'JUSTIFY_HOURS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.JustifyHours'>>, 'JUSTIFY_INTERVAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.JustifyInterval'>>, 'KURTOSIS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Kurtosis'>>, 'LAG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Lag'>>, 'LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Last'>>, 'LAST_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.LastDay'>>, 'LAST_DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.LastDay'>>, 'LAST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LastValue'>>, 'LAX_BOOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxBool'>>, 'LAX_FLOAT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxFloat64'>>, 'LAX_INT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxInt64'>>, 'LAX_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxString'>>, 'LEAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Lead'>>, 'LEAST': <function Parser.<lambda>>, 'LEFT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Left'>>, 'LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Length'>>, 'LEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Length'>>, 'CHAR_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Length'>>, 'CHARACTER_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Length'>>, 'LEVENSHTEIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Levenshtein'>>, 'LIST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.List'>>, 'LN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Ln'>>, 'LOCALTIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Localtime'>>, 'LOCALTIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Localtimestamp'>>, 'LOG': <function build_logarithm>, 'LOGICAL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalAnd'>>, 'BOOL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalAnd'>>, 'BOOLAND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalAnd'>>, 'LOGICAL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalOr'>>, 'BOOL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalOr'>>, 'BOOLOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalOr'>>, 'LOWER': <function build_lower>, 'LCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Lower'>>, 'LOWER_HEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.LowerHex'>>, 'MD5': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5'>>, 'MD5_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5Digest'>>, 'M_D5_NUMBER_LOWER64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5NumberLower64'>>, 'M_D5_NUMBER_UPPER64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5NumberUpper64'>>, 'M_L_FORECAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.MLForecast'>>, 'M_L_TRANSLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.MLTranslate'>>, 'MAKE_INTERVAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.MakeInterval'>>, 'MANHATTAN_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.ManhattanDistance'>>, 'MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Map'>>, 'MAP_CAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapCat'>>, 'MAP_CONTAINS_KEY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapContainsKey'>>, 'MAP_DELETE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapDelete'>>, 'MAP_FROM_ENTRIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapFromEntries'>>, 'MAP_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapInsert'>>, 'MAP_KEYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapKeys'>>, 'MAP_PICK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapPick'>>, 'MAP_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapSize'>>, 'MATCH_AGAINST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MatchAgainst'>>, 'MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Max'>>, 'MEDIAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Median'>>, 'MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Min'>>, 'MINHASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Minhash'>>, 'MINHASH_COMBINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.MinhashCombine'>>, 'MINUTE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Minute'>>, 'MODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Mode'>>, 'MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Month'>>, 'MONTHNAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Monthname'>>, 'MONTHS_BETWEEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.MonthsBetween'>>, 'NET_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.NetFunc'>>, 'NEXT_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.NextDay'>>, 'NEXT_VALUE_FOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ddl.NextValueFor'>>, 'NORMAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Normal'>>, 'NORMALIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Normalize'>>, 'NTH_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.NthValue'>>, 'NTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Ntile'>>, 'NULLIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Nullif'>>, 'NUMBER_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.NumberToStr'>>, 'NVL2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Nvl2'>>, 'OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ObjectAgg'>>, 'OBJECT_ID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ObjectId'>>, 'OBJECT_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ObjectInsert'>>, 'OPEN_J_S_O_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.OpenJSON'>>, 'OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Or'>>, 'OVERLAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Overlay'>>, 'PAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Pad'>>, 'PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.ParameterizedAgg'>>, 'PARSE_BIGNUMERIC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ParseBignumeric'>>, 'PARSE_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.ParseDatetime'>>, 'PARSE_IP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ParseIp'>>, 'PARSE_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ParseJSON'>>, 'JSON_PARSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ParseJSON'>>, 'PARSE_NUMERIC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ParseNumeric'>>, 'PARSE_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.ParseTime'>>, 'PARSE_URL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ParseUrl'>>, 'PERCENT_RANK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.PercentRank'>>, 'PERCENTILE_CONT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.PercentileCont'>>, 'PERCENTILE_DISC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.PercentileDisc'>>, 'PI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Pi'>>, 'POSEXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Posexplode'>>, 'POSEXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.PosexplodeOuter'>>, 'POWER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Pow'>>, 'POW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Pow'>>, 'PREDICT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Predict'>>, 'PREVIOUS_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.PreviousDay'>>, 'QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Quantile'>>, 'QUARTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Quarter'>>, 'RADIANS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Radians'>>, 'RAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Rand'>>, 'RANDOM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Rand'>>, 'RANDN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Randn'>>, 'RANDSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Randstr'>>, 'RANGE_BUCKET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.RangeBucket'>>, 'RANGE_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.RangeN'>>, 'RANK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Rank'>>, 'READ_CSV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ReadCSV'>>, 'READ_PARQUET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ReadParquet'>>, 'REDUCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Reduce'>>, 'REG_DOMAIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.RegDomain'>>, 'REGEXP_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpCount'>>, 'REGEXP_EXTRACT': <function build_regexp_extract.<locals>._builder>, 'REGEXP_EXTRACT_ALL': <function build_regexp_extract.<locals>._builder>, 'REGEXP_FULL_MATCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpFullMatch'>>, 'REGEXP_I_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpILike'>>, 'REGEXP_INSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpInstr'>>, 'REGEXP_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.RegexpLike'>>, 'REGEXP_REPLACE': <function DuckDBParser.<lambda>>, 'REGEXP_SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpSplit'>>, 'REGR_AVGX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrAvgx'>>, 'REGR_AVGY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrAvgy'>>, 'REGR_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrCount'>>, 'REGR_INTERCEPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrIntercept'>>, 'REGR_R2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrR2'>>, 'REGR_SLOPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSlope'>>, 'REGR_SXX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSxx'>>, 'REGR_SXY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSxy'>>, 'REGR_SYY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSyy'>>, 'REGR_VALX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrValx'>>, 'REGR_VALY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrValy'>>, 'REPEAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Repeat'>>, 'REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Replace'>>, 'REVERSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Reverse'>>, 'RIGHT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Right'>>, 'ROUND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Round'>>, 'ROW_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RowNumber'>>, 'RTRIMMED_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RtrimmedLength'>>, 'SHA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA'>>, 'SHA1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA'>>, 'S_H_A1_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA1Digest'>>, 'SHA2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA2'>>, 'S_H_A2_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA2Digest'>>, 'SAFE_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeAdd'>>, 'SAFE_CONVERT_BYTES_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SafeConvertBytesToString'>>, 'SAFE_DIVIDE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeDivide'>>, 'SAFE_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.SafeFunc'>>, 'SAFE_MULTIPLY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeMultiply'>>, 'SAFE_NEGATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeNegate'>>, 'SAFE_SUBTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeSubtract'>>, 'SEARCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Search'>>, 'SEARCH_IP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SearchIp'>>, 'SEC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sec'>>, 'SECH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sech'>>, 'SECOND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Second'>>, 'SEQ1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq1'>>, 'SEQ2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq2'>>, 'SEQ4': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq4'>>, 'SEQ8': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq8'>>, 'SESSION_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.SessionUser'>>, 'SIGN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sign'>>, 'SIGNUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sign'>>, 'SIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sin'>>, 'SINH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sinh'>>, 'SKEWNESS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Skewness'>>, 'SORT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.SortArray'>>, 'SOUNDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Soundex'>>, 'SOUNDEX_P123': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SoundexP123'>>, 'SPACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Space'>>, 'SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Split'>>, 'SPLIT_PART': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SplitPart'>>, 'SQRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sqrt'>>, 'ST_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StDistance'>>, 'ST_POINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StPoint'>>, 'ST_MAKEPOINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StPoint'>>, 'STANDARD_HASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StandardHash'>>, 'STAR_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StarMap'>>, 'STARTS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StartsWith'>>, 'STARTSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StartsWith'>>, 'STDDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Stddev'>>, 'STDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Stddev'>>, 'STDDEV_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.StddevPop'>>, 'STDDEV_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.StddevSamp'>>, 'STR_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StrPosition'>>, 'STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.StrToDate'>>, 'STR_TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StrToMap'>>, 'STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.StrToTime'>>, 'STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.StrToUnix'>>, 'STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.String'>>, 'STRING_TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Split'>>, 'SPLIT_BY_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StringToArray'>>, 'STRTOK_TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StringToArray'>>, 'STRIP_NULL_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.StripNullValue'>>, 'STRTOK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Strtok'>>, 'STRUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Struct'>>, 'STRUCT_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StructExtract'>>, 'STUFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Stuff'>>, 'INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Stuff'>>, 'SUBSTRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Substring'>>, 'SUBSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Substring'>>, 'SUBSTRING_INDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SubstringIndex'>>, 'SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Sum'>>, 'SYSTIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Systimestamp'>>, 'TAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Tan'>>, 'TANH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Tanh'>>, 'TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Time'>>, 'TIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeAdd'>>, 'TIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeDiff'>>, 'TIME_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeFromParts'>>, 'TIMEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeFromParts'>>, 'TIME_SLICE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeSlice'>>, 'TIME_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeStrToDate'>>, 'TIME_STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeStrToTime'>>, 'TIME_STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeStrToUnix'>>, 'TIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeSub'>>, 'TIME_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeToStr'>>, 'TIME_TO_TIME_STR': <function Parser.<lambda>>, 'TIME_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeToUnix'>>, 'TIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeTrunc'>>, 'TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Timestamp'>>, 'TIMESTAMP_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampAdd'>>, 'TIMESTAMPDIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampDiff'>>, 'TIMESTAMP_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampDiff'>>, 'TIMESTAMP_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampFromParts'>>, 'TIMESTAMPFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampFromParts'>>, 'TIMESTAMP_LTZ_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampLtzFromParts'>>, 'TIMESTAMPLTZFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampLtzFromParts'>>, 'TIMESTAMP_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampSub'>>, 'TIMESTAMP_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampTrunc'>>, 'TIMESTAMP_TZ_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampTzFromParts'>>, 'TIMESTAMPTZFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampTzFromParts'>>, 'TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ToArray'>>, 'TO_BASE32': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToBase32'>>, 'TO_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToBase64'>>, 'TO_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToBinary'>>, 'TO_BOOLEAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ToBoolean'>>, 'TO_CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToChar'>>, 'TO_CODE_POINTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToCodePoints'>>, 'TO_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.ToDays'>>, 'TO_DECFLOAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToDecfloat'>>, 'TO_DOUBLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToDouble'>>, 'TO_FILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToFile'>>, 'TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ToMap'>>, 'TO_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToNumber'>>, 'TO_VARIANT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ToVariant'>>, 'TRANSFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Transform'>>, 'TRANSLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Translate'>>, 'TRIM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Trim'>>, 'TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Trunc'>>, 'TRUNCATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Trunc'>>, 'TRY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Try'>>, 'TRY_BASE64_DECODE_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryBase64DecodeBinary'>>, 'TRY_BASE64_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryBase64DecodeString'>>, 'TRY_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.TryCast'>>, 'TRY_HEX_DECODE_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryHexDecodeBinary'>>, 'TRY_HEX_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryHexDecodeString'>>, 'TRY_TO_DECFLOAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryToDecfloat'>>, 'TS_OR_DI_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDiToDi'>>, 'TS_OR_DS_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsAdd'>>, 'TS_OR_DS_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsDiff'>>, 'TS_OR_DS_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsToDate'>>, 'TS_OR_DS_TO_DATE_STR': <function Parser.<lambda>>, 'TS_OR_DS_TO_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsToDatetime'>>, 'TS_OR_DS_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsToTime'>>, 'TS_OR_DS_TO_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsToTimestamp'>>, 'TYPEOF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Typeof'>>, 'UNHEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Unhex'>>, 'UNICODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Unicode'>>, 'UNIFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Uniform'>>, 'UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixDate'>>, 'UNIX_MICROS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixMicros'>>, 'UNIX_MILLIS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixMillis'>>, 'UNIX_SECONDS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixSeconds'>>, 'UNIX_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixToStr'>>, 'UNIX_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixToTime'>>, 'UNIX_TO_TIME_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixToTimeStr'>>, 'UNNEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Explode'>>, 'UPPER': <function build_upper>, 'UCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Upper'>>, 'UTC_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UtcDate'>>, 'UTC_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UtcTime'>>, 'UTC_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UtcTimestamp'>>, 'UUID': <function Parser.<lambda>>, 'GEN_RANDOM_UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Uuid'>>, 'GENERATE_UUID': <function Parser.<lambda>>, 'UUID_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Uuid'>>, 'VAR_MAP': <function build_var_map>, 'VARIANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Variance'>>, 'VARIANCE_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Variance'>>, 'VAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Variance'>>, 'VARIANCE_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.VariancePop'>>, 'VAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.VariancePop'>>, 'VECTOR_SEARCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.VectorSearch'>>, 'WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Week'>>, 'WEEK_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.WeekOfYear'>>, 'WEEKOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.WeekOfYear'>>, 'WEEK_START': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.WeekStart'>>, 'WIDTH_BUCKET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.WidthBucket'>>, 'XMLELEMENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.XMLElement'>>, 'XMLGET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.XMLGet'>>, 'X_M_L_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.XMLTable'>>, 'XOR': <function binary_from_function.<locals>.<lambda>>, 'YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Year'>>, 'YEAR_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeek'>>, 'YEAROFWEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeek'>>, 'YEAR_OF_WEEK_ISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeekIso'>>, 'YEAROFWEEKISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeekIso'>>, 'ZIPF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Zipf'>>, 'EXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array._ExplodeOuter'>>, 'ARRAYAGG': <function Parser.<lambda>>, 'JSON_EXTRACT_PATH_TEXT': <function build_extract_json_with_path.<locals>._builder>, 'LIKE': <function build_like>, 'LOG2': <function Parser.<lambda>>, 'LOG10': <function Parser.<lambda>>, 'LPAD': <function Parser.<lambda>>, 'LEFTPAD': <function Parser.<lambda>>, 'LTRIM': <function Parser.<lambda>>, 'MOD': <function build_mod>, 'RIGHTPAD': <function Parser.<lambda>>, 'RPAD': <function Parser.<lambda>>, 'RTRIM': <function Parser.<lambda>>, 'SCOPE_RESOLUTION': <function Parser.<lambda>>, 'STRPOS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StrPosition'>>, 'CHARINDEX': <function Parser.<lambda>>, 'INSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StrPosition'>>, 'LOCATE': <function Parser.<lambda>>, 'TO_HEX': <function build_hex>, 'ARRAY_REVERSE_SORT': <function _build_sort_array_desc>, 'BIT_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseAndAgg'>>, 'BIT_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseOrAgg'>>, 'BIT_XOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseXorAgg'>>, 'CURRENT_LOCALTIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Localtimestamp'>>, 'DATETRUNC': <function date_trunc_to_time>, 'EDITDIST3': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Levenshtein'>>, 'EPOCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeToUnix'>>, 'EPOCH_MS': <function DuckDBParser.<lambda>>, 'GET_CURRENT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTime'>>, 'JARO_WINKLER_SIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.JarowinklerSimilarity'>>, 'JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ParseJSON'>>, 'JSON_ARRAY': <function DuckDBParser.<lambda>>, 'JSON_EXTRACT_PATH': <function build_extract_json_with_path.<locals>._builder>, 'JSON_EXTRACT_STRING': <function build_extract_json_with_path.<locals>._builder>, 'LIST_APPEND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayAppend'>>, 'LIST_CONCAT': <function build_array_concat>, 'LIST_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContains'>>, 'LIST_COSINE_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.CosineDistance'>>, 'LIST_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.EuclideanDistance'>>, 'LIST_FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayFilter'>>, 'LIST_HAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContains'>>, 'LIST_HAS_ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayOverlaps'>>, 'LIST_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayMax'>>, 'LIST_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayMin'>>, 'LIST_PREPEND': <function _build_array_prepend>, 'LIST_REVERSE_SORT': <function _build_sort_array_desc>, 'LIST_SORT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.SortArray'>>, 'LIST_TRANSFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Transform'>>, 'LIST_VALUE': <function DuckDBParser.<lambda>>, 'MAKE_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateFromParts'>>, 'MAKE_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeFromParts'>>, 'MAKE_TIMESTAMP': <function _build_make_timestamp>, 'QUANTILE_CONT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.PercentileCont'>>, 'QUANTILE_DISC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.PercentileDisc'>>, 'RANGE': <function _build_generate_series.<locals>._builder>, 'REGEXP_MATCHES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.RegexpLike'>>, 'SHA256': <function DuckDBParser.<lambda>>, 'STRFTIME': <function build_formatted_time.<locals>._builder>, 'STRING_SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Split'>>, 'STRING_SPLIT_REGEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpSplit'>>, 'STRPTIME': <function build_formatted_time.<locals>._builder>, 'STRUCT_PACK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Struct'>>, 'STR_SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Split'>>, 'STR_SPLIT_REGEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpSplit'>>, 'TODAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentDate'>>, 'TIME_BUCKET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateBin'>>, 'TO_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixToTime'>>, 'VERSION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentVersion'>>}

FUNCTION_PARSERS = {'ARG_MAX': <function Parser.<dictcomp>.<lambda>>, 'ARGMAX': <function Parser.<dictcomp>.<lambda>>, 'MAX_BY': <function Parser.<dictcomp>.<lambda>>, 'ARG_MIN': <function Parser.<dictcomp>.<lambda>>, 'ARGMIN': <function Parser.<dictcomp>.<lambda>>, 'MIN_BY': <function Parser.<dictcomp>.<lambda>>, 'CAST': <function Parser.<lambda>>, 'CEIL': <function Parser.<lambda>>, 'CONVERT': <function Parser.<lambda>>, 'CHAR': <function Parser.<lambda>>, 'CHR': <function Parser.<lambda>>, 'EXTRACT': <function Parser.<lambda>>, 'FLOOR': <function Parser.<lambda>>, 'GAP_FILL': <function Parser.<lambda>>, 'INITCAP': <function Parser.<lambda>>, 'JSON_OBJECT': <function Parser.<lambda>>, 'JSON_OBJECTAGG': <function Parser.<lambda>>, 'JSON_TABLE': <function Parser.<lambda>>, 'MATCH': <function Parser.<lambda>>, 'NORMALIZE': <function Parser.<lambda>>, 'OPENJSON': <function Parser.<lambda>>, 'OVERLAY': <function Parser.<lambda>>, 'POSITION': <function Parser.<lambda>>, 'SAFE_CAST': <function Parser.<lambda>>, 'STRING_AGG': <function Parser.<lambda>>, 'SUBSTRING': <function Parser.<lambda>>, 'TRIM': <function Parser.<lambda>>, 'TRY_CAST': <function Parser.<lambda>>, 'TRY_CONVERT': <function Parser.<lambda>>, 'XMLELEMENT': <function Parser.<lambda>>, 'XMLTABLE': <function Parser.<lambda>>, 'GROUP_CONCAT': <function DuckDBParser.<lambda>>, 'LISTAGG': <function DuckDBParser.<lambda>>, 'STRINGAGG': <function DuckDBParser.<lambda>>}

NO_PAREN_FUNCTION_PARSERS = {'ANY': <function Parser.<lambda>>, 'CASE': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <function Parser.<lambda>>, 'IF': <function Parser.<lambda>>, 'MAP': <function DuckDBParser.<lambda>>, '@': <function DuckDBParser.<lambda>>}

PLACEHOLDER_PARSERS = {<TokenType.PLACEHOLDER: 353>: <function Parser.<lambda>>, <TokenType.PARAMETER: 56>: <function DuckDBParser.<lambda>>, <TokenType.COLON: 11>: <function Parser.<lambda>>}

TYPE_CONVERTERS = {<DType.DECIMAL: 'DECIMAL'>: <function build_default_decimal_type.<locals>._builder>, <DType.TEXT: 'TEXT'>: <function DuckDBParser.<lambda>>}

STATEMENT_PARSERS = {<TokenType.ALTER: 217>: <function Parser.<lambda>>, <TokenType.ANALYZE: 435>: <function Parser.<lambda>>, <TokenType.BEGIN: 227>: <function Parser.<lambda>>, <TokenType.CACHE: 230>: <function Parser.<lambda>>, <TokenType.COMMENT: 236>: <function Parser.<lambda>>, <TokenType.COMMIT: 237>: <function Parser.<lambda>>, <TokenType.COPY: 240>: <function Parser.<lambda>>, <TokenType.CREATE: 241>: <function Parser.<lambda>>, <TokenType.DELETE: 254>: <function Parser.<lambda>>, <TokenType.DESC: 255>: <function Parser.<lambda>>, <TokenType.DESCRIBE: 256>: <function Parser.<lambda>>, <TokenType.DROP: 262>: <function Parser.<lambda>>, <TokenType.GRANT: 286>: <function Parser.<lambda>>, <TokenType.REVOKE: 373>: <function Parser.<lambda>>, <TokenType.INSERT: 297>: <function Parser.<lambda>>, <TokenType.KILL: 311>: <function Parser.<lambda>>, <TokenType.LOAD: 318>: <function Parser.<lambda>>, <TokenType.MERGE: 325>: <function Parser.<lambda>>, <TokenType.PIVOT: 352>: <function Parser.<lambda>>, <TokenType.PRAGMA: 357>: <function Parser.<lambda>>, <TokenType.REFRESH: 369>: <function Parser.<lambda>>, <TokenType.ROLLBACK: 378>: <function Parser.<lambda>>, <TokenType.SET: 388>: <function Parser.<lambda>>, <TokenType.TRUNCATE: 407>: <function Parser.<lambda>>, <TokenType.UNCACHE: 409>: <function Parser.<lambda>>, <TokenType.UNPIVOT: 412>: <function Parser.<lambda>>, <TokenType.UPDATE: 413>: <function Parser.<lambda>>, <TokenType.USE: 414>: <function Parser.<lambda>>, <TokenType.SEMICOLON: 19>: <function Parser.<lambda>>, <TokenType.ATTACH: 225>: <function DuckDBParser.<lambda>>, <TokenType.DETACH: 257>: <function DuckDBParser.<lambda>>, <TokenType.FORCE: 277>: <function DuckDBParser.<lambda>>, <TokenType.INSTALL: 298>: <function DuckDBParser.<lambda>>, <TokenType.SHOW: 390>: <function DuckDBParser.<lambda>>}

SET_PARSERS = {'GLOBAL': <function Parser.<lambda>>, 'LOCAL': <function Parser.<lambda>>, 'SESSION': <function Parser.<lambda>>, 'TRANSACTION': <function Parser.<lambda>>, 'VARIABLE': <function DuckDBParser.<lambda>>}

SHOW_TRIE = {'TABLES': {0: True}, 'ALL': {'TABLES': {0: True}}}

SET_TRIE = {'GLOBAL': {0: True}, 'LOCAL': {0: True}, 'SESSION': {0: True}, 'TRANSACTION': {0: True}, 'VARIABLE': {0: True}}

Inherited Members

sqlglot.parser.Parser: Parser; STRUCT_TYPE_TOKENS; NESTED_TYPE_TOKENS; ENUM_TYPE_TOKENS; AGGREGATE_TYPE_TOKENS; TYPE_TOKENS; SIGNED_TO_UNSIGNED_TYPE_TOKEN; SUBQUERY_PREDICATES; SUBQUERY_TOKENS; RESERVED_TOKENS; DB_CREATABLES; CREATABLES; TRIGGER_EVENTS; ALTERABLES; ID_VAR_TOKENS; TABLE_ALIAS_TOKENS; ALIAS_TOKENS; COLON_PLACEHOLDER_TOKENS; ARRAY_CONSTRUCTORS; COMMENT_TABLE_ALIAS_TOKENS; UPDATE_ALIAS_TOKENS; TRIM_TYPES; IDENTIFIER_TOKENS; BRACKETS; COLUMN_POSTFIX_TOKENS; TABLE_POSTFIX_TOKENS; FUNC_TOKENS; CONJUNCTION; ASSIGNMENT; DISJUNCTION; EQUALITY; COMPARISON; TERM; FACTOR; TIMES; TIMESTAMPS; SET_OPERATIONS; JOIN_METHODS; JOIN_SIDES; JOIN_KINDS; JOIN_HINTS; TABLE_TERMINATORS; LAMBDAS; TYPED_LAMBDA_ARGS; LAMBDA_ARG_TERMINATORS; COLUMN_OPERATORS; CAST_COLUMN_OPERATORS; EXPRESSION_PARSERS; UNARY_PARSERS; STRING_PARSERS; NUMERIC_PARSERS; PRIMARY_PARSERS; PIPE_SYNTAX_TRANSFORM_PARSERS; PROPERTY_PARSERS; CONSTRAINT_PARSERS; ALTER_PARSERS; ALTER_ALTER_PARSERS; SCHEMA_UNNAMED_CONSTRAINTS; INVALID_FUNC_NAME_TOKENS; KEY_VALUE_DEFINITIONS; QUERY_MODIFIER_PARSERS; QUERY_MODIFIER_TOKENS; TYPE_LITERAL_PARSERS; DDL_SELECT_TOKENS; PRE_VOLATILE_TOKENS; TRANSACTION_KIND; TRANSACTION_CHARACTERISTICS; CONFLICT_ACTIONS; TRIGGER_TIMING; TRIGGER_DEFERRABLE; CREATE_SEQUENCE; ISOLATED_LOADING_OPTIONS; USABLES; CAST_ACTIONS; SCHEMA_BINDING_OPTIONS; PROCEDURE_OPTIONS; EXECUTE_AS_OPTIONS; KEY_CONSTRAINT_OPTIONS; WINDOW_EXCLUDE_OPTIONS; INSERT_ALTERNATIVES; CLONE_KEYWORDS; HISTORICAL_DATA_PREFIX; HISTORICAL_DATA_KIND; OPCLASS_FOLLOW_KEYWORDS; OPTYPE_FOLLOW_TOKENS; TABLE_INDEX_HINT_TOKENS; VIEW_ATTRIBUTES; WINDOW_ALIAS_TOKENS; WINDOW_BEFORE_PAREN_TOKENS; WINDOW_SIDES; JSON_KEY_VALUE_SEPARATOR_TOKENS; FETCH_TOKENS; ADD_CONSTRAINT_TOKENS; DISTINCT_TOKENS; UNNEST_OFFSET_ALIAS_TOKENS; SELECT_START_TOKENS; COPY_INTO_VARLEN_OPTIONS; IS_JSON_PREDICATE_KIND; ODBC_DATETIME_LITERALS; ON_CONDITION_TOKENS; PRIVILEGE_FOLLOW_TOKENS; DESCRIBE_STYLES; SET_ASSIGNMENT_DELIMITERS; ANALYZE_STYLES; ANALYZE_EXPRESSION_PARSERS; PARTITION_KEYWORDS; AMBIGUOUS_ALIAS_TOKENS; OPERATION_MODIFIERS; RECURSIVE_CTE_SEARCH_KIND; SECURITY_PROPERTY_KEYWORDS; MODIFIABLES; STRICT_CAST; PREFIXED_PIVOT_COLUMNS; IDENTIFY_PIVOT_STRINGS; LOG_DEFAULTS_TO_LN; TABLESAMPLE_CSV; DEFAULT_SAMPLING_METHOD; SET_REQUIRES_ASSIGNMENT_DELIMITER; TRIM_PATTERN_FIRST; STRING_ALIASES; MODIFIERS_ATTACHED_TO_SET_OP; SET_OP_MODIFIERS; NO_PAREN_IF_COMMANDS; JSON_ARROWS_REQUIRE_JSON_TYPE; COLON_IS_VARIANT_EXTRACT; VALUES_FOLLOWED_BY_PAREN; SUPPORTS_IMPLICIT_UNNEST; INTERVAL_SPANS; SUPPORTS_PARTITION_SELECTION; WRAPPED_TRANSFORM_COLUMN_CONSTRAINT; OPTIONAL_ALIAS_TOKEN_CTE; ALTER_RENAME_REQUIRES_COLUMN; ALTER_TABLE_PARTITIONS; JOINS_HAVE_EQUAL_PRECEDENCE; ZONE_AWARE_TIMESTAMP_CONSTRUCTOR; JSON_EXTRACT_REQUIRES_JSON_EXPRESSION; ADD_JOIN_ON_TRUE; SUPPORTS_OMITTED_INTERVAL_SPAN_UNIT; error_level; error_message_context; max_errors; max_nodes; dialect; sql; errors; reset; raise_error; validate_expression; parse; parse_into; check_errors; expression; parse_set_operation; build_cast