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

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_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': <bound method Func.from_arg_list of <class 'sqlglot.expressions.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': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lower'>>, 'LCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lower'>>, 'MD5': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5'>>, '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': <bound method Func.from_arg_list of <class 'sqlglot.expressions.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 Parser.<lambda>>, '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'>>}
AGG_FUNCTIONS = {'cramersVBiasCorrected', 'topK', 'quantileTimingWeighted', 'maxMap', 'groupBitmapXor', 'studentTTest', 'covarPop', 'quantilesInterpolatedWeighted', 'last_value', 'boundingRatio', 'quantileExact', 'quantile', 'min', 'topKWeighted', 'uniqTheta', 'kurtSamp', 'quantilesTimingWeighted', 'theilsU', 'largestTriangleThreeBuckets', 'groupBitmapOr', 'quantilesExactLow', 'quantilesBFloat16', 'welchTTest', 'sumMap', 'quantileTDigest', 'cramersV', 'entropy', 'covarSamp', 'maxIntersectionsPosition', 'simpleLinearRegression', 'argMax', 'stochasticLogisticRegression', 'quantileDeterministic', 'quantiles', 'corr', 'avgWeighted', 'uniqHLL12', 'quantileExactHigh', 'sumWithOverflow', 'quantileExactWeighted', 'uniq', 'stochasticLinearRegression', 'deltaSum', 'sum', 'histogram', 'quantilesDeterministic', 'groupBitOr', 'quantileTiming', 'sequenceNextNode', 'quantileTDigestWeighted', 'rankCorr', 'first_value', 'sequenceCount', 'varSamp', 'uniqUpTo', 'contingency', 'anyHeavy', 'groupArrayLast', 'exponentialTimeDecayedAvg', 'sequenceMatch', 'varPop', 'groupArrayMovingAvg', 'uniqCombined', 'sumCount', 'quantileGK', 'skewPop', 'groupBitAnd', 'max', 'intervalLengthSum', 'quantilesExactHigh', 'quantilesBFloat16Weighted', 'sumKahan', 'median', 'quantilesGK', 'avg', 'meanZTest', 'retention', 'windowFunnel', 'kurtPop', 'uniqCombined64', 'groupUniqArray', 'groupArrayMovingSum', 'groupArray', 'groupBitXor', 'quantileBFloat16', 'deltaSumTimestamp', 'minMap', 'skewSamp', 'quantilesTDigest', 'any', 'maxIntersections', 'sparkBar', 'kolmogorovSmirnovTest', 'groupArraySample', 'groupBitmap', 'categoricalInformationValue', 'quantileInterpolatedWeighted', 'quantilesTiming', 'quantilesTDigestWeighted', 'groupBitmapAnd', 'uniqExact', 'quantilesExactWeighted', 'quantileBFloat16Weighted', 'argMin', 'stddevPop', 'exponentialMovingAverage', 'count', 'mannWhitneyUTest', 'quantileExactLow', 'quantilesExact', 'groupArrayInsertAt', 'anyLast', 'stddevSamp'}
AGG_FUNCTIONS_SUFFIXES = ['If', 'Array', 'ArrayIf', 'Map', 'SimpleState', 'State', 'Merge', 'MergeState', 'ForEach', 'Distinct', 'OrDefault', 'OrNull', 'Resample', 'ArgMin', 'ArgMax']
FUNC_TOKENS = {<TokenType.TINYINT: 'TINYINT'>, <TokenType.SOME: 'SOME'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.BIT: 'BIT'>, <TokenType.ANY: 'ANY'>, <TokenType.JSONB: 'JSONB'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.LEFT: 'LEFT'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.RANGE: 'RANGE'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.FILTER: 'FILTER'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.INT128: 'INT128'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.UINT256: 'UINT256'>, <TokenType.UINT: 'UINT'>, <TokenType.YEAR: 'YEAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.XOR: 'XOR'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.LIKE: 'LIKE'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, <TokenType.CHAR: 'CHAR'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.NAME: 'NAME'>, <TokenType.INDEX: 'INDEX'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.ILIKE: 'ILIKE'>, <TokenType.UUID: 'UUID'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.RLIKE: 'RLIKE'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.NULL: 'NULL'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.UINT128: 'UINT128'>, <TokenType.VAR: 'VAR'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.TIME: 'TIME'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.ALL: 'ALL'>, <TokenType.ROW: 'ROW'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.XML: 'XML'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.NESTED: 'NESTED'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.IPV4: 'IPV4'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.GLOB: 'GLOB'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.TEXT: 'TEXT'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.DATE: 'DATE'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.INT: 'INT'>, <TokenType.IPV6: 'IPV6'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.DATE32: 'DATE32'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.INSERT: 'INSERT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.INT256: 'INT256'>, <TokenType.SET: 'SET'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.JSON: 'JSON'>, <TokenType.FIRST: 'FIRST'>, <TokenType.BINARY: 'BINARY'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.MERGE: 'MERGE'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.TABLE: 'TABLE'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.SUPER: 'SUPER'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.INET: 'INET'>, <TokenType.MAP: 'MAP'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.MONEY: 'MONEY'>, <TokenType.BOOLEAN: 'BOOLEAN'>}
AGG_FUNC_MAPPING = {'cramersVBiasCorrectedIf': ('cramersVBiasCorrected', 'If'), 'topKIf': ('topK', 'If'), 'quantileTimingWeightedIf': ('quantileTimingWeighted', 'If'), 'maxMapIf': ('maxMap', 'If'), 'groupBitmapXorIf': ('groupBitmapXor', 'If'), 'studentTTestIf': ('studentTTest', 'If'), 'covarPopIf': ('covarPop', 'If'), 'quantilesInterpolatedWeightedIf': ('quantilesInterpolatedWeighted', 'If'), 'last_valueIf': ('last_value', 'If'), 'boundingRatioIf': ('boundingRatio', 'If'), 'quantileExactIf': ('quantileExact', 'If'), 'quantileIf': ('quantile', 'If'), 'minIf': ('min', 'If'), 'topKWeightedIf': ('topKWeighted', 'If'), 'uniqThetaIf': ('uniqTheta', 'If'), 'kurtSampIf': ('kurtSamp', 'If'), 'quantilesTimingWeightedIf': ('quantilesTimingWeighted', 'If'), 'theilsUIf': ('theilsU', 'If'), 'largestTriangleThreeBucketsIf': ('largestTriangleThreeBuckets', 'If'), 'groupBitmapOrIf': ('groupBitmapOr', 'If'), 'quantilesExactLowIf': ('quantilesExactLow', 'If'), 'quantilesBFloat16If': ('quantilesBFloat16', 'If'), 'welchTTestIf': ('welchTTest', 'If'), 'sumMapIf': ('sumMap', 'If'), 'quantileTDigestIf': ('quantileTDigest', 'If'), 'cramersVIf': ('cramersV', 'If'), 'entropyIf': ('entropy', 'If'), 'covarSampIf': ('covarSamp', 'If'), 'maxIntersectionsPositionIf': ('maxIntersectionsPosition', 'If'), 'simpleLinearRegressionIf': ('simpleLinearRegression', 'If'), 'argMaxIf': ('argMax', 'If'), 'stochasticLogisticRegressionIf': ('stochasticLogisticRegression', 'If'), 'quantileDeterministicIf': ('quantileDeterministic', 'If'), 'quantilesIf': ('quantiles', 'If'), 'corrIf': ('corr', 'If'), 'avgWeightedIf': ('avgWeighted', 'If'), 'uniqHLL12If': ('uniqHLL12', 'If'), 'quantileExactHighIf': ('quantileExactHigh', 'If'), 'sumWithOverflowIf': ('sumWithOverflow', 'If'), 'quantileExactWeightedIf': ('quantileExactWeighted', 'If'), 'uniqIf': ('uniq', 'If'), 'stochasticLinearRegressionIf': ('stochasticLinearRegression', 'If'), 'deltaSumIf': ('deltaSum', 'If'), 'sumIf': ('sum', 'If'), 'histogramIf': ('histogram', 'If'), 'quantilesDeterministicIf': ('quantilesDeterministic', 'If'), 'groupBitOrIf': ('groupBitOr', 'If'), 'quantileTimingIf': ('quantileTiming', 'If'), 'sequenceNextNodeIf': ('sequenceNextNode', 'If'), 'quantileTDigestWeightedIf': ('quantileTDigestWeighted', 'If'), 'rankCorrIf': ('rankCorr', 'If'), 'first_valueIf': ('first_value', 'If'), 'sequenceCountIf': ('sequenceCount', 'If'), 'varSampIf': ('varSamp', 'If'), 'uniqUpToIf': ('uniqUpTo', 'If'), 'contingencyIf': ('contingency', 'If'), 'anyHeavyIf': ('anyHeavy', 'If'), 'groupArrayLastIf': ('groupArrayLast', 'If'), 'exponentialTimeDecayedAvgIf': ('exponentialTimeDecayedAvg', 'If'), 'sequenceMatchIf': ('sequenceMatch', 'If'), 'varPopIf': ('varPop', 'If'), 'groupArrayMovingAvgIf': ('groupArrayMovingAvg', 'If'), 'uniqCombinedIf': ('uniqCombined', 'If'), 'sumCountIf': ('sumCount', 'If'), 'quantileGKIf': ('quantileGK', 'If'), 'skewPopIf': ('skewPop', 'If'), 'groupBitAndIf': ('groupBitAnd', 'If'), 'maxIf': ('max', 'If'), 'intervalLengthSumIf': ('intervalLengthSum', 'If'), 'quantilesExactHighIf': ('quantilesExactHigh', 'If'), 'quantilesBFloat16WeightedIf': ('quantilesBFloat16Weighted', 'If'), 'sumKahanIf': ('sumKahan', 'If'), 'medianIf': ('median', 'If'), 'quantilesGKIf': ('quantilesGK', 'If'), 'avgIf': ('avg', 'If'), 'meanZTestIf': ('meanZTest', 'If'), 'retentionIf': ('retention', 'If'), 'windowFunnelIf': ('windowFunnel', 'If'), 'kurtPopIf': ('kurtPop', 'If'), 'uniqCombined64If': ('uniqCombined64', 'If'), 'groupUniqArrayIf': ('groupUniqArray', 'If'), 'groupArrayMovingSumIf': ('groupArrayMovingSum', 'If'), 'groupArrayIf': ('groupArray', 'If'), 'groupBitXorIf': ('groupBitXor', 'If'), 'quantileBFloat16If': ('quantileBFloat16', 'If'), 'deltaSumTimestampIf': ('deltaSumTimestamp', 'If'), 'minMapIf': ('minMap', 'If'), 'skewSampIf': ('skewSamp', 'If'), 'quantilesTDigestIf': ('quantilesTDigest', 'If'), 'anyIf': ('any', 'If'), 'maxIntersectionsIf': ('maxIntersections', 'If'), 'sparkBarIf': ('sparkBar', 'If'), 'kolmogorovSmirnovTestIf': ('kolmogorovSmirnovTest', 'If'), 'groupArraySampleIf': ('groupArraySample', 'If'), 'groupBitmapIf': ('groupBitmap', 'If'), 'categoricalInformationValueIf': ('categoricalInformationValue', 'If'), 'quantileInterpolatedWeightedIf': ('quantileInterpolatedWeighted', 'If'), 'quantilesTimingIf': ('quantilesTiming', 'If'), 'quantilesTDigestWeightedIf': ('quantilesTDigestWeighted', 'If'), 'groupBitmapAndIf': ('groupBitmapAnd', 'If'), 'uniqExactIf': ('uniqExact', 'If'), 'quantilesExactWeightedIf': ('quantilesExactWeighted', 'If'), 'quantileBFloat16WeightedIf': ('quantileBFloat16Weighted', 'If'), 'argMinIf': ('argMin', 'If'), 'stddevPopIf': ('stddevPop', 'If'), 'exponentialMovingAverageIf': ('exponentialMovingAverage', 'If'), 'countIf': ('count', 'If'), 'mannWhitneyUTestIf': ('mannWhitneyUTest', 'If'), 'quantileExactLowIf': ('quantileExactLow', 'If'), 'quantilesExactIf': ('quantilesExact', 'If'), 'groupArrayInsertAtIf': ('groupArrayInsertAt', 'If'), 'anyLastIf': ('anyLast', 'If'), 'stddevSampIf': ('stddevSamp', 'If'), 'cramersVBiasCorrectedArray': ('cramersVBiasCorrected', 'Array'), 'topKArray': ('topK', 'Array'), 'quantileTimingWeightedArray': ('quantileTimingWeighted', 'Array'), 'maxMapArray': ('maxMap', 'Array'), 'groupBitmapXorArray': ('groupBitmapXor', 'Array'), 'studentTTestArray': ('studentTTest', 'Array'), 'covarPopArray': ('covarPop', 'Array'), 'quantilesInterpolatedWeightedArray': ('quantilesInterpolatedWeighted', 'Array'), 'last_valueArray': ('last_value', 'Array'), 'boundingRatioArray': ('boundingRatio', 'Array'), 'quantileExactArray': ('quantileExact', 'Array'), 'quantileArray': ('quantile', 'Array'), 'minArray': ('min', 'Array'), 'topKWeightedArray': ('topKWeighted', 'Array'), 'uniqThetaArray': ('uniqTheta', 'Array'), 'kurtSampArray': ('kurtSamp', 'Array'), 'quantilesTimingWeightedArray': ('quantilesTimingWeighted', 'Array'), 'theilsUArray': ('theilsU', 'Array'), 'largestTriangleThreeBucketsArray': ('largestTriangleThreeBuckets', 'Array'), 'groupBitmapOrArray': ('groupBitmapOr', 'Array'), 'quantilesExactLowArray': ('quantilesExactLow', 'Array'), 'quantilesBFloat16Array': ('quantilesBFloat16', 'Array'), 'welchTTestArray': ('welchTTest', 'Array'), 'sumMapArray': ('sumMap', 'Array'), 'quantileTDigestArray': ('quantileTDigest', 'Array'), 'cramersVArray': ('cramersV', 'Array'), 'entropyArray': ('entropy', 'Array'), 'covarSampArray': ('covarSamp', 'Array'), 'maxIntersectionsPositionArray': ('maxIntersectionsPosition', 'Array'), 'simpleLinearRegressionArray': ('simpleLinearRegression', 'Array'), 'argMaxArray': ('argMax', 'Array'), 'stochasticLogisticRegressionArray': ('stochasticLogisticRegression', 'Array'), 'quantileDeterministicArray': ('quantileDeterministic', 'Array'), 'quantilesArray': ('quantiles', 'Array'), 'corrArray': ('corr', 'Array'), 'avgWeightedArray': ('avgWeighted', 'Array'), 'uniqHLL12Array': ('uniqHLL12', 'Array'), 'quantileExactHighArray': ('quantileExactHigh', 'Array'), 'sumWithOverflowArray': ('sumWithOverflow', 'Array'), 'quantileExactWeightedArray': ('quantileExactWeighted', 'Array'), 'uniqArray': ('uniq', 'Array'), 'stochasticLinearRegressionArray': ('stochasticLinearRegression', 'Array'), 'deltaSumArray': ('deltaSum', 'Array'), 'sumArray': ('sum', 'Array'), 'histogramArray': ('histogram', 'Array'), 'quantilesDeterministicArray': ('quantilesDeterministic', 'Array'), 'groupBitOrArray': ('groupBitOr', 'Array'), 'quantileTimingArray': ('quantileTiming', 'Array'), 'sequenceNextNodeArray': ('sequenceNextNode', 'Array'), 'quantileTDigestWeightedArray': ('quantileTDigestWeighted', 'Array'), 'rankCorrArray': ('rankCorr', 'Array'), 'first_valueArray': ('first_value', 'Array'), 'sequenceCountArray': ('sequenceCount', 'Array'), 'varSampArray': ('varSamp', 'Array'), 'uniqUpToArray': ('uniqUpTo', 'Array'), 'contingencyArray': ('contingency', 'Array'), 'anyHeavyArray': ('anyHeavy', 'Array'), 'groupArrayLastArray': ('groupArrayLast', 'Array'), 'exponentialTimeDecayedAvgArray': ('exponentialTimeDecayedAvg', 'Array'), 'sequenceMatchArray': ('sequenceMatch', 'Array'), 'varPopArray': ('varPop', 'Array'), 'groupArrayMovingAvgArray': ('groupArrayMovingAvg', 'Array'), 'uniqCombinedArray': ('uniqCombined', 'Array'), 'sumCountArray': ('sumCount', 'Array'), 'quantileGKArray': ('quantileGK', 'Array'), 'skewPopArray': ('skewPop', 'Array'), 'groupBitAndArray': ('groupBitAnd', 'Array'), 'maxArray': ('max', 'Array'), 'intervalLengthSumArray': ('intervalLengthSum', 'Array'), 'quantilesExactHighArray': ('quantilesExactHigh', 'Array'), 'quantilesBFloat16WeightedArray': ('quantilesBFloat16Weighted', 'Array'), 'sumKahanArray': ('sumKahan', 'Array'), 'medianArray': ('median', 'Array'), 'quantilesGKArray': ('quantilesGK', 'Array'), 'avgArray': ('avg', 'Array'), 'meanZTestArray': ('meanZTest', 'Array'), 'retentionArray': ('retention', 'Array'), 'windowFunnelArray': ('windowFunnel', 'Array'), 'kurtPopArray': ('kurtPop', 'Array'), 'uniqCombined64Array': ('uniqCombined64', 'Array'), 'groupUniqArrayArray': ('groupUniqArray', 'Array'), 'groupArrayMovingSumArray': ('groupArrayMovingSum', 'Array'), 'groupArrayArray': ('groupArray', 'Array'), 'groupBitXorArray': ('groupBitXor', 'Array'), 'quantileBFloat16Array': ('quantileBFloat16', 'Array'), 'deltaSumTimestampArray': ('deltaSumTimestamp', 'Array'), 'minMapArray': ('minMap', 'Array'), 'skewSampArray': ('skewSamp', 'Array'), 'quantilesTDigestArray': ('quantilesTDigest', 'Array'), 'anyArray': ('any', 'Array'), 'maxIntersectionsArray': ('maxIntersections', 'Array'), 'sparkBarArray': ('sparkBar', 'Array'), 'kolmogorovSmirnovTestArray': ('kolmogorovSmirnovTest', 'Array'), 'groupArraySampleArray': ('groupArraySample', 'Array'), 'groupBitmapArray': ('groupBitmap', 'Array'), 'categoricalInformationValueArray': ('categoricalInformationValue', 'Array'), 'quantileInterpolatedWeightedArray': ('quantileInterpolatedWeighted', 'Array'), 'quantilesTimingArray': ('quantilesTiming', 'Array'), 'quantilesTDigestWeightedArray': ('quantilesTDigestWeighted', 'Array'), 'groupBitmapAndArray': ('groupBitmapAnd', 'Array'), 'uniqExactArray': ('uniqExact', 'Array'), 'quantilesExactWeightedArray': ('quantilesExactWeighted', 'Array'), 'quantileBFloat16WeightedArray': ('quantileBFloat16Weighted', 'Array'), 'argMinArray': ('argMin', 'Array'), 'stddevPopArray': ('stddevPop', 'Array'), 'exponentialMovingAverageArray': ('exponentialMovingAverage', 'Array'), 'countArray': ('count', 'Array'), 'mannWhitneyUTestArray': ('mannWhitneyUTest', 'Array'), 'quantileExactLowArray': ('quantileExactLow', 'Array'), 'quantilesExactArray': ('quantilesExact', 'Array'), 'groupArrayInsertAtArray': ('groupArrayInsertAt', 'Array'), 'anyLastArray': ('anyLast', 'Array'), 'stddevSampArray': ('stddevSamp', 'Array'), 'cramersVBiasCorrectedArrayIf': ('cramersVBiasCorrected', 'ArrayIf'), 'topKArrayIf': ('topK', 'ArrayIf'), 'quantileTimingWeightedArrayIf': ('quantileTimingWeighted', 'ArrayIf'), 'maxMapArrayIf': ('maxMap', 'ArrayIf'), 'groupBitmapXorArrayIf': ('groupBitmapXor', 'ArrayIf'), 'studentTTestArrayIf': ('studentTTest', 'ArrayIf'), 'covarPopArrayIf': ('covarPop', 'ArrayIf'), 'quantilesInterpolatedWeightedArrayIf': ('quantilesInterpolatedWeighted', 'ArrayIf'), 'last_valueArrayIf': ('last_value', 'ArrayIf'), 'boundingRatioArrayIf': ('boundingRatio', 'ArrayIf'), 'quantileExactArrayIf': ('quantileExact', 'ArrayIf'), 'quantileArrayIf': ('quantile', 'ArrayIf'), 'minArrayIf': ('min', 'ArrayIf'), 'topKWeightedArrayIf': ('topKWeighted', 'ArrayIf'), 'uniqThetaArrayIf': ('uniqTheta', 'ArrayIf'), 'kurtSampArrayIf': ('kurtSamp', 'ArrayIf'), 'quantilesTimingWeightedArrayIf': ('quantilesTimingWeighted', 'ArrayIf'), 'theilsUArrayIf': ('theilsU', 'ArrayIf'), 'largestTriangleThreeBucketsArrayIf': ('largestTriangleThreeBuckets', 'ArrayIf'), 'groupBitmapOrArrayIf': ('groupBitmapOr', 'ArrayIf'), 'quantilesExactLowArrayIf': ('quantilesExactLow', 'ArrayIf'), 'quantilesBFloat16ArrayIf': ('quantilesBFloat16', 'ArrayIf'), 'welchTTestArrayIf': ('welchTTest', 'ArrayIf'), 'sumMapArrayIf': ('sumMap', 'ArrayIf'), 'quantileTDigestArrayIf': ('quantileTDigest', 'ArrayIf'), 'cramersVArrayIf': ('cramersV', 'ArrayIf'), 'entropyArrayIf': ('entropy', 'ArrayIf'), 'covarSampArrayIf': ('covarSamp', 'ArrayIf'), 'maxIntersectionsPositionArrayIf': ('maxIntersectionsPosition', 'ArrayIf'), 'simpleLinearRegressionArrayIf': ('simpleLinearRegression', 'ArrayIf'), 'argMaxArrayIf': ('argMax', 'ArrayIf'), 'stochasticLogisticRegressionArrayIf': ('stochasticLogisticRegression', 'ArrayIf'), 'quantileDeterministicArrayIf': ('quantileDeterministic', 'ArrayIf'), 'quantilesArrayIf': ('quantiles', 'ArrayIf'), 'corrArrayIf': ('corr', 'ArrayIf'), 'avgWeightedArrayIf': ('avgWeighted', 'ArrayIf'), 'uniqHLL12ArrayIf': ('uniqHLL12', 'ArrayIf'), 'quantileExactHighArrayIf': ('quantileExactHigh', 'ArrayIf'), 'sumWithOverflowArrayIf': ('sumWithOverflow', 'ArrayIf'), 'quantileExactWeightedArrayIf': ('quantileExactWeighted', 'ArrayIf'), 'uniqArrayIf': ('uniq', 'ArrayIf'), 'stochasticLinearRegressionArrayIf': ('stochasticLinearRegression', 'ArrayIf'), 'deltaSumArrayIf': ('deltaSum', 'ArrayIf'), 'sumArrayIf': ('sum', 'ArrayIf'), 'histogramArrayIf': ('histogram', 'ArrayIf'), 'quantilesDeterministicArrayIf': ('quantilesDeterministic', 'ArrayIf'), 'groupBitOrArrayIf': ('groupBitOr', 'ArrayIf'), 'quantileTimingArrayIf': ('quantileTiming', 'ArrayIf'), 'sequenceNextNodeArrayIf': ('sequenceNextNode', 'ArrayIf'), 'quantileTDigestWeightedArrayIf': ('quantileTDigestWeighted', 'ArrayIf'), 'rankCorrArrayIf': ('rankCorr', 'ArrayIf'), 'first_valueArrayIf': ('first_value', 'ArrayIf'), 'sequenceCountArrayIf': ('sequenceCount', 'ArrayIf'), 'varSampArrayIf': ('varSamp', 'ArrayIf'), 'uniqUpToArrayIf': ('uniqUpTo', 'ArrayIf'), 'contingencyArrayIf': ('contingency', 'ArrayIf'), 'anyHeavyArrayIf': ('anyHeavy', 'ArrayIf'), 'groupArrayLastArrayIf': ('groupArrayLast', 'ArrayIf'), 'exponentialTimeDecayedAvgArrayIf': ('exponentialTimeDecayedAvg', 'ArrayIf'), 'sequenceMatchArrayIf': ('sequenceMatch', 'ArrayIf'), 'varPopArrayIf': ('varPop', 'ArrayIf'), 'groupArrayMovingAvgArrayIf': ('groupArrayMovingAvg', 'ArrayIf'), 'uniqCombinedArrayIf': ('uniqCombined', 'ArrayIf'), 'sumCountArrayIf': ('sumCount', 'ArrayIf'), 'quantileGKArrayIf': ('quantileGK', 'ArrayIf'), 'skewPopArrayIf': ('skewPop', 'ArrayIf'), 'groupBitAndArrayIf': ('groupBitAnd', 'ArrayIf'), 'maxArrayIf': ('max', 'ArrayIf'), 'intervalLengthSumArrayIf': ('intervalLengthSum', 'ArrayIf'), 'quantilesExactHighArrayIf': ('quantilesExactHigh', 'ArrayIf'), 'quantilesBFloat16WeightedArrayIf': ('quantilesBFloat16Weighted', 'ArrayIf'), 'sumKahanArrayIf': ('sumKahan', 'ArrayIf'), 'medianArrayIf': ('median', 'ArrayIf'), 'quantilesGKArrayIf': ('quantilesGK', 'ArrayIf'), 'avgArrayIf': ('avg', 'ArrayIf'), 'meanZTestArrayIf': ('meanZTest', 'ArrayIf'), 'retentionArrayIf': ('retention', 'ArrayIf'), 'windowFunnelArrayIf': ('windowFunnel', 'ArrayIf'), 'kurtPopArrayIf': ('kurtPop', 'ArrayIf'), 'uniqCombined64ArrayIf': ('uniqCombined64', 'ArrayIf'), 'groupUniqArrayArrayIf': ('groupUniqArray', 'ArrayIf'), 'groupArrayMovingSumArrayIf': ('groupArrayMovingSum', 'ArrayIf'), 'groupArrayArrayIf': ('groupArray', 'ArrayIf'), 'groupBitXorArrayIf': ('groupBitXor', 'ArrayIf'), 'quantileBFloat16ArrayIf': ('quantileBFloat16', 'ArrayIf'), 'deltaSumTimestampArrayIf': ('deltaSumTimestamp', 'ArrayIf'), 'minMapArrayIf': ('minMap', 'ArrayIf'), 'skewSampArrayIf': ('skewSamp', 'ArrayIf'), 'quantilesTDigestArrayIf': ('quantilesTDigest', 'ArrayIf'), 'anyArrayIf': ('any', 'ArrayIf'), 'maxIntersectionsArrayIf': ('maxIntersections', 'ArrayIf'), 'sparkBarArrayIf': ('sparkBar', 'ArrayIf'), 'kolmogorovSmirnovTestArrayIf': ('kolmogorovSmirnovTest', 'ArrayIf'), 'groupArraySampleArrayIf': ('groupArraySample', 'ArrayIf'), 'groupBitmapArrayIf': ('groupBitmap', 'ArrayIf'), 'categoricalInformationValueArrayIf': ('categoricalInformationValue', 'ArrayIf'), 'quantileInterpolatedWeightedArrayIf': ('quantileInterpolatedWeighted', 'ArrayIf'), 'quantilesTimingArrayIf': ('quantilesTiming', 'ArrayIf'), 'quantilesTDigestWeightedArrayIf': ('quantilesTDigestWeighted', 'ArrayIf'), 'groupBitmapAndArrayIf': ('groupBitmapAnd', 'ArrayIf'), 'uniqExactArrayIf': ('uniqExact', 'ArrayIf'), 'quantilesExactWeightedArrayIf': ('quantilesExactWeighted', 'ArrayIf'), 'quantileBFloat16WeightedArrayIf': ('quantileBFloat16Weighted', 'ArrayIf'), 'argMinArrayIf': ('argMin', 'ArrayIf'), 'stddevPopArrayIf': ('stddevPop', 'ArrayIf'), 'exponentialMovingAverageArrayIf': ('exponentialMovingAverage', 'ArrayIf'), 'countArrayIf': ('count', 'ArrayIf'), 'mannWhitneyUTestArrayIf': ('mannWhitneyUTest', 'ArrayIf'), 'quantileExactLowArrayIf': ('quantileExactLow', 'ArrayIf'), 'quantilesExactArrayIf': ('quantilesExact', 'ArrayIf'), 'groupArrayInsertAtArrayIf': ('groupArrayInsertAt', 'ArrayIf'), 'anyLastArrayIf': ('anyLast', 'ArrayIf'), 'stddevSampArrayIf': ('stddevSamp', 'ArrayIf'), 'cramersVBiasCorrectedMap': ('cramersVBiasCorrected', 'Map'), 'topKMap': ('topK', 'Map'), 'quantileTimingWeightedMap': ('quantileTimingWeighted', 'Map'), 'maxMapMap': ('maxMap', 'Map'), 'groupBitmapXorMap': ('groupBitmapXor', 'Map'), 'studentTTestMap': ('studentTTest', 'Map'), 'covarPopMap': ('covarPop', 'Map'), 'quantilesInterpolatedWeightedMap': ('quantilesInterpolatedWeighted', 'Map'), 'last_valueMap': ('last_value', 'Map'), 'boundingRatioMap': ('boundingRatio', 'Map'), 'quantileExactMap': ('quantileExact', 'Map'), 'quantileMap': ('quantile', 'Map'), 'minMap': ('minMap', ''), 'topKWeightedMap': ('topKWeighted', 'Map'), 'uniqThetaMap': ('uniqTheta', 'Map'), 'kurtSampMap': ('kurtSamp', 'Map'), 'quantilesTimingWeightedMap': ('quantilesTimingWeighted', 'Map'), 'theilsUMap': ('theilsU', 'Map'), 'largestTriangleThreeBucketsMap': ('largestTriangleThreeBuckets', 'Map'), 'groupBitmapOrMap': ('groupBitmapOr', 'Map'), 'quantilesExactLowMap': ('quantilesExactLow', 'Map'), 'quantilesBFloat16Map': ('quantilesBFloat16', 'Map'), 'welchTTestMap': ('welchTTest', 'Map'), 'sumMapMap': ('sumMap', 'Map'), 'quantileTDigestMap': ('quantileTDigest', 'Map'), 'cramersVMap': ('cramersV', 'Map'), 'entropyMap': ('entropy', 'Map'), 'covarSampMap': ('covarSamp', 'Map'), 'maxIntersectionsPositionMap': ('maxIntersectionsPosition', 'Map'), 'simpleLinearRegressionMap': ('simpleLinearRegression', 'Map'), 'argMaxMap': ('argMax', 'Map'), 'stochasticLogisticRegressionMap': ('stochasticLogisticRegression', 'Map'), 'quantileDeterministicMap': ('quantileDeterministic', 'Map'), 'quantilesMap': ('quantiles', 'Map'), 'corrMap': ('corr', 'Map'), 'avgWeightedMap': ('avgWeighted', 'Map'), 'uniqHLL12Map': ('uniqHLL12', 'Map'), 'quantileExactHighMap': ('quantileExactHigh', 'Map'), 'sumWithOverflowMap': ('sumWithOverflow', 'Map'), 'quantileExactWeightedMap': ('quantileExactWeighted', 'Map'), 'uniqMap': ('uniq', 'Map'), 'stochasticLinearRegressionMap': ('stochasticLinearRegression', 'Map'), 'deltaSumMap': ('deltaSum', 'Map'), 'sumMap': ('sumMap', ''), 'histogramMap': ('histogram', 'Map'), 'quantilesDeterministicMap': ('quantilesDeterministic', 'Map'), 'groupBitOrMap': ('groupBitOr', 'Map'), 'quantileTimingMap': ('quantileTiming', 'Map'), 'sequenceNextNodeMap': ('sequenceNextNode', 'Map'), 'quantileTDigestWeightedMap': ('quantileTDigestWeighted', 'Map'), 'rankCorrMap': ('rankCorr', 'Map'), 'first_valueMap': ('first_value', 'Map'), 'sequenceCountMap': ('sequenceCount', 'Map'), 'varSampMap': ('varSamp', 'Map'), 'uniqUpToMap': ('uniqUpTo', 'Map'), 'contingencyMap': ('contingency', 'Map'), 'anyHeavyMap': ('anyHeavy', 'Map'), 'groupArrayLastMap': ('groupArrayLast', 'Map'), 'exponentialTimeDecayedAvgMap': ('exponentialTimeDecayedAvg', 'Map'), 'sequenceMatchMap': ('sequenceMatch', 'Map'), 'varPopMap': ('varPop', 'Map'), 'groupArrayMovingAvgMap': ('groupArrayMovingAvg', 'Map'), 'uniqCombinedMap': ('uniqCombined', 'Map'), 'sumCountMap': ('sumCount', 'Map'), 'quantileGKMap': ('quantileGK', 'Map'), 'skewPopMap': ('skewPop', 'Map'), 'groupBitAndMap': ('groupBitAnd', 'Map'), 'maxMap': ('maxMap', ''), 'intervalLengthSumMap': ('intervalLengthSum', 'Map'), 'quantilesExactHighMap': ('quantilesExactHigh', 'Map'), 'quantilesBFloat16WeightedMap': ('quantilesBFloat16Weighted', 'Map'), 'sumKahanMap': ('sumKahan', 'Map'), 'medianMap': ('median', 'Map'), 'quantilesGKMap': ('quantilesGK', 'Map'), 'avgMap': ('avg', 'Map'), 'meanZTestMap': ('meanZTest', 'Map'), 'retentionMap': ('retention', 'Map'), 'windowFunnelMap': ('windowFunnel', 'Map'), 'kurtPopMap': ('kurtPop', 'Map'), 'uniqCombined64Map': ('uniqCombined64', 'Map'), 'groupUniqArrayMap': ('groupUniqArray', 'Map'), 'groupArrayMovingSumMap': ('groupArrayMovingSum', 'Map'), 'groupArrayMap': ('groupArray', 'Map'), 'groupBitXorMap': ('groupBitXor', 'Map'), 'quantileBFloat16Map': ('quantileBFloat16', 'Map'), 'deltaSumTimestampMap': ('deltaSumTimestamp', 'Map'), 'minMapMap': ('minMap', 'Map'), 'skewSampMap': ('skewSamp', 'Map'), 'quantilesTDigestMap': ('quantilesTDigest', 'Map'), 'anyMap': ('any', 'Map'), 'maxIntersectionsMap': ('maxIntersections', 'Map'), 'sparkBarMap': ('sparkBar', 'Map'), 'kolmogorovSmirnovTestMap': ('kolmogorovSmirnovTest', 'Map'), 'groupArraySampleMap': ('groupArraySample', 'Map'), 'groupBitmapMap': ('groupBitmap', 'Map'), 'categoricalInformationValueMap': ('categoricalInformationValue', 'Map'), 'quantileInterpolatedWeightedMap': ('quantileInterpolatedWeighted', 'Map'), 'quantilesTimingMap': ('quantilesTiming', 'Map'), 'quantilesTDigestWeightedMap': ('quantilesTDigestWeighted', 'Map'), 'groupBitmapAndMap': ('groupBitmapAnd', 'Map'), 'uniqExactMap': ('uniqExact', 'Map'), 'quantilesExactWeightedMap': ('quantilesExactWeighted', 'Map'), 'quantileBFloat16WeightedMap': ('quantileBFloat16Weighted', 'Map'), 'argMinMap': ('argMin', 'Map'), 'stddevPopMap': ('stddevPop', 'Map'), 'exponentialMovingAverageMap': ('exponentialMovingAverage', 'Map'), 'countMap': ('count', 'Map'), 'mannWhitneyUTestMap': ('mannWhitneyUTest', 'Map'), 'quantileExactLowMap': ('quantileExactLow', 'Map'), 'quantilesExactMap': ('quantilesExact', 'Map'), 'groupArrayInsertAtMap': ('groupArrayInsertAt', 'Map'), 'anyLastMap': ('anyLast', 'Map'), 'stddevSampMap': ('stddevSamp', 'Map'), 'cramersVBiasCorrectedSimpleState': ('cramersVBiasCorrected', 'SimpleState'), 'topKSimpleState': ('topK', 'SimpleState'), 'quantileTimingWeightedSimpleState': ('quantileTimingWeighted', 'SimpleState'), 'maxMapSimpleState': ('maxMap', 'SimpleState'), 'groupBitmapXorSimpleState': ('groupBitmapXor', 'SimpleState'), 'studentTTestSimpleState': ('studentTTest', 'SimpleState'), 'covarPopSimpleState': ('covarPop', 'SimpleState'), 'quantilesInterpolatedWeightedSimpleState': ('quantilesInterpolatedWeighted', 'SimpleState'), 'last_valueSimpleState': ('last_value', 'SimpleState'), 'boundingRatioSimpleState': ('boundingRatio', 'SimpleState'), 'quantileExactSimpleState': ('quantileExact', 'SimpleState'), 'quantileSimpleState': ('quantile', 'SimpleState'), 'minSimpleState': ('min', 'SimpleState'), 'topKWeightedSimpleState': ('topKWeighted', 'SimpleState'), 'uniqThetaSimpleState': ('uniqTheta', 'SimpleState'), 'kurtSampSimpleState': ('kurtSamp', 'SimpleState'), 'quantilesTimingWeightedSimpleState': ('quantilesTimingWeighted', 'SimpleState'), 'theilsUSimpleState': ('theilsU', 'SimpleState'), 'largestTriangleThreeBucketsSimpleState': ('largestTriangleThreeBuckets', 'SimpleState'), 'groupBitmapOrSimpleState': ('groupBitmapOr', 'SimpleState'), 'quantilesExactLowSimpleState': ('quantilesExactLow', 'SimpleState'), 'quantilesBFloat16SimpleState': ('quantilesBFloat16', 'SimpleState'), 'welchTTestSimpleState': ('welchTTest', 'SimpleState'), 'sumMapSimpleState': ('sumMap', 'SimpleState'), 'quantileTDigestSimpleState': ('quantileTDigest', 'SimpleState'), 'cramersVSimpleState': ('cramersV', 'SimpleState'), 'entropySimpleState': ('entropy', 'SimpleState'), 'covarSampSimpleState': ('covarSamp', 'SimpleState'), 'maxIntersectionsPositionSimpleState': ('maxIntersectionsPosition', 'SimpleState'), 'simpleLinearRegressionSimpleState': ('simpleLinearRegression', 'SimpleState'), 'argMaxSimpleState': ('argMax', 'SimpleState'), 'stochasticLogisticRegressionSimpleState': ('stochasticLogisticRegression', 'SimpleState'), 'quantileDeterministicSimpleState': ('quantileDeterministic', 'SimpleState'), 'quantilesSimpleState': ('quantiles', 'SimpleState'), 'corrSimpleState': ('corr', 'SimpleState'), 'avgWeightedSimpleState': ('avgWeighted', 'SimpleState'), 'uniqHLL12SimpleState': ('uniqHLL12', 'SimpleState'), 'quantileExactHighSimpleState': ('quantileExactHigh', 'SimpleState'), 'sumWithOverflowSimpleState': ('sumWithOverflow', 'SimpleState'), 'quantileExactWeightedSimpleState': ('quantileExactWeighted', 'SimpleState'), 'uniqSimpleState': ('uniq', 'SimpleState'), 'stochasticLinearRegressionSimpleState': ('stochasticLinearRegression', 'SimpleState'), 'deltaSumSimpleState': ('deltaSum', 'SimpleState'), 'sumSimpleState': ('sum', 'SimpleState'), 'histogramSimpleState': ('histogram', 'SimpleState'), 'quantilesDeterministicSimpleState': ('quantilesDeterministic', 'SimpleState'), 'groupBitOrSimpleState': ('groupBitOr', 'SimpleState'), 'quantileTimingSimpleState': ('quantileTiming', 'SimpleState'), 'sequenceNextNodeSimpleState': ('sequenceNextNode', 'SimpleState'), 'quantileTDigestWeightedSimpleState': ('quantileTDigestWeighted', 'SimpleState'), 'rankCorrSimpleState': ('rankCorr', 'SimpleState'), 'first_valueSimpleState': ('first_value', 'SimpleState'), 'sequenceCountSimpleState': ('sequenceCount', 'SimpleState'), 'varSampSimpleState': ('varSamp', 'SimpleState'), 'uniqUpToSimpleState': ('uniqUpTo', 'SimpleState'), 'contingencySimpleState': ('contingency', 'SimpleState'), 'anyHeavySimpleState': ('anyHeavy', 'SimpleState'), 'groupArrayLastSimpleState': ('groupArrayLast', 'SimpleState'), 'exponentialTimeDecayedAvgSimpleState': ('exponentialTimeDecayedAvg', 'SimpleState'), 'sequenceMatchSimpleState': ('sequenceMatch', 'SimpleState'), 'varPopSimpleState': ('varPop', 'SimpleState'), 'groupArrayMovingAvgSimpleState': ('groupArrayMovingAvg', 'SimpleState'), 'uniqCombinedSimpleState': ('uniqCombined', 'SimpleState'), 'sumCountSimpleState': ('sumCount', 'SimpleState'), 'quantileGKSimpleState': ('quantileGK', 'SimpleState'), 'skewPopSimpleState': ('skewPop', 'SimpleState'), 'groupBitAndSimpleState': ('groupBitAnd', 'SimpleState'), 'maxSimpleState': ('max', 'SimpleState'), 'intervalLengthSumSimpleState': ('intervalLengthSum', 'SimpleState'), 'quantilesExactHighSimpleState': ('quantilesExactHigh', 'SimpleState'), 'quantilesBFloat16WeightedSimpleState': ('quantilesBFloat16Weighted', 'SimpleState'), 'sumKahanSimpleState': ('sumKahan', 'SimpleState'), 'medianSimpleState': ('median', 'SimpleState'), 'quantilesGKSimpleState': ('quantilesGK', 'SimpleState'), 'avgSimpleState': ('avg', 'SimpleState'), 'meanZTestSimpleState': ('meanZTest', 'SimpleState'), 'retentionSimpleState': ('retention', 'SimpleState'), 'windowFunnelSimpleState': ('windowFunnel', 'SimpleState'), 'kurtPopSimpleState': ('kurtPop', 'SimpleState'), 'uniqCombined64SimpleState': ('uniqCombined64', 'SimpleState'), 'groupUniqArraySimpleState': ('groupUniqArray', 'SimpleState'), 'groupArrayMovingSumSimpleState': ('groupArrayMovingSum', 'SimpleState'), 'groupArraySimpleState': ('groupArray', 'SimpleState'), 'groupBitXorSimpleState': ('groupBitXor', 'SimpleState'), 'quantileBFloat16SimpleState': ('quantileBFloat16', 'SimpleState'), 'deltaSumTimestampSimpleState': ('deltaSumTimestamp', 'SimpleState'), 'minMapSimpleState': ('minMap', 'SimpleState'), 'skewSampSimpleState': ('skewSamp', 'SimpleState'), 'quantilesTDigestSimpleState': ('quantilesTDigest', 'SimpleState'), 'anySimpleState': ('any', 'SimpleState'), 'maxIntersectionsSimpleState': ('maxIntersections', 'SimpleState'), 'sparkBarSimpleState': ('sparkBar', 'SimpleState'), 'kolmogorovSmirnovTestSimpleState': ('kolmogorovSmirnovTest', 'SimpleState'), 'groupArraySampleSimpleState': ('groupArraySample', 'SimpleState'), 'groupBitmapSimpleState': ('groupBitmap', 'SimpleState'), 'categoricalInformationValueSimpleState': ('categoricalInformationValue', 'SimpleState'), 'quantileInterpolatedWeightedSimpleState': ('quantileInterpolatedWeighted', 'SimpleState'), 'quantilesTimingSimpleState': ('quantilesTiming', 'SimpleState'), 'quantilesTDigestWeightedSimpleState': ('quantilesTDigestWeighted', 'SimpleState'), 'groupBitmapAndSimpleState': ('groupBitmapAnd', 'SimpleState'), 'uniqExactSimpleState': ('uniqExact', 'SimpleState'), 'quantilesExactWeightedSimpleState': ('quantilesExactWeighted', 'SimpleState'), 'quantileBFloat16WeightedSimpleState': ('quantileBFloat16Weighted', 'SimpleState'), 'argMinSimpleState': ('argMin', 'SimpleState'), 'stddevPopSimpleState': ('stddevPop', 'SimpleState'), 'exponentialMovingAverageSimpleState': ('exponentialMovingAverage', 'SimpleState'), 'countSimpleState': ('count', 'SimpleState'), 'mannWhitneyUTestSimpleState': ('mannWhitneyUTest', 'SimpleState'), 'quantileExactLowSimpleState': ('quantileExactLow', 'SimpleState'), 'quantilesExactSimpleState': ('quantilesExact', 'SimpleState'), 'groupArrayInsertAtSimpleState': ('groupArrayInsertAt', 'SimpleState'), 'anyLastSimpleState': ('anyLast', 'SimpleState'), 'stddevSampSimpleState': ('stddevSamp', 'SimpleState'), 'cramersVBiasCorrectedState': ('cramersVBiasCorrected', 'State'), 'topKState': ('topK', 'State'), 'quantileTimingWeightedState': ('quantileTimingWeighted', 'State'), 'maxMapState': ('maxMap', 'State'), 'groupBitmapXorState': ('groupBitmapXor', 'State'), 'studentTTestState': ('studentTTest', 'State'), 'covarPopState': ('covarPop', 'State'), 'quantilesInterpolatedWeightedState': ('quantilesInterpolatedWeighted', 'State'), 'last_valueState': ('last_value', 'State'), 'boundingRatioState': ('boundingRatio', 'State'), 'quantileExactState': ('quantileExact', 'State'), 'quantileState': ('quantile', 'State'), 'minState': ('min', 'State'), 'topKWeightedState': ('topKWeighted', 'State'), 'uniqThetaState': ('uniqTheta', 'State'), 'kurtSampState': ('kurtSamp', 'State'), 'quantilesTimingWeightedState': ('quantilesTimingWeighted', 'State'), 'theilsUState': ('theilsU', 'State'), 'largestTriangleThreeBucketsState': ('largestTriangleThreeBuckets', 'State'), 'groupBitmapOrState': ('groupBitmapOr', 'State'), 'quantilesExactLowState': ('quantilesExactLow', 'State'), 'quantilesBFloat16State': ('quantilesBFloat16', 'State'), 'welchTTestState': ('welchTTest', 'State'), 'sumMapState': ('sumMap', 'State'), 'quantileTDigestState': ('quantileTDigest', 'State'), 'cramersVState': ('cramersV', 'State'), 'entropyState': ('entropy', 'State'), 'covarSampState': ('covarSamp', 'State'), 'maxIntersectionsPositionState': ('maxIntersectionsPosition', 'State'), 'simpleLinearRegressionState': ('simpleLinearRegression', 'State'), 'argMaxState': ('argMax', 'State'), 'stochasticLogisticRegressionState': ('stochasticLogisticRegression', 'State'), 'quantileDeterministicState': ('quantileDeterministic', 'State'), 'quantilesState': ('quantiles', 'State'), 'corrState': ('corr', 'State'), 'avgWeightedState': ('avgWeighted', 'State'), 'uniqHLL12State': ('uniqHLL12', 'State'), 'quantileExactHighState': ('quantileExactHigh', 'State'), 'sumWithOverflowState': ('sumWithOverflow', 'State'), 'quantileExactWeightedState': ('quantileExactWeighted', 'State'), 'uniqState': ('uniq', 'State'), 'stochasticLinearRegressionState': ('stochasticLinearRegression', 'State'), 'deltaSumState': ('deltaSum', 'State'), 'sumState': ('sum', 'State'), 'histogramState': ('histogram', 'State'), 'quantilesDeterministicState': ('quantilesDeterministic', 'State'), 'groupBitOrState': ('groupBitOr', 'State'), 'quantileTimingState': ('quantileTiming', 'State'), 'sequenceNextNodeState': ('sequenceNextNode', 'State'), 'quantileTDigestWeightedState': ('quantileTDigestWeighted', 'State'), 'rankCorrState': ('rankCorr', 'State'), 'first_valueState': ('first_value', 'State'), 'sequenceCountState': ('sequenceCount', 'State'), 'varSampState': ('varSamp', 'State'), 'uniqUpToState': ('uniqUpTo', 'State'), 'contingencyState': ('contingency', 'State'), 'anyHeavyState': ('anyHeavy', 'State'), 'groupArrayLastState': ('groupArrayLast', 'State'), 'exponentialTimeDecayedAvgState': ('exponentialTimeDecayedAvg', 'State'), 'sequenceMatchState': ('sequenceMatch', 'State'), 'varPopState': ('varPop', 'State'), 'groupArrayMovingAvgState': ('groupArrayMovingAvg', 'State'), 'uniqCombinedState': ('uniqCombined', 'State'), 'sumCountState': ('sumCount', 'State'), 'quantileGKState': ('quantileGK', 'State'), 'skewPopState': ('skewPop', 'State'), 'groupBitAndState': ('groupBitAnd', 'State'), 'maxState': ('max', 'State'), 'intervalLengthSumState': ('intervalLengthSum', 'State'), 'quantilesExactHighState': ('quantilesExactHigh', 'State'), 'quantilesBFloat16WeightedState': ('quantilesBFloat16Weighted', 'State'), 'sumKahanState': ('sumKahan', 'State'), 'medianState': ('median', 'State'), 'quantilesGKState': ('quantilesGK', 'State'), 'avgState': ('avg', 'State'), 'meanZTestState': ('meanZTest', 'State'), 'retentionState': ('retention', 'State'), 'windowFunnelState': ('windowFunnel', 'State'), 'kurtPopState': ('kurtPop', 'State'), 'uniqCombined64State': ('uniqCombined64', 'State'), 'groupUniqArrayState': ('groupUniqArray', 'State'), 'groupArrayMovingSumState': ('groupArrayMovingSum', 'State'), 'groupArrayState': ('groupArray', 'State'), 'groupBitXorState': ('groupBitXor', 'State'), 'quantileBFloat16State': ('quantileBFloat16', 'State'), 'deltaSumTimestampState': ('deltaSumTimestamp', 'State'), 'minMapState': ('minMap', 'State'), 'skewSampState': ('skewSamp', 'State'), 'quantilesTDigestState': ('quantilesTDigest', 'State'), 'anyState': ('any', 'State'), 'maxIntersectionsState': ('maxIntersections', 'State'), 'sparkBarState': ('sparkBar', 'State'), 'kolmogorovSmirnovTestState': ('kolmogorovSmirnovTest', 'State'), 'groupArraySampleState': ('groupArraySample', 'State'), 'groupBitmapState': ('groupBitmap', 'State'), 'categoricalInformationValueState': ('categoricalInformationValue', 'State'), 'quantileInterpolatedWeightedState': ('quantileInterpolatedWeighted', 'State'), 'quantilesTimingState': ('quantilesTiming', 'State'), 'quantilesTDigestWeightedState': ('quantilesTDigestWeighted', 'State'), 'groupBitmapAndState': ('groupBitmapAnd', 'State'), 'uniqExactState': ('uniqExact', 'State'), 'quantilesExactWeightedState': ('quantilesExactWeighted', 'State'), 'quantileBFloat16WeightedState': ('quantileBFloat16Weighted', 'State'), 'argMinState': ('argMin', 'State'), 'stddevPopState': ('stddevPop', 'State'), 'exponentialMovingAverageState': ('exponentialMovingAverage', 'State'), 'countState': ('count', 'State'), 'mannWhitneyUTestState': ('mannWhitneyUTest', 'State'), 'quantileExactLowState': ('quantileExactLow', 'State'), 'quantilesExactState': ('quantilesExact', 'State'), 'groupArrayInsertAtState': ('groupArrayInsertAt', 'State'), 'anyLastState': ('anyLast', 'State'), 'stddevSampState': ('stddevSamp', 'State'), 'cramersVBiasCorrectedMerge': ('cramersVBiasCorrected', 'Merge'), 'topKMerge': ('topK', 'Merge'), 'quantileTimingWeightedMerge': ('quantileTimingWeighted', 'Merge'), 'maxMapMerge': ('maxMap', 'Merge'), 'groupBitmapXorMerge': ('groupBitmapXor', 'Merge'), 'studentTTestMerge': ('studentTTest', 'Merge'), 'covarPopMerge': ('covarPop', 'Merge'), 'quantilesInterpolatedWeightedMerge': ('quantilesInterpolatedWeighted', 'Merge'), 'last_valueMerge': ('last_value', 'Merge'), 'boundingRatioMerge': ('boundingRatio', 'Merge'), 'quantileExactMerge': ('quantileExact', 'Merge'), 'quantileMerge': ('quantile', 'Merge'), 'minMerge': ('min', 'Merge'), 'topKWeightedMerge': ('topKWeighted', 'Merge'), 'uniqThetaMerge': ('uniqTheta', 'Merge'), 'kurtSampMerge': ('kurtSamp', 'Merge'), 'quantilesTimingWeightedMerge': ('quantilesTimingWeighted', 'Merge'), 'theilsUMerge': ('theilsU', 'Merge'), 'largestTriangleThreeBucketsMerge': ('largestTriangleThreeBuckets', 'Merge'), 'groupBitmapOrMerge': ('groupBitmapOr', 'Merge'), 'quantilesExactLowMerge': ('quantilesExactLow', 'Merge'), 'quantilesBFloat16Merge': ('quantilesBFloat16', 'Merge'), 'welchTTestMerge': ('welchTTest', 'Merge'), 'sumMapMerge': ('sumMap', 'Merge'), 'quantileTDigestMerge': ('quantileTDigest', 'Merge'), 'cramersVMerge': ('cramersV', 'Merge'), 'entropyMerge': ('entropy', 'Merge'), 'covarSampMerge': ('covarSamp', 'Merge'), 'maxIntersectionsPositionMerge': ('maxIntersectionsPosition', 'Merge'), 'simpleLinearRegressionMerge': ('simpleLinearRegression', 'Merge'), 'argMaxMerge': ('argMax', 'Merge'), 'stochasticLogisticRegressionMerge': ('stochasticLogisticRegression', 'Merge'), 'quantileDeterministicMerge': ('quantileDeterministic', 'Merge'), 'quantilesMerge': ('quantiles', 'Merge'), 'corrMerge': ('corr', 'Merge'), 'avgWeightedMerge': ('avgWeighted', 'Merge'), 'uniqHLL12Merge': ('uniqHLL12', 'Merge'), 'quantileExactHighMerge': ('quantileExactHigh', 'Merge'), 'sumWithOverflowMerge': ('sumWithOverflow', 'Merge'), 'quantileExactWeightedMerge': ('quantileExactWeighted', 'Merge'), 'uniqMerge': ('uniq', 'Merge'), 'stochasticLinearRegressionMerge': ('stochasticLinearRegression', 'Merge'), 'deltaSumMerge': ('deltaSum', 'Merge'), 'sumMerge': ('sum', 'Merge'), 'histogramMerge': ('histogram', 'Merge'), 'quantilesDeterministicMerge': ('quantilesDeterministic', 'Merge'), 'groupBitOrMerge': ('groupBitOr', 'Merge'), 'quantileTimingMerge': ('quantileTiming', 'Merge'), 'sequenceNextNodeMerge': ('sequenceNextNode', 'Merge'), 'quantileTDigestWeightedMerge': ('quantileTDigestWeighted', 'Merge'), 'rankCorrMerge': ('rankCorr', 'Merge'), 'first_valueMerge': ('first_value', 'Merge'), 'sequenceCountMerge': ('sequenceCount', 'Merge'), 'varSampMerge': ('varSamp', 'Merge'), 'uniqUpToMerge': ('uniqUpTo', 'Merge'), 'contingencyMerge': ('contingency', 'Merge'), 'anyHeavyMerge': ('anyHeavy', 'Merge'), 'groupArrayLastMerge': ('groupArrayLast', 'Merge'), 'exponentialTimeDecayedAvgMerge': ('exponentialTimeDecayedAvg', 'Merge'), 'sequenceMatchMerge': ('sequenceMatch', 'Merge'), 'varPopMerge': ('varPop', 'Merge'), 'groupArrayMovingAvgMerge': ('groupArrayMovingAvg', 'Merge'), 'uniqCombinedMerge': ('uniqCombined', 'Merge'), 'sumCountMerge': ('sumCount', 'Merge'), 'quantileGKMerge': ('quantileGK', 'Merge'), 'skewPopMerge': ('skewPop', 'Merge'), 'groupBitAndMerge': ('groupBitAnd', 'Merge'), 'maxMerge': ('max', 'Merge'), 'intervalLengthSumMerge': ('intervalLengthSum', 'Merge'), 'quantilesExactHighMerge': ('quantilesExactHigh', 'Merge'), 'quantilesBFloat16WeightedMerge': ('quantilesBFloat16Weighted', 'Merge'), 'sumKahanMerge': ('sumKahan', 'Merge'), 'medianMerge': ('median', 'Merge'), 'quantilesGKMerge': ('quantilesGK', 'Merge'), 'avgMerge': ('avg', 'Merge'), 'meanZTestMerge': ('meanZTest', 'Merge'), 'retentionMerge': ('retention', 'Merge'), 'windowFunnelMerge': ('windowFunnel', 'Merge'), 'kurtPopMerge': ('kurtPop', 'Merge'), 'uniqCombined64Merge': ('uniqCombined64', 'Merge'), 'groupUniqArrayMerge': ('groupUniqArray', 'Merge'), 'groupArrayMovingSumMerge': ('groupArrayMovingSum', 'Merge'), 'groupArrayMerge': ('groupArray', 'Merge'), 'groupBitXorMerge': ('groupBitXor', 'Merge'), 'quantileBFloat16Merge': ('quantileBFloat16', 'Merge'), 'deltaSumTimestampMerge': ('deltaSumTimestamp', 'Merge'), 'minMapMerge': ('minMap', 'Merge'), 'skewSampMerge': ('skewSamp', 'Merge'), 'quantilesTDigestMerge': ('quantilesTDigest', 'Merge'), 'anyMerge': ('any', 'Merge'), 'maxIntersectionsMerge': ('maxIntersections', 'Merge'), 'sparkBarMerge': ('sparkBar', 'Merge'), 'kolmogorovSmirnovTestMerge': ('kolmogorovSmirnovTest', 'Merge'), 'groupArraySampleMerge': ('groupArraySample', 'Merge'), 'groupBitmapMerge': ('groupBitmap', 'Merge'), 'categoricalInformationValueMerge': ('categoricalInformationValue', 'Merge'), 'quantileInterpolatedWeightedMerge': ('quantileInterpolatedWeighted', 'Merge'), 'quantilesTimingMerge': ('quantilesTiming', 'Merge'), 'quantilesTDigestWeightedMerge': ('quantilesTDigestWeighted', 'Merge'), 'groupBitmapAndMerge': ('groupBitmapAnd', 'Merge'), 'uniqExactMerge': ('uniqExact', 'Merge'), 'quantilesExactWeightedMerge': ('quantilesExactWeighted', 'Merge'), 'quantileBFloat16WeightedMerge': ('quantileBFloat16Weighted', 'Merge'), 'argMinMerge': ('argMin', 'Merge'), 'stddevPopMerge': ('stddevPop', 'Merge'), 'exponentialMovingAverageMerge': ('exponentialMovingAverage', 'Merge'), 'countMerge': ('count', 'Merge'), 'mannWhitneyUTestMerge': ('mannWhitneyUTest', 'Merge'), 'quantileExactLowMerge': ('quantileExactLow', 'Merge'), 'quantilesExactMerge': ('quantilesExact', 'Merge'), 'groupArrayInsertAtMerge': ('groupArrayInsertAt', 'Merge'), 'anyLastMerge': ('anyLast', 'Merge'), 'stddevSampMerge': ('stddevSamp', 'Merge'), 'cramersVBiasCorrectedMergeState': ('cramersVBiasCorrected', 'MergeState'), 'topKMergeState': ('topK', 'MergeState'), 'quantileTimingWeightedMergeState': ('quantileTimingWeighted', 'MergeState'), 'maxMapMergeState': ('maxMap', 'MergeState'), 'groupBitmapXorMergeState': ('groupBitmapXor', 'MergeState'), 'studentTTestMergeState': ('studentTTest', 'MergeState'), 'covarPopMergeState': ('covarPop', 'MergeState'), 'quantilesInterpolatedWeightedMergeState': ('quantilesInterpolatedWeighted', 'MergeState'), 'last_valueMergeState': ('last_value', 'MergeState'), 'boundingRatioMergeState': ('boundingRatio', 'MergeState'), 'quantileExactMergeState': ('quantileExact', 'MergeState'), 'quantileMergeState': ('quantile', 'MergeState'), 'minMergeState': ('min', 'MergeState'), 'topKWeightedMergeState': ('topKWeighted', 'MergeState'), 'uniqThetaMergeState': ('uniqTheta', 'MergeState'), 'kurtSampMergeState': ('kurtSamp', 'MergeState'), 'quantilesTimingWeightedMergeState': ('quantilesTimingWeighted', 'MergeState'), 'theilsUMergeState': ('theilsU', 'MergeState'), 'largestTriangleThreeBucketsMergeState': ('largestTriangleThreeBuckets', 'MergeState'), 'groupBitmapOrMergeState': ('groupBitmapOr', 'MergeState'), 'quantilesExactLowMergeState': ('quantilesExactLow', 'MergeState'), 'quantilesBFloat16MergeState': ('quantilesBFloat16', 'MergeState'), 'welchTTestMergeState': ('welchTTest', 'MergeState'), 'sumMapMergeState': ('sumMap', 'MergeState'), 'quantileTDigestMergeState': ('quantileTDigest', 'MergeState'), 'cramersVMergeState': ('cramersV', 'MergeState'), 'entropyMergeState': ('entropy', 'MergeState'), 'covarSampMergeState': ('covarSamp', 'MergeState'), 'maxIntersectionsPositionMergeState': ('maxIntersectionsPosition', 'MergeState'), 'simpleLinearRegressionMergeState': ('simpleLinearRegression', 'MergeState'), 'argMaxMergeState': ('argMax', 'MergeState'), 'stochasticLogisticRegressionMergeState': ('stochasticLogisticRegression', 'MergeState'), 'quantileDeterministicMergeState': ('quantileDeterministic', 'MergeState'), 'quantilesMergeState': ('quantiles', 'MergeState'), 'corrMergeState': ('corr', 'MergeState'), 'avgWeightedMergeState': ('avgWeighted', 'MergeState'), 'uniqHLL12MergeState': ('uniqHLL12', 'MergeState'), 'quantileExactHighMergeState': ('quantileExactHigh', 'MergeState'), 'sumWithOverflowMergeState': ('sumWithOverflow', 'MergeState'), 'quantileExactWeightedMergeState': ('quantileExactWeighted', 'MergeState'), 'uniqMergeState': ('uniq', 'MergeState'), 'stochasticLinearRegressionMergeState': ('stochasticLinearRegression', 'MergeState'), 'deltaSumMergeState': ('deltaSum', 'MergeState'), 'sumMergeState': ('sum', 'MergeState'), 'histogramMergeState': ('histogram', 'MergeState'), 'quantilesDeterministicMergeState': ('quantilesDeterministic', 'MergeState'), 'groupBitOrMergeState': ('groupBitOr', 'MergeState'), 'quantileTimingMergeState': ('quantileTiming', 'MergeState'), 'sequenceNextNodeMergeState': ('sequenceNextNode', 'MergeState'), 'quantileTDigestWeightedMergeState': ('quantileTDigestWeighted', 'MergeState'), 'rankCorrMergeState': ('rankCorr', 'MergeState'), 'first_valueMergeState': ('first_value', 'MergeState'), 'sequenceCountMergeState': ('sequenceCount', 'MergeState'), 'varSampMergeState': ('varSamp', 'MergeState'), 'uniqUpToMergeState': ('uniqUpTo', 'MergeState'), 'contingencyMergeState': ('contingency', 'MergeState'), 'anyHeavyMergeState': ('anyHeavy', 'MergeState'), 'groupArrayLastMergeState': ('groupArrayLast', 'MergeState'), 'exponentialTimeDecayedAvgMergeState': ('exponentialTimeDecayedAvg', 'MergeState'), 'sequenceMatchMergeState': ('sequenceMatch', 'MergeState'), 'varPopMergeState': ('varPop', 'MergeState'), 'groupArrayMovingAvgMergeState': ('groupArrayMovingAvg', 'MergeState'), 'uniqCombinedMergeState': ('uniqCombined', 'MergeState'), 'sumCountMergeState': ('sumCount', 'MergeState'), 'quantileGKMergeState': ('quantileGK', 'MergeState'), 'skewPopMergeState': ('skewPop', 'MergeState'), 'groupBitAndMergeState': ('groupBitAnd', 'MergeState'), 'maxMergeState': ('max', 'MergeState'), 'intervalLengthSumMergeState': ('intervalLengthSum', 'MergeState'), 'quantilesExactHighMergeState': ('quantilesExactHigh', 'MergeState'), 'quantilesBFloat16WeightedMergeState': ('quantilesBFloat16Weighted', 'MergeState'), 'sumKahanMergeState': ('sumKahan', 'MergeState'), 'medianMergeState': ('median', 'MergeState'), 'quantilesGKMergeState': ('quantilesGK', 'MergeState'), 'avgMergeState': ('avg', 'MergeState'), 'meanZTestMergeState': ('meanZTest', 'MergeState'), 'retentionMergeState': ('retention', 'MergeState'), 'windowFunnelMergeState': ('windowFunnel', 'MergeState'), 'kurtPopMergeState': ('kurtPop', 'MergeState'), 'uniqCombined64MergeState': ('uniqCombined64', 'MergeState'), 'groupUniqArrayMergeState': ('groupUniqArray', 'MergeState'), 'groupArrayMovingSumMergeState': ('groupArrayMovingSum', 'MergeState'), 'groupArrayMergeState': ('groupArray', 'MergeState'), 'groupBitXorMergeState': ('groupBitXor', 'MergeState'), 'quantileBFloat16MergeState': ('quantileBFloat16', 'MergeState'), 'deltaSumTimestampMergeState': ('deltaSumTimestamp', 'MergeState'), 'minMapMergeState': ('minMap', 'MergeState'), 'skewSampMergeState': ('skewSamp', 'MergeState'), 'quantilesTDigestMergeState': ('quantilesTDigest', 'MergeState'), 'anyMergeState': ('any', 'MergeState'), 'maxIntersectionsMergeState': ('maxIntersections', 'MergeState'), 'sparkBarMergeState': ('sparkBar', 'MergeState'), 'kolmogorovSmirnovTestMergeState': ('kolmogorovSmirnovTest', 'MergeState'), 'groupArraySampleMergeState': ('groupArraySample', 'MergeState'), 'groupBitmapMergeState': ('groupBitmap', 'MergeState'), 'categoricalInformationValueMergeState': ('categoricalInformationValue', 'MergeState'), 'quantileInterpolatedWeightedMergeState': ('quantileInterpolatedWeighted', 'MergeState'), 'quantilesTimingMergeState': ('quantilesTiming', 'MergeState'), 'quantilesTDigestWeightedMergeState': ('quantilesTDigestWeighted', 'MergeState'), 'groupBitmapAndMergeState': ('groupBitmapAnd', 'MergeState'), 'uniqExactMergeState': ('uniqExact', 'MergeState'), 'quantilesExactWeightedMergeState': ('quantilesExactWeighted', 'MergeState'), 'quantileBFloat16WeightedMergeState': ('quantileBFloat16Weighted', 'MergeState'), 'argMinMergeState': ('argMin', 'MergeState'), 'stddevPopMergeState': ('stddevPop', 'MergeState'), 'exponentialMovingAverageMergeState': ('exponentialMovingAverage', 'MergeState'), 'countMergeState': ('count', 'MergeState'), 'mannWhitneyUTestMergeState': ('mannWhitneyUTest', 'MergeState'), 'quantileExactLowMergeState': ('quantileExactLow', 'MergeState'), 'quantilesExactMergeState': ('quantilesExact', 'MergeState'), 'groupArrayInsertAtMergeState': ('groupArrayInsertAt', 'MergeState'), 'anyLastMergeState': ('anyLast', 'MergeState'), 'stddevSampMergeState': ('stddevSamp', 'MergeState'), 'cramersVBiasCorrectedForEach': ('cramersVBiasCorrected', 'ForEach'), 'topKForEach': ('topK', 'ForEach'), 'quantileTimingWeightedForEach': ('quantileTimingWeighted', 'ForEach'), 'maxMapForEach': ('maxMap', 'ForEach'), 'groupBitmapXorForEach': ('groupBitmapXor', 'ForEach'), 'studentTTestForEach': ('studentTTest', 'ForEach'), 'covarPopForEach': ('covarPop', 'ForEach'), 'quantilesInterpolatedWeightedForEach': ('quantilesInterpolatedWeighted', 'ForEach'), 'last_valueForEach': ('last_value', 'ForEach'), 'boundingRatioForEach': ('boundingRatio', 'ForEach'), 'quantileExactForEach': ('quantileExact', 'ForEach'), 'quantileForEach': ('quantile', 'ForEach'), 'minForEach': ('min', 'ForEach'), 'topKWeightedForEach': ('topKWeighted', 'ForEach'), 'uniqThetaForEach': ('uniqTheta', 'ForEach'), 'kurtSampForEach': ('kurtSamp', 'ForEach'), 'quantilesTimingWeightedForEach': ('quantilesTimingWeighted', 'ForEach'), 'theilsUForEach': ('theilsU', 'ForEach'), 'largestTriangleThreeBucketsForEach': ('largestTriangleThreeBuckets', 'ForEach'), 'groupBitmapOrForEach': ('groupBitmapOr', 'ForEach'), 'quantilesExactLowForEach': ('quantilesExactLow', 'ForEach'), 'quantilesBFloat16ForEach': ('quantilesBFloat16', 'ForEach'), 'welchTTestForEach': ('welchTTest', 'ForEach'), 'sumMapForEach': ('sumMap', 'ForEach'), 'quantileTDigestForEach': ('quantileTDigest', 'ForEach'), 'cramersVForEach': ('cramersV', 'ForEach'), 'entropyForEach': ('entropy', 'ForEach'), 'covarSampForEach': ('covarSamp', 'ForEach'), 'maxIntersectionsPositionForEach': ('maxIntersectionsPosition', 'ForEach'), 'simpleLinearRegressionForEach': ('simpleLinearRegression', 'ForEach'), 'argMaxForEach': ('argMax', 'ForEach'), 'stochasticLogisticRegressionForEach': ('stochasticLogisticRegression', 'ForEach'), 'quantileDeterministicForEach': ('quantileDeterministic', 'ForEach'), 'quantilesForEach': ('quantiles', 'ForEach'), 'corrForEach': ('corr', 'ForEach'), 'avgWeightedForEach': ('avgWeighted', 'ForEach'), 'uniqHLL12ForEach': ('uniqHLL12', 'ForEach'), 'quantileExactHighForEach': ('quantileExactHigh', 'ForEach'), 'sumWithOverflowForEach': ('sumWithOverflow', 'ForEach'), 'quantileExactWeightedForEach': ('quantileExactWeighted', 'ForEach'), 'uniqForEach': ('uniq', 'ForEach'), 'stochasticLinearRegressionForEach': ('stochasticLinearRegression', 'ForEach'), 'deltaSumForEach': ('deltaSum', 'ForEach'), 'sumForEach': ('sum', 'ForEach'), 'histogramForEach': ('histogram', 'ForEach'), 'quantilesDeterministicForEach': ('quantilesDeterministic', 'ForEach'), 'groupBitOrForEach': ('groupBitOr', 'ForEach'), 'quantileTimingForEach': ('quantileTiming', 'ForEach'), 'sequenceNextNodeForEach': ('sequenceNextNode', 'ForEach'), 'quantileTDigestWeightedForEach': ('quantileTDigestWeighted', 'ForEach'), 'rankCorrForEach': ('rankCorr', 'ForEach'), 'first_valueForEach': ('first_value', 'ForEach'), 'sequenceCountForEach': ('sequenceCount', 'ForEach'), 'varSampForEach': ('varSamp', 'ForEach'), 'uniqUpToForEach': ('uniqUpTo', 'ForEach'), 'contingencyForEach': ('contingency', 'ForEach'), 'anyHeavyForEach': ('anyHeavy', 'ForEach'), 'groupArrayLastForEach': ('groupArrayLast', 'ForEach'), 'exponentialTimeDecayedAvgForEach': ('exponentialTimeDecayedAvg', 'ForEach'), 'sequenceMatchForEach': ('sequenceMatch', 'ForEach'), 'varPopForEach': ('varPop', 'ForEach'), 'groupArrayMovingAvgForEach': ('groupArrayMovingAvg', 'ForEach'), 'uniqCombinedForEach': ('uniqCombined', 'ForEach'), 'sumCountForEach': ('sumCount', 'ForEach'), 'quantileGKForEach': ('quantileGK', 'ForEach'), 'skewPopForEach': ('skewPop', 'ForEach'), 'groupBitAndForEach': ('groupBitAnd', 'ForEach'), 'maxForEach': ('max', 'ForEach'), 'intervalLengthSumForEach': ('intervalLengthSum', 'ForEach'), 'quantilesExactHighForEach': ('quantilesExactHigh', 'ForEach'), 'quantilesBFloat16WeightedForEach': ('quantilesBFloat16Weighted', 'ForEach'), 'sumKahanForEach': ('sumKahan', 'ForEach'), 'medianForEach': ('median', 'ForEach'), 'quantilesGKForEach': ('quantilesGK', 'ForEach'), 'avgForEach': ('avg', 'ForEach'), 'meanZTestForEach': ('meanZTest', 'ForEach'), 'retentionForEach': ('retention', 'ForEach'), 'windowFunnelForEach': ('windowFunnel', 'ForEach'), 'kurtPopForEach': ('kurtPop', 'ForEach'), 'uniqCombined64ForEach': ('uniqCombined64', 'ForEach'), 'groupUniqArrayForEach': ('groupUniqArray', 'ForEach'), 'groupArrayMovingSumForEach': ('groupArrayMovingSum', 'ForEach'), 'groupArrayForEach': ('groupArray', 'ForEach'), 'groupBitXorForEach': ('groupBitXor', 'ForEach'), 'quantileBFloat16ForEach': ('quantileBFloat16', 'ForEach'), 'deltaSumTimestampForEach': ('deltaSumTimestamp', 'ForEach'), 'minMapForEach': ('minMap', 'ForEach'), 'skewSampForEach': ('skewSamp', 'ForEach'), 'quantilesTDigestForEach': ('quantilesTDigest', 'ForEach'), 'anyForEach': ('any', 'ForEach'), 'maxIntersectionsForEach': ('maxIntersections', 'ForEach'), 'sparkBarForEach': ('sparkBar', 'ForEach'), 'kolmogorovSmirnovTestForEach': ('kolmogorovSmirnovTest', 'ForEach'), 'groupArraySampleForEach': ('groupArraySample', 'ForEach'), 'groupBitmapForEach': ('groupBitmap', 'ForEach'), 'categoricalInformationValueForEach': ('categoricalInformationValue', 'ForEach'), 'quantileInterpolatedWeightedForEach': ('quantileInterpolatedWeighted', 'ForEach'), 'quantilesTimingForEach': ('quantilesTiming', 'ForEach'), 'quantilesTDigestWeightedForEach': ('quantilesTDigestWeighted', 'ForEach'), 'groupBitmapAndForEach': ('groupBitmapAnd', 'ForEach'), 'uniqExactForEach': ('uniqExact', 'ForEach'), 'quantilesExactWeightedForEach': ('quantilesExactWeighted', 'ForEach'), 'quantileBFloat16WeightedForEach': ('quantileBFloat16Weighted', 'ForEach'), 'argMinForEach': ('argMin', 'ForEach'), 'stddevPopForEach': ('stddevPop', 'ForEach'), 'exponentialMovingAverageForEach': ('exponentialMovingAverage', 'ForEach'), 'countForEach': ('count', 'ForEach'), 'mannWhitneyUTestForEach': ('mannWhitneyUTest', 'ForEach'), 'quantileExactLowForEach': ('quantileExactLow', 'ForEach'), 'quantilesExactForEach': ('quantilesExact', 'ForEach'), 'groupArrayInsertAtForEach': ('groupArrayInsertAt', 'ForEach'), 'anyLastForEach': ('anyLast', 'ForEach'), 'stddevSampForEach': ('stddevSamp', 'ForEach'), 'cramersVBiasCorrectedDistinct': ('cramersVBiasCorrected', 'Distinct'), 'topKDistinct': ('topK', 'Distinct'), 'quantileTimingWeightedDistinct': ('quantileTimingWeighted', 'Distinct'), 'maxMapDistinct': ('maxMap', 'Distinct'), 'groupBitmapXorDistinct': ('groupBitmapXor', 'Distinct'), 'studentTTestDistinct': ('studentTTest', 'Distinct'), 'covarPopDistinct': ('covarPop', 'Distinct'), 'quantilesInterpolatedWeightedDistinct': ('quantilesInterpolatedWeighted', 'Distinct'), 'last_valueDistinct': ('last_value', 'Distinct'), 'boundingRatioDistinct': ('boundingRatio', 'Distinct'), 'quantileExactDistinct': ('quantileExact', 'Distinct'), 'quantileDistinct': ('quantile', 'Distinct'), 'minDistinct': ('min', 'Distinct'), 'topKWeightedDistinct': ('topKWeighted', 'Distinct'), 'uniqThetaDistinct': ('uniqTheta', 'Distinct'), 'kurtSampDistinct': ('kurtSamp', 'Distinct'), 'quantilesTimingWeightedDistinct': ('quantilesTimingWeighted', 'Distinct'), 'theilsUDistinct': ('theilsU', 'Distinct'), 'largestTriangleThreeBucketsDistinct': ('largestTriangleThreeBuckets', 'Distinct'), 'groupBitmapOrDistinct': ('groupBitmapOr', 'Distinct'), 'quantilesExactLowDistinct': ('quantilesExactLow', 'Distinct'), 'quantilesBFloat16Distinct': ('quantilesBFloat16', 'Distinct'), 'welchTTestDistinct': ('welchTTest', 'Distinct'), 'sumMapDistinct': ('sumMap', 'Distinct'), 'quantileTDigestDistinct': ('quantileTDigest', 'Distinct'), 'cramersVDistinct': ('cramersV', 'Distinct'), 'entropyDistinct': ('entropy', 'Distinct'), 'covarSampDistinct': ('covarSamp', 'Distinct'), 'maxIntersectionsPositionDistinct': ('maxIntersectionsPosition', 'Distinct'), 'simpleLinearRegressionDistinct': ('simpleLinearRegression', 'Distinct'), 'argMaxDistinct': ('argMax', 'Distinct'), 'stochasticLogisticRegressionDistinct': ('stochasticLogisticRegression', 'Distinct'), 'quantileDeterministicDistinct': ('quantileDeterministic', 'Distinct'), 'quantilesDistinct': ('quantiles', 'Distinct'), 'corrDistinct': ('corr', 'Distinct'), 'avgWeightedDistinct': ('avgWeighted', 'Distinct'), 'uniqHLL12Distinct': ('uniqHLL12', 'Distinct'), 'quantileExactHighDistinct': ('quantileExactHigh', 'Distinct'), 'sumWithOverflowDistinct': ('sumWithOverflow', 'Distinct'), 'quantileExactWeightedDistinct': ('quantileExactWeighted', 'Distinct'), 'uniqDistinct': ('uniq', 'Distinct'), 'stochasticLinearRegressionDistinct': ('stochasticLinearRegression', 'Distinct'), 'deltaSumDistinct': ('deltaSum', 'Distinct'), 'sumDistinct': ('sum', 'Distinct'), 'histogramDistinct': ('histogram', 'Distinct'), 'quantilesDeterministicDistinct': ('quantilesDeterministic', 'Distinct'), 'groupBitOrDistinct': ('groupBitOr', 'Distinct'), 'quantileTimingDistinct': ('quantileTiming', 'Distinct'), 'sequenceNextNodeDistinct': ('sequenceNextNode', 'Distinct'), 'quantileTDigestWeightedDistinct': ('quantileTDigestWeighted', 'Distinct'), 'rankCorrDistinct': ('rankCorr', 'Distinct'), 'first_valueDistinct': ('first_value', 'Distinct'), 'sequenceCountDistinct': ('sequenceCount', 'Distinct'), 'varSampDistinct': ('varSamp', 'Distinct'), 'uniqUpToDistinct': ('uniqUpTo', 'Distinct'), 'contingencyDistinct': ('contingency', 'Distinct'), 'anyHeavyDistinct': ('anyHeavy', 'Distinct'), 'groupArrayLastDistinct': ('groupArrayLast', 'Distinct'), 'exponentialTimeDecayedAvgDistinct': ('exponentialTimeDecayedAvg', 'Distinct'), 'sequenceMatchDistinct': ('sequenceMatch', 'Distinct'), 'varPopDistinct': ('varPop', 'Distinct'), 'groupArrayMovingAvgDistinct': ('groupArrayMovingAvg', 'Distinct'), 'uniqCombinedDistinct': ('uniqCombined', 'Distinct'), 'sumCountDistinct': ('sumCount', 'Distinct'), 'quantileGKDistinct': ('quantileGK', 'Distinct'), 'skewPopDistinct': ('skewPop', 'Distinct'), 'groupBitAndDistinct': ('groupBitAnd', 'Distinct'), 'maxDistinct': ('max', 'Distinct'), 'intervalLengthSumDistinct': ('intervalLengthSum', 'Distinct'), 'quantilesExactHighDistinct': ('quantilesExactHigh', 'Distinct'), 'quantilesBFloat16WeightedDistinct': ('quantilesBFloat16Weighted', 'Distinct'), 'sumKahanDistinct': ('sumKahan', 'Distinct'), 'medianDistinct': ('median', 'Distinct'), 'quantilesGKDistinct': ('quantilesGK', 'Distinct'), 'avgDistinct': ('avg', 'Distinct'), 'meanZTestDistinct': ('meanZTest', 'Distinct'), 'retentionDistinct': ('retention', 'Distinct'), 'windowFunnelDistinct': ('windowFunnel', 'Distinct'), 'kurtPopDistinct': ('kurtPop', 'Distinct'), 'uniqCombined64Distinct': ('uniqCombined64', 'Distinct'), 'groupUniqArrayDistinct': ('groupUniqArray', 'Distinct'), 'groupArrayMovingSumDistinct': ('groupArrayMovingSum', 'Distinct'), 'groupArrayDistinct': ('groupArray', 'Distinct'), 'groupBitXorDistinct': ('groupBitXor', 'Distinct'), 'quantileBFloat16Distinct': ('quantileBFloat16', 'Distinct'), 'deltaSumTimestampDistinct': ('deltaSumTimestamp', 'Distinct'), 'minMapDistinct': ('minMap', 'Distinct'), 'skewSampDistinct': ('skewSamp', 'Distinct'), 'quantilesTDigestDistinct': ('quantilesTDigest', 'Distinct'), 'anyDistinct': ('any', 'Distinct'), 'maxIntersectionsDistinct': ('maxIntersections', 'Distinct'), 'sparkBarDistinct': ('sparkBar', 'Distinct'), 'kolmogorovSmirnovTestDistinct': ('kolmogorovSmirnovTest', 'Distinct'), 'groupArraySampleDistinct': ('groupArraySample', 'Distinct'), 'groupBitmapDistinct': ('groupBitmap', 'Distinct'), 'categoricalInformationValueDistinct': ('categoricalInformationValue', 'Distinct'), 'quantileInterpolatedWeightedDistinct': ('quantileInterpolatedWeighted', 'Distinct'), 'quantilesTimingDistinct': ('quantilesTiming', 'Distinct'), 'quantilesTDigestWeightedDistinct': ('quantilesTDigestWeighted', 'Distinct'), 'groupBitmapAndDistinct': ('groupBitmapAnd', 'Distinct'), 'uniqExactDistinct': ('uniqExact', 'Distinct'), 'quantilesExactWeightedDistinct': ('quantilesExactWeighted', 'Distinct'), 'quantileBFloat16WeightedDistinct': ('quantileBFloat16Weighted', 'Distinct'), 'argMinDistinct': ('argMin', 'Distinct'), 'stddevPopDistinct': ('stddevPop', 'Distinct'), 'exponentialMovingAverageDistinct': ('exponentialMovingAverage', 'Distinct'), 'countDistinct': ('count', 'Distinct'), 'mannWhitneyUTestDistinct': ('mannWhitneyUTest', 'Distinct'), 'quantileExactLowDistinct': ('quantileExactLow', 'Distinct'), 'quantilesExactDistinct': ('quantilesExact', 'Distinct'), 'groupArrayInsertAtDistinct': ('groupArrayInsertAt', 'Distinct'), 'anyLastDistinct': ('anyLast', 'Distinct'), 'stddevSampDistinct': ('stddevSamp', 'Distinct'), 'cramersVBiasCorrectedOrDefault': ('cramersVBiasCorrected', 'OrDefault'), 'topKOrDefault': ('topK', 'OrDefault'), 'quantileTimingWeightedOrDefault': ('quantileTimingWeighted', 'OrDefault'), 'maxMapOrDefault': ('maxMap', 'OrDefault'), 'groupBitmapXorOrDefault': ('groupBitmapXor', 'OrDefault'), 'studentTTestOrDefault': ('studentTTest', 'OrDefault'), 'covarPopOrDefault': ('covarPop', 'OrDefault'), 'quantilesInterpolatedWeightedOrDefault': ('quantilesInterpolatedWeighted', 'OrDefault'), 'last_valueOrDefault': ('last_value', 'OrDefault'), 'boundingRatioOrDefault': ('boundingRatio', 'OrDefault'), 'quantileExactOrDefault': ('quantileExact', 'OrDefault'), 'quantileOrDefault': ('quantile', 'OrDefault'), 'minOrDefault': ('min', 'OrDefault'), 'topKWeightedOrDefault': ('topKWeighted', 'OrDefault'), 'uniqThetaOrDefault': ('uniqTheta', 'OrDefault'), 'kurtSampOrDefault': ('kurtSamp', 'OrDefault'), 'quantilesTimingWeightedOrDefault': ('quantilesTimingWeighted', 'OrDefault'), 'theilsUOrDefault': ('theilsU', 'OrDefault'), 'largestTriangleThreeBucketsOrDefault': ('largestTriangleThreeBuckets', 'OrDefault'), 'groupBitmapOrOrDefault': ('groupBitmapOr', 'OrDefault'), 'quantilesExactLowOrDefault': ('quantilesExactLow', 'OrDefault'), 'quantilesBFloat16OrDefault': ('quantilesBFloat16', 'OrDefault'), 'welchTTestOrDefault': ('welchTTest', 'OrDefault'), 'sumMapOrDefault': ('sumMap', 'OrDefault'), 'quantileTDigestOrDefault': ('quantileTDigest', 'OrDefault'), 'cramersVOrDefault': ('cramersV', 'OrDefault'), 'entropyOrDefault': ('entropy', 'OrDefault'), 'covarSampOrDefault': ('covarSamp', 'OrDefault'), 'maxIntersectionsPositionOrDefault': ('maxIntersectionsPosition', 'OrDefault'), 'simpleLinearRegressionOrDefault': ('simpleLinearRegression', 'OrDefault'), 'argMaxOrDefault': ('argMax', 'OrDefault'), 'stochasticLogisticRegressionOrDefault': ('stochasticLogisticRegression', 'OrDefault'), 'quantileDeterministicOrDefault': ('quantileDeterministic', 'OrDefault'), 'quantilesOrDefault': ('quantiles', 'OrDefault'), 'corrOrDefault': ('corr', 'OrDefault'), 'avgWeightedOrDefault': ('avgWeighted', 'OrDefault'), 'uniqHLL12OrDefault': ('uniqHLL12', 'OrDefault'), 'quantileExactHighOrDefault': ('quantileExactHigh', 'OrDefault'), 'sumWithOverflowOrDefault': ('sumWithOverflow', 'OrDefault'), 'quantileExactWeightedOrDefault': ('quantileExactWeighted', 'OrDefault'), 'uniqOrDefault': ('uniq', 'OrDefault'), 'stochasticLinearRegressionOrDefault': ('stochasticLinearRegression', 'OrDefault'), 'deltaSumOrDefault': ('deltaSum', 'OrDefault'), 'sumOrDefault': ('sum', 'OrDefault'), 'histogramOrDefault': ('histogram', 'OrDefault'), 'quantilesDeterministicOrDefault': ('quantilesDeterministic', 'OrDefault'), 'groupBitOrOrDefault': ('groupBitOr', 'OrDefault'), 'quantileTimingOrDefault': ('quantileTiming', 'OrDefault'), 'sequenceNextNodeOrDefault': ('sequenceNextNode', 'OrDefault'), 'quantileTDigestWeightedOrDefault': ('quantileTDigestWeighted', 'OrDefault'), 'rankCorrOrDefault': ('rankCorr', 'OrDefault'), 'first_valueOrDefault': ('first_value', 'OrDefault'), 'sequenceCountOrDefault': ('sequenceCount', 'OrDefault'), 'varSampOrDefault': ('varSamp', 'OrDefault'), 'uniqUpToOrDefault': ('uniqUpTo', 'OrDefault'), 'contingencyOrDefault': ('contingency', 'OrDefault'), 'anyHeavyOrDefault': ('anyHeavy', 'OrDefault'), 'groupArrayLastOrDefault': ('groupArrayLast', 'OrDefault'), 'exponentialTimeDecayedAvgOrDefault': ('exponentialTimeDecayedAvg', 'OrDefault'), 'sequenceMatchOrDefault': ('sequenceMatch', 'OrDefault'), 'varPopOrDefault': ('varPop', 'OrDefault'), 'groupArrayMovingAvgOrDefault': ('groupArrayMovingAvg', 'OrDefault'), 'uniqCombinedOrDefault': ('uniqCombined', 'OrDefault'), 'sumCountOrDefault': ('sumCount', 'OrDefault'), 'quantileGKOrDefault': ('quantileGK', 'OrDefault'), 'skewPopOrDefault': ('skewPop', 'OrDefault'), 'groupBitAndOrDefault': ('groupBitAnd', 'OrDefault'), 'maxOrDefault': ('max', 'OrDefault'), 'intervalLengthSumOrDefault': ('intervalLengthSum', 'OrDefault'), 'quantilesExactHighOrDefault': ('quantilesExactHigh', 'OrDefault'), 'quantilesBFloat16WeightedOrDefault': ('quantilesBFloat16Weighted', 'OrDefault'), 'sumKahanOrDefault': ('sumKahan', 'OrDefault'), 'medianOrDefault': ('median', 'OrDefault'), 'quantilesGKOrDefault': ('quantilesGK', 'OrDefault'), 'avgOrDefault': ('avg', 'OrDefault'), 'meanZTestOrDefault': ('meanZTest', 'OrDefault'), 'retentionOrDefault': ('retention', 'OrDefault'), 'windowFunnelOrDefault': ('windowFunnel', 'OrDefault'), 'kurtPopOrDefault': ('kurtPop', 'OrDefault'), 'uniqCombined64OrDefault': ('uniqCombined64', 'OrDefault'), 'groupUniqArrayOrDefault': ('groupUniqArray', 'OrDefault'), 'groupArrayMovingSumOrDefault': ('groupArrayMovingSum', 'OrDefault'), 'groupArrayOrDefault': ('groupArray', 'OrDefault'), 'groupBitXorOrDefault': ('groupBitXor', 'OrDefault'), 'quantileBFloat16OrDefault': ('quantileBFloat16', 'OrDefault'), 'deltaSumTimestampOrDefault': ('deltaSumTimestamp', 'OrDefault'), 'minMapOrDefault': ('minMap', 'OrDefault'), 'skewSampOrDefault': ('skewSamp', 'OrDefault'), 'quantilesTDigestOrDefault': ('quantilesTDigest', 'OrDefault'), 'anyOrDefault': ('any', 'OrDefault'), 'maxIntersectionsOrDefault': ('maxIntersections', 'OrDefault'), 'sparkBarOrDefault': ('sparkBar', 'OrDefault'), 'kolmogorovSmirnovTestOrDefault': ('kolmogorovSmirnovTest', 'OrDefault'), 'groupArraySampleOrDefault': ('groupArraySample', 'OrDefault'), 'groupBitmapOrDefault': ('groupBitmap', 'OrDefault'), 'categoricalInformationValueOrDefault': ('categoricalInformationValue', 'OrDefault'), 'quantileInterpolatedWeightedOrDefault': ('quantileInterpolatedWeighted', 'OrDefault'), 'quantilesTimingOrDefault': ('quantilesTiming', 'OrDefault'), 'quantilesTDigestWeightedOrDefault': ('quantilesTDigestWeighted', 'OrDefault'), 'groupBitmapAndOrDefault': ('groupBitmapAnd', 'OrDefault'), 'uniqExactOrDefault': ('uniqExact', 'OrDefault'), 'quantilesExactWeightedOrDefault': ('quantilesExactWeighted', 'OrDefault'), 'quantileBFloat16WeightedOrDefault': ('quantileBFloat16Weighted', 'OrDefault'), 'argMinOrDefault': ('argMin', 'OrDefault'), 'stddevPopOrDefault': ('stddevPop', 'OrDefault'), 'exponentialMovingAverageOrDefault': ('exponentialMovingAverage', 'OrDefault'), 'countOrDefault': ('count', 'OrDefault'), 'mannWhitneyUTestOrDefault': ('mannWhitneyUTest', 'OrDefault'), 'quantileExactLowOrDefault': ('quantileExactLow', 'OrDefault'), 'quantilesExactOrDefault': ('quantilesExact', 'OrDefault'), 'groupArrayInsertAtOrDefault': ('groupArrayInsertAt', 'OrDefault'), 'anyLastOrDefault': ('anyLast', 'OrDefault'), 'stddevSampOrDefault': ('stddevSamp', 'OrDefault'), 'cramersVBiasCorrectedOrNull': ('cramersVBiasCorrected', 'OrNull'), 'topKOrNull': ('topK', 'OrNull'), 'quantileTimingWeightedOrNull': ('quantileTimingWeighted', 'OrNull'), 'maxMapOrNull': ('maxMap', 'OrNull'), 'groupBitmapXorOrNull': ('groupBitmapXor', 'OrNull'), 'studentTTestOrNull': ('studentTTest', 'OrNull'), 'covarPopOrNull': ('covarPop', 'OrNull'), 'quantilesInterpolatedWeightedOrNull': ('quantilesInterpolatedWeighted', 'OrNull'), 'last_valueOrNull': ('last_value', 'OrNull'), 'boundingRatioOrNull': ('boundingRatio', 'OrNull'), 'quantileExactOrNull': ('quantileExact', 'OrNull'), 'quantileOrNull': ('quantile', 'OrNull'), 'minOrNull': ('min', 'OrNull'), 'topKWeightedOrNull': ('topKWeighted', 'OrNull'), 'uniqThetaOrNull': ('uniqTheta', 'OrNull'), 'kurtSampOrNull': ('kurtSamp', 'OrNull'), 'quantilesTimingWeightedOrNull': ('quantilesTimingWeighted', 'OrNull'), 'theilsUOrNull': ('theilsU', 'OrNull'), 'largestTriangleThreeBucketsOrNull': ('largestTriangleThreeBuckets', 'OrNull'), 'groupBitmapOrOrNull': ('groupBitmapOr', 'OrNull'), 'quantilesExactLowOrNull': ('quantilesExactLow', 'OrNull'), 'quantilesBFloat16OrNull': ('quantilesBFloat16', 'OrNull'), 'welchTTestOrNull': ('welchTTest', 'OrNull'), 'sumMapOrNull': ('sumMap', 'OrNull'), 'quantileTDigestOrNull': ('quantileTDigest', 'OrNull'), 'cramersVOrNull': ('cramersV', 'OrNull'), 'entropyOrNull': ('entropy', 'OrNull'), 'covarSampOrNull': ('covarSamp', 'OrNull'), 'maxIntersectionsPositionOrNull': ('maxIntersectionsPosition', 'OrNull'), 'simpleLinearRegressionOrNull': ('simpleLinearRegression', 'OrNull'), 'argMaxOrNull': ('argMax', 'OrNull'), 'stochasticLogisticRegressionOrNull': ('stochasticLogisticRegression', 'OrNull'), 'quantileDeterministicOrNull': ('quantileDeterministic', 'OrNull'), 'quantilesOrNull': ('quantiles', 'OrNull'), 'corrOrNull': ('corr', 'OrNull'), 'avgWeightedOrNull': ('avgWeighted', 'OrNull'), 'uniqHLL12OrNull': ('uniqHLL12', 'OrNull'), 'quantileExactHighOrNull': ('quantileExactHigh', 'OrNull'), 'sumWithOverflowOrNull': ('sumWithOverflow', 'OrNull'), 'quantileExactWeightedOrNull': ('quantileExactWeighted', 'OrNull'), 'uniqOrNull': ('uniq', 'OrNull'), 'stochasticLinearRegressionOrNull': ('stochasticLinearRegression', 'OrNull'), 'deltaSumOrNull': ('deltaSum', 'OrNull'), 'sumOrNull': ('sum', 'OrNull'), 'histogramOrNull': ('histogram', 'OrNull'), 'quantilesDeterministicOrNull': ('quantilesDeterministic', 'OrNull'), 'groupBitOrOrNull': ('groupBitOr', 'OrNull'), 'quantileTimingOrNull': ('quantileTiming', 'OrNull'), 'sequenceNextNodeOrNull': ('sequenceNextNode', 'OrNull'), 'quantileTDigestWeightedOrNull': ('quantileTDigestWeighted', 'OrNull'), 'rankCorrOrNull': ('rankCorr', 'OrNull'), 'first_valueOrNull': ('first_value', 'OrNull'), 'sequenceCountOrNull': ('sequenceCount', 'OrNull'), 'varSampOrNull': ('varSamp', 'OrNull'), 'uniqUpToOrNull': ('uniqUpTo', 'OrNull'), 'contingencyOrNull': ('contingency', 'OrNull'), 'anyHeavyOrNull': ('anyHeavy', 'OrNull'), 'groupArrayLastOrNull': ('groupArrayLast', 'OrNull'), 'exponentialTimeDecayedAvgOrNull': ('exponentialTimeDecayedAvg', 'OrNull'), 'sequenceMatchOrNull': ('sequenceMatch', 'OrNull'), 'varPopOrNull': ('varPop', 'OrNull'), 'groupArrayMovingAvgOrNull': ('groupArrayMovingAvg', 'OrNull'), 'uniqCombinedOrNull': ('uniqCombined', 'OrNull'), 'sumCountOrNull': ('sumCount', 'OrNull'), 'quantileGKOrNull': ('quantileGK', 'OrNull'), 'skewPopOrNull': ('skewPop', 'OrNull'), 'groupBitAndOrNull': ('groupBitAnd', 'OrNull'), 'maxOrNull': ('max', 'OrNull'), 'intervalLengthSumOrNull': ('intervalLengthSum', 'OrNull'), 'quantilesExactHighOrNull': ('quantilesExactHigh', 'OrNull'), 'quantilesBFloat16WeightedOrNull': ('quantilesBFloat16Weighted', 'OrNull'), 'sumKahanOrNull': ('sumKahan', 'OrNull'), 'medianOrNull': ('median', 'OrNull'), 'quantilesGKOrNull': ('quantilesGK', 'OrNull'), 'avgOrNull': ('avg', 'OrNull'), 'meanZTestOrNull': ('meanZTest', 'OrNull'), 'retentionOrNull': ('retention', 'OrNull'), 'windowFunnelOrNull': ('windowFunnel', 'OrNull'), 'kurtPopOrNull': ('kurtPop', 'OrNull'), 'uniqCombined64OrNull': ('uniqCombined64', 'OrNull'), 'groupUniqArrayOrNull': ('groupUniqArray', 'OrNull'), 'groupArrayMovingSumOrNull': ('groupArrayMovingSum', 'OrNull'), 'groupArrayOrNull': ('groupArray', 'OrNull'), 'groupBitXorOrNull': ('groupBitXor', 'OrNull'), 'quantileBFloat16OrNull': ('quantileBFloat16', 'OrNull'), 'deltaSumTimestampOrNull': ('deltaSumTimestamp', 'OrNull'), 'minMapOrNull': ('minMap', 'OrNull'), 'skewSampOrNull': ('skewSamp', 'OrNull'), 'quantilesTDigestOrNull': ('quantilesTDigest', 'OrNull'), 'anyOrNull': ('any', 'OrNull'), 'maxIntersectionsOrNull': ('maxIntersections', 'OrNull'), 'sparkBarOrNull': ('sparkBar', 'OrNull'), 'kolmogorovSmirnovTestOrNull': ('kolmogorovSmirnovTest', 'OrNull'), 'groupArraySampleOrNull': ('groupArraySample', 'OrNull'), 'groupBitmapOrNull': ('groupBitmap', 'OrNull'), 'categoricalInformationValueOrNull': ('categoricalInformationValue', 'OrNull'), 'quantileInterpolatedWeightedOrNull': ('quantileInterpolatedWeighted', 'OrNull'), 'quantilesTimingOrNull': ('quantilesTiming', 'OrNull'), 'quantilesTDigestWeightedOrNull': ('quantilesTDigestWeighted', 'OrNull'), 'groupBitmapAndOrNull': ('groupBitmapAnd', 'OrNull'), 'uniqExactOrNull': ('uniqExact', 'OrNull'), 'quantilesExactWeightedOrNull': ('quantilesExactWeighted', 'OrNull'), 'quantileBFloat16WeightedOrNull': ('quantileBFloat16Weighted', 'OrNull'), 'argMinOrNull': ('argMin', 'OrNull'), 'stddevPopOrNull': ('stddevPop', 'OrNull'), 'exponentialMovingAverageOrNull': ('exponentialMovingAverage', 'OrNull'), 'countOrNull': ('count', 'OrNull'), 'mannWhitneyUTestOrNull': ('mannWhitneyUTest', 'OrNull'), 'quantileExactLowOrNull': ('quantileExactLow', 'OrNull'), 'quantilesExactOrNull': ('quantilesExact', 'OrNull'), 'groupArrayInsertAtOrNull': ('groupArrayInsertAt', 'OrNull'), 'anyLastOrNull': ('anyLast', 'OrNull'), 'stddevSampOrNull': ('stddevSamp', 'OrNull'), 'cramersVBiasCorrectedResample': ('cramersVBiasCorrected', 'Resample'), 'topKResample': ('topK', 'Resample'), 'quantileTimingWeightedResample': ('quantileTimingWeighted', 'Resample'), 'maxMapResample': ('maxMap', 'Resample'), 'groupBitmapXorResample': ('groupBitmapXor', 'Resample'), 'studentTTestResample': ('studentTTest', 'Resample'), 'covarPopResample': ('covarPop', 'Resample'), 'quantilesInterpolatedWeightedResample': ('quantilesInterpolatedWeighted', 'Resample'), 'last_valueResample': ('last_value', 'Resample'), 'boundingRatioResample': ('boundingRatio', 'Resample'), 'quantileExactResample': ('quantileExact', 'Resample'), 'quantileResample': ('quantile', 'Resample'), 'minResample': ('min', 'Resample'), 'topKWeightedResample': ('topKWeighted', 'Resample'), 'uniqThetaResample': ('uniqTheta', 'Resample'), 'kurtSampResample': ('kurtSamp', 'Resample'), 'quantilesTimingWeightedResample': ('quantilesTimingWeighted', 'Resample'), 'theilsUResample': ('theilsU', 'Resample'), 'largestTriangleThreeBucketsResample': ('largestTriangleThreeBuckets', 'Resample'), 'groupBitmapOrResample': ('groupBitmapOr', 'Resample'), 'quantilesExactLowResample': ('quantilesExactLow', 'Resample'), 'quantilesBFloat16Resample': ('quantilesBFloat16', 'Resample'), 'welchTTestResample': ('welchTTest', 'Resample'), 'sumMapResample': ('sumMap', 'Resample'), 'quantileTDigestResample': ('quantileTDigest', 'Resample'), 'cramersVResample': ('cramersV', 'Resample'), 'entropyResample': ('entropy', 'Resample'), 'covarSampResample': ('covarSamp', 'Resample'), 'maxIntersectionsPositionResample': ('maxIntersectionsPosition', 'Resample'), 'simpleLinearRegressionResample': ('simpleLinearRegression', 'Resample'), 'argMaxResample': ('argMax', 'Resample'), 'stochasticLogisticRegressionResample': ('stochasticLogisticRegression', 'Resample'), 'quantileDeterministicResample': ('quantileDeterministic', 'Resample'), 'quantilesResample': ('quantiles', 'Resample'), 'corrResample': ('corr', 'Resample'), 'avgWeightedResample': ('avgWeighted', 'Resample'), 'uniqHLL12Resample': ('uniqHLL12', 'Resample'), 'quantileExactHighResample': ('quantileExactHigh', 'Resample'), 'sumWithOverflowResample': ('sumWithOverflow', 'Resample'), 'quantileExactWeightedResample': ('quantileExactWeighted', 'Resample'), 'uniqResample': ('uniq', 'Resample'), 'stochasticLinearRegressionResample': ('stochasticLinearRegression', 'Resample'), 'deltaSumResample': ('deltaSum', 'Resample'), 'sumResample': ('sum', 'Resample'), 'histogramResample': ('histogram', 'Resample'), 'quantilesDeterministicResample': ('quantilesDeterministic', 'Resample'), 'groupBitOrResample': ('groupBitOr', 'Resample'), 'quantileTimingResample': ('quantileTiming', 'Resample'), 'sequenceNextNodeResample': ('sequenceNextNode', 'Resample'), 'quantileTDigestWeightedResample': ('quantileTDigestWeighted', 'Resample'), 'rankCorrResample': ('rankCorr', 'Resample'), 'first_valueResample': ('first_value', 'Resample'), 'sequenceCountResample': ('sequenceCount', 'Resample'), 'varSampResample': ('varSamp', 'Resample'), 'uniqUpToResample': ('uniqUpTo', 'Resample'), 'contingencyResample': ('contingency', 'Resample'), 'anyHeavyResample': ('anyHeavy', 'Resample'), 'groupArrayLastResample': ('groupArrayLast', 'Resample'), 'exponentialTimeDecayedAvgResample': ('exponentialTimeDecayedAvg', 'Resample'), 'sequenceMatchResample': ('sequenceMatch', 'Resample'), 'varPopResample': ('varPop', 'Resample'), 'groupArrayMovingAvgResample': ('groupArrayMovingAvg', 'Resample'), 'uniqCombinedResample': ('uniqCombined', 'Resample'), 'sumCountResample': ('sumCount', 'Resample'), 'quantileGKResample': ('quantileGK', 'Resample'), 'skewPopResample': ('skewPop', 'Resample'), 'groupBitAndResample': ('groupBitAnd', 'Resample'), 'maxResample': ('max', 'Resample'), 'intervalLengthSumResample': ('intervalLengthSum', 'Resample'), 'quantilesExactHighResample': ('quantilesExactHigh', 'Resample'), 'quantilesBFloat16WeightedResample': ('quantilesBFloat16Weighted', 'Resample'), 'sumKahanResample': ('sumKahan', 'Resample'), 'medianResample': ('median', 'Resample'), 'quantilesGKResample': ('quantilesGK', 'Resample'), 'avgResample': ('avg', 'Resample'), 'meanZTestResample': ('meanZTest', 'Resample'), 'retentionResample': ('retention', 'Resample'), 'windowFunnelResample': ('windowFunnel', 'Resample'), 'kurtPopResample': ('kurtPop', 'Resample'), 'uniqCombined64Resample': ('uniqCombined64', 'Resample'), 'groupUniqArrayResample': ('groupUniqArray', 'Resample'), 'groupArrayMovingSumResample': ('groupArrayMovingSum', 'Resample'), 'groupArrayResample': ('groupArray', 'Resample'), 'groupBitXorResample': ('groupBitXor', 'Resample'), 'quantileBFloat16Resample': ('quantileBFloat16', 'Resample'), 'deltaSumTimestampResample': ('deltaSumTimestamp', 'Resample'), 'minMapResample': ('minMap', 'Resample'), 'skewSampResample': ('skewSamp', 'Resample'), 'quantilesTDigestResample': ('quantilesTDigest', 'Resample'), 'anyResample': ('any', 'Resample'), 'maxIntersectionsResample': ('maxIntersections', 'Resample'), 'sparkBarResample': ('sparkBar', 'Resample'), 'kolmogorovSmirnovTestResample': ('kolmogorovSmirnovTest', 'Resample'), 'groupArraySampleResample': ('groupArraySample', 'Resample'), 'groupBitmapResample': ('groupBitmap', 'Resample'), 'categoricalInformationValueResample': ('categoricalInformationValue', 'Resample'), 'quantileInterpolatedWeightedResample': ('quantileInterpolatedWeighted', 'Resample'), 'quantilesTimingResample': ('quantilesTiming', 'Resample'), 'quantilesTDigestWeightedResample': ('quantilesTDigestWeighted', 'Resample'), 'groupBitmapAndResample': ('groupBitmapAnd', 'Resample'), 'uniqExactResample': ('uniqExact', 'Resample'), 'quantilesExactWeightedResample': ('quantilesExactWeighted', 'Resample'), 'quantileBFloat16WeightedResample': ('quantileBFloat16Weighted', 'Resample'), 'argMinResample': ('argMin', 'Resample'), 'stddevPopResample': ('stddevPop', 'Resample'), 'exponentialMovingAverageResample': ('exponentialMovingAverage', 'Resample'), 'countResample': ('count', 'Resample'), 'mannWhitneyUTestResample': ('mannWhitneyUTest', 'Resample'), 'quantileExactLowResample': ('quantileExactLow', 'Resample'), 'quantilesExactResample': ('quantilesExact', 'Resample'), 'groupArrayInsertAtResample': ('groupArrayInsertAt', 'Resample'), 'anyLastResample': ('anyLast', 'Resample'), 'stddevSampResample': ('stddevSamp', 'Resample'), 'cramersVBiasCorrectedArgMin': ('cramersVBiasCorrected', 'ArgMin'), 'topKArgMin': ('topK', 'ArgMin'), 'quantileTimingWeightedArgMin': ('quantileTimingWeighted', 'ArgMin'), 'maxMapArgMin': ('maxMap', 'ArgMin'), 'groupBitmapXorArgMin': ('groupBitmapXor', 'ArgMin'), 'studentTTestArgMin': ('studentTTest', 'ArgMin'), 'covarPopArgMin': ('covarPop', 'ArgMin'), 'quantilesInterpolatedWeightedArgMin': ('quantilesInterpolatedWeighted', 'ArgMin'), 'last_valueArgMin': ('last_value', 'ArgMin'), 'boundingRatioArgMin': ('boundingRatio', 'ArgMin'), 'quantileExactArgMin': ('quantileExact', 'ArgMin'), 'quantileArgMin': ('quantile', 'ArgMin'), 'minArgMin': ('min', 'ArgMin'), 'topKWeightedArgMin': ('topKWeighted', 'ArgMin'), 'uniqThetaArgMin': ('uniqTheta', 'ArgMin'), 'kurtSampArgMin': ('kurtSamp', 'ArgMin'), 'quantilesTimingWeightedArgMin': ('quantilesTimingWeighted', 'ArgMin'), 'theilsUArgMin': ('theilsU', 'ArgMin'), 'largestTriangleThreeBucketsArgMin': ('largestTriangleThreeBuckets', 'ArgMin'), 'groupBitmapOrArgMin': ('groupBitmapOr', 'ArgMin'), 'quantilesExactLowArgMin': ('quantilesExactLow', 'ArgMin'), 'quantilesBFloat16ArgMin': ('quantilesBFloat16', 'ArgMin'), 'welchTTestArgMin': ('welchTTest', 'ArgMin'), 'sumMapArgMin': ('sumMap', 'ArgMin'), 'quantileTDigestArgMin': ('quantileTDigest', 'ArgMin'), 'cramersVArgMin': ('cramersV', 'ArgMin'), 'entropyArgMin': ('entropy', 'ArgMin'), 'covarSampArgMin': ('covarSamp', 'ArgMin'), 'maxIntersectionsPositionArgMin': ('maxIntersectionsPosition', 'ArgMin'), 'simpleLinearRegressionArgMin': ('simpleLinearRegression', 'ArgMin'), 'argMaxArgMin': ('argMax', 'ArgMin'), 'stochasticLogisticRegressionArgMin': ('stochasticLogisticRegression', 'ArgMin'), 'quantileDeterministicArgMin': ('quantileDeterministic', 'ArgMin'), 'quantilesArgMin': ('quantiles', 'ArgMin'), 'corrArgMin': ('corr', 'ArgMin'), 'avgWeightedArgMin': ('avgWeighted', 'ArgMin'), 'uniqHLL12ArgMin': ('uniqHLL12', 'ArgMin'), 'quantileExactHighArgMin': ('quantileExactHigh', 'ArgMin'), 'sumWithOverflowArgMin': ('sumWithOverflow', 'ArgMin'), 'quantileExactWeightedArgMin': ('quantileExactWeighted', 'ArgMin'), 'uniqArgMin': ('uniq', 'ArgMin'), 'stochasticLinearRegressionArgMin': ('stochasticLinearRegression', 'ArgMin'), 'deltaSumArgMin': ('deltaSum', 'ArgMin'), 'sumArgMin': ('sum', 'ArgMin'), 'histogramArgMin': ('histogram', 'ArgMin'), 'quantilesDeterministicArgMin': ('quantilesDeterministic', 'ArgMin'), 'groupBitOrArgMin': ('groupBitOr', 'ArgMin'), 'quantileTimingArgMin': ('quantileTiming', 'ArgMin'), 'sequenceNextNodeArgMin': ('sequenceNextNode', 'ArgMin'), 'quantileTDigestWeightedArgMin': ('quantileTDigestWeighted', 'ArgMin'), 'rankCorrArgMin': ('rankCorr', 'ArgMin'), 'first_valueArgMin': ('first_value', 'ArgMin'), 'sequenceCountArgMin': ('sequenceCount', 'ArgMin'), 'varSampArgMin': ('varSamp', 'ArgMin'), 'uniqUpToArgMin': ('uniqUpTo', 'ArgMin'), 'contingencyArgMin': ('contingency', 'ArgMin'), 'anyHeavyArgMin': ('anyHeavy', 'ArgMin'), 'groupArrayLastArgMin': ('groupArrayLast', 'ArgMin'), 'exponentialTimeDecayedAvgArgMin': ('exponentialTimeDecayedAvg', 'ArgMin'), 'sequenceMatchArgMin': ('sequenceMatch', 'ArgMin'), 'varPopArgMin': ('varPop', 'ArgMin'), 'groupArrayMovingAvgArgMin': ('groupArrayMovingAvg', 'ArgMin'), 'uniqCombinedArgMin': ('uniqCombined', 'ArgMin'), 'sumCountArgMin': ('sumCount', 'ArgMin'), 'quantileGKArgMin': ('quantileGK', 'ArgMin'), 'skewPopArgMin': ('skewPop', 'ArgMin'), 'groupBitAndArgMin': ('groupBitAnd', 'ArgMin'), 'maxArgMin': ('max', 'ArgMin'), 'intervalLengthSumArgMin': ('intervalLengthSum', 'ArgMin'), 'quantilesExactHighArgMin': ('quantilesExactHigh', 'ArgMin'), 'quantilesBFloat16WeightedArgMin': ('quantilesBFloat16Weighted', 'ArgMin'), 'sumKahanArgMin': ('sumKahan', 'ArgMin'), 'medianArgMin': ('median', 'ArgMin'), 'quantilesGKArgMin': ('quantilesGK', 'ArgMin'), 'avgArgMin': ('avg', 'ArgMin'), 'meanZTestArgMin': ('meanZTest', 'ArgMin'), 'retentionArgMin': ('retention', 'ArgMin'), 'windowFunnelArgMin': ('windowFunnel', 'ArgMin'), 'kurtPopArgMin': ('kurtPop', 'ArgMin'), 'uniqCombined64ArgMin': ('uniqCombined64', 'ArgMin'), 'groupUniqArrayArgMin': ('groupUniqArray', 'ArgMin'), 'groupArrayMovingSumArgMin': ('groupArrayMovingSum', 'ArgMin'), 'groupArrayArgMin': ('groupArray', 'ArgMin'), 'groupBitXorArgMin': ('groupBitXor', 'ArgMin'), 'quantileBFloat16ArgMin': ('quantileBFloat16', 'ArgMin'), 'deltaSumTimestampArgMin': ('deltaSumTimestamp', 'ArgMin'), 'minMapArgMin': ('minMap', 'ArgMin'), 'skewSampArgMin': ('skewSamp', 'ArgMin'), 'quantilesTDigestArgMin': ('quantilesTDigest', 'ArgMin'), 'anyArgMin': ('any', 'ArgMin'), 'maxIntersectionsArgMin': ('maxIntersections', 'ArgMin'), 'sparkBarArgMin': ('sparkBar', 'ArgMin'), 'kolmogorovSmirnovTestArgMin': ('kolmogorovSmirnovTest', 'ArgMin'), 'groupArraySampleArgMin': ('groupArraySample', 'ArgMin'), 'groupBitmapArgMin': ('groupBitmap', 'ArgMin'), 'categoricalInformationValueArgMin': ('categoricalInformationValue', 'ArgMin'), 'quantileInterpolatedWeightedArgMin': ('quantileInterpolatedWeighted', 'ArgMin'), 'quantilesTimingArgMin': ('quantilesTiming', 'ArgMin'), 'quantilesTDigestWeightedArgMin': ('quantilesTDigestWeighted', 'ArgMin'), 'groupBitmapAndArgMin': ('groupBitmapAnd', 'ArgMin'), 'uniqExactArgMin': ('uniqExact', 'ArgMin'), 'quantilesExactWeightedArgMin': ('quantilesExactWeighted', 'ArgMin'), 'quantileBFloat16WeightedArgMin': ('quantileBFloat16Weighted', 'ArgMin'), 'argMinArgMin': ('argMin', 'ArgMin'), 'stddevPopArgMin': ('stddevPop', 'ArgMin'), 'exponentialMovingAverageArgMin': ('exponentialMovingAverage', 'ArgMin'), 'countArgMin': ('count', 'ArgMin'), 'mannWhitneyUTestArgMin': ('mannWhitneyUTest', 'ArgMin'), 'quantileExactLowArgMin': ('quantileExactLow', 'ArgMin'), 'quantilesExactArgMin': ('quantilesExact', 'ArgMin'), 'groupArrayInsertAtArgMin': ('groupArrayInsertAt', 'ArgMin'), 'anyLastArgMin': ('anyLast', 'ArgMin'), 'stddevSampArgMin': ('stddevSamp', 'ArgMin'), 'cramersVBiasCorrectedArgMax': ('cramersVBiasCorrected', 'ArgMax'), 'topKArgMax': ('topK', 'ArgMax'), 'quantileTimingWeightedArgMax': ('quantileTimingWeighted', 'ArgMax'), 'maxMapArgMax': ('maxMap', 'ArgMax'), 'groupBitmapXorArgMax': ('groupBitmapXor', 'ArgMax'), 'studentTTestArgMax': ('studentTTest', 'ArgMax'), 'covarPopArgMax': ('covarPop', 'ArgMax'), 'quantilesInterpolatedWeightedArgMax': ('quantilesInterpolatedWeighted', 'ArgMax'), 'last_valueArgMax': ('last_value', 'ArgMax'), 'boundingRatioArgMax': ('boundingRatio', 'ArgMax'), 'quantileExactArgMax': ('quantileExact', 'ArgMax'), 'quantileArgMax': ('quantile', 'ArgMax'), 'minArgMax': ('min', 'ArgMax'), 'topKWeightedArgMax': ('topKWeighted', 'ArgMax'), 'uniqThetaArgMax': ('uniqTheta', 'ArgMax'), 'kurtSampArgMax': ('kurtSamp', 'ArgMax'), 'quantilesTimingWeightedArgMax': ('quantilesTimingWeighted', 'ArgMax'), 'theilsUArgMax': ('theilsU', 'ArgMax'), 'largestTriangleThreeBucketsArgMax': ('largestTriangleThreeBuckets', 'ArgMax'), 'groupBitmapOrArgMax': ('groupBitmapOr', 'ArgMax'), 'quantilesExactLowArgMax': ('quantilesExactLow', 'ArgMax'), 'quantilesBFloat16ArgMax': ('quantilesBFloat16', 'ArgMax'), 'welchTTestArgMax': ('welchTTest', 'ArgMax'), 'sumMapArgMax': ('sumMap', 'ArgMax'), 'quantileTDigestArgMax': ('quantileTDigest', 'ArgMax'), 'cramersVArgMax': ('cramersV', 'ArgMax'), 'entropyArgMax': ('entropy', 'ArgMax'), 'covarSampArgMax': ('covarSamp', 'ArgMax'), 'maxIntersectionsPositionArgMax': ('maxIntersectionsPosition', 'ArgMax'), 'simpleLinearRegressionArgMax': ('simpleLinearRegression', 'ArgMax'), 'argMaxArgMax': ('argMax', 'ArgMax'), 'stochasticLogisticRegressionArgMax': ('stochasticLogisticRegression', 'ArgMax'), 'quantileDeterministicArgMax': ('quantileDeterministic', 'ArgMax'), 'quantilesArgMax': ('quantiles', 'ArgMax'), 'corrArgMax': ('corr', 'ArgMax'), 'avgWeightedArgMax': ('avgWeighted', 'ArgMax'), 'uniqHLL12ArgMax': ('uniqHLL12', 'ArgMax'), 'quantileExactHighArgMax': ('quantileExactHigh', 'ArgMax'), 'sumWithOverflowArgMax': ('sumWithOverflow', 'ArgMax'), 'quantileExactWeightedArgMax': ('quantileExactWeighted', 'ArgMax'), 'uniqArgMax': ('uniq', 'ArgMax'), 'stochasticLinearRegressionArgMax': ('stochasticLinearRegression', 'ArgMax'), 'deltaSumArgMax': ('deltaSum', 'ArgMax'), 'sumArgMax': ('sum', 'ArgMax'), 'histogramArgMax': ('histogram', 'ArgMax'), 'quantilesDeterministicArgMax': ('quantilesDeterministic', 'ArgMax'), 'groupBitOrArgMax': ('groupBitOr', 'ArgMax'), 'quantileTimingArgMax': ('quantileTiming', 'ArgMax'), 'sequenceNextNodeArgMax': ('sequenceNextNode', 'ArgMax'), 'quantileTDigestWeightedArgMax': ('quantileTDigestWeighted', 'ArgMax'), 'rankCorrArgMax': ('rankCorr', 'ArgMax'), 'first_valueArgMax': ('first_value', 'ArgMax'), 'sequenceCountArgMax': ('sequenceCount', 'ArgMax'), 'varSampArgMax': ('varSamp', 'ArgMax'), 'uniqUpToArgMax': ('uniqUpTo', 'ArgMax'), 'contingencyArgMax': ('contingency', 'ArgMax'), 'anyHeavyArgMax': ('anyHeavy', 'ArgMax'), 'groupArrayLastArgMax': ('groupArrayLast', 'ArgMax'), 'exponentialTimeDecayedAvgArgMax': ('exponentialTimeDecayedAvg', 'ArgMax'), 'sequenceMatchArgMax': ('sequenceMatch', 'ArgMax'), 'varPopArgMax': ('varPop', 'ArgMax'), 'groupArrayMovingAvgArgMax': ('groupArrayMovingAvg', 'ArgMax'), 'uniqCombinedArgMax': ('uniqCombined', 'ArgMax'), 'sumCountArgMax': ('sumCount', 'ArgMax'), 'quantileGKArgMax': ('quantileGK', 'ArgMax'), 'skewPopArgMax': ('skewPop', 'ArgMax'), 'groupBitAndArgMax': ('groupBitAnd', 'ArgMax'), 'maxArgMax': ('max', 'ArgMax'), 'intervalLengthSumArgMax': ('intervalLengthSum', 'ArgMax'), 'quantilesExactHighArgMax': ('quantilesExactHigh', 'ArgMax'), 'quantilesBFloat16WeightedArgMax': ('quantilesBFloat16Weighted', 'ArgMax'), 'sumKahanArgMax': ('sumKahan', 'ArgMax'), 'medianArgMax': ('median', 'ArgMax'), 'quantilesGKArgMax': ('quantilesGK', 'ArgMax'), 'avgArgMax': ('avg', 'ArgMax'), 'meanZTestArgMax': ('meanZTest', 'ArgMax'), 'retentionArgMax': ('retention', 'ArgMax'), 'windowFunnelArgMax': ('windowFunnel', 'ArgMax'), 'kurtPopArgMax': ('kurtPop', 'ArgMax'), 'uniqCombined64ArgMax': ('uniqCombined64', 'ArgMax'), 'groupUniqArrayArgMax': ('groupUniqArray', 'ArgMax'), 'groupArrayMovingSumArgMax': ('groupArrayMovingSum', 'ArgMax'), 'groupArrayArgMax': ('groupArray', 'ArgMax'), 'groupBitXorArgMax': ('groupBitXor', 'ArgMax'), 'quantileBFloat16ArgMax': ('quantileBFloat16', 'ArgMax'), 'deltaSumTimestampArgMax': ('deltaSumTimestamp', 'ArgMax'), 'minMapArgMax': ('minMap', 'ArgMax'), 'skewSampArgMax': ('skewSamp', 'ArgMax'), 'quantilesTDigestArgMax': ('quantilesTDigest', 'ArgMax'), 'anyArgMax': ('any', 'ArgMax'), 'maxIntersectionsArgMax': ('maxIntersections', 'ArgMax'), 'sparkBarArgMax': ('sparkBar', 'ArgMax'), 'kolmogorovSmirnovTestArgMax': ('kolmogorovSmirnovTest', 'ArgMax'), 'groupArraySampleArgMax': ('groupArraySample', 'ArgMax'), 'groupBitmapArgMax': ('groupBitmap', 'ArgMax'), 'categoricalInformationValueArgMax': ('categoricalInformationValue', 'ArgMax'), 'quantileInterpolatedWeightedArgMax': ('quantileInterpolatedWeighted', 'ArgMax'), 'quantilesTimingArgMax': ('quantilesTiming', 'ArgMax'), 'quantilesTDigestWeightedArgMax': ('quantilesTDigestWeighted', 'ArgMax'), 'groupBitmapAndArgMax': ('groupBitmapAnd', 'ArgMax'), 'uniqExactArgMax': ('uniqExact', 'ArgMax'), 'quantilesExactWeightedArgMax': ('quantilesExactWeighted', 'ArgMax'), 'quantileBFloat16WeightedArgMax': ('quantileBFloat16Weighted', 'ArgMax'), 'argMinArgMax': ('argMin', 'ArgMax'), 'stddevPopArgMax': ('stddevPop', 'ArgMax'), 'exponentialMovingAverageArgMax': ('exponentialMovingAverage', 'ArgMax'), 'countArgMax': ('count', 'ArgMax'), 'mannWhitneyUTestArgMax': ('mannWhitneyUTest', 'ArgMax'), 'quantileExactLowArgMax': ('quantileExactLow', 'ArgMax'), 'quantilesExactArgMax': ('quantilesExact', 'ArgMax'), 'groupArrayInsertAtArgMax': ('groupArrayInsertAt', 'ArgMax'), 'anyLastArgMax': ('anyLast', 'ArgMax'), 'stddevSampArgMax': ('stddevSamp', 'ArgMax'), 'cramersVBiasCorrected': ('cramersVBiasCorrected', ''), 'topK': ('topK', ''), 'quantileTimingWeighted': ('quantileTimingWeighted', ''), 'groupBitmapXor': ('groupBitmapXor', ''), 'studentTTest': ('studentTTest', ''), 'covarPop': ('covarPop', ''), 'quantilesInterpolatedWeighted': ('quantilesInterpolatedWeighted', ''), 'last_value': ('last_value', ''), 'boundingRatio': ('boundingRatio', ''), 'quantileExact': ('quantileExact', ''), 'quantile': ('quantile', ''), 'min': ('min', ''), 'topKWeighted': ('topKWeighted', ''), 'uniqTheta': ('uniqTheta', ''), 'kurtSamp': ('kurtSamp', ''), 'quantilesTimingWeighted': ('quantilesTimingWeighted', ''), 'theilsU': ('theilsU', ''), 'largestTriangleThreeBuckets': ('largestTriangleThreeBuckets', ''), 'groupBitmapOr': ('groupBitmapOr', ''), 'quantilesExactLow': ('quantilesExactLow', ''), 'quantilesBFloat16': ('quantilesBFloat16', ''), 'welchTTest': ('welchTTest', ''), 'quantileTDigest': ('quantileTDigest', ''), 'cramersV': ('cramersV', ''), 'entropy': ('entropy', ''), 'covarSamp': ('covarSamp', ''), 'maxIntersectionsPosition': ('maxIntersectionsPosition', ''), 'simpleLinearRegression': ('simpleLinearRegression', ''), 'argMax': ('argMax', ''), 'stochasticLogisticRegression': ('stochasticLogisticRegression', ''), 'quantileDeterministic': ('quantileDeterministic', ''), 'quantiles': ('quantiles', ''), 'corr': ('corr', ''), 'avgWeighted': ('avgWeighted', ''), 'uniqHLL12': ('uniqHLL12', ''), 'quantileExactHigh': ('quantileExactHigh', ''), 'sumWithOverflow': ('sumWithOverflow', ''), 'quantileExactWeighted': ('quantileExactWeighted', ''), 'uniq': ('uniq', ''), 'stochasticLinearRegression': ('stochasticLinearRegression', ''), 'deltaSum': ('deltaSum', ''), 'sum': ('sum', ''), 'histogram': ('histogram', ''), 'quantilesDeterministic': ('quantilesDeterministic', ''), 'groupBitOr': ('groupBitOr', ''), 'quantileTiming': ('quantileTiming', ''), 'sequenceNextNode': ('sequenceNextNode', ''), 'quantileTDigestWeighted': ('quantileTDigestWeighted', ''), 'rankCorr': ('rankCorr', ''), 'first_value': ('first_value', ''), 'sequenceCount': ('sequenceCount', ''), 'varSamp': ('varSamp', ''), 'uniqUpTo': ('uniqUpTo', ''), 'contingency': ('contingency', ''), 'anyHeavy': ('anyHeavy', ''), 'groupArrayLast': ('groupArrayLast', ''), 'exponentialTimeDecayedAvg': ('exponentialTimeDecayedAvg', ''), 'sequenceMatch': ('sequenceMatch', ''), 'varPop': ('varPop', ''), 'groupArrayMovingAvg': ('groupArrayMovingAvg', ''), 'uniqCombined': ('uniqCombined', ''), 'sumCount': ('sumCount', ''), 'quantileGK': ('quantileGK', ''), 'skewPop': ('skewPop', ''), 'groupBitAnd': ('groupBitAnd', ''), 'max': ('max', ''), 'intervalLengthSum': ('intervalLengthSum', ''), 'quantilesExactHigh': ('quantilesExactHigh', ''), 'quantilesBFloat16Weighted': ('quantilesBFloat16Weighted', ''), 'sumKahan': ('sumKahan', ''), 'median': ('median', ''), 'quantilesGK': ('quantilesGK', ''), 'avg': ('avg', ''), 'meanZTest': ('meanZTest', ''), 'retention': ('retention', ''), 'windowFunnel': ('windowFunnel', ''), 'kurtPop': ('kurtPop', ''), 'uniqCombined64': ('uniqCombined64', ''), 'groupUniqArray': ('groupUniqArray', ''), 'groupArrayMovingSum': ('groupArrayMovingSum', ''), 'groupArray': ('groupArray', ''), 'groupBitXor': ('groupBitXor', ''), 'quantileBFloat16': ('quantileBFloat16', ''), 'deltaSumTimestamp': ('deltaSumTimestamp', ''), 'skewSamp': ('skewSamp', ''), 'quantilesTDigest': ('quantilesTDigest', ''), 'any': ('any', ''), 'maxIntersections': ('maxIntersections', ''), 'sparkBar': ('sparkBar', ''), 'kolmogorovSmirnovTest': ('kolmogorovSmirnovTest', ''), 'groupArraySample': ('groupArraySample', ''), 'groupBitmap': ('groupBitmap', ''), 'categoricalInformationValue': ('categoricalInformationValue', ''), 'quantileInterpolatedWeighted': ('quantileInterpolatedWeighted', ''), 'quantilesTiming': ('quantilesTiming', ''), 'quantilesTDigestWeighted': ('quantilesTDigestWeighted', ''), 'groupBitmapAnd': ('groupBitmapAnd', ''), 'uniqExact': ('uniqExact', ''), 'quantilesExactWeighted': ('quantilesExactWeighted', ''), 'quantileBFloat16Weighted': ('quantileBFloat16Weighted', ''), 'argMin': ('argMin', ''), 'stddevPop': ('stddevPop', ''), 'exponentialMovingAverage': ('exponentialMovingAverage', ''), 'count': ('count', ''), 'mannWhitneyUTest': ('mannWhitneyUTest', ''), 'quantileExactLow': ('quantileExactLow', ''), 'quantilesExact': ('quantilesExact', ''), 'groupArrayInsertAt': ('groupArrayInsertAt', ''), 'anyLast': ('anyLast', ''), 'stddevSamp': ('stddevSamp', '')}
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.INNER: 'INNER'>, <TokenType.ANTI: 'ANTI'>, <TokenType.OUTER: 'OUTER'>, <TokenType.ANY: 'ANY'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.CROSS: 'CROSS'>, <TokenType.SEMI: 'SEMI'>, <TokenType.ASOF: 'ASOF'>}
TABLE_ALIAS_TOKENS = {<TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.SOME: 'SOME'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.BIT: 'BIT'>, <TokenType.JSONB: 'JSONB'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.RANGE: 'RANGE'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.USE: 'USE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.INT128: 'INT128'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.UINT256: 'UINT256'>, <TokenType.UINT: 'UINT'>, <TokenType.YEAR: 'YEAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.CASE: 'CASE'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.LOAD: 'LOAD'>, <TokenType.CHAR: 'CHAR'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.NAME: 'NAME'>, <TokenType.INDEX: 'INDEX'>, <TokenType.TOP: 'TOP'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.NULL: 'NULL'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.CACHE: 'CACHE'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.UINT128: 'UINT128'>, <TokenType.VAR: 'VAR'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.NEXT: 'NEXT'>, <TokenType.SHOW: 'SHOW'>, <TokenType.TIME: 'TIME'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.DESC: 'DESC'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.ALL: 'ALL'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.ROW: 'ROW'>, <TokenType.COPY: 'COPY'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.XML: 'XML'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.NESTED: 'NESTED'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.IPV4: 'IPV4'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.TEXT: 'TEXT'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.DATE: 'DATE'>, <TokenType.DIV: 'DIV'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.ROWS: 'ROWS'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.INT: 'INT'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.IPV6: 'IPV6'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.DATE32: 'DATE32'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.DELETE: 'DELETE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.INT256: 'INT256'>, <TokenType.SET: 'SET'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.JSON: 'JSON'>, <TokenType.FIRST: 'FIRST'>, <TokenType.ASC: 'ASC'>, <TokenType.BINARY: 'BINARY'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.MERGE: 'MERGE'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.KILL: 'KILL'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.TABLE: 'TABLE'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.KEEP: 'KEEP'>, <TokenType.SUPER: 'SUPER'>, <TokenType.IS: 'IS'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.INET: 'INET'>, <TokenType.END: 'END'>, <TokenType.TRUE: 'TRUE'>, <TokenType.FALSE: 'FALSE'>, <TokenType.MAP: 'MAP'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.VIEW: 'VIEW'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.MONEY: 'MONEY'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.BOOLEAN: 'BOOLEAN'>}
ALIAS_TOKENS = {<TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.SOME: 'SOME'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.BIT: 'BIT'>, <TokenType.ANY: 'ANY'>, <TokenType.JSONB: 'JSONB'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.LEFT: 'LEFT'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.RANGE: 'RANGE'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.FILTER: 'FILTER'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.INT128: 'INT128'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.UINT256: 'UINT256'>, <TokenType.UINT: 'UINT'>, <TokenType.YEAR: 'YEAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.CASE: 'CASE'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.FULL: 'FULL'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.LOAD: 'LOAD'>, <TokenType.CHAR: 'CHAR'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.ANTI: 'ANTI'>, <TokenType.MONEY: 'MONEY'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.NAME: 'NAME'>, <TokenType.INDEX: 'INDEX'>, <TokenType.TOP: 'TOP'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.NULL: 'NULL'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.APPLY: 'APPLY'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.CACHE: 'CACHE'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.UINT128: 'UINT128'>, <TokenType.VAR: 'VAR'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.NEXT: 'NEXT'>, <TokenType.SHOW: 'SHOW'>, <TokenType.TIME: 'TIME'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.DESC: 'DESC'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.ALL: 'ALL'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.ROW: 'ROW'>, <TokenType.COPY: 'COPY'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.FINAL: 'FINAL'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.XML: 'XML'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.NESTED: 'NESTED'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.IPV4: 'IPV4'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.TEXT: 'TEXT'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.DATE: 'DATE'>, <TokenType.DIV: 'DIV'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.ROWS: 'ROWS'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.INT: 'INT'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.IPV6: 'IPV6'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.DATE32: 'DATE32'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.DELETE: 'DELETE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.INT256: 'INT256'>, <TokenType.SET: 'SET'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.JSON: 'JSON'>, <TokenType.FIRST: 'FIRST'>, <TokenType.BINARY: 'BINARY'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.MERGE: 'MERGE'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.KILL: 'KILL'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.TABLE: 'TABLE'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.ASOF: 'ASOF'>, <TokenType.KEEP: 'KEEP'>, <TokenType.SUPER: 'SUPER'>, <TokenType.IS: 'IS'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.INET: 'INET'>, <TokenType.END: 'END'>, <TokenType.TRUE: 'TRUE'>, <TokenType.FALSE: 'FALSE'>, <TokenType.MAP: 'MAP'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.SEMI: 'SEMI'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.VIEW: 'VIEW'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.USE: 'USE'>, <TokenType.ASC: 'ASC'>, <TokenType.BOOLEAN: 'BOOLEAN'>}
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>>}
SCHEMA_UNNAMED_CONSTRAINTS = {'INDEX', 'PERIOD', 'EXCLUDE', 'LIKE', 'PRIMARY KEY', 'FOREIGN KEY', 'UNIQUE', 'CHECK'}
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_PARSERS
INVALID_FUNC_NAME_TOKENS
KEY_VALUE_DEFINITIONS
SET_PARSERS
SHOW_PARSERS
TYPE_LITERAL_PARSERS
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
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):
582    class Generator(generator.Generator):
583        QUERY_HINTS = False
584        STRUCT_DELIMITER = ("(", ")")
585        NVL2_SUPPORTED = False
586        TABLESAMPLE_REQUIRES_PARENS = False
587        TABLESAMPLE_SIZE_IS_ROWS = False
588        TABLESAMPLE_KEYWORDS = "SAMPLE"
589        LAST_DAY_SUPPORTS_DATE_PART = False
590        CAN_IMPLEMENT_ARRAY_ANY = True
591        SUPPORTS_TO_NUMBER = False
592
593        STRING_TYPE_MAPPING = {
594            exp.DataType.Type.CHAR: "String",
595            exp.DataType.Type.LONGBLOB: "String",
596            exp.DataType.Type.LONGTEXT: "String",
597            exp.DataType.Type.MEDIUMBLOB: "String",
598            exp.DataType.Type.MEDIUMTEXT: "String",
599            exp.DataType.Type.TINYBLOB: "String",
600            exp.DataType.Type.TINYTEXT: "String",
601            exp.DataType.Type.TEXT: "String",
602            exp.DataType.Type.VARBINARY: "String",
603            exp.DataType.Type.VARCHAR: "String",
604        }
605
606        SUPPORTED_JSON_PATH_PARTS = {
607            exp.JSONPathKey,
608            exp.JSONPathRoot,
609            exp.JSONPathSubscript,
610        }
611
612        TYPE_MAPPING = {
613            **generator.Generator.TYPE_MAPPING,
614            **STRING_TYPE_MAPPING,
615            exp.DataType.Type.ARRAY: "Array",
616            exp.DataType.Type.BIGINT: "Int64",
617            exp.DataType.Type.DATE32: "Date32",
618            exp.DataType.Type.DATETIME64: "DateTime64",
619            exp.DataType.Type.DOUBLE: "Float64",
620            exp.DataType.Type.ENUM: "Enum",
621            exp.DataType.Type.ENUM8: "Enum8",
622            exp.DataType.Type.ENUM16: "Enum16",
623            exp.DataType.Type.FIXEDSTRING: "FixedString",
624            exp.DataType.Type.FLOAT: "Float32",
625            exp.DataType.Type.INT: "Int32",
626            exp.DataType.Type.MEDIUMINT: "Int32",
627            exp.DataType.Type.INT128: "Int128",
628            exp.DataType.Type.INT256: "Int256",
629            exp.DataType.Type.LOWCARDINALITY: "LowCardinality",
630            exp.DataType.Type.MAP: "Map",
631            exp.DataType.Type.NESTED: "Nested",
632            exp.DataType.Type.NULLABLE: "Nullable",
633            exp.DataType.Type.SMALLINT: "Int16",
634            exp.DataType.Type.STRUCT: "Tuple",
635            exp.DataType.Type.TINYINT: "Int8",
636            exp.DataType.Type.UBIGINT: "UInt64",
637            exp.DataType.Type.UINT: "UInt32",
638            exp.DataType.Type.UINT128: "UInt128",
639            exp.DataType.Type.UINT256: "UInt256",
640            exp.DataType.Type.USMALLINT: "UInt16",
641            exp.DataType.Type.UTINYINT: "UInt8",
642            exp.DataType.Type.IPV4: "IPv4",
643            exp.DataType.Type.IPV6: "IPv6",
644            exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction",
645            exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction",
646        }
647
648        TRANSFORMS = {
649            **generator.Generator.TRANSFORMS,
650            exp.AnyValue: rename_func("any"),
651            exp.ApproxDistinct: rename_func("uniq"),
652            exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this),
653            exp.ArraySize: rename_func("LENGTH"),
654            exp.ArraySum: rename_func("arraySum"),
655            exp.ArgMax: arg_max_or_min_no_count("argMax"),
656            exp.ArgMin: arg_max_or_min_no_count("argMin"),
657            exp.Array: inline_array_sql,
658            exp.CastToStrType: rename_func("CAST"),
659            exp.CountIf: rename_func("countIf"),
660            exp.CompressColumnConstraint: lambda self,
661            e: f"CODEC({self.expressions(e, key='this', flat=True)})",
662            exp.ComputedColumnConstraint: lambda self,
663            e: f"{'MATERIALIZED' if e.args.get('persisted') else 'ALIAS'} {self.sql(e, 'this')}",
664            exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"),
665            exp.DateAdd: date_delta_sql("DATE_ADD"),
666            exp.DateDiff: date_delta_sql("DATE_DIFF"),
667            exp.Explode: rename_func("arrayJoin"),
668            exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL",
669            exp.IsNan: rename_func("isNaN"),
670            exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False),
671            exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False),
672            exp.JSONPathKey: json_path_key_only_name,
673            exp.JSONPathRoot: lambda *_: "",
674            exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)),
675            exp.Nullif: rename_func("nullIf"),
676            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
677            exp.Pivot: no_pivot_sql,
678            exp.Quantile: _quantile_sql,
679            exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression),
680            exp.Rand: rename_func("randCanonical"),
681            exp.Select: transforms.preprocess([transforms.eliminate_qualify]),
682            exp.StartsWith: rename_func("startsWith"),
683            exp.StrPosition: lambda self, e: self.func(
684                "position", e.this, e.args.get("substr"), e.args.get("position")
685            ),
686            exp.TimeToStr: lambda self, e: self.func(
687                "DATE_FORMAT", e.this, self.format_time(e), e.args.get("timezone")
688            ),
689            exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)),
690            exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions),
691        }
692
693        PROPERTIES_LOCATION = {
694            **generator.Generator.PROPERTIES_LOCATION,
695            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
696            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
697            exp.OnCluster: exp.Properties.Location.POST_NAME,
698        }
699
700        JOIN_HINTS = False
701        TABLE_HINTS = False
702        EXPLICIT_UNION = True
703        GROUPINGS_SEP = ""
704        OUTER_UNION_MODIFIERS = False
705
706        # there's no list in docs, but it can be found in Clickhouse code
707        # see `ClickHouse/src/Parsers/ParserCreate*.cpp`
708        ON_CLUSTER_TARGETS = {
709            "DATABASE",
710            "TABLE",
711            "VIEW",
712            "DICTIONARY",
713            "INDEX",
714            "FUNCTION",
715            "NAMED COLLECTION",
716        }
717
718        def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str:
719            this = self.json_path_part(expression.this)
720            return str(int(this) + 1) if is_int(this) else this
721
722        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
723            return f"AS {self.sql(expression, 'this')}"
724
725        def _any_to_has(
726            self,
727            expression: exp.EQ | exp.NEQ,
728            default: t.Callable[[t.Any], str],
729            prefix: str = "",
730        ) -> str:
731            if isinstance(expression.left, exp.Any):
732                arr = expression.left
733                this = expression.right
734            elif isinstance(expression.right, exp.Any):
735                arr = expression.right
736                this = expression.left
737            else:
738                return default(expression)
739
740            return prefix + self.func("has", arr.this.unnest(), this)
741
742        def eq_sql(self, expression: exp.EQ) -> str:
743            return self._any_to_has(expression, super().eq_sql)
744
745        def neq_sql(self, expression: exp.NEQ) -> str:
746            return self._any_to_has(expression, super().neq_sql, "NOT ")
747
748        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
749            # Manually add a flag to make the search case-insensitive
750            regex = self.func("CONCAT", "'(?i)'", expression.expression)
751            return self.func("match", expression.this, regex)
752
753        def datatype_sql(self, expression: exp.DataType) -> str:
754            # String is the standard ClickHouse type, every other variant is just an alias.
755            # Additionally, any supplied length parameter will be ignored.
756            #
757            # https://clickhouse.com/docs/en/sql-reference/data-types/string
758            if expression.this in self.STRING_TYPE_MAPPING:
759                return "String"
760
761            return super().datatype_sql(expression)
762
763        def cte_sql(self, expression: exp.CTE) -> str:
764            if expression.args.get("scalar"):
765                this = self.sql(expression, "this")
766                alias = self.sql(expression, "alias")
767                return f"{this} AS {alias}"
768
769            return super().cte_sql(expression)
770
771        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
772            return super().after_limit_modifiers(expression) + [
773                (
774                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
775                    if expression.args.get("settings")
776                    else ""
777                ),
778                (
779                    self.seg("FORMAT ") + self.sql(expression, "format")
780                    if expression.args.get("format")
781                    else ""
782                ),
783            ]
784
785        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
786            params = self.expressions(expression, key="params", flat=True)
787            return self.func(expression.name, *expression.expressions) + f"({params})"
788
789        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
790            return self.func(expression.name, *expression.expressions)
791
792        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
793            return self.anonymousaggfunc_sql(expression)
794
795        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
796            return self.parameterizedagg_sql(expression)
797
798        def placeholder_sql(self, expression: exp.Placeholder) -> str:
799            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
800
801        def oncluster_sql(self, expression: exp.OnCluster) -> str:
802            return f"ON CLUSTER {self.sql(expression, 'this')}"
803
804        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
805            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
806                exp.Properties.Location.POST_NAME
807            ):
808                this_name = self.sql(expression.this, "this")
809                this_properties = " ".join(
810                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
811                )
812                this_schema = self.schema_columns_sql(expression.this)
813                return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}"
814
815            return super().createable_sql(expression, locations)
816
817        def prewhere_sql(self, expression: exp.PreWhere) -> str:
818            this = self.indent(self.sql(expression, "this"))
819            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
820
821        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
822            this = self.sql(expression, "this")
823            this = f" {this}" if this else ""
824            expr = self.sql(expression, "expression")
825            expr = f" {expr}" if expr else ""
826            index_type = self.sql(expression, "index_type")
827            index_type = f" TYPE {index_type}" if index_type else ""
828            granularity = self.sql(expression, "granularity")
829            granularity = f" GRANULARITY {granularity}" if granularity else ""
830
831            return f"INDEX{this}{expr}{index_type}{granularity}"

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.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>>}
PROPERTIES_LOCATION = {<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 = {'DICTIONARY', 'INDEX', 'TABLE', 'NAMED COLLECTION', 'DATABASE', 'VIEW', 'FUNCTION'}
def likeproperty_sql(self, expression: sqlglot.expressions.LikeProperty) -> str:
722        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
723            return f"AS {self.sql(expression, 'this')}"
def eq_sql(self, expression: sqlglot.expressions.EQ) -> str:
742        def eq_sql(self, expression: exp.EQ) -> str:
743            return self._any_to_has(expression, super().eq_sql)
def neq_sql(self, expression: sqlglot.expressions.NEQ) -> str:
745        def neq_sql(self, expression: exp.NEQ) -> str:
746            return self._any_to_has(expression, super().neq_sql, "NOT ")
def regexpilike_sql(self, expression: sqlglot.expressions.RegexpILike) -> str:
748        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
749            # Manually add a flag to make the search case-insensitive
750            regex = self.func("CONCAT", "'(?i)'", expression.expression)
751            return self.func("match", expression.this, regex)
def datatype_sql(self, expression: sqlglot.expressions.DataType) -> str:
753        def datatype_sql(self, expression: exp.DataType) -> str:
754            # String is the standard ClickHouse type, every other variant is just an alias.
755            # Additionally, any supplied length parameter will be ignored.
756            #
757            # https://clickhouse.com/docs/en/sql-reference/data-types/string
758            if expression.this in self.STRING_TYPE_MAPPING:
759                return "String"
760
761            return super().datatype_sql(expression)
def cte_sql(self, expression: sqlglot.expressions.CTE) -> str:
763        def cte_sql(self, expression: exp.CTE) -> str:
764            if expression.args.get("scalar"):
765                this = self.sql(expression, "this")
766                alias = self.sql(expression, "alias")
767                return f"{this} AS {alias}"
768
769            return super().cte_sql(expression)
def after_limit_modifiers(self, expression: sqlglot.expressions.Expression) -> List[str]:
771        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
772            return super().after_limit_modifiers(expression) + [
773                (
774                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
775                    if expression.args.get("settings")
776                    else ""
777                ),
778                (
779                    self.seg("FORMAT ") + self.sql(expression, "format")
780                    if expression.args.get("format")
781                    else ""
782                ),
783            ]
def parameterizedagg_sql(self, expression: sqlglot.expressions.ParameterizedAgg) -> str:
785        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
786            params = self.expressions(expression, key="params", flat=True)
787            return self.func(expression.name, *expression.expressions) + f"({params})"
def anonymousaggfunc_sql(self, expression: sqlglot.expressions.AnonymousAggFunc) -> str:
789        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
790            return self.func(expression.name, *expression.expressions)
def combinedaggfunc_sql(self, expression: sqlglot.expressions.CombinedAggFunc) -> str:
792        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
793            return self.anonymousaggfunc_sql(expression)
def combinedparameterizedagg_sql(self, expression: sqlglot.expressions.CombinedParameterizedAgg) -> str:
795        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
796            return self.parameterizedagg_sql(expression)
def placeholder_sql(self, expression: sqlglot.expressions.Placeholder) -> str:
798        def placeholder_sql(self, expression: exp.Placeholder) -> str:
799            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
def oncluster_sql(self, expression: sqlglot.expressions.OnCluster) -> str:
801        def oncluster_sql(self, expression: exp.OnCluster) -> str:
802            return f"ON CLUSTER {self.sql(expression, 'this')}"
def createable_sql( self, expression: sqlglot.expressions.Create, locations: DefaultDict) -> str:
804        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
805            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
806                exp.Properties.Location.POST_NAME
807            ):
808                this_name = self.sql(expression.this, "this")
809                this_properties = " ".join(
810                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
811                )
812                this_schema = self.schema_columns_sql(expression.this)
813                return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}"
814
815            return super().createable_sql(expression, locations)
def prewhere_sql(self, expression: sqlglot.expressions.PreWhere) -> str:
817        def prewhere_sql(self, expression: exp.PreWhere) -> str:
818            this = self.indent(self.sql(expression, "this"))
819            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
def indexcolumnconstraint_sql(self, expression: sqlglot.expressions.IndexColumnConstraint) -> str:
821        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
822            this = self.sql(expression, "this")
823            this = f" {this}" if this else ""
824            expr = self.sql(expression, "expression")
825            expr = f" {expr}" if expr else ""
826            index_type = self.sql(expression, "index_type")
827            index_type = f" TYPE {index_type}" if index_type else ""
828            granularity = self.sql(expression, "granularity")
829            granularity = f" GRANULARITY {granularity}" if granularity else ""
830
831            return f"INDEX{this}{expr}{index_type}{granularity}"
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_MAPPING
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
inputoutputformat_sql
national_sql
partition_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
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