Edit on GitHub

sqlglot.dialects.clickhouse

  1from __future__ import annotations
  2
  3import typing as t
  4
  5from sqlglot import exp, generator, parser, tokens, transforms
  6from sqlglot.dialects.dialect import (
  7    Dialect,
  8    arg_max_or_min_no_count,
  9    build_formatted_time,
 10    date_delta_sql,
 11    inline_array_sql,
 12    json_extract_segments,
 13    json_path_key_only_name,
 14    no_pivot_sql,
 15    build_json_extract_path,
 16    rename_func,
 17    var_map_sql,
 18)
 19from sqlglot.helper import is_int, seq_get
 20from sqlglot.tokens import Token, TokenType
 21
 22
 23def _build_date_format(args: t.List) -> exp.TimeToStr:
 24    expr = build_formatted_time(exp.TimeToStr, "clickhouse")(args)
 25
 26    timezone = seq_get(args, 2)
 27    if timezone:
 28        expr.set("timezone", timezone)
 29
 30    return expr
 31
 32
 33def _unix_to_time_sql(self: ClickHouse.Generator, expression: exp.UnixToTime) -> str:
 34    scale = expression.args.get("scale")
 35    timestamp = expression.this
 36
 37    if scale in (None, exp.UnixToTime.SECONDS):
 38        return self.func("fromUnixTimestamp", exp.cast(timestamp, exp.DataType.Type.BIGINT))
 39    if scale == exp.UnixToTime.MILLIS:
 40        return self.func("fromUnixTimestamp64Milli", exp.cast(timestamp, exp.DataType.Type.BIGINT))
 41    if scale == exp.UnixToTime.MICROS:
 42        return self.func("fromUnixTimestamp64Micro", exp.cast(timestamp, exp.DataType.Type.BIGINT))
 43    if scale == exp.UnixToTime.NANOS:
 44        return self.func("fromUnixTimestamp64Nano", exp.cast(timestamp, exp.DataType.Type.BIGINT))
 45
 46    return self.func(
 47        "fromUnixTimestamp",
 48        exp.cast(
 49            exp.Div(this=timestamp, expression=exp.func("POW", 10, scale)), exp.DataType.Type.BIGINT
 50        ),
 51    )
 52
 53
 54def _lower_func(sql: str) -> str:
 55    index = sql.index("(")
 56    return sql[:index].lower() + sql[index:]
 57
 58
 59def _quantile_sql(self: ClickHouse.Generator, expression: exp.Quantile) -> str:
 60    quantile = expression.args["quantile"]
 61    args = f"({self.sql(expression, 'this')})"
 62
 63    if isinstance(quantile, exp.Array):
 64        func = self.func("quantiles", *quantile)
 65    else:
 66        func = self.func("quantile", quantile)
 67
 68    return func + args
 69
 70
 71def _build_count_if(args: t.List) -> exp.CountIf | exp.CombinedAggFunc:
 72    if len(args) == 1:
 73        return exp.CountIf(this=seq_get(args, 0))
 74
 75    return exp.CombinedAggFunc(this="countIf", expressions=args, parts=("count", "If"))
 76
 77
 78class ClickHouse(Dialect):
 79    NORMALIZE_FUNCTIONS: bool | str = False
 80    NULL_ORDERING = "nulls_are_last"
 81    SUPPORTS_USER_DEFINED_TYPES = False
 82    SAFE_DIVISION = True
 83    LOG_BASE_FIRST: t.Optional[bool] = None
 84
 85    UNESCAPED_SEQUENCES = {
 86        "\\0": "\0",
 87    }
 88
 89    class Tokenizer(tokens.Tokenizer):
 90        COMMENTS = ["--", "#", "#!", ("/*", "*/")]
 91        IDENTIFIERS = ['"', "`"]
 92        STRING_ESCAPES = ["'", "\\"]
 93        BIT_STRINGS = [("0b", "")]
 94        HEX_STRINGS = [("0x", ""), ("0X", "")]
 95        HEREDOC_STRINGS = ["$"]
 96
 97        KEYWORDS = {
 98            **tokens.Tokenizer.KEYWORDS,
 99            "ATTACH": TokenType.COMMAND,
100            "DATE32": TokenType.DATE32,
101            "DATETIME64": TokenType.DATETIME64,
102            "DICTIONARY": TokenType.DICTIONARY,
103            "ENUM8": TokenType.ENUM8,
104            "ENUM16": TokenType.ENUM16,
105            "FINAL": TokenType.FINAL,
106            "FIXEDSTRING": TokenType.FIXEDSTRING,
107            "FLOAT32": TokenType.FLOAT,
108            "FLOAT64": TokenType.DOUBLE,
109            "GLOBAL": TokenType.GLOBAL,
110            "INT256": TokenType.INT256,
111            "LOWCARDINALITY": TokenType.LOWCARDINALITY,
112            "MAP": TokenType.MAP,
113            "NESTED": TokenType.NESTED,
114            "SAMPLE": TokenType.TABLE_SAMPLE,
115            "TUPLE": TokenType.STRUCT,
116            "UINT128": TokenType.UINT128,
117            "UINT16": TokenType.USMALLINT,
118            "UINT256": TokenType.UINT256,
119            "UINT32": TokenType.UINT,
120            "UINT64": TokenType.UBIGINT,
121            "UINT8": TokenType.UTINYINT,
122            "IPV4": TokenType.IPV4,
123            "IPV6": TokenType.IPV6,
124            "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION,
125            "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION,
126            "SYSTEM": TokenType.COMMAND,
127            "PREWHERE": TokenType.PREWHERE,
128        }
129
130        SINGLE_TOKENS = {
131            **tokens.Tokenizer.SINGLE_TOKENS,
132            "$": TokenType.HEREDOC_STRING,
133        }
134
135    class Parser(parser.Parser):
136        # Tested in ClickHouse's playground, it seems that the following two queries do the same thing
137        # * select x from t1 union all select x from t2 limit 1;
138        # * select x from t1 union all (select x from t2 limit 1);
139        MODIFIERS_ATTACHED_TO_UNION = False
140        INTERVAL_SPANS = False
141
142        FUNCTIONS = {
143            **parser.Parser.FUNCTIONS,
144            "ANY": exp.AnyValue.from_arg_list,
145            "ARRAYSUM": exp.ArraySum.from_arg_list,
146            "COUNTIF": _build_count_if,
147            "DATE_ADD": lambda args: exp.DateAdd(
148                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
149            ),
150            "DATEADD": lambda args: exp.DateAdd(
151                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
152            ),
153            "DATE_DIFF": lambda args: exp.DateDiff(
154                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
155            ),
156            "DATEDIFF": lambda args: exp.DateDiff(
157                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
158            ),
159            "DATE_FORMAT": _build_date_format,
160            "FORMATDATETIME": _build_date_format,
161            "JSONEXTRACTSTRING": build_json_extract_path(
162                exp.JSONExtractScalar, zero_based_indexing=False
163            ),
164            "MAP": parser.build_var_map,
165            "MATCH": exp.RegexpLike.from_arg_list,
166            "RANDCANONICAL": exp.Rand.from_arg_list,
167            "TUPLE": exp.Struct.from_arg_list,
168            "UNIQ": exp.ApproxDistinct.from_arg_list,
169            "XOR": lambda args: exp.Xor(expressions=args),
170            "MD5": exp.MD5Digest.from_arg_list,
171            "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
172            "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
173        }
174
175        AGG_FUNCTIONS = {
176            "count",
177            "min",
178            "max",
179            "sum",
180            "avg",
181            "any",
182            "stddevPop",
183            "stddevSamp",
184            "varPop",
185            "varSamp",
186            "corr",
187            "covarPop",
188            "covarSamp",
189            "entropy",
190            "exponentialMovingAverage",
191            "intervalLengthSum",
192            "kolmogorovSmirnovTest",
193            "mannWhitneyUTest",
194            "median",
195            "rankCorr",
196            "sumKahan",
197            "studentTTest",
198            "welchTTest",
199            "anyHeavy",
200            "anyLast",
201            "boundingRatio",
202            "first_value",
203            "last_value",
204            "argMin",
205            "argMax",
206            "avgWeighted",
207            "topK",
208            "topKWeighted",
209            "deltaSum",
210            "deltaSumTimestamp",
211            "groupArray",
212            "groupArrayLast",
213            "groupUniqArray",
214            "groupArrayInsertAt",
215            "groupArrayMovingAvg",
216            "groupArrayMovingSum",
217            "groupArraySample",
218            "groupBitAnd",
219            "groupBitOr",
220            "groupBitXor",
221            "groupBitmap",
222            "groupBitmapAnd",
223            "groupBitmapOr",
224            "groupBitmapXor",
225            "sumWithOverflow",
226            "sumMap",
227            "minMap",
228            "maxMap",
229            "skewSamp",
230            "skewPop",
231            "kurtSamp",
232            "kurtPop",
233            "uniq",
234            "uniqExact",
235            "uniqCombined",
236            "uniqCombined64",
237            "uniqHLL12",
238            "uniqTheta",
239            "quantile",
240            "quantiles",
241            "quantileExact",
242            "quantilesExact",
243            "quantileExactLow",
244            "quantilesExactLow",
245            "quantileExactHigh",
246            "quantilesExactHigh",
247            "quantileExactWeighted",
248            "quantilesExactWeighted",
249            "quantileTiming",
250            "quantilesTiming",
251            "quantileTimingWeighted",
252            "quantilesTimingWeighted",
253            "quantileDeterministic",
254            "quantilesDeterministic",
255            "quantileTDigest",
256            "quantilesTDigest",
257            "quantileTDigestWeighted",
258            "quantilesTDigestWeighted",
259            "quantileBFloat16",
260            "quantilesBFloat16",
261            "quantileBFloat16Weighted",
262            "quantilesBFloat16Weighted",
263            "simpleLinearRegression",
264            "stochasticLinearRegression",
265            "stochasticLogisticRegression",
266            "categoricalInformationValue",
267            "contingency",
268            "cramersV",
269            "cramersVBiasCorrected",
270            "theilsU",
271            "maxIntersections",
272            "maxIntersectionsPosition",
273            "meanZTest",
274            "quantileInterpolatedWeighted",
275            "quantilesInterpolatedWeighted",
276            "quantileGK",
277            "quantilesGK",
278            "sparkBar",
279            "sumCount",
280            "largestTriangleThreeBuckets",
281            "histogram",
282            "sequenceMatch",
283            "sequenceCount",
284            "windowFunnel",
285            "retention",
286            "uniqUpTo",
287            "sequenceNextNode",
288            "exponentialTimeDecayedAvg",
289        }
290
291        AGG_FUNCTIONS_SUFFIXES = [
292            "If",
293            "Array",
294            "ArrayIf",
295            "Map",
296            "SimpleState",
297            "State",
298            "Merge",
299            "MergeState",
300            "ForEach",
301            "Distinct",
302            "OrDefault",
303            "OrNull",
304            "Resample",
305            "ArgMin",
306            "ArgMax",
307        ]
308
309        FUNC_TOKENS = {
310            *parser.Parser.FUNC_TOKENS,
311            TokenType.SET,
312        }
313
314        AGG_FUNC_MAPPING = (
315            lambda functions, suffixes: {
316                f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions
317            }
318        )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES)
319
320        FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"}
321
322        FUNCTION_PARSERS = {
323            **parser.Parser.FUNCTION_PARSERS,
324            "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()),
325            "QUANTILE": lambda self: self._parse_quantile(),
326        }
327
328        FUNCTION_PARSERS.pop("MATCH")
329
330        NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy()
331        NO_PAREN_FUNCTION_PARSERS.pop("ANY")
332
333        RANGE_PARSERS = {
334            **parser.Parser.RANGE_PARSERS,
335            TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN)
336            and self._parse_in(this, is_global=True),
337        }
338
339        # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to
340        # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler.
341        COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy()
342        COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
343
344        JOIN_KINDS = {
345            *parser.Parser.JOIN_KINDS,
346            TokenType.ANY,
347            TokenType.ASOF,
348            TokenType.ARRAY,
349        }
350
351        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
352            TokenType.ANY,
353            TokenType.ARRAY,
354            TokenType.FINAL,
355            TokenType.FORMAT,
356            TokenType.SETTINGS,
357        }
358
359        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
360            TokenType.FORMAT,
361        }
362
363        LOG_DEFAULTS_TO_LN = True
364
365        QUERY_MODIFIER_PARSERS = {
366            **parser.Parser.QUERY_MODIFIER_PARSERS,
367            TokenType.SETTINGS: lambda self: (
368                "settings",
369                self._advance() or self._parse_csv(self._parse_conjunction),
370            ),
371            TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
372        }
373
374        CONSTRAINT_PARSERS = {
375            **parser.Parser.CONSTRAINT_PARSERS,
376            "INDEX": lambda self: self._parse_index_constraint(),
377            "CODEC": lambda self: self._parse_compress(),
378        }
379
380        ALTER_PARSERS = {
381            **parser.Parser.ALTER_PARSERS,
382            "REPLACE": lambda self: self._parse_alter_table_replace(),
383        }
384
385        SCHEMA_UNNAMED_CONSTRAINTS = {
386            *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
387            "INDEX",
388        }
389
390        def _parse_conjunction(self) -> t.Optional[exp.Expression]:
391            this = super()._parse_conjunction()
392
393            if self._match(TokenType.PLACEHOLDER):
394                return self.expression(
395                    exp.If,
396                    this=this,
397                    true=self._parse_conjunction(),
398                    false=self._match(TokenType.COLON) and self._parse_conjunction(),
399                )
400
401            return this
402
403        def _parse_placeholder(self) -> t.Optional[exp.Expression]:
404            """
405            Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
406            https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
407            """
408            if not self._match(TokenType.L_BRACE):
409                return None
410
411            this = self._parse_id_var()
412            self._match(TokenType.COLON)
413            kind = self._parse_types(check_func=False, allow_identifiers=False) or (
414                self._match_text_seq("IDENTIFIER") and "Identifier"
415            )
416
417            if not kind:
418                self.raise_error("Expecting a placeholder type or 'Identifier' for tables")
419            elif not self._match(TokenType.R_BRACE):
420                self.raise_error("Expecting }")
421
422            return self.expression(exp.Placeholder, this=this, kind=kind)
423
424        def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In:
425            this = super()._parse_in(this)
426            this.set("is_global", is_global)
427            return this
428
429        def _parse_table(
430            self,
431            schema: bool = False,
432            joins: bool = False,
433            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
434            parse_bracket: bool = False,
435            is_db_reference: bool = False,
436            parse_partition: bool = False,
437        ) -> t.Optional[exp.Expression]:
438            this = super()._parse_table(
439                schema=schema,
440                joins=joins,
441                alias_tokens=alias_tokens,
442                parse_bracket=parse_bracket,
443                is_db_reference=is_db_reference,
444            )
445
446            if self._match(TokenType.FINAL):
447                this = self.expression(exp.Final, this=this)
448
449            return this
450
451        def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
452            return super()._parse_position(haystack_first=True)
453
454        # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
455        def _parse_cte(self) -> exp.CTE:
456            # WITH <identifier> AS <subquery expression>
457            cte: t.Optional[exp.CTE] = self._try_parse(super()._parse_cte)
458
459            if not cte:
460                # WITH <expression> AS <identifier>
461                cte = self.expression(
462                    exp.CTE,
463                    this=self._parse_conjunction(),
464                    alias=self._parse_table_alias(),
465                    scalar=True,
466                )
467
468            return cte
469
470        def _parse_join_parts(
471            self,
472        ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
473            is_global = self._match(TokenType.GLOBAL) and self._prev
474            kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev
475
476            if kind_pre:
477                kind = self._match_set(self.JOIN_KINDS) and self._prev
478                side = self._match_set(self.JOIN_SIDES) and self._prev
479                return is_global, side, kind
480
481            return (
482                is_global,
483                self._match_set(self.JOIN_SIDES) and self._prev,
484                self._match_set(self.JOIN_KINDS) and self._prev,
485            )
486
487        def _parse_join(
488            self, skip_join_token: bool = False, parse_bracket: bool = False
489        ) -> t.Optional[exp.Join]:
490            join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True)
491            if join:
492                join.set("global", join.args.pop("method", None))
493
494            return join
495
496        def _parse_function(
497            self,
498            functions: t.Optional[t.Dict[str, t.Callable]] = None,
499            anonymous: bool = False,
500            optional_parens: bool = True,
501            any_token: bool = False,
502        ) -> t.Optional[exp.Expression]:
503            expr = super()._parse_function(
504                functions=functions,
505                anonymous=anonymous,
506                optional_parens=optional_parens,
507                any_token=any_token,
508            )
509
510            func = expr.this if isinstance(expr, exp.Window) else expr
511
512            # Aggregate functions can be split in 2 parts: <func_name><suffix>
513            parts = (
514                self.AGG_FUNC_MAPPING.get(func.this) if isinstance(func, exp.Anonymous) else None
515            )
516
517            if parts:
518                params = self._parse_func_params(func)
519
520                kwargs = {
521                    "this": func.this,
522                    "expressions": func.expressions,
523                }
524                if parts[1]:
525                    kwargs["parts"] = parts
526                    exp_class = exp.CombinedParameterizedAgg if params else exp.CombinedAggFunc
527                else:
528                    exp_class = exp.ParameterizedAgg if params else exp.AnonymousAggFunc
529
530                kwargs["exp_class"] = exp_class
531                if params:
532                    kwargs["params"] = params
533
534                func = self.expression(**kwargs)
535
536                if isinstance(expr, exp.Window):
537                    # The window's func was parsed as Anonymous in base parser, fix its
538                    # type to be CH style CombinedAnonymousAggFunc / AnonymousAggFunc
539                    expr.set("this", func)
540                elif params:
541                    # Params have blocked super()._parse_function() from parsing the following window
542                    # (if that exists) as they're standing between the function call and the window spec
543                    expr = self._parse_window(func)
544                else:
545                    expr = func
546
547            return expr
548
549        def _parse_func_params(
550            self, this: t.Optional[exp.Func] = None
551        ) -> t.Optional[t.List[exp.Expression]]:
552            if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
553                return self._parse_csv(self._parse_lambda)
554
555            if self._match(TokenType.L_PAREN):
556                params = self._parse_csv(self._parse_lambda)
557                self._match_r_paren(this)
558                return params
559
560            return None
561
562        def _parse_quantile(self) -> exp.Quantile:
563            this = self._parse_lambda()
564            params = self._parse_func_params()
565            if params:
566                return self.expression(exp.Quantile, this=params[0], quantile=this)
567            return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5))
568
569        def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
570            return super()._parse_wrapped_id_vars(optional=True)
571
572        def _parse_primary_key(
573            self, wrapped_optional: bool = False, in_props: bool = False
574        ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
575            return super()._parse_primary_key(
576                wrapped_optional=wrapped_optional or in_props, in_props=in_props
577            )
578
579        def _parse_on_property(self) -> t.Optional[exp.Expression]:
580            index = self._index
581            if self._match_text_seq("CLUSTER"):
582                this = self._parse_id_var()
583                if this:
584                    return self.expression(exp.OnCluster, this=this)
585                else:
586                    self._retreat(index)
587            return None
588
589        def _parse_index_constraint(
590            self, kind: t.Optional[str] = None
591        ) -> exp.IndexColumnConstraint:
592            # INDEX name1 expr TYPE type1(args) GRANULARITY value
593            this = self._parse_id_var()
594            expression = self._parse_conjunction()
595
596            index_type = self._match_text_seq("TYPE") and (
597                self._parse_function() or self._parse_var()
598            )
599
600            granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
601
602            return self.expression(
603                exp.IndexColumnConstraint,
604                this=this,
605                expression=expression,
606                index_type=index_type,
607                granularity=granularity,
608            )
609
610        def _parse_partition(self) -> t.Optional[exp.Partition]:
611            # https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#how-to-set-partition-expression
612            if not self._match(TokenType.PARTITION):
613                return None
614
615            if self._match_text_seq("ID"):
616                # Corresponds to the PARTITION ID <string_value> syntax
617                expressions: t.List[exp.Expression] = [
618                    self.expression(exp.PartitionId, this=self._parse_string())
619                ]
620            else:
621                expressions = self._parse_expressions()
622
623            return self.expression(exp.Partition, expressions=expressions)
624
625        def _parse_alter_table_replace(self) -> t.Optional[exp.Expression]:
626            partition = self._parse_partition()
627
628            if not partition or not self._match(TokenType.FROM):
629                return None
630
631            return self.expression(
632                exp.ReplacePartition, expression=partition, source=self._parse_table_parts()
633            )
634
635        def _parse_projection_def(self) -> t.Optional[exp.ProjectionDef]:
636            if not self._match_text_seq("PROJECTION"):
637                return None
638
639            return self.expression(
640                exp.ProjectionDef,
641                this=self._parse_id_var(),
642                expression=self._parse_wrapped(self._parse_statement),
643            )
644
645        def _parse_constraint(self) -> t.Optional[exp.Expression]:
646            return super()._parse_constraint() or self._parse_projection_def()
647
648    class Generator(generator.Generator):
649        QUERY_HINTS = False
650        STRUCT_DELIMITER = ("(", ")")
651        NVL2_SUPPORTED = False
652        TABLESAMPLE_REQUIRES_PARENS = False
653        TABLESAMPLE_SIZE_IS_ROWS = False
654        TABLESAMPLE_KEYWORDS = "SAMPLE"
655        LAST_DAY_SUPPORTS_DATE_PART = False
656        CAN_IMPLEMENT_ARRAY_ANY = True
657        SUPPORTS_TO_NUMBER = False
658
659        STRING_TYPE_MAPPING = {
660            exp.DataType.Type.CHAR: "String",
661            exp.DataType.Type.LONGBLOB: "String",
662            exp.DataType.Type.LONGTEXT: "String",
663            exp.DataType.Type.MEDIUMBLOB: "String",
664            exp.DataType.Type.MEDIUMTEXT: "String",
665            exp.DataType.Type.TINYBLOB: "String",
666            exp.DataType.Type.TINYTEXT: "String",
667            exp.DataType.Type.TEXT: "String",
668            exp.DataType.Type.VARBINARY: "String",
669            exp.DataType.Type.VARCHAR: "String",
670        }
671
672        SUPPORTED_JSON_PATH_PARTS = {
673            exp.JSONPathKey,
674            exp.JSONPathRoot,
675            exp.JSONPathSubscript,
676        }
677
678        TYPE_MAPPING = {
679            **generator.Generator.TYPE_MAPPING,
680            **STRING_TYPE_MAPPING,
681            exp.DataType.Type.ARRAY: "Array",
682            exp.DataType.Type.BIGINT: "Int64",
683            exp.DataType.Type.DATE32: "Date32",
684            exp.DataType.Type.DATETIME64: "DateTime64",
685            exp.DataType.Type.DOUBLE: "Float64",
686            exp.DataType.Type.ENUM: "Enum",
687            exp.DataType.Type.ENUM8: "Enum8",
688            exp.DataType.Type.ENUM16: "Enum16",
689            exp.DataType.Type.FIXEDSTRING: "FixedString",
690            exp.DataType.Type.FLOAT: "Float32",
691            exp.DataType.Type.INT: "Int32",
692            exp.DataType.Type.MEDIUMINT: "Int32",
693            exp.DataType.Type.INT128: "Int128",
694            exp.DataType.Type.INT256: "Int256",
695            exp.DataType.Type.LOWCARDINALITY: "LowCardinality",
696            exp.DataType.Type.MAP: "Map",
697            exp.DataType.Type.NESTED: "Nested",
698            exp.DataType.Type.NULLABLE: "Nullable",
699            exp.DataType.Type.SMALLINT: "Int16",
700            exp.DataType.Type.STRUCT: "Tuple",
701            exp.DataType.Type.TINYINT: "Int8",
702            exp.DataType.Type.UBIGINT: "UInt64",
703            exp.DataType.Type.UINT: "UInt32",
704            exp.DataType.Type.UINT128: "UInt128",
705            exp.DataType.Type.UINT256: "UInt256",
706            exp.DataType.Type.USMALLINT: "UInt16",
707            exp.DataType.Type.UTINYINT: "UInt8",
708            exp.DataType.Type.IPV4: "IPv4",
709            exp.DataType.Type.IPV6: "IPv6",
710            exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction",
711            exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction",
712        }
713
714        TRANSFORMS = {
715            **generator.Generator.TRANSFORMS,
716            exp.AnyValue: rename_func("any"),
717            exp.ApproxDistinct: rename_func("uniq"),
718            exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this),
719            exp.ArraySize: rename_func("LENGTH"),
720            exp.ArraySum: rename_func("arraySum"),
721            exp.ArgMax: arg_max_or_min_no_count("argMax"),
722            exp.ArgMin: arg_max_or_min_no_count("argMin"),
723            exp.Array: inline_array_sql,
724            exp.CastToStrType: rename_func("CAST"),
725            exp.CountIf: rename_func("countIf"),
726            exp.CompressColumnConstraint: lambda self,
727            e: f"CODEC({self.expressions(e, key='this', flat=True)})",
728            exp.ComputedColumnConstraint: lambda self,
729            e: f"{'MATERIALIZED' if e.args.get('persisted') else 'ALIAS'} {self.sql(e, 'this')}",
730            exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"),
731            exp.DateAdd: date_delta_sql("DATE_ADD"),
732            exp.DateDiff: date_delta_sql("DATE_DIFF"),
733            exp.Explode: rename_func("arrayJoin"),
734            exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL",
735            exp.IsNan: rename_func("isNaN"),
736            exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False),
737            exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False),
738            exp.JSONPathKey: json_path_key_only_name,
739            exp.JSONPathRoot: lambda *_: "",
740            exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)),
741            exp.Nullif: rename_func("nullIf"),
742            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
743            exp.Pivot: no_pivot_sql,
744            exp.Quantile: _quantile_sql,
745            exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression),
746            exp.Rand: rename_func("randCanonical"),
747            exp.Select: transforms.preprocess([transforms.eliminate_qualify]),
748            exp.StartsWith: rename_func("startsWith"),
749            exp.StrPosition: lambda self, e: self.func(
750                "position", e.this, e.args.get("substr"), e.args.get("position")
751            ),
752            exp.TimeToStr: lambda self, e: self.func(
753                "DATE_FORMAT", e.this, self.format_time(e), e.args.get("timezone")
754            ),
755            exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)),
756            exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions),
757            exp.MD5Digest: rename_func("MD5"),
758            exp.MD5: lambda self, e: self.func("LOWER", self.func("HEX", self.func("MD5", e.this))),
759            exp.SHA: rename_func("SHA1"),
760            exp.SHA2: lambda self, e: self.func(
761                "SHA256" if e.text("length") == "256" else "SHA512", e.this
762            ),
763            exp.UnixToTime: _unix_to_time_sql,
764        }
765
766        PROPERTIES_LOCATION = {
767            **generator.Generator.PROPERTIES_LOCATION,
768            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
769            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
770            exp.OnCluster: exp.Properties.Location.POST_NAME,
771        }
772
773        JOIN_HINTS = False
774        TABLE_HINTS = False
775        EXPLICIT_UNION = True
776        GROUPINGS_SEP = ""
777        OUTER_UNION_MODIFIERS = False
778
779        # there's no list in docs, but it can be found in Clickhouse code
780        # see `ClickHouse/src/Parsers/ParserCreate*.cpp`
781        ON_CLUSTER_TARGETS = {
782            "DATABASE",
783            "TABLE",
784            "VIEW",
785            "DICTIONARY",
786            "INDEX",
787            "FUNCTION",
788            "NAMED COLLECTION",
789        }
790
791        def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str:
792            this = self.json_path_part(expression.this)
793            return str(int(this) + 1) if is_int(this) else this
794
795        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
796            return f"AS {self.sql(expression, 'this')}"
797
798        def _any_to_has(
799            self,
800            expression: exp.EQ | exp.NEQ,
801            default: t.Callable[[t.Any], str],
802            prefix: str = "",
803        ) -> str:
804            if isinstance(expression.left, exp.Any):
805                arr = expression.left
806                this = expression.right
807            elif isinstance(expression.right, exp.Any):
808                arr = expression.right
809                this = expression.left
810            else:
811                return default(expression)
812
813            return prefix + self.func("has", arr.this.unnest(), this)
814
815        def eq_sql(self, expression: exp.EQ) -> str:
816            return self._any_to_has(expression, super().eq_sql)
817
818        def neq_sql(self, expression: exp.NEQ) -> str:
819            return self._any_to_has(expression, super().neq_sql, "NOT ")
820
821        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
822            # Manually add a flag to make the search case-insensitive
823            regex = self.func("CONCAT", "'(?i)'", expression.expression)
824            return self.func("match", expression.this, regex)
825
826        def datatype_sql(self, expression: exp.DataType) -> str:
827            # String is the standard ClickHouse type, every other variant is just an alias.
828            # Additionally, any supplied length parameter will be ignored.
829            #
830            # https://clickhouse.com/docs/en/sql-reference/data-types/string
831            if expression.this in self.STRING_TYPE_MAPPING:
832                return "String"
833
834            return super().datatype_sql(expression)
835
836        def cte_sql(self, expression: exp.CTE) -> str:
837            if expression.args.get("scalar"):
838                this = self.sql(expression, "this")
839                alias = self.sql(expression, "alias")
840                return f"{this} AS {alias}"
841
842            return super().cte_sql(expression)
843
844        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
845            return super().after_limit_modifiers(expression) + [
846                (
847                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
848                    if expression.args.get("settings")
849                    else ""
850                ),
851                (
852                    self.seg("FORMAT ") + self.sql(expression, "format")
853                    if expression.args.get("format")
854                    else ""
855                ),
856            ]
857
858        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
859            params = self.expressions(expression, key="params", flat=True)
860            return self.func(expression.name, *expression.expressions) + f"({params})"
861
862        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
863            return self.func(expression.name, *expression.expressions)
864
865        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
866            return self.anonymousaggfunc_sql(expression)
867
868        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
869            return self.parameterizedagg_sql(expression)
870
871        def placeholder_sql(self, expression: exp.Placeholder) -> str:
872            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
873
874        def oncluster_sql(self, expression: exp.OnCluster) -> str:
875            return f"ON CLUSTER {self.sql(expression, 'this')}"
876
877        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
878            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
879                exp.Properties.Location.POST_NAME
880            ):
881                this_name = self.sql(expression.this, "this")
882                this_properties = " ".join(
883                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
884                )
885                this_schema = self.schema_columns_sql(expression.this)
886                return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}"
887
888            return super().createable_sql(expression, locations)
889
890        def prewhere_sql(self, expression: exp.PreWhere) -> str:
891            this = self.indent(self.sql(expression, "this"))
892            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
893
894        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
895            this = self.sql(expression, "this")
896            this = f" {this}" if this else ""
897            expr = self.sql(expression, "expression")
898            expr = f" {expr}" if expr else ""
899            index_type = self.sql(expression, "index_type")
900            index_type = f" TYPE {index_type}" if index_type else ""
901            granularity = self.sql(expression, "granularity")
902            granularity = f" GRANULARITY {granularity}" if granularity else ""
903
904            return f"INDEX{this}{expr}{index_type}{granularity}"
905
906        def partition_sql(self, expression: exp.Partition) -> str:
907            return f"PARTITION {self.expressions(expression, flat=True)}"
908
909        def partitionid_sql(self, expression: exp.PartitionId) -> str:
910            return f"ID {self.sql(expression.this)}"
911
912        def replacepartition_sql(self, expression: exp.ReplacePartition) -> str:
913            return (
914                f"REPLACE {self.sql(expression.expression)} FROM {self.sql(expression, 'source')}"
915            )
916
917        def projectiondef_sql(self, expression: exp.ProjectionDef) -> str:
918            return f"PROJECTION {self.sql(expression.this)} {self.wrap(expression.expression)}"
class ClickHouse(sqlglot.dialects.dialect.Dialect):
 79class ClickHouse(Dialect):
 80    NORMALIZE_FUNCTIONS: bool | str = False
 81    NULL_ORDERING = "nulls_are_last"
 82    SUPPORTS_USER_DEFINED_TYPES = False
 83    SAFE_DIVISION = True
 84    LOG_BASE_FIRST: t.Optional[bool] = None
 85
 86    UNESCAPED_SEQUENCES = {
 87        "\\0": "\0",
 88    }
 89
 90    class Tokenizer(tokens.Tokenizer):
 91        COMMENTS = ["--", "#", "#!", ("/*", "*/")]
 92        IDENTIFIERS = ['"', "`"]
 93        STRING_ESCAPES = ["'", "\\"]
 94        BIT_STRINGS = [("0b", "")]
 95        HEX_STRINGS = [("0x", ""), ("0X", "")]
 96        HEREDOC_STRINGS = ["$"]
 97
 98        KEYWORDS = {
 99            **tokens.Tokenizer.KEYWORDS,
100            "ATTACH": TokenType.COMMAND,
101            "DATE32": TokenType.DATE32,
102            "DATETIME64": TokenType.DATETIME64,
103            "DICTIONARY": TokenType.DICTIONARY,
104            "ENUM8": TokenType.ENUM8,
105            "ENUM16": TokenType.ENUM16,
106            "FINAL": TokenType.FINAL,
107            "FIXEDSTRING": TokenType.FIXEDSTRING,
108            "FLOAT32": TokenType.FLOAT,
109            "FLOAT64": TokenType.DOUBLE,
110            "GLOBAL": TokenType.GLOBAL,
111            "INT256": TokenType.INT256,
112            "LOWCARDINALITY": TokenType.LOWCARDINALITY,
113            "MAP": TokenType.MAP,
114            "NESTED": TokenType.NESTED,
115            "SAMPLE": TokenType.TABLE_SAMPLE,
116            "TUPLE": TokenType.STRUCT,
117            "UINT128": TokenType.UINT128,
118            "UINT16": TokenType.USMALLINT,
119            "UINT256": TokenType.UINT256,
120            "UINT32": TokenType.UINT,
121            "UINT64": TokenType.UBIGINT,
122            "UINT8": TokenType.UTINYINT,
123            "IPV4": TokenType.IPV4,
124            "IPV6": TokenType.IPV6,
125            "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION,
126            "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION,
127            "SYSTEM": TokenType.COMMAND,
128            "PREWHERE": TokenType.PREWHERE,
129        }
130
131        SINGLE_TOKENS = {
132            **tokens.Tokenizer.SINGLE_TOKENS,
133            "$": TokenType.HEREDOC_STRING,
134        }
135
136    class Parser(parser.Parser):
137        # Tested in ClickHouse's playground, it seems that the following two queries do the same thing
138        # * select x from t1 union all select x from t2 limit 1;
139        # * select x from t1 union all (select x from t2 limit 1);
140        MODIFIERS_ATTACHED_TO_UNION = False
141        INTERVAL_SPANS = False
142
143        FUNCTIONS = {
144            **parser.Parser.FUNCTIONS,
145            "ANY": exp.AnyValue.from_arg_list,
146            "ARRAYSUM": exp.ArraySum.from_arg_list,
147            "COUNTIF": _build_count_if,
148            "DATE_ADD": lambda args: exp.DateAdd(
149                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
150            ),
151            "DATEADD": lambda args: exp.DateAdd(
152                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
153            ),
154            "DATE_DIFF": lambda args: exp.DateDiff(
155                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
156            ),
157            "DATEDIFF": lambda args: exp.DateDiff(
158                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
159            ),
160            "DATE_FORMAT": _build_date_format,
161            "FORMATDATETIME": _build_date_format,
162            "JSONEXTRACTSTRING": build_json_extract_path(
163                exp.JSONExtractScalar, zero_based_indexing=False
164            ),
165            "MAP": parser.build_var_map,
166            "MATCH": exp.RegexpLike.from_arg_list,
167            "RANDCANONICAL": exp.Rand.from_arg_list,
168            "TUPLE": exp.Struct.from_arg_list,
169            "UNIQ": exp.ApproxDistinct.from_arg_list,
170            "XOR": lambda args: exp.Xor(expressions=args),
171            "MD5": exp.MD5Digest.from_arg_list,
172            "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
173            "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
174        }
175
176        AGG_FUNCTIONS = {
177            "count",
178            "min",
179            "max",
180            "sum",
181            "avg",
182            "any",
183            "stddevPop",
184            "stddevSamp",
185            "varPop",
186            "varSamp",
187            "corr",
188            "covarPop",
189            "covarSamp",
190            "entropy",
191            "exponentialMovingAverage",
192            "intervalLengthSum",
193            "kolmogorovSmirnovTest",
194            "mannWhitneyUTest",
195            "median",
196            "rankCorr",
197            "sumKahan",
198            "studentTTest",
199            "welchTTest",
200            "anyHeavy",
201            "anyLast",
202            "boundingRatio",
203            "first_value",
204            "last_value",
205            "argMin",
206            "argMax",
207            "avgWeighted",
208            "topK",
209            "topKWeighted",
210            "deltaSum",
211            "deltaSumTimestamp",
212            "groupArray",
213            "groupArrayLast",
214            "groupUniqArray",
215            "groupArrayInsertAt",
216            "groupArrayMovingAvg",
217            "groupArrayMovingSum",
218            "groupArraySample",
219            "groupBitAnd",
220            "groupBitOr",
221            "groupBitXor",
222            "groupBitmap",
223            "groupBitmapAnd",
224            "groupBitmapOr",
225            "groupBitmapXor",
226            "sumWithOverflow",
227            "sumMap",
228            "minMap",
229            "maxMap",
230            "skewSamp",
231            "skewPop",
232            "kurtSamp",
233            "kurtPop",
234            "uniq",
235            "uniqExact",
236            "uniqCombined",
237            "uniqCombined64",
238            "uniqHLL12",
239            "uniqTheta",
240            "quantile",
241            "quantiles",
242            "quantileExact",
243            "quantilesExact",
244            "quantileExactLow",
245            "quantilesExactLow",
246            "quantileExactHigh",
247            "quantilesExactHigh",
248            "quantileExactWeighted",
249            "quantilesExactWeighted",
250            "quantileTiming",
251            "quantilesTiming",
252            "quantileTimingWeighted",
253            "quantilesTimingWeighted",
254            "quantileDeterministic",
255            "quantilesDeterministic",
256            "quantileTDigest",
257            "quantilesTDigest",
258            "quantileTDigestWeighted",
259            "quantilesTDigestWeighted",
260            "quantileBFloat16",
261            "quantilesBFloat16",
262            "quantileBFloat16Weighted",
263            "quantilesBFloat16Weighted",
264            "simpleLinearRegression",
265            "stochasticLinearRegression",
266            "stochasticLogisticRegression",
267            "categoricalInformationValue",
268            "contingency",
269            "cramersV",
270            "cramersVBiasCorrected",
271            "theilsU",
272            "maxIntersections",
273            "maxIntersectionsPosition",
274            "meanZTest",
275            "quantileInterpolatedWeighted",
276            "quantilesInterpolatedWeighted",
277            "quantileGK",
278            "quantilesGK",
279            "sparkBar",
280            "sumCount",
281            "largestTriangleThreeBuckets",
282            "histogram",
283            "sequenceMatch",
284            "sequenceCount",
285            "windowFunnel",
286            "retention",
287            "uniqUpTo",
288            "sequenceNextNode",
289            "exponentialTimeDecayedAvg",
290        }
291
292        AGG_FUNCTIONS_SUFFIXES = [
293            "If",
294            "Array",
295            "ArrayIf",
296            "Map",
297            "SimpleState",
298            "State",
299            "Merge",
300            "MergeState",
301            "ForEach",
302            "Distinct",
303            "OrDefault",
304            "OrNull",
305            "Resample",
306            "ArgMin",
307            "ArgMax",
308        ]
309
310        FUNC_TOKENS = {
311            *parser.Parser.FUNC_TOKENS,
312            TokenType.SET,
313        }
314
315        AGG_FUNC_MAPPING = (
316            lambda functions, suffixes: {
317                f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions
318            }
319        )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES)
320
321        FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"}
322
323        FUNCTION_PARSERS = {
324            **parser.Parser.FUNCTION_PARSERS,
325            "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()),
326            "QUANTILE": lambda self: self._parse_quantile(),
327        }
328
329        FUNCTION_PARSERS.pop("MATCH")
330
331        NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy()
332        NO_PAREN_FUNCTION_PARSERS.pop("ANY")
333
334        RANGE_PARSERS = {
335            **parser.Parser.RANGE_PARSERS,
336            TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN)
337            and self._parse_in(this, is_global=True),
338        }
339
340        # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to
341        # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler.
342        COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy()
343        COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
344
345        JOIN_KINDS = {
346            *parser.Parser.JOIN_KINDS,
347            TokenType.ANY,
348            TokenType.ASOF,
349            TokenType.ARRAY,
350        }
351
352        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
353            TokenType.ANY,
354            TokenType.ARRAY,
355            TokenType.FINAL,
356            TokenType.FORMAT,
357            TokenType.SETTINGS,
358        }
359
360        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
361            TokenType.FORMAT,
362        }
363
364        LOG_DEFAULTS_TO_LN = True
365
366        QUERY_MODIFIER_PARSERS = {
367            **parser.Parser.QUERY_MODIFIER_PARSERS,
368            TokenType.SETTINGS: lambda self: (
369                "settings",
370                self._advance() or self._parse_csv(self._parse_conjunction),
371            ),
372            TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
373        }
374
375        CONSTRAINT_PARSERS = {
376            **parser.Parser.CONSTRAINT_PARSERS,
377            "INDEX": lambda self: self._parse_index_constraint(),
378            "CODEC": lambda self: self._parse_compress(),
379        }
380
381        ALTER_PARSERS = {
382            **parser.Parser.ALTER_PARSERS,
383            "REPLACE": lambda self: self._parse_alter_table_replace(),
384        }
385
386        SCHEMA_UNNAMED_CONSTRAINTS = {
387            *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
388            "INDEX",
389        }
390
391        def _parse_conjunction(self) -> t.Optional[exp.Expression]:
392            this = super()._parse_conjunction()
393
394            if self._match(TokenType.PLACEHOLDER):
395                return self.expression(
396                    exp.If,
397                    this=this,
398                    true=self._parse_conjunction(),
399                    false=self._match(TokenType.COLON) and self._parse_conjunction(),
400                )
401
402            return this
403
404        def _parse_placeholder(self) -> t.Optional[exp.Expression]:
405            """
406            Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
407            https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
408            """
409            if not self._match(TokenType.L_BRACE):
410                return None
411
412            this = self._parse_id_var()
413            self._match(TokenType.COLON)
414            kind = self._parse_types(check_func=False, allow_identifiers=False) or (
415                self._match_text_seq("IDENTIFIER") and "Identifier"
416            )
417
418            if not kind:
419                self.raise_error("Expecting a placeholder type or 'Identifier' for tables")
420            elif not self._match(TokenType.R_BRACE):
421                self.raise_error("Expecting }")
422
423            return self.expression(exp.Placeholder, this=this, kind=kind)
424
425        def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In:
426            this = super()._parse_in(this)
427            this.set("is_global", is_global)
428            return this
429
430        def _parse_table(
431            self,
432            schema: bool = False,
433            joins: bool = False,
434            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
435            parse_bracket: bool = False,
436            is_db_reference: bool = False,
437            parse_partition: bool = False,
438        ) -> t.Optional[exp.Expression]:
439            this = super()._parse_table(
440                schema=schema,
441                joins=joins,
442                alias_tokens=alias_tokens,
443                parse_bracket=parse_bracket,
444                is_db_reference=is_db_reference,
445            )
446
447            if self._match(TokenType.FINAL):
448                this = self.expression(exp.Final, this=this)
449
450            return this
451
452        def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
453            return super()._parse_position(haystack_first=True)
454
455        # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
456        def _parse_cte(self) -> exp.CTE:
457            # WITH <identifier> AS <subquery expression>
458            cte: t.Optional[exp.CTE] = self._try_parse(super()._parse_cte)
459
460            if not cte:
461                # WITH <expression> AS <identifier>
462                cte = self.expression(
463                    exp.CTE,
464                    this=self._parse_conjunction(),
465                    alias=self._parse_table_alias(),
466                    scalar=True,
467                )
468
469            return cte
470
471        def _parse_join_parts(
472            self,
473        ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
474            is_global = self._match(TokenType.GLOBAL) and self._prev
475            kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev
476
477            if kind_pre:
478                kind = self._match_set(self.JOIN_KINDS) and self._prev
479                side = self._match_set(self.JOIN_SIDES) and self._prev
480                return is_global, side, kind
481
482            return (
483                is_global,
484                self._match_set(self.JOIN_SIDES) and self._prev,
485                self._match_set(self.JOIN_KINDS) and self._prev,
486            )
487
488        def _parse_join(
489            self, skip_join_token: bool = False, parse_bracket: bool = False
490        ) -> t.Optional[exp.Join]:
491            join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True)
492            if join:
493                join.set("global", join.args.pop("method", None))
494
495            return join
496
497        def _parse_function(
498            self,
499            functions: t.Optional[t.Dict[str, t.Callable]] = None,
500            anonymous: bool = False,
501            optional_parens: bool = True,
502            any_token: bool = False,
503        ) -> t.Optional[exp.Expression]:
504            expr = super()._parse_function(
505                functions=functions,
506                anonymous=anonymous,
507                optional_parens=optional_parens,
508                any_token=any_token,
509            )
510
511            func = expr.this if isinstance(expr, exp.Window) else expr
512
513            # Aggregate functions can be split in 2 parts: <func_name><suffix>
514            parts = (
515                self.AGG_FUNC_MAPPING.get(func.this) if isinstance(func, exp.Anonymous) else None
516            )
517
518            if parts:
519                params = self._parse_func_params(func)
520
521                kwargs = {
522                    "this": func.this,
523                    "expressions": func.expressions,
524                }
525                if parts[1]:
526                    kwargs["parts"] = parts
527                    exp_class = exp.CombinedParameterizedAgg if params else exp.CombinedAggFunc
528                else:
529                    exp_class = exp.ParameterizedAgg if params else exp.AnonymousAggFunc
530
531                kwargs["exp_class"] = exp_class
532                if params:
533                    kwargs["params"] = params
534
535                func = self.expression(**kwargs)
536
537                if isinstance(expr, exp.Window):
538                    # The window's func was parsed as Anonymous in base parser, fix its
539                    # type to be CH style CombinedAnonymousAggFunc / AnonymousAggFunc
540                    expr.set("this", func)
541                elif params:
542                    # Params have blocked super()._parse_function() from parsing the following window
543                    # (if that exists) as they're standing between the function call and the window spec
544                    expr = self._parse_window(func)
545                else:
546                    expr = func
547
548            return expr
549
550        def _parse_func_params(
551            self, this: t.Optional[exp.Func] = None
552        ) -> t.Optional[t.List[exp.Expression]]:
553            if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
554                return self._parse_csv(self._parse_lambda)
555
556            if self._match(TokenType.L_PAREN):
557                params = self._parse_csv(self._parse_lambda)
558                self._match_r_paren(this)
559                return params
560
561            return None
562
563        def _parse_quantile(self) -> exp.Quantile:
564            this = self._parse_lambda()
565            params = self._parse_func_params()
566            if params:
567                return self.expression(exp.Quantile, this=params[0], quantile=this)
568            return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5))
569
570        def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
571            return super()._parse_wrapped_id_vars(optional=True)
572
573        def _parse_primary_key(
574            self, wrapped_optional: bool = False, in_props: bool = False
575        ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
576            return super()._parse_primary_key(
577                wrapped_optional=wrapped_optional or in_props, in_props=in_props
578            )
579
580        def _parse_on_property(self) -> t.Optional[exp.Expression]:
581            index = self._index
582            if self._match_text_seq("CLUSTER"):
583                this = self._parse_id_var()
584                if this:
585                    return self.expression(exp.OnCluster, this=this)
586                else:
587                    self._retreat(index)
588            return None
589
590        def _parse_index_constraint(
591            self, kind: t.Optional[str] = None
592        ) -> exp.IndexColumnConstraint:
593            # INDEX name1 expr TYPE type1(args) GRANULARITY value
594            this = self._parse_id_var()
595            expression = self._parse_conjunction()
596
597            index_type = self._match_text_seq("TYPE") and (
598                self._parse_function() or self._parse_var()
599            )
600
601            granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
602
603            return self.expression(
604                exp.IndexColumnConstraint,
605                this=this,
606                expression=expression,
607                index_type=index_type,
608                granularity=granularity,
609            )
610
611        def _parse_partition(self) -> t.Optional[exp.Partition]:
612            # https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#how-to-set-partition-expression
613            if not self._match(TokenType.PARTITION):
614                return None
615
616            if self._match_text_seq("ID"):
617                # Corresponds to the PARTITION ID <string_value> syntax
618                expressions: t.List[exp.Expression] = [
619                    self.expression(exp.PartitionId, this=self._parse_string())
620                ]
621            else:
622                expressions = self._parse_expressions()
623
624            return self.expression(exp.Partition, expressions=expressions)
625
626        def _parse_alter_table_replace(self) -> t.Optional[exp.Expression]:
627            partition = self._parse_partition()
628
629            if not partition or not self._match(TokenType.FROM):
630                return None
631
632            return self.expression(
633                exp.ReplacePartition, expression=partition, source=self._parse_table_parts()
634            )
635
636        def _parse_projection_def(self) -> t.Optional[exp.ProjectionDef]:
637            if not self._match_text_seq("PROJECTION"):
638                return None
639
640            return self.expression(
641                exp.ProjectionDef,
642                this=self._parse_id_var(),
643                expression=self._parse_wrapped(self._parse_statement),
644            )
645
646        def _parse_constraint(self) -> t.Optional[exp.Expression]:
647            return super()._parse_constraint() or self._parse_projection_def()
648
649    class Generator(generator.Generator):
650        QUERY_HINTS = False
651        STRUCT_DELIMITER = ("(", ")")
652        NVL2_SUPPORTED = False
653        TABLESAMPLE_REQUIRES_PARENS = False
654        TABLESAMPLE_SIZE_IS_ROWS = False
655        TABLESAMPLE_KEYWORDS = "SAMPLE"
656        LAST_DAY_SUPPORTS_DATE_PART = False
657        CAN_IMPLEMENT_ARRAY_ANY = True
658        SUPPORTS_TO_NUMBER = False
659
660        STRING_TYPE_MAPPING = {
661            exp.DataType.Type.CHAR: "String",
662            exp.DataType.Type.LONGBLOB: "String",
663            exp.DataType.Type.LONGTEXT: "String",
664            exp.DataType.Type.MEDIUMBLOB: "String",
665            exp.DataType.Type.MEDIUMTEXT: "String",
666            exp.DataType.Type.TINYBLOB: "String",
667            exp.DataType.Type.TINYTEXT: "String",
668            exp.DataType.Type.TEXT: "String",
669            exp.DataType.Type.VARBINARY: "String",
670            exp.DataType.Type.VARCHAR: "String",
671        }
672
673        SUPPORTED_JSON_PATH_PARTS = {
674            exp.JSONPathKey,
675            exp.JSONPathRoot,
676            exp.JSONPathSubscript,
677        }
678
679        TYPE_MAPPING = {
680            **generator.Generator.TYPE_MAPPING,
681            **STRING_TYPE_MAPPING,
682            exp.DataType.Type.ARRAY: "Array",
683            exp.DataType.Type.BIGINT: "Int64",
684            exp.DataType.Type.DATE32: "Date32",
685            exp.DataType.Type.DATETIME64: "DateTime64",
686            exp.DataType.Type.DOUBLE: "Float64",
687            exp.DataType.Type.ENUM: "Enum",
688            exp.DataType.Type.ENUM8: "Enum8",
689            exp.DataType.Type.ENUM16: "Enum16",
690            exp.DataType.Type.FIXEDSTRING: "FixedString",
691            exp.DataType.Type.FLOAT: "Float32",
692            exp.DataType.Type.INT: "Int32",
693            exp.DataType.Type.MEDIUMINT: "Int32",
694            exp.DataType.Type.INT128: "Int128",
695            exp.DataType.Type.INT256: "Int256",
696            exp.DataType.Type.LOWCARDINALITY: "LowCardinality",
697            exp.DataType.Type.MAP: "Map",
698            exp.DataType.Type.NESTED: "Nested",
699            exp.DataType.Type.NULLABLE: "Nullable",
700            exp.DataType.Type.SMALLINT: "Int16",
701            exp.DataType.Type.STRUCT: "Tuple",
702            exp.DataType.Type.TINYINT: "Int8",
703            exp.DataType.Type.UBIGINT: "UInt64",
704            exp.DataType.Type.UINT: "UInt32",
705            exp.DataType.Type.UINT128: "UInt128",
706            exp.DataType.Type.UINT256: "UInt256",
707            exp.DataType.Type.USMALLINT: "UInt16",
708            exp.DataType.Type.UTINYINT: "UInt8",
709            exp.DataType.Type.IPV4: "IPv4",
710            exp.DataType.Type.IPV6: "IPv6",
711            exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction",
712            exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction",
713        }
714
715        TRANSFORMS = {
716            **generator.Generator.TRANSFORMS,
717            exp.AnyValue: rename_func("any"),
718            exp.ApproxDistinct: rename_func("uniq"),
719            exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this),
720            exp.ArraySize: rename_func("LENGTH"),
721            exp.ArraySum: rename_func("arraySum"),
722            exp.ArgMax: arg_max_or_min_no_count("argMax"),
723            exp.ArgMin: arg_max_or_min_no_count("argMin"),
724            exp.Array: inline_array_sql,
725            exp.CastToStrType: rename_func("CAST"),
726            exp.CountIf: rename_func("countIf"),
727            exp.CompressColumnConstraint: lambda self,
728            e: f"CODEC({self.expressions(e, key='this', flat=True)})",
729            exp.ComputedColumnConstraint: lambda self,
730            e: f"{'MATERIALIZED' if e.args.get('persisted') else 'ALIAS'} {self.sql(e, 'this')}",
731            exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"),
732            exp.DateAdd: date_delta_sql("DATE_ADD"),
733            exp.DateDiff: date_delta_sql("DATE_DIFF"),
734            exp.Explode: rename_func("arrayJoin"),
735            exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL",
736            exp.IsNan: rename_func("isNaN"),
737            exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False),
738            exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False),
739            exp.JSONPathKey: json_path_key_only_name,
740            exp.JSONPathRoot: lambda *_: "",
741            exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)),
742            exp.Nullif: rename_func("nullIf"),
743            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
744            exp.Pivot: no_pivot_sql,
745            exp.Quantile: _quantile_sql,
746            exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression),
747            exp.Rand: rename_func("randCanonical"),
748            exp.Select: transforms.preprocess([transforms.eliminate_qualify]),
749            exp.StartsWith: rename_func("startsWith"),
750            exp.StrPosition: lambda self, e: self.func(
751                "position", e.this, e.args.get("substr"), e.args.get("position")
752            ),
753            exp.TimeToStr: lambda self, e: self.func(
754                "DATE_FORMAT", e.this, self.format_time(e), e.args.get("timezone")
755            ),
756            exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)),
757            exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions),
758            exp.MD5Digest: rename_func("MD5"),
759            exp.MD5: lambda self, e: self.func("LOWER", self.func("HEX", self.func("MD5", e.this))),
760            exp.SHA: rename_func("SHA1"),
761            exp.SHA2: lambda self, e: self.func(
762                "SHA256" if e.text("length") == "256" else "SHA512", e.this
763            ),
764            exp.UnixToTime: _unix_to_time_sql,
765        }
766
767        PROPERTIES_LOCATION = {
768            **generator.Generator.PROPERTIES_LOCATION,
769            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
770            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
771            exp.OnCluster: exp.Properties.Location.POST_NAME,
772        }
773
774        JOIN_HINTS = False
775        TABLE_HINTS = False
776        EXPLICIT_UNION = True
777        GROUPINGS_SEP = ""
778        OUTER_UNION_MODIFIERS = False
779
780        # there's no list in docs, but it can be found in Clickhouse code
781        # see `ClickHouse/src/Parsers/ParserCreate*.cpp`
782        ON_CLUSTER_TARGETS = {
783            "DATABASE",
784            "TABLE",
785            "VIEW",
786            "DICTIONARY",
787            "INDEX",
788            "FUNCTION",
789            "NAMED COLLECTION",
790        }
791
792        def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str:
793            this = self.json_path_part(expression.this)
794            return str(int(this) + 1) if is_int(this) else this
795
796        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
797            return f"AS {self.sql(expression, 'this')}"
798
799        def _any_to_has(
800            self,
801            expression: exp.EQ | exp.NEQ,
802            default: t.Callable[[t.Any], str],
803            prefix: str = "",
804        ) -> str:
805            if isinstance(expression.left, exp.Any):
806                arr = expression.left
807                this = expression.right
808            elif isinstance(expression.right, exp.Any):
809                arr = expression.right
810                this = expression.left
811            else:
812                return default(expression)
813
814            return prefix + self.func("has", arr.this.unnest(), this)
815
816        def eq_sql(self, expression: exp.EQ) -> str:
817            return self._any_to_has(expression, super().eq_sql)
818
819        def neq_sql(self, expression: exp.NEQ) -> str:
820            return self._any_to_has(expression, super().neq_sql, "NOT ")
821
822        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
823            # Manually add a flag to make the search case-insensitive
824            regex = self.func("CONCAT", "'(?i)'", expression.expression)
825            return self.func("match", expression.this, regex)
826
827        def datatype_sql(self, expression: exp.DataType) -> str:
828            # String is the standard ClickHouse type, every other variant is just an alias.
829            # Additionally, any supplied length parameter will be ignored.
830            #
831            # https://clickhouse.com/docs/en/sql-reference/data-types/string
832            if expression.this in self.STRING_TYPE_MAPPING:
833                return "String"
834
835            return super().datatype_sql(expression)
836
837        def cte_sql(self, expression: exp.CTE) -> str:
838            if expression.args.get("scalar"):
839                this = self.sql(expression, "this")
840                alias = self.sql(expression, "alias")
841                return f"{this} AS {alias}"
842
843            return super().cte_sql(expression)
844
845        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
846            return super().after_limit_modifiers(expression) + [
847                (
848                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
849                    if expression.args.get("settings")
850                    else ""
851                ),
852                (
853                    self.seg("FORMAT ") + self.sql(expression, "format")
854                    if expression.args.get("format")
855                    else ""
856                ),
857            ]
858
859        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
860            params = self.expressions(expression, key="params", flat=True)
861            return self.func(expression.name, *expression.expressions) + f"({params})"
862
863        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
864            return self.func(expression.name, *expression.expressions)
865
866        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
867            return self.anonymousaggfunc_sql(expression)
868
869        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
870            return self.parameterizedagg_sql(expression)
871
872        def placeholder_sql(self, expression: exp.Placeholder) -> str:
873            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
874
875        def oncluster_sql(self, expression: exp.OnCluster) -> str:
876            return f"ON CLUSTER {self.sql(expression, 'this')}"
877
878        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
879            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
880                exp.Properties.Location.POST_NAME
881            ):
882                this_name = self.sql(expression.this, "this")
883                this_properties = " ".join(
884                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
885                )
886                this_schema = self.schema_columns_sql(expression.this)
887                return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}"
888
889            return super().createable_sql(expression, locations)
890
891        def prewhere_sql(self, expression: exp.PreWhere) -> str:
892            this = self.indent(self.sql(expression, "this"))
893            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
894
895        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
896            this = self.sql(expression, "this")
897            this = f" {this}" if this else ""
898            expr = self.sql(expression, "expression")
899            expr = f" {expr}" if expr else ""
900            index_type = self.sql(expression, "index_type")
901            index_type = f" TYPE {index_type}" if index_type else ""
902            granularity = self.sql(expression, "granularity")
903            granularity = f" GRANULARITY {granularity}" if granularity else ""
904
905            return f"INDEX{this}{expr}{index_type}{granularity}"
906
907        def partition_sql(self, expression: exp.Partition) -> str:
908            return f"PARTITION {self.expressions(expression, flat=True)}"
909
910        def partitionid_sql(self, expression: exp.PartitionId) -> str:
911            return f"ID {self.sql(expression.this)}"
912
913        def replacepartition_sql(self, expression: exp.ReplacePartition) -> str:
914            return (
915                f"REPLACE {self.sql(expression.expression)} FROM {self.sql(expression, 'source')}"
916            )
917
918        def projectiondef_sql(self, expression: exp.ProjectionDef) -> str:
919            return f"PROJECTION {self.sql(expression.this)} {self.wrap(expression.expression)}"
NORMALIZE_FUNCTIONS: bool | str = False

Determines how function names are going to be normalized.

Possible values:

"upper" or True: Convert names to uppercase. "lower": Convert names to lowercase. False: Disables function name normalization.

NULL_ORDERING = 'nulls_are_last'

Default NULL ordering method to use if not explicitly set. Possible values: "nulls_are_small", "nulls_are_large", "nulls_are_last"

SUPPORTS_USER_DEFINED_TYPES = False

Whether user-defined data types are supported.

SAFE_DIVISION = True

Whether division by zero throws an error (False) or returns NULL (True).

LOG_BASE_FIRST: Optional[bool] = None

Whether the base comes first in the LOG function. Possible values: True, False, None (two arguments are not supported by LOG)

UNESCAPED_SEQUENCES = {'\\a': '\x07', '\\b': '\x08', '\\f': '\x0c', '\\n': '\n', '\\r': '\r', '\\t': '\t', '\\v': '\x0b', '\\\\': '\\', '\\0': '\x00'}

Mapping of an escaped sequence (\n) to its unescaped version ( ).

tokenizer_class = <class 'ClickHouse.Tokenizer'>
parser_class = <class 'ClickHouse.Parser'>
generator_class = <class 'ClickHouse.Generator'>
TIME_TRIE: Dict = {}
FORMAT_TRIE: Dict = {}
INVERSE_TIME_MAPPING: Dict[str, str] = {}
INVERSE_TIME_TRIE: Dict = {}
ESCAPED_SEQUENCES: Dict[str, str] = {'\x07': '\\a', '\x08': '\\b', '\x0c': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t', '\x0b': '\\v', '\\': '\\\\', '\x00': '\\0'}
QUOTE_START = "'"
QUOTE_END = "'"
IDENTIFIER_START = '"'
IDENTIFIER_END = '"'
BIT_START: Optional[str] = '0b'
BIT_END: Optional[str] = ''
HEX_START: Optional[str] = '0x'
HEX_END: Optional[str] = ''
BYTE_START: Optional[str] = None
BYTE_END: Optional[str] = None
UNICODE_START: Optional[str] = None
UNICODE_END: Optional[str] = None
class ClickHouse.Tokenizer(sqlglot.tokens.Tokenizer):
 90    class Tokenizer(tokens.Tokenizer):
 91        COMMENTS = ["--", "#", "#!", ("/*", "*/")]
 92        IDENTIFIERS = ['"', "`"]
 93        STRING_ESCAPES = ["'", "\\"]
 94        BIT_STRINGS = [("0b", "")]
 95        HEX_STRINGS = [("0x", ""), ("0X", "")]
 96        HEREDOC_STRINGS = ["$"]
 97
 98        KEYWORDS = {
 99            **tokens.Tokenizer.KEYWORDS,
100            "ATTACH": TokenType.COMMAND,
101            "DATE32": TokenType.DATE32,
102            "DATETIME64": TokenType.DATETIME64,
103            "DICTIONARY": TokenType.DICTIONARY,
104            "ENUM8": TokenType.ENUM8,
105            "ENUM16": TokenType.ENUM16,
106            "FINAL": TokenType.FINAL,
107            "FIXEDSTRING": TokenType.FIXEDSTRING,
108            "FLOAT32": TokenType.FLOAT,
109            "FLOAT64": TokenType.DOUBLE,
110            "GLOBAL": TokenType.GLOBAL,
111            "INT256": TokenType.INT256,
112            "LOWCARDINALITY": TokenType.LOWCARDINALITY,
113            "MAP": TokenType.MAP,
114            "NESTED": TokenType.NESTED,
115            "SAMPLE": TokenType.TABLE_SAMPLE,
116            "TUPLE": TokenType.STRUCT,
117            "UINT128": TokenType.UINT128,
118            "UINT16": TokenType.USMALLINT,
119            "UINT256": TokenType.UINT256,
120            "UINT32": TokenType.UINT,
121            "UINT64": TokenType.UBIGINT,
122            "UINT8": TokenType.UTINYINT,
123            "IPV4": TokenType.IPV4,
124            "IPV6": TokenType.IPV6,
125            "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION,
126            "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION,
127            "SYSTEM": TokenType.COMMAND,
128            "PREWHERE": TokenType.PREWHERE,
129        }
130
131        SINGLE_TOKENS = {
132            **tokens.Tokenizer.SINGLE_TOKENS,
133            "$": TokenType.HEREDOC_STRING,
134        }
COMMENTS = ['--', '#', '#!', ('/*', '*/')]
IDENTIFIERS = ['"', '`']
STRING_ESCAPES = ["'", '\\']
BIT_STRINGS = [('0b', '')]
HEX_STRINGS = [('0x', ''), ('0X', '')]
HEREDOC_STRINGS = ['$']
KEYWORDS = {'{%': <TokenType.BLOCK_START: 'BLOCK_START'>, '{%+': <TokenType.BLOCK_START: 'BLOCK_START'>, '{%-': <TokenType.BLOCK_START: 'BLOCK_START'>, '%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '+%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '-%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '{{+': <TokenType.BLOCK_START: 'BLOCK_START'>, '{{-': <TokenType.BLOCK_START: 'BLOCK_START'>, '+}}': <TokenType.BLOCK_END: 'BLOCK_END'>, '-}}': <TokenType.BLOCK_END: 'BLOCK_END'>, '/*+': <TokenType.HINT: 'HINT'>, '==': <TokenType.EQ: 'EQ'>, '::': <TokenType.DCOLON: 'DCOLON'>, '||': <TokenType.DPIPE: 'DPIPE'>, '>=': <TokenType.GTE: 'GTE'>, '<=': <TokenType.LTE: 'LTE'>, '<>': <TokenType.NEQ: 'NEQ'>, '!=': <TokenType.NEQ: 'NEQ'>, ':=': <TokenType.COLON_EQ: 'COLON_EQ'>, '<=>': <TokenType.NULLSAFE_EQ: 'NULLSAFE_EQ'>, '->': <TokenType.ARROW: 'ARROW'>, '->>': <TokenType.DARROW: 'DARROW'>, '=>': <TokenType.FARROW: 'FARROW'>, '#>': <TokenType.HASH_ARROW: 'HASH_ARROW'>, '#>>': <TokenType.DHASH_ARROW: 'DHASH_ARROW'>, '<->': <TokenType.LR_ARROW: 'LR_ARROW'>, '&&': <TokenType.DAMP: 'DAMP'>, '??': <TokenType.DQMARK: 'DQMARK'>, 'ALL': <TokenType.ALL: 'ALL'>, 'ALWAYS': <TokenType.ALWAYS: 'ALWAYS'>, 'AND': <TokenType.AND: 'AND'>, 'ANTI': <TokenType.ANTI: 'ANTI'>, 'ANY': <TokenType.ANY: 'ANY'>, 'ASC': <TokenType.ASC: 'ASC'>, 'AS': <TokenType.ALIAS: 'ALIAS'>, 'ASOF': <TokenType.ASOF: 'ASOF'>, 'AUTOINCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'AUTO_INCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'BEGIN': <TokenType.BEGIN: 'BEGIN'>, 'BETWEEN': <TokenType.BETWEEN: 'BETWEEN'>, 'CACHE': <TokenType.CACHE: 'CACHE'>, 'UNCACHE': <TokenType.UNCACHE: 'UNCACHE'>, 'CASE': <TokenType.CASE: 'CASE'>, 'CHARACTER SET': <TokenType.CHARACTER_SET: 'CHARACTER_SET'>, 'CLUSTER BY': <TokenType.CLUSTER_BY: 'CLUSTER_BY'>, 'COLLATE': <TokenType.COLLATE: 'COLLATE'>, 'COLUMN': <TokenType.COLUMN: 'COLUMN'>, 'COMMIT': <TokenType.COMMIT: 'COMMIT'>, 'CONNECT BY': <TokenType.CONNECT_BY: 'CONNECT_BY'>, 'CONSTRAINT': <TokenType.CONSTRAINT: 'CONSTRAINT'>, 'COPY': <TokenType.COPY: 'COPY'>, 'CREATE': <TokenType.CREATE: 'CREATE'>, 'CROSS': <TokenType.CROSS: 'CROSS'>, 'CUBE': <TokenType.CUBE: 'CUBE'>, 'CURRENT_DATE': <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, 'CURRENT_TIME': <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, 'CURRENT_TIMESTAMP': <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, 'CURRENT_USER': <TokenType.CURRENT_USER: 'CURRENT_USER'>, 'DATABASE': <TokenType.DATABASE: 'DATABASE'>, 'DEFAULT': <TokenType.DEFAULT: 'DEFAULT'>, 'DELETE': <TokenType.DELETE: 'DELETE'>, 'DESC': <TokenType.DESC: 'DESC'>, 'DESCRIBE': <TokenType.DESCRIBE: 'DESCRIBE'>, 'DISTINCT': <TokenType.DISTINCT: 'DISTINCT'>, 'DISTRIBUTE BY': <TokenType.DISTRIBUTE_BY: 'DISTRIBUTE_BY'>, 'DIV': <TokenType.DIV: 'DIV'>, 'DROP': <TokenType.DROP: 'DROP'>, 'ELSE': <TokenType.ELSE: 'ELSE'>, 'END': <TokenType.END: 'END'>, 'ENUM': <TokenType.ENUM: 'ENUM'>, 'ESCAPE': <TokenType.ESCAPE: 'ESCAPE'>, 'EXCEPT': <TokenType.EXCEPT: 'EXCEPT'>, 'EXECUTE': <TokenType.EXECUTE: 'EXECUTE'>, 'EXISTS': <TokenType.EXISTS: 'EXISTS'>, 'FALSE': <TokenType.FALSE: 'FALSE'>, 'FETCH': <TokenType.FETCH: 'FETCH'>, 'FILTER': <TokenType.FILTER: 'FILTER'>, 'FIRST': <TokenType.FIRST: 'FIRST'>, 'FULL': <TokenType.FULL: 'FULL'>, 'FUNCTION': <TokenType.FUNCTION: 'FUNCTION'>, 'FOR': <TokenType.FOR: 'FOR'>, 'FOREIGN KEY': <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, 'FORMAT': <TokenType.FORMAT: 'FORMAT'>, 'FROM': <TokenType.FROM: 'FROM'>, 'GEOGRAPHY': <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, 'GEOMETRY': <TokenType.GEOMETRY: 'GEOMETRY'>, 'GLOB': <TokenType.GLOB: 'GLOB'>, 'GROUP BY': <TokenType.GROUP_BY: 'GROUP_BY'>, 'GROUPING SETS': <TokenType.GROUPING_SETS: 'GROUPING_SETS'>, 'HAVING': <TokenType.HAVING: 'HAVING'>, 'ILIKE': <TokenType.ILIKE: 'ILIKE'>, 'IN': <TokenType.IN: 'IN'>, 'INDEX': <TokenType.INDEX: 'INDEX'>, 'INET': <TokenType.INET: 'INET'>, 'INNER': <TokenType.INNER: 'INNER'>, 'INSERT': <TokenType.INSERT: 'INSERT'>, 'INTERVAL': <TokenType.INTERVAL: 'INTERVAL'>, 'INTERSECT': <TokenType.INTERSECT: 'INTERSECT'>, 'INTO': <TokenType.INTO: 'INTO'>, 'IS': <TokenType.IS: 'IS'>, 'ISNULL': <TokenType.ISNULL: 'ISNULL'>, 'JOIN': <TokenType.JOIN: 'JOIN'>, 'KEEP': <TokenType.KEEP: 'KEEP'>, 'KILL': <TokenType.KILL: 'KILL'>, 'LATERAL': <TokenType.LATERAL: 'LATERAL'>, 'LEFT': <TokenType.LEFT: 'LEFT'>, 'LIKE': <TokenType.LIKE: 'LIKE'>, 'LIMIT': <TokenType.LIMIT: 'LIMIT'>, 'LOAD': <TokenType.LOAD: 'LOAD'>, 'LOCK': <TokenType.LOCK: 'LOCK'>, 'MERGE': <TokenType.MERGE: 'MERGE'>, 'NATURAL': <TokenType.NATURAL: 'NATURAL'>, 'NEXT': <TokenType.NEXT: 'NEXT'>, 'NOT': <TokenType.NOT: 'NOT'>, 'NOTNULL': <TokenType.NOTNULL: 'NOTNULL'>, 'NULL': <TokenType.NULL: 'NULL'>, 'OBJECT': <TokenType.OBJECT: 'OBJECT'>, 'OFFSET': <TokenType.OFFSET: 'OFFSET'>, 'ON': <TokenType.ON: 'ON'>, 'OR': <TokenType.OR: 'OR'>, 'XOR': <TokenType.XOR: 'XOR'>, 'ORDER BY': <TokenType.ORDER_BY: 'ORDER_BY'>, 'ORDINALITY': <TokenType.ORDINALITY: 'ORDINALITY'>, 'OUTER': <TokenType.OUTER: 'OUTER'>, 'OVER': <TokenType.OVER: 'OVER'>, 'OVERLAPS': <TokenType.OVERLAPS: 'OVERLAPS'>, 'OVERWRITE': <TokenType.OVERWRITE: 'OVERWRITE'>, 'PARTITION': <TokenType.PARTITION: 'PARTITION'>, 'PARTITION BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED_BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PERCENT': <TokenType.PERCENT: 'PERCENT'>, 'PIVOT': <TokenType.PIVOT: 'PIVOT'>, 'PRAGMA': <TokenType.PRAGMA: 'PRAGMA'>, 'PRIMARY KEY': <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, 'PROCEDURE': <TokenType.PROCEDURE: 'PROCEDURE'>, 'QUALIFY': <TokenType.QUALIFY: 'QUALIFY'>, 'RANGE': <TokenType.RANGE: 'RANGE'>, 'RECURSIVE': <TokenType.RECURSIVE: 'RECURSIVE'>, 'REGEXP': <TokenType.RLIKE: 'RLIKE'>, 'REPLACE': <TokenType.REPLACE: 'REPLACE'>, 'RETURNING': <TokenType.RETURNING: 'RETURNING'>, 'REFERENCES': <TokenType.REFERENCES: 'REFERENCES'>, 'RIGHT': <TokenType.RIGHT: 'RIGHT'>, 'RLIKE': <TokenType.RLIKE: 'RLIKE'>, 'ROLLBACK': <TokenType.ROLLBACK: 'ROLLBACK'>, 'ROLLUP': <TokenType.ROLLUP: 'ROLLUP'>, 'ROW': <TokenType.ROW: 'ROW'>, 'ROWS': <TokenType.ROWS: 'ROWS'>, 'SCHEMA': <TokenType.SCHEMA: 'SCHEMA'>, 'SELECT': <TokenType.SELECT: 'SELECT'>, 'SEMI': <TokenType.SEMI: 'SEMI'>, 'SET': <TokenType.SET: 'SET'>, 'SETTINGS': <TokenType.SETTINGS: 'SETTINGS'>, 'SHOW': <TokenType.SHOW: 'SHOW'>, 'SIMILAR TO': <TokenType.SIMILAR_TO: 'SIMILAR_TO'>, 'SOME': <TokenType.SOME: 'SOME'>, 'SORT BY': <TokenType.SORT_BY: 'SORT_BY'>, 'START WITH': <TokenType.START_WITH: 'START_WITH'>, 'TABLE': <TokenType.TABLE: 'TABLE'>, 'TABLESAMPLE': <TokenType.TABLE_SAMPLE: 'TABLE_SAMPLE'>, 'TEMP': <TokenType.TEMPORARY: 'TEMPORARY'>, 'TEMPORARY': <TokenType.TEMPORARY: 'TEMPORARY'>, 'THEN': <TokenType.THEN: 'THEN'>, 'TRUE': <TokenType.TRUE: 'TRUE'>, 'TRUNCATE': <TokenType.TRUNCATE: 'TRUNCATE'>, 'UNION': <TokenType.UNION: 'UNION'>, 'UNKNOWN': <TokenType.UNKNOWN: 'UNKNOWN'>, 'UNNEST': <TokenType.UNNEST: 'UNNEST'>, 'UNPIVOT': <TokenType.UNPIVOT: 'UNPIVOT'>, 'UPDATE': <TokenType.UPDATE: 'UPDATE'>, 'USE': <TokenType.USE: 'USE'>, 'USING': <TokenType.USING: 'USING'>, 'UUID': <TokenType.UUID: 'UUID'>, 'VALUES': <TokenType.VALUES: 'VALUES'>, 'VIEW': <TokenType.VIEW: 'VIEW'>, 'VOLATILE': <TokenType.VOLATILE: 'VOLATILE'>, 'WHEN': <TokenType.WHEN: 'WHEN'>, 'WHERE': <TokenType.WHERE: 'WHERE'>, 'WINDOW': <TokenType.WINDOW: 'WINDOW'>, 'WITH': <TokenType.WITH: 'WITH'>, 'APPLY': <TokenType.APPLY: 'APPLY'>, 'ARRAY': <TokenType.ARRAY: 'ARRAY'>, 'BIT': <TokenType.BIT: 'BIT'>, 'BOOL': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BOOLEAN': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BYTE': <TokenType.TINYINT: 'TINYINT'>, 'MEDIUMINT': <TokenType.MEDIUMINT: 'MEDIUMINT'>, 'INT1': <TokenType.TINYINT: 'TINYINT'>, 'TINYINT': <TokenType.TINYINT: 'TINYINT'>, 'INT16': <TokenType.SMALLINT: 'SMALLINT'>, 'SHORT': <TokenType.SMALLINT: 'SMALLINT'>, 'SMALLINT': <TokenType.SMALLINT: 'SMALLINT'>, 'INT128': <TokenType.INT128: 'INT128'>, 'HUGEINT': <TokenType.INT128: 'INT128'>, 'INT2': <TokenType.SMALLINT: 'SMALLINT'>, 'INTEGER': <TokenType.INT: 'INT'>, 'INT': <TokenType.INT: 'INT'>, 'INT4': <TokenType.INT: 'INT'>, 'INT32': <TokenType.INT: 'INT'>, 'INT64': <TokenType.BIGINT: 'BIGINT'>, 'LONG': <TokenType.BIGINT: 'BIGINT'>, 'BIGINT': <TokenType.BIGINT: 'BIGINT'>, 'INT8': <TokenType.TINYINT: 'TINYINT'>, 'UINT': <TokenType.UINT: 'UINT'>, 'DEC': <TokenType.DECIMAL: 'DECIMAL'>, 'DECIMAL': <TokenType.DECIMAL: 'DECIMAL'>, 'BIGDECIMAL': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, 'BIGNUMERIC': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, 'MAP': <TokenType.MAP: 'MAP'>, 'NULLABLE': <TokenType.NULLABLE: 'NULLABLE'>, 'NUMBER': <TokenType.DECIMAL: 'DECIMAL'>, 'NUMERIC': <TokenType.DECIMAL: 'DECIMAL'>, 'FIXED': <TokenType.DECIMAL: 'DECIMAL'>, 'REAL': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT4': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT8': <TokenType.DOUBLE: 'DOUBLE'>, 'DOUBLE': <TokenType.DOUBLE: 'DOUBLE'>, 'DOUBLE PRECISION': <TokenType.DOUBLE: 'DOUBLE'>, 'JSON': <TokenType.JSON: 'JSON'>, 'CHAR': <TokenType.CHAR: 'CHAR'>, 'CHARACTER': <TokenType.CHAR: 'CHAR'>, 'NCHAR': <TokenType.NCHAR: 'NCHAR'>, 'VARCHAR': <TokenType.VARCHAR: 'VARCHAR'>, 'VARCHAR2': <TokenType.VARCHAR: 'VARCHAR'>, 'NVARCHAR': <TokenType.NVARCHAR: 'NVARCHAR'>, 'NVARCHAR2': <TokenType.NVARCHAR: 'NVARCHAR'>, 'BPCHAR': <TokenType.BPCHAR: 'BPCHAR'>, 'STR': <TokenType.TEXT: 'TEXT'>, 'STRING': <TokenType.TEXT: 'TEXT'>, 'TEXT': <TokenType.TEXT: 'TEXT'>, 'LONGTEXT': <TokenType.LONGTEXT: 'LONGTEXT'>, 'MEDIUMTEXT': <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, 'TINYTEXT': <TokenType.TINYTEXT: 'TINYTEXT'>, 'CLOB': <TokenType.TEXT: 'TEXT'>, 'LONGVARCHAR': <TokenType.TEXT: 'TEXT'>, 'BINARY': <TokenType.BINARY: 'BINARY'>, 'BLOB': <TokenType.VARBINARY: 'VARBINARY'>, 'LONGBLOB': <TokenType.LONGBLOB: 'LONGBLOB'>, 'MEDIUMBLOB': <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, 'TINYBLOB': <TokenType.TINYBLOB: 'TINYBLOB'>, 'BYTEA': <TokenType.VARBINARY: 'VARBINARY'>, 'VARBINARY': <TokenType.VARBINARY: 'VARBINARY'>, 'TIME': <TokenType.TIME: 'TIME'>, 'TIMETZ': <TokenType.TIMETZ: 'TIMETZ'>, 'TIMESTAMP': <TokenType.TIMESTAMP: 'TIMESTAMP'>, 'TIMESTAMPTZ': <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, 'TIMESTAMPLTZ': <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, 'TIMESTAMP_LTZ': <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, 'TIMESTAMPNTZ': <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, 'TIMESTAMP_NTZ': <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, 'DATE': <TokenType.DATE: 'DATE'>, 'DATETIME': <TokenType.DATETIME: 'DATETIME'>, 'INT4RANGE': <TokenType.INT4RANGE: 'INT4RANGE'>, 'INT4MULTIRANGE': <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, 'INT8RANGE': <TokenType.INT8RANGE: 'INT8RANGE'>, 'INT8MULTIRANGE': <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, 'NUMRANGE': <TokenType.NUMRANGE: 'NUMRANGE'>, 'NUMMULTIRANGE': <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, 'TSRANGE': <TokenType.TSRANGE: 'TSRANGE'>, 'TSMULTIRANGE': <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, 'TSTZRANGE': <TokenType.TSTZRANGE: 'TSTZRANGE'>, 'TSTZMULTIRANGE': <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, 'DATERANGE': <TokenType.DATERANGE: 'DATERANGE'>, 'DATEMULTIRANGE': <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, 'UNIQUE': <TokenType.UNIQUE: 'UNIQUE'>, 'STRUCT': <TokenType.STRUCT: 'STRUCT'>, 'SEQUENCE': <TokenType.SEQUENCE: 'SEQUENCE'>, 'VARIANT': <TokenType.VARIANT: 'VARIANT'>, 'ALTER': <TokenType.ALTER: 'ALTER'>, 'ANALYZE': <TokenType.COMMAND: 'COMMAND'>, 'CALL': <TokenType.COMMAND: 'COMMAND'>, 'COMMENT': <TokenType.COMMENT: 'COMMENT'>, 'EXPLAIN': <TokenType.COMMAND: 'COMMAND'>, 'GRANT': <TokenType.COMMAND: 'COMMAND'>, 'OPTIMIZE': <TokenType.COMMAND: 'COMMAND'>, 'PREPARE': <TokenType.COMMAND: 'COMMAND'>, 'VACUUM': <TokenType.COMMAND: 'COMMAND'>, 'USER-DEFINED': <TokenType.USERDEFINED: 'USERDEFINED'>, 'FOR VERSION': <TokenType.VERSION_SNAPSHOT: 'VERSION_SNAPSHOT'>, 'FOR TIMESTAMP': <TokenType.TIMESTAMP_SNAPSHOT: 'TIMESTAMP_SNAPSHOT'>, 'ATTACH': <TokenType.COMMAND: 'COMMAND'>, 'DATE32': <TokenType.DATE32: 'DATE32'>, 'DATETIME64': <TokenType.DATETIME64: 'DATETIME64'>, 'DICTIONARY': <TokenType.DICTIONARY: 'DICTIONARY'>, 'ENUM8': <TokenType.ENUM8: 'ENUM8'>, 'ENUM16': <TokenType.ENUM16: 'ENUM16'>, 'FINAL': <TokenType.FINAL: 'FINAL'>, 'FIXEDSTRING': <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, 'FLOAT32': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT64': <TokenType.DOUBLE: 'DOUBLE'>, 'GLOBAL': <TokenType.GLOBAL: 'GLOBAL'>, 'INT256': <TokenType.INT256: 'INT256'>, 'LOWCARDINALITY': <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, 'NESTED': <TokenType.NESTED: 'NESTED'>, 'SAMPLE': <TokenType.TABLE_SAMPLE: 'TABLE_SAMPLE'>, 'TUPLE': <TokenType.STRUCT: 'STRUCT'>, 'UINT128': <TokenType.UINT128: 'UINT128'>, 'UINT16': <TokenType.USMALLINT: 'USMALLINT'>, 'UINT256': <TokenType.UINT256: 'UINT256'>, 'UINT32': <TokenType.UINT: 'UINT'>, 'UINT64': <TokenType.UBIGINT: 'UBIGINT'>, 'UINT8': <TokenType.UTINYINT: 'UTINYINT'>, 'IPV4': <TokenType.IPV4: 'IPV4'>, 'IPV6': <TokenType.IPV6: 'IPV6'>, 'AGGREGATEFUNCTION': <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, 'SIMPLEAGGREGATEFUNCTION': <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, 'SYSTEM': <TokenType.COMMAND: 'COMMAND'>, 'PREWHERE': <TokenType.PREWHERE: 'PREWHERE'>}
SINGLE_TOKENS = {'(': <TokenType.L_PAREN: 'L_PAREN'>, ')': <TokenType.R_PAREN: 'R_PAREN'>, '[': <TokenType.L_BRACKET: 'L_BRACKET'>, ']': <TokenType.R_BRACKET: 'R_BRACKET'>, '{': <TokenType.L_BRACE: 'L_BRACE'>, '}': <TokenType.R_BRACE: 'R_BRACE'>, '&': <TokenType.AMP: 'AMP'>, '^': <TokenType.CARET: 'CARET'>, ':': <TokenType.COLON: 'COLON'>, ',': <TokenType.COMMA: 'COMMA'>, '.': <TokenType.DOT: 'DOT'>, '-': <TokenType.DASH: 'DASH'>, '=': <TokenType.EQ: 'EQ'>, '>': <TokenType.GT: 'GT'>, '<': <TokenType.LT: 'LT'>, '%': <TokenType.MOD: 'MOD'>, '!': <TokenType.NOT: 'NOT'>, '|': <TokenType.PIPE: 'PIPE'>, '+': <TokenType.PLUS: 'PLUS'>, ';': <TokenType.SEMICOLON: 'SEMICOLON'>, '/': <TokenType.SLASH: 'SLASH'>, '\\': <TokenType.BACKSLASH: 'BACKSLASH'>, '*': <TokenType.STAR: 'STAR'>, '~': <TokenType.TILDA: 'TILDA'>, '?': <TokenType.PLACEHOLDER: 'PLACEHOLDER'>, '@': <TokenType.PARAMETER: 'PARAMETER'>, '#': <TokenType.HASH: 'HASH'>, "'": <TokenType.UNKNOWN: 'UNKNOWN'>, '`': <TokenType.UNKNOWN: 'UNKNOWN'>, '"': <TokenType.UNKNOWN: 'UNKNOWN'>, '$': <TokenType.HEREDOC_STRING: 'HEREDOC_STRING'>}
class ClickHouse.Parser(sqlglot.parser.Parser):
136    class Parser(parser.Parser):
137        # Tested in ClickHouse's playground, it seems that the following two queries do the same thing
138        # * select x from t1 union all select x from t2 limit 1;
139        # * select x from t1 union all (select x from t2 limit 1);
140        MODIFIERS_ATTACHED_TO_UNION = False
141        INTERVAL_SPANS = False
142
143        FUNCTIONS = {
144            **parser.Parser.FUNCTIONS,
145            "ANY": exp.AnyValue.from_arg_list,
146            "ARRAYSUM": exp.ArraySum.from_arg_list,
147            "COUNTIF": _build_count_if,
148            "DATE_ADD": lambda args: exp.DateAdd(
149                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
150            ),
151            "DATEADD": lambda args: exp.DateAdd(
152                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
153            ),
154            "DATE_DIFF": lambda args: exp.DateDiff(
155                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
156            ),
157            "DATEDIFF": lambda args: exp.DateDiff(
158                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
159            ),
160            "DATE_FORMAT": _build_date_format,
161            "FORMATDATETIME": _build_date_format,
162            "JSONEXTRACTSTRING": build_json_extract_path(
163                exp.JSONExtractScalar, zero_based_indexing=False
164            ),
165            "MAP": parser.build_var_map,
166            "MATCH": exp.RegexpLike.from_arg_list,
167            "RANDCANONICAL": exp.Rand.from_arg_list,
168            "TUPLE": exp.Struct.from_arg_list,
169            "UNIQ": exp.ApproxDistinct.from_arg_list,
170            "XOR": lambda args: exp.Xor(expressions=args),
171            "MD5": exp.MD5Digest.from_arg_list,
172            "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
173            "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
174        }
175
176        AGG_FUNCTIONS = {
177            "count",
178            "min",
179            "max",
180            "sum",
181            "avg",
182            "any",
183            "stddevPop",
184            "stddevSamp",
185            "varPop",
186            "varSamp",
187            "corr",
188            "covarPop",
189            "covarSamp",
190            "entropy",
191            "exponentialMovingAverage",
192            "intervalLengthSum",
193            "kolmogorovSmirnovTest",
194            "mannWhitneyUTest",
195            "median",
196            "rankCorr",
197            "sumKahan",
198            "studentTTest",
199            "welchTTest",
200            "anyHeavy",
201            "anyLast",
202            "boundingRatio",
203            "first_value",
204            "last_value",
205            "argMin",
206            "argMax",
207            "avgWeighted",
208            "topK",
209            "topKWeighted",
210            "deltaSum",
211            "deltaSumTimestamp",
212            "groupArray",
213            "groupArrayLast",
214            "groupUniqArray",
215            "groupArrayInsertAt",
216            "groupArrayMovingAvg",
217            "groupArrayMovingSum",
218            "groupArraySample",
219            "groupBitAnd",
220            "groupBitOr",
221            "groupBitXor",
222            "groupBitmap",
223            "groupBitmapAnd",
224            "groupBitmapOr",
225            "groupBitmapXor",
226            "sumWithOverflow",
227            "sumMap",
228            "minMap",
229            "maxMap",
230            "skewSamp",
231            "skewPop",
232            "kurtSamp",
233            "kurtPop",
234            "uniq",
235            "uniqExact",
236            "uniqCombined",
237            "uniqCombined64",
238            "uniqHLL12",
239            "uniqTheta",
240            "quantile",
241            "quantiles",
242            "quantileExact",
243            "quantilesExact",
244            "quantileExactLow",
245            "quantilesExactLow",
246            "quantileExactHigh",
247            "quantilesExactHigh",
248            "quantileExactWeighted",
249            "quantilesExactWeighted",
250            "quantileTiming",
251            "quantilesTiming",
252            "quantileTimingWeighted",
253            "quantilesTimingWeighted",
254            "quantileDeterministic",
255            "quantilesDeterministic",
256            "quantileTDigest",
257            "quantilesTDigest",
258            "quantileTDigestWeighted",
259            "quantilesTDigestWeighted",
260            "quantileBFloat16",
261            "quantilesBFloat16",
262            "quantileBFloat16Weighted",
263            "quantilesBFloat16Weighted",
264            "simpleLinearRegression",
265            "stochasticLinearRegression",
266            "stochasticLogisticRegression",
267            "categoricalInformationValue",
268            "contingency",
269            "cramersV",
270            "cramersVBiasCorrected",
271            "theilsU",
272            "maxIntersections",
273            "maxIntersectionsPosition",
274            "meanZTest",
275            "quantileInterpolatedWeighted",
276            "quantilesInterpolatedWeighted",
277            "quantileGK",
278            "quantilesGK",
279            "sparkBar",
280            "sumCount",
281            "largestTriangleThreeBuckets",
282            "histogram",
283            "sequenceMatch",
284            "sequenceCount",
285            "windowFunnel",
286            "retention",
287            "uniqUpTo",
288            "sequenceNextNode",
289            "exponentialTimeDecayedAvg",
290        }
291
292        AGG_FUNCTIONS_SUFFIXES = [
293            "If",
294            "Array",
295            "ArrayIf",
296            "Map",
297            "SimpleState",
298            "State",
299            "Merge",
300            "MergeState",
301            "ForEach",
302            "Distinct",
303            "OrDefault",
304            "OrNull",
305            "Resample",
306            "ArgMin",
307            "ArgMax",
308        ]
309
310        FUNC_TOKENS = {
311            *parser.Parser.FUNC_TOKENS,
312            TokenType.SET,
313        }
314
315        AGG_FUNC_MAPPING = (
316            lambda functions, suffixes: {
317                f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions
318            }
319        )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES)
320
321        FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"}
322
323        FUNCTION_PARSERS = {
324            **parser.Parser.FUNCTION_PARSERS,
325            "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()),
326            "QUANTILE": lambda self: self._parse_quantile(),
327        }
328
329        FUNCTION_PARSERS.pop("MATCH")
330
331        NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy()
332        NO_PAREN_FUNCTION_PARSERS.pop("ANY")
333
334        RANGE_PARSERS = {
335            **parser.Parser.RANGE_PARSERS,
336            TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN)
337            and self._parse_in(this, is_global=True),
338        }
339
340        # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to
341        # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler.
342        COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy()
343        COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
344
345        JOIN_KINDS = {
346            *parser.Parser.JOIN_KINDS,
347            TokenType.ANY,
348            TokenType.ASOF,
349            TokenType.ARRAY,
350        }
351
352        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
353            TokenType.ANY,
354            TokenType.ARRAY,
355            TokenType.FINAL,
356            TokenType.FORMAT,
357            TokenType.SETTINGS,
358        }
359
360        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
361            TokenType.FORMAT,
362        }
363
364        LOG_DEFAULTS_TO_LN = True
365
366        QUERY_MODIFIER_PARSERS = {
367            **parser.Parser.QUERY_MODIFIER_PARSERS,
368            TokenType.SETTINGS: lambda self: (
369                "settings",
370                self._advance() or self._parse_csv(self._parse_conjunction),
371            ),
372            TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
373        }
374
375        CONSTRAINT_PARSERS = {
376            **parser.Parser.CONSTRAINT_PARSERS,
377            "INDEX": lambda self: self._parse_index_constraint(),
378            "CODEC": lambda self: self._parse_compress(),
379        }
380
381        ALTER_PARSERS = {
382            **parser.Parser.ALTER_PARSERS,
383            "REPLACE": lambda self: self._parse_alter_table_replace(),
384        }
385
386        SCHEMA_UNNAMED_CONSTRAINTS = {
387            *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
388            "INDEX",
389        }
390
391        def _parse_conjunction(self) -> t.Optional[exp.Expression]:
392            this = super()._parse_conjunction()
393
394            if self._match(TokenType.PLACEHOLDER):
395                return self.expression(
396                    exp.If,
397                    this=this,
398                    true=self._parse_conjunction(),
399                    false=self._match(TokenType.COLON) and self._parse_conjunction(),
400                )
401
402            return this
403
404        def _parse_placeholder(self) -> t.Optional[exp.Expression]:
405            """
406            Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
407            https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
408            """
409            if not self._match(TokenType.L_BRACE):
410                return None
411
412            this = self._parse_id_var()
413            self._match(TokenType.COLON)
414            kind = self._parse_types(check_func=False, allow_identifiers=False) or (
415                self._match_text_seq("IDENTIFIER") and "Identifier"
416            )
417
418            if not kind:
419                self.raise_error("Expecting a placeholder type or 'Identifier' for tables")
420            elif not self._match(TokenType.R_BRACE):
421                self.raise_error("Expecting }")
422
423            return self.expression(exp.Placeholder, this=this, kind=kind)
424
425        def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In:
426            this = super()._parse_in(this)
427            this.set("is_global", is_global)
428            return this
429
430        def _parse_table(
431            self,
432            schema: bool = False,
433            joins: bool = False,
434            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
435            parse_bracket: bool = False,
436            is_db_reference: bool = False,
437            parse_partition: bool = False,
438        ) -> t.Optional[exp.Expression]:
439            this = super()._parse_table(
440                schema=schema,
441                joins=joins,
442                alias_tokens=alias_tokens,
443                parse_bracket=parse_bracket,
444                is_db_reference=is_db_reference,
445            )
446
447            if self._match(TokenType.FINAL):
448                this = self.expression(exp.Final, this=this)
449
450            return this
451
452        def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
453            return super()._parse_position(haystack_first=True)
454
455        # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
456        def _parse_cte(self) -> exp.CTE:
457            # WITH <identifier> AS <subquery expression>
458            cte: t.Optional[exp.CTE] = self._try_parse(super()._parse_cte)
459
460            if not cte:
461                # WITH <expression> AS <identifier>
462                cte = self.expression(
463                    exp.CTE,
464                    this=self._parse_conjunction(),
465                    alias=self._parse_table_alias(),
466                    scalar=True,
467                )
468
469            return cte
470
471        def _parse_join_parts(
472            self,
473        ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
474            is_global = self._match(TokenType.GLOBAL) and self._prev
475            kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev
476
477            if kind_pre:
478                kind = self._match_set(self.JOIN_KINDS) and self._prev
479                side = self._match_set(self.JOIN_SIDES) and self._prev
480                return is_global, side, kind
481
482            return (
483                is_global,
484                self._match_set(self.JOIN_SIDES) and self._prev,
485                self._match_set(self.JOIN_KINDS) and self._prev,
486            )
487
488        def _parse_join(
489            self, skip_join_token: bool = False, parse_bracket: bool = False
490        ) -> t.Optional[exp.Join]:
491            join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True)
492            if join:
493                join.set("global", join.args.pop("method", None))
494
495            return join
496
497        def _parse_function(
498            self,
499            functions: t.Optional[t.Dict[str, t.Callable]] = None,
500            anonymous: bool = False,
501            optional_parens: bool = True,
502            any_token: bool = False,
503        ) -> t.Optional[exp.Expression]:
504            expr = super()._parse_function(
505                functions=functions,
506                anonymous=anonymous,
507                optional_parens=optional_parens,
508                any_token=any_token,
509            )
510
511            func = expr.this if isinstance(expr, exp.Window) else expr
512
513            # Aggregate functions can be split in 2 parts: <func_name><suffix>
514            parts = (
515                self.AGG_FUNC_MAPPING.get(func.this) if isinstance(func, exp.Anonymous) else None
516            )
517
518            if parts:
519                params = self._parse_func_params(func)
520
521                kwargs = {
522                    "this": func.this,
523                    "expressions": func.expressions,
524                }
525                if parts[1]:
526                    kwargs["parts"] = parts
527                    exp_class = exp.CombinedParameterizedAgg if params else exp.CombinedAggFunc
528                else:
529                    exp_class = exp.ParameterizedAgg if params else exp.AnonymousAggFunc
530
531                kwargs["exp_class"] = exp_class
532                if params:
533                    kwargs["params"] = params
534
535                func = self.expression(**kwargs)
536
537                if isinstance(expr, exp.Window):
538                    # The window's func was parsed as Anonymous in base parser, fix its
539                    # type to be CH style CombinedAnonymousAggFunc / AnonymousAggFunc
540                    expr.set("this", func)
541                elif params:
542                    # Params have blocked super()._parse_function() from parsing the following window
543                    # (if that exists) as they're standing between the function call and the window spec
544                    expr = self._parse_window(func)
545                else:
546                    expr = func
547
548            return expr
549
550        def _parse_func_params(
551            self, this: t.Optional[exp.Func] = None
552        ) -> t.Optional[t.List[exp.Expression]]:
553            if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
554                return self._parse_csv(self._parse_lambda)
555
556            if self._match(TokenType.L_PAREN):
557                params = self._parse_csv(self._parse_lambda)
558                self._match_r_paren(this)
559                return params
560
561            return None
562
563        def _parse_quantile(self) -> exp.Quantile:
564            this = self._parse_lambda()
565            params = self._parse_func_params()
566            if params:
567                return self.expression(exp.Quantile, this=params[0], quantile=this)
568            return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5))
569
570        def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
571            return super()._parse_wrapped_id_vars(optional=True)
572
573        def _parse_primary_key(
574            self, wrapped_optional: bool = False, in_props: bool = False
575        ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
576            return super()._parse_primary_key(
577                wrapped_optional=wrapped_optional or in_props, in_props=in_props
578            )
579
580        def _parse_on_property(self) -> t.Optional[exp.Expression]:
581            index = self._index
582            if self._match_text_seq("CLUSTER"):
583                this = self._parse_id_var()
584                if this:
585                    return self.expression(exp.OnCluster, this=this)
586                else:
587                    self._retreat(index)
588            return None
589
590        def _parse_index_constraint(
591            self, kind: t.Optional[str] = None
592        ) -> exp.IndexColumnConstraint:
593            # INDEX name1 expr TYPE type1(args) GRANULARITY value
594            this = self._parse_id_var()
595            expression = self._parse_conjunction()
596
597            index_type = self._match_text_seq("TYPE") and (
598                self._parse_function() or self._parse_var()
599            )
600
601            granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
602
603            return self.expression(
604                exp.IndexColumnConstraint,
605                this=this,
606                expression=expression,
607                index_type=index_type,
608                granularity=granularity,
609            )
610
611        def _parse_partition(self) -> t.Optional[exp.Partition]:
612            # https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#how-to-set-partition-expression
613            if not self._match(TokenType.PARTITION):
614                return None
615
616            if self._match_text_seq("ID"):
617                # Corresponds to the PARTITION ID <string_value> syntax
618                expressions: t.List[exp.Expression] = [
619                    self.expression(exp.PartitionId, this=self._parse_string())
620                ]
621            else:
622                expressions = self._parse_expressions()
623
624            return self.expression(exp.Partition, expressions=expressions)
625
626        def _parse_alter_table_replace(self) -> t.Optional[exp.Expression]:
627            partition = self._parse_partition()
628
629            if not partition or not self._match(TokenType.FROM):
630                return None
631
632            return self.expression(
633                exp.ReplacePartition, expression=partition, source=self._parse_table_parts()
634            )
635
636        def _parse_projection_def(self) -> t.Optional[exp.ProjectionDef]:
637            if not self._match_text_seq("PROJECTION"):
638                return None
639
640            return self.expression(
641                exp.ProjectionDef,
642                this=self._parse_id_var(),
643                expression=self._parse_wrapped(self._parse_statement),
644            )
645
646        def _parse_constraint(self) -> t.Optional[exp.Expression]:
647            return super()._parse_constraint() or self._parse_projection_def()

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
MODIFIERS_ATTACHED_TO_UNION = False
INTERVAL_SPANS = False
FUNCTIONS = {'ABS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Abs'>>, 'ADD_MONTHS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AddMonths'>>, 'ANONYMOUS_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnonymousAggFunc'>>, 'ANY_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnyValue'>>, 'APPROX_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_COUNT_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxQuantile'>>, 'APPROX_TOP_K': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxTopK'>>, 'ARG_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARGMAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'MAX_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARG_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARGMIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'MIN_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Array'>>, 'ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAgg'>>, 'ARRAY_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAll'>>, 'ARRAY_ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAny'>>, 'ARRAY_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CONSTRUCT_COMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConstructCompact'>>, 'ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContains'>>, 'FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_OVERLAPS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayOverlaps'>>, 'ARRAY_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_SORT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySort'>>, 'ARRAY_SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySum'>>, 'ARRAY_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayToString'>>, 'ARRAY_JOIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayToString'>>, 'ARRAY_UNION_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUnionAgg'>>, 'ARRAY_UNIQUE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUniqueAgg'>>, 'AVG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Avg'>>, 'CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Case'>>, 'CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cast'>>, 'CAST_TO_STR_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CastToStrType'>>, 'CBRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cbrt'>>, 'CEIL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CEILING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CHR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Chr'>>, 'CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Chr'>>, 'COALESCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'IFNULL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'NVL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'COLLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Collate'>>, 'COMBINED_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedAggFunc'>>, 'COMBINED_PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedParameterizedAgg'>>, 'CONCAT': <function Parser.<lambda>>, 'CONCAT_WS': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ConnectByRoot'>>, 'CONVERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Convert'>>, 'CORR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Corr'>>, 'COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Count'>>, 'COUNT_IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CountIf'>>, 'COUNTIF': <function _build_count_if>, 'COVAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CovarPop'>>, 'COVAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CovarSamp'>>, 'CURRENT_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDate'>>, 'CURRENT_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDatetime'>>, 'CURRENT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTime'>>, 'CURRENT_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTimestamp'>>, 'CURRENT_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentUser'>>, 'DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Date'>>, 'DATE_ADD': <function ClickHouse.Parser.<lambda>>, 'DATEDIFF': <function ClickHouse.Parser.<lambda>>, 'DATE_DIFF': <function ClickHouse.Parser.<lambda>>, 'DATE_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATE_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateStrToDate'>>, 'DATE_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateSub'>>, 'DATE_TO_DATE_STR': <function Parser.<lambda>>, 'DATE_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateToDi'>>, 'DATE_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateTrunc'>>, 'DATETIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeAdd'>>, 'DATETIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeDiff'>>, 'DATETIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeSub'>>, 'DATETIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeTrunc'>>, 'DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Day'>>, 'DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAYOFMONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAY_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAYOFWEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAY_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DAYOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DECODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Decode'>>, 'DI_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DiToDate'>>, 'ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Encode'>>, 'EXP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Exp'>>, 'EXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Explode'>>, 'EXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ExplodeOuter'>>, 'EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Extract'>>, 'FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.First'>>, 'FIRST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FirstValue'>>, 'FLATTEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Flatten'>>, 'FLOOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Floor'>>, 'FROM_BASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase'>>, 'FROM_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase64'>>, 'GENERATE_DATE_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateDateArray'>>, 'GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateSeries'>>, 'GREATEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Greatest'>>, 'GROUP_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GroupConcat'>>, 'HEX': <function build_hex>, 'HLL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Hll'>>, 'IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'IIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'INITCAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Initcap'>>, 'IS_INF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'ISINF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'IS_NAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'ISNAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'J_S_O_N_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArray'>>, 'J_S_O_N_ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayAgg'>>, 'JSON_ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayContains'>>, 'JSONB_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtract'>>, 'JSONB_EXTRACT_SCALAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtractScalar'>>, 'JSON_EXTRACT': <function build_extract_json_with_path.<locals>._builder>, 'JSON_EXTRACT_SCALAR': <function build_extract_json_with_path.<locals>._builder>, 'JSON_FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONFormat'>>, 'J_S_O_N_OBJECT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObject'>>, 'J_S_O_N_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObjectAgg'>>, 'J_S_O_N_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONTable'>>, 'LAG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lag'>>, 'LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Last'>>, 'LAST_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastValue'>>, 'LEAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lead'>>, 'LEAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Least'>>, 'LEFT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Left'>>, 'LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEVENSHTEIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Levenshtein'>>, 'LN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ln'>>, 'LOG': <function build_logarithm>, 'LOGICAL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOLAND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'LOGICAL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOLOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'LOWER': <function build_lower>, 'LCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lower'>>, 'LOWER_HEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LowerHex'>>, 'MD5': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5Digest'>>, 'MD5_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5Digest'>>, 'MAP': <function build_var_map>, 'MAP_FROM_ENTRIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MapFromEntries'>>, 'MATCH_AGAINST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MatchAgainst'>>, 'MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Max'>>, 'MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Min'>>, 'MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Month'>>, 'MONTHS_BETWEEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MonthsBetween'>>, 'NEXT_VALUE_FOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NextValueFor'>>, 'NTH_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NthValue'>>, 'NULLIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nullif'>>, 'NUMBER_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NumberToStr'>>, 'NVL2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nvl2'>>, 'OPEN_J_S_O_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.OpenJSON'>>, 'PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParameterizedAgg'>>, 'PARSE_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'JSON_PARSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'PERCENTILE_CONT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileCont'>>, 'PERCENTILE_DISC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileDisc'>>, 'POSEXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Posexplode'>>, 'POSEXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PosexplodeOuter'>>, 'POWER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'POW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'PREDICT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Predict'>>, 'QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quantile'>>, 'QUARTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quarter'>>, 'RAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDOM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Randn'>>, 'RANGE_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RangeN'>>, 'READ_CSV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ReadCSV'>>, 'REDUCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Reduce'>>, 'REGEXP_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpExtract'>>, 'REGEXP_I_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpILike'>>, 'REGEXP_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpLike'>>, 'REGEXP_REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpReplace'>>, 'REGEXP_SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpSplit'>>, 'REPEAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Repeat'>>, 'RIGHT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Right'>>, 'ROUND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Round'>>, 'ROW_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RowNumber'>>, 'SHA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA2'>>, 'SAFE_DIVIDE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SafeDivide'>>, 'SIGN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sign'>>, 'SIGNUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sign'>>, 'SORT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SortArray'>>, 'SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Split'>>, 'SQRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sqrt'>>, 'STANDARD_HASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StandardHash'>>, 'STAR_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StarMap'>>, 'STARTS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STARTSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STDDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stddev'>>, 'STDDEV_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevPop'>>, 'STDDEV_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevSamp'>>, 'STR_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrPosition'>>, 'STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToDate'>>, 'STR_TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToMap'>>, 'STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToTime'>>, 'STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToUnix'>>, 'STRUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Struct'>>, 'STRUCT_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StructExtract'>>, 'STUFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'SUBSTRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Substring'>>, 'SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sum'>>, 'TIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeAdd'>>, 'TIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeDiff'>>, 'TIME_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIMEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIME_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToDate'>>, 'TIME_STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToTime'>>, 'TIME_STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToUnix'>>, 'TIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeSub'>>, 'TIME_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToStr'>>, 'TIME_TO_TIME_STR': <function Parser.<lambda>>, 'TIME_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToUnix'>>, 'TIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeTrunc'>>, 'TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Timestamp'>>, 'TIMESTAMP_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampAdd'>>, 'TIMESTAMPDIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampDiff'>>, 'TIMESTAMP_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampDiff'>>, 'TIMESTAMP_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMPFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMP_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampSub'>>, 'TIMESTAMP_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampTrunc'>>, 'TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToArray'>>, 'TO_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToBase64'>>, 'TO_CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToChar'>>, 'TO_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToDays'>>, 'TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToMap'>>, 'TO_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToNumber'>>, 'TRANSFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Transform'>>, 'TRIM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Trim'>>, 'TRY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Try'>>, 'TRY_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TryCast'>>, 'TS_OR_DI_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDiToDi'>>, 'TS_OR_DS_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsAdd'>>, 'TS_OR_DS_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsDiff'>>, 'TS_OR_DS_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToDate'>>, 'TS_OR_DS_TO_DATE_STR': <function Parser.<lambda>>, 'TS_OR_DS_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTime'>>, 'TS_OR_DS_TO_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTimestamp'>>, 'UNHEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Unhex'>>, 'UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixDate'>>, 'UNIX_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToStr'>>, 'UNIX_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTime'>>, 'UNIX_TO_TIME_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTimeStr'>>, 'UPPER': <function build_upper>, 'UCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Upper'>>, 'VAR_MAP': <function build_var_map>, 'VARIANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'VAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Week'>>, 'WEEK_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'WEEKOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'WHEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.When'>>, 'X_M_L_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.XMLTable'>>, 'XOR': <function ClickHouse.Parser.<lambda>>, 'YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Year'>>, 'GLOB': <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>>, 'MOD': <function build_mod>, 'TO_HEX': <function build_hex>, 'ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnyValue'>>, 'ARRAYSUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySum'>>, 'DATEADD': <function ClickHouse.Parser.<lambda>>, 'DATE_FORMAT': <function _build_date_format>, 'FORMATDATETIME': <function _build_date_format>, 'JSONEXTRACTSTRING': <function build_json_extract_path.<locals>._builder>, 'MATCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpLike'>>, 'RANDCANONICAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'TUPLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Struct'>>, 'UNIQ': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'SHA256': <function ClickHouse.Parser.<lambda>>, 'SHA512': <function ClickHouse.Parser.<lambda>>}
AGG_FUNCTIONS = {'categoricalInformationValue', 'groupArrayInsertAt', 'quantilesTDigest', 'groupArraySample', 'quantileBFloat16', 'covarSamp', 'quantilesExact', 'maxIntersections', 'median', 'largestTriangleThreeBuckets', 'uniq', 'avg', 'groupBitmapAnd', 'quantile', 'quantilesTimingWeighted', 'cramersVBiasCorrected', 'maxIntersectionsPosition', 'quantilesDeterministic', 'quantileGK', 'kurtPop', 'corr', 'kolmogorovSmirnovTest', 'argMin', 'count', 'sequenceNextNode', 'topK', 'first_value', 'stochasticLogisticRegression', 'quantileExactHigh', 'minMap', 'sumMap', 'maxMap', 'kurtSamp', 'quantileTDigest', 'deltaSum', 'groupBitOr', 'max', 'sum', 'any', 'quantilesExactHigh', 'uniqUpTo', 'avgWeighted', 'sequenceMatch', 'mannWhitneyUTest', 'sumCount', 'topKWeighted', 'last_value', 'quantileBFloat16Weighted', 'min', 'quantileTDigestWeighted', 'uniqCombined', 'varPop', 'varSamp', 'quantileTiming', 'groupBitmap', 'covarPop', 'welchTTest', 'uniqCombined64', 'quantilesTDigestWeighted', 'simpleLinearRegression', 'intervalLengthSum', 'quantiles', 'quantileTimingWeighted', 'histogram', 'meanZTest', 'quantilesExactLow', 'retention', 'groupBitXor', 'windowFunnel', 'stddevPop', 'anyHeavy', 'uniqHLL12', 'quantileExactLow', 'skewSamp', 'rankCorr', 'argMax', 'quantilesTiming', 'cramersV', 'quantilesBFloat16Weighted', 'contingency', 'skewPop', 'groupArrayMovingSum', 'quantilesExactWeighted', 'groupBitmapOr', 'sequenceCount', 'exponentialTimeDecayedAvg', 'sumKahan', 'quantilesInterpolatedWeighted', 'uniqTheta', 'quantileInterpolatedWeighted', 'quantileExactWeighted', 'exponentialMovingAverage', 'anyLast', 'sumWithOverflow', 'quantileExact', 'groupArrayLast', 'groupBitmapXor', 'quantilesBFloat16', 'boundingRatio', 'quantileDeterministic', 'theilsU', 'groupBitAnd', 'uniqExact', 'groupArray', 'quantilesGK', 'deltaSumTimestamp', 'sparkBar', 'stochasticLinearRegression', 'groupUniqArray', 'stddevSamp', 'groupArrayMovingAvg', 'entropy', 'studentTTest'}
AGG_FUNCTIONS_SUFFIXES = ['If', 'Array', 'ArrayIf', 'Map', 'SimpleState', 'State', 'Merge', 'MergeState', 'ForEach', 'Distinct', 'OrDefault', 'OrNull', 'Resample', 'ArgMin', 'ArgMax']
FUNC_TOKENS = {<TokenType.NULL: 'NULL'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.ANY: 'ANY'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.ALL: 'ALL'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.SET: 'SET'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.NAME: 'NAME'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.BINARY: 'BINARY'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.MERGE: 'MERGE'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.INT: 'INT'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.RLIKE: 'RLIKE'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.UUID: 'UUID'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.NESTED: 'NESTED'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.YEAR: 'YEAR'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.INT128: 'INT128'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.IPV6: 'IPV6'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.UINT256: 'UINT256'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.INT256: 'INT256'>, <TokenType.UINT128: 'UINT128'>, <TokenType.INDEX: 'INDEX'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.LEFT: 'LEFT'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.SOME: 'SOME'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.CHAR: 'CHAR'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.ILIKE: 'ILIKE'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.ROW: 'ROW'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.RANGE: 'RANGE'>, <TokenType.DATE: 'DATE'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.BIT: 'BIT'>, <TokenType.FILTER: 'FILTER'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.INET: 'INET'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.TIME: 'TIME'>, <TokenType.FIRST: 'FIRST'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.TABLE: 'TABLE'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.ENUM: 'ENUM'>, <TokenType.SUPER: 'SUPER'>, <TokenType.TEXT: 'TEXT'>, <TokenType.MAP: 'MAP'>, <TokenType.GLOB: 'GLOB'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.DATE32: 'DATE32'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.XML: 'XML'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.LIKE: 'LIKE'>, <TokenType.MONEY: 'MONEY'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.JSONB: 'JSONB'>, <TokenType.VAR: 'VAR'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.JSON: 'JSON'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.XOR: 'XOR'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.INSERT: 'INSERT'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.UINT: 'UINT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.EXISTS: 'EXISTS'>}
AGG_FUNC_MAPPING = {'categoricalInformationValueIf': ('categoricalInformationValue', 'If'), 'groupArrayInsertAtIf': ('groupArrayInsertAt', 'If'), 'quantilesTDigestIf': ('quantilesTDigest', 'If'), 'groupArraySampleIf': ('groupArraySample', 'If'), 'quantileBFloat16If': ('quantileBFloat16', 'If'), 'covarSampIf': ('covarSamp', 'If'), 'quantilesExactIf': ('quantilesExact', 'If'), 'maxIntersectionsIf': ('maxIntersections', 'If'), 'medianIf': ('median', 'If'), 'largestTriangleThreeBucketsIf': ('largestTriangleThreeBuckets', 'If'), 'uniqIf': ('uniq', 'If'), 'avgIf': ('avg', 'If'), 'groupBitmapAndIf': ('groupBitmapAnd', 'If'), 'quantileIf': ('quantile', 'If'), 'quantilesTimingWeightedIf': ('quantilesTimingWeighted', 'If'), 'cramersVBiasCorrectedIf': ('cramersVBiasCorrected', 'If'), 'maxIntersectionsPositionIf': ('maxIntersectionsPosition', 'If'), 'quantilesDeterministicIf': ('quantilesDeterministic', 'If'), 'quantileGKIf': ('quantileGK', 'If'), 'kurtPopIf': ('kurtPop', 'If'), 'corrIf': ('corr', 'If'), 'kolmogorovSmirnovTestIf': ('kolmogorovSmirnovTest', 'If'), 'argMinIf': ('argMin', 'If'), 'countIf': ('count', 'If'), 'sequenceNextNodeIf': ('sequenceNextNode', 'If'), 'topKIf': ('topK', 'If'), 'first_valueIf': ('first_value', 'If'), 'stochasticLogisticRegressionIf': ('stochasticLogisticRegression', 'If'), 'quantileExactHighIf': ('quantileExactHigh', 'If'), 'minMapIf': ('minMap', 'If'), 'sumMapIf': ('sumMap', 'If'), 'maxMapIf': ('maxMap', 'If'), 'kurtSampIf': ('kurtSamp', 'If'), 'quantileTDigestIf': ('quantileTDigest', 'If'), 'deltaSumIf': ('deltaSum', 'If'), 'groupBitOrIf': ('groupBitOr', 'If'), 'maxIf': ('max', 'If'), 'sumIf': ('sum', 'If'), 'anyIf': ('any', 'If'), 'quantilesExactHighIf': ('quantilesExactHigh', 'If'), 'uniqUpToIf': ('uniqUpTo', 'If'), 'avgWeightedIf': ('avgWeighted', 'If'), 'sequenceMatchIf': ('sequenceMatch', 'If'), 'mannWhitneyUTestIf': ('mannWhitneyUTest', 'If'), 'sumCountIf': ('sumCount', 'If'), 'topKWeightedIf': ('topKWeighted', 'If'), 'last_valueIf': ('last_value', 'If'), 'quantileBFloat16WeightedIf': ('quantileBFloat16Weighted', 'If'), 'minIf': ('min', 'If'), 'quantileTDigestWeightedIf': ('quantileTDigestWeighted', 'If'), 'uniqCombinedIf': ('uniqCombined', 'If'), 'varPopIf': ('varPop', 'If'), 'varSampIf': ('varSamp', 'If'), 'quantileTimingIf': ('quantileTiming', 'If'), 'groupBitmapIf': ('groupBitmap', 'If'), 'covarPopIf': ('covarPop', 'If'), 'welchTTestIf': ('welchTTest', 'If'), 'uniqCombined64If': ('uniqCombined64', 'If'), 'quantilesTDigestWeightedIf': ('quantilesTDigestWeighted', 'If'), 'simpleLinearRegressionIf': ('simpleLinearRegression', 'If'), 'intervalLengthSumIf': ('intervalLengthSum', 'If'), 'quantilesIf': ('quantiles', 'If'), 'quantileTimingWeightedIf': ('quantileTimingWeighted', 'If'), 'histogramIf': ('histogram', 'If'), 'meanZTestIf': ('meanZTest', 'If'), 'quantilesExactLowIf': ('quantilesExactLow', 'If'), 'retentionIf': ('retention', 'If'), 'groupBitXorIf': ('groupBitXor', 'If'), 'windowFunnelIf': ('windowFunnel', 'If'), 'stddevPopIf': ('stddevPop', 'If'), 'anyHeavyIf': ('anyHeavy', 'If'), 'uniqHLL12If': ('uniqHLL12', 'If'), 'quantileExactLowIf': ('quantileExactLow', 'If'), 'skewSampIf': ('skewSamp', 'If'), 'rankCorrIf': ('rankCorr', 'If'), 'argMaxIf': ('argMax', 'If'), 'quantilesTimingIf': ('quantilesTiming', 'If'), 'cramersVIf': ('cramersV', 'If'), 'quantilesBFloat16WeightedIf': ('quantilesBFloat16Weighted', 'If'), 'contingencyIf': ('contingency', 'If'), 'skewPopIf': ('skewPop', 'If'), 'groupArrayMovingSumIf': ('groupArrayMovingSum', 'If'), 'quantilesExactWeightedIf': ('quantilesExactWeighted', 'If'), 'groupBitmapOrIf': ('groupBitmapOr', 'If'), 'sequenceCountIf': ('sequenceCount', 'If'), 'exponentialTimeDecayedAvgIf': ('exponentialTimeDecayedAvg', 'If'), 'sumKahanIf': ('sumKahan', 'If'), 'quantilesInterpolatedWeightedIf': ('quantilesInterpolatedWeighted', 'If'), 'uniqThetaIf': ('uniqTheta', 'If'), 'quantileInterpolatedWeightedIf': ('quantileInterpolatedWeighted', 'If'), 'quantileExactWeightedIf': ('quantileExactWeighted', 'If'), 'exponentialMovingAverageIf': ('exponentialMovingAverage', 'If'), 'anyLastIf': ('anyLast', 'If'), 'sumWithOverflowIf': ('sumWithOverflow', 'If'), 'quantileExactIf': ('quantileExact', 'If'), 'groupArrayLastIf': ('groupArrayLast', 'If'), 'groupBitmapXorIf': ('groupBitmapXor', 'If'), 'quantilesBFloat16If': ('quantilesBFloat16', 'If'), 'boundingRatioIf': ('boundingRatio', 'If'), 'quantileDeterministicIf': ('quantileDeterministic', 'If'), 'theilsUIf': ('theilsU', 'If'), 'groupBitAndIf': ('groupBitAnd', 'If'), 'uniqExactIf': ('uniqExact', 'If'), 'groupArrayIf': ('groupArray', 'If'), 'quantilesGKIf': ('quantilesGK', 'If'), 'deltaSumTimestampIf': ('deltaSumTimestamp', 'If'), 'sparkBarIf': ('sparkBar', 'If'), 'stochasticLinearRegressionIf': ('stochasticLinearRegression', 'If'), 'groupUniqArrayIf': ('groupUniqArray', 'If'), 'stddevSampIf': ('stddevSamp', 'If'), 'groupArrayMovingAvgIf': ('groupArrayMovingAvg', 'If'), 'entropyIf': ('entropy', 'If'), 'studentTTestIf': ('studentTTest', 'If'), 'categoricalInformationValueArray': ('categoricalInformationValue', 'Array'), 'groupArrayInsertAtArray': ('groupArrayInsertAt', 'Array'), 'quantilesTDigestArray': ('quantilesTDigest', 'Array'), 'groupArraySampleArray': ('groupArraySample', 'Array'), 'quantileBFloat16Array': ('quantileBFloat16', 'Array'), 'covarSampArray': ('covarSamp', 'Array'), 'quantilesExactArray': ('quantilesExact', 'Array'), 'maxIntersectionsArray': ('maxIntersections', 'Array'), 'medianArray': ('median', 'Array'), 'largestTriangleThreeBucketsArray': ('largestTriangleThreeBuckets', 'Array'), 'uniqArray': ('uniq', 'Array'), 'avgArray': ('avg', 'Array'), 'groupBitmapAndArray': ('groupBitmapAnd', 'Array'), 'quantileArray': ('quantile', 'Array'), 'quantilesTimingWeightedArray': ('quantilesTimingWeighted', 'Array'), 'cramersVBiasCorrectedArray': ('cramersVBiasCorrected', 'Array'), 'maxIntersectionsPositionArray': ('maxIntersectionsPosition', 'Array'), 'quantilesDeterministicArray': ('quantilesDeterministic', 'Array'), 'quantileGKArray': ('quantileGK', 'Array'), 'kurtPopArray': ('kurtPop', 'Array'), 'corrArray': ('corr', 'Array'), 'kolmogorovSmirnovTestArray': ('kolmogorovSmirnovTest', 'Array'), 'argMinArray': ('argMin', 'Array'), 'countArray': ('count', 'Array'), 'sequenceNextNodeArray': ('sequenceNextNode', 'Array'), 'topKArray': ('topK', 'Array'), 'first_valueArray': ('first_value', 'Array'), 'stochasticLogisticRegressionArray': ('stochasticLogisticRegression', 'Array'), 'quantileExactHighArray': ('quantileExactHigh', 'Array'), 'minMapArray': ('minMap', 'Array'), 'sumMapArray': ('sumMap', 'Array'), 'maxMapArray': ('maxMap', 'Array'), 'kurtSampArray': ('kurtSamp', 'Array'), 'quantileTDigestArray': ('quantileTDigest', 'Array'), 'deltaSumArray': ('deltaSum', 'Array'), 'groupBitOrArray': ('groupBitOr', 'Array'), 'maxArray': ('max', 'Array'), 'sumArray': ('sum', 'Array'), 'anyArray': ('any', 'Array'), 'quantilesExactHighArray': ('quantilesExactHigh', 'Array'), 'uniqUpToArray': ('uniqUpTo', 'Array'), 'avgWeightedArray': ('avgWeighted', 'Array'), 'sequenceMatchArray': ('sequenceMatch', 'Array'), 'mannWhitneyUTestArray': ('mannWhitneyUTest', 'Array'), 'sumCountArray': ('sumCount', 'Array'), 'topKWeightedArray': ('topKWeighted', 'Array'), 'last_valueArray': ('last_value', 'Array'), 'quantileBFloat16WeightedArray': ('quantileBFloat16Weighted', 'Array'), 'minArray': ('min', 'Array'), 'quantileTDigestWeightedArray': ('quantileTDigestWeighted', 'Array'), 'uniqCombinedArray': ('uniqCombined', 'Array'), 'varPopArray': ('varPop', 'Array'), 'varSampArray': ('varSamp', 'Array'), 'quantileTimingArray': ('quantileTiming', 'Array'), 'groupBitmapArray': ('groupBitmap', 'Array'), 'covarPopArray': ('covarPop', 'Array'), 'welchTTestArray': ('welchTTest', 'Array'), 'uniqCombined64Array': ('uniqCombined64', 'Array'), 'quantilesTDigestWeightedArray': ('quantilesTDigestWeighted', 'Array'), 'simpleLinearRegressionArray': ('simpleLinearRegression', 'Array'), 'intervalLengthSumArray': ('intervalLengthSum', 'Array'), 'quantilesArray': ('quantiles', 'Array'), 'quantileTimingWeightedArray': ('quantileTimingWeighted', 'Array'), 'histogramArray': ('histogram', 'Array'), 'meanZTestArray': ('meanZTest', 'Array'), 'quantilesExactLowArray': ('quantilesExactLow', 'Array'), 'retentionArray': ('retention', 'Array'), 'groupBitXorArray': ('groupBitXor', 'Array'), 'windowFunnelArray': ('windowFunnel', 'Array'), 'stddevPopArray': ('stddevPop', 'Array'), 'anyHeavyArray': ('anyHeavy', 'Array'), 'uniqHLL12Array': ('uniqHLL12', 'Array'), 'quantileExactLowArray': ('quantileExactLow', 'Array'), 'skewSampArray': ('skewSamp', 'Array'), 'rankCorrArray': ('rankCorr', 'Array'), 'argMaxArray': ('argMax', 'Array'), 'quantilesTimingArray': ('quantilesTiming', 'Array'), 'cramersVArray': ('cramersV', 'Array'), 'quantilesBFloat16WeightedArray': ('quantilesBFloat16Weighted', 'Array'), 'contingencyArray': ('contingency', 'Array'), 'skewPopArray': ('skewPop', 'Array'), 'groupArrayMovingSumArray': ('groupArrayMovingSum', 'Array'), 'quantilesExactWeightedArray': ('quantilesExactWeighted', 'Array'), 'groupBitmapOrArray': ('groupBitmapOr', 'Array'), 'sequenceCountArray': ('sequenceCount', 'Array'), 'exponentialTimeDecayedAvgArray': ('exponentialTimeDecayedAvg', 'Array'), 'sumKahanArray': ('sumKahan', 'Array'), 'quantilesInterpolatedWeightedArray': ('quantilesInterpolatedWeighted', 'Array'), 'uniqThetaArray': ('uniqTheta', 'Array'), 'quantileInterpolatedWeightedArray': ('quantileInterpolatedWeighted', 'Array'), 'quantileExactWeightedArray': ('quantileExactWeighted', 'Array'), 'exponentialMovingAverageArray': ('exponentialMovingAverage', 'Array'), 'anyLastArray': ('anyLast', 'Array'), 'sumWithOverflowArray': ('sumWithOverflow', 'Array'), 'quantileExactArray': ('quantileExact', 'Array'), 'groupArrayLastArray': ('groupArrayLast', 'Array'), 'groupBitmapXorArray': ('groupBitmapXor', 'Array'), 'quantilesBFloat16Array': ('quantilesBFloat16', 'Array'), 'boundingRatioArray': ('boundingRatio', 'Array'), 'quantileDeterministicArray': ('quantileDeterministic', 'Array'), 'theilsUArray': ('theilsU', 'Array'), 'groupBitAndArray': ('groupBitAnd', 'Array'), 'uniqExactArray': ('uniqExact', 'Array'), 'groupArrayArray': ('groupArray', 'Array'), 'quantilesGKArray': ('quantilesGK', 'Array'), 'deltaSumTimestampArray': ('deltaSumTimestamp', 'Array'), 'sparkBarArray': ('sparkBar', 'Array'), 'stochasticLinearRegressionArray': ('stochasticLinearRegression', 'Array'), 'groupUniqArrayArray': ('groupUniqArray', 'Array'), 'stddevSampArray': ('stddevSamp', 'Array'), 'groupArrayMovingAvgArray': ('groupArrayMovingAvg', 'Array'), 'entropyArray': ('entropy', 'Array'), 'studentTTestArray': ('studentTTest', 'Array'), 'categoricalInformationValueArrayIf': ('categoricalInformationValue', 'ArrayIf'), 'groupArrayInsertAtArrayIf': ('groupArrayInsertAt', 'ArrayIf'), 'quantilesTDigestArrayIf': ('quantilesTDigest', 'ArrayIf'), 'groupArraySampleArrayIf': ('groupArraySample', 'ArrayIf'), 'quantileBFloat16ArrayIf': ('quantileBFloat16', 'ArrayIf'), 'covarSampArrayIf': ('covarSamp', 'ArrayIf'), 'quantilesExactArrayIf': ('quantilesExact', 'ArrayIf'), 'maxIntersectionsArrayIf': ('maxIntersections', 'ArrayIf'), 'medianArrayIf': ('median', 'ArrayIf'), 'largestTriangleThreeBucketsArrayIf': ('largestTriangleThreeBuckets', 'ArrayIf'), 'uniqArrayIf': ('uniq', 'ArrayIf'), 'avgArrayIf': ('avg', 'ArrayIf'), 'groupBitmapAndArrayIf': ('groupBitmapAnd', 'ArrayIf'), 'quantileArrayIf': ('quantile', 'ArrayIf'), 'quantilesTimingWeightedArrayIf': ('quantilesTimingWeighted', 'ArrayIf'), 'cramersVBiasCorrectedArrayIf': ('cramersVBiasCorrected', 'ArrayIf'), 'maxIntersectionsPositionArrayIf': ('maxIntersectionsPosition', 'ArrayIf'), 'quantilesDeterministicArrayIf': ('quantilesDeterministic', 'ArrayIf'), 'quantileGKArrayIf': ('quantileGK', 'ArrayIf'), 'kurtPopArrayIf': ('kurtPop', 'ArrayIf'), 'corrArrayIf': ('corr', 'ArrayIf'), 'kolmogorovSmirnovTestArrayIf': ('kolmogorovSmirnovTest', 'ArrayIf'), 'argMinArrayIf': ('argMin', 'ArrayIf'), 'countArrayIf': ('count', 'ArrayIf'), 'sequenceNextNodeArrayIf': ('sequenceNextNode', 'ArrayIf'), 'topKArrayIf': ('topK', 'ArrayIf'), 'first_valueArrayIf': ('first_value', 'ArrayIf'), 'stochasticLogisticRegressionArrayIf': ('stochasticLogisticRegression', 'ArrayIf'), 'quantileExactHighArrayIf': ('quantileExactHigh', 'ArrayIf'), 'minMapArrayIf': ('minMap', 'ArrayIf'), 'sumMapArrayIf': ('sumMap', 'ArrayIf'), 'maxMapArrayIf': ('maxMap', 'ArrayIf'), 'kurtSampArrayIf': ('kurtSamp', 'ArrayIf'), 'quantileTDigestArrayIf': ('quantileTDigest', 'ArrayIf'), 'deltaSumArrayIf': ('deltaSum', 'ArrayIf'), 'groupBitOrArrayIf': ('groupBitOr', 'ArrayIf'), 'maxArrayIf': ('max', 'ArrayIf'), 'sumArrayIf': ('sum', 'ArrayIf'), 'anyArrayIf': ('any', 'ArrayIf'), 'quantilesExactHighArrayIf': ('quantilesExactHigh', 'ArrayIf'), 'uniqUpToArrayIf': ('uniqUpTo', 'ArrayIf'), 'avgWeightedArrayIf': ('avgWeighted', 'ArrayIf'), 'sequenceMatchArrayIf': ('sequenceMatch', 'ArrayIf'), 'mannWhitneyUTestArrayIf': ('mannWhitneyUTest', 'ArrayIf'), 'sumCountArrayIf': ('sumCount', 'ArrayIf'), 'topKWeightedArrayIf': ('topKWeighted', 'ArrayIf'), 'last_valueArrayIf': ('last_value', 'ArrayIf'), 'quantileBFloat16WeightedArrayIf': ('quantileBFloat16Weighted', 'ArrayIf'), 'minArrayIf': ('min', 'ArrayIf'), 'quantileTDigestWeightedArrayIf': ('quantileTDigestWeighted', 'ArrayIf'), 'uniqCombinedArrayIf': ('uniqCombined', 'ArrayIf'), 'varPopArrayIf': ('varPop', 'ArrayIf'), 'varSampArrayIf': ('varSamp', 'ArrayIf'), 'quantileTimingArrayIf': ('quantileTiming', 'ArrayIf'), 'groupBitmapArrayIf': ('groupBitmap', 'ArrayIf'), 'covarPopArrayIf': ('covarPop', 'ArrayIf'), 'welchTTestArrayIf': ('welchTTest', 'ArrayIf'), 'uniqCombined64ArrayIf': ('uniqCombined64', 'ArrayIf'), 'quantilesTDigestWeightedArrayIf': ('quantilesTDigestWeighted', 'ArrayIf'), 'simpleLinearRegressionArrayIf': ('simpleLinearRegression', 'ArrayIf'), 'intervalLengthSumArrayIf': ('intervalLengthSum', 'ArrayIf'), 'quantilesArrayIf': ('quantiles', 'ArrayIf'), 'quantileTimingWeightedArrayIf': ('quantileTimingWeighted', 'ArrayIf'), 'histogramArrayIf': ('histogram', 'ArrayIf'), 'meanZTestArrayIf': ('meanZTest', 'ArrayIf'), 'quantilesExactLowArrayIf': ('quantilesExactLow', 'ArrayIf'), 'retentionArrayIf': ('retention', 'ArrayIf'), 'groupBitXorArrayIf': ('groupBitXor', 'ArrayIf'), 'windowFunnelArrayIf': ('windowFunnel', 'ArrayIf'), 'stddevPopArrayIf': ('stddevPop', 'ArrayIf'), 'anyHeavyArrayIf': ('anyHeavy', 'ArrayIf'), 'uniqHLL12ArrayIf': ('uniqHLL12', 'ArrayIf'), 'quantileExactLowArrayIf': ('quantileExactLow', 'ArrayIf'), 'skewSampArrayIf': ('skewSamp', 'ArrayIf'), 'rankCorrArrayIf': ('rankCorr', 'ArrayIf'), 'argMaxArrayIf': ('argMax', 'ArrayIf'), 'quantilesTimingArrayIf': ('quantilesTiming', 'ArrayIf'), 'cramersVArrayIf': ('cramersV', 'ArrayIf'), 'quantilesBFloat16WeightedArrayIf': ('quantilesBFloat16Weighted', 'ArrayIf'), 'contingencyArrayIf': ('contingency', 'ArrayIf'), 'skewPopArrayIf': ('skewPop', 'ArrayIf'), 'groupArrayMovingSumArrayIf': ('groupArrayMovingSum', 'ArrayIf'), 'quantilesExactWeightedArrayIf': ('quantilesExactWeighted', 'ArrayIf'), 'groupBitmapOrArrayIf': ('groupBitmapOr', 'ArrayIf'), 'sequenceCountArrayIf': ('sequenceCount', 'ArrayIf'), 'exponentialTimeDecayedAvgArrayIf': ('exponentialTimeDecayedAvg', 'ArrayIf'), 'sumKahanArrayIf': ('sumKahan', 'ArrayIf'), 'quantilesInterpolatedWeightedArrayIf': ('quantilesInterpolatedWeighted', 'ArrayIf'), 'uniqThetaArrayIf': ('uniqTheta', 'ArrayIf'), 'quantileInterpolatedWeightedArrayIf': ('quantileInterpolatedWeighted', 'ArrayIf'), 'quantileExactWeightedArrayIf': ('quantileExactWeighted', 'ArrayIf'), 'exponentialMovingAverageArrayIf': ('exponentialMovingAverage', 'ArrayIf'), 'anyLastArrayIf': ('anyLast', 'ArrayIf'), 'sumWithOverflowArrayIf': ('sumWithOverflow', 'ArrayIf'), 'quantileExactArrayIf': ('quantileExact', 'ArrayIf'), 'groupArrayLastArrayIf': ('groupArrayLast', 'ArrayIf'), 'groupBitmapXorArrayIf': ('groupBitmapXor', 'ArrayIf'), 'quantilesBFloat16ArrayIf': ('quantilesBFloat16', 'ArrayIf'), 'boundingRatioArrayIf': ('boundingRatio', 'ArrayIf'), 'quantileDeterministicArrayIf': ('quantileDeterministic', 'ArrayIf'), 'theilsUArrayIf': ('theilsU', 'ArrayIf'), 'groupBitAndArrayIf': ('groupBitAnd', 'ArrayIf'), 'uniqExactArrayIf': ('uniqExact', 'ArrayIf'), 'groupArrayArrayIf': ('groupArray', 'ArrayIf'), 'quantilesGKArrayIf': ('quantilesGK', 'ArrayIf'), 'deltaSumTimestampArrayIf': ('deltaSumTimestamp', 'ArrayIf'), 'sparkBarArrayIf': ('sparkBar', 'ArrayIf'), 'stochasticLinearRegressionArrayIf': ('stochasticLinearRegression', 'ArrayIf'), 'groupUniqArrayArrayIf': ('groupUniqArray', 'ArrayIf'), 'stddevSampArrayIf': ('stddevSamp', 'ArrayIf'), 'groupArrayMovingAvgArrayIf': ('groupArrayMovingAvg', 'ArrayIf'), 'entropyArrayIf': ('entropy', 'ArrayIf'), 'studentTTestArrayIf': ('studentTTest', 'ArrayIf'), 'categoricalInformationValueMap': ('categoricalInformationValue', 'Map'), 'groupArrayInsertAtMap': ('groupArrayInsertAt', 'Map'), 'quantilesTDigestMap': ('quantilesTDigest', 'Map'), 'groupArraySampleMap': ('groupArraySample', 'Map'), 'quantileBFloat16Map': ('quantileBFloat16', 'Map'), 'covarSampMap': ('covarSamp', 'Map'), 'quantilesExactMap': ('quantilesExact', 'Map'), 'maxIntersectionsMap': ('maxIntersections', 'Map'), 'medianMap': ('median', 'Map'), 'largestTriangleThreeBucketsMap': ('largestTriangleThreeBuckets', 'Map'), 'uniqMap': ('uniq', 'Map'), 'avgMap': ('avg', 'Map'), 'groupBitmapAndMap': ('groupBitmapAnd', 'Map'), 'quantileMap': ('quantile', 'Map'), 'quantilesTimingWeightedMap': ('quantilesTimingWeighted', 'Map'), 'cramersVBiasCorrectedMap': ('cramersVBiasCorrected', 'Map'), 'maxIntersectionsPositionMap': ('maxIntersectionsPosition', 'Map'), 'quantilesDeterministicMap': ('quantilesDeterministic', 'Map'), 'quantileGKMap': ('quantileGK', 'Map'), 'kurtPopMap': ('kurtPop', 'Map'), 'corrMap': ('corr', 'Map'), 'kolmogorovSmirnovTestMap': ('kolmogorovSmirnovTest', 'Map'), 'argMinMap': ('argMin', 'Map'), 'countMap': ('count', 'Map'), 'sequenceNextNodeMap': ('sequenceNextNode', 'Map'), 'topKMap': ('topK', 'Map'), 'first_valueMap': ('first_value', 'Map'), 'stochasticLogisticRegressionMap': ('stochasticLogisticRegression', 'Map'), 'quantileExactHighMap': ('quantileExactHigh', 'Map'), 'minMapMap': ('minMap', 'Map'), 'sumMapMap': ('sumMap', 'Map'), 'maxMapMap': ('maxMap', 'Map'), 'kurtSampMap': ('kurtSamp', 'Map'), 'quantileTDigestMap': ('quantileTDigest', 'Map'), 'deltaSumMap': ('deltaSum', 'Map'), 'groupBitOrMap': ('groupBitOr', 'Map'), 'maxMap': ('maxMap', ''), 'sumMap': ('sumMap', ''), 'anyMap': ('any', 'Map'), 'quantilesExactHighMap': ('quantilesExactHigh', 'Map'), 'uniqUpToMap': ('uniqUpTo', 'Map'), 'avgWeightedMap': ('avgWeighted', 'Map'), 'sequenceMatchMap': ('sequenceMatch', 'Map'), 'mannWhitneyUTestMap': ('mannWhitneyUTest', 'Map'), 'sumCountMap': ('sumCount', 'Map'), 'topKWeightedMap': ('topKWeighted', 'Map'), 'last_valueMap': ('last_value', 'Map'), 'quantileBFloat16WeightedMap': ('quantileBFloat16Weighted', 'Map'), 'minMap': ('minMap', ''), 'quantileTDigestWeightedMap': ('quantileTDigestWeighted', 'Map'), 'uniqCombinedMap': ('uniqCombined', 'Map'), 'varPopMap': ('varPop', 'Map'), 'varSampMap': ('varSamp', 'Map'), 'quantileTimingMap': ('quantileTiming', 'Map'), 'groupBitmapMap': ('groupBitmap', 'Map'), 'covarPopMap': ('covarPop', 'Map'), 'welchTTestMap': ('welchTTest', 'Map'), 'uniqCombined64Map': ('uniqCombined64', 'Map'), 'quantilesTDigestWeightedMap': ('quantilesTDigestWeighted', 'Map'), 'simpleLinearRegressionMap': ('simpleLinearRegression', 'Map'), 'intervalLengthSumMap': ('intervalLengthSum', 'Map'), 'quantilesMap': ('quantiles', 'Map'), 'quantileTimingWeightedMap': ('quantileTimingWeighted', 'Map'), 'histogramMap': ('histogram', 'Map'), 'meanZTestMap': ('meanZTest', 'Map'), 'quantilesExactLowMap': ('quantilesExactLow', 'Map'), 'retentionMap': ('retention', 'Map'), 'groupBitXorMap': ('groupBitXor', 'Map'), 'windowFunnelMap': ('windowFunnel', 'Map'), 'stddevPopMap': ('stddevPop', 'Map'), 'anyHeavyMap': ('anyHeavy', 'Map'), 'uniqHLL12Map': ('uniqHLL12', 'Map'), 'quantileExactLowMap': ('quantileExactLow', 'Map'), 'skewSampMap': ('skewSamp', 'Map'), 'rankCorrMap': ('rankCorr', 'Map'), 'argMaxMap': ('argMax', 'Map'), 'quantilesTimingMap': ('quantilesTiming', 'Map'), 'cramersVMap': ('cramersV', 'Map'), 'quantilesBFloat16WeightedMap': ('quantilesBFloat16Weighted', 'Map'), 'contingencyMap': ('contingency', 'Map'), 'skewPopMap': ('skewPop', 'Map'), 'groupArrayMovingSumMap': ('groupArrayMovingSum', 'Map'), 'quantilesExactWeightedMap': ('quantilesExactWeighted', 'Map'), 'groupBitmapOrMap': ('groupBitmapOr', 'Map'), 'sequenceCountMap': ('sequenceCount', 'Map'), 'exponentialTimeDecayedAvgMap': ('exponentialTimeDecayedAvg', 'Map'), 'sumKahanMap': ('sumKahan', 'Map'), 'quantilesInterpolatedWeightedMap': ('quantilesInterpolatedWeighted', 'Map'), 'uniqThetaMap': ('uniqTheta', 'Map'), 'quantileInterpolatedWeightedMap': ('quantileInterpolatedWeighted', 'Map'), 'quantileExactWeightedMap': ('quantileExactWeighted', 'Map'), 'exponentialMovingAverageMap': ('exponentialMovingAverage', 'Map'), 'anyLastMap': ('anyLast', 'Map'), 'sumWithOverflowMap': ('sumWithOverflow', 'Map'), 'quantileExactMap': ('quantileExact', 'Map'), 'groupArrayLastMap': ('groupArrayLast', 'Map'), 'groupBitmapXorMap': ('groupBitmapXor', 'Map'), 'quantilesBFloat16Map': ('quantilesBFloat16', 'Map'), 'boundingRatioMap': ('boundingRatio', 'Map'), 'quantileDeterministicMap': ('quantileDeterministic', 'Map'), 'theilsUMap': ('theilsU', 'Map'), 'groupBitAndMap': ('groupBitAnd', 'Map'), 'uniqExactMap': ('uniqExact', 'Map'), 'groupArrayMap': ('groupArray', 'Map'), 'quantilesGKMap': ('quantilesGK', 'Map'), 'deltaSumTimestampMap': ('deltaSumTimestamp', 'Map'), 'sparkBarMap': ('sparkBar', 'Map'), 'stochasticLinearRegressionMap': ('stochasticLinearRegression', 'Map'), 'groupUniqArrayMap': ('groupUniqArray', 'Map'), 'stddevSampMap': ('stddevSamp', 'Map'), 'groupArrayMovingAvgMap': ('groupArrayMovingAvg', 'Map'), 'entropyMap': ('entropy', 'Map'), 'studentTTestMap': ('studentTTest', 'Map'), 'categoricalInformationValueSimpleState': ('categoricalInformationValue', 'SimpleState'), 'groupArrayInsertAtSimpleState': ('groupArrayInsertAt', 'SimpleState'), 'quantilesTDigestSimpleState': ('quantilesTDigest', 'SimpleState'), 'groupArraySampleSimpleState': ('groupArraySample', 'SimpleState'), 'quantileBFloat16SimpleState': ('quantileBFloat16', 'SimpleState'), 'covarSampSimpleState': ('covarSamp', 'SimpleState'), 'quantilesExactSimpleState': ('quantilesExact', 'SimpleState'), 'maxIntersectionsSimpleState': ('maxIntersections', 'SimpleState'), 'medianSimpleState': ('median', 'SimpleState'), 'largestTriangleThreeBucketsSimpleState': ('largestTriangleThreeBuckets', 'SimpleState'), 'uniqSimpleState': ('uniq', 'SimpleState'), 'avgSimpleState': ('avg', 'SimpleState'), 'groupBitmapAndSimpleState': ('groupBitmapAnd', 'SimpleState'), 'quantileSimpleState': ('quantile', 'SimpleState'), 'quantilesTimingWeightedSimpleState': ('quantilesTimingWeighted', 'SimpleState'), 'cramersVBiasCorrectedSimpleState': ('cramersVBiasCorrected', 'SimpleState'), 'maxIntersectionsPositionSimpleState': ('maxIntersectionsPosition', 'SimpleState'), 'quantilesDeterministicSimpleState': ('quantilesDeterministic', 'SimpleState'), 'quantileGKSimpleState': ('quantileGK', 'SimpleState'), 'kurtPopSimpleState': ('kurtPop', 'SimpleState'), 'corrSimpleState': ('corr', 'SimpleState'), 'kolmogorovSmirnovTestSimpleState': ('kolmogorovSmirnovTest', 'SimpleState'), 'argMinSimpleState': ('argMin', 'SimpleState'), 'countSimpleState': ('count', 'SimpleState'), 'sequenceNextNodeSimpleState': ('sequenceNextNode', 'SimpleState'), 'topKSimpleState': ('topK', 'SimpleState'), 'first_valueSimpleState': ('first_value', 'SimpleState'), 'stochasticLogisticRegressionSimpleState': ('stochasticLogisticRegression', 'SimpleState'), 'quantileExactHighSimpleState': ('quantileExactHigh', 'SimpleState'), 'minMapSimpleState': ('minMap', 'SimpleState'), 'sumMapSimpleState': ('sumMap', 'SimpleState'), 'maxMapSimpleState': ('maxMap', 'SimpleState'), 'kurtSampSimpleState': ('kurtSamp', 'SimpleState'), 'quantileTDigestSimpleState': ('quantileTDigest', 'SimpleState'), 'deltaSumSimpleState': ('deltaSum', 'SimpleState'), 'groupBitOrSimpleState': ('groupBitOr', 'SimpleState'), 'maxSimpleState': ('max', 'SimpleState'), 'sumSimpleState': ('sum', 'SimpleState'), 'anySimpleState': ('any', 'SimpleState'), 'quantilesExactHighSimpleState': ('quantilesExactHigh', 'SimpleState'), 'uniqUpToSimpleState': ('uniqUpTo', 'SimpleState'), 'avgWeightedSimpleState': ('avgWeighted', 'SimpleState'), 'sequenceMatchSimpleState': ('sequenceMatch', 'SimpleState'), 'mannWhitneyUTestSimpleState': ('mannWhitneyUTest', 'SimpleState'), 'sumCountSimpleState': ('sumCount', 'SimpleState'), 'topKWeightedSimpleState': ('topKWeighted', 'SimpleState'), 'last_valueSimpleState': ('last_value', 'SimpleState'), 'quantileBFloat16WeightedSimpleState': ('quantileBFloat16Weighted', 'SimpleState'), 'minSimpleState': ('min', 'SimpleState'), 'quantileTDigestWeightedSimpleState': ('quantileTDigestWeighted', 'SimpleState'), 'uniqCombinedSimpleState': ('uniqCombined', 'SimpleState'), 'varPopSimpleState': ('varPop', 'SimpleState'), 'varSampSimpleState': ('varSamp', 'SimpleState'), 'quantileTimingSimpleState': ('quantileTiming', 'SimpleState'), 'groupBitmapSimpleState': ('groupBitmap', 'SimpleState'), 'covarPopSimpleState': ('covarPop', 'SimpleState'), 'welchTTestSimpleState': ('welchTTest', 'SimpleState'), 'uniqCombined64SimpleState': ('uniqCombined64', 'SimpleState'), 'quantilesTDigestWeightedSimpleState': ('quantilesTDigestWeighted', 'SimpleState'), 'simpleLinearRegressionSimpleState': ('simpleLinearRegression', 'SimpleState'), 'intervalLengthSumSimpleState': ('intervalLengthSum', 'SimpleState'), 'quantilesSimpleState': ('quantiles', 'SimpleState'), 'quantileTimingWeightedSimpleState': ('quantileTimingWeighted', 'SimpleState'), 'histogramSimpleState': ('histogram', 'SimpleState'), 'meanZTestSimpleState': ('meanZTest', 'SimpleState'), 'quantilesExactLowSimpleState': ('quantilesExactLow', 'SimpleState'), 'retentionSimpleState': ('retention', 'SimpleState'), 'groupBitXorSimpleState': ('groupBitXor', 'SimpleState'), 'windowFunnelSimpleState': ('windowFunnel', 'SimpleState'), 'stddevPopSimpleState': ('stddevPop', 'SimpleState'), 'anyHeavySimpleState': ('anyHeavy', 'SimpleState'), 'uniqHLL12SimpleState': ('uniqHLL12', 'SimpleState'), 'quantileExactLowSimpleState': ('quantileExactLow', 'SimpleState'), 'skewSampSimpleState': ('skewSamp', 'SimpleState'), 'rankCorrSimpleState': ('rankCorr', 'SimpleState'), 'argMaxSimpleState': ('argMax', 'SimpleState'), 'quantilesTimingSimpleState': ('quantilesTiming', 'SimpleState'), 'cramersVSimpleState': ('cramersV', 'SimpleState'), 'quantilesBFloat16WeightedSimpleState': ('quantilesBFloat16Weighted', 'SimpleState'), 'contingencySimpleState': ('contingency', 'SimpleState'), 'skewPopSimpleState': ('skewPop', 'SimpleState'), 'groupArrayMovingSumSimpleState': ('groupArrayMovingSum', 'SimpleState'), 'quantilesExactWeightedSimpleState': ('quantilesExactWeighted', 'SimpleState'), 'groupBitmapOrSimpleState': ('groupBitmapOr', 'SimpleState'), 'sequenceCountSimpleState': ('sequenceCount', 'SimpleState'), 'exponentialTimeDecayedAvgSimpleState': ('exponentialTimeDecayedAvg', 'SimpleState'), 'sumKahanSimpleState': ('sumKahan', 'SimpleState'), 'quantilesInterpolatedWeightedSimpleState': ('quantilesInterpolatedWeighted', 'SimpleState'), 'uniqThetaSimpleState': ('uniqTheta', 'SimpleState'), 'quantileInterpolatedWeightedSimpleState': ('quantileInterpolatedWeighted', 'SimpleState'), 'quantileExactWeightedSimpleState': ('quantileExactWeighted', 'SimpleState'), 'exponentialMovingAverageSimpleState': ('exponentialMovingAverage', 'SimpleState'), 'anyLastSimpleState': ('anyLast', 'SimpleState'), 'sumWithOverflowSimpleState': ('sumWithOverflow', 'SimpleState'), 'quantileExactSimpleState': ('quantileExact', 'SimpleState'), 'groupArrayLastSimpleState': ('groupArrayLast', 'SimpleState'), 'groupBitmapXorSimpleState': ('groupBitmapXor', 'SimpleState'), 'quantilesBFloat16SimpleState': ('quantilesBFloat16', 'SimpleState'), 'boundingRatioSimpleState': ('boundingRatio', 'SimpleState'), 'quantileDeterministicSimpleState': ('quantileDeterministic', 'SimpleState'), 'theilsUSimpleState': ('theilsU', 'SimpleState'), 'groupBitAndSimpleState': ('groupBitAnd', 'SimpleState'), 'uniqExactSimpleState': ('uniqExact', 'SimpleState'), 'groupArraySimpleState': ('groupArray', 'SimpleState'), 'quantilesGKSimpleState': ('quantilesGK', 'SimpleState'), 'deltaSumTimestampSimpleState': ('deltaSumTimestamp', 'SimpleState'), 'sparkBarSimpleState': ('sparkBar', 'SimpleState'), 'stochasticLinearRegressionSimpleState': ('stochasticLinearRegression', 'SimpleState'), 'groupUniqArraySimpleState': ('groupUniqArray', 'SimpleState'), 'stddevSampSimpleState': ('stddevSamp', 'SimpleState'), 'groupArrayMovingAvgSimpleState': ('groupArrayMovingAvg', 'SimpleState'), 'entropySimpleState': ('entropy', 'SimpleState'), 'studentTTestSimpleState': ('studentTTest', 'SimpleState'), 'categoricalInformationValueState': ('categoricalInformationValue', 'State'), 'groupArrayInsertAtState': ('groupArrayInsertAt', 'State'), 'quantilesTDigestState': ('quantilesTDigest', 'State'), 'groupArraySampleState': ('groupArraySample', 'State'), 'quantileBFloat16State': ('quantileBFloat16', 'State'), 'covarSampState': ('covarSamp', 'State'), 'quantilesExactState': ('quantilesExact', 'State'), 'maxIntersectionsState': ('maxIntersections', 'State'), 'medianState': ('median', 'State'), 'largestTriangleThreeBucketsState': ('largestTriangleThreeBuckets', 'State'), 'uniqState': ('uniq', 'State'), 'avgState': ('avg', 'State'), 'groupBitmapAndState': ('groupBitmapAnd', 'State'), 'quantileState': ('quantile', 'State'), 'quantilesTimingWeightedState': ('quantilesTimingWeighted', 'State'), 'cramersVBiasCorrectedState': ('cramersVBiasCorrected', 'State'), 'maxIntersectionsPositionState': ('maxIntersectionsPosition', 'State'), 'quantilesDeterministicState': ('quantilesDeterministic', 'State'), 'quantileGKState': ('quantileGK', 'State'), 'kurtPopState': ('kurtPop', 'State'), 'corrState': ('corr', 'State'), 'kolmogorovSmirnovTestState': ('kolmogorovSmirnovTest', 'State'), 'argMinState': ('argMin', 'State'), 'countState': ('count', 'State'), 'sequenceNextNodeState': ('sequenceNextNode', 'State'), 'topKState': ('topK', 'State'), 'first_valueState': ('first_value', 'State'), 'stochasticLogisticRegressionState': ('stochasticLogisticRegression', 'State'), 'quantileExactHighState': ('quantileExactHigh', 'State'), 'minMapState': ('minMap', 'State'), 'sumMapState': ('sumMap', 'State'), 'maxMapState': ('maxMap', 'State'), 'kurtSampState': ('kurtSamp', 'State'), 'quantileTDigestState': ('quantileTDigest', 'State'), 'deltaSumState': ('deltaSum', 'State'), 'groupBitOrState': ('groupBitOr', 'State'), 'maxState': ('max', 'State'), 'sumState': ('sum', 'State'), 'anyState': ('any', 'State'), 'quantilesExactHighState': ('quantilesExactHigh', 'State'), 'uniqUpToState': ('uniqUpTo', 'State'), 'avgWeightedState': ('avgWeighted', 'State'), 'sequenceMatchState': ('sequenceMatch', 'State'), 'mannWhitneyUTestState': ('mannWhitneyUTest', 'State'), 'sumCountState': ('sumCount', 'State'), 'topKWeightedState': ('topKWeighted', 'State'), 'last_valueState': ('last_value', 'State'), 'quantileBFloat16WeightedState': ('quantileBFloat16Weighted', 'State'), 'minState': ('min', 'State'), 'quantileTDigestWeightedState': ('quantileTDigestWeighted', 'State'), 'uniqCombinedState': ('uniqCombined', 'State'), 'varPopState': ('varPop', 'State'), 'varSampState': ('varSamp', 'State'), 'quantileTimingState': ('quantileTiming', 'State'), 'groupBitmapState': ('groupBitmap', 'State'), 'covarPopState': ('covarPop', 'State'), 'welchTTestState': ('welchTTest', 'State'), 'uniqCombined64State': ('uniqCombined64', 'State'), 'quantilesTDigestWeightedState': ('quantilesTDigestWeighted', 'State'), 'simpleLinearRegressionState': ('simpleLinearRegression', 'State'), 'intervalLengthSumState': ('intervalLengthSum', 'State'), 'quantilesState': ('quantiles', 'State'), 'quantileTimingWeightedState': ('quantileTimingWeighted', 'State'), 'histogramState': ('histogram', 'State'), 'meanZTestState': ('meanZTest', 'State'), 'quantilesExactLowState': ('quantilesExactLow', 'State'), 'retentionState': ('retention', 'State'), 'groupBitXorState': ('groupBitXor', 'State'), 'windowFunnelState': ('windowFunnel', 'State'), 'stddevPopState': ('stddevPop', 'State'), 'anyHeavyState': ('anyHeavy', 'State'), 'uniqHLL12State': ('uniqHLL12', 'State'), 'quantileExactLowState': ('quantileExactLow', 'State'), 'skewSampState': ('skewSamp', 'State'), 'rankCorrState': ('rankCorr', 'State'), 'argMaxState': ('argMax', 'State'), 'quantilesTimingState': ('quantilesTiming', 'State'), 'cramersVState': ('cramersV', 'State'), 'quantilesBFloat16WeightedState': ('quantilesBFloat16Weighted', 'State'), 'contingencyState': ('contingency', 'State'), 'skewPopState': ('skewPop', 'State'), 'groupArrayMovingSumState': ('groupArrayMovingSum', 'State'), 'quantilesExactWeightedState': ('quantilesExactWeighted', 'State'), 'groupBitmapOrState': ('groupBitmapOr', 'State'), 'sequenceCountState': ('sequenceCount', 'State'), 'exponentialTimeDecayedAvgState': ('exponentialTimeDecayedAvg', 'State'), 'sumKahanState': ('sumKahan', 'State'), 'quantilesInterpolatedWeightedState': ('quantilesInterpolatedWeighted', 'State'), 'uniqThetaState': ('uniqTheta', 'State'), 'quantileInterpolatedWeightedState': ('quantileInterpolatedWeighted', 'State'), 'quantileExactWeightedState': ('quantileExactWeighted', 'State'), 'exponentialMovingAverageState': ('exponentialMovingAverage', 'State'), 'anyLastState': ('anyLast', 'State'), 'sumWithOverflowState': ('sumWithOverflow', 'State'), 'quantileExactState': ('quantileExact', 'State'), 'groupArrayLastState': ('groupArrayLast', 'State'), 'groupBitmapXorState': ('groupBitmapXor', 'State'), 'quantilesBFloat16State': ('quantilesBFloat16', 'State'), 'boundingRatioState': ('boundingRatio', 'State'), 'quantileDeterministicState': ('quantileDeterministic', 'State'), 'theilsUState': ('theilsU', 'State'), 'groupBitAndState': ('groupBitAnd', 'State'), 'uniqExactState': ('uniqExact', 'State'), 'groupArrayState': ('groupArray', 'State'), 'quantilesGKState': ('quantilesGK', 'State'), 'deltaSumTimestampState': ('deltaSumTimestamp', 'State'), 'sparkBarState': ('sparkBar', 'State'), 'stochasticLinearRegressionState': ('stochasticLinearRegression', 'State'), 'groupUniqArrayState': ('groupUniqArray', 'State'), 'stddevSampState': ('stddevSamp', 'State'), 'groupArrayMovingAvgState': ('groupArrayMovingAvg', 'State'), 'entropyState': ('entropy', 'State'), 'studentTTestState': ('studentTTest', 'State'), 'categoricalInformationValueMerge': ('categoricalInformationValue', 'Merge'), 'groupArrayInsertAtMerge': ('groupArrayInsertAt', 'Merge'), 'quantilesTDigestMerge': ('quantilesTDigest', 'Merge'), 'groupArraySampleMerge': ('groupArraySample', 'Merge'), 'quantileBFloat16Merge': ('quantileBFloat16', 'Merge'), 'covarSampMerge': ('covarSamp', 'Merge'), 'quantilesExactMerge': ('quantilesExact', 'Merge'), 'maxIntersectionsMerge': ('maxIntersections', 'Merge'), 'medianMerge': ('median', 'Merge'), 'largestTriangleThreeBucketsMerge': ('largestTriangleThreeBuckets', 'Merge'), 'uniqMerge': ('uniq', 'Merge'), 'avgMerge': ('avg', 'Merge'), 'groupBitmapAndMerge': ('groupBitmapAnd', 'Merge'), 'quantileMerge': ('quantile', 'Merge'), 'quantilesTimingWeightedMerge': ('quantilesTimingWeighted', 'Merge'), 'cramersVBiasCorrectedMerge': ('cramersVBiasCorrected', 'Merge'), 'maxIntersectionsPositionMerge': ('maxIntersectionsPosition', 'Merge'), 'quantilesDeterministicMerge': ('quantilesDeterministic', 'Merge'), 'quantileGKMerge': ('quantileGK', 'Merge'), 'kurtPopMerge': ('kurtPop', 'Merge'), 'corrMerge': ('corr', 'Merge'), 'kolmogorovSmirnovTestMerge': ('kolmogorovSmirnovTest', 'Merge'), 'argMinMerge': ('argMin', 'Merge'), 'countMerge': ('count', 'Merge'), 'sequenceNextNodeMerge': ('sequenceNextNode', 'Merge'), 'topKMerge': ('topK', 'Merge'), 'first_valueMerge': ('first_value', 'Merge'), 'stochasticLogisticRegressionMerge': ('stochasticLogisticRegression', 'Merge'), 'quantileExactHighMerge': ('quantileExactHigh', 'Merge'), 'minMapMerge': ('minMap', 'Merge'), 'sumMapMerge': ('sumMap', 'Merge'), 'maxMapMerge': ('maxMap', 'Merge'), 'kurtSampMerge': ('kurtSamp', 'Merge'), 'quantileTDigestMerge': ('quantileTDigest', 'Merge'), 'deltaSumMerge': ('deltaSum', 'Merge'), 'groupBitOrMerge': ('groupBitOr', 'Merge'), 'maxMerge': ('max', 'Merge'), 'sumMerge': ('sum', 'Merge'), 'anyMerge': ('any', 'Merge'), 'quantilesExactHighMerge': ('quantilesExactHigh', 'Merge'), 'uniqUpToMerge': ('uniqUpTo', 'Merge'), 'avgWeightedMerge': ('avgWeighted', 'Merge'), 'sequenceMatchMerge': ('sequenceMatch', 'Merge'), 'mannWhitneyUTestMerge': ('mannWhitneyUTest', 'Merge'), 'sumCountMerge': ('sumCount', 'Merge'), 'topKWeightedMerge': ('topKWeighted', 'Merge'), 'last_valueMerge': ('last_value', 'Merge'), 'quantileBFloat16WeightedMerge': ('quantileBFloat16Weighted', 'Merge'), 'minMerge': ('min', 'Merge'), 'quantileTDigestWeightedMerge': ('quantileTDigestWeighted', 'Merge'), 'uniqCombinedMerge': ('uniqCombined', 'Merge'), 'varPopMerge': ('varPop', 'Merge'), 'varSampMerge': ('varSamp', 'Merge'), 'quantileTimingMerge': ('quantileTiming', 'Merge'), 'groupBitmapMerge': ('groupBitmap', 'Merge'), 'covarPopMerge': ('covarPop', 'Merge'), 'welchTTestMerge': ('welchTTest', 'Merge'), 'uniqCombined64Merge': ('uniqCombined64', 'Merge'), 'quantilesTDigestWeightedMerge': ('quantilesTDigestWeighted', 'Merge'), 'simpleLinearRegressionMerge': ('simpleLinearRegression', 'Merge'), 'intervalLengthSumMerge': ('intervalLengthSum', 'Merge'), 'quantilesMerge': ('quantiles', 'Merge'), 'quantileTimingWeightedMerge': ('quantileTimingWeighted', 'Merge'), 'histogramMerge': ('histogram', 'Merge'), 'meanZTestMerge': ('meanZTest', 'Merge'), 'quantilesExactLowMerge': ('quantilesExactLow', 'Merge'), 'retentionMerge': ('retention', 'Merge'), 'groupBitXorMerge': ('groupBitXor', 'Merge'), 'windowFunnelMerge': ('windowFunnel', 'Merge'), 'stddevPopMerge': ('stddevPop', 'Merge'), 'anyHeavyMerge': ('anyHeavy', 'Merge'), 'uniqHLL12Merge': ('uniqHLL12', 'Merge'), 'quantileExactLowMerge': ('quantileExactLow', 'Merge'), 'skewSampMerge': ('skewSamp', 'Merge'), 'rankCorrMerge': ('rankCorr', 'Merge'), 'argMaxMerge': ('argMax', 'Merge'), 'quantilesTimingMerge': ('quantilesTiming', 'Merge'), 'cramersVMerge': ('cramersV', 'Merge'), 'quantilesBFloat16WeightedMerge': ('quantilesBFloat16Weighted', 'Merge'), 'contingencyMerge': ('contingency', 'Merge'), 'skewPopMerge': ('skewPop', 'Merge'), 'groupArrayMovingSumMerge': ('groupArrayMovingSum', 'Merge'), 'quantilesExactWeightedMerge': ('quantilesExactWeighted', 'Merge'), 'groupBitmapOrMerge': ('groupBitmapOr', 'Merge'), 'sequenceCountMerge': ('sequenceCount', 'Merge'), 'exponentialTimeDecayedAvgMerge': ('exponentialTimeDecayedAvg', 'Merge'), 'sumKahanMerge': ('sumKahan', 'Merge'), 'quantilesInterpolatedWeightedMerge': ('quantilesInterpolatedWeighted', 'Merge'), 'uniqThetaMerge': ('uniqTheta', 'Merge'), 'quantileInterpolatedWeightedMerge': ('quantileInterpolatedWeighted', 'Merge'), 'quantileExactWeightedMerge': ('quantileExactWeighted', 'Merge'), 'exponentialMovingAverageMerge': ('exponentialMovingAverage', 'Merge'), 'anyLastMerge': ('anyLast', 'Merge'), 'sumWithOverflowMerge': ('sumWithOverflow', 'Merge'), 'quantileExactMerge': ('quantileExact', 'Merge'), 'groupArrayLastMerge': ('groupArrayLast', 'Merge'), 'groupBitmapXorMerge': ('groupBitmapXor', 'Merge'), 'quantilesBFloat16Merge': ('quantilesBFloat16', 'Merge'), 'boundingRatioMerge': ('boundingRatio', 'Merge'), 'quantileDeterministicMerge': ('quantileDeterministic', 'Merge'), 'theilsUMerge': ('theilsU', 'Merge'), 'groupBitAndMerge': ('groupBitAnd', 'Merge'), 'uniqExactMerge': ('uniqExact', 'Merge'), 'groupArrayMerge': ('groupArray', 'Merge'), 'quantilesGKMerge': ('quantilesGK', 'Merge'), 'deltaSumTimestampMerge': ('deltaSumTimestamp', 'Merge'), 'sparkBarMerge': ('sparkBar', 'Merge'), 'stochasticLinearRegressionMerge': ('stochasticLinearRegression', 'Merge'), 'groupUniqArrayMerge': ('groupUniqArray', 'Merge'), 'stddevSampMerge': ('stddevSamp', 'Merge'), 'groupArrayMovingAvgMerge': ('groupArrayMovingAvg', 'Merge'), 'entropyMerge': ('entropy', 'Merge'), 'studentTTestMerge': ('studentTTest', 'Merge'), 'categoricalInformationValueMergeState': ('categoricalInformationValue', 'MergeState'), 'groupArrayInsertAtMergeState': ('groupArrayInsertAt', 'MergeState'), 'quantilesTDigestMergeState': ('quantilesTDigest', 'MergeState'), 'groupArraySampleMergeState': ('groupArraySample', 'MergeState'), 'quantileBFloat16MergeState': ('quantileBFloat16', 'MergeState'), 'covarSampMergeState': ('covarSamp', 'MergeState'), 'quantilesExactMergeState': ('quantilesExact', 'MergeState'), 'maxIntersectionsMergeState': ('maxIntersections', 'MergeState'), 'medianMergeState': ('median', 'MergeState'), 'largestTriangleThreeBucketsMergeState': ('largestTriangleThreeBuckets', 'MergeState'), 'uniqMergeState': ('uniq', 'MergeState'), 'avgMergeState': ('avg', 'MergeState'), 'groupBitmapAndMergeState': ('groupBitmapAnd', 'MergeState'), 'quantileMergeState': ('quantile', 'MergeState'), 'quantilesTimingWeightedMergeState': ('quantilesTimingWeighted', 'MergeState'), 'cramersVBiasCorrectedMergeState': ('cramersVBiasCorrected', 'MergeState'), 'maxIntersectionsPositionMergeState': ('maxIntersectionsPosition', 'MergeState'), 'quantilesDeterministicMergeState': ('quantilesDeterministic', 'MergeState'), 'quantileGKMergeState': ('quantileGK', 'MergeState'), 'kurtPopMergeState': ('kurtPop', 'MergeState'), 'corrMergeState': ('corr', 'MergeState'), 'kolmogorovSmirnovTestMergeState': ('kolmogorovSmirnovTest', 'MergeState'), 'argMinMergeState': ('argMin', 'MergeState'), 'countMergeState': ('count', 'MergeState'), 'sequenceNextNodeMergeState': ('sequenceNextNode', 'MergeState'), 'topKMergeState': ('topK', 'MergeState'), 'first_valueMergeState': ('first_value', 'MergeState'), 'stochasticLogisticRegressionMergeState': ('stochasticLogisticRegression', 'MergeState'), 'quantileExactHighMergeState': ('quantileExactHigh', 'MergeState'), 'minMapMergeState': ('minMap', 'MergeState'), 'sumMapMergeState': ('sumMap', 'MergeState'), 'maxMapMergeState': ('maxMap', 'MergeState'), 'kurtSampMergeState': ('kurtSamp', 'MergeState'), 'quantileTDigestMergeState': ('quantileTDigest', 'MergeState'), 'deltaSumMergeState': ('deltaSum', 'MergeState'), 'groupBitOrMergeState': ('groupBitOr', 'MergeState'), 'maxMergeState': ('max', 'MergeState'), 'sumMergeState': ('sum', 'MergeState'), 'anyMergeState': ('any', 'MergeState'), 'quantilesExactHighMergeState': ('quantilesExactHigh', 'MergeState'), 'uniqUpToMergeState': ('uniqUpTo', 'MergeState'), 'avgWeightedMergeState': ('avgWeighted', 'MergeState'), 'sequenceMatchMergeState': ('sequenceMatch', 'MergeState'), 'mannWhitneyUTestMergeState': ('mannWhitneyUTest', 'MergeState'), 'sumCountMergeState': ('sumCount', 'MergeState'), 'topKWeightedMergeState': ('topKWeighted', 'MergeState'), 'last_valueMergeState': ('last_value', 'MergeState'), 'quantileBFloat16WeightedMergeState': ('quantileBFloat16Weighted', 'MergeState'), 'minMergeState': ('min', 'MergeState'), 'quantileTDigestWeightedMergeState': ('quantileTDigestWeighted', 'MergeState'), 'uniqCombinedMergeState': ('uniqCombined', 'MergeState'), 'varPopMergeState': ('varPop', 'MergeState'), 'varSampMergeState': ('varSamp', 'MergeState'), 'quantileTimingMergeState': ('quantileTiming', 'MergeState'), 'groupBitmapMergeState': ('groupBitmap', 'MergeState'), 'covarPopMergeState': ('covarPop', 'MergeState'), 'welchTTestMergeState': ('welchTTest', 'MergeState'), 'uniqCombined64MergeState': ('uniqCombined64', 'MergeState'), 'quantilesTDigestWeightedMergeState': ('quantilesTDigestWeighted', 'MergeState'), 'simpleLinearRegressionMergeState': ('simpleLinearRegression', 'MergeState'), 'intervalLengthSumMergeState': ('intervalLengthSum', 'MergeState'), 'quantilesMergeState': ('quantiles', 'MergeState'), 'quantileTimingWeightedMergeState': ('quantileTimingWeighted', 'MergeState'), 'histogramMergeState': ('histogram', 'MergeState'), 'meanZTestMergeState': ('meanZTest', 'MergeState'), 'quantilesExactLowMergeState': ('quantilesExactLow', 'MergeState'), 'retentionMergeState': ('retention', 'MergeState'), 'groupBitXorMergeState': ('groupBitXor', 'MergeState'), 'windowFunnelMergeState': ('windowFunnel', 'MergeState'), 'stddevPopMergeState': ('stddevPop', 'MergeState'), 'anyHeavyMergeState': ('anyHeavy', 'MergeState'), 'uniqHLL12MergeState': ('uniqHLL12', 'MergeState'), 'quantileExactLowMergeState': ('quantileExactLow', 'MergeState'), 'skewSampMergeState': ('skewSamp', 'MergeState'), 'rankCorrMergeState': ('rankCorr', 'MergeState'), 'argMaxMergeState': ('argMax', 'MergeState'), 'quantilesTimingMergeState': ('quantilesTiming', 'MergeState'), 'cramersVMergeState': ('cramersV', 'MergeState'), 'quantilesBFloat16WeightedMergeState': ('quantilesBFloat16Weighted', 'MergeState'), 'contingencyMergeState': ('contingency', 'MergeState'), 'skewPopMergeState': ('skewPop', 'MergeState'), 'groupArrayMovingSumMergeState': ('groupArrayMovingSum', 'MergeState'), 'quantilesExactWeightedMergeState': ('quantilesExactWeighted', 'MergeState'), 'groupBitmapOrMergeState': ('groupBitmapOr', 'MergeState'), 'sequenceCountMergeState': ('sequenceCount', 'MergeState'), 'exponentialTimeDecayedAvgMergeState': ('exponentialTimeDecayedAvg', 'MergeState'), 'sumKahanMergeState': ('sumKahan', 'MergeState'), 'quantilesInterpolatedWeightedMergeState': ('quantilesInterpolatedWeighted', 'MergeState'), 'uniqThetaMergeState': ('uniqTheta', 'MergeState'), 'quantileInterpolatedWeightedMergeState': ('quantileInterpolatedWeighted', 'MergeState'), 'quantileExactWeightedMergeState': ('quantileExactWeighted', 'MergeState'), 'exponentialMovingAverageMergeState': ('exponentialMovingAverage', 'MergeState'), 'anyLastMergeState': ('anyLast', 'MergeState'), 'sumWithOverflowMergeState': ('sumWithOverflow', 'MergeState'), 'quantileExactMergeState': ('quantileExact', 'MergeState'), 'groupArrayLastMergeState': ('groupArrayLast', 'MergeState'), 'groupBitmapXorMergeState': ('groupBitmapXor', 'MergeState'), 'quantilesBFloat16MergeState': ('quantilesBFloat16', 'MergeState'), 'boundingRatioMergeState': ('boundingRatio', 'MergeState'), 'quantileDeterministicMergeState': ('quantileDeterministic', 'MergeState'), 'theilsUMergeState': ('theilsU', 'MergeState'), 'groupBitAndMergeState': ('groupBitAnd', 'MergeState'), 'uniqExactMergeState': ('uniqExact', 'MergeState'), 'groupArrayMergeState': ('groupArray', 'MergeState'), 'quantilesGKMergeState': ('quantilesGK', 'MergeState'), 'deltaSumTimestampMergeState': ('deltaSumTimestamp', 'MergeState'), 'sparkBarMergeState': ('sparkBar', 'MergeState'), 'stochasticLinearRegressionMergeState': ('stochasticLinearRegression', 'MergeState'), 'groupUniqArrayMergeState': ('groupUniqArray', 'MergeState'), 'stddevSampMergeState': ('stddevSamp', 'MergeState'), 'groupArrayMovingAvgMergeState': ('groupArrayMovingAvg', 'MergeState'), 'entropyMergeState': ('entropy', 'MergeState'), 'studentTTestMergeState': ('studentTTest', 'MergeState'), 'categoricalInformationValueForEach': ('categoricalInformationValue', 'ForEach'), 'groupArrayInsertAtForEach': ('groupArrayInsertAt', 'ForEach'), 'quantilesTDigestForEach': ('quantilesTDigest', 'ForEach'), 'groupArraySampleForEach': ('groupArraySample', 'ForEach'), 'quantileBFloat16ForEach': ('quantileBFloat16', 'ForEach'), 'covarSampForEach': ('covarSamp', 'ForEach'), 'quantilesExactForEach': ('quantilesExact', 'ForEach'), 'maxIntersectionsForEach': ('maxIntersections', 'ForEach'), 'medianForEach': ('median', 'ForEach'), 'largestTriangleThreeBucketsForEach': ('largestTriangleThreeBuckets', 'ForEach'), 'uniqForEach': ('uniq', 'ForEach'), 'avgForEach': ('avg', 'ForEach'), 'groupBitmapAndForEach': ('groupBitmapAnd', 'ForEach'), 'quantileForEach': ('quantile', 'ForEach'), 'quantilesTimingWeightedForEach': ('quantilesTimingWeighted', 'ForEach'), 'cramersVBiasCorrectedForEach': ('cramersVBiasCorrected', 'ForEach'), 'maxIntersectionsPositionForEach': ('maxIntersectionsPosition', 'ForEach'), 'quantilesDeterministicForEach': ('quantilesDeterministic', 'ForEach'), 'quantileGKForEach': ('quantileGK', 'ForEach'), 'kurtPopForEach': ('kurtPop', 'ForEach'), 'corrForEach': ('corr', 'ForEach'), 'kolmogorovSmirnovTestForEach': ('kolmogorovSmirnovTest', 'ForEach'), 'argMinForEach': ('argMin', 'ForEach'), 'countForEach': ('count', 'ForEach'), 'sequenceNextNodeForEach': ('sequenceNextNode', 'ForEach'), 'topKForEach': ('topK', 'ForEach'), 'first_valueForEach': ('first_value', 'ForEach'), 'stochasticLogisticRegressionForEach': ('stochasticLogisticRegression', 'ForEach'), 'quantileExactHighForEach': ('quantileExactHigh', 'ForEach'), 'minMapForEach': ('minMap', 'ForEach'), 'sumMapForEach': ('sumMap', 'ForEach'), 'maxMapForEach': ('maxMap', 'ForEach'), 'kurtSampForEach': ('kurtSamp', 'ForEach'), 'quantileTDigestForEach': ('quantileTDigest', 'ForEach'), 'deltaSumForEach': ('deltaSum', 'ForEach'), 'groupBitOrForEach': ('groupBitOr', 'ForEach'), 'maxForEach': ('max', 'ForEach'), 'sumForEach': ('sum', 'ForEach'), 'anyForEach': ('any', 'ForEach'), 'quantilesExactHighForEach': ('quantilesExactHigh', 'ForEach'), 'uniqUpToForEach': ('uniqUpTo', 'ForEach'), 'avgWeightedForEach': ('avgWeighted', 'ForEach'), 'sequenceMatchForEach': ('sequenceMatch', 'ForEach'), 'mannWhitneyUTestForEach': ('mannWhitneyUTest', 'ForEach'), 'sumCountForEach': ('sumCount', 'ForEach'), 'topKWeightedForEach': ('topKWeighted', 'ForEach'), 'last_valueForEach': ('last_value', 'ForEach'), 'quantileBFloat16WeightedForEach': ('quantileBFloat16Weighted', 'ForEach'), 'minForEach': ('min', 'ForEach'), 'quantileTDigestWeightedForEach': ('quantileTDigestWeighted', 'ForEach'), 'uniqCombinedForEach': ('uniqCombined', 'ForEach'), 'varPopForEach': ('varPop', 'ForEach'), 'varSampForEach': ('varSamp', 'ForEach'), 'quantileTimingForEach': ('quantileTiming', 'ForEach'), 'groupBitmapForEach': ('groupBitmap', 'ForEach'), 'covarPopForEach': ('covarPop', 'ForEach'), 'welchTTestForEach': ('welchTTest', 'ForEach'), 'uniqCombined64ForEach': ('uniqCombined64', 'ForEach'), 'quantilesTDigestWeightedForEach': ('quantilesTDigestWeighted', 'ForEach'), 'simpleLinearRegressionForEach': ('simpleLinearRegression', 'ForEach'), 'intervalLengthSumForEach': ('intervalLengthSum', 'ForEach'), 'quantilesForEach': ('quantiles', 'ForEach'), 'quantileTimingWeightedForEach': ('quantileTimingWeighted', 'ForEach'), 'histogramForEach': ('histogram', 'ForEach'), 'meanZTestForEach': ('meanZTest', 'ForEach'), 'quantilesExactLowForEach': ('quantilesExactLow', 'ForEach'), 'retentionForEach': ('retention', 'ForEach'), 'groupBitXorForEach': ('groupBitXor', 'ForEach'), 'windowFunnelForEach': ('windowFunnel', 'ForEach'), 'stddevPopForEach': ('stddevPop', 'ForEach'), 'anyHeavyForEach': ('anyHeavy', 'ForEach'), 'uniqHLL12ForEach': ('uniqHLL12', 'ForEach'), 'quantileExactLowForEach': ('quantileExactLow', 'ForEach'), 'skewSampForEach': ('skewSamp', 'ForEach'), 'rankCorrForEach': ('rankCorr', 'ForEach'), 'argMaxForEach': ('argMax', 'ForEach'), 'quantilesTimingForEach': ('quantilesTiming', 'ForEach'), 'cramersVForEach': ('cramersV', 'ForEach'), 'quantilesBFloat16WeightedForEach': ('quantilesBFloat16Weighted', 'ForEach'), 'contingencyForEach': ('contingency', 'ForEach'), 'skewPopForEach': ('skewPop', 'ForEach'), 'groupArrayMovingSumForEach': ('groupArrayMovingSum', 'ForEach'), 'quantilesExactWeightedForEach': ('quantilesExactWeighted', 'ForEach'), 'groupBitmapOrForEach': ('groupBitmapOr', 'ForEach'), 'sequenceCountForEach': ('sequenceCount', 'ForEach'), 'exponentialTimeDecayedAvgForEach': ('exponentialTimeDecayedAvg', 'ForEach'), 'sumKahanForEach': ('sumKahan', 'ForEach'), 'quantilesInterpolatedWeightedForEach': ('quantilesInterpolatedWeighted', 'ForEach'), 'uniqThetaForEach': ('uniqTheta', 'ForEach'), 'quantileInterpolatedWeightedForEach': ('quantileInterpolatedWeighted', 'ForEach'), 'quantileExactWeightedForEach': ('quantileExactWeighted', 'ForEach'), 'exponentialMovingAverageForEach': ('exponentialMovingAverage', 'ForEach'), 'anyLastForEach': ('anyLast', 'ForEach'), 'sumWithOverflowForEach': ('sumWithOverflow', 'ForEach'), 'quantileExactForEach': ('quantileExact', 'ForEach'), 'groupArrayLastForEach': ('groupArrayLast', 'ForEach'), 'groupBitmapXorForEach': ('groupBitmapXor', 'ForEach'), 'quantilesBFloat16ForEach': ('quantilesBFloat16', 'ForEach'), 'boundingRatioForEach': ('boundingRatio', 'ForEach'), 'quantileDeterministicForEach': ('quantileDeterministic', 'ForEach'), 'theilsUForEach': ('theilsU', 'ForEach'), 'groupBitAndForEach': ('groupBitAnd', 'ForEach'), 'uniqExactForEach': ('uniqExact', 'ForEach'), 'groupArrayForEach': ('groupArray', 'ForEach'), 'quantilesGKForEach': ('quantilesGK', 'ForEach'), 'deltaSumTimestampForEach': ('deltaSumTimestamp', 'ForEach'), 'sparkBarForEach': ('sparkBar', 'ForEach'), 'stochasticLinearRegressionForEach': ('stochasticLinearRegression', 'ForEach'), 'groupUniqArrayForEach': ('groupUniqArray', 'ForEach'), 'stddevSampForEach': ('stddevSamp', 'ForEach'), 'groupArrayMovingAvgForEach': ('groupArrayMovingAvg', 'ForEach'), 'entropyForEach': ('entropy', 'ForEach'), 'studentTTestForEach': ('studentTTest', 'ForEach'), 'categoricalInformationValueDistinct': ('categoricalInformationValue', 'Distinct'), 'groupArrayInsertAtDistinct': ('groupArrayInsertAt', 'Distinct'), 'quantilesTDigestDistinct': ('quantilesTDigest', 'Distinct'), 'groupArraySampleDistinct': ('groupArraySample', 'Distinct'), 'quantileBFloat16Distinct': ('quantileBFloat16', 'Distinct'), 'covarSampDistinct': ('covarSamp', 'Distinct'), 'quantilesExactDistinct': ('quantilesExact', 'Distinct'), 'maxIntersectionsDistinct': ('maxIntersections', 'Distinct'), 'medianDistinct': ('median', 'Distinct'), 'largestTriangleThreeBucketsDistinct': ('largestTriangleThreeBuckets', 'Distinct'), 'uniqDistinct': ('uniq', 'Distinct'), 'avgDistinct': ('avg', 'Distinct'), 'groupBitmapAndDistinct': ('groupBitmapAnd', 'Distinct'), 'quantileDistinct': ('quantile', 'Distinct'), 'quantilesTimingWeightedDistinct': ('quantilesTimingWeighted', 'Distinct'), 'cramersVBiasCorrectedDistinct': ('cramersVBiasCorrected', 'Distinct'), 'maxIntersectionsPositionDistinct': ('maxIntersectionsPosition', 'Distinct'), 'quantilesDeterministicDistinct': ('quantilesDeterministic', 'Distinct'), 'quantileGKDistinct': ('quantileGK', 'Distinct'), 'kurtPopDistinct': ('kurtPop', 'Distinct'), 'corrDistinct': ('corr', 'Distinct'), 'kolmogorovSmirnovTestDistinct': ('kolmogorovSmirnovTest', 'Distinct'), 'argMinDistinct': ('argMin', 'Distinct'), 'countDistinct': ('count', 'Distinct'), 'sequenceNextNodeDistinct': ('sequenceNextNode', 'Distinct'), 'topKDistinct': ('topK', 'Distinct'), 'first_valueDistinct': ('first_value', 'Distinct'), 'stochasticLogisticRegressionDistinct': ('stochasticLogisticRegression', 'Distinct'), 'quantileExactHighDistinct': ('quantileExactHigh', 'Distinct'), 'minMapDistinct': ('minMap', 'Distinct'), 'sumMapDistinct': ('sumMap', 'Distinct'), 'maxMapDistinct': ('maxMap', 'Distinct'), 'kurtSampDistinct': ('kurtSamp', 'Distinct'), 'quantileTDigestDistinct': ('quantileTDigest', 'Distinct'), 'deltaSumDistinct': ('deltaSum', 'Distinct'), 'groupBitOrDistinct': ('groupBitOr', 'Distinct'), 'maxDistinct': ('max', 'Distinct'), 'sumDistinct': ('sum', 'Distinct'), 'anyDistinct': ('any', 'Distinct'), 'quantilesExactHighDistinct': ('quantilesExactHigh', 'Distinct'), 'uniqUpToDistinct': ('uniqUpTo', 'Distinct'), 'avgWeightedDistinct': ('avgWeighted', 'Distinct'), 'sequenceMatchDistinct': ('sequenceMatch', 'Distinct'), 'mannWhitneyUTestDistinct': ('mannWhitneyUTest', 'Distinct'), 'sumCountDistinct': ('sumCount', 'Distinct'), 'topKWeightedDistinct': ('topKWeighted', 'Distinct'), 'last_valueDistinct': ('last_value', 'Distinct'), 'quantileBFloat16WeightedDistinct': ('quantileBFloat16Weighted', 'Distinct'), 'minDistinct': ('min', 'Distinct'), 'quantileTDigestWeightedDistinct': ('quantileTDigestWeighted', 'Distinct'), 'uniqCombinedDistinct': ('uniqCombined', 'Distinct'), 'varPopDistinct': ('varPop', 'Distinct'), 'varSampDistinct': ('varSamp', 'Distinct'), 'quantileTimingDistinct': ('quantileTiming', 'Distinct'), 'groupBitmapDistinct': ('groupBitmap', 'Distinct'), 'covarPopDistinct': ('covarPop', 'Distinct'), 'welchTTestDistinct': ('welchTTest', 'Distinct'), 'uniqCombined64Distinct': ('uniqCombined64', 'Distinct'), 'quantilesTDigestWeightedDistinct': ('quantilesTDigestWeighted', 'Distinct'), 'simpleLinearRegressionDistinct': ('simpleLinearRegression', 'Distinct'), 'intervalLengthSumDistinct': ('intervalLengthSum', 'Distinct'), 'quantilesDistinct': ('quantiles', 'Distinct'), 'quantileTimingWeightedDistinct': ('quantileTimingWeighted', 'Distinct'), 'histogramDistinct': ('histogram', 'Distinct'), 'meanZTestDistinct': ('meanZTest', 'Distinct'), 'quantilesExactLowDistinct': ('quantilesExactLow', 'Distinct'), 'retentionDistinct': ('retention', 'Distinct'), 'groupBitXorDistinct': ('groupBitXor', 'Distinct'), 'windowFunnelDistinct': ('windowFunnel', 'Distinct'), 'stddevPopDistinct': ('stddevPop', 'Distinct'), 'anyHeavyDistinct': ('anyHeavy', 'Distinct'), 'uniqHLL12Distinct': ('uniqHLL12', 'Distinct'), 'quantileExactLowDistinct': ('quantileExactLow', 'Distinct'), 'skewSampDistinct': ('skewSamp', 'Distinct'), 'rankCorrDistinct': ('rankCorr', 'Distinct'), 'argMaxDistinct': ('argMax', 'Distinct'), 'quantilesTimingDistinct': ('quantilesTiming', 'Distinct'), 'cramersVDistinct': ('cramersV', 'Distinct'), 'quantilesBFloat16WeightedDistinct': ('quantilesBFloat16Weighted', 'Distinct'), 'contingencyDistinct': ('contingency', 'Distinct'), 'skewPopDistinct': ('skewPop', 'Distinct'), 'groupArrayMovingSumDistinct': ('groupArrayMovingSum', 'Distinct'), 'quantilesExactWeightedDistinct': ('quantilesExactWeighted', 'Distinct'), 'groupBitmapOrDistinct': ('groupBitmapOr', 'Distinct'), 'sequenceCountDistinct': ('sequenceCount', 'Distinct'), 'exponentialTimeDecayedAvgDistinct': ('exponentialTimeDecayedAvg', 'Distinct'), 'sumKahanDistinct': ('sumKahan', 'Distinct'), 'quantilesInterpolatedWeightedDistinct': ('quantilesInterpolatedWeighted', 'Distinct'), 'uniqThetaDistinct': ('uniqTheta', 'Distinct'), 'quantileInterpolatedWeightedDistinct': ('quantileInterpolatedWeighted', 'Distinct'), 'quantileExactWeightedDistinct': ('quantileExactWeighted', 'Distinct'), 'exponentialMovingAverageDistinct': ('exponentialMovingAverage', 'Distinct'), 'anyLastDistinct': ('anyLast', 'Distinct'), 'sumWithOverflowDistinct': ('sumWithOverflow', 'Distinct'), 'quantileExactDistinct': ('quantileExact', 'Distinct'), 'groupArrayLastDistinct': ('groupArrayLast', 'Distinct'), 'groupBitmapXorDistinct': ('groupBitmapXor', 'Distinct'), 'quantilesBFloat16Distinct': ('quantilesBFloat16', 'Distinct'), 'boundingRatioDistinct': ('boundingRatio', 'Distinct'), 'quantileDeterministicDistinct': ('quantileDeterministic', 'Distinct'), 'theilsUDistinct': ('theilsU', 'Distinct'), 'groupBitAndDistinct': ('groupBitAnd', 'Distinct'), 'uniqExactDistinct': ('uniqExact', 'Distinct'), 'groupArrayDistinct': ('groupArray', 'Distinct'), 'quantilesGKDistinct': ('quantilesGK', 'Distinct'), 'deltaSumTimestampDistinct': ('deltaSumTimestamp', 'Distinct'), 'sparkBarDistinct': ('sparkBar', 'Distinct'), 'stochasticLinearRegressionDistinct': ('stochasticLinearRegression', 'Distinct'), 'groupUniqArrayDistinct': ('groupUniqArray', 'Distinct'), 'stddevSampDistinct': ('stddevSamp', 'Distinct'), 'groupArrayMovingAvgDistinct': ('groupArrayMovingAvg', 'Distinct'), 'entropyDistinct': ('entropy', 'Distinct'), 'studentTTestDistinct': ('studentTTest', 'Distinct'), 'categoricalInformationValueOrDefault': ('categoricalInformationValue', 'OrDefault'), 'groupArrayInsertAtOrDefault': ('groupArrayInsertAt', 'OrDefault'), 'quantilesTDigestOrDefault': ('quantilesTDigest', 'OrDefault'), 'groupArraySampleOrDefault': ('groupArraySample', 'OrDefault'), 'quantileBFloat16OrDefault': ('quantileBFloat16', 'OrDefault'), 'covarSampOrDefault': ('covarSamp', 'OrDefault'), 'quantilesExactOrDefault': ('quantilesExact', 'OrDefault'), 'maxIntersectionsOrDefault': ('maxIntersections', 'OrDefault'), 'medianOrDefault': ('median', 'OrDefault'), 'largestTriangleThreeBucketsOrDefault': ('largestTriangleThreeBuckets', 'OrDefault'), 'uniqOrDefault': ('uniq', 'OrDefault'), 'avgOrDefault': ('avg', 'OrDefault'), 'groupBitmapAndOrDefault': ('groupBitmapAnd', 'OrDefault'), 'quantileOrDefault': ('quantile', 'OrDefault'), 'quantilesTimingWeightedOrDefault': ('quantilesTimingWeighted', 'OrDefault'), 'cramersVBiasCorrectedOrDefault': ('cramersVBiasCorrected', 'OrDefault'), 'maxIntersectionsPositionOrDefault': ('maxIntersectionsPosition', 'OrDefault'), 'quantilesDeterministicOrDefault': ('quantilesDeterministic', 'OrDefault'), 'quantileGKOrDefault': ('quantileGK', 'OrDefault'), 'kurtPopOrDefault': ('kurtPop', 'OrDefault'), 'corrOrDefault': ('corr', 'OrDefault'), 'kolmogorovSmirnovTestOrDefault': ('kolmogorovSmirnovTest', 'OrDefault'), 'argMinOrDefault': ('argMin', 'OrDefault'), 'countOrDefault': ('count', 'OrDefault'), 'sequenceNextNodeOrDefault': ('sequenceNextNode', 'OrDefault'), 'topKOrDefault': ('topK', 'OrDefault'), 'first_valueOrDefault': ('first_value', 'OrDefault'), 'stochasticLogisticRegressionOrDefault': ('stochasticLogisticRegression', 'OrDefault'), 'quantileExactHighOrDefault': ('quantileExactHigh', 'OrDefault'), 'minMapOrDefault': ('minMap', 'OrDefault'), 'sumMapOrDefault': ('sumMap', 'OrDefault'), 'maxMapOrDefault': ('maxMap', 'OrDefault'), 'kurtSampOrDefault': ('kurtSamp', 'OrDefault'), 'quantileTDigestOrDefault': ('quantileTDigest', 'OrDefault'), 'deltaSumOrDefault': ('deltaSum', 'OrDefault'), 'groupBitOrOrDefault': ('groupBitOr', 'OrDefault'), 'maxOrDefault': ('max', 'OrDefault'), 'sumOrDefault': ('sum', 'OrDefault'), 'anyOrDefault': ('any', 'OrDefault'), 'quantilesExactHighOrDefault': ('quantilesExactHigh', 'OrDefault'), 'uniqUpToOrDefault': ('uniqUpTo', 'OrDefault'), 'avgWeightedOrDefault': ('avgWeighted', 'OrDefault'), 'sequenceMatchOrDefault': ('sequenceMatch', 'OrDefault'), 'mannWhitneyUTestOrDefault': ('mannWhitneyUTest', 'OrDefault'), 'sumCountOrDefault': ('sumCount', 'OrDefault'), 'topKWeightedOrDefault': ('topKWeighted', 'OrDefault'), 'last_valueOrDefault': ('last_value', 'OrDefault'), 'quantileBFloat16WeightedOrDefault': ('quantileBFloat16Weighted', 'OrDefault'), 'minOrDefault': ('min', 'OrDefault'), 'quantileTDigestWeightedOrDefault': ('quantileTDigestWeighted', 'OrDefault'), 'uniqCombinedOrDefault': ('uniqCombined', 'OrDefault'), 'varPopOrDefault': ('varPop', 'OrDefault'), 'varSampOrDefault': ('varSamp', 'OrDefault'), 'quantileTimingOrDefault': ('quantileTiming', 'OrDefault'), 'groupBitmapOrDefault': ('groupBitmap', 'OrDefault'), 'covarPopOrDefault': ('covarPop', 'OrDefault'), 'welchTTestOrDefault': ('welchTTest', 'OrDefault'), 'uniqCombined64OrDefault': ('uniqCombined64', 'OrDefault'), 'quantilesTDigestWeightedOrDefault': ('quantilesTDigestWeighted', 'OrDefault'), 'simpleLinearRegressionOrDefault': ('simpleLinearRegression', 'OrDefault'), 'intervalLengthSumOrDefault': ('intervalLengthSum', 'OrDefault'), 'quantilesOrDefault': ('quantiles', 'OrDefault'), 'quantileTimingWeightedOrDefault': ('quantileTimingWeighted', 'OrDefault'), 'histogramOrDefault': ('histogram', 'OrDefault'), 'meanZTestOrDefault': ('meanZTest', 'OrDefault'), 'quantilesExactLowOrDefault': ('quantilesExactLow', 'OrDefault'), 'retentionOrDefault': ('retention', 'OrDefault'), 'groupBitXorOrDefault': ('groupBitXor', 'OrDefault'), 'windowFunnelOrDefault': ('windowFunnel', 'OrDefault'), 'stddevPopOrDefault': ('stddevPop', 'OrDefault'), 'anyHeavyOrDefault': ('anyHeavy', 'OrDefault'), 'uniqHLL12OrDefault': ('uniqHLL12', 'OrDefault'), 'quantileExactLowOrDefault': ('quantileExactLow', 'OrDefault'), 'skewSampOrDefault': ('skewSamp', 'OrDefault'), 'rankCorrOrDefault': ('rankCorr', 'OrDefault'), 'argMaxOrDefault': ('argMax', 'OrDefault'), 'quantilesTimingOrDefault': ('quantilesTiming', 'OrDefault'), 'cramersVOrDefault': ('cramersV', 'OrDefault'), 'quantilesBFloat16WeightedOrDefault': ('quantilesBFloat16Weighted', 'OrDefault'), 'contingencyOrDefault': ('contingency', 'OrDefault'), 'skewPopOrDefault': ('skewPop', 'OrDefault'), 'groupArrayMovingSumOrDefault': ('groupArrayMovingSum', 'OrDefault'), 'quantilesExactWeightedOrDefault': ('quantilesExactWeighted', 'OrDefault'), 'groupBitmapOrOrDefault': ('groupBitmapOr', 'OrDefault'), 'sequenceCountOrDefault': ('sequenceCount', 'OrDefault'), 'exponentialTimeDecayedAvgOrDefault': ('exponentialTimeDecayedAvg', 'OrDefault'), 'sumKahanOrDefault': ('sumKahan', 'OrDefault'), 'quantilesInterpolatedWeightedOrDefault': ('quantilesInterpolatedWeighted', 'OrDefault'), 'uniqThetaOrDefault': ('uniqTheta', 'OrDefault'), 'quantileInterpolatedWeightedOrDefault': ('quantileInterpolatedWeighted', 'OrDefault'), 'quantileExactWeightedOrDefault': ('quantileExactWeighted', 'OrDefault'), 'exponentialMovingAverageOrDefault': ('exponentialMovingAverage', 'OrDefault'), 'anyLastOrDefault': ('anyLast', 'OrDefault'), 'sumWithOverflowOrDefault': ('sumWithOverflow', 'OrDefault'), 'quantileExactOrDefault': ('quantileExact', 'OrDefault'), 'groupArrayLastOrDefault': ('groupArrayLast', 'OrDefault'), 'groupBitmapXorOrDefault': ('groupBitmapXor', 'OrDefault'), 'quantilesBFloat16OrDefault': ('quantilesBFloat16', 'OrDefault'), 'boundingRatioOrDefault': ('boundingRatio', 'OrDefault'), 'quantileDeterministicOrDefault': ('quantileDeterministic', 'OrDefault'), 'theilsUOrDefault': ('theilsU', 'OrDefault'), 'groupBitAndOrDefault': ('groupBitAnd', 'OrDefault'), 'uniqExactOrDefault': ('uniqExact', 'OrDefault'), 'groupArrayOrDefault': ('groupArray', 'OrDefault'), 'quantilesGKOrDefault': ('quantilesGK', 'OrDefault'), 'deltaSumTimestampOrDefault': ('deltaSumTimestamp', 'OrDefault'), 'sparkBarOrDefault': ('sparkBar', 'OrDefault'), 'stochasticLinearRegressionOrDefault': ('stochasticLinearRegression', 'OrDefault'), 'groupUniqArrayOrDefault': ('groupUniqArray', 'OrDefault'), 'stddevSampOrDefault': ('stddevSamp', 'OrDefault'), 'groupArrayMovingAvgOrDefault': ('groupArrayMovingAvg', 'OrDefault'), 'entropyOrDefault': ('entropy', 'OrDefault'), 'studentTTestOrDefault': ('studentTTest', 'OrDefault'), 'categoricalInformationValueOrNull': ('categoricalInformationValue', 'OrNull'), 'groupArrayInsertAtOrNull': ('groupArrayInsertAt', 'OrNull'), 'quantilesTDigestOrNull': ('quantilesTDigest', 'OrNull'), 'groupArraySampleOrNull': ('groupArraySample', 'OrNull'), 'quantileBFloat16OrNull': ('quantileBFloat16', 'OrNull'), 'covarSampOrNull': ('covarSamp', 'OrNull'), 'quantilesExactOrNull': ('quantilesExact', 'OrNull'), 'maxIntersectionsOrNull': ('maxIntersections', 'OrNull'), 'medianOrNull': ('median', 'OrNull'), 'largestTriangleThreeBucketsOrNull': ('largestTriangleThreeBuckets', 'OrNull'), 'uniqOrNull': ('uniq', 'OrNull'), 'avgOrNull': ('avg', 'OrNull'), 'groupBitmapAndOrNull': ('groupBitmapAnd', 'OrNull'), 'quantileOrNull': ('quantile', 'OrNull'), 'quantilesTimingWeightedOrNull': ('quantilesTimingWeighted', 'OrNull'), 'cramersVBiasCorrectedOrNull': ('cramersVBiasCorrected', 'OrNull'), 'maxIntersectionsPositionOrNull': ('maxIntersectionsPosition', 'OrNull'), 'quantilesDeterministicOrNull': ('quantilesDeterministic', 'OrNull'), 'quantileGKOrNull': ('quantileGK', 'OrNull'), 'kurtPopOrNull': ('kurtPop', 'OrNull'), 'corrOrNull': ('corr', 'OrNull'), 'kolmogorovSmirnovTestOrNull': ('kolmogorovSmirnovTest', 'OrNull'), 'argMinOrNull': ('argMin', 'OrNull'), 'countOrNull': ('count', 'OrNull'), 'sequenceNextNodeOrNull': ('sequenceNextNode', 'OrNull'), 'topKOrNull': ('topK', 'OrNull'), 'first_valueOrNull': ('first_value', 'OrNull'), 'stochasticLogisticRegressionOrNull': ('stochasticLogisticRegression', 'OrNull'), 'quantileExactHighOrNull': ('quantileExactHigh', 'OrNull'), 'minMapOrNull': ('minMap', 'OrNull'), 'sumMapOrNull': ('sumMap', 'OrNull'), 'maxMapOrNull': ('maxMap', 'OrNull'), 'kurtSampOrNull': ('kurtSamp', 'OrNull'), 'quantileTDigestOrNull': ('quantileTDigest', 'OrNull'), 'deltaSumOrNull': ('deltaSum', 'OrNull'), 'groupBitOrOrNull': ('groupBitOr', 'OrNull'), 'maxOrNull': ('max', 'OrNull'), 'sumOrNull': ('sum', 'OrNull'), 'anyOrNull': ('any', 'OrNull'), 'quantilesExactHighOrNull': ('quantilesExactHigh', 'OrNull'), 'uniqUpToOrNull': ('uniqUpTo', 'OrNull'), 'avgWeightedOrNull': ('avgWeighted', 'OrNull'), 'sequenceMatchOrNull': ('sequenceMatch', 'OrNull'), 'mannWhitneyUTestOrNull': ('mannWhitneyUTest', 'OrNull'), 'sumCountOrNull': ('sumCount', 'OrNull'), 'topKWeightedOrNull': ('topKWeighted', 'OrNull'), 'last_valueOrNull': ('last_value', 'OrNull'), 'quantileBFloat16WeightedOrNull': ('quantileBFloat16Weighted', 'OrNull'), 'minOrNull': ('min', 'OrNull'), 'quantileTDigestWeightedOrNull': ('quantileTDigestWeighted', 'OrNull'), 'uniqCombinedOrNull': ('uniqCombined', 'OrNull'), 'varPopOrNull': ('varPop', 'OrNull'), 'varSampOrNull': ('varSamp', 'OrNull'), 'quantileTimingOrNull': ('quantileTiming', 'OrNull'), 'groupBitmapOrNull': ('groupBitmap', 'OrNull'), 'covarPopOrNull': ('covarPop', 'OrNull'), 'welchTTestOrNull': ('welchTTest', 'OrNull'), 'uniqCombined64OrNull': ('uniqCombined64', 'OrNull'), 'quantilesTDigestWeightedOrNull': ('quantilesTDigestWeighted', 'OrNull'), 'simpleLinearRegressionOrNull': ('simpleLinearRegression', 'OrNull'), 'intervalLengthSumOrNull': ('intervalLengthSum', 'OrNull'), 'quantilesOrNull': ('quantiles', 'OrNull'), 'quantileTimingWeightedOrNull': ('quantileTimingWeighted', 'OrNull'), 'histogramOrNull': ('histogram', 'OrNull'), 'meanZTestOrNull': ('meanZTest', 'OrNull'), 'quantilesExactLowOrNull': ('quantilesExactLow', 'OrNull'), 'retentionOrNull': ('retention', 'OrNull'), 'groupBitXorOrNull': ('groupBitXor', 'OrNull'), 'windowFunnelOrNull': ('windowFunnel', 'OrNull'), 'stddevPopOrNull': ('stddevPop', 'OrNull'), 'anyHeavyOrNull': ('anyHeavy', 'OrNull'), 'uniqHLL12OrNull': ('uniqHLL12', 'OrNull'), 'quantileExactLowOrNull': ('quantileExactLow', 'OrNull'), 'skewSampOrNull': ('skewSamp', 'OrNull'), 'rankCorrOrNull': ('rankCorr', 'OrNull'), 'argMaxOrNull': ('argMax', 'OrNull'), 'quantilesTimingOrNull': ('quantilesTiming', 'OrNull'), 'cramersVOrNull': ('cramersV', 'OrNull'), 'quantilesBFloat16WeightedOrNull': ('quantilesBFloat16Weighted', 'OrNull'), 'contingencyOrNull': ('contingency', 'OrNull'), 'skewPopOrNull': ('skewPop', 'OrNull'), 'groupArrayMovingSumOrNull': ('groupArrayMovingSum', 'OrNull'), 'quantilesExactWeightedOrNull': ('quantilesExactWeighted', 'OrNull'), 'groupBitmapOrOrNull': ('groupBitmapOr', 'OrNull'), 'sequenceCountOrNull': ('sequenceCount', 'OrNull'), 'exponentialTimeDecayedAvgOrNull': ('exponentialTimeDecayedAvg', 'OrNull'), 'sumKahanOrNull': ('sumKahan', 'OrNull'), 'quantilesInterpolatedWeightedOrNull': ('quantilesInterpolatedWeighted', 'OrNull'), 'uniqThetaOrNull': ('uniqTheta', 'OrNull'), 'quantileInterpolatedWeightedOrNull': ('quantileInterpolatedWeighted', 'OrNull'), 'quantileExactWeightedOrNull': ('quantileExactWeighted', 'OrNull'), 'exponentialMovingAverageOrNull': ('exponentialMovingAverage', 'OrNull'), 'anyLastOrNull': ('anyLast', 'OrNull'), 'sumWithOverflowOrNull': ('sumWithOverflow', 'OrNull'), 'quantileExactOrNull': ('quantileExact', 'OrNull'), 'groupArrayLastOrNull': ('groupArrayLast', 'OrNull'), 'groupBitmapXorOrNull': ('groupBitmapXor', 'OrNull'), 'quantilesBFloat16OrNull': ('quantilesBFloat16', 'OrNull'), 'boundingRatioOrNull': ('boundingRatio', 'OrNull'), 'quantileDeterministicOrNull': ('quantileDeterministic', 'OrNull'), 'theilsUOrNull': ('theilsU', 'OrNull'), 'groupBitAndOrNull': ('groupBitAnd', 'OrNull'), 'uniqExactOrNull': ('uniqExact', 'OrNull'), 'groupArrayOrNull': ('groupArray', 'OrNull'), 'quantilesGKOrNull': ('quantilesGK', 'OrNull'), 'deltaSumTimestampOrNull': ('deltaSumTimestamp', 'OrNull'), 'sparkBarOrNull': ('sparkBar', 'OrNull'), 'stochasticLinearRegressionOrNull': ('stochasticLinearRegression', 'OrNull'), 'groupUniqArrayOrNull': ('groupUniqArray', 'OrNull'), 'stddevSampOrNull': ('stddevSamp', 'OrNull'), 'groupArrayMovingAvgOrNull': ('groupArrayMovingAvg', 'OrNull'), 'entropyOrNull': ('entropy', 'OrNull'), 'studentTTestOrNull': ('studentTTest', 'OrNull'), 'categoricalInformationValueResample': ('categoricalInformationValue', 'Resample'), 'groupArrayInsertAtResample': ('groupArrayInsertAt', 'Resample'), 'quantilesTDigestResample': ('quantilesTDigest', 'Resample'), 'groupArraySampleResample': ('groupArraySample', 'Resample'), 'quantileBFloat16Resample': ('quantileBFloat16', 'Resample'), 'covarSampResample': ('covarSamp', 'Resample'), 'quantilesExactResample': ('quantilesExact', 'Resample'), 'maxIntersectionsResample': ('maxIntersections', 'Resample'), 'medianResample': ('median', 'Resample'), 'largestTriangleThreeBucketsResample': ('largestTriangleThreeBuckets', 'Resample'), 'uniqResample': ('uniq', 'Resample'), 'avgResample': ('avg', 'Resample'), 'groupBitmapAndResample': ('groupBitmapAnd', 'Resample'), 'quantileResample': ('quantile', 'Resample'), 'quantilesTimingWeightedResample': ('quantilesTimingWeighted', 'Resample'), 'cramersVBiasCorrectedResample': ('cramersVBiasCorrected', 'Resample'), 'maxIntersectionsPositionResample': ('maxIntersectionsPosition', 'Resample'), 'quantilesDeterministicResample': ('quantilesDeterministic', 'Resample'), 'quantileGKResample': ('quantileGK', 'Resample'), 'kurtPopResample': ('kurtPop', 'Resample'), 'corrResample': ('corr', 'Resample'), 'kolmogorovSmirnovTestResample': ('kolmogorovSmirnovTest', 'Resample'), 'argMinResample': ('argMin', 'Resample'), 'countResample': ('count', 'Resample'), 'sequenceNextNodeResample': ('sequenceNextNode', 'Resample'), 'topKResample': ('topK', 'Resample'), 'first_valueResample': ('first_value', 'Resample'), 'stochasticLogisticRegressionResample': ('stochasticLogisticRegression', 'Resample'), 'quantileExactHighResample': ('quantileExactHigh', 'Resample'), 'minMapResample': ('minMap', 'Resample'), 'sumMapResample': ('sumMap', 'Resample'), 'maxMapResample': ('maxMap', 'Resample'), 'kurtSampResample': ('kurtSamp', 'Resample'), 'quantileTDigestResample': ('quantileTDigest', 'Resample'), 'deltaSumResample': ('deltaSum', 'Resample'), 'groupBitOrResample': ('groupBitOr', 'Resample'), 'maxResample': ('max', 'Resample'), 'sumResample': ('sum', 'Resample'), 'anyResample': ('any', 'Resample'), 'quantilesExactHighResample': ('quantilesExactHigh', 'Resample'), 'uniqUpToResample': ('uniqUpTo', 'Resample'), 'avgWeightedResample': ('avgWeighted', 'Resample'), 'sequenceMatchResample': ('sequenceMatch', 'Resample'), 'mannWhitneyUTestResample': ('mannWhitneyUTest', 'Resample'), 'sumCountResample': ('sumCount', 'Resample'), 'topKWeightedResample': ('topKWeighted', 'Resample'), 'last_valueResample': ('last_value', 'Resample'), 'quantileBFloat16WeightedResample': ('quantileBFloat16Weighted', 'Resample'), 'minResample': ('min', 'Resample'), 'quantileTDigestWeightedResample': ('quantileTDigestWeighted', 'Resample'), 'uniqCombinedResample': ('uniqCombined', 'Resample'), 'varPopResample': ('varPop', 'Resample'), 'varSampResample': ('varSamp', 'Resample'), 'quantileTimingResample': ('quantileTiming', 'Resample'), 'groupBitmapResample': ('groupBitmap', 'Resample'), 'covarPopResample': ('covarPop', 'Resample'), 'welchTTestResample': ('welchTTest', 'Resample'), 'uniqCombined64Resample': ('uniqCombined64', 'Resample'), 'quantilesTDigestWeightedResample': ('quantilesTDigestWeighted', 'Resample'), 'simpleLinearRegressionResample': ('simpleLinearRegression', 'Resample'), 'intervalLengthSumResample': ('intervalLengthSum', 'Resample'), 'quantilesResample': ('quantiles', 'Resample'), 'quantileTimingWeightedResample': ('quantileTimingWeighted', 'Resample'), 'histogramResample': ('histogram', 'Resample'), 'meanZTestResample': ('meanZTest', 'Resample'), 'quantilesExactLowResample': ('quantilesExactLow', 'Resample'), 'retentionResample': ('retention', 'Resample'), 'groupBitXorResample': ('groupBitXor', 'Resample'), 'windowFunnelResample': ('windowFunnel', 'Resample'), 'stddevPopResample': ('stddevPop', 'Resample'), 'anyHeavyResample': ('anyHeavy', 'Resample'), 'uniqHLL12Resample': ('uniqHLL12', 'Resample'), 'quantileExactLowResample': ('quantileExactLow', 'Resample'), 'skewSampResample': ('skewSamp', 'Resample'), 'rankCorrResample': ('rankCorr', 'Resample'), 'argMaxResample': ('argMax', 'Resample'), 'quantilesTimingResample': ('quantilesTiming', 'Resample'), 'cramersVResample': ('cramersV', 'Resample'), 'quantilesBFloat16WeightedResample': ('quantilesBFloat16Weighted', 'Resample'), 'contingencyResample': ('contingency', 'Resample'), 'skewPopResample': ('skewPop', 'Resample'), 'groupArrayMovingSumResample': ('groupArrayMovingSum', 'Resample'), 'quantilesExactWeightedResample': ('quantilesExactWeighted', 'Resample'), 'groupBitmapOrResample': ('groupBitmapOr', 'Resample'), 'sequenceCountResample': ('sequenceCount', 'Resample'), 'exponentialTimeDecayedAvgResample': ('exponentialTimeDecayedAvg', 'Resample'), 'sumKahanResample': ('sumKahan', 'Resample'), 'quantilesInterpolatedWeightedResample': ('quantilesInterpolatedWeighted', 'Resample'), 'uniqThetaResample': ('uniqTheta', 'Resample'), 'quantileInterpolatedWeightedResample': ('quantileInterpolatedWeighted', 'Resample'), 'quantileExactWeightedResample': ('quantileExactWeighted', 'Resample'), 'exponentialMovingAverageResample': ('exponentialMovingAverage', 'Resample'), 'anyLastResample': ('anyLast', 'Resample'), 'sumWithOverflowResample': ('sumWithOverflow', 'Resample'), 'quantileExactResample': ('quantileExact', 'Resample'), 'groupArrayLastResample': ('groupArrayLast', 'Resample'), 'groupBitmapXorResample': ('groupBitmapXor', 'Resample'), 'quantilesBFloat16Resample': ('quantilesBFloat16', 'Resample'), 'boundingRatioResample': ('boundingRatio', 'Resample'), 'quantileDeterministicResample': ('quantileDeterministic', 'Resample'), 'theilsUResample': ('theilsU', 'Resample'), 'groupBitAndResample': ('groupBitAnd', 'Resample'), 'uniqExactResample': ('uniqExact', 'Resample'), 'groupArrayResample': ('groupArray', 'Resample'), 'quantilesGKResample': ('quantilesGK', 'Resample'), 'deltaSumTimestampResample': ('deltaSumTimestamp', 'Resample'), 'sparkBarResample': ('sparkBar', 'Resample'), 'stochasticLinearRegressionResample': ('stochasticLinearRegression', 'Resample'), 'groupUniqArrayResample': ('groupUniqArray', 'Resample'), 'stddevSampResample': ('stddevSamp', 'Resample'), 'groupArrayMovingAvgResample': ('groupArrayMovingAvg', 'Resample'), 'entropyResample': ('entropy', 'Resample'), 'studentTTestResample': ('studentTTest', 'Resample'), 'categoricalInformationValueArgMin': ('categoricalInformationValue', 'ArgMin'), 'groupArrayInsertAtArgMin': ('groupArrayInsertAt', 'ArgMin'), 'quantilesTDigestArgMin': ('quantilesTDigest', 'ArgMin'), 'groupArraySampleArgMin': ('groupArraySample', 'ArgMin'), 'quantileBFloat16ArgMin': ('quantileBFloat16', 'ArgMin'), 'covarSampArgMin': ('covarSamp', 'ArgMin'), 'quantilesExactArgMin': ('quantilesExact', 'ArgMin'), 'maxIntersectionsArgMin': ('maxIntersections', 'ArgMin'), 'medianArgMin': ('median', 'ArgMin'), 'largestTriangleThreeBucketsArgMin': ('largestTriangleThreeBuckets', 'ArgMin'), 'uniqArgMin': ('uniq', 'ArgMin'), 'avgArgMin': ('avg', 'ArgMin'), 'groupBitmapAndArgMin': ('groupBitmapAnd', 'ArgMin'), 'quantileArgMin': ('quantile', 'ArgMin'), 'quantilesTimingWeightedArgMin': ('quantilesTimingWeighted', 'ArgMin'), 'cramersVBiasCorrectedArgMin': ('cramersVBiasCorrected', 'ArgMin'), 'maxIntersectionsPositionArgMin': ('maxIntersectionsPosition', 'ArgMin'), 'quantilesDeterministicArgMin': ('quantilesDeterministic', 'ArgMin'), 'quantileGKArgMin': ('quantileGK', 'ArgMin'), 'kurtPopArgMin': ('kurtPop', 'ArgMin'), 'corrArgMin': ('corr', 'ArgMin'), 'kolmogorovSmirnovTestArgMin': ('kolmogorovSmirnovTest', 'ArgMin'), 'argMinArgMin': ('argMin', 'ArgMin'), 'countArgMin': ('count', 'ArgMin'), 'sequenceNextNodeArgMin': ('sequenceNextNode', 'ArgMin'), 'topKArgMin': ('topK', 'ArgMin'), 'first_valueArgMin': ('first_value', 'ArgMin'), 'stochasticLogisticRegressionArgMin': ('stochasticLogisticRegression', 'ArgMin'), 'quantileExactHighArgMin': ('quantileExactHigh', 'ArgMin'), 'minMapArgMin': ('minMap', 'ArgMin'), 'sumMapArgMin': ('sumMap', 'ArgMin'), 'maxMapArgMin': ('maxMap', 'ArgMin'), 'kurtSampArgMin': ('kurtSamp', 'ArgMin'), 'quantileTDigestArgMin': ('quantileTDigest', 'ArgMin'), 'deltaSumArgMin': ('deltaSum', 'ArgMin'), 'groupBitOrArgMin': ('groupBitOr', 'ArgMin'), 'maxArgMin': ('max', 'ArgMin'), 'sumArgMin': ('sum', 'ArgMin'), 'anyArgMin': ('any', 'ArgMin'), 'quantilesExactHighArgMin': ('quantilesExactHigh', 'ArgMin'), 'uniqUpToArgMin': ('uniqUpTo', 'ArgMin'), 'avgWeightedArgMin': ('avgWeighted', 'ArgMin'), 'sequenceMatchArgMin': ('sequenceMatch', 'ArgMin'), 'mannWhitneyUTestArgMin': ('mannWhitneyUTest', 'ArgMin'), 'sumCountArgMin': ('sumCount', 'ArgMin'), 'topKWeightedArgMin': ('topKWeighted', 'ArgMin'), 'last_valueArgMin': ('last_value', 'ArgMin'), 'quantileBFloat16WeightedArgMin': ('quantileBFloat16Weighted', 'ArgMin'), 'minArgMin': ('min', 'ArgMin'), 'quantileTDigestWeightedArgMin': ('quantileTDigestWeighted', 'ArgMin'), 'uniqCombinedArgMin': ('uniqCombined', 'ArgMin'), 'varPopArgMin': ('varPop', 'ArgMin'), 'varSampArgMin': ('varSamp', 'ArgMin'), 'quantileTimingArgMin': ('quantileTiming', 'ArgMin'), 'groupBitmapArgMin': ('groupBitmap', 'ArgMin'), 'covarPopArgMin': ('covarPop', 'ArgMin'), 'welchTTestArgMin': ('welchTTest', 'ArgMin'), 'uniqCombined64ArgMin': ('uniqCombined64', 'ArgMin'), 'quantilesTDigestWeightedArgMin': ('quantilesTDigestWeighted', 'ArgMin'), 'simpleLinearRegressionArgMin': ('simpleLinearRegression', 'ArgMin'), 'intervalLengthSumArgMin': ('intervalLengthSum', 'ArgMin'), 'quantilesArgMin': ('quantiles', 'ArgMin'), 'quantileTimingWeightedArgMin': ('quantileTimingWeighted', 'ArgMin'), 'histogramArgMin': ('histogram', 'ArgMin'), 'meanZTestArgMin': ('meanZTest', 'ArgMin'), 'quantilesExactLowArgMin': ('quantilesExactLow', 'ArgMin'), 'retentionArgMin': ('retention', 'ArgMin'), 'groupBitXorArgMin': ('groupBitXor', 'ArgMin'), 'windowFunnelArgMin': ('windowFunnel', 'ArgMin'), 'stddevPopArgMin': ('stddevPop', 'ArgMin'), 'anyHeavyArgMin': ('anyHeavy', 'ArgMin'), 'uniqHLL12ArgMin': ('uniqHLL12', 'ArgMin'), 'quantileExactLowArgMin': ('quantileExactLow', 'ArgMin'), 'skewSampArgMin': ('skewSamp', 'ArgMin'), 'rankCorrArgMin': ('rankCorr', 'ArgMin'), 'argMaxArgMin': ('argMax', 'ArgMin'), 'quantilesTimingArgMin': ('quantilesTiming', 'ArgMin'), 'cramersVArgMin': ('cramersV', 'ArgMin'), 'quantilesBFloat16WeightedArgMin': ('quantilesBFloat16Weighted', 'ArgMin'), 'contingencyArgMin': ('contingency', 'ArgMin'), 'skewPopArgMin': ('skewPop', 'ArgMin'), 'groupArrayMovingSumArgMin': ('groupArrayMovingSum', 'ArgMin'), 'quantilesExactWeightedArgMin': ('quantilesExactWeighted', 'ArgMin'), 'groupBitmapOrArgMin': ('groupBitmapOr', 'ArgMin'), 'sequenceCountArgMin': ('sequenceCount', 'ArgMin'), 'exponentialTimeDecayedAvgArgMin': ('exponentialTimeDecayedAvg', 'ArgMin'), 'sumKahanArgMin': ('sumKahan', 'ArgMin'), 'quantilesInterpolatedWeightedArgMin': ('quantilesInterpolatedWeighted', 'ArgMin'), 'uniqThetaArgMin': ('uniqTheta', 'ArgMin'), 'quantileInterpolatedWeightedArgMin': ('quantileInterpolatedWeighted', 'ArgMin'), 'quantileExactWeightedArgMin': ('quantileExactWeighted', 'ArgMin'), 'exponentialMovingAverageArgMin': ('exponentialMovingAverage', 'ArgMin'), 'anyLastArgMin': ('anyLast', 'ArgMin'), 'sumWithOverflowArgMin': ('sumWithOverflow', 'ArgMin'), 'quantileExactArgMin': ('quantileExact', 'ArgMin'), 'groupArrayLastArgMin': ('groupArrayLast', 'ArgMin'), 'groupBitmapXorArgMin': ('groupBitmapXor', 'ArgMin'), 'quantilesBFloat16ArgMin': ('quantilesBFloat16', 'ArgMin'), 'boundingRatioArgMin': ('boundingRatio', 'ArgMin'), 'quantileDeterministicArgMin': ('quantileDeterministic', 'ArgMin'), 'theilsUArgMin': ('theilsU', 'ArgMin'), 'groupBitAndArgMin': ('groupBitAnd', 'ArgMin'), 'uniqExactArgMin': ('uniqExact', 'ArgMin'), 'groupArrayArgMin': ('groupArray', 'ArgMin'), 'quantilesGKArgMin': ('quantilesGK', 'ArgMin'), 'deltaSumTimestampArgMin': ('deltaSumTimestamp', 'ArgMin'), 'sparkBarArgMin': ('sparkBar', 'ArgMin'), 'stochasticLinearRegressionArgMin': ('stochasticLinearRegression', 'ArgMin'), 'groupUniqArrayArgMin': ('groupUniqArray', 'ArgMin'), 'stddevSampArgMin': ('stddevSamp', 'ArgMin'), 'groupArrayMovingAvgArgMin': ('groupArrayMovingAvg', 'ArgMin'), 'entropyArgMin': ('entropy', 'ArgMin'), 'studentTTestArgMin': ('studentTTest', 'ArgMin'), 'categoricalInformationValueArgMax': ('categoricalInformationValue', 'ArgMax'), 'groupArrayInsertAtArgMax': ('groupArrayInsertAt', 'ArgMax'), 'quantilesTDigestArgMax': ('quantilesTDigest', 'ArgMax'), 'groupArraySampleArgMax': ('groupArraySample', 'ArgMax'), 'quantileBFloat16ArgMax': ('quantileBFloat16', 'ArgMax'), 'covarSampArgMax': ('covarSamp', 'ArgMax'), 'quantilesExactArgMax': ('quantilesExact', 'ArgMax'), 'maxIntersectionsArgMax': ('maxIntersections', 'ArgMax'), 'medianArgMax': ('median', 'ArgMax'), 'largestTriangleThreeBucketsArgMax': ('largestTriangleThreeBuckets', 'ArgMax'), 'uniqArgMax': ('uniq', 'ArgMax'), 'avgArgMax': ('avg', 'ArgMax'), 'groupBitmapAndArgMax': ('groupBitmapAnd', 'ArgMax'), 'quantileArgMax': ('quantile', 'ArgMax'), 'quantilesTimingWeightedArgMax': ('quantilesTimingWeighted', 'ArgMax'), 'cramersVBiasCorrectedArgMax': ('cramersVBiasCorrected', 'ArgMax'), 'maxIntersectionsPositionArgMax': ('maxIntersectionsPosition', 'ArgMax'), 'quantilesDeterministicArgMax': ('quantilesDeterministic', 'ArgMax'), 'quantileGKArgMax': ('quantileGK', 'ArgMax'), 'kurtPopArgMax': ('kurtPop', 'ArgMax'), 'corrArgMax': ('corr', 'ArgMax'), 'kolmogorovSmirnovTestArgMax': ('kolmogorovSmirnovTest', 'ArgMax'), 'argMinArgMax': ('argMin', 'ArgMax'), 'countArgMax': ('count', 'ArgMax'), 'sequenceNextNodeArgMax': ('sequenceNextNode', 'ArgMax'), 'topKArgMax': ('topK', 'ArgMax'), 'first_valueArgMax': ('first_value', 'ArgMax'), 'stochasticLogisticRegressionArgMax': ('stochasticLogisticRegression', 'ArgMax'), 'quantileExactHighArgMax': ('quantileExactHigh', 'ArgMax'), 'minMapArgMax': ('minMap', 'ArgMax'), 'sumMapArgMax': ('sumMap', 'ArgMax'), 'maxMapArgMax': ('maxMap', 'ArgMax'), 'kurtSampArgMax': ('kurtSamp', 'ArgMax'), 'quantileTDigestArgMax': ('quantileTDigest', 'ArgMax'), 'deltaSumArgMax': ('deltaSum', 'ArgMax'), 'groupBitOrArgMax': ('groupBitOr', 'ArgMax'), 'maxArgMax': ('max', 'ArgMax'), 'sumArgMax': ('sum', 'ArgMax'), 'anyArgMax': ('any', 'ArgMax'), 'quantilesExactHighArgMax': ('quantilesExactHigh', 'ArgMax'), 'uniqUpToArgMax': ('uniqUpTo', 'ArgMax'), 'avgWeightedArgMax': ('avgWeighted', 'ArgMax'), 'sequenceMatchArgMax': ('sequenceMatch', 'ArgMax'), 'mannWhitneyUTestArgMax': ('mannWhitneyUTest', 'ArgMax'), 'sumCountArgMax': ('sumCount', 'ArgMax'), 'topKWeightedArgMax': ('topKWeighted', 'ArgMax'), 'last_valueArgMax': ('last_value', 'ArgMax'), 'quantileBFloat16WeightedArgMax': ('quantileBFloat16Weighted', 'ArgMax'), 'minArgMax': ('min', 'ArgMax'), 'quantileTDigestWeightedArgMax': ('quantileTDigestWeighted', 'ArgMax'), 'uniqCombinedArgMax': ('uniqCombined', 'ArgMax'), 'varPopArgMax': ('varPop', 'ArgMax'), 'varSampArgMax': ('varSamp', 'ArgMax'), 'quantileTimingArgMax': ('quantileTiming', 'ArgMax'), 'groupBitmapArgMax': ('groupBitmap', 'ArgMax'), 'covarPopArgMax': ('covarPop', 'ArgMax'), 'welchTTestArgMax': ('welchTTest', 'ArgMax'), 'uniqCombined64ArgMax': ('uniqCombined64', 'ArgMax'), 'quantilesTDigestWeightedArgMax': ('quantilesTDigestWeighted', 'ArgMax'), 'simpleLinearRegressionArgMax': ('simpleLinearRegression', 'ArgMax'), 'intervalLengthSumArgMax': ('intervalLengthSum', 'ArgMax'), 'quantilesArgMax': ('quantiles', 'ArgMax'), 'quantileTimingWeightedArgMax': ('quantileTimingWeighted', 'ArgMax'), 'histogramArgMax': ('histogram', 'ArgMax'), 'meanZTestArgMax': ('meanZTest', 'ArgMax'), 'quantilesExactLowArgMax': ('quantilesExactLow', 'ArgMax'), 'retentionArgMax': ('retention', 'ArgMax'), 'groupBitXorArgMax': ('groupBitXor', 'ArgMax'), 'windowFunnelArgMax': ('windowFunnel', 'ArgMax'), 'stddevPopArgMax': ('stddevPop', 'ArgMax'), 'anyHeavyArgMax': ('anyHeavy', 'ArgMax'), 'uniqHLL12ArgMax': ('uniqHLL12', 'ArgMax'), 'quantileExactLowArgMax': ('quantileExactLow', 'ArgMax'), 'skewSampArgMax': ('skewSamp', 'ArgMax'), 'rankCorrArgMax': ('rankCorr', 'ArgMax'), 'argMaxArgMax': ('argMax', 'ArgMax'), 'quantilesTimingArgMax': ('quantilesTiming', 'ArgMax'), 'cramersVArgMax': ('cramersV', 'ArgMax'), 'quantilesBFloat16WeightedArgMax': ('quantilesBFloat16Weighted', 'ArgMax'), 'contingencyArgMax': ('contingency', 'ArgMax'), 'skewPopArgMax': ('skewPop', 'ArgMax'), 'groupArrayMovingSumArgMax': ('groupArrayMovingSum', 'ArgMax'), 'quantilesExactWeightedArgMax': ('quantilesExactWeighted', 'ArgMax'), 'groupBitmapOrArgMax': ('groupBitmapOr', 'ArgMax'), 'sequenceCountArgMax': ('sequenceCount', 'ArgMax'), 'exponentialTimeDecayedAvgArgMax': ('exponentialTimeDecayedAvg', 'ArgMax'), 'sumKahanArgMax': ('sumKahan', 'ArgMax'), 'quantilesInterpolatedWeightedArgMax': ('quantilesInterpolatedWeighted', 'ArgMax'), 'uniqThetaArgMax': ('uniqTheta', 'ArgMax'), 'quantileInterpolatedWeightedArgMax': ('quantileInterpolatedWeighted', 'ArgMax'), 'quantileExactWeightedArgMax': ('quantileExactWeighted', 'ArgMax'), 'exponentialMovingAverageArgMax': ('exponentialMovingAverage', 'ArgMax'), 'anyLastArgMax': ('anyLast', 'ArgMax'), 'sumWithOverflowArgMax': ('sumWithOverflow', 'ArgMax'), 'quantileExactArgMax': ('quantileExact', 'ArgMax'), 'groupArrayLastArgMax': ('groupArrayLast', 'ArgMax'), 'groupBitmapXorArgMax': ('groupBitmapXor', 'ArgMax'), 'quantilesBFloat16ArgMax': ('quantilesBFloat16', 'ArgMax'), 'boundingRatioArgMax': ('boundingRatio', 'ArgMax'), 'quantileDeterministicArgMax': ('quantileDeterministic', 'ArgMax'), 'theilsUArgMax': ('theilsU', 'ArgMax'), 'groupBitAndArgMax': ('groupBitAnd', 'ArgMax'), 'uniqExactArgMax': ('uniqExact', 'ArgMax'), 'groupArrayArgMax': ('groupArray', 'ArgMax'), 'quantilesGKArgMax': ('quantilesGK', 'ArgMax'), 'deltaSumTimestampArgMax': ('deltaSumTimestamp', 'ArgMax'), 'sparkBarArgMax': ('sparkBar', 'ArgMax'), 'stochasticLinearRegressionArgMax': ('stochasticLinearRegression', 'ArgMax'), 'groupUniqArrayArgMax': ('groupUniqArray', 'ArgMax'), 'stddevSampArgMax': ('stddevSamp', 'ArgMax'), 'groupArrayMovingAvgArgMax': ('groupArrayMovingAvg', 'ArgMax'), 'entropyArgMax': ('entropy', 'ArgMax'), 'studentTTestArgMax': ('studentTTest', 'ArgMax'), 'categoricalInformationValue': ('categoricalInformationValue', ''), 'groupArrayInsertAt': ('groupArrayInsertAt', ''), 'quantilesTDigest': ('quantilesTDigest', ''), 'groupArraySample': ('groupArraySample', ''), 'quantileBFloat16': ('quantileBFloat16', ''), 'covarSamp': ('covarSamp', ''), 'quantilesExact': ('quantilesExact', ''), 'maxIntersections': ('maxIntersections', ''), 'median': ('median', ''), 'largestTriangleThreeBuckets': ('largestTriangleThreeBuckets', ''), 'uniq': ('uniq', ''), 'avg': ('avg', ''), 'groupBitmapAnd': ('groupBitmapAnd', ''), 'quantile': ('quantile', ''), 'quantilesTimingWeighted': ('quantilesTimingWeighted', ''), 'cramersVBiasCorrected': ('cramersVBiasCorrected', ''), 'maxIntersectionsPosition': ('maxIntersectionsPosition', ''), 'quantilesDeterministic': ('quantilesDeterministic', ''), 'quantileGK': ('quantileGK', ''), 'kurtPop': ('kurtPop', ''), 'corr': ('corr', ''), 'kolmogorovSmirnovTest': ('kolmogorovSmirnovTest', ''), 'argMin': ('argMin', ''), 'count': ('count', ''), 'sequenceNextNode': ('sequenceNextNode', ''), 'topK': ('topK', ''), 'first_value': ('first_value', ''), 'stochasticLogisticRegression': ('stochasticLogisticRegression', ''), 'quantileExactHigh': ('quantileExactHigh', ''), 'kurtSamp': ('kurtSamp', ''), 'quantileTDigest': ('quantileTDigest', ''), 'deltaSum': ('deltaSum', ''), 'groupBitOr': ('groupBitOr', ''), 'max': ('max', ''), 'sum': ('sum', ''), 'any': ('any', ''), 'quantilesExactHigh': ('quantilesExactHigh', ''), 'uniqUpTo': ('uniqUpTo', ''), 'avgWeighted': ('avgWeighted', ''), 'sequenceMatch': ('sequenceMatch', ''), 'mannWhitneyUTest': ('mannWhitneyUTest', ''), 'sumCount': ('sumCount', ''), 'topKWeighted': ('topKWeighted', ''), 'last_value': ('last_value', ''), 'quantileBFloat16Weighted': ('quantileBFloat16Weighted', ''), 'min': ('min', ''), 'quantileTDigestWeighted': ('quantileTDigestWeighted', ''), 'uniqCombined': ('uniqCombined', ''), 'varPop': ('varPop', ''), 'varSamp': ('varSamp', ''), 'quantileTiming': ('quantileTiming', ''), 'groupBitmap': ('groupBitmap', ''), 'covarPop': ('covarPop', ''), 'welchTTest': ('welchTTest', ''), 'uniqCombined64': ('uniqCombined64', ''), 'quantilesTDigestWeighted': ('quantilesTDigestWeighted', ''), 'simpleLinearRegression': ('simpleLinearRegression', ''), 'intervalLengthSum': ('intervalLengthSum', ''), 'quantiles': ('quantiles', ''), 'quantileTimingWeighted': ('quantileTimingWeighted', ''), 'histogram': ('histogram', ''), 'meanZTest': ('meanZTest', ''), 'quantilesExactLow': ('quantilesExactLow', ''), 'retention': ('retention', ''), 'groupBitXor': ('groupBitXor', ''), 'windowFunnel': ('windowFunnel', ''), 'stddevPop': ('stddevPop', ''), 'anyHeavy': ('anyHeavy', ''), 'uniqHLL12': ('uniqHLL12', ''), 'quantileExactLow': ('quantileExactLow', ''), 'skewSamp': ('skewSamp', ''), 'rankCorr': ('rankCorr', ''), 'argMax': ('argMax', ''), 'quantilesTiming': ('quantilesTiming', ''), 'cramersV': ('cramersV', ''), 'quantilesBFloat16Weighted': ('quantilesBFloat16Weighted', ''), 'contingency': ('contingency', ''), 'skewPop': ('skewPop', ''), 'groupArrayMovingSum': ('groupArrayMovingSum', ''), 'quantilesExactWeighted': ('quantilesExactWeighted', ''), 'groupBitmapOr': ('groupBitmapOr', ''), 'sequenceCount': ('sequenceCount', ''), 'exponentialTimeDecayedAvg': ('exponentialTimeDecayedAvg', ''), 'sumKahan': ('sumKahan', ''), 'quantilesInterpolatedWeighted': ('quantilesInterpolatedWeighted', ''), 'uniqTheta': ('uniqTheta', ''), 'quantileInterpolatedWeighted': ('quantileInterpolatedWeighted', ''), 'quantileExactWeighted': ('quantileExactWeighted', ''), 'exponentialMovingAverage': ('exponentialMovingAverage', ''), 'anyLast': ('anyLast', ''), 'sumWithOverflow': ('sumWithOverflow', ''), 'quantileExact': ('quantileExact', ''), 'groupArrayLast': ('groupArrayLast', ''), 'groupBitmapXor': ('groupBitmapXor', ''), 'quantilesBFloat16': ('quantilesBFloat16', ''), 'boundingRatio': ('boundingRatio', ''), 'quantileDeterministic': ('quantileDeterministic', ''), 'theilsU': ('theilsU', ''), 'groupBitAnd': ('groupBitAnd', ''), 'uniqExact': ('uniqExact', ''), 'groupArray': ('groupArray', ''), 'quantilesGK': ('quantilesGK', ''), 'deltaSumTimestamp': ('deltaSumTimestamp', ''), 'sparkBar': ('sparkBar', ''), 'stochasticLinearRegression': ('stochasticLinearRegression', ''), 'groupUniqArray': ('groupUniqArray', ''), 'stddevSamp': ('stddevSamp', ''), 'groupArrayMovingAvg': ('groupArrayMovingAvg', ''), 'entropy': ('entropy', ''), 'studentTTest': ('studentTTest', '')}
FUNCTIONS_WITH_ALIASED_ARGS = {'TUPLE', 'STRUCT'}
FUNCTION_PARSERS = {'CAST': <function Parser.<lambda>>, 'CONVERT': <function Parser.<lambda>>, 'DECODE': <function Parser.<lambda>>, 'EXTRACT': <function Parser.<lambda>>, 'JSON_OBJECT': <function Parser.<lambda>>, 'JSON_OBJECTAGG': <function Parser.<lambda>>, 'JSON_TABLE': <function Parser.<lambda>>, 'OPENJSON': <function Parser.<lambda>>, 'POSITION': <function Parser.<lambda>>, 'PREDICT': <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>>, 'ARRAYJOIN': <function ClickHouse.Parser.<lambda>>, 'QUANTILE': <function ClickHouse.Parser.<lambda>>}
NO_PAREN_FUNCTION_PARSERS = {'CASE': <function Parser.<lambda>>, 'IF': <function Parser.<lambda>>, 'NEXT': <function Parser.<lambda>>}
RANGE_PARSERS = {<TokenType.BETWEEN: 'BETWEEN'>: <function Parser.<lambda>>, <TokenType.GLOB: 'GLOB'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.ILIKE: 'ILIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.IN: 'IN'>: <function Parser.<lambda>>, <TokenType.IRLIKE: 'IRLIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.IS: 'IS'>: <function Parser.<lambda>>, <TokenType.LIKE: 'LIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.OVERLAPS: 'OVERLAPS'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.RLIKE: 'RLIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.SIMILAR_TO: 'SIMILAR_TO'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.FOR: 'FOR'>: <function Parser.<lambda>>, <TokenType.GLOBAL: 'GLOBAL'>: <function ClickHouse.Parser.<lambda>>}
COLUMN_OPERATORS = {<TokenType.DOT: 'DOT'>: None, <TokenType.DCOLON: 'DCOLON'>: <function Parser.<lambda>>, <TokenType.ARROW: 'ARROW'>: <function Parser.<lambda>>, <TokenType.DARROW: 'DARROW'>: <function Parser.<lambda>>, <TokenType.HASH_ARROW: 'HASH_ARROW'>: <function Parser.<lambda>>, <TokenType.DHASH_ARROW: 'DHASH_ARROW'>: <function Parser.<lambda>>}
JOIN_KINDS = {<TokenType.OUTER: 'OUTER'>, <TokenType.SEMI: 'SEMI'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.ASOF: 'ASOF'>, <TokenType.CROSS: 'CROSS'>, <TokenType.ANY: 'ANY'>, <TokenType.INNER: 'INNER'>, <TokenType.ANTI: 'ANTI'>}
TABLE_ALIAS_TOKENS = {<TokenType.NULL: 'NULL'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.ALL: 'ALL'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.SET: 'SET'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.VIEW: 'VIEW'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.NAME: 'NAME'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.DELETE: 'DELETE'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.COPY: 'COPY'>, <TokenType.BINARY: 'BINARY'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.TAG: 'TAG'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.MERGE: 'MERGE'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.INT: 'INT'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.UINT: 'UINT'>, <TokenType.NEXT: 'NEXT'>, <TokenType.TRUE: 'TRUE'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.UUID: 'UUID'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.NESTED: 'NESTED'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.FALSE: 'FALSE'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.YEAR: 'YEAR'>, <TokenType.DIV: 'DIV'>, <TokenType.INT128: 'INT128'>, <TokenType.IPV6: 'IPV6'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.UINT256: 'UINT256'>, <TokenType.CACHE: 'CACHE'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.INT256: 'INT256'>, <TokenType.UINT128: 'UINT128'>, <TokenType.INDEX: 'INDEX'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.SOME: 'SOME'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.CHAR: 'CHAR'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.USE: 'USE'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.SHOW: 'SHOW'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.ROWS: 'ROWS'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.DESC: 'DESC'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.ROW: 'ROW'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.RANGE: 'RANGE'>, <TokenType.DATE: 'DATE'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.CASE: 'CASE'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.BIT: 'BIT'>, <TokenType.KILL: 'KILL'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.FILTER: 'FILTER'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.INET: 'INET'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.TIME: 'TIME'>, <TokenType.FIRST: 'FIRST'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.TABLE: 'TABLE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.ENUM: 'ENUM'>, <TokenType.SUPER: 'SUPER'>, <TokenType.TEXT: 'TEXT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.MAP: 'MAP'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.ASC: 'ASC'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.DATE32: 'DATE32'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.XML: 'XML'>, <TokenType.TOP: 'TOP'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.END: 'END'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.MONEY: 'MONEY'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.JSONB: 'JSONB'>, <TokenType.IS: 'IS'>, <TokenType.KEEP: 'KEEP'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.VAR: 'VAR'>, <TokenType.LOAD: 'LOAD'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.JSON: 'JSON'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.EXISTS: 'EXISTS'>}
ALIAS_TOKENS = {<TokenType.NULL: 'NULL'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.ANY: 'ANY'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.ALL: 'ALL'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.FINAL: 'FINAL'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.SET: 'SET'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.VIEW: 'VIEW'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.NAME: 'NAME'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.DELETE: 'DELETE'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.COPY: 'COPY'>, <TokenType.BINARY: 'BINARY'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.TAG: 'TAG'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.MERGE: 'MERGE'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.INT: 'INT'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.NEXT: 'NEXT'>, <TokenType.TRUE: 'TRUE'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.UUID: 'UUID'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.NESTED: 'NESTED'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.FALSE: 'FALSE'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.YEAR: 'YEAR'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.DIV: 'DIV'>, <TokenType.INT128: 'INT128'>, <TokenType.IPV6: 'IPV6'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.FULL: 'FULL'>, <TokenType.UINT256: 'UINT256'>, <TokenType.CACHE: 'CACHE'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.INT256: 'INT256'>, <TokenType.UINT128: 'UINT128'>, <TokenType.INDEX: 'INDEX'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.LEFT: 'LEFT'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.ASOF: 'ASOF'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.SOME: 'SOME'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.CHAR: 'CHAR'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.USE: 'USE'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.SHOW: 'SHOW'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.ROWS: 'ROWS'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.DESC: 'DESC'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.ROW: 'ROW'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.RANGE: 'RANGE'>, <TokenType.DATE: 'DATE'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.CASE: 'CASE'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.BIT: 'BIT'>, <TokenType.KILL: 'KILL'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.FILTER: 'FILTER'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.INET: 'INET'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.TIME: 'TIME'>, <TokenType.FIRST: 'FIRST'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.APPLY: 'APPLY'>, <TokenType.ANTI: 'ANTI'>, <TokenType.TABLE: 'TABLE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.ENUM: 'ENUM'>, <TokenType.SUPER: 'SUPER'>, <TokenType.TEXT: 'TEXT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.MAP: 'MAP'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.ASC: 'ASC'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.DATE32: 'DATE32'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.SEMI: 'SEMI'>, <TokenType.XML: 'XML'>, <TokenType.TOP: 'TOP'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.END: 'END'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.MONEY: 'MONEY'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.JSONB: 'JSONB'>, <TokenType.IS: 'IS'>, <TokenType.KEEP: 'KEEP'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.VAR: 'VAR'>, <TokenType.LOAD: 'LOAD'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.JSON: 'JSON'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.UINT: 'UINT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.EXISTS: 'EXISTS'>}
LOG_DEFAULTS_TO_LN = True
QUERY_MODIFIER_PARSERS = {<TokenType.MATCH_RECOGNIZE: 'MATCH_RECOGNIZE'>: <function Parser.<lambda>>, <TokenType.PREWHERE: 'PREWHERE'>: <function Parser.<lambda>>, <TokenType.WHERE: 'WHERE'>: <function Parser.<lambda>>, <TokenType.GROUP_BY: 'GROUP_BY'>: <function Parser.<lambda>>, <TokenType.HAVING: 'HAVING'>: <function Parser.<lambda>>, <TokenType.QUALIFY: 'QUALIFY'>: <function Parser.<lambda>>, <TokenType.WINDOW: 'WINDOW'>: <function Parser.<lambda>>, <TokenType.ORDER_BY: 'ORDER_BY'>: <function Parser.<lambda>>, <TokenType.LIMIT: 'LIMIT'>: <function Parser.<lambda>>, <TokenType.FETCH: 'FETCH'>: <function Parser.<lambda>>, <TokenType.OFFSET: 'OFFSET'>: <function Parser.<lambda>>, <TokenType.FOR: 'FOR'>: <function Parser.<lambda>>, <TokenType.LOCK: 'LOCK'>: <function Parser.<lambda>>, <TokenType.TABLE_SAMPLE: 'TABLE_SAMPLE'>: <function Parser.<lambda>>, <TokenType.USING: 'USING'>: <function Parser.<lambda>>, <TokenType.CLUSTER_BY: 'CLUSTER_BY'>: <function Parser.<lambda>>, <TokenType.DISTRIBUTE_BY: 'DISTRIBUTE_BY'>: <function Parser.<lambda>>, <TokenType.SORT_BY: 'SORT_BY'>: <function Parser.<lambda>>, <TokenType.CONNECT_BY: 'CONNECT_BY'>: <function Parser.<lambda>>, <TokenType.START_WITH: 'START_WITH'>: <function Parser.<lambda>>, <TokenType.SETTINGS: 'SETTINGS'>: <function ClickHouse.Parser.<lambda>>, <TokenType.FORMAT: 'FORMAT'>: <function ClickHouse.Parser.<lambda>>}
CONSTRAINT_PARSERS = {'AUTOINCREMENT': <function Parser.<lambda>>, 'AUTO_INCREMENT': <function Parser.<lambda>>, 'CASESPECIFIC': <function Parser.<lambda>>, 'CHARACTER SET': <function Parser.<lambda>>, 'CHECK': <function Parser.<lambda>>, 'COLLATE': <function Parser.<lambda>>, 'COMMENT': <function Parser.<lambda>>, 'COMPRESS': <function Parser.<lambda>>, 'CLUSTERED': <function Parser.<lambda>>, 'NONCLUSTERED': <function Parser.<lambda>>, 'DEFAULT': <function Parser.<lambda>>, 'ENCODE': <function Parser.<lambda>>, 'EPHEMERAL': <function Parser.<lambda>>, 'EXCLUDE': <function Parser.<lambda>>, 'FOREIGN KEY': <function Parser.<lambda>>, 'FORMAT': <function Parser.<lambda>>, 'GENERATED': <function Parser.<lambda>>, 'IDENTITY': <function Parser.<lambda>>, 'INLINE': <function Parser.<lambda>>, 'LIKE': <function Parser.<lambda>>, 'NOT': <function Parser.<lambda>>, 'NULL': <function Parser.<lambda>>, 'ON': <function Parser.<lambda>>, 'PATH': <function Parser.<lambda>>, 'PERIOD': <function Parser.<lambda>>, 'PRIMARY KEY': <function Parser.<lambda>>, 'REFERENCES': <function Parser.<lambda>>, 'TITLE': <function Parser.<lambda>>, 'TTL': <function Parser.<lambda>>, 'UNIQUE': <function Parser.<lambda>>, 'UPPERCASE': <function Parser.<lambda>>, 'WITH': <function Parser.<lambda>>, 'INDEX': <function ClickHouse.Parser.<lambda>>, 'CODEC': <function ClickHouse.Parser.<lambda>>}
ALTER_PARSERS = {'ADD': <function Parser.<lambda>>, 'ALTER': <function Parser.<lambda>>, 'CLUSTER BY': <function Parser.<lambda>>, 'DELETE': <function Parser.<lambda>>, 'DROP': <function Parser.<lambda>>, 'RENAME': <function Parser.<lambda>>, 'REPLACE': <function ClickHouse.Parser.<lambda>>}
SCHEMA_UNNAMED_CONSTRAINTS = {'FOREIGN KEY', 'EXCLUDE', 'INDEX', 'LIKE', 'CHECK', 'PRIMARY KEY', 'UNIQUE', 'PERIOD'}
SHOW_TRIE: Dict = {}
SET_TRIE: Dict = {'GLOBAL': {0: True}, 'LOCAL': {0: True}, 'SESSION': {0: True}, 'TRANSACTION': {0: True}}
Inherited Members
sqlglot.parser.Parser
Parser
NO_PAREN_FUNCTIONS
STRUCT_TYPE_TOKENS
NESTED_TYPE_TOKENS
ENUM_TYPE_TOKENS
AGGREGATE_TYPE_TOKENS
TYPE_TOKENS
SIGNED_TO_UNSIGNED_TYPE_TOKEN
SUBQUERY_PREDICATES
RESERVED_TOKENS
DB_CREATABLES
CREATABLES
ID_VAR_TOKENS
INTERVAL_VARS
COMMENT_TABLE_ALIAS_TOKENS
UPDATE_ALIAS_TOKENS
TRIM_TYPES
CONJUNCTION
EQUALITY
COMPARISON
BITWISE
TERM
FACTOR
EXPONENT
TIMES
TIMESTAMPS
SET_OPERATIONS
JOIN_METHODS
JOIN_SIDES
JOIN_HINTS
LAMBDAS
EXPRESSION_PARSERS
STATEMENT_PARSERS
UNARY_PARSERS
STRING_PARSERS
NUMERIC_PARSERS
PRIMARY_PARSERS
PLACEHOLDER_PARSERS
PROPERTY_PARSERS
ALTER_ALTER_PARSERS
INVALID_FUNC_NAME_TOKENS
KEY_VALUE_DEFINITIONS
SET_PARSERS
SHOW_PARSERS
TYPE_LITERAL_PARSERS
TYPE_CONVERTER
DDL_SELECT_TOKENS
PRE_VOLATILE_TOKENS
TRANSACTION_KIND
TRANSACTION_CHARACTERISTICS
CONFLICT_ACTIONS
CREATE_SEQUENCE
ISOLATED_LOADING_OPTIONS
USABLES
CAST_ACTIONS
INSERT_ALTERNATIVES
CLONE_KEYWORDS
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
NULL_TOKENS
UNNEST_OFFSET_ALIAS_TOKENS
SELECT_START_TOKENS
STRICT_CAST
PREFIXED_PIVOT_COLUMNS
IDENTIFY_PIVOT_STRINGS
ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN
TABLESAMPLE_CSV
DEFAULT_SAMPLING_METHOD
SET_REQUIRES_ASSIGNMENT_DELIMITER
TRIM_PATTERN_FIRST
STRING_ALIASES
UNION_MODIFIERS
NO_PAREN_IF_COMMANDS
JSON_ARROWS_REQUIRE_JSON_TYPE
VALUES_FOLLOWED_BY_PAREN
SUPPORTS_IMPLICIT_UNNEST
SUPPORTS_PARTITION_SELECTION
error_level
error_message_context
max_errors
dialect
reset
parse
parse_into
check_errors
raise_error
expression
validate_expression
errors
sql
class ClickHouse.Generator(sqlglot.generator.Generator):
649    class Generator(generator.Generator):
650        QUERY_HINTS = False
651        STRUCT_DELIMITER = ("(", ")")
652        NVL2_SUPPORTED = False
653        TABLESAMPLE_REQUIRES_PARENS = False
654        TABLESAMPLE_SIZE_IS_ROWS = False
655        TABLESAMPLE_KEYWORDS = "SAMPLE"
656        LAST_DAY_SUPPORTS_DATE_PART = False
657        CAN_IMPLEMENT_ARRAY_ANY = True
658        SUPPORTS_TO_NUMBER = False
659
660        STRING_TYPE_MAPPING = {
661            exp.DataType.Type.CHAR: "String",
662            exp.DataType.Type.LONGBLOB: "String",
663            exp.DataType.Type.LONGTEXT: "String",
664            exp.DataType.Type.MEDIUMBLOB: "String",
665            exp.DataType.Type.MEDIUMTEXT: "String",
666            exp.DataType.Type.TINYBLOB: "String",
667            exp.DataType.Type.TINYTEXT: "String",
668            exp.DataType.Type.TEXT: "String",
669            exp.DataType.Type.VARBINARY: "String",
670            exp.DataType.Type.VARCHAR: "String",
671        }
672
673        SUPPORTED_JSON_PATH_PARTS = {
674            exp.JSONPathKey,
675            exp.JSONPathRoot,
676            exp.JSONPathSubscript,
677        }
678
679        TYPE_MAPPING = {
680            **generator.Generator.TYPE_MAPPING,
681            **STRING_TYPE_MAPPING,
682            exp.DataType.Type.ARRAY: "Array",
683            exp.DataType.Type.BIGINT: "Int64",
684            exp.DataType.Type.DATE32: "Date32",
685            exp.DataType.Type.DATETIME64: "DateTime64",
686            exp.DataType.Type.DOUBLE: "Float64",
687            exp.DataType.Type.ENUM: "Enum",
688            exp.DataType.Type.ENUM8: "Enum8",
689            exp.DataType.Type.ENUM16: "Enum16",
690            exp.DataType.Type.FIXEDSTRING: "FixedString",
691            exp.DataType.Type.FLOAT: "Float32",
692            exp.DataType.Type.INT: "Int32",
693            exp.DataType.Type.MEDIUMINT: "Int32",
694            exp.DataType.Type.INT128: "Int128",
695            exp.DataType.Type.INT256: "Int256",
696            exp.DataType.Type.LOWCARDINALITY: "LowCardinality",
697            exp.DataType.Type.MAP: "Map",
698            exp.DataType.Type.NESTED: "Nested",
699            exp.DataType.Type.NULLABLE: "Nullable",
700            exp.DataType.Type.SMALLINT: "Int16",
701            exp.DataType.Type.STRUCT: "Tuple",
702            exp.DataType.Type.TINYINT: "Int8",
703            exp.DataType.Type.UBIGINT: "UInt64",
704            exp.DataType.Type.UINT: "UInt32",
705            exp.DataType.Type.UINT128: "UInt128",
706            exp.DataType.Type.UINT256: "UInt256",
707            exp.DataType.Type.USMALLINT: "UInt16",
708            exp.DataType.Type.UTINYINT: "UInt8",
709            exp.DataType.Type.IPV4: "IPv4",
710            exp.DataType.Type.IPV6: "IPv6",
711            exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction",
712            exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction",
713        }
714
715        TRANSFORMS = {
716            **generator.Generator.TRANSFORMS,
717            exp.AnyValue: rename_func("any"),
718            exp.ApproxDistinct: rename_func("uniq"),
719            exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this),
720            exp.ArraySize: rename_func("LENGTH"),
721            exp.ArraySum: rename_func("arraySum"),
722            exp.ArgMax: arg_max_or_min_no_count("argMax"),
723            exp.ArgMin: arg_max_or_min_no_count("argMin"),
724            exp.Array: inline_array_sql,
725            exp.CastToStrType: rename_func("CAST"),
726            exp.CountIf: rename_func("countIf"),
727            exp.CompressColumnConstraint: lambda self,
728            e: f"CODEC({self.expressions(e, key='this', flat=True)})",
729            exp.ComputedColumnConstraint: lambda self,
730            e: f"{'MATERIALIZED' if e.args.get('persisted') else 'ALIAS'} {self.sql(e, 'this')}",
731            exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"),
732            exp.DateAdd: date_delta_sql("DATE_ADD"),
733            exp.DateDiff: date_delta_sql("DATE_DIFF"),
734            exp.Explode: rename_func("arrayJoin"),
735            exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL",
736            exp.IsNan: rename_func("isNaN"),
737            exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False),
738            exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False),
739            exp.JSONPathKey: json_path_key_only_name,
740            exp.JSONPathRoot: lambda *_: "",
741            exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)),
742            exp.Nullif: rename_func("nullIf"),
743            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
744            exp.Pivot: no_pivot_sql,
745            exp.Quantile: _quantile_sql,
746            exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression),
747            exp.Rand: rename_func("randCanonical"),
748            exp.Select: transforms.preprocess([transforms.eliminate_qualify]),
749            exp.StartsWith: rename_func("startsWith"),
750            exp.StrPosition: lambda self, e: self.func(
751                "position", e.this, e.args.get("substr"), e.args.get("position")
752            ),
753            exp.TimeToStr: lambda self, e: self.func(
754                "DATE_FORMAT", e.this, self.format_time(e), e.args.get("timezone")
755            ),
756            exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)),
757            exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions),
758            exp.MD5Digest: rename_func("MD5"),
759            exp.MD5: lambda self, e: self.func("LOWER", self.func("HEX", self.func("MD5", e.this))),
760            exp.SHA: rename_func("SHA1"),
761            exp.SHA2: lambda self, e: self.func(
762                "SHA256" if e.text("length") == "256" else "SHA512", e.this
763            ),
764            exp.UnixToTime: _unix_to_time_sql,
765        }
766
767        PROPERTIES_LOCATION = {
768            **generator.Generator.PROPERTIES_LOCATION,
769            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
770            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
771            exp.OnCluster: exp.Properties.Location.POST_NAME,
772        }
773
774        JOIN_HINTS = False
775        TABLE_HINTS = False
776        EXPLICIT_UNION = True
777        GROUPINGS_SEP = ""
778        OUTER_UNION_MODIFIERS = False
779
780        # there's no list in docs, but it can be found in Clickhouse code
781        # see `ClickHouse/src/Parsers/ParserCreate*.cpp`
782        ON_CLUSTER_TARGETS = {
783            "DATABASE",
784            "TABLE",
785            "VIEW",
786            "DICTIONARY",
787            "INDEX",
788            "FUNCTION",
789            "NAMED COLLECTION",
790        }
791
792        def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str:
793            this = self.json_path_part(expression.this)
794            return str(int(this) + 1) if is_int(this) else this
795
796        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
797            return f"AS {self.sql(expression, 'this')}"
798
799        def _any_to_has(
800            self,
801            expression: exp.EQ | exp.NEQ,
802            default: t.Callable[[t.Any], str],
803            prefix: str = "",
804        ) -> str:
805            if isinstance(expression.left, exp.Any):
806                arr = expression.left
807                this = expression.right
808            elif isinstance(expression.right, exp.Any):
809                arr = expression.right
810                this = expression.left
811            else:
812                return default(expression)
813
814            return prefix + self.func("has", arr.this.unnest(), this)
815
816        def eq_sql(self, expression: exp.EQ) -> str:
817            return self._any_to_has(expression, super().eq_sql)
818
819        def neq_sql(self, expression: exp.NEQ) -> str:
820            return self._any_to_has(expression, super().neq_sql, "NOT ")
821
822        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
823            # Manually add a flag to make the search case-insensitive
824            regex = self.func("CONCAT", "'(?i)'", expression.expression)
825            return self.func("match", expression.this, regex)
826
827        def datatype_sql(self, expression: exp.DataType) -> str:
828            # String is the standard ClickHouse type, every other variant is just an alias.
829            # Additionally, any supplied length parameter will be ignored.
830            #
831            # https://clickhouse.com/docs/en/sql-reference/data-types/string
832            if expression.this in self.STRING_TYPE_MAPPING:
833                return "String"
834
835            return super().datatype_sql(expression)
836
837        def cte_sql(self, expression: exp.CTE) -> str:
838            if expression.args.get("scalar"):
839                this = self.sql(expression, "this")
840                alias = self.sql(expression, "alias")
841                return f"{this} AS {alias}"
842
843            return super().cte_sql(expression)
844
845        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
846            return super().after_limit_modifiers(expression) + [
847                (
848                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
849                    if expression.args.get("settings")
850                    else ""
851                ),
852                (
853                    self.seg("FORMAT ") + self.sql(expression, "format")
854                    if expression.args.get("format")
855                    else ""
856                ),
857            ]
858
859        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
860            params = self.expressions(expression, key="params", flat=True)
861            return self.func(expression.name, *expression.expressions) + f"({params})"
862
863        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
864            return self.func(expression.name, *expression.expressions)
865
866        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
867            return self.anonymousaggfunc_sql(expression)
868
869        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
870            return self.parameterizedagg_sql(expression)
871
872        def placeholder_sql(self, expression: exp.Placeholder) -> str:
873            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
874
875        def oncluster_sql(self, expression: exp.OnCluster) -> str:
876            return f"ON CLUSTER {self.sql(expression, 'this')}"
877
878        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
879            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
880                exp.Properties.Location.POST_NAME
881            ):
882                this_name = self.sql(expression.this, "this")
883                this_properties = " ".join(
884                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
885                )
886                this_schema = self.schema_columns_sql(expression.this)
887                return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}"
888
889            return super().createable_sql(expression, locations)
890
891        def prewhere_sql(self, expression: exp.PreWhere) -> str:
892            this = self.indent(self.sql(expression, "this"))
893            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
894
895        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
896            this = self.sql(expression, "this")
897            this = f" {this}" if this else ""
898            expr = self.sql(expression, "expression")
899            expr = f" {expr}" if expr else ""
900            index_type = self.sql(expression, "index_type")
901            index_type = f" TYPE {index_type}" if index_type else ""
902            granularity = self.sql(expression, "granularity")
903            granularity = f" GRANULARITY {granularity}" if granularity else ""
904
905            return f"INDEX{this}{expr}{index_type}{granularity}"
906
907        def partition_sql(self, expression: exp.Partition) -> str:
908            return f"PARTITION {self.expressions(expression, flat=True)}"
909
910        def partitionid_sql(self, expression: exp.PartitionId) -> str:
911            return f"ID {self.sql(expression.this)}"
912
913        def replacepartition_sql(self, expression: exp.ReplacePartition) -> str:
914            return (
915                f"REPLACE {self.sql(expression.expression)} FROM {self.sql(expression, 'source')}"
916            )
917
918        def projectiondef_sql(self, expression: exp.ProjectionDef) -> str:
919            return f"PROJECTION {self.sql(expression.this)} {self.wrap(expression.expression)}"

Generator converts a given syntax tree to the corresponding SQL string.

Arguments:
  • pretty: Whether to format the produced SQL string. Default: False.
  • identify: Determines when an identifier should be quoted. Possible values are: False (default): Never quote, except in cases where it's mandatory by the dialect. True or 'always': Always quote. 'safe': Only quote identifiers that are case insensitive.
  • normalize: Whether to normalize identifiers to lowercase. Default: False.
  • pad: The pad size in a formatted string. For example, this affects the indentation of a projection in a query, relative to its nesting level. Default: 2.
  • indent: The indentation size in a formatted string. For example, this affects the indentation of subqueries and filters under a WHERE clause. Default: 2.
  • normalize_functions: How to normalize function names. Possible values are: "upper" or True (default): Convert names to uppercase. "lower": Convert names to lowercase. False: Disables function name normalization.
  • unsupported_level: Determines the generator's behavior when it encounters unsupported expressions. Default ErrorLevel.WARN.
  • max_unsupported: Maximum number of unsupported messages to include in a raised UnsupportedError. This is only relevant if unsupported_level is ErrorLevel.RAISE. Default: 3
  • leading_comma: Whether the comma is leading or trailing in select expressions. This is only relevant when generating in pretty mode. Default: False
  • max_text_width: The max number of characters in a segment before creating new lines in pretty mode. The default is on the smaller end because the length only represents a segment and not the true line length. Default: 80
  • comments: Whether to preserve comments in the output SQL code. Default: True
QUERY_HINTS = False
STRUCT_DELIMITER = ('(', ')')
NVL2_SUPPORTED = False
TABLESAMPLE_REQUIRES_PARENS = False
TABLESAMPLE_SIZE_IS_ROWS = False
TABLESAMPLE_KEYWORDS = 'SAMPLE'
LAST_DAY_SUPPORTS_DATE_PART = False
CAN_IMPLEMENT_ARRAY_ANY = True
SUPPORTS_TO_NUMBER = False
STRING_TYPE_MAPPING = {<Type.CHAR: 'CHAR'>: 'String', <Type.LONGBLOB: 'LONGBLOB'>: 'String', <Type.LONGTEXT: 'LONGTEXT'>: 'String', <Type.MEDIUMBLOB: 'MEDIUMBLOB'>: 'String', <Type.MEDIUMTEXT: 'MEDIUMTEXT'>: 'String', <Type.TINYBLOB: 'TINYBLOB'>: 'String', <Type.TINYTEXT: 'TINYTEXT'>: 'String', <Type.TEXT: 'TEXT'>: 'String', <Type.VARBINARY: 'VARBINARY'>: 'String', <Type.VARCHAR: 'VARCHAR'>: 'String'}
TYPE_MAPPING = {<Type.NCHAR: 'NCHAR'>: 'CHAR', <Type.NVARCHAR: 'NVARCHAR'>: 'VARCHAR', <Type.MEDIUMTEXT: 'MEDIUMTEXT'>: 'String', <Type.LONGTEXT: 'LONGTEXT'>: 'String', <Type.TINYTEXT: 'TINYTEXT'>: 'String', <Type.MEDIUMBLOB: 'MEDIUMBLOB'>: 'String', <Type.LONGBLOB: 'LONGBLOB'>: 'String', <Type.TINYBLOB: 'TINYBLOB'>: 'String', <Type.INET: 'INET'>: 'INET', <Type.ROWVERSION: 'ROWVERSION'>: 'VARBINARY', <Type.CHAR: 'CHAR'>: 'String', <Type.TEXT: 'TEXT'>: 'String', <Type.VARBINARY: 'VARBINARY'>: 'String', <Type.VARCHAR: 'VARCHAR'>: 'String', <Type.ARRAY: 'ARRAY'>: 'Array', <Type.BIGINT: 'BIGINT'>: 'Int64', <Type.DATE32: 'DATE32'>: 'Date32', <Type.DATETIME64: 'DATETIME64'>: 'DateTime64', <Type.DOUBLE: 'DOUBLE'>: 'Float64', <Type.ENUM: 'ENUM'>: 'Enum', <Type.ENUM8: 'ENUM8'>: 'Enum8', <Type.ENUM16: 'ENUM16'>: 'Enum16', <Type.FIXEDSTRING: 'FIXEDSTRING'>: 'FixedString', <Type.FLOAT: 'FLOAT'>: 'Float32', <Type.INT: 'INT'>: 'Int32', <Type.MEDIUMINT: 'MEDIUMINT'>: 'Int32', <Type.INT128: 'INT128'>: 'Int128', <Type.INT256: 'INT256'>: 'Int256', <Type.LOWCARDINALITY: 'LOWCARDINALITY'>: 'LowCardinality', <Type.MAP: 'MAP'>: 'Map', <Type.NESTED: 'NESTED'>: 'Nested', <Type.NULLABLE: 'NULLABLE'>: 'Nullable', <Type.SMALLINT: 'SMALLINT'>: 'Int16', <Type.STRUCT: 'STRUCT'>: 'Tuple', <Type.TINYINT: 'TINYINT'>: 'Int8', <Type.UBIGINT: 'UBIGINT'>: 'UInt64', <Type.UINT: 'UINT'>: 'UInt32', <Type.UINT128: 'UINT128'>: 'UInt128', <Type.UINT256: 'UINT256'>: 'UInt256', <Type.USMALLINT: 'USMALLINT'>: 'UInt16', <Type.UTINYINT: 'UTINYINT'>: 'UInt8', <Type.IPV4: 'IPV4'>: 'IPv4', <Type.IPV6: 'IPV6'>: 'IPv6', <Type.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>: 'AggregateFunction', <Type.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>: 'SimpleAggregateFunction'}
TRANSFORMS = {<class 'sqlglot.expressions.JSONPathKey'>: <function json_path_key_only_name>, <class 'sqlglot.expressions.JSONPathRoot'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.JSONPathSubscript'>: <function <lambda>>, <class 'sqlglot.expressions.AllowedValuesProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.AutoRefreshProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.BackupProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CaseSpecificColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ClusteredColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CollateColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CommentColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CopyGrantsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DateFormatColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DefaultColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EncodeColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EphemeralColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExcludeColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExecuteAsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExternalProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.GlobalProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.HeapProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.IcebergProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InheritsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InlineLengthColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.IntervalSpan'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.JSONExtract'>: <function json_extract_segments.<locals>._json_extract_segments>, <class 'sqlglot.expressions.JSONExtractScalar'>: <function json_extract_segments.<locals>._json_extract_segments>, <class 'sqlglot.expressions.LanguageProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LocationProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LogProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.MaterializedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NonClusteredColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NoPrimaryIndexProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NotForReplicationColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnCommitProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnUpdateColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OutputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.PathColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.RemoteWithConnectionModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ReturnsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SampleProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SetConfigProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SetProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SettingsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SharingProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SqlReadWriteProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SqlSecurityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StabilityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TemporaryProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TitleColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Timestamp'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ToMap'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ToTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransformModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransientProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UppercaseColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UnloggedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VarMap'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.ViewAttributeProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VolatileProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithJournalTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithOperator'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.AnyValue'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ApproxDistinct'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ArrayFilter'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.ArraySize'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ArraySum'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ArgMax'>: <function arg_max_or_min_no_count.<locals>._arg_max_or_min_sql>, <class 'sqlglot.expressions.ArgMin'>: <function arg_max_or_min_no_count.<locals>._arg_max_or_min_sql>, <class 'sqlglot.expressions.Array'>: <function inline_array_sql>, <class 'sqlglot.expressions.CastToStrType'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.CountIf'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.CompressColumnConstraint'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.ComputedColumnConstraint'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.CurrentDate'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.DateAdd'>: <function date_delta_sql.<locals>._delta_sql>, <class 'sqlglot.expressions.DateDiff'>: <function date_delta_sql.<locals>._delta_sql>, <class 'sqlglot.expressions.Explode'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Final'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.IsNan'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Map'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.Nullif'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.PartitionedByProperty'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.Pivot'>: <function no_pivot_sql>, <class 'sqlglot.expressions.Quantile'>: <function _quantile_sql>, <class 'sqlglot.expressions.RegexpLike'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.Rand'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Select'>: <function preprocess.<locals>._to_sql>, <class 'sqlglot.expressions.StartsWith'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.StrPosition'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.TimeToStr'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.Xor'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.MD5Digest'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.MD5'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.SHA'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.SHA2'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.UnixToTime'>: <function _unix_to_time_sql>}
PROPERTIES_LOCATION = {<class 'sqlglot.expressions.AllowedValuesProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.AlgorithmProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.AutoIncrementProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.AutoRefreshProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.BackupProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.BlockCompressionProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.CharacterSetProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ChecksumProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.CollateProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.CopyGrantsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Cluster'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ClusteredByProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DataBlocksizeProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.DefinerProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.DictRange'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DictProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DistKeyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DistStyleProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.EngineProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ExecuteAsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ExternalProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.FallbackProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.FileFormatProperty'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.FreespaceProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.GlobalProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.HeapProperty'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.InheritsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.IcebergProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.InputModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.IsolatedLoadingProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.JournalProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.LanguageProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LikeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LocationProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LockProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LockingProperty'>: <Location.POST_ALIAS: 'POST_ALIAS'>, <class 'sqlglot.expressions.LogProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.MaterializedProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.MergeBlockRatioProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.NoPrimaryIndexProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.OnProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.OnCommitProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.Order'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.OutputModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PartitionedByProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PartitionedOfProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PrimaryKey'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Property'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.RemoteWithConnectionModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ReturnsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatDelimitedProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatSerdeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SampleProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SchemaCommentProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SerdeProperties'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Set'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SettingsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SetProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.SetConfigProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SharingProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.SequenceProperties'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.SortKeyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SqlReadWriteProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SqlSecurityProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.StabilityProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.TemporaryProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.ToTableProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.TransientProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.TransformModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.MergeTreeTTL'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.UnloggedProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.ViewAttributeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.VolatileProperty'>: <Location.UNSUPPORTED: 'UNSUPPORTED'>, <class 'sqlglot.expressions.WithDataProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.WithJournalTableProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.WithSystemVersioningProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.OnCluster'>: <Location.POST_NAME: 'POST_NAME'>}
JOIN_HINTS = False
TABLE_HINTS = False
EXPLICIT_UNION = True
GROUPINGS_SEP = ''
OUTER_UNION_MODIFIERS = False
ON_CLUSTER_TARGETS = {'VIEW', 'FUNCTION', 'INDEX', 'NAMED COLLECTION', 'DICTIONARY', 'DATABASE', 'TABLE'}
def likeproperty_sql(self, expression: sqlglot.expressions.LikeProperty) -> str:
796        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
797            return f"AS {self.sql(expression, 'this')}"
def eq_sql(self, expression: sqlglot.expressions.EQ) -> str:
816        def eq_sql(self, expression: exp.EQ) -> str:
817            return self._any_to_has(expression, super().eq_sql)
def neq_sql(self, expression: sqlglot.expressions.NEQ) -> str:
819        def neq_sql(self, expression: exp.NEQ) -> str:
820            return self._any_to_has(expression, super().neq_sql, "NOT ")
def regexpilike_sql(self, expression: sqlglot.expressions.RegexpILike) -> str:
822        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
823            # Manually add a flag to make the search case-insensitive
824            regex = self.func("CONCAT", "'(?i)'", expression.expression)
825            return self.func("match", expression.this, regex)
def datatype_sql(self, expression: sqlglot.expressions.DataType) -> str:
827        def datatype_sql(self, expression: exp.DataType) -> str:
828            # String is the standard ClickHouse type, every other variant is just an alias.
829            # Additionally, any supplied length parameter will be ignored.
830            #
831            # https://clickhouse.com/docs/en/sql-reference/data-types/string
832            if expression.this in self.STRING_TYPE_MAPPING:
833                return "String"
834
835            return super().datatype_sql(expression)
def cte_sql(self, expression: sqlglot.expressions.CTE) -> str:
837        def cte_sql(self, expression: exp.CTE) -> str:
838            if expression.args.get("scalar"):
839                this = self.sql(expression, "this")
840                alias = self.sql(expression, "alias")
841                return f"{this} AS {alias}"
842
843            return super().cte_sql(expression)
def after_limit_modifiers(self, expression: sqlglot.expressions.Expression) -> List[str]:
845        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
846            return super().after_limit_modifiers(expression) + [
847                (
848                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
849                    if expression.args.get("settings")
850                    else ""
851                ),
852                (
853                    self.seg("FORMAT ") + self.sql(expression, "format")
854                    if expression.args.get("format")
855                    else ""
856                ),
857            ]
def parameterizedagg_sql(self, expression: sqlglot.expressions.ParameterizedAgg) -> str:
859        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
860            params = self.expressions(expression, key="params", flat=True)
861            return self.func(expression.name, *expression.expressions) + f"({params})"
def anonymousaggfunc_sql(self, expression: sqlglot.expressions.AnonymousAggFunc) -> str:
863        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
864            return self.func(expression.name, *expression.expressions)
def combinedaggfunc_sql(self, expression: sqlglot.expressions.CombinedAggFunc) -> str:
866        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
867            return self.anonymousaggfunc_sql(expression)
def combinedparameterizedagg_sql(self, expression: sqlglot.expressions.CombinedParameterizedAgg) -> str:
869        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
870            return self.parameterizedagg_sql(expression)
def placeholder_sql(self, expression: sqlglot.expressions.Placeholder) -> str:
872        def placeholder_sql(self, expression: exp.Placeholder) -> str:
873            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
def oncluster_sql(self, expression: sqlglot.expressions.OnCluster) -> str:
875        def oncluster_sql(self, expression: exp.OnCluster) -> str:
876            return f"ON CLUSTER {self.sql(expression, 'this')}"
def createable_sql( self, expression: sqlglot.expressions.Create, locations: DefaultDict) -> str:
878        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
879            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
880                exp.Properties.Location.POST_NAME
881            ):
882                this_name = self.sql(expression.this, "this")
883                this_properties = " ".join(
884                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
885                )
886                this_schema = self.schema_columns_sql(expression.this)
887                return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}"
888
889            return super().createable_sql(expression, locations)
def prewhere_sql(self, expression: sqlglot.expressions.PreWhere) -> str:
891        def prewhere_sql(self, expression: exp.PreWhere) -> str:
892            this = self.indent(self.sql(expression, "this"))
893            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
def indexcolumnconstraint_sql(self, expression: sqlglot.expressions.IndexColumnConstraint) -> str:
895        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
896            this = self.sql(expression, "this")
897            this = f" {this}" if this else ""
898            expr = self.sql(expression, "expression")
899            expr = f" {expr}" if expr else ""
900            index_type = self.sql(expression, "index_type")
901            index_type = f" TYPE {index_type}" if index_type else ""
902            granularity = self.sql(expression, "granularity")
903            granularity = f" GRANULARITY {granularity}" if granularity else ""
904
905            return f"INDEX{this}{expr}{index_type}{granularity}"
def partition_sql(self, expression: sqlglot.expressions.Partition) -> str:
907        def partition_sql(self, expression: exp.Partition) -> str:
908            return f"PARTITION {self.expressions(expression, flat=True)}"
def partitionid_sql(self, expression: sqlglot.expressions.PartitionId) -> str:
910        def partitionid_sql(self, expression: exp.PartitionId) -> str:
911            return f"ID {self.sql(expression.this)}"
def replacepartition_sql(self, expression: sqlglot.expressions.ReplacePartition) -> str:
913        def replacepartition_sql(self, expression: exp.ReplacePartition) -> str:
914            return (
915                f"REPLACE {self.sql(expression.expression)} FROM {self.sql(expression, 'source')}"
916            )
def projectiondef_sql(self, expression: sqlglot.expressions.ProjectionDef) -> str:
918        def projectiondef_sql(self, expression: exp.ProjectionDef) -> str:
919            return f"PROJECTION {self.sql(expression.this)} {self.wrap(expression.expression)}"
SELECT_KINDS: Tuple[str, ...] = ()
TRY_SUPPORTED = False
AFTER_HAVING_MODIFIER_TRANSFORMS = {'qualify': <function Generator.<lambda>>, 'windows': <function Generator.<lambda>>}
Inherited Members
sqlglot.generator.Generator
Generator
NULL_ORDERING_SUPPORTED
IGNORE_NULLS_IN_FUNC
LOCKING_READS_SUPPORTED
WRAP_DERIVED_VALUES
CREATE_FUNCTION_RETURN_AS
MATCHED_BY_SOURCE
SINGLE_STRING_INTERVAL
INTERVAL_ALLOWS_PLURAL_FORM
LIMIT_FETCH
LIMIT_ONLY_LITERALS
RENAME_TABLE_WITH_DB
INDEX_ON
QUERY_HINT_SEP
IS_BOOL_ALLOWED
DUPLICATE_KEY_UPDATE_WITH_SET
LIMIT_IS_TOP
RETURNING_END
COLUMN_JOIN_MARKS_SUPPORTED
EXTRACT_ALLOWS_QUOTES
TZ_TO_WITH_TIME_ZONE
VALUES_AS_TABLE
ALTER_TABLE_INCLUDE_COLUMN_KEYWORD
UNNEST_WITH_ORDINALITY
AGGREGATE_FILTER_SUPPORTED
SEMI_ANTI_JOIN_WITH_SIDE
COMPUTED_COLUMN_WITH_TYPE
SUPPORTS_TABLE_COPY
TABLESAMPLE_WITH_METHOD
TABLESAMPLE_SEED_KEYWORD
COLLATE_IS_FUNC
DATA_TYPE_SPECIFIERS_ALLOWED
ENSURE_BOOLS
CTE_RECURSIVE_KEYWORD_REQUIRED
SUPPORTS_SINGLE_ARG_CONCAT
SUPPORTS_TABLE_ALIAS_COLUMNS
UNPIVOT_ALIASES_ARE_IDENTIFIERS
JSON_KEY_VALUE_PAIR_SEP
INSERT_OVERWRITE
SUPPORTS_SELECT_INTO
SUPPORTS_UNLOGGED_TABLES
SUPPORTS_CREATE_TABLE_LIKE
LIKE_PROPERTY_INSIDE_SCHEMA
MULTI_ARG_DISTINCT
JSON_TYPE_REQUIRED_FOR_EXTRACTION
JSON_PATH_BRACKETED_KEY_SUPPORTED
JSON_PATH_SINGLE_QUOTE_ESCAPE
COPY_PARAMS_ARE_WRAPPED
COPY_PARAMS_EQ_REQUIRED
COPY_HAS_INTO_KEYWORD
STAR_EXCEPT
HEX_FUNC
TIME_PART_SINGULARS
TOKEN_MAPPING
PARAMETER_TOKEN
NAMED_PLACEHOLDER_TOKEN
RESERVED_KEYWORDS
WITH_SEPARATED_COMMENTS
EXCLUDE_COMMENTS
UNWRAPPED_INTERVAL_VALUES
PARAMETERIZABLE_TEXT_TYPES
EXPRESSIONS_WITHOUT_NESTED_CTES
SENTINEL_LINE_BREAK
pretty
identify
normalize
pad
unsupported_level
max_unsupported
leading_comma
max_text_width
comments
dialect
normalize_functions
unsupported_messages
generate
preprocess
unsupported
sep
seg
pad_comment
maybe_comment
wrap
no_identify
normalize_func
indent
sql
uncache_sql
cache_sql
characterset_sql
column_parts
column_sql
columnposition_sql
columndef_sql
columnconstraint_sql
computedcolumnconstraint_sql
autoincrementcolumnconstraint_sql
compresscolumnconstraint_sql
generatedasidentitycolumnconstraint_sql
generatedasrowcolumnconstraint_sql
periodforsystemtimeconstraint_sql
notnullcolumnconstraint_sql
transformcolumnconstraint_sql
primarykeycolumnconstraint_sql
uniquecolumnconstraint_sql
create_sql
sequenceproperties_sql
clone_sql
describe_sql
heredoc_sql
prepend_ctes
with_sql
tablealias_sql
bitstring_sql
hexstring_sql
bytestring_sql
unicodestring_sql
rawstring_sql
datatypeparam_sql
directory_sql
delete_sql
drop_sql
except_sql
except_op
fetch_sql
filter_sql
hint_sql
indexparameters_sql
index_sql
identifier_sql
hex_sql
lowerhex_sql
inputoutputformat_sql
national_sql
properties_sql
root_properties
properties
with_properties
locate_properties
property_name
property_sql
fallbackproperty_sql
journalproperty_sql
freespaceproperty_sql
checksumproperty_sql
mergeblockratioproperty_sql
datablocksizeproperty_sql
blockcompressionproperty_sql
isolatedloadingproperty_sql
partitionboundspec_sql
partitionedofproperty_sql
lockingproperty_sql
withdataproperty_sql
withsystemversioningproperty_sql
insert_sql
intersect_sql
intersect_op
introducer_sql
kill_sql
pseudotype_sql
objectidentifier_sql
onconflict_sql
returning_sql
rowformatdelimitedproperty_sql
withtablehint_sql
indextablehint_sql
historicaldata_sql
table_parts
table_sql
tablesample_sql
pivot_sql
version_sql
tuple_sql
update_sql
values_sql
var_sql
into_sql
from_sql
group_sql
having_sql
connect_sql
prior_sql
join_sql
lambda_sql
lateral_op
lateral_sql
limit_sql
offset_sql
setitem_sql
set_sql
pragma_sql
lock_sql
literal_sql
escape_str
loaddata_sql
null_sql
boolean_sql
order_sql
withfill_sql
cluster_sql
distribute_sql
sort_sql
ordered_sql
matchrecognizemeasure_sql
matchrecognize_sql
query_modifiers
queryoption_sql
offset_limit_modifiers
select_sql
schema_sql
schema_columns_sql
star_sql
parameter_sql
sessionparameter_sql
subquery_sql
qualify_sql
set_operations
union_sql
union_op
unnest_sql
where_sql
window_sql
partition_by_sql
windowspec_sql
withingroup_sql
between_sql
bracket_offset_expressions
bracket_sql
all_sql
any_sql
exists_sql
case_sql
constraint_sql
nextvaluefor_sql
extract_sql
trim_sql
convert_concat_args
concat_sql
concatws_sql
check_sql
foreignkey_sql
primarykey_sql
if_sql
matchagainst_sql
jsonkeyvalue_sql
jsonpath_sql
json_path_part
formatjson_sql
jsonobject_sql
jsonobjectagg_sql
jsonarray_sql
jsonarrayagg_sql
jsoncolumndef_sql
jsonschema_sql
jsontable_sql
openjsoncolumndef_sql
openjson_sql
in_sql
in_unnest_op
interval_sql
return_sql
reference_sql
anonymous_sql
paren_sql
neg_sql
not_sql
alias_sql
pivotalias_sql
aliases_sql
atindex_sql
attimezone_sql
fromtimezone_sql
add_sql
and_sql
or_sql
xor_sql
connector_sql
bitwiseand_sql
bitwiseleftshift_sql
bitwisenot_sql
bitwiseor_sql
bitwiserightshift_sql
bitwisexor_sql
cast_sql
currentdate_sql
currenttimestamp_sql
collate_sql
command_sql
comment_sql
mergetreettlaction_sql
mergetreettl_sql
transaction_sql
commit_sql
rollback_sql
altercolumn_sql
alterdiststyle_sql
altersortkey_sql
renametable_sql
renamecolumn_sql
altertable_sql
add_column_sql
droppartition_sql
addconstraint_sql
distinct_sql
ignorenulls_sql
respectnulls_sql
havingmax_sql
intdiv_sql
dpipe_sql
div_sql
overlaps_sql
distance_sql
dot_sql
propertyeq_sql
escape_sql
glob_sql
gt_sql
gte_sql
ilike_sql
ilikeany_sql
is_sql
like_sql
likeany_sql
similarto_sql
lt_sql
lte_sql
mod_sql
mul_sql
nullsafeeq_sql
nullsafeneq_sql
slice_sql
sub_sql
trycast_sql
try_sql
log_sql
use_sql
binary
function_fallback_sql
func
format_args
too_wide
format_time
expressions
op_expressions
naked_property
tag_sql
token_sql
userdefinedfunction_sql
joinhint_sql
kwarg_sql
when_sql
merge_sql
tochar_sql
tonumber_sql
dictproperty_sql
dictrange_sql
dictsubproperty_sql
clusteredbyproperty_sql
anyvalue_sql
querytransform_sql
indexconstraintoption_sql
checkcolumnconstraint_sql
nvl2_sql
comprehension_sql
columnprefix_sql
opclass_sql
predict_sql
forin_sql
refresh_sql
operator_sql
toarray_sql
tsordstotime_sql
tsordstotimestamp_sql
tsordstodate_sql
unixdate_sql
lastday_sql
dateadd_sql
arrayany_sql
generateseries_sql
struct_sql
partitionrange_sql
truncatetable_sql
convert_sql
copyparameter_sql
credentials_sql
copy_sql
semicolon_sql