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

ESCAPE_SEQUENCES = {'\\0': '\x00'}

Mapping of an unescaped escape sequence to the corresponding character.

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 = {}
INVERSE_ESCAPE_SEQUENCES: Dict[str, str] = {'\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):
 59    class Tokenizer(tokens.Tokenizer):
 60        COMMENTS = ["--", "#", "#!", ("/*", "*/")]
 61        IDENTIFIERS = ['"', "`"]
 62        STRING_ESCAPES = ["'", "\\"]
 63        BIT_STRINGS = [("0b", "")]
 64        HEX_STRINGS = [("0x", ""), ("0X", "")]
 65        HEREDOC_STRINGS = ["$"]
 66
 67        KEYWORDS = {
 68            **tokens.Tokenizer.KEYWORDS,
 69            "ATTACH": TokenType.COMMAND,
 70            "DATE32": TokenType.DATE32,
 71            "DATETIME64": TokenType.DATETIME64,
 72            "DICTIONARY": TokenType.DICTIONARY,
 73            "ENUM8": TokenType.ENUM8,
 74            "ENUM16": TokenType.ENUM16,
 75            "FINAL": TokenType.FINAL,
 76            "FIXEDSTRING": TokenType.FIXEDSTRING,
 77            "FLOAT32": TokenType.FLOAT,
 78            "FLOAT64": TokenType.DOUBLE,
 79            "GLOBAL": TokenType.GLOBAL,
 80            "INT256": TokenType.INT256,
 81            "LOWCARDINALITY": TokenType.LOWCARDINALITY,
 82            "MAP": TokenType.MAP,
 83            "NESTED": TokenType.NESTED,
 84            "SAMPLE": TokenType.TABLE_SAMPLE,
 85            "TUPLE": TokenType.STRUCT,
 86            "UINT128": TokenType.UINT128,
 87            "UINT16": TokenType.USMALLINT,
 88            "UINT256": TokenType.UINT256,
 89            "UINT32": TokenType.UINT,
 90            "UINT64": TokenType.UBIGINT,
 91            "UINT8": TokenType.UTINYINT,
 92            "IPV4": TokenType.IPV4,
 93            "IPV6": TokenType.IPV6,
 94            "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION,
 95            "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION,
 96            "SYSTEM": TokenType.COMMAND,
 97            "PREWHERE": TokenType.PREWHERE,
 98        }
 99
100        SINGLE_TOKENS = {
101            **tokens.Tokenizer.SINGLE_TOKENS,
102            "$": TokenType.HEREDOC_STRING,
103        }
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'>, '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):
105    class Parser(parser.Parser):
106        # Tested in ClickHouse's playground, it seems that the following two queries do the same thing
107        # * select x from t1 union all select x from t2 limit 1;
108        # * select x from t1 union all (select x from t2 limit 1);
109        MODIFIERS_ATTACHED_TO_UNION = False
110
111        FUNCTIONS = {
112            **parser.Parser.FUNCTIONS,
113            "ANY": exp.AnyValue.from_arg_list,
114            "ARRAYSUM": exp.ArraySum.from_arg_list,
115            "COUNTIF": _build_count_if,
116            "DATE_ADD": lambda args: exp.DateAdd(
117                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
118            ),
119            "DATEADD": lambda args: exp.DateAdd(
120                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
121            ),
122            "DATE_DIFF": lambda args: exp.DateDiff(
123                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
124            ),
125            "DATEDIFF": lambda args: exp.DateDiff(
126                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
127            ),
128            "JSONEXTRACTSTRING": build_json_extract_path(
129                exp.JSONExtractScalar, zero_based_indexing=False
130            ),
131            "MAP": parser.build_var_map,
132            "MATCH": exp.RegexpLike.from_arg_list,
133            "RANDCANONICAL": exp.Rand.from_arg_list,
134            "TUPLE": exp.Struct.from_arg_list,
135            "UNIQ": exp.ApproxDistinct.from_arg_list,
136            "XOR": lambda args: exp.Xor(expressions=args),
137        }
138
139        AGG_FUNCTIONS = {
140            "count",
141            "min",
142            "max",
143            "sum",
144            "avg",
145            "any",
146            "stddevPop",
147            "stddevSamp",
148            "varPop",
149            "varSamp",
150            "corr",
151            "covarPop",
152            "covarSamp",
153            "entropy",
154            "exponentialMovingAverage",
155            "intervalLengthSum",
156            "kolmogorovSmirnovTest",
157            "mannWhitneyUTest",
158            "median",
159            "rankCorr",
160            "sumKahan",
161            "studentTTest",
162            "welchTTest",
163            "anyHeavy",
164            "anyLast",
165            "boundingRatio",
166            "first_value",
167            "last_value",
168            "argMin",
169            "argMax",
170            "avgWeighted",
171            "topK",
172            "topKWeighted",
173            "deltaSum",
174            "deltaSumTimestamp",
175            "groupArray",
176            "groupArrayLast",
177            "groupUniqArray",
178            "groupArrayInsertAt",
179            "groupArrayMovingAvg",
180            "groupArrayMovingSum",
181            "groupArraySample",
182            "groupBitAnd",
183            "groupBitOr",
184            "groupBitXor",
185            "groupBitmap",
186            "groupBitmapAnd",
187            "groupBitmapOr",
188            "groupBitmapXor",
189            "sumWithOverflow",
190            "sumMap",
191            "minMap",
192            "maxMap",
193            "skewSamp",
194            "skewPop",
195            "kurtSamp",
196            "kurtPop",
197            "uniq",
198            "uniqExact",
199            "uniqCombined",
200            "uniqCombined64",
201            "uniqHLL12",
202            "uniqTheta",
203            "quantile",
204            "quantiles",
205            "quantileExact",
206            "quantilesExact",
207            "quantileExactLow",
208            "quantilesExactLow",
209            "quantileExactHigh",
210            "quantilesExactHigh",
211            "quantileExactWeighted",
212            "quantilesExactWeighted",
213            "quantileTiming",
214            "quantilesTiming",
215            "quantileTimingWeighted",
216            "quantilesTimingWeighted",
217            "quantileDeterministic",
218            "quantilesDeterministic",
219            "quantileTDigest",
220            "quantilesTDigest",
221            "quantileTDigestWeighted",
222            "quantilesTDigestWeighted",
223            "quantileBFloat16",
224            "quantilesBFloat16",
225            "quantileBFloat16Weighted",
226            "quantilesBFloat16Weighted",
227            "simpleLinearRegression",
228            "stochasticLinearRegression",
229            "stochasticLogisticRegression",
230            "categoricalInformationValue",
231            "contingency",
232            "cramersV",
233            "cramersVBiasCorrected",
234            "theilsU",
235            "maxIntersections",
236            "maxIntersectionsPosition",
237            "meanZTest",
238            "quantileInterpolatedWeighted",
239            "quantilesInterpolatedWeighted",
240            "quantileGK",
241            "quantilesGK",
242            "sparkBar",
243            "sumCount",
244            "largestTriangleThreeBuckets",
245        }
246
247        AGG_FUNCTIONS_SUFFIXES = [
248            "If",
249            "Array",
250            "ArrayIf",
251            "Map",
252            "SimpleState",
253            "State",
254            "Merge",
255            "MergeState",
256            "ForEach",
257            "Distinct",
258            "OrDefault",
259            "OrNull",
260            "Resample",
261            "ArgMin",
262            "ArgMax",
263        ]
264
265        AGG_FUNC_MAPPING = (
266            lambda functions, suffixes: {
267                f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions
268            }
269        )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES)
270
271        FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"}
272
273        FUNCTION_PARSERS = {
274            **parser.Parser.FUNCTION_PARSERS,
275            "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()),
276            "QUANTILE": lambda self: self._parse_quantile(),
277        }
278
279        FUNCTION_PARSERS.pop("MATCH")
280
281        NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy()
282        NO_PAREN_FUNCTION_PARSERS.pop("ANY")
283
284        RANGE_PARSERS = {
285            **parser.Parser.RANGE_PARSERS,
286            TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN)
287            and self._parse_in(this, is_global=True),
288        }
289
290        # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to
291        # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler.
292        COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy()
293        COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
294
295        JOIN_KINDS = {
296            *parser.Parser.JOIN_KINDS,
297            TokenType.ANY,
298            TokenType.ASOF,
299            TokenType.ARRAY,
300        }
301
302        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
303            TokenType.ANY,
304            TokenType.ARRAY,
305            TokenType.FINAL,
306            TokenType.FORMAT,
307            TokenType.SETTINGS,
308        }
309
310        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
311            TokenType.FORMAT,
312        }
313
314        LOG_DEFAULTS_TO_LN = True
315
316        QUERY_MODIFIER_PARSERS = {
317            **parser.Parser.QUERY_MODIFIER_PARSERS,
318            TokenType.SETTINGS: lambda self: (
319                "settings",
320                self._advance() or self._parse_csv(self._parse_conjunction),
321            ),
322            TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
323        }
324
325        def _parse_conjunction(self) -> t.Optional[exp.Expression]:
326            this = super()._parse_conjunction()
327
328            if self._match(TokenType.PLACEHOLDER):
329                return self.expression(
330                    exp.If,
331                    this=this,
332                    true=self._parse_conjunction(),
333                    false=self._match(TokenType.COLON) and self._parse_conjunction(),
334                )
335
336            return this
337
338        def _parse_placeholder(self) -> t.Optional[exp.Expression]:
339            """
340            Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
341            https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
342            """
343            if not self._match(TokenType.L_BRACE):
344                return None
345
346            this = self._parse_id_var()
347            self._match(TokenType.COLON)
348            kind = self._parse_types(check_func=False, allow_identifiers=False) or (
349                self._match_text_seq("IDENTIFIER") and "Identifier"
350            )
351
352            if not kind:
353                self.raise_error("Expecting a placeholder type or 'Identifier' for tables")
354            elif not self._match(TokenType.R_BRACE):
355                self.raise_error("Expecting }")
356
357            return self.expression(exp.Placeholder, this=this, kind=kind)
358
359        def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In:
360            this = super()._parse_in(this)
361            this.set("is_global", is_global)
362            return this
363
364        def _parse_table(
365            self,
366            schema: bool = False,
367            joins: bool = False,
368            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
369            parse_bracket: bool = False,
370            is_db_reference: bool = False,
371        ) -> t.Optional[exp.Expression]:
372            this = super()._parse_table(
373                schema=schema,
374                joins=joins,
375                alias_tokens=alias_tokens,
376                parse_bracket=parse_bracket,
377                is_db_reference=is_db_reference,
378            )
379
380            if self._match(TokenType.FINAL):
381                this = self.expression(exp.Final, this=this)
382
383            return this
384
385        def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
386            return super()._parse_position(haystack_first=True)
387
388        # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
389        def _parse_cte(self) -> exp.CTE:
390            index = self._index
391            try:
392                # WITH <identifier> AS <subquery expression>
393                return super()._parse_cte()
394            except ParseError:
395                # WITH <expression> AS <identifier>
396                self._retreat(index)
397
398                return self.expression(
399                    exp.CTE,
400                    this=self._parse_conjunction(),
401                    alias=self._parse_table_alias(),
402                    scalar=True,
403                )
404
405        def _parse_join_parts(
406            self,
407        ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
408            is_global = self._match(TokenType.GLOBAL) and self._prev
409            kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev
410
411            if kind_pre:
412                kind = self._match_set(self.JOIN_KINDS) and self._prev
413                side = self._match_set(self.JOIN_SIDES) and self._prev
414                return is_global, side, kind
415
416            return (
417                is_global,
418                self._match_set(self.JOIN_SIDES) and self._prev,
419                self._match_set(self.JOIN_KINDS) and self._prev,
420            )
421
422        def _parse_join(
423            self, skip_join_token: bool = False, parse_bracket: bool = False
424        ) -> t.Optional[exp.Join]:
425            join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True)
426            if join:
427                join.set("global", join.args.pop("method", None))
428
429            return join
430
431        def _parse_function(
432            self,
433            functions: t.Optional[t.Dict[str, t.Callable]] = None,
434            anonymous: bool = False,
435            optional_parens: bool = True,
436        ) -> t.Optional[exp.Expression]:
437            func = super()._parse_function(
438                functions=functions, anonymous=anonymous, optional_parens=optional_parens
439            )
440
441            if isinstance(func, exp.Anonymous):
442                parts = self.AGG_FUNC_MAPPING.get(func.this)
443                params = self._parse_func_params(func)
444
445                if params:
446                    if parts and parts[1]:
447                        return self.expression(
448                            exp.CombinedParameterizedAgg,
449                            this=func.this,
450                            expressions=func.expressions,
451                            params=params,
452                            parts=parts,
453                        )
454                    return self.expression(
455                        exp.ParameterizedAgg,
456                        this=func.this,
457                        expressions=func.expressions,
458                        params=params,
459                    )
460
461                if parts:
462                    if parts[1]:
463                        return self.expression(
464                            exp.CombinedAggFunc,
465                            this=func.this,
466                            expressions=func.expressions,
467                            parts=parts,
468                        )
469                    return self.expression(
470                        exp.AnonymousAggFunc,
471                        this=func.this,
472                        expressions=func.expressions,
473                    )
474
475            return func
476
477        def _parse_func_params(
478            self, this: t.Optional[exp.Func] = None
479        ) -> t.Optional[t.List[exp.Expression]]:
480            if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
481                return self._parse_csv(self._parse_lambda)
482
483            if self._match(TokenType.L_PAREN):
484                params = self._parse_csv(self._parse_lambda)
485                self._match_r_paren(this)
486                return params
487
488            return None
489
490        def _parse_quantile(self) -> exp.Quantile:
491            this = self._parse_lambda()
492            params = self._parse_func_params()
493            if params:
494                return self.expression(exp.Quantile, this=params[0], quantile=this)
495            return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5))
496
497        def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
498            return super()._parse_wrapped_id_vars(optional=True)
499
500        def _parse_primary_key(
501            self, wrapped_optional: bool = False, in_props: bool = False
502        ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
503            return super()._parse_primary_key(
504                wrapped_optional=wrapped_optional or in_props, in_props=in_props
505            )
506
507        def _parse_on_property(self) -> t.Optional[exp.Expression]:
508            index = self._index
509            if self._match_text_seq("CLUSTER"):
510                this = self._parse_id_var()
511                if this:
512                    return self.expression(exp.OnCluster, this=this)
513                else:
514                    self._retreat(index)
515            return None

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

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. Default: 2.
  • indent: The indentation size in a formatted string. 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.DateAdd'>: <function date_delta_sql.<locals>._delta_sql>, <class 'sqlglot.expressions.DateFormatColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DefaultColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EncodeColumnConstraint'>: <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.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.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.CurrentDate'>: <function ClickHouse.Generator.<lambda>>, <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.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.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 = ''
ON_CLUSTER_TARGETS = {'DICTIONARY', 'NAMED COLLECTION', 'INDEX', 'VIEW', 'TABLE', 'DATABASE', 'FUNCTION'}
def likeproperty_sql(self, expression: sqlglot.expressions.LikeProperty) -> str:
649        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
650            return f"AS {self.sql(expression, 'this')}"
def eq_sql(self, expression: sqlglot.expressions.EQ) -> str:
669        def eq_sql(self, expression: exp.EQ) -> str:
670            return self._any_to_has(expression, super().eq_sql)
def neq_sql(self, expression: sqlglot.expressions.NEQ) -> str:
672        def neq_sql(self, expression: exp.NEQ) -> str:
673            return self._any_to_has(expression, super().neq_sql, "NOT ")
def regexpilike_sql(self, expression: sqlglot.expressions.RegexpILike) -> str:
675        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
676            # Manually add a flag to make the search case-insensitive
677            regex = self.func("CONCAT", "'(?i)'", expression.expression)
678            return self.func("match", expression.this, regex)
def datatype_sql(self, expression: sqlglot.expressions.DataType) -> str:
680        def datatype_sql(self, expression: exp.DataType) -> str:
681            # String is the standard ClickHouse type, every other variant is just an alias.
682            # Additionally, any supplied length parameter will be ignored.
683            #
684            # https://clickhouse.com/docs/en/sql-reference/data-types/string
685            if expression.this in self.STRING_TYPE_MAPPING:
686                return "String"
687
688            return super().datatype_sql(expression)
def cte_sql(self, expression: sqlglot.expressions.CTE) -> str:
690        def cte_sql(self, expression: exp.CTE) -> str:
691            if expression.args.get("scalar"):
692                this = self.sql(expression, "this")
693                alias = self.sql(expression, "alias")
694                return f"{this} AS {alias}"
695
696            return super().cte_sql(expression)
def after_limit_modifiers(self, expression: sqlglot.expressions.Expression) -> List[str]:
698        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
699            return super().after_limit_modifiers(expression) + [
700                (
701                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
702                    if expression.args.get("settings")
703                    else ""
704                ),
705                (
706                    self.seg("FORMAT ") + self.sql(expression, "format")
707                    if expression.args.get("format")
708                    else ""
709                ),
710            ]
def parameterizedagg_sql(self, expression: sqlglot.expressions.ParameterizedAgg) -> str:
712        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
713            params = self.expressions(expression, key="params", flat=True)
714            return self.func(expression.name, *expression.expressions) + f"({params})"
def anonymousaggfunc_sql(self, expression: sqlglot.expressions.AnonymousAggFunc) -> str:
716        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
717            return self.func(expression.name, *expression.expressions)
def combinedaggfunc_sql(self, expression: sqlglot.expressions.CombinedAggFunc) -> str:
719        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
720            return self.anonymousaggfunc_sql(expression)
def combinedparameterizedagg_sql(self, expression: sqlglot.expressions.CombinedParameterizedAgg) -> str:
722        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
723            return self.parameterizedagg_sql(expression)
def placeholder_sql(self, expression: sqlglot.expressions.Placeholder) -> str:
725        def placeholder_sql(self, expression: exp.Placeholder) -> str:
726            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
def oncluster_sql(self, expression: sqlglot.expressions.OnCluster) -> str:
728        def oncluster_sql(self, expression: exp.OnCluster) -> str:
729            return f"ON CLUSTER {self.sql(expression, 'this')}"
def createable_sql( self, expression: sqlglot.expressions.Create, locations: DefaultDict) -> str:
731        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
732            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
733                exp.Properties.Location.POST_NAME
734            ):
735                this_name = self.sql(expression.this, "this")
736                this_properties = " ".join(
737                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
738                )
739                this_schema = self.schema_columns_sql(expression.this)
740                return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}"
741
742            return super().createable_sql(expression, locations)
def prewhere_sql(self, expression: sqlglot.expressions.PreWhere) -> str:
744        def prewhere_sql(self, expression: exp.PreWhere) -> str:
745            this = self.indent(self.sql(expression, "this"))
746            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
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_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
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_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
text_width
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
indexcolumnconstraint_sql
nvl2_sql
comprehension_sql
columnprefix_sql
opclass_sql
predict_sql
forin_sql
refresh_sql
operator_sql
toarray_sql
tsordstotime_sql
tsordstodate_sql
unixdate_sql
lastday_sql
arrayany_sql
generateseries_sql
struct_sql
partitionrange_sql
truncatetable_sql
convert_sql