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        }
258
259        AGG_FUNCTIONS_SUFFIXES = [
260            "If",
261            "Array",
262            "ArrayIf",
263            "Map",
264            "SimpleState",
265            "State",
266            "Merge",
267            "MergeState",
268            "ForEach",
269            "Distinct",
270            "OrDefault",
271            "OrNull",
272            "Resample",
273            "ArgMin",
274            "ArgMax",
275        ]
276
277        FUNC_TOKENS = {
278            *parser.Parser.FUNC_TOKENS,
279            TokenType.SET,
280        }
281
282        AGG_FUNC_MAPPING = (
283            lambda functions, suffixes: {
284                f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions
285            }
286        )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES)
287
288        FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"}
289
290        FUNCTION_PARSERS = {
291            **parser.Parser.FUNCTION_PARSERS,
292            "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()),
293            "QUANTILE": lambda self: self._parse_quantile(),
294        }
295
296        FUNCTION_PARSERS.pop("MATCH")
297
298        NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy()
299        NO_PAREN_FUNCTION_PARSERS.pop("ANY")
300
301        RANGE_PARSERS = {
302            **parser.Parser.RANGE_PARSERS,
303            TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN)
304            and self._parse_in(this, is_global=True),
305        }
306
307        # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to
308        # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler.
309        COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy()
310        COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
311
312        JOIN_KINDS = {
313            *parser.Parser.JOIN_KINDS,
314            TokenType.ANY,
315            TokenType.ASOF,
316            TokenType.ARRAY,
317        }
318
319        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
320            TokenType.ANY,
321            TokenType.ARRAY,
322            TokenType.FINAL,
323            TokenType.FORMAT,
324            TokenType.SETTINGS,
325        }
326
327        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
328            TokenType.FORMAT,
329        }
330
331        LOG_DEFAULTS_TO_LN = True
332
333        QUERY_MODIFIER_PARSERS = {
334            **parser.Parser.QUERY_MODIFIER_PARSERS,
335            TokenType.SETTINGS: lambda self: (
336                "settings",
337                self._advance() or self._parse_csv(self._parse_conjunction),
338            ),
339            TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
340        }
341
342        CONSTRAINT_PARSERS = {
343            **parser.Parser.CONSTRAINT_PARSERS,
344            "INDEX": lambda self: self._parse_index_constraint(),
345            "CODEC": lambda self: self._parse_compress(),
346        }
347
348        SCHEMA_UNNAMED_CONSTRAINTS = {
349            *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
350            "INDEX",
351        }
352
353        def _parse_conjunction(self) -> t.Optional[exp.Expression]:
354            this = super()._parse_conjunction()
355
356            if self._match(TokenType.PLACEHOLDER):
357                return self.expression(
358                    exp.If,
359                    this=this,
360                    true=self._parse_conjunction(),
361                    false=self._match(TokenType.COLON) and self._parse_conjunction(),
362                )
363
364            return this
365
366        def _parse_placeholder(self) -> t.Optional[exp.Expression]:
367            """
368            Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
369            https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
370            """
371            if not self._match(TokenType.L_BRACE):
372                return None
373
374            this = self._parse_id_var()
375            self._match(TokenType.COLON)
376            kind = self._parse_types(check_func=False, allow_identifiers=False) or (
377                self._match_text_seq("IDENTIFIER") and "Identifier"
378            )
379
380            if not kind:
381                self.raise_error("Expecting a placeholder type or 'Identifier' for tables")
382            elif not self._match(TokenType.R_BRACE):
383                self.raise_error("Expecting }")
384
385            return self.expression(exp.Placeholder, this=this, kind=kind)
386
387        def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In:
388            this = super()._parse_in(this)
389            this.set("is_global", is_global)
390            return this
391
392        def _parse_table(
393            self,
394            schema: bool = False,
395            joins: bool = False,
396            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
397            parse_bracket: bool = False,
398            is_db_reference: bool = False,
399            parse_partition: bool = False,
400        ) -> t.Optional[exp.Expression]:
401            this = super()._parse_table(
402                schema=schema,
403                joins=joins,
404                alias_tokens=alias_tokens,
405                parse_bracket=parse_bracket,
406                is_db_reference=is_db_reference,
407            )
408
409            if self._match(TokenType.FINAL):
410                this = self.expression(exp.Final, this=this)
411
412            return this
413
414        def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
415            return super()._parse_position(haystack_first=True)
416
417        # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
418        def _parse_cte(self) -> exp.CTE:
419            # WITH <identifier> AS <subquery expression>
420            cte: t.Optional[exp.CTE] = self._try_parse(super()._parse_cte)
421
422            if not cte:
423                # WITH <expression> AS <identifier>
424                cte = self.expression(
425                    exp.CTE,
426                    this=self._parse_conjunction(),
427                    alias=self._parse_table_alias(),
428                    scalar=True,
429                )
430
431            return cte
432
433        def _parse_join_parts(
434            self,
435        ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
436            is_global = self._match(TokenType.GLOBAL) and self._prev
437            kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev
438
439            if kind_pre:
440                kind = self._match_set(self.JOIN_KINDS) and self._prev
441                side = self._match_set(self.JOIN_SIDES) and self._prev
442                return is_global, side, kind
443
444            return (
445                is_global,
446                self._match_set(self.JOIN_SIDES) and self._prev,
447                self._match_set(self.JOIN_KINDS) and self._prev,
448            )
449
450        def _parse_join(
451            self, skip_join_token: bool = False, parse_bracket: bool = False
452        ) -> t.Optional[exp.Join]:
453            join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True)
454            if join:
455                join.set("global", join.args.pop("method", None))
456
457            return join
458
459        def _parse_function(
460            self,
461            functions: t.Optional[t.Dict[str, t.Callable]] = None,
462            anonymous: bool = False,
463            optional_parens: bool = True,
464            any_token: bool = False,
465        ) -> t.Optional[exp.Expression]:
466            func = super()._parse_function(
467                functions=functions,
468                anonymous=anonymous,
469                optional_parens=optional_parens,
470                any_token=any_token,
471            )
472
473            if isinstance(func, exp.Anonymous):
474                parts = self.AGG_FUNC_MAPPING.get(func.this)
475                params = self._parse_func_params(func)
476
477                if params:
478                    if parts and parts[1]:
479                        return self.expression(
480                            exp.CombinedParameterizedAgg,
481                            this=func.this,
482                            expressions=func.expressions,
483                            params=params,
484                            parts=parts,
485                        )
486                    return self.expression(
487                        exp.ParameterizedAgg,
488                        this=func.this,
489                        expressions=func.expressions,
490                        params=params,
491                    )
492
493                if parts:
494                    if parts[1]:
495                        return self.expression(
496                            exp.CombinedAggFunc,
497                            this=func.this,
498                            expressions=func.expressions,
499                            parts=parts,
500                        )
501                    return self.expression(
502                        exp.AnonymousAggFunc,
503                        this=func.this,
504                        expressions=func.expressions,
505                    )
506
507            return func
508
509        def _parse_func_params(
510            self, this: t.Optional[exp.Func] = None
511        ) -> t.Optional[t.List[exp.Expression]]:
512            if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
513                return self._parse_csv(self._parse_lambda)
514
515            if self._match(TokenType.L_PAREN):
516                params = self._parse_csv(self._parse_lambda)
517                self._match_r_paren(this)
518                return params
519
520            return None
521
522        def _parse_quantile(self) -> exp.Quantile:
523            this = self._parse_lambda()
524            params = self._parse_func_params()
525            if params:
526                return self.expression(exp.Quantile, this=params[0], quantile=this)
527            return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5))
528
529        def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
530            return super()._parse_wrapped_id_vars(optional=True)
531
532        def _parse_primary_key(
533            self, wrapped_optional: bool = False, in_props: bool = False
534        ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
535            return super()._parse_primary_key(
536                wrapped_optional=wrapped_optional or in_props, in_props=in_props
537            )
538
539        def _parse_on_property(self) -> t.Optional[exp.Expression]:
540            index = self._index
541            if self._match_text_seq("CLUSTER"):
542                this = self._parse_id_var()
543                if this:
544                    return self.expression(exp.OnCluster, this=this)
545                else:
546                    self._retreat(index)
547            return None
548
549        def _parse_index_constraint(
550            self, kind: t.Optional[str] = None
551        ) -> exp.IndexColumnConstraint:
552            # INDEX name1 expr TYPE type1(args) GRANULARITY value
553            this = self._parse_id_var()
554            expression = self._parse_conjunction()
555
556            index_type = self._match_text_seq("TYPE") and (
557                self._parse_function() or self._parse_var()
558            )
559
560            granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
561
562            return self.expression(
563                exp.IndexColumnConstraint,
564                this=this,
565                expression=expression,
566                index_type=index_type,
567                granularity=granularity,
568            )
569
570    class Generator(generator.Generator):
571        QUERY_HINTS = False
572        STRUCT_DELIMITER = ("(", ")")
573        NVL2_SUPPORTED = False
574        TABLESAMPLE_REQUIRES_PARENS = False
575        TABLESAMPLE_SIZE_IS_ROWS = False
576        TABLESAMPLE_KEYWORDS = "SAMPLE"
577        LAST_DAY_SUPPORTS_DATE_PART = False
578        CAN_IMPLEMENT_ARRAY_ANY = True
579        SUPPORTS_TO_NUMBER = False
580
581        STRING_TYPE_MAPPING = {
582            exp.DataType.Type.CHAR: "String",
583            exp.DataType.Type.LONGBLOB: "String",
584            exp.DataType.Type.LONGTEXT: "String",
585            exp.DataType.Type.MEDIUMBLOB: "String",
586            exp.DataType.Type.MEDIUMTEXT: "String",
587            exp.DataType.Type.TINYBLOB: "String",
588            exp.DataType.Type.TINYTEXT: "String",
589            exp.DataType.Type.TEXT: "String",
590            exp.DataType.Type.VARBINARY: "String",
591            exp.DataType.Type.VARCHAR: "String",
592        }
593
594        SUPPORTED_JSON_PATH_PARTS = {
595            exp.JSONPathKey,
596            exp.JSONPathRoot,
597            exp.JSONPathSubscript,
598        }
599
600        TYPE_MAPPING = {
601            **generator.Generator.TYPE_MAPPING,
602            **STRING_TYPE_MAPPING,
603            exp.DataType.Type.ARRAY: "Array",
604            exp.DataType.Type.BIGINT: "Int64",
605            exp.DataType.Type.DATE32: "Date32",
606            exp.DataType.Type.DATETIME64: "DateTime64",
607            exp.DataType.Type.DOUBLE: "Float64",
608            exp.DataType.Type.ENUM: "Enum",
609            exp.DataType.Type.ENUM8: "Enum8",
610            exp.DataType.Type.ENUM16: "Enum16",
611            exp.DataType.Type.FIXEDSTRING: "FixedString",
612            exp.DataType.Type.FLOAT: "Float32",
613            exp.DataType.Type.INT: "Int32",
614            exp.DataType.Type.MEDIUMINT: "Int32",
615            exp.DataType.Type.INT128: "Int128",
616            exp.DataType.Type.INT256: "Int256",
617            exp.DataType.Type.LOWCARDINALITY: "LowCardinality",
618            exp.DataType.Type.MAP: "Map",
619            exp.DataType.Type.NESTED: "Nested",
620            exp.DataType.Type.NULLABLE: "Nullable",
621            exp.DataType.Type.SMALLINT: "Int16",
622            exp.DataType.Type.STRUCT: "Tuple",
623            exp.DataType.Type.TINYINT: "Int8",
624            exp.DataType.Type.UBIGINT: "UInt64",
625            exp.DataType.Type.UINT: "UInt32",
626            exp.DataType.Type.UINT128: "UInt128",
627            exp.DataType.Type.UINT256: "UInt256",
628            exp.DataType.Type.USMALLINT: "UInt16",
629            exp.DataType.Type.UTINYINT: "UInt8",
630            exp.DataType.Type.IPV4: "IPv4",
631            exp.DataType.Type.IPV6: "IPv6",
632            exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction",
633            exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction",
634        }
635
636        TRANSFORMS = {
637            **generator.Generator.TRANSFORMS,
638            exp.AnyValue: rename_func("any"),
639            exp.ApproxDistinct: rename_func("uniq"),
640            exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this),
641            exp.ArraySize: rename_func("LENGTH"),
642            exp.ArraySum: rename_func("arraySum"),
643            exp.ArgMax: arg_max_or_min_no_count("argMax"),
644            exp.ArgMin: arg_max_or_min_no_count("argMin"),
645            exp.Array: inline_array_sql,
646            exp.CastToStrType: rename_func("CAST"),
647            exp.CountIf: rename_func("countIf"),
648            exp.CompressColumnConstraint: lambda self,
649            e: f"CODEC({self.expressions(e, key='this', flat=True)})",
650            exp.ComputedColumnConstraint: lambda self,
651            e: f"{'MATERIALIZED' if e.args.get('persisted') else 'ALIAS'} {self.sql(e, 'this')}",
652            exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"),
653            exp.DateAdd: date_delta_sql("DATE_ADD"),
654            exp.DateDiff: date_delta_sql("DATE_DIFF"),
655            exp.Explode: rename_func("arrayJoin"),
656            exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL",
657            exp.IsNan: rename_func("isNaN"),
658            exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False),
659            exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False),
660            exp.JSONPathKey: json_path_key_only_name,
661            exp.JSONPathRoot: lambda *_: "",
662            exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)),
663            exp.Nullif: rename_func("nullIf"),
664            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
665            exp.Pivot: no_pivot_sql,
666            exp.Quantile: _quantile_sql,
667            exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression),
668            exp.Rand: rename_func("randCanonical"),
669            exp.Select: transforms.preprocess([transforms.eliminate_qualify]),
670            exp.StartsWith: rename_func("startsWith"),
671            exp.StrPosition: lambda self, e: self.func(
672                "position", e.this, e.args.get("substr"), e.args.get("position")
673            ),
674            exp.TimeToStr: lambda self, e: self.func(
675                "DATE_FORMAT", e.this, self.format_time(e), e.args.get("timezone")
676            ),
677            exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)),
678            exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions),
679        }
680
681        PROPERTIES_LOCATION = {
682            **generator.Generator.PROPERTIES_LOCATION,
683            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
684            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
685            exp.OnCluster: exp.Properties.Location.POST_NAME,
686        }
687
688        JOIN_HINTS = False
689        TABLE_HINTS = False
690        EXPLICIT_UNION = True
691        GROUPINGS_SEP = ""
692        OUTER_UNION_MODIFIERS = False
693
694        # there's no list in docs, but it can be found in Clickhouse code
695        # see `ClickHouse/src/Parsers/ParserCreate*.cpp`
696        ON_CLUSTER_TARGETS = {
697            "DATABASE",
698            "TABLE",
699            "VIEW",
700            "DICTIONARY",
701            "INDEX",
702            "FUNCTION",
703            "NAMED COLLECTION",
704        }
705
706        def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str:
707            this = self.json_path_part(expression.this)
708            return str(int(this) + 1) if is_int(this) else this
709
710        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
711            return f"AS {self.sql(expression, 'this')}"
712
713        def _any_to_has(
714            self,
715            expression: exp.EQ | exp.NEQ,
716            default: t.Callable[[t.Any], str],
717            prefix: str = "",
718        ) -> str:
719            if isinstance(expression.left, exp.Any):
720                arr = expression.left
721                this = expression.right
722            elif isinstance(expression.right, exp.Any):
723                arr = expression.right
724                this = expression.left
725            else:
726                return default(expression)
727
728            return prefix + self.func("has", arr.this.unnest(), this)
729
730        def eq_sql(self, expression: exp.EQ) -> str:
731            return self._any_to_has(expression, super().eq_sql)
732
733        def neq_sql(self, expression: exp.NEQ) -> str:
734            return self._any_to_has(expression, super().neq_sql, "NOT ")
735
736        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
737            # Manually add a flag to make the search case-insensitive
738            regex = self.func("CONCAT", "'(?i)'", expression.expression)
739            return self.func("match", expression.this, regex)
740
741        def datatype_sql(self, expression: exp.DataType) -> str:
742            # String is the standard ClickHouse type, every other variant is just an alias.
743            # Additionally, any supplied length parameter will be ignored.
744            #
745            # https://clickhouse.com/docs/en/sql-reference/data-types/string
746            if expression.this in self.STRING_TYPE_MAPPING:
747                return "String"
748
749            return super().datatype_sql(expression)
750
751        def cte_sql(self, expression: exp.CTE) -> str:
752            if expression.args.get("scalar"):
753                this = self.sql(expression, "this")
754                alias = self.sql(expression, "alias")
755                return f"{this} AS {alias}"
756
757            return super().cte_sql(expression)
758
759        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
760            return super().after_limit_modifiers(expression) + [
761                (
762                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
763                    if expression.args.get("settings")
764                    else ""
765                ),
766                (
767                    self.seg("FORMAT ") + self.sql(expression, "format")
768                    if expression.args.get("format")
769                    else ""
770                ),
771            ]
772
773        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
774            params = self.expressions(expression, key="params", flat=True)
775            return self.func(expression.name, *expression.expressions) + f"({params})"
776
777        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
778            return self.func(expression.name, *expression.expressions)
779
780        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
781            return self.anonymousaggfunc_sql(expression)
782
783        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
784            return self.parameterizedagg_sql(expression)
785
786        def placeholder_sql(self, expression: exp.Placeholder) -> str:
787            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
788
789        def oncluster_sql(self, expression: exp.OnCluster) -> str:
790            return f"ON CLUSTER {self.sql(expression, 'this')}"
791
792        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
793            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
794                exp.Properties.Location.POST_NAME
795            ):
796                this_name = self.sql(expression.this, "this")
797                this_properties = " ".join(
798                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
799                )
800                this_schema = self.schema_columns_sql(expression.this)
801                return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}"
802
803            return super().createable_sql(expression, locations)
804
805        def prewhere_sql(self, expression: exp.PreWhere) -> str:
806            this = self.indent(self.sql(expression, "this"))
807            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
808
809        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
810            this = self.sql(expression, "this")
811            this = f" {this}" if this else ""
812            expr = self.sql(expression, "expression")
813            expr = f" {expr}" if expr else ""
814            index_type = self.sql(expression, "index_type")
815            index_type = f" TYPE {index_type}" if index_type else ""
816            granularity = self.sql(expression, "granularity")
817            granularity = f" GRANULARITY {granularity}" if granularity else ""
818
819            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        }
259
260        AGG_FUNCTIONS_SUFFIXES = [
261            "If",
262            "Array",
263            "ArrayIf",
264            "Map",
265            "SimpleState",
266            "State",
267            "Merge",
268            "MergeState",
269            "ForEach",
270            "Distinct",
271            "OrDefault",
272            "OrNull",
273            "Resample",
274            "ArgMin",
275            "ArgMax",
276        ]
277
278        FUNC_TOKENS = {
279            *parser.Parser.FUNC_TOKENS,
280            TokenType.SET,
281        }
282
283        AGG_FUNC_MAPPING = (
284            lambda functions, suffixes: {
285                f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions
286            }
287        )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES)
288
289        FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"}
290
291        FUNCTION_PARSERS = {
292            **parser.Parser.FUNCTION_PARSERS,
293            "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()),
294            "QUANTILE": lambda self: self._parse_quantile(),
295        }
296
297        FUNCTION_PARSERS.pop("MATCH")
298
299        NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy()
300        NO_PAREN_FUNCTION_PARSERS.pop("ANY")
301
302        RANGE_PARSERS = {
303            **parser.Parser.RANGE_PARSERS,
304            TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN)
305            and self._parse_in(this, is_global=True),
306        }
307
308        # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to
309        # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler.
310        COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy()
311        COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
312
313        JOIN_KINDS = {
314            *parser.Parser.JOIN_KINDS,
315            TokenType.ANY,
316            TokenType.ASOF,
317            TokenType.ARRAY,
318        }
319
320        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
321            TokenType.ANY,
322            TokenType.ARRAY,
323            TokenType.FINAL,
324            TokenType.FORMAT,
325            TokenType.SETTINGS,
326        }
327
328        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
329            TokenType.FORMAT,
330        }
331
332        LOG_DEFAULTS_TO_LN = True
333
334        QUERY_MODIFIER_PARSERS = {
335            **parser.Parser.QUERY_MODIFIER_PARSERS,
336            TokenType.SETTINGS: lambda self: (
337                "settings",
338                self._advance() or self._parse_csv(self._parse_conjunction),
339            ),
340            TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
341        }
342
343        CONSTRAINT_PARSERS = {
344            **parser.Parser.CONSTRAINT_PARSERS,
345            "INDEX": lambda self: self._parse_index_constraint(),
346            "CODEC": lambda self: self._parse_compress(),
347        }
348
349        SCHEMA_UNNAMED_CONSTRAINTS = {
350            *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
351            "INDEX",
352        }
353
354        def _parse_conjunction(self) -> t.Optional[exp.Expression]:
355            this = super()._parse_conjunction()
356
357            if self._match(TokenType.PLACEHOLDER):
358                return self.expression(
359                    exp.If,
360                    this=this,
361                    true=self._parse_conjunction(),
362                    false=self._match(TokenType.COLON) and self._parse_conjunction(),
363                )
364
365            return this
366
367        def _parse_placeholder(self) -> t.Optional[exp.Expression]:
368            """
369            Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
370            https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
371            """
372            if not self._match(TokenType.L_BRACE):
373                return None
374
375            this = self._parse_id_var()
376            self._match(TokenType.COLON)
377            kind = self._parse_types(check_func=False, allow_identifiers=False) or (
378                self._match_text_seq("IDENTIFIER") and "Identifier"
379            )
380
381            if not kind:
382                self.raise_error("Expecting a placeholder type or 'Identifier' for tables")
383            elif not self._match(TokenType.R_BRACE):
384                self.raise_error("Expecting }")
385
386            return self.expression(exp.Placeholder, this=this, kind=kind)
387
388        def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In:
389            this = super()._parse_in(this)
390            this.set("is_global", is_global)
391            return this
392
393        def _parse_table(
394            self,
395            schema: bool = False,
396            joins: bool = False,
397            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
398            parse_bracket: bool = False,
399            is_db_reference: bool = False,
400            parse_partition: bool = False,
401        ) -> t.Optional[exp.Expression]:
402            this = super()._parse_table(
403                schema=schema,
404                joins=joins,
405                alias_tokens=alias_tokens,
406                parse_bracket=parse_bracket,
407                is_db_reference=is_db_reference,
408            )
409
410            if self._match(TokenType.FINAL):
411                this = self.expression(exp.Final, this=this)
412
413            return this
414
415        def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
416            return super()._parse_position(haystack_first=True)
417
418        # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
419        def _parse_cte(self) -> exp.CTE:
420            # WITH <identifier> AS <subquery expression>
421            cte: t.Optional[exp.CTE] = self._try_parse(super()._parse_cte)
422
423            if not cte:
424                # WITH <expression> AS <identifier>
425                cte = self.expression(
426                    exp.CTE,
427                    this=self._parse_conjunction(),
428                    alias=self._parse_table_alias(),
429                    scalar=True,
430                )
431
432            return cte
433
434        def _parse_join_parts(
435            self,
436        ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
437            is_global = self._match(TokenType.GLOBAL) and self._prev
438            kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev
439
440            if kind_pre:
441                kind = self._match_set(self.JOIN_KINDS) and self._prev
442                side = self._match_set(self.JOIN_SIDES) and self._prev
443                return is_global, side, kind
444
445            return (
446                is_global,
447                self._match_set(self.JOIN_SIDES) and self._prev,
448                self._match_set(self.JOIN_KINDS) and self._prev,
449            )
450
451        def _parse_join(
452            self, skip_join_token: bool = False, parse_bracket: bool = False
453        ) -> t.Optional[exp.Join]:
454            join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True)
455            if join:
456                join.set("global", join.args.pop("method", None))
457
458            return join
459
460        def _parse_function(
461            self,
462            functions: t.Optional[t.Dict[str, t.Callable]] = None,
463            anonymous: bool = False,
464            optional_parens: bool = True,
465            any_token: bool = False,
466        ) -> t.Optional[exp.Expression]:
467            func = super()._parse_function(
468                functions=functions,
469                anonymous=anonymous,
470                optional_parens=optional_parens,
471                any_token=any_token,
472            )
473
474            if isinstance(func, exp.Anonymous):
475                parts = self.AGG_FUNC_MAPPING.get(func.this)
476                params = self._parse_func_params(func)
477
478                if params:
479                    if parts and parts[1]:
480                        return self.expression(
481                            exp.CombinedParameterizedAgg,
482                            this=func.this,
483                            expressions=func.expressions,
484                            params=params,
485                            parts=parts,
486                        )
487                    return self.expression(
488                        exp.ParameterizedAgg,
489                        this=func.this,
490                        expressions=func.expressions,
491                        params=params,
492                    )
493
494                if parts:
495                    if parts[1]:
496                        return self.expression(
497                            exp.CombinedAggFunc,
498                            this=func.this,
499                            expressions=func.expressions,
500                            parts=parts,
501                        )
502                    return self.expression(
503                        exp.AnonymousAggFunc,
504                        this=func.this,
505                        expressions=func.expressions,
506                    )
507
508            return func
509
510        def _parse_func_params(
511            self, this: t.Optional[exp.Func] = None
512        ) -> t.Optional[t.List[exp.Expression]]:
513            if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
514                return self._parse_csv(self._parse_lambda)
515
516            if self._match(TokenType.L_PAREN):
517                params = self._parse_csv(self._parse_lambda)
518                self._match_r_paren(this)
519                return params
520
521            return None
522
523        def _parse_quantile(self) -> exp.Quantile:
524            this = self._parse_lambda()
525            params = self._parse_func_params()
526            if params:
527                return self.expression(exp.Quantile, this=params[0], quantile=this)
528            return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5))
529
530        def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
531            return super()._parse_wrapped_id_vars(optional=True)
532
533        def _parse_primary_key(
534            self, wrapped_optional: bool = False, in_props: bool = False
535        ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
536            return super()._parse_primary_key(
537                wrapped_optional=wrapped_optional or in_props, in_props=in_props
538            )
539
540        def _parse_on_property(self) -> t.Optional[exp.Expression]:
541            index = self._index
542            if self._match_text_seq("CLUSTER"):
543                this = self._parse_id_var()
544                if this:
545                    return self.expression(exp.OnCluster, this=this)
546                else:
547                    self._retreat(index)
548            return None
549
550        def _parse_index_constraint(
551            self, kind: t.Optional[str] = None
552        ) -> exp.IndexColumnConstraint:
553            # INDEX name1 expr TYPE type1(args) GRANULARITY value
554            this = self._parse_id_var()
555            expression = self._parse_conjunction()
556
557            index_type = self._match_text_seq("TYPE") and (
558                self._parse_function() or self._parse_var()
559            )
560
561            granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
562
563            return self.expression(
564                exp.IndexColumnConstraint,
565                this=this,
566                expression=expression,
567                index_type=index_type,
568                granularity=granularity,
569            )
570
571    class Generator(generator.Generator):
572        QUERY_HINTS = False
573        STRUCT_DELIMITER = ("(", ")")
574        NVL2_SUPPORTED = False
575        TABLESAMPLE_REQUIRES_PARENS = False
576        TABLESAMPLE_SIZE_IS_ROWS = False
577        TABLESAMPLE_KEYWORDS = "SAMPLE"
578        LAST_DAY_SUPPORTS_DATE_PART = False
579        CAN_IMPLEMENT_ARRAY_ANY = True
580        SUPPORTS_TO_NUMBER = False
581
582        STRING_TYPE_MAPPING = {
583            exp.DataType.Type.CHAR: "String",
584            exp.DataType.Type.LONGBLOB: "String",
585            exp.DataType.Type.LONGTEXT: "String",
586            exp.DataType.Type.MEDIUMBLOB: "String",
587            exp.DataType.Type.MEDIUMTEXT: "String",
588            exp.DataType.Type.TINYBLOB: "String",
589            exp.DataType.Type.TINYTEXT: "String",
590            exp.DataType.Type.TEXT: "String",
591            exp.DataType.Type.VARBINARY: "String",
592            exp.DataType.Type.VARCHAR: "String",
593        }
594
595        SUPPORTED_JSON_PATH_PARTS = {
596            exp.JSONPathKey,
597            exp.JSONPathRoot,
598            exp.JSONPathSubscript,
599        }
600
601        TYPE_MAPPING = {
602            **generator.Generator.TYPE_MAPPING,
603            **STRING_TYPE_MAPPING,
604            exp.DataType.Type.ARRAY: "Array",
605            exp.DataType.Type.BIGINT: "Int64",
606            exp.DataType.Type.DATE32: "Date32",
607            exp.DataType.Type.DATETIME64: "DateTime64",
608            exp.DataType.Type.DOUBLE: "Float64",
609            exp.DataType.Type.ENUM: "Enum",
610            exp.DataType.Type.ENUM8: "Enum8",
611            exp.DataType.Type.ENUM16: "Enum16",
612            exp.DataType.Type.FIXEDSTRING: "FixedString",
613            exp.DataType.Type.FLOAT: "Float32",
614            exp.DataType.Type.INT: "Int32",
615            exp.DataType.Type.MEDIUMINT: "Int32",
616            exp.DataType.Type.INT128: "Int128",
617            exp.DataType.Type.INT256: "Int256",
618            exp.DataType.Type.LOWCARDINALITY: "LowCardinality",
619            exp.DataType.Type.MAP: "Map",
620            exp.DataType.Type.NESTED: "Nested",
621            exp.DataType.Type.NULLABLE: "Nullable",
622            exp.DataType.Type.SMALLINT: "Int16",
623            exp.DataType.Type.STRUCT: "Tuple",
624            exp.DataType.Type.TINYINT: "Int8",
625            exp.DataType.Type.UBIGINT: "UInt64",
626            exp.DataType.Type.UINT: "UInt32",
627            exp.DataType.Type.UINT128: "UInt128",
628            exp.DataType.Type.UINT256: "UInt256",
629            exp.DataType.Type.USMALLINT: "UInt16",
630            exp.DataType.Type.UTINYINT: "UInt8",
631            exp.DataType.Type.IPV4: "IPv4",
632            exp.DataType.Type.IPV6: "IPv6",
633            exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction",
634            exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction",
635        }
636
637        TRANSFORMS = {
638            **generator.Generator.TRANSFORMS,
639            exp.AnyValue: rename_func("any"),
640            exp.ApproxDistinct: rename_func("uniq"),
641            exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this),
642            exp.ArraySize: rename_func("LENGTH"),
643            exp.ArraySum: rename_func("arraySum"),
644            exp.ArgMax: arg_max_or_min_no_count("argMax"),
645            exp.ArgMin: arg_max_or_min_no_count("argMin"),
646            exp.Array: inline_array_sql,
647            exp.CastToStrType: rename_func("CAST"),
648            exp.CountIf: rename_func("countIf"),
649            exp.CompressColumnConstraint: lambda self,
650            e: f"CODEC({self.expressions(e, key='this', flat=True)})",
651            exp.ComputedColumnConstraint: lambda self,
652            e: f"{'MATERIALIZED' if e.args.get('persisted') else 'ALIAS'} {self.sql(e, 'this')}",
653            exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"),
654            exp.DateAdd: date_delta_sql("DATE_ADD"),
655            exp.DateDiff: date_delta_sql("DATE_DIFF"),
656            exp.Explode: rename_func("arrayJoin"),
657            exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL",
658            exp.IsNan: rename_func("isNaN"),
659            exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False),
660            exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False),
661            exp.JSONPathKey: json_path_key_only_name,
662            exp.JSONPathRoot: lambda *_: "",
663            exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)),
664            exp.Nullif: rename_func("nullIf"),
665            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
666            exp.Pivot: no_pivot_sql,
667            exp.Quantile: _quantile_sql,
668            exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression),
669            exp.Rand: rename_func("randCanonical"),
670            exp.Select: transforms.preprocess([transforms.eliminate_qualify]),
671            exp.StartsWith: rename_func("startsWith"),
672            exp.StrPosition: lambda self, e: self.func(
673                "position", e.this, e.args.get("substr"), e.args.get("position")
674            ),
675            exp.TimeToStr: lambda self, e: self.func(
676                "DATE_FORMAT", e.this, self.format_time(e), e.args.get("timezone")
677            ),
678            exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)),
679            exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions),
680        }
681
682        PROPERTIES_LOCATION = {
683            **generator.Generator.PROPERTIES_LOCATION,
684            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
685            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
686            exp.OnCluster: exp.Properties.Location.POST_NAME,
687        }
688
689        JOIN_HINTS = False
690        TABLE_HINTS = False
691        EXPLICIT_UNION = True
692        GROUPINGS_SEP = ""
693        OUTER_UNION_MODIFIERS = False
694
695        # there's no list in docs, but it can be found in Clickhouse code
696        # see `ClickHouse/src/Parsers/ParserCreate*.cpp`
697        ON_CLUSTER_TARGETS = {
698            "DATABASE",
699            "TABLE",
700            "VIEW",
701            "DICTIONARY",
702            "INDEX",
703            "FUNCTION",
704            "NAMED COLLECTION",
705        }
706
707        def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str:
708            this = self.json_path_part(expression.this)
709            return str(int(this) + 1) if is_int(this) else this
710
711        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
712            return f"AS {self.sql(expression, 'this')}"
713
714        def _any_to_has(
715            self,
716            expression: exp.EQ | exp.NEQ,
717            default: t.Callable[[t.Any], str],
718            prefix: str = "",
719        ) -> str:
720            if isinstance(expression.left, exp.Any):
721                arr = expression.left
722                this = expression.right
723            elif isinstance(expression.right, exp.Any):
724                arr = expression.right
725                this = expression.left
726            else:
727                return default(expression)
728
729            return prefix + self.func("has", arr.this.unnest(), this)
730
731        def eq_sql(self, expression: exp.EQ) -> str:
732            return self._any_to_has(expression, super().eq_sql)
733
734        def neq_sql(self, expression: exp.NEQ) -> str:
735            return self._any_to_has(expression, super().neq_sql, "NOT ")
736
737        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
738            # Manually add a flag to make the search case-insensitive
739            regex = self.func("CONCAT", "'(?i)'", expression.expression)
740            return self.func("match", expression.this, regex)
741
742        def datatype_sql(self, expression: exp.DataType) -> str:
743            # String is the standard ClickHouse type, every other variant is just an alias.
744            # Additionally, any supplied length parameter will be ignored.
745            #
746            # https://clickhouse.com/docs/en/sql-reference/data-types/string
747            if expression.this in self.STRING_TYPE_MAPPING:
748                return "String"
749
750            return super().datatype_sql(expression)
751
752        def cte_sql(self, expression: exp.CTE) -> str:
753            if expression.args.get("scalar"):
754                this = self.sql(expression, "this")
755                alias = self.sql(expression, "alias")
756                return f"{this} AS {alias}"
757
758            return super().cte_sql(expression)
759
760        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
761            return super().after_limit_modifiers(expression) + [
762                (
763                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
764                    if expression.args.get("settings")
765                    else ""
766                ),
767                (
768                    self.seg("FORMAT ") + self.sql(expression, "format")
769                    if expression.args.get("format")
770                    else ""
771                ),
772            ]
773
774        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
775            params = self.expressions(expression, key="params", flat=True)
776            return self.func(expression.name, *expression.expressions) + f"({params})"
777
778        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
779            return self.func(expression.name, *expression.expressions)
780
781        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
782            return self.anonymousaggfunc_sql(expression)
783
784        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
785            return self.parameterizedagg_sql(expression)
786
787        def placeholder_sql(self, expression: exp.Placeholder) -> str:
788            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
789
790        def oncluster_sql(self, expression: exp.OnCluster) -> str:
791            return f"ON CLUSTER {self.sql(expression, 'this')}"
792
793        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
794            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
795                exp.Properties.Location.POST_NAME
796            ):
797                this_name = self.sql(expression.this, "this")
798                this_properties = " ".join(
799                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
800                )
801                this_schema = self.schema_columns_sql(expression.this)
802                return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}"
803
804            return super().createable_sql(expression, locations)
805
806        def prewhere_sql(self, expression: exp.PreWhere) -> str:
807            this = self.indent(self.sql(expression, "this"))
808            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
809
810        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
811            this = self.sql(expression, "this")
812            this = f" {this}" if this else ""
813            expr = self.sql(expression, "expression")
814            expr = f" {expr}" if expr else ""
815            index_type = self.sql(expression, "index_type")
816            index_type = f" TYPE {index_type}" if index_type else ""
817            granularity = self.sql(expression, "granularity")
818            granularity = f" GRANULARITY {granularity}" if granularity else ""
819
820            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'>, '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'>, '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'>, 'COPY': <TokenType.COMMAND: 'COMMAND'>, '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.QUOTE: 'QUOTE'>, '`': <TokenType.IDENTIFIER: 'IDENTIFIER'>, '"': <TokenType.IDENTIFIER: 'IDENTIFIER'>, '#': <TokenType.HASH: 'HASH'>, '$': <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        }
259
260        AGG_FUNCTIONS_SUFFIXES = [
261            "If",
262            "Array",
263            "ArrayIf",
264            "Map",
265            "SimpleState",
266            "State",
267            "Merge",
268            "MergeState",
269            "ForEach",
270            "Distinct",
271            "OrDefault",
272            "OrNull",
273            "Resample",
274            "ArgMin",
275            "ArgMax",
276        ]
277
278        FUNC_TOKENS = {
279            *parser.Parser.FUNC_TOKENS,
280            TokenType.SET,
281        }
282
283        AGG_FUNC_MAPPING = (
284            lambda functions, suffixes: {
285                f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions
286            }
287        )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES)
288
289        FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"}
290
291        FUNCTION_PARSERS = {
292            **parser.Parser.FUNCTION_PARSERS,
293            "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()),
294            "QUANTILE": lambda self: self._parse_quantile(),
295        }
296
297        FUNCTION_PARSERS.pop("MATCH")
298
299        NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy()
300        NO_PAREN_FUNCTION_PARSERS.pop("ANY")
301
302        RANGE_PARSERS = {
303            **parser.Parser.RANGE_PARSERS,
304            TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN)
305            and self._parse_in(this, is_global=True),
306        }
307
308        # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to
309        # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler.
310        COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy()
311        COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
312
313        JOIN_KINDS = {
314            *parser.Parser.JOIN_KINDS,
315            TokenType.ANY,
316            TokenType.ASOF,
317            TokenType.ARRAY,
318        }
319
320        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
321            TokenType.ANY,
322            TokenType.ARRAY,
323            TokenType.FINAL,
324            TokenType.FORMAT,
325            TokenType.SETTINGS,
326        }
327
328        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
329            TokenType.FORMAT,
330        }
331
332        LOG_DEFAULTS_TO_LN = True
333
334        QUERY_MODIFIER_PARSERS = {
335            **parser.Parser.QUERY_MODIFIER_PARSERS,
336            TokenType.SETTINGS: lambda self: (
337                "settings",
338                self._advance() or self._parse_csv(self._parse_conjunction),
339            ),
340            TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
341        }
342
343        CONSTRAINT_PARSERS = {
344            **parser.Parser.CONSTRAINT_PARSERS,
345            "INDEX": lambda self: self._parse_index_constraint(),
346            "CODEC": lambda self: self._parse_compress(),
347        }
348
349        SCHEMA_UNNAMED_CONSTRAINTS = {
350            *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
351            "INDEX",
352        }
353
354        def _parse_conjunction(self) -> t.Optional[exp.Expression]:
355            this = super()._parse_conjunction()
356
357            if self._match(TokenType.PLACEHOLDER):
358                return self.expression(
359                    exp.If,
360                    this=this,
361                    true=self._parse_conjunction(),
362                    false=self._match(TokenType.COLON) and self._parse_conjunction(),
363                )
364
365            return this
366
367        def _parse_placeholder(self) -> t.Optional[exp.Expression]:
368            """
369            Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
370            https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
371            """
372            if not self._match(TokenType.L_BRACE):
373                return None
374
375            this = self._parse_id_var()
376            self._match(TokenType.COLON)
377            kind = self._parse_types(check_func=False, allow_identifiers=False) or (
378                self._match_text_seq("IDENTIFIER") and "Identifier"
379            )
380
381            if not kind:
382                self.raise_error("Expecting a placeholder type or 'Identifier' for tables")
383            elif not self._match(TokenType.R_BRACE):
384                self.raise_error("Expecting }")
385
386            return self.expression(exp.Placeholder, this=this, kind=kind)
387
388        def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In:
389            this = super()._parse_in(this)
390            this.set("is_global", is_global)
391            return this
392
393        def _parse_table(
394            self,
395            schema: bool = False,
396            joins: bool = False,
397            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
398            parse_bracket: bool = False,
399            is_db_reference: bool = False,
400            parse_partition: bool = False,
401        ) -> t.Optional[exp.Expression]:
402            this = super()._parse_table(
403                schema=schema,
404                joins=joins,
405                alias_tokens=alias_tokens,
406                parse_bracket=parse_bracket,
407                is_db_reference=is_db_reference,
408            )
409
410            if self._match(TokenType.FINAL):
411                this = self.expression(exp.Final, this=this)
412
413            return this
414
415        def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
416            return super()._parse_position(haystack_first=True)
417
418        # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
419        def _parse_cte(self) -> exp.CTE:
420            # WITH <identifier> AS <subquery expression>
421            cte: t.Optional[exp.CTE] = self._try_parse(super()._parse_cte)
422
423            if not cte:
424                # WITH <expression> AS <identifier>
425                cte = self.expression(
426                    exp.CTE,
427                    this=self._parse_conjunction(),
428                    alias=self._parse_table_alias(),
429                    scalar=True,
430                )
431
432            return cte
433
434        def _parse_join_parts(
435            self,
436        ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
437            is_global = self._match(TokenType.GLOBAL) and self._prev
438            kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev
439
440            if kind_pre:
441                kind = self._match_set(self.JOIN_KINDS) and self._prev
442                side = self._match_set(self.JOIN_SIDES) and self._prev
443                return is_global, side, kind
444
445            return (
446                is_global,
447                self._match_set(self.JOIN_SIDES) and self._prev,
448                self._match_set(self.JOIN_KINDS) and self._prev,
449            )
450
451        def _parse_join(
452            self, skip_join_token: bool = False, parse_bracket: bool = False
453        ) -> t.Optional[exp.Join]:
454            join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True)
455            if join:
456                join.set("global", join.args.pop("method", None))
457
458            return join
459
460        def _parse_function(
461            self,
462            functions: t.Optional[t.Dict[str, t.Callable]] = None,
463            anonymous: bool = False,
464            optional_parens: bool = True,
465            any_token: bool = False,
466        ) -> t.Optional[exp.Expression]:
467            func = super()._parse_function(
468                functions=functions,
469                anonymous=anonymous,
470                optional_parens=optional_parens,
471                any_token=any_token,
472            )
473
474            if isinstance(func, exp.Anonymous):
475                parts = self.AGG_FUNC_MAPPING.get(func.this)
476                params = self._parse_func_params(func)
477
478                if params:
479                    if parts and parts[1]:
480                        return self.expression(
481                            exp.CombinedParameterizedAgg,
482                            this=func.this,
483                            expressions=func.expressions,
484                            params=params,
485                            parts=parts,
486                        )
487                    return self.expression(
488                        exp.ParameterizedAgg,
489                        this=func.this,
490                        expressions=func.expressions,
491                        params=params,
492                    )
493
494                if parts:
495                    if parts[1]:
496                        return self.expression(
497                            exp.CombinedAggFunc,
498                            this=func.this,
499                            expressions=func.expressions,
500                            parts=parts,
501                        )
502                    return self.expression(
503                        exp.AnonymousAggFunc,
504                        this=func.this,
505                        expressions=func.expressions,
506                    )
507
508            return func
509
510        def _parse_func_params(
511            self, this: t.Optional[exp.Func] = None
512        ) -> t.Optional[t.List[exp.Expression]]:
513            if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
514                return self._parse_csv(self._parse_lambda)
515
516            if self._match(TokenType.L_PAREN):
517                params = self._parse_csv(self._parse_lambda)
518                self._match_r_paren(this)
519                return params
520
521            return None
522
523        def _parse_quantile(self) -> exp.Quantile:
524            this = self._parse_lambda()
525            params = self._parse_func_params()
526            if params:
527                return self.expression(exp.Quantile, this=params[0], quantile=this)
528            return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5))
529
530        def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
531            return super()._parse_wrapped_id_vars(optional=True)
532
533        def _parse_primary_key(
534            self, wrapped_optional: bool = False, in_props: bool = False
535        ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
536            return super()._parse_primary_key(
537                wrapped_optional=wrapped_optional or in_props, in_props=in_props
538            )
539
540        def _parse_on_property(self) -> t.Optional[exp.Expression]:
541            index = self._index
542            if self._match_text_seq("CLUSTER"):
543                this = self._parse_id_var()
544                if this:
545                    return self.expression(exp.OnCluster, this=this)
546                else:
547                    self._retreat(index)
548            return None
549
550        def _parse_index_constraint(
551            self, kind: t.Optional[str] = None
552        ) -> exp.IndexColumnConstraint:
553            # INDEX name1 expr TYPE type1(args) GRANULARITY value
554            this = self._parse_id_var()
555            expression = self._parse_conjunction()
556
557            index_type = self._match_text_seq("TYPE") and (
558                self._parse_function() or self._parse_var()
559            )
560
561            granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
562
563            return self.expression(
564                exp.IndexColumnConstraint,
565                this=this,
566                expression=expression,
567                index_type=index_type,
568                granularity=granularity,
569            )

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