Edit on GitHub

sqlglot.parsers.clickhouse 

  1from __future__ import annotations
  2
  3import typing as t
  4
  5from collections import deque
  6
  7from sqlglot import exp, parser
  8from sqlglot.dialects.dialect import (
  9    build_date_delta,
 10    build_formatted_time,
 11    build_json_extract_path,
 12    build_like,
 13)
 14from sqlglot.helper import seq_get
 15from sqlglot.tokens import Token, TokenType
 16from builtins import type as Type
 17
 18if t.TYPE_CHECKING:
 19    from sqlglot._typing import E
 20    from collections.abc import Mapping, Sequence, Collection
 21
 22
 23def _build_datetime_format(
 24    expr_type: Type[E],
 25) -> t.Callable:
 26    def _builder(args: list, dialect: t.Any) -> E:
 27        expr = build_formatted_time(expr_type)(args, dialect)
 28
 29        timezone = seq_get(args, 2)
 30        if timezone:
 31            expr.set("zone", timezone)
 32
 33        return expr
 34
 35    return _builder
 36
 37
 38def _build_count_if(args: list) -> exp.CountIf | exp.CombinedAggFunc:
 39    if len(args) == 1:
 40        return exp.CountIf(this=seq_get(args, 0))
 41
 42    return exp.CombinedAggFunc(this="countIf", expressions=args)
 43
 44
 45def _build_str_to_date(args: list) -> exp.Cast | exp.Anonymous:
 46    if len(args) == 3:
 47        return exp.Anonymous(this="STR_TO_DATE", expressions=args)
 48
 49    strtodate = exp.StrToDate.from_arg_list(args)
 50    return exp.cast(strtodate, exp.DType.DATETIME.into_expr())
 51
 52
 53def _build_timestamp_trunc(unit: str) -> t.Callable[[list], exp.TimestampTrunc]:
 54    return lambda args: exp.TimestampTrunc(
 55        this=seq_get(args, 0), unit=exp.var(unit), zone=seq_get(args, 1)
 56    )
 57
 58
 59def _build_split_by_char(args: list) -> exp.Split | exp.Anonymous:
 60    sep = seq_get(args, 0)
 61    if isinstance(sep, exp.Literal):
 62        sep_value = sep.to_py()
 63        if isinstance(sep_value, str) and len(sep_value.encode("utf-8")) == 1:
 64            return _build_split(exp.Split)(args)
 65
 66    return exp.Anonymous(this="splitByChar", expressions=args)
 67
 68
 69def _build_split(exp_class: Type[E]) -> t.Callable[[list], E]:
 70    return lambda args: exp_class(
 71        this=seq_get(args, 1), expression=seq_get(args, 0), limit=seq_get(args, 2)
 72    )
 73
 74
 75# Skip the 'week' unit since ClickHouse's toStartOfWeek
 76# uses an extra mode argument to specify the first day of the week
 77TIMESTAMP_TRUNC_UNITS = {
 78    "MICROSECOND",
 79    "MILLISECOND",
 80    "SECOND",
 81    "MINUTE",
 82    "HOUR",
 83    "DAY",
 84    "MONTH",
 85    "QUARTER",
 86    "YEAR",
 87}
 88
 89
 90AGG_FUNCTIONS = {
 91    "count",
 92    "min",
 93    "max",
 94    "sum",
 95    "avg",
 96    "any",
 97    "stddevPop",
 98    "stddevSamp",
 99    "varPop",
100    "varSamp",
101    "corr",
102    "covarPop",
103    "covarSamp",
104    "entropy",
105    "exponentialMovingAverage",
106    "intervalLengthSum",
107    "kolmogorovSmirnovTest",
108    "mannWhitneyUTest",
109    "median",
110    "rankCorr",
111    "sumKahan",
112    "studentTTest",
113    "welchTTest",
114    "anyHeavy",
115    "anyLast",
116    "boundingRatio",
117    "first_value",
118    "last_value",
119    "argMin",
120    "argMax",
121    "avgWeighted",
122    "topK",
123    "approx_top_sum",
124    "topKWeighted",
125    "deltaSum",
126    "deltaSumTimestamp",
127    "groupArray",
128    "groupArrayLast",
129    "groupConcat",
130    "groupUniqArray",
131    "groupArrayInsertAt",
132    "groupArrayMovingAvg",
133    "groupArrayMovingSum",
134    "groupArraySample",
135    "groupBitAnd",
136    "groupBitOr",
137    "groupBitXor",
138    "groupBitmap",
139    "groupBitmapAnd",
140    "groupBitmapOr",
141    "groupBitmapXor",
142    "sumWithOverflow",
143    "sumMap",
144    "minMap",
145    "maxMap",
146    "skewSamp",
147    "skewPop",
148    "kurtSamp",
149    "kurtPop",
150    "uniq",
151    "uniqExact",
152    "uniqCombined",
153    "uniqCombined64",
154    "uniqHLL12",
155    "uniqTheta",
156    "quantile",
157    "quantiles",
158    "quantileExact",
159    "quantilesExact",
160    "quantilesExactExclusive",
161    "quantileExactLow",
162    "quantilesExactLow",
163    "quantileExactHigh",
164    "quantilesExactHigh",
165    "quantileExactWeighted",
166    "quantilesExactWeighted",
167    "quantileTiming",
168    "quantilesTiming",
169    "quantileTimingWeighted",
170    "quantilesTimingWeighted",
171    "quantileDeterministic",
172    "quantilesDeterministic",
173    "quantileTDigest",
174    "quantilesTDigest",
175    "quantileTDigestWeighted",
176    "quantilesTDigestWeighted",
177    "quantileBFloat16",
178    "quantilesBFloat16",
179    "quantileBFloat16Weighted",
180    "quantilesBFloat16Weighted",
181    "simpleLinearRegression",
182    "stochasticLinearRegression",
183    "stochasticLogisticRegression",
184    "categoricalInformationValue",
185    "contingency",
186    "cramersV",
187    "cramersVBiasCorrected",
188    "theilsU",
189    "maxIntersections",
190    "maxIntersectionsPosition",
191    "meanZTest",
192    "quantileInterpolatedWeighted",
193    "quantilesInterpolatedWeighted",
194    "quantileGK",
195    "quantilesGK",
196    "sparkBar",
197    "sumCount",
198    "largestTriangleThreeBuckets",
199    "histogram",
200    "sequenceMatch",
201    "sequenceCount",
202    "windowFunnel",
203    "retention",
204    "uniqUpTo",
205    "sequenceNextNode",
206    "exponentialTimeDecayedAvg",
207}
208
209# Sorted longest-first so that compound suffixes (e.g. "SimpleState") are matched
210# before their sub-suffixes (e.g. "State") when resolving multi-combinator functions.
211AGG_FUNCTIONS_SUFFIXES: list[str] = sorted(
212    [
213        "If",
214        "Array",
215        "ArrayIf",
216        "Map",
217        "SimpleState",
218        "State",
219        "Merge",
220        "MergeState",
221        "ForEach",
222        "Distinct",
223        "OrDefault",
224        "OrNull",
225        "Resample",
226        "ArgMin",
227        "ArgMax",
228    ],
229    key=len,
230    reverse=True,
231)
232
233# Memoized examples of all 0- and 1-suffix aggregate function names
234AGG_FUNC_MAPPING: Mapping[str, tuple[str, str | None]] = {
235    f"{f}{sfx}": (f, sfx) for sfx in AGG_FUNCTIONS_SUFFIXES for f in AGG_FUNCTIONS
236} | {f: (f, None) for f in AGG_FUNCTIONS}
237
238
239class ClickHouseParser(parser.Parser):
240    # Tested in ClickHouse's playground, it seems that the following two queries do the same thing
241    # * select x from t1 union all select x from t2 limit 1;
242    # * select x from t1 union all (select x from t2 limit 1);
243    MODIFIERS_ATTACHED_TO_SET_OP = False
244    INTERVAL_SPANS = False
245    OPTIONAL_ALIAS_TOKEN_CTE = False
246    JOINS_HAVE_EQUAL_PRECEDENCE = True
247
248    FUNCTIONS = {
249        **{
250            k: v
251            for k, v in parser.Parser.FUNCTIONS.items()
252            if k not in ("TRANSFORM", "APPROX_TOP_SUM")
253        },
254        **{f"TOSTARTOF{unit}": _build_timestamp_trunc(unit=unit) for unit in TIMESTAMP_TRUNC_UNITS},
255        "ANY": exp.AnyValue.from_arg_list,
256        "ARRAYCOMPACT": exp.ArrayCompact.from_arg_list,
257        "ARRAYCONCAT": exp.ArrayConcat.from_arg_list,
258        "ARRAYDISTINCT": exp.ArrayDistinct.from_arg_list,
259        "ARRAYEXCEPT": exp.ArrayExcept.from_arg_list,
260        "ARRAYSUM": exp.ArraySum.from_arg_list,
261        "ARRAYMAX": exp.ArrayMax.from_arg_list,
262        "ARRAYMIN": exp.ArrayMin.from_arg_list,
263        "ARRAYREVERSE": exp.ArrayReverse.from_arg_list,
264        "ARRAYSLICE": exp.ArraySlice.from_arg_list,
265        "CURRENTDATABASE": exp.CurrentDatabase.from_arg_list,
266        "CURRENTSCHEMAS": exp.CurrentSchemas.from_arg_list,
267        "COUNTIF": _build_count_if,
268        "CITYHASH64": exp.CityHash64.from_arg_list,
269        "COSINEDISTANCE": exp.CosineDistance.from_arg_list,
270        "VERSION": exp.CurrentVersion.from_arg_list,
271        "DATE_ADD": build_date_delta(exp.DateAdd, default_unit=None),
272        "DATEADD": build_date_delta(exp.DateAdd, default_unit=None),
273        "DATE_DIFF": build_date_delta(exp.DateDiff, default_unit=None, supports_timezone=True),
274        "DATEDIFF": build_date_delta(exp.DateDiff, default_unit=None, supports_timezone=True),
275        "DATE_FORMAT": _build_datetime_format(exp.TimeToStr),
276        "DATE_SUB": build_date_delta(exp.DateSub, default_unit=None),
277        "DATESUB": build_date_delta(exp.DateSub, default_unit=None),
278        "FORMATDATETIME": _build_datetime_format(exp.TimeToStr),
279        "HAS": exp.ArrayContains.from_arg_list,
280        "ILIKE": build_like(exp.ILike),
281        "JSONEXTRACTSTRING": build_json_extract_path(
282            exp.JSONExtractScalar, zero_based_indexing=False
283        ),
284        "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
285        "LIKE": build_like(exp.Like),
286        "L2Distance": exp.EuclideanDistance.from_arg_list,
287        "MAP": parser.build_var_map,
288        "MATCH": exp.RegexpLike.from_arg_list,
289        "NOTLIKE": build_like(exp.Like, not_like=True),
290        "PARSEDATETIME": _build_datetime_format(exp.ParseDatetime),
291        "RANDCANONICAL": exp.Rand.from_arg_list,
292        "STR_TO_DATE": _build_str_to_date,
293        "TIMESTAMP_SUB": build_date_delta(exp.TimestampSub, default_unit=None),
294        "TIMESTAMPSUB": build_date_delta(exp.TimestampSub, default_unit=None),
295        "TIMESTAMP_ADD": build_date_delta(exp.TimestampAdd, default_unit=None),
296        "TIMESTAMPADD": build_date_delta(exp.TimestampAdd, default_unit=None),
297        "TOMONDAY": _build_timestamp_trunc("WEEK"),
298        "UNIQ": exp.ApproxDistinct.from_arg_list,
299        "MD5": exp.MD5Digest.from_arg_list,
300        "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
301        "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
302        "SPLITBYCHAR": _build_split_by_char,
303        "SPLITBYREGEXP": _build_split(exp.RegexpSplit),
304        "SPLITBYSTRING": _build_split(exp.Split),
305        "SUBSTRINGINDEX": exp.SubstringIndex.from_arg_list,
306        "TOTYPENAME": exp.Typeof.from_arg_list,
307        "EDITDISTANCE": exp.Levenshtein.from_arg_list,
308        "JAROWINKLERSIMILARITY": exp.JarowinklerSimilarity.from_arg_list,
309        "LEVENSHTEINDISTANCE": exp.Levenshtein.from_arg_list,
310        "UTCTIMESTAMP": exp.UtcTimestamp.from_arg_list,
311    }
312
313    AGG_FUNCTIONS = AGG_FUNCTIONS
314    AGG_FUNCTIONS_SUFFIXES = AGG_FUNCTIONS_SUFFIXES
315
316    FUNC_TOKENS = {
317        *parser.Parser.FUNC_TOKENS,
318        TokenType.AND,
319        TokenType.FILE,
320        TokenType.OR,
321        TokenType.SET,
322    }
323
324    RESERVED_TOKENS = parser.Parser.RESERVED_TOKENS - {TokenType.SELECT}
325
326    ID_VAR_TOKENS = {
327        *parser.Parser.ID_VAR_TOKENS,
328        TokenType.LIKE,
329    }
330
331    AGG_FUNC_MAPPING = AGG_FUNC_MAPPING
332
333    @classmethod
334    def _resolve_clickhouse_agg(cls, name: str) -> tuple[str, Sequence[str]] | None:
335        # ClickHouse allows chaining multiple combinators on aggregate functions.
336        # See https://clickhouse.com/docs/sql-reference/aggregate-functions/combinators
337        # N.B. this resolution allows any suffix stack, including ones that ClickHouse rejects
338        # syntactically such as sumMergeMerge (due to repeated adjacent suffixes)
339
340        # Until we are able to identify a 1- or 0-suffix aggregate function by name,
341        # repeatedly strip and queue suffixes (checking longer suffixes first, see comment on
342        # AGG_FUNCTIONS_SUFFIXES_SORTED). This loop only runs for 2 or more suffixes,
343        # as AGG_FUNC_MAPPING memoizes all 0- and 1-suffix
344        accumulated_suffixes: deque[str] = deque()
345        while (parts := AGG_FUNC_MAPPING.get(name)) is None:
346            for suffix in AGG_FUNCTIONS_SUFFIXES:
347                if name.endswith(suffix) and len(name) != len(suffix):
348                    accumulated_suffixes.appendleft(suffix)
349                    name = name[: -len(suffix)]
350                    break
351            else:
352                return None
353
354        # We now have a 0- or 1-suffix aggregate
355        agg_func_name, inner_suffix = parts
356        if inner_suffix:
357            # this is a 1-suffix aggregate (either naturally or via repeated suffix
358            # stripping). prepend the innermost suffix.
359            accumulated_suffixes.appendleft(inner_suffix)
360
361        return (agg_func_name, accumulated_suffixes)
362
363    FUNCTION_PARSERS = {
364        **{k: v for k, v in parser.Parser.FUNCTION_PARSERS.items() if k != "MATCH"},
365        "ARRAYJOIN": lambda self: self.expression(exp.Explode(this=self._parse_expression())),
366        "GROUPCONCAT": lambda self: self._parse_group_concat(),
367        "QUANTILE": lambda self: self._parse_quantile(),
368        "MEDIAN": lambda self: self._parse_quantile(),
369        "COLUMNS": lambda self: self._parse_columns(),
370        "TUPLE": lambda self: exp.Struct.from_arg_list(self._parse_function_args(alias=True)),
371        "AND": lambda self: exp.and_(*self._parse_function_args(alias=False)),
372        "OR": lambda self: exp.or_(*self._parse_function_args(alias=False)),
373        "XOR": lambda self: exp.xor(*self._parse_function_args(alias=False)),
374    }
375
376    PROPERTY_PARSERS = {
377        **{k: v for k, v in parser.Parser.PROPERTY_PARSERS.items() if k != "DYNAMIC"},
378        "ENGINE": lambda self: self._parse_engine_property(),
379        "UUID": lambda self: self.expression(exp.UuidProperty(this=self._parse_string())),
380    }
381
382    NO_PAREN_FUNCTION_PARSERS = {
383        k: v for k, v in parser.Parser.NO_PAREN_FUNCTION_PARSERS.items() if k != "ANY"
384    }
385
386    NO_PAREN_FUNCTIONS = {
387        k: v
388        for k, v in parser.Parser.NO_PAREN_FUNCTIONS.items()
389        if k != TokenType.CURRENT_TIMESTAMP
390    }
391
392    RANGE_PARSERS = {
393        **parser.Parser.RANGE_PARSERS,
394        TokenType.GLOBAL: lambda self, this: self._parse_global_in(this),
395    }
396
397    COLUMN_OPERATORS = {
398        **{k: v for k, v in parser.Parser.COLUMN_OPERATORS.items() if k != TokenType.PLACEHOLDER},
399        TokenType.DOTCARET: lambda self, this, field: self.expression(
400            exp.NestedJSONSelect(this=this, expression=field)
401        ),
402    }
403
404    JOIN_KINDS = {
405        *parser.Parser.JOIN_KINDS,
406        TokenType.ALL,
407        TokenType.ANY,
408        TokenType.ASOF,
409        TokenType.ARRAY,
410    }
411
412    TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
413        TokenType.ALL,
414        TokenType.ANY,
415        TokenType.ARRAY,
416        TokenType.ASOF,
417        TokenType.FINAL,
418        TokenType.FORMAT,
419        TokenType.SETTINGS,
420    }
421
422    ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
423        TokenType.FORMAT,
424    }
425
426    LOG_DEFAULTS_TO_LN = True
427
428    QUERY_MODIFIER_PARSERS = {
429        **parser.Parser.QUERY_MODIFIER_PARSERS,
430        TokenType.SETTINGS: lambda self: (
431            "settings",
432            self._advance() or self._parse_csv(self._parse_assignment),
433        ),
434        TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
435    }
436
437    CONSTRAINT_PARSERS = {
438        **parser.Parser.CONSTRAINT_PARSERS,
439        "INDEX": lambda self: self._parse_index_constraint(),
440        "CODEC": lambda self: self._parse_compress(),
441        "ASSUME": lambda self: self._parse_assume_constraint(),
442    }
443
444    ALTER_PARSERS = {
445        **parser.Parser.ALTER_PARSERS,
446        "MODIFY": lambda self: self._parse_alter_table_modify(),
447        "REPLACE": lambda self: self._parse_alter_table_replace(),
448    }
449
450    SCHEMA_UNNAMED_CONSTRAINTS = {
451        *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
452        "INDEX",
453    } - {"CHECK"}
454
455    PLACEHOLDER_PARSERS = {
456        **parser.Parser.PLACEHOLDER_PARSERS,
457        TokenType.L_BRACE: lambda self: self._parse_query_parameter(),
458    }
459
460    STATEMENT_PARSERS = {
461        **parser.Parser.STATEMENT_PARSERS,
462        TokenType.DETACH: lambda self: self._parse_detach(),
463    }
464
465    def _parse_wrapped_select_or_assignment(self) -> exp.Expr | None:
466        return self._parse_wrapped(
467            lambda: self._parse_select() or self._parse_assignment(), optional=True
468        )
469
470    def _parse_check_constraint(self) -> exp.CheckColumnConstraint | None:
471        return self.expression(
472            exp.CheckColumnConstraint(this=self._parse_wrapped_select_or_assignment())
473        )
474
475    def _parse_assume_constraint(self) -> exp.AssumeColumnConstraint | None:
476        return self.expression(
477            exp.AssumeColumnConstraint(this=self._parse_wrapped_select_or_assignment())
478        )
479
480    def _parse_engine_property(self) -> exp.EngineProperty:
481        self._match(TokenType.EQ)
482        return self.expression(
483            exp.EngineProperty(this=self._parse_field(any_token=True, anonymous_func=True))
484        )
485
486    # https://clickhouse.com/docs/en/sql-reference/statements/create/function
487    def _parse_user_defined_function_expression(self) -> exp.Expr | None:
488        return self._parse_lambda()
489
490    def _parse_types(
491        self,
492        check_func: bool = False,
493        schema: bool = False,
494        allow_identifiers: bool = True,
495        with_collation: bool = False,
496    ) -> exp.Expr | None:
497        dtype = super()._parse_types(
498            check_func=check_func,
499            schema=schema,
500            allow_identifiers=allow_identifiers,
501            with_collation=with_collation,
502        )
503        if isinstance(dtype, exp.DataType) and dtype.args.get("nullable") is not True:
504            # Mark every type as non-nullable which is ClickHouse's default, unless it's
505            # already marked as nullable. This marker helps us transpile types from other
506            # dialects to ClickHouse, so that we can e.g. produce `CAST(x AS Nullable(String))`
507            # from `CAST(x AS TEXT)`. If there is a `NULL` value in `x`, the former would
508            # fail in ClickHouse without the `Nullable` type constructor.
509            dtype.set("nullable", False)
510
511        return dtype
512
513    def _parse_extract(self) -> exp.Extract | exp.Anonymous:
514        index = self._index
515        this = self._parse_bitwise()
516        if self._match(TokenType.FROM):
517            self._retreat(index)
518            return super()._parse_extract()
519
520        # We return Anonymous here because extract and regexpExtract have different semantics,
521        # so parsing extract(foo, bar) into RegexpExtract can potentially break queries. E.g.,
522        # `extract('foobar', 'b')` works, but ClickHouse crashes for `regexpExtract('foobar', 'b')`.
523        #
524        # TODO: can we somehow convert the former into an equivalent `regexpExtract` call?
525        self._match(TokenType.COMMA)
526        return self.expression(
527            exp.Anonymous(this="extract", expressions=[this, self._parse_bitwise()])
528        )
529
530    def _parse_assignment(self) -> exp.Expr | None:
531        this = super()._parse_assignment()
532
533        if self._match(TokenType.PLACEHOLDER):
534            return self.expression(
535                exp.If(
536                    this=this,
537                    true=self._parse_assignment(),
538                    false=self._match(TokenType.COLON) and self._parse_assignment(),
539                )
540            )
541
542        return this
543
544    def _parse_query_parameter(self) -> exp.Expr | None:
545        """
546        Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
547        https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
548        """
549        index = self._index
550
551        this = self._parse_id_var()
552        self._match(TokenType.COLON)
553        kind = self._parse_types(check_func=False, allow_identifiers=False) or (
554            self._match_text_seq("IDENTIFIER") and "Identifier"
555        )
556
557        if not kind:
558            self._retreat(index)
559            return None
560        elif not self._match(TokenType.R_BRACE):
561            self.raise_error("Expecting }")
562
563        if isinstance(this, exp.Identifier) and not this.quoted:
564            this = exp.var(this.name)
565
566        return self.expression(exp.Placeholder(this=this, kind=kind))
567
568    def _parse_bracket(self, this: exp.Expr | None = None) -> exp.Expr | None:
569        if this:
570            bracket_json_type = None
571
572            while self._match_pair(TokenType.L_BRACKET, TokenType.R_BRACKET):
573                bracket_json_type = exp.DataType(
574                    this=exp.DType.ARRAY,
575                    expressions=[
576                        bracket_json_type
577                        or exp.DType.JSON.into_expr(dialect=self.dialect, nullable=False)
578                    ],
579                    nested=True,
580                )
581
582            if bracket_json_type:
583                return self.expression(exp.JSONCast(this=this, to=bracket_json_type))
584
585        l_brace = self._match(TokenType.L_BRACE, advance=False)
586        bracket = super()._parse_bracket(this)
587
588        if l_brace and isinstance(bracket, exp.Struct):
589            varmap = exp.VarMap(keys=exp.Array(), values=exp.Array())
590            for expression in bracket.expressions:
591                if not isinstance(expression, exp.PropertyEQ):
592                    break
593
594                varmap.args["keys"].append("expressions", exp.Literal.string(expression.name))
595                varmap.args["values"].append("expressions", expression.expression)
596
597            return varmap
598
599        return bracket
600
601    def _parse_global_in(self, this: exp.Expr | None) -> exp.Not | exp.In:
602        is_negated = self._match(TokenType.NOT)
603        in_expr: exp.In | None = None
604        if self._match(TokenType.IN):
605            in_expr = self._parse_in(this)
606            in_expr.set("is_global", True)
607        return self.expression(exp.Not(this=in_expr)) if is_negated else t.cast(exp.In, in_expr)
608
609    def _parse_table(
610        self,
611        schema: bool = False,
612        joins: bool = False,
613        alias_tokens: Collection[TokenType] | None = None,
614        parse_bracket: bool = False,
615        is_db_reference: bool = False,
616        parse_partition: bool = False,
617        consume_pipe: bool = False,
618    ) -> exp.Expr | None:
619        this = super()._parse_table(
620            schema=schema,
621            joins=joins,
622            alias_tokens=alias_tokens,
623            parse_bracket=parse_bracket,
624            is_db_reference=is_db_reference,
625        )
626
627        if isinstance(this, exp.Table):
628            inner = this.this
629            alias = this.args.get("alias")
630
631            if isinstance(inner, exp.GenerateSeries) and alias and not alias.columns:
632                alias.set("columns", [exp.to_identifier("generate_series")])
633
634        if self._match(TokenType.FINAL):
635            this = self.expression(exp.Final(this=this))
636
637        return this
638
639    def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
640        return super()._parse_position(haystack_first=True)
641
642    # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
643    def _parse_cte(self) -> exp.CTE | None:
644        # WITH <identifier> AS <subquery expression>
645        cte: exp.CTE | None = self._try_parse(super()._parse_cte)
646
647        if not cte:
648            # WITH <expression> AS <identifier>
649            cte = self.expression(
650                exp.CTE(this=self._parse_assignment(), alias=self._parse_table_alias(), scalar=True)
651            )
652
653        return cte
654
655    def _parse_join_parts(
656        self,
657    ) -> tuple[Token | None, Token | None, Token | None]:
658        is_global = self._prev if self._match(TokenType.GLOBAL) else None
659
660        kind_pre = self._prev if self._match_set(self.JOIN_KINDS) else None
661        side = self._prev if self._match_set(self.JOIN_SIDES) else None
662        kind = self._prev if self._match_set(self.JOIN_KINDS) else None
663
664        return is_global, side or kind, kind_pre or kind
665
666    def _parse_join(
667        self,
668        skip_join_token: bool = False,
669        parse_bracket: bool = False,
670        alias_tokens: t.Collection[TokenType] | None = None,
671    ) -> exp.Join | None:
672        join = super()._parse_join(
673            skip_join_token=skip_join_token, parse_bracket=True, alias_tokens=alias_tokens
674        )
675        if join:
676            method = join.args.get("method")
677            join.set("method", None)
678            join.set("global_", method)
679
680            # tbl ARRAY JOIN arr <-- this should be a `Column` reference, not a `Table`
681            # https://clickhouse.com/docs/en/sql-reference/statements/select/array-join
682            if join.kind == "ARRAY":
683                for table in join.find_all(exp.Table):
684                    table.replace(table.to_column())
685
686        return join
687
688    def _parse_function(
689        self,
690        functions: dict[str, t.Callable] | None = None,
691        anonymous: bool = False,
692        optional_parens: bool = True,
693        any_token: bool = False,
694    ) -> exp.Expr | None:
695        expr = super()._parse_function(
696            functions=functions,
697            anonymous=anonymous,
698            optional_parens=optional_parens,
699            any_token=any_token,
700        )
701
702        func = expr.this if isinstance(expr, exp.Window) else expr
703
704        # Aggregate functions can be split in 2 parts: <func_name><suffix[es]>
705        parts = self._resolve_clickhouse_agg(func.this) if isinstance(func, exp.Anonymous) else None
706
707        if parts:
708            anon_func: exp.Anonymous = t.cast(exp.Anonymous, func)
709            params = self._parse_func_params(anon_func)
710
711            if len(parts[1]) > 0:
712                exp_class: Type[exp.Expr] = (
713                    exp.CombinedParameterizedAgg if params else exp.CombinedAggFunc
714                )
715            else:
716                exp_class = exp.ParameterizedAgg if params else exp.AnonymousAggFunc
717
718            instance = exp_class(this=anon_func.this, expressions=anon_func.expressions)
719            if params:
720                instance.set("params", params)
721            func = self.expression(instance)
722
723            if isinstance(expr, exp.Window):
724                # The window's func was parsed as Anonymous in base parser, fix its
725                # type to be ClickHouse style CombinedAnonymousAggFunc / AnonymousAggFunc
726                expr.set("this", func)
727            elif params:
728                # Params have blocked super()._parse_function() from parsing the following window
729                # (if that exists) as they're standing between the function call and the window spec
730                expr = self._parse_window(func)
731            else:
732                expr = func
733
734        return expr
735
736    def _parse_func_params(self, this: exp.Func | None = None) -> list[exp.Expr] | None:
737        if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
738            return self._parse_csv(self._parse_lambda)
739
740        if self._match(TokenType.L_PAREN):
741            params = self._parse_csv(self._parse_lambda)
742            self._match_r_paren(this)
743            return params
744
745        return None
746
747    def _parse_group_concat(self) -> exp.GroupConcat:
748        args = self._parse_csv(self._parse_lambda)
749        params = self._parse_func_params()
750
751        if params:
752            # groupConcat(sep [, limit])(expr)
753            separator = seq_get(args, 0)
754            limit = seq_get(args, 1)
755            this: exp.Expr | None = seq_get(params, 0)
756            if limit is not None:
757                this = exp.Limit(this=this, expression=limit)
758            return self.expression(exp.GroupConcat(this=this, separator=separator))
759
760        # groupConcat(expr)
761        return self.expression(exp.GroupConcat(this=seq_get(args, 0)))
762
763    def _parse_quantile(self) -> exp.Quantile:
764        this = self._parse_lambda()
765        params = self._parse_func_params()
766        if params:
767            return self.expression(exp.Quantile(this=params[0], quantile=this))
768        return self.expression(exp.Quantile(this=this, quantile=exp.Literal.number(0.5)))
769
770    def _parse_wrapped_id_vars(self, optional: bool = False) -> list[exp.Expr]:
771        return super()._parse_wrapped_id_vars(optional=True)
772
773    def _parse_column_def(
774        self, this: exp.Expr | None, computed_column: bool = True
775    ) -> exp.Expr | None:
776        if self._match(TokenType.DOT):
777            return exp.Dot(this=this, expression=self._parse_id_var())
778
779        return super()._parse_column_def(this, computed_column=computed_column)
780
781    def _parse_primary_key(
782        self,
783        wrapped_optional: bool = False,
784        in_props: bool = False,
785        named_primary_key: bool = False,
786    ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
787        return super()._parse_primary_key(
788            wrapped_optional=wrapped_optional or in_props,
789            in_props=in_props,
790            named_primary_key=named_primary_key,
791        )
792
793    def _parse_on_property(self) -> exp.Expr | None:
794        index = self._index
795        if self._match_text_seq("CLUSTER"):
796            this = self._parse_string() or self._parse_id_var()
797            if this:
798                return self.expression(exp.OnCluster(this=this))
799            else:
800                self._retreat(index)
801        return None
802
803    def _parse_index_constraint(self, kind: str | None = None) -> exp.IndexColumnConstraint:
804        # INDEX name1 expr TYPE type1(args) GRANULARITY value
805        this = self._parse_id_var()
806        expression = self._parse_assignment()
807
808        index_type = self._match_text_seq("TYPE") and (self._parse_function() or self._parse_var())
809
810        granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
811
812        return self.expression(
813            exp.IndexColumnConstraint(
814                this=this, expression=expression, index_type=index_type, granularity=granularity
815            )
816        )
817
818    def _parse_partition(self) -> exp.Partition | None:
819        # https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#how-to-set-partition-expression
820        if not self._match(TokenType.PARTITION):
821            return None
822
823        if self._match_text_seq("ID"):
824            # Corresponds to the PARTITION ID <string_value> syntax
825            expressions: list[exp.Expr] = [
826                self.expression(exp.PartitionId(this=self._parse_string()))
827            ]
828        else:
829            expressions = self._parse_expressions()
830
831        return self.expression(exp.Partition(expressions=expressions))
832
833    def _parse_alter_table_replace(self) -> exp.Expr | None:
834        partition = self._parse_partition()
835
836        if not partition or not self._match(TokenType.FROM):
837            return None
838
839        return self.expression(
840            exp.ReplacePartition(expression=partition, source=self._parse_table_parts())
841        )
842
843    def _parse_alter_table_modify(self) -> exp.Expr | None:
844        if properties := self._parse_properties():
845            return self.expression(exp.AlterModifySqlSecurity(expressions=properties.expressions))
846        return None
847
848    def _parse_definer(self) -> exp.DefinerProperty | None:
849        self._match(TokenType.EQ)
850        if self._match(TokenType.CURRENT_USER):
851            return exp.DefinerProperty(this=exp.Var(this=self._prev.text.upper()))
852        return exp.DefinerProperty(this=self._parse_string())
853
854    def _parse_projection_def(self) -> exp.ProjectionDef | None:
855        if not self._match_text_seq("PROJECTION"):
856            return None
857
858        return self.expression(
859            exp.ProjectionDef(
860                this=self._parse_id_var(), expression=self._parse_wrapped(self._parse_statement)
861            )
862        )
863
864    def _parse_constraint(self) -> exp.Expr | None:
865        return super()._parse_constraint() or self._parse_projection_def()
866
867    def _parse_alias(self, this: exp.Expr | None, explicit: bool = False) -> exp.Expr | None:
868        # In clickhouse "SELECT <expr> APPLY(...)" is a query modifier,
869        # so "APPLY" shouldn't be parsed as <expr>'s alias. However, "SELECT <expr> apply" is a valid alias
870        if self._match_pair(TokenType.APPLY, TokenType.L_PAREN, advance=False):
871            return this
872
873        return super()._parse_alias(this=this, explicit=explicit)
874
875    def _parse_expression(self) -> exp.Expr | None:
876        this = super()._parse_expression()
877
878        # Clickhouse allows "SELECT <expr> [APPLY(func)] [...]]" modifier
879        while self._match_pair(TokenType.APPLY, TokenType.L_PAREN):
880            this = exp.Apply(this=this, expression=self._parse_var(any_token=True))
881            self._match(TokenType.R_PAREN)
882
883        return this
884
885    def _parse_columns(self) -> exp.Expr:
886        this: exp.Expr = self.expression(exp.Columns(this=self._parse_lambda()))
887
888        while self._next and self._match_text_seq(")", "APPLY", "("):
889            self._match(TokenType.R_PAREN)
890            this = exp.Apply(this=this, expression=self._parse_var(any_token=True))
891        return this
892
893    def _parse_value(self, values: bool = True) -> exp.Tuple | None:
894        value = super()._parse_value(values=values)
895        if not value:
896            return None
897
898        # In Clickhouse "SELECT * FROM VALUES (1, 2, 3)" generates a table with a single column, in contrast
899        # to other dialects. For this case, we canonicalize the values into a tuple-of-tuples AST if it's not already one.
900        # In INSERT INTO statements the same clause actually references multiple columns (opposite semantics),
901        # but the final result is not altered by the extra parentheses.
902        # Note: Clickhouse allows VALUES([structure], value, ...) so the branch checks for the last expression
903        expressions = value.expressions
904        if values and not isinstance(expressions[-1], exp.Tuple):
905            value.set(
906                "expressions",
907                [self.expression(exp.Tuple(expressions=[expr])) for expr in expressions],
908            )
909
910        return value
911
912    def _parse_partitioned_by(self) -> exp.PartitionedByProperty:
913        # ClickHouse allows custom expressions as partition key
914        # https://clickhouse.com/docs/engines/table-engines/mergetree-family/custom-partitioning-key
915        return self.expression(exp.PartitionedByProperty(this=self._parse_assignment()))
916
917    def _parse_detach(self) -> exp.Detach:
918        kind = self._match_set(self.DB_CREATABLES) and self._prev.text.upper()
919        exists = self._parse_exists()
920        this = self._parse_table_parts()
921
922        return self.expression(
923            exp.Detach(
924                this=this,
925                kind=kind,
926                exists=exists,
927                cluster=self._parse_on_property() if self._match(TokenType.ON) else None,
928                permanent=self._match_text_seq("PERMANENTLY"),
929                sync=self._match_text_seq("SYNC"),
930            )
931        )
TIMESTAMP_TRUNC_UNITS = {'MINUTE', 'QUARTER', 'MONTH', 'YEAR', 'MICROSECOND', 'HOUR', 'SECOND', 'MILLISECOND', 'DAY'}
AGG_FUNCTIONS = {'sumKahan', 'quantilesExactHigh', 'any', 'uniqTheta', 'groupBitXor', 'theilsU', 'boundingRatio', 'histogram', 'kolmogorovSmirnovTest', 'groupBitmapXor', 'quantileDeterministic', 'varPop', 'first_value', 'uniqHLL12', 'minMap', 'simpleLinearRegression', 'quantilesInterpolatedWeighted', 'max', 'quantileTDigestWeighted', 'groupUniqArray', 'meanZTest', 'stochasticLogisticRegression', 'cramersVBiasCorrected', 'covarPop', 'count', 'deltaSum', 'quantileInterpolatedWeighted', 'quantileGK', 'anyHeavy', 'uniqUpTo', 'studentTTest', 'varSamp', 'groupBitmapOr', 'argMin', 'contingency', 'quantilesExactLow', 'covarSamp', 'mannWhitneyUTest', 'quantilesExactWeighted', 'quantileTimingWeighted', 'min', 'approx_top_sum', 'uniq', 'quantilesExact', 'retention', 'uniqExact', 'stochasticLinearRegression', 'quantilesExactExclusive', 'sparkBar', 'skewPop', 'groupArrayMovingAvg', 'median', 'groupArrayLast', 'kurtPop', 'exponentialMovingAverage', 'sequenceNextNode', 'quantile', 'groupArrayInsertAt', 'sum', 'quantileBFloat16', 'rankCorr', 'quantileTDigest', 'maxIntersectionsPosition', 'sumMap', 'kurtSamp', 'exponentialTimeDecayedAvg', 'avgWeighted', 'topKWeighted', 'largestTriangleThreeBuckets', 'groupArraySample', 'quantileExactHigh', 'windowFunnel', 'quantileExactWeighted', 'quantileExactLow', 'maxMap', 'welchTTest', 'groupBitOr', 'quantiles', 'avg', 'cramersV', 'anyLast', 'quantilesGK', 'sequenceMatch', 'quantilesTimingWeighted', 'quantilesDeterministic', 'sumCount', 'maxIntersections', 'stddevSamp', 'groupBitmapAnd', 'groupArray', 'uniqCombined', 'skewSamp', 'groupBitmap', 'quantilesBFloat16', 'quantilesTDigest', 'sequenceCount', 'uniqCombined64', 'entropy', 'quantilesTDigestWeighted', 'quantileExact', 'categoricalInformationValue', 'topK', 'groupBitAnd', 'stddevPop', 'quantileBFloat16Weighted', 'quantileTiming', 'groupConcat', 'corr', 'sumWithOverflow', 'last_value', 'argMax', 'quantilesTiming', 'groupArrayMovingSum', 'deltaSumTimestamp', 'quantilesBFloat16Weighted', 'intervalLengthSum'}
AGG_FUNCTIONS_SUFFIXES: list[str] = ['SimpleState', 'MergeState', 'OrDefault', 'Distinct', 'Resample', 'ArrayIf', 'ForEach', 'OrNull', 'ArgMin', 'ArgMax', 'Array', 'State', 'Merge', 'Map', 'If']
AGG_FUNC_MAPPING: Mapping[str, tuple[str, str | None]] = {'sumKahanSimpleState': ('sumKahan', 'SimpleState'), 'quantilesExactHighSimpleState': ('quantilesExactHigh', 'SimpleState'), 'anySimpleState': ('any', 'SimpleState'), 'uniqThetaSimpleState': ('uniqTheta', 'SimpleState'), 'groupBitXorSimpleState': ('groupBitXor', 'SimpleState'), 'theilsUSimpleState': ('theilsU', 'SimpleState'), 'boundingRatioSimpleState': ('boundingRatio', 'SimpleState'), 'histogramSimpleState': ('histogram', 'SimpleState'), 'kolmogorovSmirnovTestSimpleState': ('kolmogorovSmirnovTest', 'SimpleState'), 'groupBitmapXorSimpleState': ('groupBitmapXor', 'SimpleState'), 'quantileDeterministicSimpleState': ('quantileDeterministic', 'SimpleState'), 'varPopSimpleState': ('varPop', 'SimpleState'), 'first_valueSimpleState': ('first_value', 'SimpleState'), 'uniqHLL12SimpleState': ('uniqHLL12', 'SimpleState'), 'minMapSimpleState': ('minMap', 'SimpleState'), 'simpleLinearRegressionSimpleState': ('simpleLinearRegression', 'SimpleState'), 'quantilesInterpolatedWeightedSimpleState': ('quantilesInterpolatedWeighted', 'SimpleState'), 'maxSimpleState': ('max', 'SimpleState'), 'quantileTDigestWeightedSimpleState': ('quantileTDigestWeighted', 'SimpleState'), 'groupUniqArraySimpleState': ('groupUniqArray', 'SimpleState'), 'meanZTestSimpleState': ('meanZTest', 'SimpleState'), 'stochasticLogisticRegressionSimpleState': ('stochasticLogisticRegression', 'SimpleState'), 'cramersVBiasCorrectedSimpleState': ('cramersVBiasCorrected', 'SimpleState'), 'covarPopSimpleState': ('covarPop', 'SimpleState'), 'countSimpleState': ('count', 'SimpleState'), 'deltaSumSimpleState': ('deltaSum', 'SimpleState'), 'quantileInterpolatedWeightedSimpleState': ('quantileInterpolatedWeighted', 'SimpleState'), 'quantileGKSimpleState': ('quantileGK', 'SimpleState'), 'anyHeavySimpleState': ('anyHeavy', 'SimpleState'), 'uniqUpToSimpleState': ('uniqUpTo', 'SimpleState'), 'studentTTestSimpleState': ('studentTTest', 'SimpleState'), 'varSampSimpleState': ('varSamp', 'SimpleState'), 'groupBitmapOrSimpleState': ('groupBitmapOr', 'SimpleState'), 'argMinSimpleState': ('argMin', 'SimpleState'), 'contingencySimpleState': ('contingency', 'SimpleState'), 'quantilesExactLowSimpleState': ('quantilesExactLow', 'SimpleState'), 'covarSampSimpleState': ('covarSamp', 'SimpleState'), 'mannWhitneyUTestSimpleState': ('mannWhitneyUTest', 'SimpleState'), 'quantilesExactWeightedSimpleState': ('quantilesExactWeighted', 'SimpleState'), 'quantileTimingWeightedSimpleState': ('quantileTimingWeighted', 'SimpleState'), 'minSimpleState': ('min', 'SimpleState'), 'approx_top_sumSimpleState': ('approx_top_sum', 'SimpleState'), 'uniqSimpleState': ('uniq', 'SimpleState'), 'quantilesExactSimpleState': ('quantilesExact', 'SimpleState'), 'retentionSimpleState': ('retention', 'SimpleState'), 'uniqExactSimpleState': ('uniqExact', 'SimpleState'), 'stochasticLinearRegressionSimpleState': ('stochasticLinearRegression', 'SimpleState'), 'quantilesExactExclusiveSimpleState': ('quantilesExactExclusive', 'SimpleState'), 'sparkBarSimpleState': ('sparkBar', 'SimpleState'), 'skewPopSimpleState': ('skewPop', 'SimpleState'), 'groupArrayMovingAvgSimpleState': ('groupArrayMovingAvg', 'SimpleState'), 'medianSimpleState': ('median', 'SimpleState'), 'groupArrayLastSimpleState': ('groupArrayLast', 'SimpleState'), 'kurtPopSimpleState': ('kurtPop', 'SimpleState'), 'exponentialMovingAverageSimpleState': ('exponentialMovingAverage', 'SimpleState'), 'sequenceNextNodeSimpleState': ('sequenceNextNode', 'SimpleState'), 'quantileSimpleState': ('quantile', 'SimpleState'), 'groupArrayInsertAtSimpleState': ('groupArrayInsertAt', 'SimpleState'), 'sumSimpleState': ('sum', 'SimpleState'), 'quantileBFloat16SimpleState': ('quantileBFloat16', 'SimpleState'), 'rankCorrSimpleState': ('rankCorr', 'SimpleState'), 'quantileTDigestSimpleState': ('quantileTDigest', 'SimpleState'), 'maxIntersectionsPositionSimpleState': ('maxIntersectionsPosition', 'SimpleState'), 'sumMapSimpleState': ('sumMap', 'SimpleState'), 'kurtSampSimpleState': ('kurtSamp', 'SimpleState'), 'exponentialTimeDecayedAvgSimpleState': ('exponentialTimeDecayedAvg', 'SimpleState'), 'avgWeightedSimpleState': ('avgWeighted', 'SimpleState'), 'topKWeightedSimpleState': ('topKWeighted', 'SimpleState'), 'largestTriangleThreeBucketsSimpleState': ('largestTriangleThreeBuckets', 'SimpleState'), 'groupArraySampleSimpleState': ('groupArraySample', 'SimpleState'), 'quantileExactHighSimpleState': ('quantileExactHigh', 'SimpleState'), 'windowFunnelSimpleState': ('windowFunnel', 'SimpleState'), 'quantileExactWeightedSimpleState': ('quantileExactWeighted', 'SimpleState'), 'quantileExactLowSimpleState': ('quantileExactLow', 'SimpleState'), 'maxMapSimpleState': ('maxMap', 'SimpleState'), 'welchTTestSimpleState': ('welchTTest', 'SimpleState'), 'groupBitOrSimpleState': ('groupBitOr', 'SimpleState'), 'quantilesSimpleState': ('quantiles', 'SimpleState'), 'avgSimpleState': ('avg', 'SimpleState'), 'cramersVSimpleState': ('cramersV', 'SimpleState'), 'anyLastSimpleState': ('anyLast', 'SimpleState'), 'quantilesGKSimpleState': ('quantilesGK', 'SimpleState'), 'sequenceMatchSimpleState': ('sequenceMatch', 'SimpleState'), 'quantilesTimingWeightedSimpleState': ('quantilesTimingWeighted', 'SimpleState'), 'quantilesDeterministicSimpleState': ('quantilesDeterministic', 'SimpleState'), 'sumCountSimpleState': ('sumCount', 'SimpleState'), 'maxIntersectionsSimpleState': ('maxIntersections', 'SimpleState'), 'stddevSampSimpleState': ('stddevSamp', 'SimpleState'), 'groupBitmapAndSimpleState': ('groupBitmapAnd', 'SimpleState'), 'groupArraySimpleState': ('groupArray', 'SimpleState'), 'uniqCombinedSimpleState': ('uniqCombined', 'SimpleState'), 'skewSampSimpleState': ('skewSamp', 'SimpleState'), 'groupBitmapSimpleState': ('groupBitmap', 'SimpleState'), 'quantilesBFloat16SimpleState': ('quantilesBFloat16', 'SimpleState'), 'quantilesTDigestSimpleState': ('quantilesTDigest', 'SimpleState'), 'sequenceCountSimpleState': ('sequenceCount', 'SimpleState'), 'uniqCombined64SimpleState': ('uniqCombined64', 'SimpleState'), 'entropySimpleState': ('entropy', 'SimpleState'), 'quantilesTDigestWeightedSimpleState': ('quantilesTDigestWeighted', 'SimpleState'), 'quantileExactSimpleState': ('quantileExact', 'SimpleState'), 'categoricalInformationValueSimpleState': ('categoricalInformationValue', 'SimpleState'), 'topKSimpleState': ('topK', 'SimpleState'), 'groupBitAndSimpleState': ('groupBitAnd', 'SimpleState'), 'stddevPopSimpleState': ('stddevPop', 'SimpleState'), 'quantileBFloat16WeightedSimpleState': ('quantileBFloat16Weighted', 'SimpleState'), 'quantileTimingSimpleState': ('quantileTiming', 'SimpleState'), 'groupConcatSimpleState': ('groupConcat', 'SimpleState'), 'corrSimpleState': ('corr', 'SimpleState'), 'sumWithOverflowSimpleState': ('sumWithOverflow', 'SimpleState'), 'last_valueSimpleState': ('last_value', 'SimpleState'), 'argMaxSimpleState': ('argMax', 'SimpleState'), 'quantilesTimingSimpleState': ('quantilesTiming', 'SimpleState'), 'groupArrayMovingSumSimpleState': ('groupArrayMovingSum', 'SimpleState'), 'deltaSumTimestampSimpleState': ('deltaSumTimestamp', 'SimpleState'), 'quantilesBFloat16WeightedSimpleState': ('quantilesBFloat16Weighted', 'SimpleState'), 'intervalLengthSumSimpleState': ('intervalLengthSum', 'SimpleState'), 'sumKahanMergeState': ('sumKahan', 'MergeState'), 'quantilesExactHighMergeState': ('quantilesExactHigh', 'MergeState'), 'anyMergeState': ('any', 'MergeState'), 'uniqThetaMergeState': ('uniqTheta', 'MergeState'), 'groupBitXorMergeState': ('groupBitXor', 'MergeState'), 'theilsUMergeState': ('theilsU', 'MergeState'), 'boundingRatioMergeState': ('boundingRatio', 'MergeState'), 'histogramMergeState': ('histogram', 'MergeState'), 'kolmogorovSmirnovTestMergeState': ('kolmogorovSmirnovTest', 'MergeState'), 'groupBitmapXorMergeState': ('groupBitmapXor', 'MergeState'), 'quantileDeterministicMergeState': ('quantileDeterministic', 'MergeState'), 'varPopMergeState': ('varPop', 'MergeState'), 'first_valueMergeState': ('first_value', 'MergeState'), 'uniqHLL12MergeState': ('uniqHLL12', 'MergeState'), 'minMapMergeState': ('minMap', 'MergeState'), 'simpleLinearRegressionMergeState': ('simpleLinearRegression', 'MergeState'), 'quantilesInterpolatedWeightedMergeState': ('quantilesInterpolatedWeighted', 'MergeState'), 'maxMergeState': ('max', 'MergeState'), 'quantileTDigestWeightedMergeState': ('quantileTDigestWeighted', 'MergeState'), 'groupUniqArrayMergeState': ('groupUniqArray', 'MergeState'), 'meanZTestMergeState': ('meanZTest', 'MergeState'), 'stochasticLogisticRegressionMergeState': ('stochasticLogisticRegression', 'MergeState'), 'cramersVBiasCorrectedMergeState': ('cramersVBiasCorrected', 'MergeState'), 'covarPopMergeState': ('covarPop', 'MergeState'), 'countMergeState': ('count', 'MergeState'), 'deltaSumMergeState': ('deltaSum', 'MergeState'), 'quantileInterpolatedWeightedMergeState': ('quantileInterpolatedWeighted', 'MergeState'), 'quantileGKMergeState': ('quantileGK', 'MergeState'), 'anyHeavyMergeState': ('anyHeavy', 'MergeState'), 'uniqUpToMergeState': ('uniqUpTo', 'MergeState'), 'studentTTestMergeState': ('studentTTest', 'MergeState'), 'varSampMergeState': ('varSamp', 'MergeState'), 'groupBitmapOrMergeState': ('groupBitmapOr', 'MergeState'), 'argMinMergeState': ('argMin', 'MergeState'), 'contingencyMergeState': ('contingency', 'MergeState'), 'quantilesExactLowMergeState': ('quantilesExactLow', 'MergeState'), 'covarSampMergeState': ('covarSamp', 'MergeState'), 'mannWhitneyUTestMergeState': ('mannWhitneyUTest', 'MergeState'), 'quantilesExactWeightedMergeState': ('quantilesExactWeighted', 'MergeState'), 'quantileTimingWeightedMergeState': ('quantileTimingWeighted', 'MergeState'), 'minMergeState': ('min', 'MergeState'), 'approx_top_sumMergeState': ('approx_top_sum', 'MergeState'), 'uniqMergeState': ('uniq', 'MergeState'), 'quantilesExactMergeState': ('quantilesExact', 'MergeState'), 'retentionMergeState': ('retention', 'MergeState'), 'uniqExactMergeState': ('uniqExact', 'MergeState'), 'stochasticLinearRegressionMergeState': ('stochasticLinearRegression', 'MergeState'), 'quantilesExactExclusiveMergeState': ('quantilesExactExclusive', 'MergeState'), 'sparkBarMergeState': ('sparkBar', 'MergeState'), 'skewPopMergeState': ('skewPop', 'MergeState'), 'groupArrayMovingAvgMergeState': ('groupArrayMovingAvg', 'MergeState'), 'medianMergeState': ('median', 'MergeState'), 'groupArrayLastMergeState': ('groupArrayLast', 'MergeState'), 'kurtPopMergeState': ('kurtPop', 'MergeState'), 'exponentialMovingAverageMergeState': ('exponentialMovingAverage', 'MergeState'), 'sequenceNextNodeMergeState': ('sequenceNextNode', 'MergeState'), 'quantileMergeState': ('quantile', 'MergeState'), 'groupArrayInsertAtMergeState': ('groupArrayInsertAt', 'MergeState'), 'sumMergeState': ('sum', 'MergeState'), 'quantileBFloat16MergeState': ('quantileBFloat16', 'MergeState'), 'rankCorrMergeState': ('rankCorr', 'MergeState'), 'quantileTDigestMergeState': ('quantileTDigest', 'MergeState'), 'maxIntersectionsPositionMergeState': ('maxIntersectionsPosition', 'MergeState'), 'sumMapMergeState': ('sumMap', 'MergeState'), 'kurtSampMergeState': ('kurtSamp', 'MergeState'), 'exponentialTimeDecayedAvgMergeState': ('exponentialTimeDecayedAvg', 'MergeState'), 'avgWeightedMergeState': ('avgWeighted', 'MergeState'), 'topKWeightedMergeState': ('topKWeighted', 'MergeState'), 'largestTriangleThreeBucketsMergeState': ('largestTriangleThreeBuckets', 'MergeState'), 'groupArraySampleMergeState': ('groupArraySample', 'MergeState'), 'quantileExactHighMergeState': ('quantileExactHigh', 'MergeState'), 'windowFunnelMergeState': ('windowFunnel', 'MergeState'), 'quantileExactWeightedMergeState': ('quantileExactWeighted', 'MergeState'), 'quantileExactLowMergeState': ('quantileExactLow', 'MergeState'), 'maxMapMergeState': ('maxMap', 'MergeState'), 'welchTTestMergeState': ('welchTTest', 'MergeState'), 'groupBitOrMergeState': ('groupBitOr', 'MergeState'), 'quantilesMergeState': ('quantiles', 'MergeState'), 'avgMergeState': ('avg', 'MergeState'), 'cramersVMergeState': ('cramersV', 'MergeState'), 'anyLastMergeState': ('anyLast', 'MergeState'), 'quantilesGKMergeState': ('quantilesGK', 'MergeState'), 'sequenceMatchMergeState': ('sequenceMatch', 'MergeState'), 'quantilesTimingWeightedMergeState': ('quantilesTimingWeighted', 'MergeState'), 'quantilesDeterministicMergeState': ('quantilesDeterministic', 'MergeState'), 'sumCountMergeState': ('sumCount', 'MergeState'), 'maxIntersectionsMergeState': ('maxIntersections', 'MergeState'), 'stddevSampMergeState': ('stddevSamp', 'MergeState'), 'groupBitmapAndMergeState': ('groupBitmapAnd', 'MergeState'), 'groupArrayMergeState': ('groupArray', 'MergeState'), 'uniqCombinedMergeState': ('uniqCombined', 'MergeState'), 'skewSampMergeState': ('skewSamp', 'MergeState'), 'groupBitmapMergeState': ('groupBitmap', 'MergeState'), 'quantilesBFloat16MergeState': ('quantilesBFloat16', 'MergeState'), 'quantilesTDigestMergeState': ('quantilesTDigest', 'MergeState'), 'sequenceCountMergeState': ('sequenceCount', 'MergeState'), 'uniqCombined64MergeState': ('uniqCombined64', 'MergeState'), 'entropyMergeState': ('entropy', 'MergeState'), 'quantilesTDigestWeightedMergeState': ('quantilesTDigestWeighted', 'MergeState'), 'quantileExactMergeState': ('quantileExact', 'MergeState'), 'categoricalInformationValueMergeState': ('categoricalInformationValue', 'MergeState'), 'topKMergeState': ('topK', 'MergeState'), 'groupBitAndMergeState': ('groupBitAnd', 'MergeState'), 'stddevPopMergeState': ('stddevPop', 'MergeState'), 'quantileBFloat16WeightedMergeState': ('quantileBFloat16Weighted', 'MergeState'), 'quantileTimingMergeState': ('quantileTiming', 'MergeState'), 'groupConcatMergeState': ('groupConcat', 'MergeState'), 'corrMergeState': ('corr', 'MergeState'), 'sumWithOverflowMergeState': ('sumWithOverflow', 'MergeState'), 'last_valueMergeState': ('last_value', 'MergeState'), 'argMaxMergeState': ('argMax', 'MergeState'), 'quantilesTimingMergeState': ('quantilesTiming', 'MergeState'), 'groupArrayMovingSumMergeState': ('groupArrayMovingSum', 'MergeState'), 'deltaSumTimestampMergeState': ('deltaSumTimestamp', 'MergeState'), 'quantilesBFloat16WeightedMergeState': ('quantilesBFloat16Weighted', 'MergeState'), 'intervalLengthSumMergeState': ('intervalLengthSum', 'MergeState'), 'sumKahanOrDefault': ('sumKahan', 'OrDefault'), 'quantilesExactHighOrDefault': ('quantilesExactHigh', 'OrDefault'), 'anyOrDefault': ('any', 'OrDefault'), 'uniqThetaOrDefault': ('uniqTheta', 'OrDefault'), 'groupBitXorOrDefault': ('groupBitXor', 'OrDefault'), 'theilsUOrDefault': ('theilsU', 'OrDefault'), 'boundingRatioOrDefault': ('boundingRatio', 'OrDefault'), 'histogramOrDefault': ('histogram', 'OrDefault'), 'kolmogorovSmirnovTestOrDefault': ('kolmogorovSmirnovTest', 'OrDefault'), 'groupBitmapXorOrDefault': ('groupBitmapXor', 'OrDefault'), 'quantileDeterministicOrDefault': ('quantileDeterministic', 'OrDefault'), 'varPopOrDefault': ('varPop', 'OrDefault'), 'first_valueOrDefault': ('first_value', 'OrDefault'), 'uniqHLL12OrDefault': ('uniqHLL12', 'OrDefault'), 'minMapOrDefault': ('minMap', 'OrDefault'), 'simpleLinearRegressionOrDefault': ('simpleLinearRegression', 'OrDefault'), 'quantilesInterpolatedWeightedOrDefault': ('quantilesInterpolatedWeighted', 'OrDefault'), 'maxOrDefault': ('max', 'OrDefault'), 'quantileTDigestWeightedOrDefault': ('quantileTDigestWeighted', 'OrDefault'), 'groupUniqArrayOrDefault': ('groupUniqArray', 'OrDefault'), 'meanZTestOrDefault': ('meanZTest', 'OrDefault'), 'stochasticLogisticRegressionOrDefault': ('stochasticLogisticRegression', 'OrDefault'), 'cramersVBiasCorrectedOrDefault': ('cramersVBiasCorrected', 'OrDefault'), 'covarPopOrDefault': ('covarPop', 'OrDefault'), 'countOrDefault': ('count', 'OrDefault'), 'deltaSumOrDefault': ('deltaSum', 'OrDefault'), 'quantileInterpolatedWeightedOrDefault': ('quantileInterpolatedWeighted', 'OrDefault'), 'quantileGKOrDefault': ('quantileGK', 'OrDefault'), 'anyHeavyOrDefault': ('anyHeavy', 'OrDefault'), 'uniqUpToOrDefault': ('uniqUpTo', 'OrDefault'), 'studentTTestOrDefault': ('studentTTest', 'OrDefault'), 'varSampOrDefault': ('varSamp', 'OrDefault'), 'groupBitmapOrOrDefault': ('groupBitmapOr', 'OrDefault'), 'argMinOrDefault': ('argMin', 'OrDefault'), 'contingencyOrDefault': ('contingency', 'OrDefault'), 'quantilesExactLowOrDefault': ('quantilesExactLow', 'OrDefault'), 'covarSampOrDefault': ('covarSamp', 'OrDefault'), 'mannWhitneyUTestOrDefault': ('mannWhitneyUTest', 'OrDefault'), 'quantilesExactWeightedOrDefault': ('quantilesExactWeighted', 'OrDefault'), 'quantileTimingWeightedOrDefault': ('quantileTimingWeighted', 'OrDefault'), 'minOrDefault': ('min', 'OrDefault'), 'approx_top_sumOrDefault': ('approx_top_sum', 'OrDefault'), 'uniqOrDefault': ('uniq', 'OrDefault'), 'quantilesExactOrDefault': ('quantilesExact', 'OrDefault'), 'retentionOrDefault': ('retention', 'OrDefault'), 'uniqExactOrDefault': ('uniqExact', 'OrDefault'), 'stochasticLinearRegressionOrDefault': ('stochasticLinearRegression', 'OrDefault'), 'quantilesExactExclusiveOrDefault': ('quantilesExactExclusive', 'OrDefault'), 'sparkBarOrDefault': ('sparkBar', 'OrDefault'), 'skewPopOrDefault': ('skewPop', 'OrDefault'), 'groupArrayMovingAvgOrDefault': ('groupArrayMovingAvg', 'OrDefault'), 'medianOrDefault': ('median', 'OrDefault'), 'groupArrayLastOrDefault': ('groupArrayLast', 'OrDefault'), 'kurtPopOrDefault': ('kurtPop', 'OrDefault'), 'exponentialMovingAverageOrDefault': ('exponentialMovingAverage', 'OrDefault'), 'sequenceNextNodeOrDefault': ('sequenceNextNode', 'OrDefault'), 'quantileOrDefault': ('quantile', 'OrDefault'), 'groupArrayInsertAtOrDefault': ('groupArrayInsertAt', 'OrDefault'), 'sumOrDefault': ('sum', 'OrDefault'), 'quantileBFloat16OrDefault': ('quantileBFloat16', 'OrDefault'), 'rankCorrOrDefault': ('rankCorr', 'OrDefault'), 'quantileTDigestOrDefault': ('quantileTDigest', 'OrDefault'), 'maxIntersectionsPositionOrDefault': ('maxIntersectionsPosition', 'OrDefault'), 'sumMapOrDefault': ('sumMap', 'OrDefault'), 'kurtSampOrDefault': ('kurtSamp', 'OrDefault'), 'exponentialTimeDecayedAvgOrDefault': ('exponentialTimeDecayedAvg', 'OrDefault'), 'avgWeightedOrDefault': ('avgWeighted', 'OrDefault'), 'topKWeightedOrDefault': ('topKWeighted', 'OrDefault'), 'largestTriangleThreeBucketsOrDefault': ('largestTriangleThreeBuckets', 'OrDefault'), 'groupArraySampleOrDefault': ('groupArraySample', 'OrDefault'), 'quantileExactHighOrDefault': ('quantileExactHigh', 'OrDefault'), 'windowFunnelOrDefault': ('windowFunnel', 'OrDefault'), 'quantileExactWeightedOrDefault': ('quantileExactWeighted', 'OrDefault'), 'quantileExactLowOrDefault': ('quantileExactLow', 'OrDefault'), 'maxMapOrDefault': ('maxMap', 'OrDefault'), 'welchTTestOrDefault': ('welchTTest', 'OrDefault'), 'groupBitOrOrDefault': ('groupBitOr', 'OrDefault'), 'quantilesOrDefault': ('quantiles', 'OrDefault'), 'avgOrDefault': ('avg', 'OrDefault'), 'cramersVOrDefault': ('cramersV', 'OrDefault'), 'anyLastOrDefault': ('anyLast', 'OrDefault'), 'quantilesGKOrDefault': ('quantilesGK', 'OrDefault'), 'sequenceMatchOrDefault': ('sequenceMatch', 'OrDefault'), 'quantilesTimingWeightedOrDefault': ('quantilesTimingWeighted', 'OrDefault'), 'quantilesDeterministicOrDefault': ('quantilesDeterministic', 'OrDefault'), 'sumCountOrDefault': ('sumCount', 'OrDefault'), 'maxIntersectionsOrDefault': ('maxIntersections', 'OrDefault'), 'stddevSampOrDefault': ('stddevSamp', 'OrDefault'), 'groupBitmapAndOrDefault': ('groupBitmapAnd', 'OrDefault'), 'groupArrayOrDefault': ('groupArray', 'OrDefault'), 'uniqCombinedOrDefault': ('uniqCombined', 'OrDefault'), 'skewSampOrDefault': ('skewSamp', 'OrDefault'), 'groupBitmapOrDefault': ('groupBitmap', 'OrDefault'), 'quantilesBFloat16OrDefault': ('quantilesBFloat16', 'OrDefault'), 'quantilesTDigestOrDefault': ('quantilesTDigest', 'OrDefault'), 'sequenceCountOrDefault': ('sequenceCount', 'OrDefault'), 'uniqCombined64OrDefault': ('uniqCombined64', 'OrDefault'), 'entropyOrDefault': ('entropy', 'OrDefault'), 'quantilesTDigestWeightedOrDefault': ('quantilesTDigestWeighted', 'OrDefault'), 'quantileExactOrDefault': ('quantileExact', 'OrDefault'), 'categoricalInformationValueOrDefault': ('categoricalInformationValue', 'OrDefault'), 'topKOrDefault': ('topK', 'OrDefault'), 'groupBitAndOrDefault': ('groupBitAnd', 'OrDefault'), 'stddevPopOrDefault': ('stddevPop', 'OrDefault'), 'quantileBFloat16WeightedOrDefault': ('quantileBFloat16Weighted', 'OrDefault'), 'quantileTimingOrDefault': ('quantileTiming', 'OrDefault'), 'groupConcatOrDefault': ('groupConcat', 'OrDefault'), 'corrOrDefault': ('corr', 'OrDefault'), 'sumWithOverflowOrDefault': ('sumWithOverflow', 'OrDefault'), 'last_valueOrDefault': ('last_value', 'OrDefault'), 'argMaxOrDefault': ('argMax', 'OrDefault'), 'quantilesTimingOrDefault': ('quantilesTiming', 'OrDefault'), 'groupArrayMovingSumOrDefault': ('groupArrayMovingSum', 'OrDefault'), 'deltaSumTimestampOrDefault': ('deltaSumTimestamp', 'OrDefault'), 'quantilesBFloat16WeightedOrDefault': ('quantilesBFloat16Weighted', 'OrDefault'), 'intervalLengthSumOrDefault': ('intervalLengthSum', 'OrDefault'), 'sumKahanDistinct': ('sumKahan', 'Distinct'), 'quantilesExactHighDistinct': ('quantilesExactHigh', 'Distinct'), 'anyDistinct': ('any', 'Distinct'), 'uniqThetaDistinct': ('uniqTheta', 'Distinct'), 'groupBitXorDistinct': ('groupBitXor', 'Distinct'), 'theilsUDistinct': ('theilsU', 'Distinct'), 'boundingRatioDistinct': ('boundingRatio', 'Distinct'), 'histogramDistinct': ('histogram', 'Distinct'), 'kolmogorovSmirnovTestDistinct': ('kolmogorovSmirnovTest', 'Distinct'), 'groupBitmapXorDistinct': ('groupBitmapXor', 'Distinct'), 'quantileDeterministicDistinct': ('quantileDeterministic', 'Distinct'), 'varPopDistinct': ('varPop', 'Distinct'), 'first_valueDistinct': ('first_value', 'Distinct'), 'uniqHLL12Distinct': ('uniqHLL12', 'Distinct'), 'minMapDistinct': ('minMap', 'Distinct'), 'simpleLinearRegressionDistinct': ('simpleLinearRegression', 'Distinct'), 'quantilesInterpolatedWeightedDistinct': ('quantilesInterpolatedWeighted', 'Distinct'), 'maxDistinct': ('max', 'Distinct'), 'quantileTDigestWeightedDistinct': ('quantileTDigestWeighted', 'Distinct'), 'groupUniqArrayDistinct': ('groupUniqArray', 'Distinct'), 'meanZTestDistinct': ('meanZTest', 'Distinct'), 'stochasticLogisticRegressionDistinct': ('stochasticLogisticRegression', 'Distinct'), 'cramersVBiasCorrectedDistinct': ('cramersVBiasCorrected', 'Distinct'), 'covarPopDistinct': ('covarPop', 'Distinct'), 'countDistinct': ('count', 'Distinct'), 'deltaSumDistinct': ('deltaSum', 'Distinct'), 'quantileInterpolatedWeightedDistinct': ('quantileInterpolatedWeighted', 'Distinct'), 'quantileGKDistinct': ('quantileGK', 'Distinct'), 'anyHeavyDistinct': ('anyHeavy', 'Distinct'), 'uniqUpToDistinct': ('uniqUpTo', 'Distinct'), 'studentTTestDistinct': ('studentTTest', 'Distinct'), 'varSampDistinct': ('varSamp', 'Distinct'), 'groupBitmapOrDistinct': ('groupBitmapOr', 'Distinct'), 'argMinDistinct': ('argMin', 'Distinct'), 'contingencyDistinct': ('contingency', 'Distinct'), 'quantilesExactLowDistinct': ('quantilesExactLow', 'Distinct'), 'covarSampDistinct': ('covarSamp', 'Distinct'), 'mannWhitneyUTestDistinct': ('mannWhitneyUTest', 'Distinct'), 'quantilesExactWeightedDistinct': ('quantilesExactWeighted', 'Distinct'), 'quantileTimingWeightedDistinct': ('quantileTimingWeighted', 'Distinct'), 'minDistinct': ('min', 'Distinct'), 'approx_top_sumDistinct': ('approx_top_sum', 'Distinct'), 'uniqDistinct': ('uniq', 'Distinct'), 'quantilesExactDistinct': ('quantilesExact', 'Distinct'), 'retentionDistinct': ('retention', 'Distinct'), 'uniqExactDistinct': ('uniqExact', 'Distinct'), 'stochasticLinearRegressionDistinct': ('stochasticLinearRegression', 'Distinct'), 'quantilesExactExclusiveDistinct': ('quantilesExactExclusive', 'Distinct'), 'sparkBarDistinct': ('sparkBar', 'Distinct'), 'skewPopDistinct': ('skewPop', 'Distinct'), 'groupArrayMovingAvgDistinct': ('groupArrayMovingAvg', 'Distinct'), 'medianDistinct': ('median', 'Distinct'), 'groupArrayLastDistinct': ('groupArrayLast', 'Distinct'), 'kurtPopDistinct': ('kurtPop', 'Distinct'), 'exponentialMovingAverageDistinct': ('exponentialMovingAverage', 'Distinct'), 'sequenceNextNodeDistinct': ('sequenceNextNode', 'Distinct'), 'quantileDistinct': ('quantile', 'Distinct'), 'groupArrayInsertAtDistinct': ('groupArrayInsertAt', 'Distinct'), 'sumDistinct': ('sum', 'Distinct'), 'quantileBFloat16Distinct': ('quantileBFloat16', 'Distinct'), 'rankCorrDistinct': ('rankCorr', 'Distinct'), 'quantileTDigestDistinct': ('quantileTDigest', 'Distinct'), 'maxIntersectionsPositionDistinct': ('maxIntersectionsPosition', 'Distinct'), 'sumMapDistinct': ('sumMap', 'Distinct'), 'kurtSampDistinct': ('kurtSamp', 'Distinct'), 'exponentialTimeDecayedAvgDistinct': ('exponentialTimeDecayedAvg', 'Distinct'), 'avgWeightedDistinct': ('avgWeighted', 'Distinct'), 'topKWeightedDistinct': ('topKWeighted', 'Distinct'), 'largestTriangleThreeBucketsDistinct': ('largestTriangleThreeBuckets', 'Distinct'), 'groupArraySampleDistinct': ('groupArraySample', 'Distinct'), 'quantileExactHighDistinct': ('quantileExactHigh', 'Distinct'), 'windowFunnelDistinct': ('windowFunnel', 'Distinct'), 'quantileExactWeightedDistinct': ('quantileExactWeighted', 'Distinct'), 'quantileExactLowDistinct': ('quantileExactLow', 'Distinct'), 'maxMapDistinct': ('maxMap', 'Distinct'), 'welchTTestDistinct': ('welchTTest', 'Distinct'), 'groupBitOrDistinct': ('groupBitOr', 'Distinct'), 'quantilesDistinct': ('quantiles', 'Distinct'), 'avgDistinct': ('avg', 'Distinct'), 'cramersVDistinct': ('cramersV', 'Distinct'), 'anyLastDistinct': ('anyLast', 'Distinct'), 'quantilesGKDistinct': ('quantilesGK', 'Distinct'), 'sequenceMatchDistinct': ('sequenceMatch', 'Distinct'), 'quantilesTimingWeightedDistinct': ('quantilesTimingWeighted', 'Distinct'), 'quantilesDeterministicDistinct': ('quantilesDeterministic', 'Distinct'), 'sumCountDistinct': ('sumCount', 'Distinct'), 'maxIntersectionsDistinct': ('maxIntersections', 'Distinct'), 'stddevSampDistinct': ('stddevSamp', 'Distinct'), 'groupBitmapAndDistinct': ('groupBitmapAnd', 'Distinct'), 'groupArrayDistinct': ('groupArray', 'Distinct'), 'uniqCombinedDistinct': ('uniqCombined', 'Distinct'), 'skewSampDistinct': ('skewSamp', 'Distinct'), 'groupBitmapDistinct': ('groupBitmap', 'Distinct'), 'quantilesBFloat16Distinct': ('quantilesBFloat16', 'Distinct'), 'quantilesTDigestDistinct': ('quantilesTDigest', 'Distinct'), 'sequenceCountDistinct': ('sequenceCount', 'Distinct'), 'uniqCombined64Distinct': ('uniqCombined64', 'Distinct'), 'entropyDistinct': ('entropy', 'Distinct'), 'quantilesTDigestWeightedDistinct': ('quantilesTDigestWeighted', 'Distinct'), 'quantileExactDistinct': ('quantileExact', 'Distinct'), 'categoricalInformationValueDistinct': ('categoricalInformationValue', 'Distinct'), 'topKDistinct': ('topK', 'Distinct'), 'groupBitAndDistinct': ('groupBitAnd', 'Distinct'), 'stddevPopDistinct': ('stddevPop', 'Distinct'), 'quantileBFloat16WeightedDistinct': ('quantileBFloat16Weighted', 'Distinct'), 'quantileTimingDistinct': ('quantileTiming', 'Distinct'), 'groupConcatDistinct': ('groupConcat', 'Distinct'), 'corrDistinct': ('corr', 'Distinct'), 'sumWithOverflowDistinct': ('sumWithOverflow', 'Distinct'), 'last_valueDistinct': ('last_value', 'Distinct'), 'argMaxDistinct': ('argMax', 'Distinct'), 'quantilesTimingDistinct': ('quantilesTiming', 'Distinct'), 'groupArrayMovingSumDistinct': ('groupArrayMovingSum', 'Distinct'), 'deltaSumTimestampDistinct': ('deltaSumTimestamp', 'Distinct'), 'quantilesBFloat16WeightedDistinct': ('quantilesBFloat16Weighted', 'Distinct'), 'intervalLengthSumDistinct': ('intervalLengthSum', 'Distinct'), 'sumKahanResample': ('sumKahan', 'Resample'), 'quantilesExactHighResample': ('quantilesExactHigh', 'Resample'), 'anyResample': ('any', 'Resample'), 'uniqThetaResample': ('uniqTheta', 'Resample'), 'groupBitXorResample': ('groupBitXor', 'Resample'), 'theilsUResample': ('theilsU', 'Resample'), 'boundingRatioResample': ('boundingRatio', 'Resample'), 'histogramResample': ('histogram', 'Resample'), 'kolmogorovSmirnovTestResample': ('kolmogorovSmirnovTest', 'Resample'), 'groupBitmapXorResample': ('groupBitmapXor', 'Resample'), 'quantileDeterministicResample': ('quantileDeterministic', 'Resample'), 'varPopResample': ('varPop', 'Resample'), 'first_valueResample': ('first_value', 'Resample'), 'uniqHLL12Resample': ('uniqHLL12', 'Resample'), 'minMapResample': ('minMap', 'Resample'), 'simpleLinearRegressionResample': ('simpleLinearRegression', 'Resample'), 'quantilesInterpolatedWeightedResample': ('quantilesInterpolatedWeighted', 'Resample'), 'maxResample': ('max', 'Resample'), 'quantileTDigestWeightedResample': ('quantileTDigestWeighted', 'Resample'), 'groupUniqArrayResample': ('groupUniqArray', 'Resample'), 'meanZTestResample': ('meanZTest', 'Resample'), 'stochasticLogisticRegressionResample': ('stochasticLogisticRegression', 'Resample'), 'cramersVBiasCorrectedResample': ('cramersVBiasCorrected', 'Resample'), 'covarPopResample': ('covarPop', 'Resample'), 'countResample': ('count', 'Resample'), 'deltaSumResample': ('deltaSum', 'Resample'), 'quantileInterpolatedWeightedResample': ('quantileInterpolatedWeighted', 'Resample'), 'quantileGKResample': ('quantileGK', 'Resample'), 'anyHeavyResample': ('anyHeavy', 'Resample'), 'uniqUpToResample': ('uniqUpTo', 'Resample'), 'studentTTestResample': ('studentTTest', 'Resample'), 'varSampResample': ('varSamp', 'Resample'), 'groupBitmapOrResample': ('groupBitmapOr', 'Resample'), 'argMinResample': ('argMin', 'Resample'), 'contingencyResample': ('contingency', 'Resample'), 'quantilesExactLowResample': ('quantilesExactLow', 'Resample'), 'covarSampResample': ('covarSamp', 'Resample'), 'mannWhitneyUTestResample': ('mannWhitneyUTest', 'Resample'), 'quantilesExactWeightedResample': ('quantilesExactWeighted', 'Resample'), 'quantileTimingWeightedResample': ('quantileTimingWeighted', 'Resample'), 'minResample': ('min', 'Resample'), 'approx_top_sumResample': ('approx_top_sum', 'Resample'), 'uniqResample': ('uniq', 'Resample'), 'quantilesExactResample': ('quantilesExact', 'Resample'), 'retentionResample': ('retention', 'Resample'), 'uniqExactResample': ('uniqExact', 'Resample'), 'stochasticLinearRegressionResample': ('stochasticLinearRegression', 'Resample'), 'quantilesExactExclusiveResample': ('quantilesExactExclusive', 'Resample'), 'sparkBarResample': ('sparkBar', 'Resample'), 'skewPopResample': ('skewPop', 'Resample'), 'groupArrayMovingAvgResample': ('groupArrayMovingAvg', 'Resample'), 'medianResample': ('median', 'Resample'), 'groupArrayLastResample': ('groupArrayLast', 'Resample'), 'kurtPopResample': ('kurtPop', 'Resample'), 'exponentialMovingAverageResample': ('exponentialMovingAverage', 'Resample'), 'sequenceNextNodeResample': ('sequenceNextNode', 'Resample'), 'quantileResample': ('quantile', 'Resample'), 'groupArrayInsertAtResample': ('groupArrayInsertAt', 'Resample'), 'sumResample': ('sum', 'Resample'), 'quantileBFloat16Resample': ('quantileBFloat16', 'Resample'), 'rankCorrResample': ('rankCorr', 'Resample'), 'quantileTDigestResample': ('quantileTDigest', 'Resample'), 'maxIntersectionsPositionResample': ('maxIntersectionsPosition', 'Resample'), 'sumMapResample': ('sumMap', 'Resample'), 'kurtSampResample': ('kurtSamp', 'Resample'), 'exponentialTimeDecayedAvgResample': ('exponentialTimeDecayedAvg', 'Resample'), 'avgWeightedResample': ('avgWeighted', 'Resample'), 'topKWeightedResample': ('topKWeighted', 'Resample'), 'largestTriangleThreeBucketsResample': ('largestTriangleThreeBuckets', 'Resample'), 'groupArraySampleResample': ('groupArraySample', 'Resample'), 'quantileExactHighResample': ('quantileExactHigh', 'Resample'), 'windowFunnelResample': ('windowFunnel', 'Resample'), 'quantileExactWeightedResample': ('quantileExactWeighted', 'Resample'), 'quantileExactLowResample': ('quantileExactLow', 'Resample'), 'maxMapResample': ('maxMap', 'Resample'), 'welchTTestResample': ('welchTTest', 'Resample'), 'groupBitOrResample': ('groupBitOr', 'Resample'), 'quantilesResample': ('quantiles', 'Resample'), 'avgResample': ('avg', 'Resample'), 'cramersVResample': ('cramersV', 'Resample'), 'anyLastResample': ('anyLast', 'Resample'), 'quantilesGKResample': ('quantilesGK', 'Resample'), 'sequenceMatchResample': ('sequenceMatch', 'Resample'), 'quantilesTimingWeightedResample': ('quantilesTimingWeighted', 'Resample'), 'quantilesDeterministicResample': ('quantilesDeterministic', 'Resample'), 'sumCountResample': ('sumCount', 'Resample'), 'maxIntersectionsResample': ('maxIntersections', 'Resample'), 'stddevSampResample': ('stddevSamp', 'Resample'), 'groupBitmapAndResample': ('groupBitmapAnd', 'Resample'), 'groupArrayResample': ('groupArray', 'Resample'), 'uniqCombinedResample': ('uniqCombined', 'Resample'), 'skewSampResample': ('skewSamp', 'Resample'), 'groupBitmapResample': ('groupBitmap', 'Resample'), 'quantilesBFloat16Resample': ('quantilesBFloat16', 'Resample'), 'quantilesTDigestResample': ('quantilesTDigest', 'Resample'), 'sequenceCountResample': ('sequenceCount', 'Resample'), 'uniqCombined64Resample': ('uniqCombined64', 'Resample'), 'entropyResample': ('entropy', 'Resample'), 'quantilesTDigestWeightedResample': ('quantilesTDigestWeighted', 'Resample'), 'quantileExactResample': ('quantileExact', 'Resample'), 'categoricalInformationValueResample': ('categoricalInformationValue', 'Resample'), 'topKResample': ('topK', 'Resample'), 'groupBitAndResample': ('groupBitAnd', 'Resample'), 'stddevPopResample': ('stddevPop', 'Resample'), 'quantileBFloat16WeightedResample': ('quantileBFloat16Weighted', 'Resample'), 'quantileTimingResample': ('quantileTiming', 'Resample'), 'groupConcatResample': ('groupConcat', 'Resample'), 'corrResample': ('corr', 'Resample'), 'sumWithOverflowResample': ('sumWithOverflow', 'Resample'), 'last_valueResample': ('last_value', 'Resample'), 'argMaxResample': ('argMax', 'Resample'), 'quantilesTimingResample': ('quantilesTiming', 'Resample'), 'groupArrayMovingSumResample': ('groupArrayMovingSum', 'Resample'), 'deltaSumTimestampResample': ('deltaSumTimestamp', 'Resample'), 'quantilesBFloat16WeightedResample': ('quantilesBFloat16Weighted', 'Resample'), 'intervalLengthSumResample': ('intervalLengthSum', 'Resample'), 'sumKahanArrayIf': ('sumKahan', 'ArrayIf'), 'quantilesExactHighArrayIf': ('quantilesExactHigh', 'ArrayIf'), 'anyArrayIf': ('any', 'ArrayIf'), 'uniqThetaArrayIf': ('uniqTheta', 'ArrayIf'), 'groupBitXorArrayIf': ('groupBitXor', 'ArrayIf'), 'theilsUArrayIf': ('theilsU', 'ArrayIf'), 'boundingRatioArrayIf': ('boundingRatio', 'ArrayIf'), 'histogramArrayIf': ('histogram', 'ArrayIf'), 'kolmogorovSmirnovTestArrayIf': ('kolmogorovSmirnovTest', 'ArrayIf'), 'groupBitmapXorArrayIf': ('groupBitmapXor', 'ArrayIf'), 'quantileDeterministicArrayIf': ('quantileDeterministic', 'ArrayIf'), 'varPopArrayIf': ('varPop', 'ArrayIf'), 'first_valueArrayIf': ('first_value', 'ArrayIf'), 'uniqHLL12ArrayIf': ('uniqHLL12', 'ArrayIf'), 'minMapArrayIf': ('minMap', 'ArrayIf'), 'simpleLinearRegressionArrayIf': ('simpleLinearRegression', 'ArrayIf'), 'quantilesInterpolatedWeightedArrayIf': ('quantilesInterpolatedWeighted', 'ArrayIf'), 'maxArrayIf': ('max', 'ArrayIf'), 'quantileTDigestWeightedArrayIf': ('quantileTDigestWeighted', 'ArrayIf'), 'groupUniqArrayArrayIf': ('groupUniqArray', 'ArrayIf'), 'meanZTestArrayIf': ('meanZTest', 'ArrayIf'), 'stochasticLogisticRegressionArrayIf': ('stochasticLogisticRegression', 'ArrayIf'), 'cramersVBiasCorrectedArrayIf': ('cramersVBiasCorrected', 'ArrayIf'), 'covarPopArrayIf': ('covarPop', 'ArrayIf'), 'countArrayIf': ('count', 'ArrayIf'), 'deltaSumArrayIf': ('deltaSum', 'ArrayIf'), 'quantileInterpolatedWeightedArrayIf': ('quantileInterpolatedWeighted', 'ArrayIf'), 'quantileGKArrayIf': ('quantileGK', 'ArrayIf'), 'anyHeavyArrayIf': ('anyHeavy', 'ArrayIf'), 'uniqUpToArrayIf': ('uniqUpTo', 'ArrayIf'), 'studentTTestArrayIf': ('studentTTest', 'ArrayIf'), 'varSampArrayIf': ('varSamp', 'ArrayIf'), 'groupBitmapOrArrayIf': ('groupBitmapOr', 'ArrayIf'), 'argMinArrayIf': ('argMin', 'ArrayIf'), 'contingencyArrayIf': ('contingency', 'ArrayIf'), 'quantilesExactLowArrayIf': ('quantilesExactLow', 'ArrayIf'), 'covarSampArrayIf': ('covarSamp', 'ArrayIf'), 'mannWhitneyUTestArrayIf': ('mannWhitneyUTest', 'ArrayIf'), 'quantilesExactWeightedArrayIf': ('quantilesExactWeighted', 'ArrayIf'), 'quantileTimingWeightedArrayIf': ('quantileTimingWeighted', 'ArrayIf'), 'minArrayIf': ('min', 'ArrayIf'), 'approx_top_sumArrayIf': ('approx_top_sum', 'ArrayIf'), 'uniqArrayIf': ('uniq', 'ArrayIf'), 'quantilesExactArrayIf': ('quantilesExact', 'ArrayIf'), 'retentionArrayIf': ('retention', 'ArrayIf'), 'uniqExactArrayIf': ('uniqExact', 'ArrayIf'), 'stochasticLinearRegressionArrayIf': ('stochasticLinearRegression', 'ArrayIf'), 'quantilesExactExclusiveArrayIf': ('quantilesExactExclusive', 'ArrayIf'), 'sparkBarArrayIf': ('sparkBar', 'ArrayIf'), 'skewPopArrayIf': ('skewPop', 'ArrayIf'), 'groupArrayMovingAvgArrayIf': ('groupArrayMovingAvg', 'ArrayIf'), 'medianArrayIf': ('median', 'ArrayIf'), 'groupArrayLastArrayIf': ('groupArrayLast', 'ArrayIf'), 'kurtPopArrayIf': ('kurtPop', 'ArrayIf'), 'exponentialMovingAverageArrayIf': ('exponentialMovingAverage', 'ArrayIf'), 'sequenceNextNodeArrayIf': ('sequenceNextNode', 'ArrayIf'), 'quantileArrayIf': ('quantile', 'ArrayIf'), 'groupArrayInsertAtArrayIf': ('groupArrayInsertAt', 'ArrayIf'), 'sumArrayIf': ('sum', 'ArrayIf'), 'quantileBFloat16ArrayIf': ('quantileBFloat16', 'ArrayIf'), 'rankCorrArrayIf': ('rankCorr', 'ArrayIf'), 'quantileTDigestArrayIf': ('quantileTDigest', 'ArrayIf'), 'maxIntersectionsPositionArrayIf': ('maxIntersectionsPosition', 'ArrayIf'), 'sumMapArrayIf': ('sumMap', 'ArrayIf'), 'kurtSampArrayIf': ('kurtSamp', 'ArrayIf'), 'exponentialTimeDecayedAvgArrayIf': ('exponentialTimeDecayedAvg', 'ArrayIf'), 'avgWeightedArrayIf': ('avgWeighted', 'ArrayIf'), 'topKWeightedArrayIf': ('topKWeighted', 'ArrayIf'), 'largestTriangleThreeBucketsArrayIf': ('largestTriangleThreeBuckets', 'ArrayIf'), 'groupArraySampleArrayIf': ('groupArraySample', 'ArrayIf'), 'quantileExactHighArrayIf': ('quantileExactHigh', 'ArrayIf'), 'windowFunnelArrayIf': ('windowFunnel', 'ArrayIf'), 'quantileExactWeightedArrayIf': ('quantileExactWeighted', 'ArrayIf'), 'quantileExactLowArrayIf': ('quantileExactLow', 'ArrayIf'), 'maxMapArrayIf': ('maxMap', 'ArrayIf'), 'welchTTestArrayIf': ('welchTTest', 'ArrayIf'), 'groupBitOrArrayIf': ('groupBitOr', 'ArrayIf'), 'quantilesArrayIf': ('quantiles', 'ArrayIf'), 'avgArrayIf': ('avg', 'ArrayIf'), 'cramersVArrayIf': ('cramersV', 'ArrayIf'), 'anyLastArrayIf': ('anyLast', 'ArrayIf'), 'quantilesGKArrayIf': ('quantilesGK', 'ArrayIf'), 'sequenceMatchArrayIf': ('sequenceMatch', 'ArrayIf'), 'quantilesTimingWeightedArrayIf': ('quantilesTimingWeighted', 'ArrayIf'), 'quantilesDeterministicArrayIf': ('quantilesDeterministic', 'ArrayIf'), 'sumCountArrayIf': ('sumCount', 'ArrayIf'), 'maxIntersectionsArrayIf': ('maxIntersections', 'ArrayIf'), 'stddevSampArrayIf': ('stddevSamp', 'ArrayIf'), 'groupBitmapAndArrayIf': ('groupBitmapAnd', 'ArrayIf'), 'groupArrayArrayIf': ('groupArray', 'ArrayIf'), 'uniqCombinedArrayIf': ('uniqCombined', 'ArrayIf'), 'skewSampArrayIf': ('skewSamp', 'ArrayIf'), 'groupBitmapArrayIf': ('groupBitmap', 'ArrayIf'), 'quantilesBFloat16ArrayIf': ('quantilesBFloat16', 'ArrayIf'), 'quantilesTDigestArrayIf': ('quantilesTDigest', 'ArrayIf'), 'sequenceCountArrayIf': ('sequenceCount', 'ArrayIf'), 'uniqCombined64ArrayIf': ('uniqCombined64', 'ArrayIf'), 'entropyArrayIf': ('entropy', 'ArrayIf'), 'quantilesTDigestWeightedArrayIf': ('quantilesTDigestWeighted', 'ArrayIf'), 'quantileExactArrayIf': ('quantileExact', 'ArrayIf'), 'categoricalInformationValueArrayIf': ('categoricalInformationValue', 'ArrayIf'), 'topKArrayIf': ('topK', 'ArrayIf'), 'groupBitAndArrayIf': ('groupBitAnd', 'ArrayIf'), 'stddevPopArrayIf': ('stddevPop', 'ArrayIf'), 'quantileBFloat16WeightedArrayIf': ('quantileBFloat16Weighted', 'ArrayIf'), 'quantileTimingArrayIf': ('quantileTiming', 'ArrayIf'), 'groupConcatArrayIf': ('groupConcat', 'ArrayIf'), 'corrArrayIf': ('corr', 'ArrayIf'), 'sumWithOverflowArrayIf': ('sumWithOverflow', 'ArrayIf'), 'last_valueArrayIf': ('last_value', 'ArrayIf'), 'argMaxArrayIf': ('argMax', 'ArrayIf'), 'quantilesTimingArrayIf': ('quantilesTiming', 'ArrayIf'), 'groupArrayMovingSumArrayIf': ('groupArrayMovingSum', 'ArrayIf'), 'deltaSumTimestampArrayIf': ('deltaSumTimestamp', 'ArrayIf'), 'quantilesBFloat16WeightedArrayIf': ('quantilesBFloat16Weighted', 'ArrayIf'), 'intervalLengthSumArrayIf': ('intervalLengthSum', 'ArrayIf'), 'sumKahanForEach': ('sumKahan', 'ForEach'), 'quantilesExactHighForEach': ('quantilesExactHigh', 'ForEach'), 'anyForEach': ('any', 'ForEach'), 'uniqThetaForEach': ('uniqTheta', 'ForEach'), 'groupBitXorForEach': ('groupBitXor', 'ForEach'), 'theilsUForEach': ('theilsU', 'ForEach'), 'boundingRatioForEach': ('boundingRatio', 'ForEach'), 'histogramForEach': ('histogram', 'ForEach'), 'kolmogorovSmirnovTestForEach': ('kolmogorovSmirnovTest', 'ForEach'), 'groupBitmapXorForEach': ('groupBitmapXor', 'ForEach'), 'quantileDeterministicForEach': ('quantileDeterministic', 'ForEach'), 'varPopForEach': ('varPop', 'ForEach'), 'first_valueForEach': ('first_value', 'ForEach'), 'uniqHLL12ForEach': ('uniqHLL12', 'ForEach'), 'minMapForEach': ('minMap', 'ForEach'), 'simpleLinearRegressionForEach': ('simpleLinearRegression', 'ForEach'), 'quantilesInterpolatedWeightedForEach': ('quantilesInterpolatedWeighted', 'ForEach'), 'maxForEach': ('max', 'ForEach'), 'quantileTDigestWeightedForEach': ('quantileTDigestWeighted', 'ForEach'), 'groupUniqArrayForEach': ('groupUniqArray', 'ForEach'), 'meanZTestForEach': ('meanZTest', 'ForEach'), 'stochasticLogisticRegressionForEach': ('stochasticLogisticRegression', 'ForEach'), 'cramersVBiasCorrectedForEach': ('cramersVBiasCorrected', 'ForEach'), 'covarPopForEach': ('covarPop', 'ForEach'), 'countForEach': ('count', 'ForEach'), 'deltaSumForEach': ('deltaSum', 'ForEach'), 'quantileInterpolatedWeightedForEach': ('quantileInterpolatedWeighted', 'ForEach'), 'quantileGKForEach': ('quantileGK', 'ForEach'), 'anyHeavyForEach': ('anyHeavy', 'ForEach'), 'uniqUpToForEach': ('uniqUpTo', 'ForEach'), 'studentTTestForEach': ('studentTTest', 'ForEach'), 'varSampForEach': ('varSamp', 'ForEach'), 'groupBitmapOrForEach': ('groupBitmapOr', 'ForEach'), 'argMinForEach': ('argMin', 'ForEach'), 'contingencyForEach': ('contingency', 'ForEach'), 'quantilesExactLowForEach': ('quantilesExactLow', 'ForEach'), 'covarSampForEach': ('covarSamp', 'ForEach'), 'mannWhitneyUTestForEach': ('mannWhitneyUTest', 'ForEach'), 'quantilesExactWeightedForEach': ('quantilesExactWeighted', 'ForEach'), 'quantileTimingWeightedForEach': ('quantileTimingWeighted', 'ForEach'), 'minForEach': ('min', 'ForEach'), 'approx_top_sumForEach': ('approx_top_sum', 'ForEach'), 'uniqForEach': ('uniq', 'ForEach'), 'quantilesExactForEach': ('quantilesExact', 'ForEach'), 'retentionForEach': ('retention', 'ForEach'), 'uniqExactForEach': ('uniqExact', 'ForEach'), 'stochasticLinearRegressionForEach': ('stochasticLinearRegression', 'ForEach'), 'quantilesExactExclusiveForEach': ('quantilesExactExclusive', 'ForEach'), 'sparkBarForEach': ('sparkBar', 'ForEach'), 'skewPopForEach': ('skewPop', 'ForEach'), 'groupArrayMovingAvgForEach': ('groupArrayMovingAvg', 'ForEach'), 'medianForEach': ('median', 'ForEach'), 'groupArrayLastForEach': ('groupArrayLast', 'ForEach'), 'kurtPopForEach': ('kurtPop', 'ForEach'), 'exponentialMovingAverageForEach': ('exponentialMovingAverage', 'ForEach'), 'sequenceNextNodeForEach': ('sequenceNextNode', 'ForEach'), 'quantileForEach': ('quantile', 'ForEach'), 'groupArrayInsertAtForEach': ('groupArrayInsertAt', 'ForEach'), 'sumForEach': ('sum', 'ForEach'), 'quantileBFloat16ForEach': ('quantileBFloat16', 'ForEach'), 'rankCorrForEach': ('rankCorr', 'ForEach'), 'quantileTDigestForEach': ('quantileTDigest', 'ForEach'), 'maxIntersectionsPositionForEach': ('maxIntersectionsPosition', 'ForEach'), 'sumMapForEach': ('sumMap', 'ForEach'), 'kurtSampForEach': ('kurtSamp', 'ForEach'), 'exponentialTimeDecayedAvgForEach': ('exponentialTimeDecayedAvg', 'ForEach'), 'avgWeightedForEach': ('avgWeighted', 'ForEach'), 'topKWeightedForEach': ('topKWeighted', 'ForEach'), 'largestTriangleThreeBucketsForEach': ('largestTriangleThreeBuckets', 'ForEach'), 'groupArraySampleForEach': ('groupArraySample', 'ForEach'), 'quantileExactHighForEach': ('quantileExactHigh', 'ForEach'), 'windowFunnelForEach': ('windowFunnel', 'ForEach'), 'quantileExactWeightedForEach': ('quantileExactWeighted', 'ForEach'), 'quantileExactLowForEach': ('quantileExactLow', 'ForEach'), 'maxMapForEach': ('maxMap', 'ForEach'), 'welchTTestForEach': ('welchTTest', 'ForEach'), 'groupBitOrForEach': ('groupBitOr', 'ForEach'), 'quantilesForEach': ('quantiles', 'ForEach'), 'avgForEach': ('avg', 'ForEach'), 'cramersVForEach': ('cramersV', 'ForEach'), 'anyLastForEach': ('anyLast', 'ForEach'), 'quantilesGKForEach': ('quantilesGK', 'ForEach'), 'sequenceMatchForEach': ('sequenceMatch', 'ForEach'), 'quantilesTimingWeightedForEach': ('quantilesTimingWeighted', 'ForEach'), 'quantilesDeterministicForEach': ('quantilesDeterministic', 'ForEach'), 'sumCountForEach': ('sumCount', 'ForEach'), 'maxIntersectionsForEach': ('maxIntersections', 'ForEach'), 'stddevSampForEach': ('stddevSamp', 'ForEach'), 'groupBitmapAndForEach': ('groupBitmapAnd', 'ForEach'), 'groupArrayForEach': ('groupArray', 'ForEach'), 'uniqCombinedForEach': ('uniqCombined', 'ForEach'), 'skewSampForEach': ('skewSamp', 'ForEach'), 'groupBitmapForEach': ('groupBitmap', 'ForEach'), 'quantilesBFloat16ForEach': ('quantilesBFloat16', 'ForEach'), 'quantilesTDigestForEach': ('quantilesTDigest', 'ForEach'), 'sequenceCountForEach': ('sequenceCount', 'ForEach'), 'uniqCombined64ForEach': ('uniqCombined64', 'ForEach'), 'entropyForEach': ('entropy', 'ForEach'), 'quantilesTDigestWeightedForEach': ('quantilesTDigestWeighted', 'ForEach'), 'quantileExactForEach': ('quantileExact', 'ForEach'), 'categoricalInformationValueForEach': ('categoricalInformationValue', 'ForEach'), 'topKForEach': ('topK', 'ForEach'), 'groupBitAndForEach': ('groupBitAnd', 'ForEach'), 'stddevPopForEach': ('stddevPop', 'ForEach'), 'quantileBFloat16WeightedForEach': ('quantileBFloat16Weighted', 'ForEach'), 'quantileTimingForEach': ('quantileTiming', 'ForEach'), 'groupConcatForEach': ('groupConcat', 'ForEach'), 'corrForEach': ('corr', 'ForEach'), 'sumWithOverflowForEach': ('sumWithOverflow', 'ForEach'), 'last_valueForEach': ('last_value', 'ForEach'), 'argMaxForEach': ('argMax', 'ForEach'), 'quantilesTimingForEach': ('quantilesTiming', 'ForEach'), 'groupArrayMovingSumForEach': ('groupArrayMovingSum', 'ForEach'), 'deltaSumTimestampForEach': ('deltaSumTimestamp', 'ForEach'), 'quantilesBFloat16WeightedForEach': ('quantilesBFloat16Weighted', 'ForEach'), 'intervalLengthSumForEach': ('intervalLengthSum', 'ForEach'), 'sumKahanOrNull': ('sumKahan', 'OrNull'), 'quantilesExactHighOrNull': ('quantilesExactHigh', 'OrNull'), 'anyOrNull': ('any', 'OrNull'), 'uniqThetaOrNull': ('uniqTheta', 'OrNull'), 'groupBitXorOrNull': ('groupBitXor', 'OrNull'), 'theilsUOrNull': ('theilsU', 'OrNull'), 'boundingRatioOrNull': ('boundingRatio', 'OrNull'), 'histogramOrNull': ('histogram', 'OrNull'), 'kolmogorovSmirnovTestOrNull': ('kolmogorovSmirnovTest', 'OrNull'), 'groupBitmapXorOrNull': ('groupBitmapXor', 'OrNull'), 'quantileDeterministicOrNull': ('quantileDeterministic', 'OrNull'), 'varPopOrNull': ('varPop', 'OrNull'), 'first_valueOrNull': ('first_value', 'OrNull'), 'uniqHLL12OrNull': ('uniqHLL12', 'OrNull'), 'minMapOrNull': ('minMap', 'OrNull'), 'simpleLinearRegressionOrNull': ('simpleLinearRegression', 'OrNull'), 'quantilesInterpolatedWeightedOrNull': ('quantilesInterpolatedWeighted', 'OrNull'), 'maxOrNull': ('max', 'OrNull'), 'quantileTDigestWeightedOrNull': ('quantileTDigestWeighted', 'OrNull'), 'groupUniqArrayOrNull': ('groupUniqArray', 'OrNull'), 'meanZTestOrNull': ('meanZTest', 'OrNull'), 'stochasticLogisticRegressionOrNull': ('stochasticLogisticRegression', 'OrNull'), 'cramersVBiasCorrectedOrNull': ('cramersVBiasCorrected', 'OrNull'), 'covarPopOrNull': ('covarPop', 'OrNull'), 'countOrNull': ('count', 'OrNull'), 'deltaSumOrNull': ('deltaSum', 'OrNull'), 'quantileInterpolatedWeightedOrNull': ('quantileInterpolatedWeighted', 'OrNull'), 'quantileGKOrNull': ('quantileGK', 'OrNull'), 'anyHeavyOrNull': ('anyHeavy', 'OrNull'), 'uniqUpToOrNull': ('uniqUpTo', 'OrNull'), 'studentTTestOrNull': ('studentTTest', 'OrNull'), 'varSampOrNull': ('varSamp', 'OrNull'), 'groupBitmapOrOrNull': ('groupBitmapOr', 'OrNull'), 'argMinOrNull': ('argMin', 'OrNull'), 'contingencyOrNull': ('contingency', 'OrNull'), 'quantilesExactLowOrNull': ('quantilesExactLow', 'OrNull'), 'covarSampOrNull': ('covarSamp', 'OrNull'), 'mannWhitneyUTestOrNull': ('mannWhitneyUTest', 'OrNull'), 'quantilesExactWeightedOrNull': ('quantilesExactWeighted', 'OrNull'), 'quantileTimingWeightedOrNull': ('quantileTimingWeighted', 'OrNull'), 'minOrNull': ('min', 'OrNull'), 'approx_top_sumOrNull': ('approx_top_sum', 'OrNull'), 'uniqOrNull': ('uniq', 'OrNull'), 'quantilesExactOrNull': ('quantilesExact', 'OrNull'), 'retentionOrNull': ('retention', 'OrNull'), 'uniqExactOrNull': ('uniqExact', 'OrNull'), 'stochasticLinearRegressionOrNull': ('stochasticLinearRegression', 'OrNull'), 'quantilesExactExclusiveOrNull': ('quantilesExactExclusive', 'OrNull'), 'sparkBarOrNull': ('sparkBar', 'OrNull'), 'skewPopOrNull': ('skewPop', 'OrNull'), 'groupArrayMovingAvgOrNull': ('groupArrayMovingAvg', 'OrNull'), 'medianOrNull': ('median', 'OrNull'), 'groupArrayLastOrNull': ('groupArrayLast', 'OrNull'), 'kurtPopOrNull': ('kurtPop', 'OrNull'), 'exponentialMovingAverageOrNull': ('exponentialMovingAverage', 'OrNull'), 'sequenceNextNodeOrNull': ('sequenceNextNode', 'OrNull'), 'quantileOrNull': ('quantile', 'OrNull'), 'groupArrayInsertAtOrNull': ('groupArrayInsertAt', 'OrNull'), 'sumOrNull': ('sum', 'OrNull'), 'quantileBFloat16OrNull': ('quantileBFloat16', 'OrNull'), 'rankCorrOrNull': ('rankCorr', 'OrNull'), 'quantileTDigestOrNull': ('quantileTDigest', 'OrNull'), 'maxIntersectionsPositionOrNull': ('maxIntersectionsPosition', 'OrNull'), 'sumMapOrNull': ('sumMap', 'OrNull'), 'kurtSampOrNull': ('kurtSamp', 'OrNull'), 'exponentialTimeDecayedAvgOrNull': ('exponentialTimeDecayedAvg', 'OrNull'), 'avgWeightedOrNull': ('avgWeighted', 'OrNull'), 'topKWeightedOrNull': ('topKWeighted', 'OrNull'), 'largestTriangleThreeBucketsOrNull': ('largestTriangleThreeBuckets', 'OrNull'), 'groupArraySampleOrNull': ('groupArraySample', 'OrNull'), 'quantileExactHighOrNull': ('quantileExactHigh', 'OrNull'), 'windowFunnelOrNull': ('windowFunnel', 'OrNull'), 'quantileExactWeightedOrNull': ('quantileExactWeighted', 'OrNull'), 'quantileExactLowOrNull': ('quantileExactLow', 'OrNull'), 'maxMapOrNull': ('maxMap', 'OrNull'), 'welchTTestOrNull': ('welchTTest', 'OrNull'), 'groupBitOrOrNull': ('groupBitOr', 'OrNull'), 'quantilesOrNull': ('quantiles', 'OrNull'), 'avgOrNull': ('avg', 'OrNull'), 'cramersVOrNull': ('cramersV', 'OrNull'), 'anyLastOrNull': ('anyLast', 'OrNull'), 'quantilesGKOrNull': ('quantilesGK', 'OrNull'), 'sequenceMatchOrNull': ('sequenceMatch', 'OrNull'), 'quantilesTimingWeightedOrNull': ('quantilesTimingWeighted', 'OrNull'), 'quantilesDeterministicOrNull': ('quantilesDeterministic', 'OrNull'), 'sumCountOrNull': ('sumCount', 'OrNull'), 'maxIntersectionsOrNull': ('maxIntersections', 'OrNull'), 'stddevSampOrNull': ('stddevSamp', 'OrNull'), 'groupBitmapAndOrNull': ('groupBitmapAnd', 'OrNull'), 'groupArrayOrNull': ('groupArray', 'OrNull'), 'uniqCombinedOrNull': ('uniqCombined', 'OrNull'), 'skewSampOrNull': ('skewSamp', 'OrNull'), 'groupBitmapOrNull': ('groupBitmap', 'OrNull'), 'quantilesBFloat16OrNull': ('quantilesBFloat16', 'OrNull'), 'quantilesTDigestOrNull': ('quantilesTDigest', 'OrNull'), 'sequenceCountOrNull': ('sequenceCount', 'OrNull'), 'uniqCombined64OrNull': ('uniqCombined64', 'OrNull'), 'entropyOrNull': ('entropy', 'OrNull'), 'quantilesTDigestWeightedOrNull': ('quantilesTDigestWeighted', 'OrNull'), 'quantileExactOrNull': ('quantileExact', 'OrNull'), 'categoricalInformationValueOrNull': ('categoricalInformationValue', 'OrNull'), 'topKOrNull': ('topK', 'OrNull'), 'groupBitAndOrNull': ('groupBitAnd', 'OrNull'), 'stddevPopOrNull': ('stddevPop', 'OrNull'), 'quantileBFloat16WeightedOrNull': ('quantileBFloat16Weighted', 'OrNull'), 'quantileTimingOrNull': ('quantileTiming', 'OrNull'), 'groupConcatOrNull': ('groupConcat', 'OrNull'), 'corrOrNull': ('corr', 'OrNull'), 'sumWithOverflowOrNull': ('sumWithOverflow', 'OrNull'), 'last_valueOrNull': ('last_value', 'OrNull'), 'argMaxOrNull': ('argMax', 'OrNull'), 'quantilesTimingOrNull': ('quantilesTiming', 'OrNull'), 'groupArrayMovingSumOrNull': ('groupArrayMovingSum', 'OrNull'), 'deltaSumTimestampOrNull': ('deltaSumTimestamp', 'OrNull'), 'quantilesBFloat16WeightedOrNull': ('quantilesBFloat16Weighted', 'OrNull'), 'intervalLengthSumOrNull': ('intervalLengthSum', 'OrNull'), 'sumKahanArgMin': ('sumKahan', 'ArgMin'), 'quantilesExactHighArgMin': ('quantilesExactHigh', 'ArgMin'), 'anyArgMin': ('any', 'ArgMin'), 'uniqThetaArgMin': ('uniqTheta', 'ArgMin'), 'groupBitXorArgMin': ('groupBitXor', 'ArgMin'), 'theilsUArgMin': ('theilsU', 'ArgMin'), 'boundingRatioArgMin': ('boundingRatio', 'ArgMin'), 'histogramArgMin': ('histogram', 'ArgMin'), 'kolmogorovSmirnovTestArgMin': ('kolmogorovSmirnovTest', 'ArgMin'), 'groupBitmapXorArgMin': ('groupBitmapXor', 'ArgMin'), 'quantileDeterministicArgMin': ('quantileDeterministic', 'ArgMin'), 'varPopArgMin': ('varPop', 'ArgMin'), 'first_valueArgMin': ('first_value', 'ArgMin'), 'uniqHLL12ArgMin': ('uniqHLL12', 'ArgMin'), 'minMapArgMin': ('minMap', 'ArgMin'), 'simpleLinearRegressionArgMin': ('simpleLinearRegression', 'ArgMin'), 'quantilesInterpolatedWeightedArgMin': ('quantilesInterpolatedWeighted', 'ArgMin'), 'maxArgMin': ('max', 'ArgMin'), 'quantileTDigestWeightedArgMin': ('quantileTDigestWeighted', 'ArgMin'), 'groupUniqArrayArgMin': ('groupUniqArray', 'ArgMin'), 'meanZTestArgMin': ('meanZTest', 'ArgMin'), 'stochasticLogisticRegressionArgMin': ('stochasticLogisticRegression', 'ArgMin'), 'cramersVBiasCorrectedArgMin': ('cramersVBiasCorrected', 'ArgMin'), 'covarPopArgMin': ('covarPop', 'ArgMin'), 'countArgMin': ('count', 'ArgMin'), 'deltaSumArgMin': ('deltaSum', 'ArgMin'), 'quantileInterpolatedWeightedArgMin': ('quantileInterpolatedWeighted', 'ArgMin'), 'quantileGKArgMin': ('quantileGK', 'ArgMin'), 'anyHeavyArgMin': ('anyHeavy', 'ArgMin'), 'uniqUpToArgMin': ('uniqUpTo', 'ArgMin'), 'studentTTestArgMin': ('studentTTest', 'ArgMin'), 'varSampArgMin': ('varSamp', 'ArgMin'), 'groupBitmapOrArgMin': ('groupBitmapOr', 'ArgMin'), 'argMinArgMin': ('argMin', 'ArgMin'), 'contingencyArgMin': ('contingency', 'ArgMin'), 'quantilesExactLowArgMin': ('quantilesExactLow', 'ArgMin'), 'covarSampArgMin': ('covarSamp', 'ArgMin'), 'mannWhitneyUTestArgMin': ('mannWhitneyUTest', 'ArgMin'), 'quantilesExactWeightedArgMin': ('quantilesExactWeighted', 'ArgMin'), 'quantileTimingWeightedArgMin': ('quantileTimingWeighted', 'ArgMin'), 'minArgMin': ('min', 'ArgMin'), 'approx_top_sumArgMin': ('approx_top_sum', 'ArgMin'), 'uniqArgMin': ('uniq', 'ArgMin'), 'quantilesExactArgMin': ('quantilesExact', 'ArgMin'), 'retentionArgMin': ('retention', 'ArgMin'), 'uniqExactArgMin': ('uniqExact', 'ArgMin'), 'stochasticLinearRegressionArgMin': ('stochasticLinearRegression', 'ArgMin'), 'quantilesExactExclusiveArgMin': ('quantilesExactExclusive', 'ArgMin'), 'sparkBarArgMin': ('sparkBar', 'ArgMin'), 'skewPopArgMin': ('skewPop', 'ArgMin'), 'groupArrayMovingAvgArgMin': ('groupArrayMovingAvg', 'ArgMin'), 'medianArgMin': ('median', 'ArgMin'), 'groupArrayLastArgMin': ('groupArrayLast', 'ArgMin'), 'kurtPopArgMin': ('kurtPop', 'ArgMin'), 'exponentialMovingAverageArgMin': ('exponentialMovingAverage', 'ArgMin'), 'sequenceNextNodeArgMin': ('sequenceNextNode', 'ArgMin'), 'quantileArgMin': ('quantile', 'ArgMin'), 'groupArrayInsertAtArgMin': ('groupArrayInsertAt', 'ArgMin'), 'sumArgMin': ('sum', 'ArgMin'), 'quantileBFloat16ArgMin': ('quantileBFloat16', 'ArgMin'), 'rankCorrArgMin': ('rankCorr', 'ArgMin'), 'quantileTDigestArgMin': ('quantileTDigest', 'ArgMin'), 'maxIntersectionsPositionArgMin': ('maxIntersectionsPosition', 'ArgMin'), 'sumMapArgMin': ('sumMap', 'ArgMin'), 'kurtSampArgMin': ('kurtSamp', 'ArgMin'), 'exponentialTimeDecayedAvgArgMin': ('exponentialTimeDecayedAvg', 'ArgMin'), 'avgWeightedArgMin': ('avgWeighted', 'ArgMin'), 'topKWeightedArgMin': ('topKWeighted', 'ArgMin'), 'largestTriangleThreeBucketsArgMin': ('largestTriangleThreeBuckets', 'ArgMin'), 'groupArraySampleArgMin': ('groupArraySample', 'ArgMin'), 'quantileExactHighArgMin': ('quantileExactHigh', 'ArgMin'), 'windowFunnelArgMin': ('windowFunnel', 'ArgMin'), 'quantileExactWeightedArgMin': ('quantileExactWeighted', 'ArgMin'), 'quantileExactLowArgMin': ('quantileExactLow', 'ArgMin'), 'maxMapArgMin': ('maxMap', 'ArgMin'), 'welchTTestArgMin': ('welchTTest', 'ArgMin'), 'groupBitOrArgMin': ('groupBitOr', 'ArgMin'), 'quantilesArgMin': ('quantiles', 'ArgMin'), 'avgArgMin': ('avg', 'ArgMin'), 'cramersVArgMin': ('cramersV', 'ArgMin'), 'anyLastArgMin': ('anyLast', 'ArgMin'), 'quantilesGKArgMin': ('quantilesGK', 'ArgMin'), 'sequenceMatchArgMin': ('sequenceMatch', 'ArgMin'), 'quantilesTimingWeightedArgMin': ('quantilesTimingWeighted', 'ArgMin'), 'quantilesDeterministicArgMin': ('quantilesDeterministic', 'ArgMin'), 'sumCountArgMin': ('sumCount', 'ArgMin'), 'maxIntersectionsArgMin': ('maxIntersections', 'ArgMin'), 'stddevSampArgMin': ('stddevSamp', 'ArgMin'), 'groupBitmapAndArgMin': ('groupBitmapAnd', 'ArgMin'), 'groupArrayArgMin': ('groupArray', 'ArgMin'), 'uniqCombinedArgMin': ('uniqCombined', 'ArgMin'), 'skewSampArgMin': ('skewSamp', 'ArgMin'), 'groupBitmapArgMin': ('groupBitmap', 'ArgMin'), 'quantilesBFloat16ArgMin': ('quantilesBFloat16', 'ArgMin'), 'quantilesTDigestArgMin': ('quantilesTDigest', 'ArgMin'), 'sequenceCountArgMin': ('sequenceCount', 'ArgMin'), 'uniqCombined64ArgMin': ('uniqCombined64', 'ArgMin'), 'entropyArgMin': ('entropy', 'ArgMin'), 'quantilesTDigestWeightedArgMin': ('quantilesTDigestWeighted', 'ArgMin'), 'quantileExactArgMin': ('quantileExact', 'ArgMin'), 'categoricalInformationValueArgMin': ('categoricalInformationValue', 'ArgMin'), 'topKArgMin': ('topK', 'ArgMin'), 'groupBitAndArgMin': ('groupBitAnd', 'ArgMin'), 'stddevPopArgMin': ('stddevPop', 'ArgMin'), 'quantileBFloat16WeightedArgMin': ('quantileBFloat16Weighted', 'ArgMin'), 'quantileTimingArgMin': ('quantileTiming', 'ArgMin'), 'groupConcatArgMin': ('groupConcat', 'ArgMin'), 'corrArgMin': ('corr', 'ArgMin'), 'sumWithOverflowArgMin': ('sumWithOverflow', 'ArgMin'), 'last_valueArgMin': ('last_value', 'ArgMin'), 'argMaxArgMin': ('argMax', 'ArgMin'), 'quantilesTimingArgMin': ('quantilesTiming', 'ArgMin'), 'groupArrayMovingSumArgMin': ('groupArrayMovingSum', 'ArgMin'), 'deltaSumTimestampArgMin': ('deltaSumTimestamp', 'ArgMin'), 'quantilesBFloat16WeightedArgMin': ('quantilesBFloat16Weighted', 'ArgMin'), 'intervalLengthSumArgMin': ('intervalLengthSum', 'ArgMin'), 'sumKahanArgMax': ('sumKahan', 'ArgMax'), 'quantilesExactHighArgMax': ('quantilesExactHigh', 'ArgMax'), 'anyArgMax': ('any', 'ArgMax'), 'uniqThetaArgMax': ('uniqTheta', 'ArgMax'), 'groupBitXorArgMax': ('groupBitXor', 'ArgMax'), 'theilsUArgMax': ('theilsU', 'ArgMax'), 'boundingRatioArgMax': ('boundingRatio', 'ArgMax'), 'histogramArgMax': ('histogram', 'ArgMax'), 'kolmogorovSmirnovTestArgMax': ('kolmogorovSmirnovTest', 'ArgMax'), 'groupBitmapXorArgMax': ('groupBitmapXor', 'ArgMax'), 'quantileDeterministicArgMax': ('quantileDeterministic', 'ArgMax'), 'varPopArgMax': ('varPop', 'ArgMax'), 'first_valueArgMax': ('first_value', 'ArgMax'), 'uniqHLL12ArgMax': ('uniqHLL12', 'ArgMax'), 'minMapArgMax': ('minMap', 'ArgMax'), 'simpleLinearRegressionArgMax': ('simpleLinearRegression', 'ArgMax'), 'quantilesInterpolatedWeightedArgMax': ('quantilesInterpolatedWeighted', 'ArgMax'), 'maxArgMax': ('max', 'ArgMax'), 'quantileTDigestWeightedArgMax': ('quantileTDigestWeighted', 'ArgMax'), 'groupUniqArrayArgMax': ('groupUniqArray', 'ArgMax'), 'meanZTestArgMax': ('meanZTest', 'ArgMax'), 'stochasticLogisticRegressionArgMax': ('stochasticLogisticRegression', 'ArgMax'), 'cramersVBiasCorrectedArgMax': ('cramersVBiasCorrected', 'ArgMax'), 'covarPopArgMax': ('covarPop', 'ArgMax'), 'countArgMax': ('count', 'ArgMax'), 'deltaSumArgMax': ('deltaSum', 'ArgMax'), 'quantileInterpolatedWeightedArgMax': ('quantileInterpolatedWeighted', 'ArgMax'), 'quantileGKArgMax': ('quantileGK', 'ArgMax'), 'anyHeavyArgMax': ('anyHeavy', 'ArgMax'), 'uniqUpToArgMax': ('uniqUpTo', 'ArgMax'), 'studentTTestArgMax': ('studentTTest', 'ArgMax'), 'varSampArgMax': ('varSamp', 'ArgMax'), 'groupBitmapOrArgMax': ('groupBitmapOr', 'ArgMax'), 'argMinArgMax': ('argMin', 'ArgMax'), 'contingencyArgMax': ('contingency', 'ArgMax'), 'quantilesExactLowArgMax': ('quantilesExactLow', 'ArgMax'), 'covarSampArgMax': ('covarSamp', 'ArgMax'), 'mannWhitneyUTestArgMax': ('mannWhitneyUTest', 'ArgMax'), 'quantilesExactWeightedArgMax': ('quantilesExactWeighted', 'ArgMax'), 'quantileTimingWeightedArgMax': ('quantileTimingWeighted', 'ArgMax'), 'minArgMax': ('min', 'ArgMax'), 'approx_top_sumArgMax': ('approx_top_sum', 'ArgMax'), 'uniqArgMax': ('uniq', 'ArgMax'), 'quantilesExactArgMax': ('quantilesExact', 'ArgMax'), 'retentionArgMax': ('retention', 'ArgMax'), 'uniqExactArgMax': ('uniqExact', 'ArgMax'), 'stochasticLinearRegressionArgMax': ('stochasticLinearRegression', 'ArgMax'), 'quantilesExactExclusiveArgMax': ('quantilesExactExclusive', 'ArgMax'), 'sparkBarArgMax': ('sparkBar', 'ArgMax'), 'skewPopArgMax': ('skewPop', 'ArgMax'), 'groupArrayMovingAvgArgMax': ('groupArrayMovingAvg', 'ArgMax'), 'medianArgMax': ('median', 'ArgMax'), 'groupArrayLastArgMax': ('groupArrayLast', 'ArgMax'), 'kurtPopArgMax': ('kurtPop', 'ArgMax'), 'exponentialMovingAverageArgMax': ('exponentialMovingAverage', 'ArgMax'), 'sequenceNextNodeArgMax': ('sequenceNextNode', 'ArgMax'), 'quantileArgMax': ('quantile', 'ArgMax'), 'groupArrayInsertAtArgMax': ('groupArrayInsertAt', 'ArgMax'), 'sumArgMax': ('sum', 'ArgMax'), 'quantileBFloat16ArgMax': ('quantileBFloat16', 'ArgMax'), 'rankCorrArgMax': ('rankCorr', 'ArgMax'), 'quantileTDigestArgMax': ('quantileTDigest', 'ArgMax'), 'maxIntersectionsPositionArgMax': ('maxIntersectionsPosition', 'ArgMax'), 'sumMapArgMax': ('sumMap', 'ArgMax'), 'kurtSampArgMax': ('kurtSamp', 'ArgMax'), 'exponentialTimeDecayedAvgArgMax': ('exponentialTimeDecayedAvg', 'ArgMax'), 'avgWeightedArgMax': ('avgWeighted', 'ArgMax'), 'topKWeightedArgMax': ('topKWeighted', 'ArgMax'), 'largestTriangleThreeBucketsArgMax': ('largestTriangleThreeBuckets', 'ArgMax'), 'groupArraySampleArgMax': ('groupArraySample', 'ArgMax'), 'quantileExactHighArgMax': ('quantileExactHigh', 'ArgMax'), 'windowFunnelArgMax': ('windowFunnel', 'ArgMax'), 'quantileExactWeightedArgMax': ('quantileExactWeighted', 'ArgMax'), 'quantileExactLowArgMax': ('quantileExactLow', 'ArgMax'), 'maxMapArgMax': ('maxMap', 'ArgMax'), 'welchTTestArgMax': ('welchTTest', 'ArgMax'), 'groupBitOrArgMax': ('groupBitOr', 'ArgMax'), 'quantilesArgMax': ('quantiles', 'ArgMax'), 'avgArgMax': ('avg', 'ArgMax'), 'cramersVArgMax': ('cramersV', 'ArgMax'), 'anyLastArgMax': ('anyLast', 'ArgMax'), 'quantilesGKArgMax': ('quantilesGK', 'ArgMax'), 'sequenceMatchArgMax': ('sequenceMatch', 'ArgMax'), 'quantilesTimingWeightedArgMax': ('quantilesTimingWeighted', 'ArgMax'), 'quantilesDeterministicArgMax': ('quantilesDeterministic', 'ArgMax'), 'sumCountArgMax': ('sumCount', 'ArgMax'), 'maxIntersectionsArgMax': ('maxIntersections', 'ArgMax'), 'stddevSampArgMax': ('stddevSamp', 'ArgMax'), 'groupBitmapAndArgMax': ('groupBitmapAnd', 'ArgMax'), 'groupArrayArgMax': ('groupArray', 'ArgMax'), 'uniqCombinedArgMax': ('uniqCombined', 'ArgMax'), 'skewSampArgMax': ('skewSamp', 'ArgMax'), 'groupBitmapArgMax': ('groupBitmap', 'ArgMax'), 'quantilesBFloat16ArgMax': ('quantilesBFloat16', 'ArgMax'), 'quantilesTDigestArgMax': ('quantilesTDigest', 'ArgMax'), 'sequenceCountArgMax': ('sequenceCount', 'ArgMax'), 'uniqCombined64ArgMax': ('uniqCombined64', 'ArgMax'), 'entropyArgMax': ('entropy', 'ArgMax'), 'quantilesTDigestWeightedArgMax': ('quantilesTDigestWeighted', 'ArgMax'), 'quantileExactArgMax': ('quantileExact', 'ArgMax'), 'categoricalInformationValueArgMax': ('categoricalInformationValue', 'ArgMax'), 'topKArgMax': ('topK', 'ArgMax'), 'groupBitAndArgMax': ('groupBitAnd', 'ArgMax'), 'stddevPopArgMax': ('stddevPop', 'ArgMax'), 'quantileBFloat16WeightedArgMax': ('quantileBFloat16Weighted', 'ArgMax'), 'quantileTimingArgMax': ('quantileTiming', 'ArgMax'), 'groupConcatArgMax': ('groupConcat', 'ArgMax'), 'corrArgMax': ('corr', 'ArgMax'), 'sumWithOverflowArgMax': ('sumWithOverflow', 'ArgMax'), 'last_valueArgMax': ('last_value', 'ArgMax'), 'argMaxArgMax': ('argMax', 'ArgMax'), 'quantilesTimingArgMax': ('quantilesTiming', 'ArgMax'), 'groupArrayMovingSumArgMax': ('groupArrayMovingSum', 'ArgMax'), 'deltaSumTimestampArgMax': ('deltaSumTimestamp', 'ArgMax'), 'quantilesBFloat16WeightedArgMax': ('quantilesBFloat16Weighted', 'ArgMax'), 'intervalLengthSumArgMax': ('intervalLengthSum', 'ArgMax'), 'sumKahanArray': ('sumKahan', 'Array'), 'quantilesExactHighArray': ('quantilesExactHigh', 'Array'), 'anyArray': ('any', 'Array'), 'uniqThetaArray': ('uniqTheta', 'Array'), 'groupBitXorArray': ('groupBitXor', 'Array'), 'theilsUArray': ('theilsU', 'Array'), 'boundingRatioArray': ('boundingRatio', 'Array'), 'histogramArray': ('histogram', 'Array'), 'kolmogorovSmirnovTestArray': ('kolmogorovSmirnovTest', 'Array'), 'groupBitmapXorArray': ('groupBitmapXor', 'Array'), 'quantileDeterministicArray': ('quantileDeterministic', 'Array'), 'varPopArray': ('varPop', 'Array'), 'first_valueArray': ('first_value', 'Array'), 'uniqHLL12Array': ('uniqHLL12', 'Array'), 'minMapArray': ('minMap', 'Array'), 'simpleLinearRegressionArray': ('simpleLinearRegression', 'Array'), 'quantilesInterpolatedWeightedArray': ('quantilesInterpolatedWeighted', 'Array'), 'maxArray': ('max', 'Array'), 'quantileTDigestWeightedArray': ('quantileTDigestWeighted', 'Array'), 'groupUniqArrayArray': ('groupUniqArray', 'Array'), 'meanZTestArray': ('meanZTest', 'Array'), 'stochasticLogisticRegressionArray': ('stochasticLogisticRegression', 'Array'), 'cramersVBiasCorrectedArray': ('cramersVBiasCorrected', 'Array'), 'covarPopArray': ('covarPop', 'Array'), 'countArray': ('count', 'Array'), 'deltaSumArray': ('deltaSum', 'Array'), 'quantileInterpolatedWeightedArray': ('quantileInterpolatedWeighted', 'Array'), 'quantileGKArray': ('quantileGK', 'Array'), 'anyHeavyArray': ('anyHeavy', 'Array'), 'uniqUpToArray': ('uniqUpTo', 'Array'), 'studentTTestArray': ('studentTTest', 'Array'), 'varSampArray': ('varSamp', 'Array'), 'groupBitmapOrArray': ('groupBitmapOr', 'Array'), 'argMinArray': ('argMin', 'Array'), 'contingencyArray': ('contingency', 'Array'), 'quantilesExactLowArray': ('quantilesExactLow', 'Array'), 'covarSampArray': ('covarSamp', 'Array'), 'mannWhitneyUTestArray': ('mannWhitneyUTest', 'Array'), 'quantilesExactWeightedArray': ('quantilesExactWeighted', 'Array'), 'quantileTimingWeightedArray': ('quantileTimingWeighted', 'Array'), 'minArray': ('min', 'Array'), 'approx_top_sumArray': ('approx_top_sum', 'Array'), 'uniqArray': ('uniq', 'Array'), 'quantilesExactArray': ('quantilesExact', 'Array'), 'retentionArray': ('retention', 'Array'), 'uniqExactArray': ('uniqExact', 'Array'), 'stochasticLinearRegressionArray': ('stochasticLinearRegression', 'Array'), 'quantilesExactExclusiveArray': ('quantilesExactExclusive', 'Array'), 'sparkBarArray': ('sparkBar', 'Array'), 'skewPopArray': ('skewPop', 'Array'), 'groupArrayMovingAvgArray': ('groupArrayMovingAvg', 'Array'), 'medianArray': ('median', 'Array'), 'groupArrayLastArray': ('groupArrayLast', 'Array'), 'kurtPopArray': ('kurtPop', 'Array'), 'exponentialMovingAverageArray': ('exponentialMovingAverage', 'Array'), 'sequenceNextNodeArray': ('sequenceNextNode', 'Array'), 'quantileArray': ('quantile', 'Array'), 'groupArrayInsertAtArray': ('groupArrayInsertAt', 'Array'), 'sumArray': ('sum', 'Array'), 'quantileBFloat16Array': ('quantileBFloat16', 'Array'), 'rankCorrArray': ('rankCorr', 'Array'), 'quantileTDigestArray': ('quantileTDigest', 'Array'), 'maxIntersectionsPositionArray': ('maxIntersectionsPosition', 'Array'), 'sumMapArray': ('sumMap', 'Array'), 'kurtSampArray': ('kurtSamp', 'Array'), 'exponentialTimeDecayedAvgArray': ('exponentialTimeDecayedAvg', 'Array'), 'avgWeightedArray': ('avgWeighted', 'Array'), 'topKWeightedArray': ('topKWeighted', 'Array'), 'largestTriangleThreeBucketsArray': ('largestTriangleThreeBuckets', 'Array'), 'groupArraySampleArray': ('groupArraySample', 'Array'), 'quantileExactHighArray': ('quantileExactHigh', 'Array'), 'windowFunnelArray': ('windowFunnel', 'Array'), 'quantileExactWeightedArray': ('quantileExactWeighted', 'Array'), 'quantileExactLowArray': ('quantileExactLow', 'Array'), 'maxMapArray': ('maxMap', 'Array'), 'welchTTestArray': ('welchTTest', 'Array'), 'groupBitOrArray': ('groupBitOr', 'Array'), 'quantilesArray': ('quantiles', 'Array'), 'avgArray': ('avg', 'Array'), 'cramersVArray': ('cramersV', 'Array'), 'anyLastArray': ('anyLast', 'Array'), 'quantilesGKArray': ('quantilesGK', 'Array'), 'sequenceMatchArray': ('sequenceMatch', 'Array'), 'quantilesTimingWeightedArray': ('quantilesTimingWeighted', 'Array'), 'quantilesDeterministicArray': ('quantilesDeterministic', 'Array'), 'sumCountArray': ('sumCount', 'Array'), 'maxIntersectionsArray': ('maxIntersections', 'Array'), 'stddevSampArray': ('stddevSamp', 'Array'), 'groupBitmapAndArray': ('groupBitmapAnd', 'Array'), 'groupArrayArray': ('groupArray', 'Array'), 'uniqCombinedArray': ('uniqCombined', 'Array'), 'skewSampArray': ('skewSamp', 'Array'), 'groupBitmapArray': ('groupBitmap', 'Array'), 'quantilesBFloat16Array': ('quantilesBFloat16', 'Array'), 'quantilesTDigestArray': ('quantilesTDigest', 'Array'), 'sequenceCountArray': ('sequenceCount', 'Array'), 'uniqCombined64Array': ('uniqCombined64', 'Array'), 'entropyArray': ('entropy', 'Array'), 'quantilesTDigestWeightedArray': ('quantilesTDigestWeighted', 'Array'), 'quantileExactArray': ('quantileExact', 'Array'), 'categoricalInformationValueArray': ('categoricalInformationValue', 'Array'), 'topKArray': ('topK', 'Array'), 'groupBitAndArray': ('groupBitAnd', 'Array'), 'stddevPopArray': ('stddevPop', 'Array'), 'quantileBFloat16WeightedArray': ('quantileBFloat16Weighted', 'Array'), 'quantileTimingArray': ('quantileTiming', 'Array'), 'groupConcatArray': ('groupConcat', 'Array'), 'corrArray': ('corr', 'Array'), 'sumWithOverflowArray': ('sumWithOverflow', 'Array'), 'last_valueArray': ('last_value', 'Array'), 'argMaxArray': ('argMax', 'Array'), 'quantilesTimingArray': ('quantilesTiming', 'Array'), 'groupArrayMovingSumArray': ('groupArrayMovingSum', 'Array'), 'deltaSumTimestampArray': ('deltaSumTimestamp', 'Array'), 'quantilesBFloat16WeightedArray': ('quantilesBFloat16Weighted', 'Array'), 'intervalLengthSumArray': ('intervalLengthSum', 'Array'), 'sumKahanState': ('sumKahan', 'State'), 'quantilesExactHighState': ('quantilesExactHigh', 'State'), 'anyState': ('any', 'State'), 'uniqThetaState': ('uniqTheta', 'State'), 'groupBitXorState': ('groupBitXor', 'State'), 'theilsUState': ('theilsU', 'State'), 'boundingRatioState': ('boundingRatio', 'State'), 'histogramState': ('histogram', 'State'), 'kolmogorovSmirnovTestState': ('kolmogorovSmirnovTest', 'State'), 'groupBitmapXorState': ('groupBitmapXor', 'State'), 'quantileDeterministicState': ('quantileDeterministic', 'State'), 'varPopState': ('varPop', 'State'), 'first_valueState': ('first_value', 'State'), 'uniqHLL12State': ('uniqHLL12', 'State'), 'minMapState': ('minMap', 'State'), 'simpleLinearRegressionState': ('simpleLinearRegression', 'State'), 'quantilesInterpolatedWeightedState': ('quantilesInterpolatedWeighted', 'State'), 'maxState': ('max', 'State'), 'quantileTDigestWeightedState': ('quantileTDigestWeighted', 'State'), 'groupUniqArrayState': ('groupUniqArray', 'State'), 'meanZTestState': ('meanZTest', 'State'), 'stochasticLogisticRegressionState': ('stochasticLogisticRegression', 'State'), 'cramersVBiasCorrectedState': ('cramersVBiasCorrected', 'State'), 'covarPopState': ('covarPop', 'State'), 'countState': ('count', 'State'), 'deltaSumState': ('deltaSum', 'State'), 'quantileInterpolatedWeightedState': ('quantileInterpolatedWeighted', 'State'), 'quantileGKState': ('quantileGK', 'State'), 'anyHeavyState': ('anyHeavy', 'State'), 'uniqUpToState': ('uniqUpTo', 'State'), 'studentTTestState': ('studentTTest', 'State'), 'varSampState': ('varSamp', 'State'), 'groupBitmapOrState': ('groupBitmapOr', 'State'), 'argMinState': ('argMin', 'State'), 'contingencyState': ('contingency', 'State'), 'quantilesExactLowState': ('quantilesExactLow', 'State'), 'covarSampState': ('covarSamp', 'State'), 'mannWhitneyUTestState': ('mannWhitneyUTest', 'State'), 'quantilesExactWeightedState': ('quantilesExactWeighted', 'State'), 'quantileTimingWeightedState': ('quantileTimingWeighted', 'State'), 'minState': ('min', 'State'), 'approx_top_sumState': ('approx_top_sum', 'State'), 'uniqState': ('uniq', 'State'), 'quantilesExactState': ('quantilesExact', 'State'), 'retentionState': ('retention', 'State'), 'uniqExactState': ('uniqExact', 'State'), 'stochasticLinearRegressionState': ('stochasticLinearRegression', 'State'), 'quantilesExactExclusiveState': ('quantilesExactExclusive', 'State'), 'sparkBarState': ('sparkBar', 'State'), 'skewPopState': ('skewPop', 'State'), 'groupArrayMovingAvgState': ('groupArrayMovingAvg', 'State'), 'medianState': ('median', 'State'), 'groupArrayLastState': ('groupArrayLast', 'State'), 'kurtPopState': ('kurtPop', 'State'), 'exponentialMovingAverageState': ('exponentialMovingAverage', 'State'), 'sequenceNextNodeState': ('sequenceNextNode', 'State'), 'quantileState': ('quantile', 'State'), 'groupArrayInsertAtState': ('groupArrayInsertAt', 'State'), 'sumState': ('sum', 'State'), 'quantileBFloat16State': ('quantileBFloat16', 'State'), 'rankCorrState': ('rankCorr', 'State'), 'quantileTDigestState': ('quantileTDigest', 'State'), 'maxIntersectionsPositionState': ('maxIntersectionsPosition', 'State'), 'sumMapState': ('sumMap', 'State'), 'kurtSampState': ('kurtSamp', 'State'), 'exponentialTimeDecayedAvgState': ('exponentialTimeDecayedAvg', 'State'), 'avgWeightedState': ('avgWeighted', 'State'), 'topKWeightedState': ('topKWeighted', 'State'), 'largestTriangleThreeBucketsState': ('largestTriangleThreeBuckets', 'State'), 'groupArraySampleState': ('groupArraySample', 'State'), 'quantileExactHighState': ('quantileExactHigh', 'State'), 'windowFunnelState': ('windowFunnel', 'State'), 'quantileExactWeightedState': ('quantileExactWeighted', 'State'), 'quantileExactLowState': ('quantileExactLow', 'State'), 'maxMapState': ('maxMap', 'State'), 'welchTTestState': ('welchTTest', 'State'), 'groupBitOrState': ('groupBitOr', 'State'), 'quantilesState': ('quantiles', 'State'), 'avgState': ('avg', 'State'), 'cramersVState': ('cramersV', 'State'), 'anyLastState': ('anyLast', 'State'), 'quantilesGKState': ('quantilesGK', 'State'), 'sequenceMatchState': ('sequenceMatch', 'State'), 'quantilesTimingWeightedState': ('quantilesTimingWeighted', 'State'), 'quantilesDeterministicState': ('quantilesDeterministic', 'State'), 'sumCountState': ('sumCount', 'State'), 'maxIntersectionsState': ('maxIntersections', 'State'), 'stddevSampState': ('stddevSamp', 'State'), 'groupBitmapAndState': ('groupBitmapAnd', 'State'), 'groupArrayState': ('groupArray', 'State'), 'uniqCombinedState': ('uniqCombined', 'State'), 'skewSampState': ('skewSamp', 'State'), 'groupBitmapState': ('groupBitmap', 'State'), 'quantilesBFloat16State': ('quantilesBFloat16', 'State'), 'quantilesTDigestState': ('quantilesTDigest', 'State'), 'sequenceCountState': ('sequenceCount', 'State'), 'uniqCombined64State': ('uniqCombined64', 'State'), 'entropyState': ('entropy', 'State'), 'quantilesTDigestWeightedState': ('quantilesTDigestWeighted', 'State'), 'quantileExactState': ('quantileExact', 'State'), 'categoricalInformationValueState': ('categoricalInformationValue', 'State'), 'topKState': ('topK', 'State'), 'groupBitAndState': ('groupBitAnd', 'State'), 'stddevPopState': ('stddevPop', 'State'), 'quantileBFloat16WeightedState': ('quantileBFloat16Weighted', 'State'), 'quantileTimingState': ('quantileTiming', 'State'), 'groupConcatState': ('groupConcat', 'State'), 'corrState': ('corr', 'State'), 'sumWithOverflowState': ('sumWithOverflow', 'State'), 'last_valueState': ('last_value', 'State'), 'argMaxState': ('argMax', 'State'), 'quantilesTimingState': ('quantilesTiming', 'State'), 'groupArrayMovingSumState': ('groupArrayMovingSum', 'State'), 'deltaSumTimestampState': ('deltaSumTimestamp', 'State'), 'quantilesBFloat16WeightedState': ('quantilesBFloat16Weighted', 'State'), 'intervalLengthSumState': ('intervalLengthSum', 'State'), 'sumKahanMerge': ('sumKahan', 'Merge'), 'quantilesExactHighMerge': ('quantilesExactHigh', 'Merge'), 'anyMerge': ('any', 'Merge'), 'uniqThetaMerge': ('uniqTheta', 'Merge'), 'groupBitXorMerge': ('groupBitXor', 'Merge'), 'theilsUMerge': ('theilsU', 'Merge'), 'boundingRatioMerge': ('boundingRatio', 'Merge'), 'histogramMerge': ('histogram', 'Merge'), 'kolmogorovSmirnovTestMerge': ('kolmogorovSmirnovTest', 'Merge'), 'groupBitmapXorMerge': ('groupBitmapXor', 'Merge'), 'quantileDeterministicMerge': ('quantileDeterministic', 'Merge'), 'varPopMerge': ('varPop', 'Merge'), 'first_valueMerge': ('first_value', 'Merge'), 'uniqHLL12Merge': ('uniqHLL12', 'Merge'), 'minMapMerge': ('minMap', 'Merge'), 'simpleLinearRegressionMerge': ('simpleLinearRegression', 'Merge'), 'quantilesInterpolatedWeightedMerge': ('quantilesInterpolatedWeighted', 'Merge'), 'maxMerge': ('max', 'Merge'), 'quantileTDigestWeightedMerge': ('quantileTDigestWeighted', 'Merge'), 'groupUniqArrayMerge': ('groupUniqArray', 'Merge'), 'meanZTestMerge': ('meanZTest', 'Merge'), 'stochasticLogisticRegressionMerge': ('stochasticLogisticRegression', 'Merge'), 'cramersVBiasCorrectedMerge': ('cramersVBiasCorrected', 'Merge'), 'covarPopMerge': ('covarPop', 'Merge'), 'countMerge': ('count', 'Merge'), 'deltaSumMerge': ('deltaSum', 'Merge'), 'quantileInterpolatedWeightedMerge': ('quantileInterpolatedWeighted', 'Merge'), 'quantileGKMerge': ('quantileGK', 'Merge'), 'anyHeavyMerge': ('anyHeavy', 'Merge'), 'uniqUpToMerge': ('uniqUpTo', 'Merge'), 'studentTTestMerge': ('studentTTest', 'Merge'), 'varSampMerge': ('varSamp', 'Merge'), 'groupBitmapOrMerge': ('groupBitmapOr', 'Merge'), 'argMinMerge': ('argMin', 'Merge'), 'contingencyMerge': ('contingency', 'Merge'), 'quantilesExactLowMerge': ('quantilesExactLow', 'Merge'), 'covarSampMerge': ('covarSamp', 'Merge'), 'mannWhitneyUTestMerge': ('mannWhitneyUTest', 'Merge'), 'quantilesExactWeightedMerge': ('quantilesExactWeighted', 'Merge'), 'quantileTimingWeightedMerge': ('quantileTimingWeighted', 'Merge'), 'minMerge': ('min', 'Merge'), 'approx_top_sumMerge': ('approx_top_sum', 'Merge'), 'uniqMerge': ('uniq', 'Merge'), 'quantilesExactMerge': ('quantilesExact', 'Merge'), 'retentionMerge': ('retention', 'Merge'), 'uniqExactMerge': ('uniqExact', 'Merge'), 'stochasticLinearRegressionMerge': ('stochasticLinearRegression', 'Merge'), 'quantilesExactExclusiveMerge': ('quantilesExactExclusive', 'Merge'), 'sparkBarMerge': ('sparkBar', 'Merge'), 'skewPopMerge': ('skewPop', 'Merge'), 'groupArrayMovingAvgMerge': ('groupArrayMovingAvg', 'Merge'), 'medianMerge': ('median', 'Merge'), 'groupArrayLastMerge': ('groupArrayLast', 'Merge'), 'kurtPopMerge': ('kurtPop', 'Merge'), 'exponentialMovingAverageMerge': ('exponentialMovingAverage', 'Merge'), 'sequenceNextNodeMerge': ('sequenceNextNode', 'Merge'), 'quantileMerge': ('quantile', 'Merge'), 'groupArrayInsertAtMerge': ('groupArrayInsertAt', 'Merge'), 'sumMerge': ('sum', 'Merge'), 'quantileBFloat16Merge': ('quantileBFloat16', 'Merge'), 'rankCorrMerge': ('rankCorr', 'Merge'), 'quantileTDigestMerge': ('quantileTDigest', 'Merge'), 'maxIntersectionsPositionMerge': ('maxIntersectionsPosition', 'Merge'), 'sumMapMerge': ('sumMap', 'Merge'), 'kurtSampMerge': ('kurtSamp', 'Merge'), 'exponentialTimeDecayedAvgMerge': ('exponentialTimeDecayedAvg', 'Merge'), 'avgWeightedMerge': ('avgWeighted', 'Merge'), 'topKWeightedMerge': ('topKWeighted', 'Merge'), 'largestTriangleThreeBucketsMerge': ('largestTriangleThreeBuckets', 'Merge'), 'groupArraySampleMerge': ('groupArraySample', 'Merge'), 'quantileExactHighMerge': ('quantileExactHigh', 'Merge'), 'windowFunnelMerge': ('windowFunnel', 'Merge'), 'quantileExactWeightedMerge': ('quantileExactWeighted', 'Merge'), 'quantileExactLowMerge': ('quantileExactLow', 'Merge'), 'maxMapMerge': ('maxMap', 'Merge'), 'welchTTestMerge': ('welchTTest', 'Merge'), 'groupBitOrMerge': ('groupBitOr', 'Merge'), 'quantilesMerge': ('quantiles', 'Merge'), 'avgMerge': ('avg', 'Merge'), 'cramersVMerge': ('cramersV', 'Merge'), 'anyLastMerge': ('anyLast', 'Merge'), 'quantilesGKMerge': ('quantilesGK', 'Merge'), 'sequenceMatchMerge': ('sequenceMatch', 'Merge'), 'quantilesTimingWeightedMerge': ('quantilesTimingWeighted', 'Merge'), 'quantilesDeterministicMerge': ('quantilesDeterministic', 'Merge'), 'sumCountMerge': ('sumCount', 'Merge'), 'maxIntersectionsMerge': ('maxIntersections', 'Merge'), 'stddevSampMerge': ('stddevSamp', 'Merge'), 'groupBitmapAndMerge': ('groupBitmapAnd', 'Merge'), 'groupArrayMerge': ('groupArray', 'Merge'), 'uniqCombinedMerge': ('uniqCombined', 'Merge'), 'skewSampMerge': ('skewSamp', 'Merge'), 'groupBitmapMerge': ('groupBitmap', 'Merge'), 'quantilesBFloat16Merge': ('quantilesBFloat16', 'Merge'), 'quantilesTDigestMerge': ('quantilesTDigest', 'Merge'), 'sequenceCountMerge': ('sequenceCount', 'Merge'), 'uniqCombined64Merge': ('uniqCombined64', 'Merge'), 'entropyMerge': ('entropy', 'Merge'), 'quantilesTDigestWeightedMerge': ('quantilesTDigestWeighted', 'Merge'), 'quantileExactMerge': ('quantileExact', 'Merge'), 'categoricalInformationValueMerge': ('categoricalInformationValue', 'Merge'), 'topKMerge': ('topK', 'Merge'), 'groupBitAndMerge': ('groupBitAnd', 'Merge'), 'stddevPopMerge': ('stddevPop', 'Merge'), 'quantileBFloat16WeightedMerge': ('quantileBFloat16Weighted', 'Merge'), 'quantileTimingMerge': ('quantileTiming', 'Merge'), 'groupConcatMerge': ('groupConcat', 'Merge'), 'corrMerge': ('corr', 'Merge'), 'sumWithOverflowMerge': ('sumWithOverflow', 'Merge'), 'last_valueMerge': ('last_value', 'Merge'), 'argMaxMerge': ('argMax', 'Merge'), 'quantilesTimingMerge': ('quantilesTiming', 'Merge'), 'groupArrayMovingSumMerge': ('groupArrayMovingSum', 'Merge'), 'deltaSumTimestampMerge': ('deltaSumTimestamp', 'Merge'), 'quantilesBFloat16WeightedMerge': ('quantilesBFloat16Weighted', 'Merge'), 'intervalLengthSumMerge': ('intervalLengthSum', 'Merge'), 'sumKahanMap': ('sumKahan', 'Map'), 'quantilesExactHighMap': ('quantilesExactHigh', 'Map'), 'anyMap': ('any', 'Map'), 'uniqThetaMap': ('uniqTheta', 'Map'), 'groupBitXorMap': ('groupBitXor', 'Map'), 'theilsUMap': ('theilsU', 'Map'), 'boundingRatioMap': ('boundingRatio', 'Map'), 'histogramMap': ('histogram', 'Map'), 'kolmogorovSmirnovTestMap': ('kolmogorovSmirnovTest', 'Map'), 'groupBitmapXorMap': ('groupBitmapXor', 'Map'), 'quantileDeterministicMap': ('quantileDeterministic', 'Map'), 'varPopMap': ('varPop', 'Map'), 'first_valueMap': ('first_value', 'Map'), 'uniqHLL12Map': ('uniqHLL12', 'Map'), 'minMapMap': ('minMap', 'Map'), 'simpleLinearRegressionMap': ('simpleLinearRegression', 'Map'), 'quantilesInterpolatedWeightedMap': ('quantilesInterpolatedWeighted', 'Map'), 'maxMap': ('maxMap', None), 'quantileTDigestWeightedMap': ('quantileTDigestWeighted', 'Map'), 'groupUniqArrayMap': ('groupUniqArray', 'Map'), 'meanZTestMap': ('meanZTest', 'Map'), 'stochasticLogisticRegressionMap': ('stochasticLogisticRegression', 'Map'), 'cramersVBiasCorrectedMap': ('cramersVBiasCorrected', 'Map'), 'covarPopMap': ('covarPop', 'Map'), 'countMap': ('count', 'Map'), 'deltaSumMap': ('deltaSum', 'Map'), 'quantileInterpolatedWeightedMap': ('quantileInterpolatedWeighted', 'Map'), 'quantileGKMap': ('quantileGK', 'Map'), 'anyHeavyMap': ('anyHeavy', 'Map'), 'uniqUpToMap': ('uniqUpTo', 'Map'), 'studentTTestMap': ('studentTTest', 'Map'), 'varSampMap': ('varSamp', 'Map'), 'groupBitmapOrMap': ('groupBitmapOr', 'Map'), 'argMinMap': ('argMin', 'Map'), 'contingencyMap': ('contingency', 'Map'), 'quantilesExactLowMap': ('quantilesExactLow', 'Map'), 'covarSampMap': ('covarSamp', 'Map'), 'mannWhitneyUTestMap': ('mannWhitneyUTest', 'Map'), 'quantilesExactWeightedMap': ('quantilesExactWeighted', 'Map'), 'quantileTimingWeightedMap': ('quantileTimingWeighted', 'Map'), 'minMap': ('minMap', None), 'approx_top_sumMap': ('approx_top_sum', 'Map'), 'uniqMap': ('uniq', 'Map'), 'quantilesExactMap': ('quantilesExact', 'Map'), 'retentionMap': ('retention', 'Map'), 'uniqExactMap': ('uniqExact', 'Map'), 'stochasticLinearRegressionMap': ('stochasticLinearRegression', 'Map'), 'quantilesExactExclusiveMap': ('quantilesExactExclusive', 'Map'), 'sparkBarMap': ('sparkBar', 'Map'), 'skewPopMap': ('skewPop', 'Map'), 'groupArrayMovingAvgMap': ('groupArrayMovingAvg', 'Map'), 'medianMap': ('median', 'Map'), 'groupArrayLastMap': ('groupArrayLast', 'Map'), 'kurtPopMap': ('kurtPop', 'Map'), 'exponentialMovingAverageMap': ('exponentialMovingAverage', 'Map'), 'sequenceNextNodeMap': ('sequenceNextNode', 'Map'), 'quantileMap': ('quantile', 'Map'), 'groupArrayInsertAtMap': ('groupArrayInsertAt', 'Map'), 'sumMap': ('sumMap', None), 'quantileBFloat16Map': ('quantileBFloat16', 'Map'), 'rankCorrMap': ('rankCorr', 'Map'), 'quantileTDigestMap': ('quantileTDigest', 'Map'), 'maxIntersectionsPositionMap': ('maxIntersectionsPosition', 'Map'), 'sumMapMap': ('sumMap', 'Map'), 'kurtSampMap': ('kurtSamp', 'Map'), 'exponentialTimeDecayedAvgMap': ('exponentialTimeDecayedAvg', 'Map'), 'avgWeightedMap': ('avgWeighted', 'Map'), 'topKWeightedMap': ('topKWeighted', 'Map'), 'largestTriangleThreeBucketsMap': ('largestTriangleThreeBuckets', 'Map'), 'groupArraySampleMap': ('groupArraySample', 'Map'), 'quantileExactHighMap': ('quantileExactHigh', 'Map'), 'windowFunnelMap': ('windowFunnel', 'Map'), 'quantileExactWeightedMap': ('quantileExactWeighted', 'Map'), 'quantileExactLowMap': ('quantileExactLow', 'Map'), 'maxMapMap': ('maxMap', 'Map'), 'welchTTestMap': ('welchTTest', 'Map'), 'groupBitOrMap': ('groupBitOr', 'Map'), 'quantilesMap': ('quantiles', 'Map'), 'avgMap': ('avg', 'Map'), 'cramersVMap': ('cramersV', 'Map'), 'anyLastMap': ('anyLast', 'Map'), 'quantilesGKMap': ('quantilesGK', 'Map'), 'sequenceMatchMap': ('sequenceMatch', 'Map'), 'quantilesTimingWeightedMap': ('quantilesTimingWeighted', 'Map'), 'quantilesDeterministicMap': ('quantilesDeterministic', 'Map'), 'sumCountMap': ('sumCount', 'Map'), 'maxIntersectionsMap': ('maxIntersections', 'Map'), 'stddevSampMap': ('stddevSamp', 'Map'), 'groupBitmapAndMap': ('groupBitmapAnd', 'Map'), 'groupArrayMap': ('groupArray', 'Map'), 'uniqCombinedMap': ('uniqCombined', 'Map'), 'skewSampMap': ('skewSamp', 'Map'), 'groupBitmapMap': ('groupBitmap', 'Map'), 'quantilesBFloat16Map': ('quantilesBFloat16', 'Map'), 'quantilesTDigestMap': ('quantilesTDigest', 'Map'), 'sequenceCountMap': ('sequenceCount', 'Map'), 'uniqCombined64Map': ('uniqCombined64', 'Map'), 'entropyMap': ('entropy', 'Map'), 'quantilesTDigestWeightedMap': ('quantilesTDigestWeighted', 'Map'), 'quantileExactMap': ('quantileExact', 'Map'), 'categoricalInformationValueMap': ('categoricalInformationValue', 'Map'), 'topKMap': ('topK', 'Map'), 'groupBitAndMap': ('groupBitAnd', 'Map'), 'stddevPopMap': ('stddevPop', 'Map'), 'quantileBFloat16WeightedMap': ('quantileBFloat16Weighted', 'Map'), 'quantileTimingMap': ('quantileTiming', 'Map'), 'groupConcatMap': ('groupConcat', 'Map'), 'corrMap': ('corr', 'Map'), 'sumWithOverflowMap': ('sumWithOverflow', 'Map'), 'last_valueMap': ('last_value', 'Map'), 'argMaxMap': ('argMax', 'Map'), 'quantilesTimingMap': ('quantilesTiming', 'Map'), 'groupArrayMovingSumMap': ('groupArrayMovingSum', 'Map'), 'deltaSumTimestampMap': ('deltaSumTimestamp', 'Map'), 'quantilesBFloat16WeightedMap': ('quantilesBFloat16Weighted', 'Map'), 'intervalLengthSumMap': ('intervalLengthSum', 'Map'), 'sumKahanIf': ('sumKahan', 'If'), 'quantilesExactHighIf': ('quantilesExactHigh', 'If'), 'anyIf': ('any', 'If'), 'uniqThetaIf': ('uniqTheta', 'If'), 'groupBitXorIf': ('groupBitXor', 'If'), 'theilsUIf': ('theilsU', 'If'), 'boundingRatioIf': ('boundingRatio', 'If'), 'histogramIf': ('histogram', 'If'), 'kolmogorovSmirnovTestIf': ('kolmogorovSmirnovTest', 'If'), 'groupBitmapXorIf': ('groupBitmapXor', 'If'), 'quantileDeterministicIf': ('quantileDeterministic', 'If'), 'varPopIf': ('varPop', 'If'), 'first_valueIf': ('first_value', 'If'), 'uniqHLL12If': ('uniqHLL12', 'If'), 'minMapIf': ('minMap', 'If'), 'simpleLinearRegressionIf': ('simpleLinearRegression', 'If'), 'quantilesInterpolatedWeightedIf': ('quantilesInterpolatedWeighted', 'If'), 'maxIf': ('max', 'If'), 'quantileTDigestWeightedIf': ('quantileTDigestWeighted', 'If'), 'groupUniqArrayIf': ('groupUniqArray', 'If'), 'meanZTestIf': ('meanZTest', 'If'), 'stochasticLogisticRegressionIf': ('stochasticLogisticRegression', 'If'), 'cramersVBiasCorrectedIf': ('cramersVBiasCorrected', 'If'), 'covarPopIf': ('covarPop', 'If'), 'countIf': ('count', 'If'), 'deltaSumIf': ('deltaSum', 'If'), 'quantileInterpolatedWeightedIf': ('quantileInterpolatedWeighted', 'If'), 'quantileGKIf': ('quantileGK', 'If'), 'anyHeavyIf': ('anyHeavy', 'If'), 'uniqUpToIf': ('uniqUpTo', 'If'), 'studentTTestIf': ('studentTTest', 'If'), 'varSampIf': ('varSamp', 'If'), 'groupBitmapOrIf': ('groupBitmapOr', 'If'), 'argMinIf': ('argMin', 'If'), 'contingencyIf': ('contingency', 'If'), 'quantilesExactLowIf': ('quantilesExactLow', 'If'), 'covarSampIf': ('covarSamp', 'If'), 'mannWhitneyUTestIf': ('mannWhitneyUTest', 'If'), 'quantilesExactWeightedIf': ('quantilesExactWeighted', 'If'), 'quantileTimingWeightedIf': ('quantileTimingWeighted', 'If'), 'minIf': ('min', 'If'), 'approx_top_sumIf': ('approx_top_sum', 'If'), 'uniqIf': ('uniq', 'If'), 'quantilesExactIf': ('quantilesExact', 'If'), 'retentionIf': ('retention', 'If'), 'uniqExactIf': ('uniqExact', 'If'), 'stochasticLinearRegressionIf': ('stochasticLinearRegression', 'If'), 'quantilesExactExclusiveIf': ('quantilesExactExclusive', 'If'), 'sparkBarIf': ('sparkBar', 'If'), 'skewPopIf': ('skewPop', 'If'), 'groupArrayMovingAvgIf': ('groupArrayMovingAvg', 'If'), 'medianIf': ('median', 'If'), 'groupArrayLastIf': ('groupArrayLast', 'If'), 'kurtPopIf': ('kurtPop', 'If'), 'exponentialMovingAverageIf': ('exponentialMovingAverage', 'If'), 'sequenceNextNodeIf': ('sequenceNextNode', 'If'), 'quantileIf': ('quantile', 'If'), 'groupArrayInsertAtIf': ('groupArrayInsertAt', 'If'), 'sumIf': ('sum', 'If'), 'quantileBFloat16If': ('quantileBFloat16', 'If'), 'rankCorrIf': ('rankCorr', 'If'), 'quantileTDigestIf': ('quantileTDigest', 'If'), 'maxIntersectionsPositionIf': ('maxIntersectionsPosition', 'If'), 'sumMapIf': ('sumMap', 'If'), 'kurtSampIf': ('kurtSamp', 'If'), 'exponentialTimeDecayedAvgIf': ('exponentialTimeDecayedAvg', 'If'), 'avgWeightedIf': ('avgWeighted', 'If'), 'topKWeightedIf': ('topKWeighted', 'If'), 'largestTriangleThreeBucketsIf': ('largestTriangleThreeBuckets', 'If'), 'groupArraySampleIf': ('groupArraySample', 'If'), 'quantileExactHighIf': ('quantileExactHigh', 'If'), 'windowFunnelIf': ('windowFunnel', 'If'), 'quantileExactWeightedIf': ('quantileExactWeighted', 'If'), 'quantileExactLowIf': ('quantileExactLow', 'If'), 'maxMapIf': ('maxMap', 'If'), 'welchTTestIf': ('welchTTest', 'If'), 'groupBitOrIf': ('groupBitOr', 'If'), 'quantilesIf': ('quantiles', 'If'), 'avgIf': ('avg', 'If'), 'cramersVIf': ('cramersV', 'If'), 'anyLastIf': ('anyLast', 'If'), 'quantilesGKIf': ('quantilesGK', 'If'), 'sequenceMatchIf': ('sequenceMatch', 'If'), 'quantilesTimingWeightedIf': ('quantilesTimingWeighted', 'If'), 'quantilesDeterministicIf': ('quantilesDeterministic', 'If'), 'sumCountIf': ('sumCount', 'If'), 'maxIntersectionsIf': ('maxIntersections', 'If'), 'stddevSampIf': ('stddevSamp', 'If'), 'groupBitmapAndIf': ('groupBitmapAnd', 'If'), 'groupArrayIf': ('groupArray', 'If'), 'uniqCombinedIf': ('uniqCombined', 'If'), 'skewSampIf': ('skewSamp', 'If'), 'groupBitmapIf': ('groupBitmap', 'If'), 'quantilesBFloat16If': ('quantilesBFloat16', 'If'), 'quantilesTDigestIf': ('quantilesTDigest', 'If'), 'sequenceCountIf': ('sequenceCount', 'If'), 'uniqCombined64If': ('uniqCombined64', 'If'), 'entropyIf': ('entropy', 'If'), 'quantilesTDigestWeightedIf': ('quantilesTDigestWeighted', 'If'), 'quantileExactIf': ('quantileExact', 'If'), 'categoricalInformationValueIf': ('categoricalInformationValue', 'If'), 'topKIf': ('topK', 'If'), 'groupBitAndIf': ('groupBitAnd', 'If'), 'stddevPopIf': ('stddevPop', 'If'), 'quantileBFloat16WeightedIf': ('quantileBFloat16Weighted', 'If'), 'quantileTimingIf': ('quantileTiming', 'If'), 'groupConcatIf': ('groupConcat', 'If'), 'corrIf': ('corr', 'If'), 'sumWithOverflowIf': ('sumWithOverflow', 'If'), 'last_valueIf': ('last_value', 'If'), 'argMaxIf': ('argMax', 'If'), 'quantilesTimingIf': ('quantilesTiming', 'If'), 'groupArrayMovingSumIf': ('groupArrayMovingSum', 'If'), 'deltaSumTimestampIf': ('deltaSumTimestamp', 'If'), 'quantilesBFloat16WeightedIf': ('quantilesBFloat16Weighted', 'If'), 'intervalLengthSumIf': ('intervalLengthSum', 'If'), 'sumKahan': ('sumKahan', None), 'quantilesExactHigh': ('quantilesExactHigh', None), 'any': ('any', None), 'uniqTheta': ('uniqTheta', None), 'groupBitXor': ('groupBitXor', None), 'theilsU': ('theilsU', None), 'boundingRatio': ('boundingRatio', None), 'histogram': ('histogram', None), 'kolmogorovSmirnovTest': ('kolmogorovSmirnovTest', None), 'groupBitmapXor': ('groupBitmapXor', None), 'quantileDeterministic': ('quantileDeterministic', None), 'varPop': ('varPop', None), 'first_value': ('first_value', None), 'uniqHLL12': ('uniqHLL12', None), 'simpleLinearRegression': ('simpleLinearRegression', None), 'quantilesInterpolatedWeighted': ('quantilesInterpolatedWeighted', None), 'max': ('max', None), 'quantileTDigestWeighted': ('quantileTDigestWeighted', None), 'groupUniqArray': ('groupUniqArray', None), 'meanZTest': ('meanZTest', None), 'stochasticLogisticRegression': ('stochasticLogisticRegression', None), 'cramersVBiasCorrected': ('cramersVBiasCorrected', None), 'covarPop': ('covarPop', None), 'count': ('count', None), 'deltaSum': ('deltaSum', None), 'quantileInterpolatedWeighted': ('quantileInterpolatedWeighted', None), 'quantileGK': ('quantileGK', None), 'anyHeavy': ('anyHeavy', None), 'uniqUpTo': ('uniqUpTo', None), 'studentTTest': ('studentTTest', None), 'varSamp': ('varSamp', None), 'groupBitmapOr': ('groupBitmapOr', None), 'argMin': ('argMin', None), 'contingency': ('contingency', None), 'quantilesExactLow': ('quantilesExactLow', None), 'covarSamp': ('covarSamp', None), 'mannWhitneyUTest': ('mannWhitneyUTest', None), 'quantilesExactWeighted': ('quantilesExactWeighted', None), 'quantileTimingWeighted': ('quantileTimingWeighted', None), 'min': ('min', None), 'approx_top_sum': ('approx_top_sum', None), 'uniq': ('uniq', None), 'quantilesExact': ('quantilesExact', None), 'retention': ('retention', None), 'uniqExact': ('uniqExact', None), 'stochasticLinearRegression': ('stochasticLinearRegression', None), 'quantilesExactExclusive': ('quantilesExactExclusive', None), 'sparkBar': ('sparkBar', None), 'skewPop': ('skewPop', None), 'groupArrayMovingAvg': ('groupArrayMovingAvg', None), 'median': ('median', None), 'groupArrayLast': ('groupArrayLast', None), 'kurtPop': ('kurtPop', None), 'exponentialMovingAverage': ('exponentialMovingAverage', None), 'sequenceNextNode': ('sequenceNextNode', None), 'quantile': ('quantile', None), 'groupArrayInsertAt': ('groupArrayInsertAt', None), 'sum': ('sum', None), 'quantileBFloat16': ('quantileBFloat16', None), 'rankCorr': ('rankCorr', None), 'quantileTDigest': ('quantileTDigest', None), 'maxIntersectionsPosition': ('maxIntersectionsPosition', None), 'kurtSamp': ('kurtSamp', None), 'exponentialTimeDecayedAvg': ('exponentialTimeDecayedAvg', None), 'avgWeighted': ('avgWeighted', None), 'topKWeighted': ('topKWeighted', None), 'largestTriangleThreeBuckets': ('largestTriangleThreeBuckets', None), 'groupArraySample': ('groupArraySample', None), 'quantileExactHigh': ('quantileExactHigh', None), 'windowFunnel': ('windowFunnel', None), 'quantileExactWeighted': ('quantileExactWeighted', None), 'quantileExactLow': ('quantileExactLow', None), 'welchTTest': ('welchTTest', None), 'groupBitOr': ('groupBitOr', None), 'quantiles': ('quantiles', None), 'avg': ('avg', None), 'cramersV': ('cramersV', None), 'anyLast': ('anyLast', None), 'quantilesGK': ('quantilesGK', None), 'sequenceMatch': ('sequenceMatch', None), 'quantilesTimingWeighted': ('quantilesTimingWeighted', None), 'quantilesDeterministic': ('quantilesDeterministic', None), 'sumCount': ('sumCount', None), 'maxIntersections': ('maxIntersections', None), 'stddevSamp': ('stddevSamp', None), 'groupBitmapAnd': ('groupBitmapAnd', None), 'groupArray': ('groupArray', None), 'uniqCombined': ('uniqCombined', None), 'skewSamp': ('skewSamp', None), 'groupBitmap': ('groupBitmap', None), 'quantilesBFloat16': ('quantilesBFloat16', None), 'quantilesTDigest': ('quantilesTDigest', None), 'sequenceCount': ('sequenceCount', None), 'uniqCombined64': ('uniqCombined64', None), 'entropy': ('entropy', None), 'quantilesTDigestWeighted': ('quantilesTDigestWeighted', None), 'quantileExact': ('quantileExact', None), 'categoricalInformationValue': ('categoricalInformationValue', None), 'topK': ('topK', None), 'groupBitAnd': ('groupBitAnd', None), 'stddevPop': ('stddevPop', None), 'quantileBFloat16Weighted': ('quantileBFloat16Weighted', None), 'quantileTiming': ('quantileTiming', None), 'groupConcat': ('groupConcat', None), 'corr': ('corr', None), 'sumWithOverflow': ('sumWithOverflow', None), 'last_value': ('last_value', None), 'argMax': ('argMax', None), 'quantilesTiming': ('quantilesTiming', None), 'groupArrayMovingSum': ('groupArrayMovingSum', None), 'deltaSumTimestamp': ('deltaSumTimestamp', None), 'quantilesBFloat16Weighted': ('quantilesBFloat16Weighted', None), 'intervalLengthSum': ('intervalLengthSum', None)}
class ClickHouseParser(sqlglot.parser.Parser): 
240class ClickHouseParser(parser.Parser):
241    # Tested in ClickHouse's playground, it seems that the following two queries do the same thing
242    # * select x from t1 union all select x from t2 limit 1;
243    # * select x from t1 union all (select x from t2 limit 1);
244    MODIFIERS_ATTACHED_TO_SET_OP = False
245    INTERVAL_SPANS = False
246    OPTIONAL_ALIAS_TOKEN_CTE = False
247    JOINS_HAVE_EQUAL_PRECEDENCE = True
248
249    FUNCTIONS = {
250        **{
251            k: v
252            for k, v in parser.Parser.FUNCTIONS.items()
253            if k not in ("TRANSFORM", "APPROX_TOP_SUM")
254        },
255        **{f"TOSTARTOF{unit}": _build_timestamp_trunc(unit=unit) for unit in TIMESTAMP_TRUNC_UNITS},
256        "ANY": exp.AnyValue.from_arg_list,
257        "ARRAYCOMPACT": exp.ArrayCompact.from_arg_list,
258        "ARRAYCONCAT": exp.ArrayConcat.from_arg_list,
259        "ARRAYDISTINCT": exp.ArrayDistinct.from_arg_list,
260        "ARRAYEXCEPT": exp.ArrayExcept.from_arg_list,
261        "ARRAYSUM": exp.ArraySum.from_arg_list,
262        "ARRAYMAX": exp.ArrayMax.from_arg_list,
263        "ARRAYMIN": exp.ArrayMin.from_arg_list,
264        "ARRAYREVERSE": exp.ArrayReverse.from_arg_list,
265        "ARRAYSLICE": exp.ArraySlice.from_arg_list,
266        "CURRENTDATABASE": exp.CurrentDatabase.from_arg_list,
267        "CURRENTSCHEMAS": exp.CurrentSchemas.from_arg_list,
268        "COUNTIF": _build_count_if,
269        "CITYHASH64": exp.CityHash64.from_arg_list,
270        "COSINEDISTANCE": exp.CosineDistance.from_arg_list,
271        "VERSION": exp.CurrentVersion.from_arg_list,
272        "DATE_ADD": build_date_delta(exp.DateAdd, default_unit=None),
273        "DATEADD": build_date_delta(exp.DateAdd, default_unit=None),
274        "DATE_DIFF": build_date_delta(exp.DateDiff, default_unit=None, supports_timezone=True),
275        "DATEDIFF": build_date_delta(exp.DateDiff, default_unit=None, supports_timezone=True),
276        "DATE_FORMAT": _build_datetime_format(exp.TimeToStr),
277        "DATE_SUB": build_date_delta(exp.DateSub, default_unit=None),
278        "DATESUB": build_date_delta(exp.DateSub, default_unit=None),
279        "FORMATDATETIME": _build_datetime_format(exp.TimeToStr),
280        "HAS": exp.ArrayContains.from_arg_list,
281        "ILIKE": build_like(exp.ILike),
282        "JSONEXTRACTSTRING": build_json_extract_path(
283            exp.JSONExtractScalar, zero_based_indexing=False
284        ),
285        "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
286        "LIKE": build_like(exp.Like),
287        "L2Distance": exp.EuclideanDistance.from_arg_list,
288        "MAP": parser.build_var_map,
289        "MATCH": exp.RegexpLike.from_arg_list,
290        "NOTLIKE": build_like(exp.Like, not_like=True),
291        "PARSEDATETIME": _build_datetime_format(exp.ParseDatetime),
292        "RANDCANONICAL": exp.Rand.from_arg_list,
293        "STR_TO_DATE": _build_str_to_date,
294        "TIMESTAMP_SUB": build_date_delta(exp.TimestampSub, default_unit=None),
295        "TIMESTAMPSUB": build_date_delta(exp.TimestampSub, default_unit=None),
296        "TIMESTAMP_ADD": build_date_delta(exp.TimestampAdd, default_unit=None),
297        "TIMESTAMPADD": build_date_delta(exp.TimestampAdd, default_unit=None),
298        "TOMONDAY": _build_timestamp_trunc("WEEK"),
299        "UNIQ": exp.ApproxDistinct.from_arg_list,
300        "MD5": exp.MD5Digest.from_arg_list,
301        "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
302        "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
303        "SPLITBYCHAR": _build_split_by_char,
304        "SPLITBYREGEXP": _build_split(exp.RegexpSplit),
305        "SPLITBYSTRING": _build_split(exp.Split),
306        "SUBSTRINGINDEX": exp.SubstringIndex.from_arg_list,
307        "TOTYPENAME": exp.Typeof.from_arg_list,
308        "EDITDISTANCE": exp.Levenshtein.from_arg_list,
309        "JAROWINKLERSIMILARITY": exp.JarowinklerSimilarity.from_arg_list,
310        "LEVENSHTEINDISTANCE": exp.Levenshtein.from_arg_list,
311        "UTCTIMESTAMP": exp.UtcTimestamp.from_arg_list,
312    }
313
314    AGG_FUNCTIONS = AGG_FUNCTIONS
315    AGG_FUNCTIONS_SUFFIXES = AGG_FUNCTIONS_SUFFIXES
316
317    FUNC_TOKENS = {
318        *parser.Parser.FUNC_TOKENS,
319        TokenType.AND,
320        TokenType.FILE,
321        TokenType.OR,
322        TokenType.SET,
323    }
324
325    RESERVED_TOKENS = parser.Parser.RESERVED_TOKENS - {TokenType.SELECT}
326
327    ID_VAR_TOKENS = {
328        *parser.Parser.ID_VAR_TOKENS,
329        TokenType.LIKE,
330    }
331
332    AGG_FUNC_MAPPING = AGG_FUNC_MAPPING
333
334    @classmethod
335    def _resolve_clickhouse_agg(cls, name: str) -> tuple[str, Sequence[str]] | None:
336        # ClickHouse allows chaining multiple combinators on aggregate functions.
337        # See https://clickhouse.com/docs/sql-reference/aggregate-functions/combinators
338        # N.B. this resolution allows any suffix stack, including ones that ClickHouse rejects
339        # syntactically such as sumMergeMerge (due to repeated adjacent suffixes)
340
341        # Until we are able to identify a 1- or 0-suffix aggregate function by name,
342        # repeatedly strip and queue suffixes (checking longer suffixes first, see comment on
343        # AGG_FUNCTIONS_SUFFIXES_SORTED). This loop only runs for 2 or more suffixes,
344        # as AGG_FUNC_MAPPING memoizes all 0- and 1-suffix
345        accumulated_suffixes: deque[str] = deque()
346        while (parts := AGG_FUNC_MAPPING.get(name)) is None:
347            for suffix in AGG_FUNCTIONS_SUFFIXES:
348                if name.endswith(suffix) and len(name) != len(suffix):
349                    accumulated_suffixes.appendleft(suffix)
350                    name = name[: -len(suffix)]
351                    break
352            else:
353                return None
354
355        # We now have a 0- or 1-suffix aggregate
356        agg_func_name, inner_suffix = parts
357        if inner_suffix:
358            # this is a 1-suffix aggregate (either naturally or via repeated suffix
359            # stripping). prepend the innermost suffix.
360            accumulated_suffixes.appendleft(inner_suffix)
361
362        return (agg_func_name, accumulated_suffixes)
363
364    FUNCTION_PARSERS = {
365        **{k: v for k, v in parser.Parser.FUNCTION_PARSERS.items() if k != "MATCH"},
366        "ARRAYJOIN": lambda self: self.expression(exp.Explode(this=self._parse_expression())),
367        "GROUPCONCAT": lambda self: self._parse_group_concat(),
368        "QUANTILE": lambda self: self._parse_quantile(),
369        "MEDIAN": lambda self: self._parse_quantile(),
370        "COLUMNS": lambda self: self._parse_columns(),
371        "TUPLE": lambda self: exp.Struct.from_arg_list(self._parse_function_args(alias=True)),
372        "AND": lambda self: exp.and_(*self._parse_function_args(alias=False)),
373        "OR": lambda self: exp.or_(*self._parse_function_args(alias=False)),
374        "XOR": lambda self: exp.xor(*self._parse_function_args(alias=False)),
375    }
376
377    PROPERTY_PARSERS = {
378        **{k: v for k, v in parser.Parser.PROPERTY_PARSERS.items() if k != "DYNAMIC"},
379        "ENGINE": lambda self: self._parse_engine_property(),
380        "UUID": lambda self: self.expression(exp.UuidProperty(this=self._parse_string())),
381    }
382
383    NO_PAREN_FUNCTION_PARSERS = {
384        k: v for k, v in parser.Parser.NO_PAREN_FUNCTION_PARSERS.items() if k != "ANY"
385    }
386
387    NO_PAREN_FUNCTIONS = {
388        k: v
389        for k, v in parser.Parser.NO_PAREN_FUNCTIONS.items()
390        if k != TokenType.CURRENT_TIMESTAMP
391    }
392
393    RANGE_PARSERS = {
394        **parser.Parser.RANGE_PARSERS,
395        TokenType.GLOBAL: lambda self, this: self._parse_global_in(this),
396    }
397
398    COLUMN_OPERATORS = {
399        **{k: v for k, v in parser.Parser.COLUMN_OPERATORS.items() if k != TokenType.PLACEHOLDER},
400        TokenType.DOTCARET: lambda self, this, field: self.expression(
401            exp.NestedJSONSelect(this=this, expression=field)
402        ),
403    }
404
405    JOIN_KINDS = {
406        *parser.Parser.JOIN_KINDS,
407        TokenType.ALL,
408        TokenType.ANY,
409        TokenType.ASOF,
410        TokenType.ARRAY,
411    }
412
413    TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
414        TokenType.ALL,
415        TokenType.ANY,
416        TokenType.ARRAY,
417        TokenType.ASOF,
418        TokenType.FINAL,
419        TokenType.FORMAT,
420        TokenType.SETTINGS,
421    }
422
423    ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
424        TokenType.FORMAT,
425    }
426
427    LOG_DEFAULTS_TO_LN = True
428
429    QUERY_MODIFIER_PARSERS = {
430        **parser.Parser.QUERY_MODIFIER_PARSERS,
431        TokenType.SETTINGS: lambda self: (
432            "settings",
433            self._advance() or self._parse_csv(self._parse_assignment),
434        ),
435        TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
436    }
437
438    CONSTRAINT_PARSERS = {
439        **parser.Parser.CONSTRAINT_PARSERS,
440        "INDEX": lambda self: self._parse_index_constraint(),
441        "CODEC": lambda self: self._parse_compress(),
442        "ASSUME": lambda self: self._parse_assume_constraint(),
443    }
444
445    ALTER_PARSERS = {
446        **parser.Parser.ALTER_PARSERS,
447        "MODIFY": lambda self: self._parse_alter_table_modify(),
448        "REPLACE": lambda self: self._parse_alter_table_replace(),
449    }
450
451    SCHEMA_UNNAMED_CONSTRAINTS = {
452        *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
453        "INDEX",
454    } - {"CHECK"}
455
456    PLACEHOLDER_PARSERS = {
457        **parser.Parser.PLACEHOLDER_PARSERS,
458        TokenType.L_BRACE: lambda self: self._parse_query_parameter(),
459    }
460
461    STATEMENT_PARSERS = {
462        **parser.Parser.STATEMENT_PARSERS,
463        TokenType.DETACH: lambda self: self._parse_detach(),
464    }
465
466    def _parse_wrapped_select_or_assignment(self) -> exp.Expr | None:
467        return self._parse_wrapped(
468            lambda: self._parse_select() or self._parse_assignment(), optional=True
469        )
470
471    def _parse_check_constraint(self) -> exp.CheckColumnConstraint | None:
472        return self.expression(
473            exp.CheckColumnConstraint(this=self._parse_wrapped_select_or_assignment())
474        )
475
476    def _parse_assume_constraint(self) -> exp.AssumeColumnConstraint | None:
477        return self.expression(
478            exp.AssumeColumnConstraint(this=self._parse_wrapped_select_or_assignment())
479        )
480
481    def _parse_engine_property(self) -> exp.EngineProperty:
482        self._match(TokenType.EQ)
483        return self.expression(
484            exp.EngineProperty(this=self._parse_field(any_token=True, anonymous_func=True))
485        )
486
487    # https://clickhouse.com/docs/en/sql-reference/statements/create/function
488    def _parse_user_defined_function_expression(self) -> exp.Expr | None:
489        return self._parse_lambda()
490
491    def _parse_types(
492        self,
493        check_func: bool = False,
494        schema: bool = False,
495        allow_identifiers: bool = True,
496        with_collation: bool = False,
497    ) -> exp.Expr | None:
498        dtype = super()._parse_types(
499            check_func=check_func,
500            schema=schema,
501            allow_identifiers=allow_identifiers,
502            with_collation=with_collation,
503        )
504        if isinstance(dtype, exp.DataType) and dtype.args.get("nullable") is not True:
505            # Mark every type as non-nullable which is ClickHouse's default, unless it's
506            # already marked as nullable. This marker helps us transpile types from other
507            # dialects to ClickHouse, so that we can e.g. produce `CAST(x AS Nullable(String))`
508            # from `CAST(x AS TEXT)`. If there is a `NULL` value in `x`, the former would
509            # fail in ClickHouse without the `Nullable` type constructor.
510            dtype.set("nullable", False)
511
512        return dtype
513
514    def _parse_extract(self) -> exp.Extract | exp.Anonymous:
515        index = self._index
516        this = self._parse_bitwise()
517        if self._match(TokenType.FROM):
518            self._retreat(index)
519            return super()._parse_extract()
520
521        # We return Anonymous here because extract and regexpExtract have different semantics,
522        # so parsing extract(foo, bar) into RegexpExtract can potentially break queries. E.g.,
523        # `extract('foobar', 'b')` works, but ClickHouse crashes for `regexpExtract('foobar', 'b')`.
524        #
525        # TODO: can we somehow convert the former into an equivalent `regexpExtract` call?
526        self._match(TokenType.COMMA)
527        return self.expression(
528            exp.Anonymous(this="extract", expressions=[this, self._parse_bitwise()])
529        )
530
531    def _parse_assignment(self) -> exp.Expr | None:
532        this = super()._parse_assignment()
533
534        if self._match(TokenType.PLACEHOLDER):
535            return self.expression(
536                exp.If(
537                    this=this,
538                    true=self._parse_assignment(),
539                    false=self._match(TokenType.COLON) and self._parse_assignment(),
540                )
541            )
542
543        return this
544
545    def _parse_query_parameter(self) -> exp.Expr | None:
546        """
547        Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
548        https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
549        """
550        index = self._index
551
552        this = self._parse_id_var()
553        self._match(TokenType.COLON)
554        kind = self._parse_types(check_func=False, allow_identifiers=False) or (
555            self._match_text_seq("IDENTIFIER") and "Identifier"
556        )
557
558        if not kind:
559            self._retreat(index)
560            return None
561        elif not self._match(TokenType.R_BRACE):
562            self.raise_error("Expecting }")
563
564        if isinstance(this, exp.Identifier) and not this.quoted:
565            this = exp.var(this.name)
566
567        return self.expression(exp.Placeholder(this=this, kind=kind))
568
569    def _parse_bracket(self, this: exp.Expr | None = None) -> exp.Expr | None:
570        if this:
571            bracket_json_type = None
572
573            while self._match_pair(TokenType.L_BRACKET, TokenType.R_BRACKET):
574                bracket_json_type = exp.DataType(
575                    this=exp.DType.ARRAY,
576                    expressions=[
577                        bracket_json_type
578                        or exp.DType.JSON.into_expr(dialect=self.dialect, nullable=False)
579                    ],
580                    nested=True,
581                )
582
583            if bracket_json_type:
584                return self.expression(exp.JSONCast(this=this, to=bracket_json_type))
585
586        l_brace = self._match(TokenType.L_BRACE, advance=False)
587        bracket = super()._parse_bracket(this)
588
589        if l_brace and isinstance(bracket, exp.Struct):
590            varmap = exp.VarMap(keys=exp.Array(), values=exp.Array())
591            for expression in bracket.expressions:
592                if not isinstance(expression, exp.PropertyEQ):
593                    break
594
595                varmap.args["keys"].append("expressions", exp.Literal.string(expression.name))
596                varmap.args["values"].append("expressions", expression.expression)
597
598            return varmap
599
600        return bracket
601
602    def _parse_global_in(self, this: exp.Expr | None) -> exp.Not | exp.In:
603        is_negated = self._match(TokenType.NOT)
604        in_expr: exp.In | None = None
605        if self._match(TokenType.IN):
606            in_expr = self._parse_in(this)
607            in_expr.set("is_global", True)
608        return self.expression(exp.Not(this=in_expr)) if is_negated else t.cast(exp.In, in_expr)
609
610    def _parse_table(
611        self,
612        schema: bool = False,
613        joins: bool = False,
614        alias_tokens: Collection[TokenType] | None = None,
615        parse_bracket: bool = False,
616        is_db_reference: bool = False,
617        parse_partition: bool = False,
618        consume_pipe: bool = False,
619    ) -> exp.Expr | None:
620        this = super()._parse_table(
621            schema=schema,
622            joins=joins,
623            alias_tokens=alias_tokens,
624            parse_bracket=parse_bracket,
625            is_db_reference=is_db_reference,
626        )
627
628        if isinstance(this, exp.Table):
629            inner = this.this
630            alias = this.args.get("alias")
631
632            if isinstance(inner, exp.GenerateSeries) and alias and not alias.columns:
633                alias.set("columns", [exp.to_identifier("generate_series")])
634
635        if self._match(TokenType.FINAL):
636            this = self.expression(exp.Final(this=this))
637
638        return this
639
640    def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
641        return super()._parse_position(haystack_first=True)
642
643    # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
644    def _parse_cte(self) -> exp.CTE | None:
645        # WITH <identifier> AS <subquery expression>
646        cte: exp.CTE | None = self._try_parse(super()._parse_cte)
647
648        if not cte:
649            # WITH <expression> AS <identifier>
650            cte = self.expression(
651                exp.CTE(this=self._parse_assignment(), alias=self._parse_table_alias(), scalar=True)
652            )
653
654        return cte
655
656    def _parse_join_parts(
657        self,
658    ) -> tuple[Token | None, Token | None, Token | None]:
659        is_global = self._prev if self._match(TokenType.GLOBAL) else None
660
661        kind_pre = self._prev if self._match_set(self.JOIN_KINDS) else None
662        side = self._prev if self._match_set(self.JOIN_SIDES) else None
663        kind = self._prev if self._match_set(self.JOIN_KINDS) else None
664
665        return is_global, side or kind, kind_pre or kind
666
667    def _parse_join(
668        self,
669        skip_join_token: bool = False,
670        parse_bracket: bool = False,
671        alias_tokens: t.Collection[TokenType] | None = None,
672    ) -> exp.Join | None:
673        join = super()._parse_join(
674            skip_join_token=skip_join_token, parse_bracket=True, alias_tokens=alias_tokens
675        )
676        if join:
677            method = join.args.get("method")
678            join.set("method", None)
679            join.set("global_", method)
680
681            # tbl ARRAY JOIN arr <-- this should be a `Column` reference, not a `Table`
682            # https://clickhouse.com/docs/en/sql-reference/statements/select/array-join
683            if join.kind == "ARRAY":
684                for table in join.find_all(exp.Table):
685                    table.replace(table.to_column())
686
687        return join
688
689    def _parse_function(
690        self,
691        functions: dict[str, t.Callable] | None = None,
692        anonymous: bool = False,
693        optional_parens: bool = True,
694        any_token: bool = False,
695    ) -> exp.Expr | None:
696        expr = super()._parse_function(
697            functions=functions,
698            anonymous=anonymous,
699            optional_parens=optional_parens,
700            any_token=any_token,
701        )
702
703        func = expr.this if isinstance(expr, exp.Window) else expr
704
705        # Aggregate functions can be split in 2 parts: <func_name><suffix[es]>
706        parts = self._resolve_clickhouse_agg(func.this) if isinstance(func, exp.Anonymous) else None
707
708        if parts:
709            anon_func: exp.Anonymous = t.cast(exp.Anonymous, func)
710            params = self._parse_func_params(anon_func)
711
712            if len(parts[1]) > 0:
713                exp_class: Type[exp.Expr] = (
714                    exp.CombinedParameterizedAgg if params else exp.CombinedAggFunc
715                )
716            else:
717                exp_class = exp.ParameterizedAgg if params else exp.AnonymousAggFunc
718
719            instance = exp_class(this=anon_func.this, expressions=anon_func.expressions)
720            if params:
721                instance.set("params", params)
722            func = self.expression(instance)
723
724            if isinstance(expr, exp.Window):
725                # The window's func was parsed as Anonymous in base parser, fix its
726                # type to be ClickHouse style CombinedAnonymousAggFunc / AnonymousAggFunc
727                expr.set("this", func)
728            elif params:
729                # Params have blocked super()._parse_function() from parsing the following window
730                # (if that exists) as they're standing between the function call and the window spec
731                expr = self._parse_window(func)
732            else:
733                expr = func
734
735        return expr
736
737    def _parse_func_params(self, this: exp.Func | None = None) -> list[exp.Expr] | None:
738        if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
739            return self._parse_csv(self._parse_lambda)
740
741        if self._match(TokenType.L_PAREN):
742            params = self._parse_csv(self._parse_lambda)
743            self._match_r_paren(this)
744            return params
745
746        return None
747
748    def _parse_group_concat(self) -> exp.GroupConcat:
749        args = self._parse_csv(self._parse_lambda)
750        params = self._parse_func_params()
751
752        if params:
753            # groupConcat(sep [, limit])(expr)
754            separator = seq_get(args, 0)
755            limit = seq_get(args, 1)
756            this: exp.Expr | None = seq_get(params, 0)
757            if limit is not None:
758                this = exp.Limit(this=this, expression=limit)
759            return self.expression(exp.GroupConcat(this=this, separator=separator))
760
761        # groupConcat(expr)
762        return self.expression(exp.GroupConcat(this=seq_get(args, 0)))
763
764    def _parse_quantile(self) -> exp.Quantile:
765        this = self._parse_lambda()
766        params = self._parse_func_params()
767        if params:
768            return self.expression(exp.Quantile(this=params[0], quantile=this))
769        return self.expression(exp.Quantile(this=this, quantile=exp.Literal.number(0.5)))
770
771    def _parse_wrapped_id_vars(self, optional: bool = False) -> list[exp.Expr]:
772        return super()._parse_wrapped_id_vars(optional=True)
773
774    def _parse_column_def(
775        self, this: exp.Expr | None, computed_column: bool = True
776    ) -> exp.Expr | None:
777        if self._match(TokenType.DOT):
778            return exp.Dot(this=this, expression=self._parse_id_var())
779
780        return super()._parse_column_def(this, computed_column=computed_column)
781
782    def _parse_primary_key(
783        self,
784        wrapped_optional: bool = False,
785        in_props: bool = False,
786        named_primary_key: bool = False,
787    ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
788        return super()._parse_primary_key(
789            wrapped_optional=wrapped_optional or in_props,
790            in_props=in_props,
791            named_primary_key=named_primary_key,
792        )
793
794    def _parse_on_property(self) -> exp.Expr | None:
795        index = self._index
796        if self._match_text_seq("CLUSTER"):
797            this = self._parse_string() or self._parse_id_var()
798            if this:
799                return self.expression(exp.OnCluster(this=this))
800            else:
801                self._retreat(index)
802        return None
803
804    def _parse_index_constraint(self, kind: str | None = None) -> exp.IndexColumnConstraint:
805        # INDEX name1 expr TYPE type1(args) GRANULARITY value
806        this = self._parse_id_var()
807        expression = self._parse_assignment()
808
809        index_type = self._match_text_seq("TYPE") and (self._parse_function() or self._parse_var())
810
811        granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
812
813        return self.expression(
814            exp.IndexColumnConstraint(
815                this=this, expression=expression, index_type=index_type, granularity=granularity
816            )
817        )
818
819    def _parse_partition(self) -> exp.Partition | None:
820        # https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#how-to-set-partition-expression
821        if not self._match(TokenType.PARTITION):
822            return None
823
824        if self._match_text_seq("ID"):
825            # Corresponds to the PARTITION ID <string_value> syntax
826            expressions: list[exp.Expr] = [
827                self.expression(exp.PartitionId(this=self._parse_string()))
828            ]
829        else:
830            expressions = self._parse_expressions()
831
832        return self.expression(exp.Partition(expressions=expressions))
833
834    def _parse_alter_table_replace(self) -> exp.Expr | None:
835        partition = self._parse_partition()
836
837        if not partition or not self._match(TokenType.FROM):
838            return None
839
840        return self.expression(
841            exp.ReplacePartition(expression=partition, source=self._parse_table_parts())
842        )
843
844    def _parse_alter_table_modify(self) -> exp.Expr | None:
845        if properties := self._parse_properties():
846            return self.expression(exp.AlterModifySqlSecurity(expressions=properties.expressions))
847        return None
848
849    def _parse_definer(self) -> exp.DefinerProperty | None:
850        self._match(TokenType.EQ)
851        if self._match(TokenType.CURRENT_USER):
852            return exp.DefinerProperty(this=exp.Var(this=self._prev.text.upper()))
853        return exp.DefinerProperty(this=self._parse_string())
854
855    def _parse_projection_def(self) -> exp.ProjectionDef | None:
856        if not self._match_text_seq("PROJECTION"):
857            return None
858
859        return self.expression(
860            exp.ProjectionDef(
861                this=self._parse_id_var(), expression=self._parse_wrapped(self._parse_statement)
862            )
863        )
864
865    def _parse_constraint(self) -> exp.Expr | None:
866        return super()._parse_constraint() or self._parse_projection_def()
867
868    def _parse_alias(self, this: exp.Expr | None, explicit: bool = False) -> exp.Expr | None:
869        # In clickhouse "SELECT <expr> APPLY(...)" is a query modifier,
870        # so "APPLY" shouldn't be parsed as <expr>'s alias. However, "SELECT <expr> apply" is a valid alias
871        if self._match_pair(TokenType.APPLY, TokenType.L_PAREN, advance=False):
872            return this
873
874        return super()._parse_alias(this=this, explicit=explicit)
875
876    def _parse_expression(self) -> exp.Expr | None:
877        this = super()._parse_expression()
878
879        # Clickhouse allows "SELECT <expr> [APPLY(func)] [...]]" modifier
880        while self._match_pair(TokenType.APPLY, TokenType.L_PAREN):
881            this = exp.Apply(this=this, expression=self._parse_var(any_token=True))
882            self._match(TokenType.R_PAREN)
883
884        return this
885
886    def _parse_columns(self) -> exp.Expr:
887        this: exp.Expr = self.expression(exp.Columns(this=self._parse_lambda()))
888
889        while self._next and self._match_text_seq(")", "APPLY", "("):
890            self._match(TokenType.R_PAREN)
891            this = exp.Apply(this=this, expression=self._parse_var(any_token=True))
892        return this
893
894    def _parse_value(self, values: bool = True) -> exp.Tuple | None:
895        value = super()._parse_value(values=values)
896        if not value:
897            return None
898
899        # In Clickhouse "SELECT * FROM VALUES (1, 2, 3)" generates a table with a single column, in contrast
900        # to other dialects. For this case, we canonicalize the values into a tuple-of-tuples AST if it's not already one.
901        # In INSERT INTO statements the same clause actually references multiple columns (opposite semantics),
902        # but the final result is not altered by the extra parentheses.
903        # Note: Clickhouse allows VALUES([structure], value, ...) so the branch checks for the last expression
904        expressions = value.expressions
905        if values and not isinstance(expressions[-1], exp.Tuple):
906            value.set(
907                "expressions",
908                [self.expression(exp.Tuple(expressions=[expr])) for expr in expressions],
909            )
910
911        return value
912
913    def _parse_partitioned_by(self) -> exp.PartitionedByProperty:
914        # ClickHouse allows custom expressions as partition key
915        # https://clickhouse.com/docs/engines/table-engines/mergetree-family/custom-partitioning-key
916        return self.expression(exp.PartitionedByProperty(this=self._parse_assignment()))
917
918    def _parse_detach(self) -> exp.Detach:
919        kind = self._match_set(self.DB_CREATABLES) and self._prev.text.upper()
920        exists = self._parse_exists()
921        this = self._parse_table_parts()
922
923        return self.expression(
924            exp.Detach(
925                this=this,
926                kind=kind,
927                exists=exists,
928                cluster=self._parse_on_property() if self._match(TokenType.ON) else None,
929                permanent=self._match_text_seq("PERMANENTLY"),
930                sync=self._match_text_seq("SYNC"),
931            )
932        )

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

Arguments:
  • error_level: The desired error level. Default: ErrorLevel.IMMEDIATE
  • error_message_context: The amount of context to capture from a query string when displaying the error message (in number of characters). Default: 100
  • max_errors: Maximum number of error messages to include in a raised ParseError. This is only relevant if error_level is ErrorLevel.RAISE. Default: 3
  • max_nodes: Maximum number of AST nodes to prevent memory exhaustion. Set to -1 (default) to disable the check.
MODIFIERS_ATTACHED_TO_SET_OP = False
INTERVAL_SPANS = False
OPTIONAL_ALIAS_TOKEN_CTE = False
JOINS_HAVE_EQUAL_PRECEDENCE = True
FUNCTIONS = {'AI_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.AIAgg'>>, 'AI_CLASSIFY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIClassify'>>, 'AI_EMBED': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIEmbed'>>, 'A_I_FORECAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIForecast'>>, 'AI_GENERATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIGenerate'>>, 'AI_SIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AISimilarity'>>, 'AI_SUMMARIZE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.AISummarizeAgg'>>, 'ABS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Abs'>>, 'ACOS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Acos'>>, 'ACOSH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Acosh'>>, 'ADD_MONTHS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.AddMonths'>>, 'AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.And'>>, 'ANONYMOUS_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.AnonymousAggFunc'>>, 'ANY_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.AnyValue'>>, 'APPLY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Apply'>>, 'APPROX_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.ApproxDistinct'>>, 'APPROX_COUNT_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.ApproxDistinct'>>, 'APPROX_PERCENTILE_ACCUMULATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxPercentileAccumulate'>>, 'APPROX_PERCENTILE_COMBINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxPercentileCombine'>>, 'APPROX_PERCENTILE_ESTIMATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxPercentileEstimate'>>, 'APPROX_QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxQuantile'>>, 'APPROX_QUANTILES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxQuantiles'>>, 'APPROX_TOP_K': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopK'>>, 'APPROX_TOP_K_ACCUMULATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopKAccumulate'>>, 'APPROX_TOP_K_COMBINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopKCombine'>>, 'APPROX_TOP_K_ESTIMATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopKEstimate'>>, 'APPROXIMATE_SIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproximateSimilarity'>>, 'APPROXIMATE_JACCARD_INDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproximateSimilarity'>>, 'ARG_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMax'>>, 'ARGMAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMax'>>, 'MAX_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMax'>>, 'ARG_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMin'>>, 'ARGMIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMin'>>, 'MIN_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMin'>>, 'ARRAY': <function Parser.<lambda>>, 'ARRAY_AGG': <function Parser.<lambda>>, 'ARRAY_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayAll'>>, 'ARRAY_ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayAny'>>, 'ARRAY_APPEND': <function build_array_append>, 'ARRAY_COMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayCompact'>>, 'ARRAY_CONCAT': <function build_array_concat>, 'ARRAY_CAT': <function build_array_concat>, 'ARRAY_CONCAT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArrayConcatAgg'>>, 'ARRAY_CONSTRUCT_COMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayConstructCompact'>>, 'ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContains'>>, 'ARRAY_HAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContains'>>, 'ARRAY_CONTAINS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContainsAll'>>, 'ARRAY_HAS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContainsAll'>>, 'ARRAY_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayDistinct'>>, 'ARRAY_EXCEPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayExcept'>>, 'FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayFilter'>>, 'ARRAY_FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayFilter'>>, 'ARRAY_FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayFirst'>>, 'ARRAY_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayInsert'>>, 'ARRAY_INTERSECT': <function Parser.<lambda>>, 'ARRAY_INTERSECTION': <function Parser.<lambda>>, 'ARRAY_LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayLast'>>, 'ARRAY_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayMax'>>, 'ARRAY_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayMin'>>, 'ARRAY_OVERLAPS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayOverlaps'>>, 'ARRAY_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayPosition'>>, 'ARRAY_PREPEND': <function build_array_prepend>, 'ARRAY_REMOVE': <function build_array_remove>, 'ARRAY_REMOVE_AT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayRemoveAt'>>, 'ARRAY_REVERSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayReverse'>>, 'ARRAY_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySize'>>, 'ARRAY_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySize'>>, 'ARRAY_SLICE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySlice'>>, 'ARRAY_SORT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySort'>>, 'ARRAY_SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySum'>>, 'ARRAY_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayToString'>>, 'ARRAY_JOIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayToString'>>, 'ARRAY_UNION_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArrayUnionAgg'>>, 'ARRAY_UNIQUE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArrayUniqueAgg'>>, 'ARRAYS_ZIP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraysZip'>>, 'ASCII': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Ascii'>>, 'ASIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Asin'>>, 'ASINH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Asinh'>>, 'ATAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Atan'>>, 'ATAN2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Atan2'>>, 'ATANH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Atanh'>>, 'AVG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Avg'>>, 'BASE64_DECODE_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Base64DecodeBinary'>>, 'BASE64_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Base64DecodeString'>>, 'BASE64_ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Base64Encode'>>, 'BIT_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.BitLength'>>, 'BITMAP_BIT_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapBitPosition'>>, 'BITMAP_BUCKET_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapBucketNumber'>>, 'BITMAP_CONSTRUCT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapConstructAgg'>>, 'BITMAP_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapCount'>>, 'BITMAP_OR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapOrAgg'>>, 'BITWISE_AND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseAndAgg'>>, 'BITWISE_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseCount'>>, 'BITWISE_OR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseOrAgg'>>, 'BITWISE_XOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseXorAgg'>>, 'BOOLAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Booland'>>, 'BOOLNOT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Boolnot'>>, 'BOOLOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Boolor'>>, 'BOOLXOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BoolxorAgg'>>, 'BYTE_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ByteLength'>>, 'CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Case'>>, 'CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Cast'>>, 'CAST_TO_STR_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CastToStrType'>>, 'CBRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cbrt'>>, 'CEIL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Ceil'>>, 'CEILING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Ceil'>>, 'CHECK_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.CheckJson'>>, 'CHECK_XML': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CheckXml'>>, 'CHR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Chr'>>, 'CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Chr'>>, 'CITY_HASH64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.CityHash64'>>, 'COALESCE': <function build_coalesce>, 'IFNULL': <function build_coalesce>, 'NVL': <function build_coalesce>, 'CODE_POINTS_TO_BYTES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.CodePointsToBytes'>>, 'CODE_POINTS_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.CodePointsToString'>>, 'COLLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Collate'>>, 'COLLATION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Collation'>>, 'COLUMNS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Columns'>>, 'COMBINED_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.CombinedAggFunc'>>, 'COMBINED_PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.CombinedParameterizedAgg'>>, 'COMPRESS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Compress'>>, 'CONCAT': <function Parser.<lambda>>, 'CONCAT_WS': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ConnectByRoot'>>, 'CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Contains'>>, 'CONVERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Convert'>>, 'CONVERT_TIMEZONE': <function build_convert_timezone>, 'CONVERT_TO_CHARSET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ConvertToCharset'>>, 'CORR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Corr'>>, 'COS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cos'>>, 'COSH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cosh'>>, 'COSINE_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.CosineDistance'>>, 'COT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cot'>>, 'COTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Coth'>>, 'COUNT': <function Parser.<lambda>>, 'COUNT_IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CountIf'>>, 'COUNTIF': <function _build_count_if>, 'COVAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CovarPop'>>, 'COVAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CovarSamp'>>, 'CSC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Csc'>>, 'CSCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Csch'>>, 'CUME_DIST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CumeDist'>>, 'CURRENT_ACCOUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentAccount'>>, 'CURRENT_ACCOUNT_NAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentAccountName'>>, 'CURRENT_AVAILABLE_ROLES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentAvailableRoles'>>, 'CURRENT_CATALOG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentCatalog'>>, 'CURRENT_CLIENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentClient'>>, 'CURRENT_DATABASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentDatabase'>>, 'CURRENT_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentDate'>>, 'CURRENT_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentDatetime'>>, 'CURRENT_IP_ADDRESS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentIpAddress'>>, 'CURRENT_ORGANIZATION_NAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentOrganizationName'>>, 'CURRENT_ORGANIZATION_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentOrganizationUser'>>, 'CURRENT_REGION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentRegion'>>, 'CURRENT_ROLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentRole'>>, 'CURRENT_ROLE_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentRoleType'>>, 'CURRENT_SCHEMA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSchema'>>, 'CURRENT_SCHEMAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSchemas'>>, 'CURRENT_SECONDARY_ROLES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSecondaryRoles'>>, 'CURRENT_SESSION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSession'>>, 'CURRENT_STATEMENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentStatement'>>, 'CURRENT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTime'>>, 'CURRENT_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTimestamp'>>, 'CURRENT_TIMESTAMP_L_T_Z': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTimestampLTZ'>>, 'CURRENT_TIMEZONE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTimezone'>>, 'CURRENT_TRANSACTION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentTransaction'>>, 'CURRENT_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentUser'>>, 'CURRENT_USER_ID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentUserId'>>, 'CURRENT_VERSION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentVersion'>>, 'CURRENT_WAREHOUSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentWarehouse'>>, 'DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Date'>>, 'DATE_ADD': <function build_date_delta.<locals>._builder>, 'DATE_BIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateBin'>>, 'DATEDIFF': <function build_date_delta.<locals>._builder>, 'DATE_DIFF': <function build_date_delta.<locals>._builder>, 'DATE_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateFromParts'>>, 'DATEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateFromParts'>>, 'DATE_FROM_UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateFromUnixDate'>>, 'DATE_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateStrToDate'>>, 'DATE_SUB': <function build_date_delta.<locals>._builder>, 'DATE_TO_DATE_STR': <function Parser.<lambda>>, 'DATE_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateToDi'>>, 'DATE_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateTrunc'>>, 'DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Datetime'>>, 'DATETIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeAdd'>>, 'DATETIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeDiff'>>, 'DATETIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeSub'>>, 'DATETIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeTrunc'>>, 'DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Day'>>, 'DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfMonth'>>, 'DAYOFMONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfMonth'>>, 'DAY_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeek'>>, 'DAYOFWEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeek'>>, 'DAYOFWEEK_ISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeekIso'>>, 'ISODOW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeekIso'>>, 'DAY_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfYear'>>, 'DAYOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfYear'>>, 'DAYNAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Dayname'>>, 'DECODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Decode'>>, 'DECODE_CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.DecodeCase'>>, 'DECOMPRESS_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.DecompressBinary'>>, 'DECOMPRESS_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.DecompressString'>>, 'DECRYPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Decrypt'>>, 'DECRYPT_RAW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.DecryptRaw'>>, 'DEGREES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Degrees'>>, 'DENSE_RANK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.DenseRank'>>, 'DI_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DiToDate'>>, 'DOT_PRODUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.DotProduct'>>, 'ELT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Elt'>>, 'ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Encode'>>, 'ENCRYPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Encrypt'>>, 'ENCRYPT_RAW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.EncryptRaw'>>, 'ENDS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.EndsWith'>>, 'ENDSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.EndsWith'>>, 'EQUAL_NULL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.EqualNull'>>, 'EUCLIDEAN_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.EuclideanDistance'>>, 'EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Exists'>>, 'EXP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Exp'>>, 'EXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Explode'>>, 'EXPLODING_GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ExplodingGenerateSeries'>>, 'EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Extract'>>, 'FACTORIAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Factorial'>>, 'FARM_FINGERPRINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FarmFingerprint'>>, 'FARMFINGERPRINT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FarmFingerprint'>>, 'FEATURES_AT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.FeaturesAtTime'>>, 'FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.First'>>, 'FIRST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.FirstValue'>>, 'FLATTEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Flatten'>>, 'FLOAT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Float64'>>, 'FLOOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Floor'>>, 'FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Format'>>, 'FROM_BASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FromBase'>>, 'FROM_BASE32': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FromBase32'>>, 'FROM_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FromBase64'>>, 'FROM_ISO8601_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.FromISO8601Timestamp'>>, 'GAP_FILL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.GapFill'>>, 'GENERATE_BOOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateBool'>>, 'GENERATE_DATE_ARRAY': <function Parser.<lambda>>, 'GENERATE_DOUBLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateDouble'>>, 'GENERATE_EMBEDDING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateEmbedding'>>, 'GENERATE_INT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateInt'>>, 'GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.GenerateSeries'>>, 'GENERATE_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateTable'>>, 'GENERATE_TEXT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateText'>>, 'GENERATE_TIMESTAMP_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.GenerateTimestampArray'>>, 'GENERATOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Generator'>>, 'GET_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.GetExtract'>>, 'GET_IGNORE_CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GetIgnoreCase'>>, 'GETBIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Getbit'>>, 'GET_BIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Getbit'>>, 'GREATEST': <function Parser.<lambda>>, 'GROUP_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.GroupConcat'>>, 'GROUPING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Grouping'>>, 'GROUPING_ID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.GroupingId'>>, 'HASH_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.HashAgg'>>, 'HEX': <function build_hex>, 'HEX_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.HexDecodeString'>>, 'HLL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Hll'>>, 'HOST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Host'>>, 'HOUR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Hour'>>, 'IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.If'>>, 'IIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.If'>>, 'INITCAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Initcap'>>, 'INLINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Inline'>>, 'INT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Int64'>>, 'IS_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.IsArray'>>, 'IS_ASCII': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.IsAscii'>>, 'IS_INF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsInf'>>, 'ISINF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsInf'>>, 'IS_NAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsNan'>>, 'ISNAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsNan'>>, 'IS_NULL_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.IsNullValue'>>, 'J_S_O_N_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArray'>>, 'J_S_O_N_ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayAgg'>>, 'JSON_ARRAY_APPEND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayAppend'>>, 'JSON_ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayContains'>>, 'JSON_ARRAY_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayInsert'>>, 'JSONB_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBContains'>>, 'J_S_O_N_B_CONTAINS_ALL_TOP_KEYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBContainsAllTopKeys'>>, 'J_S_O_N_B_CONTAINS_ANY_TOP_KEYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBContainsAnyTopKeys'>>, 'J_S_O_N_B_DELETE_AT_PATH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBDeleteAtPath'>>, 'JSONB_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBExists'>>, 'JSONB_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBExtract'>>, 'JSONB_EXTRACT_SCALAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBExtractScalar'>>, 'J_S_O_N_B_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBObjectAgg'>>, 'J_S_O_N_BOOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBool'>>, 'J_S_O_N_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.JSONCast'>>, 'J_S_O_N_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONExists'>>, 'JSON_EXTRACT': <function build_extract_json_with_path.<locals>._builder>, 'JSON_EXTRACT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONExtractArray'>>, 'JSON_EXTRACT_SCALAR': <function build_extract_json_with_path.<locals>._builder>, 'JSON_FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONFormat'>>, 'JSON_KEYS': <function Parser.<lambda>>, 'J_S_O_N_KEYS_AT_DEPTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONKeysAtDepth'>>, 'J_S_O_N_OBJECT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONObject'>>, 'J_S_O_N_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONObjectAgg'>>, 'JSON_REMOVE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONRemove'>>, 'JSON_SET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONSet'>>, 'JSON_STRIP_NULLS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONStripNulls'>>, 'J_S_O_N_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONTable'>>, 'JSON_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONType'>>, 'J_S_O_N_VALUE_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.query.JSONValueArray'>>, 'JAROWINKLER_SIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.JarowinklerSimilarity'>>, 'JUSTIFY_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.JustifyDays'>>, 'JUSTIFY_HOURS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.JustifyHours'>>, 'JUSTIFY_INTERVAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.JustifyInterval'>>, 'KURTOSIS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Kurtosis'>>, 'LAG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Lag'>>, 'LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Last'>>, 'LAST_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.LastDay'>>, 'LAST_DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.LastDay'>>, 'LAST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LastValue'>>, 'LAX_BOOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxBool'>>, 'LAX_FLOAT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxFloat64'>>, 'LAX_INT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxInt64'>>, 'LAX_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxString'>>, 'LEAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Lead'>>, 'LEAST': <function Parser.<lambda>>, 'LEFT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Left'>>, 'LENGTH': <function ClickHouseParser.<lambda>>, 'LEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Length'>>, 'CHAR_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Length'>>, 'CHARACTER_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Length'>>, 'LEVENSHTEIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Levenshtein'>>, 'LIST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.List'>>, 'LN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Ln'>>, 'LOCALTIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Localtime'>>, 'LOCALTIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Localtimestamp'>>, 'LOG': <function build_logarithm>, 'LOGICAL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalAnd'>>, 'BOOL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalAnd'>>, 'BOOLAND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalAnd'>>, 'LOGICAL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalOr'>>, 'BOOL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalOr'>>, 'BOOLOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalOr'>>, 'LOWER': <function build_lower>, 'LCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Lower'>>, 'LOWER_HEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.LowerHex'>>, 'MD5': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5Digest'>>, 'MD5_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5Digest'>>, 'M_D5_NUMBER_LOWER64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5NumberLower64'>>, 'M_D5_NUMBER_UPPER64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5NumberUpper64'>>, 'M_L_FORECAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.MLForecast'>>, 'M_L_TRANSLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.MLTranslate'>>, 'MAKE_INTERVAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.MakeInterval'>>, 'MANHATTAN_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.ManhattanDistance'>>, 'MAP': <function build_var_map>, 'MAP_CAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapCat'>>, 'MAP_CONTAINS_KEY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapContainsKey'>>, 'MAP_DELETE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapDelete'>>, 'MAP_FROM_ENTRIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapFromEntries'>>, 'MAP_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapInsert'>>, 'MAP_KEYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapKeys'>>, 'MAP_PICK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapPick'>>, 'MAP_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapSize'>>, 'MATCH_AGAINST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MatchAgainst'>>, 'MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Max'>>, 'MEDIAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Median'>>, 'MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Min'>>, 'MINHASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Minhash'>>, 'MINHASH_COMBINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.MinhashCombine'>>, 'MINUTE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Minute'>>, 'MODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Mode'>>, 'MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Month'>>, 'MONTHNAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Monthname'>>, 'MONTHS_BETWEEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.MonthsBetween'>>, 'NET_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.NetFunc'>>, 'NEXT_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.NextDay'>>, 'NEXT_VALUE_FOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ddl.NextValueFor'>>, 'NORMAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Normal'>>, 'NORMALIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Normalize'>>, 'NTH_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.NthValue'>>, 'NTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Ntile'>>, 'NULLIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Nullif'>>, 'NUMBER_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.NumberToStr'>>, 'NVL2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Nvl2'>>, 'OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ObjectAgg'>>, 'OBJECT_ID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ObjectId'>>, 'OBJECT_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ObjectInsert'>>, 'OBJECT_TRANSFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ObjectTransform'>>, 'OPEN_J_S_O_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.OpenJSON'>>, 'OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Or'>>, 'OVERLAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Overlay'>>, 'PAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Pad'>>, 'PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.ParameterizedAgg'>>, 'PARSE_BIGNUMERIC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ParseBignumeric'>>, 'PARSE_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.ParseDatetime'>>, 'PARSE_IP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ParseIp'>>, 'PARSE_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ParseJSON'>>, 'JSON_PARSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ParseJSON'>>, 'PARSE_NUMERIC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ParseNumeric'>>, 'PARSE_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.ParseTime'>>, 'PARSE_URL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ParseUrl'>>, 'PERCENT_RANK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.PercentRank'>>, 'PERCENTILE_CONT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.PercentileCont'>>, 'PERCENTILE_DISC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.PercentileDisc'>>, 'PI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Pi'>>, 'POSEXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Posexplode'>>, 'POSEXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.PosexplodeOuter'>>, 'POWER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Pow'>>, 'POW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Pow'>>, 'PREDICT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Predict'>>, 'PREVIOUS_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.PreviousDay'>>, 'QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Quantile'>>, 'QUARTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Quarter'>>, 'RADIANS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Radians'>>, 'RAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Rand'>>, 'RANDOM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Rand'>>, 'RANDN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Randn'>>, 'RANDSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Randstr'>>, 'RANGE_BUCKET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.RangeBucket'>>, 'RANGE_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.RangeN'>>, 'RANK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Rank'>>, 'READ_CSV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ReadCSV'>>, 'READ_PARQUET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ReadParquet'>>, 'REDUCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Reduce'>>, 'REG_DOMAIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.RegDomain'>>, 'REGEXP_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpCount'>>, 'REGEXP_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpExtract'>>, 'REGEXP_EXTRACT_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpExtractAll'>>, 'REGEXP_FULL_MATCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpFullMatch'>>, 'REGEXP_I_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpILike'>>, 'REGEXP_INSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpInstr'>>, 'REGEXP_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.RegexpLike'>>, 'REGEXP_REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpReplace'>>, 'REGEXP_SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpSplit'>>, 'REGR_AVGX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrAvgx'>>, 'REGR_AVGY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrAvgy'>>, 'REGR_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrCount'>>, 'REGR_INTERCEPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrIntercept'>>, 'REGR_R2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrR2'>>, 'REGR_SLOPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSlope'>>, 'REGR_SXX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSxx'>>, 'REGR_SXY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSxy'>>, 'REGR_SYY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSyy'>>, 'REGR_VALX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrValx'>>, 'REGR_VALY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrValy'>>, 'REPEAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Repeat'>>, 'REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Replace'>>, 'REVERSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Reverse'>>, 'RIGHT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Right'>>, 'ROUND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Round'>>, 'ROW_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RowNumber'>>, 'RTRIMMED_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RtrimmedLength'>>, 'SHA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA'>>, 'SHA1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA'>>, 'S_H_A1_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA1Digest'>>, 'SHA2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA2'>>, 'S_H_A2_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA2Digest'>>, 'SAFE_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeAdd'>>, 'SAFE_CONVERT_BYTES_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SafeConvertBytesToString'>>, 'SAFE_DIVIDE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeDivide'>>, 'SAFE_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.SafeFunc'>>, 'SAFE_MULTIPLY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeMultiply'>>, 'SAFE_NEGATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeNegate'>>, 'SAFE_SUBTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeSubtract'>>, 'SEARCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Search'>>, 'SEARCH_IP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SearchIp'>>, 'SEC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sec'>>, 'SECH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sech'>>, 'SECOND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Second'>>, 'SEQ1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq1'>>, 'SEQ2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq2'>>, 'SEQ4': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq4'>>, 'SEQ8': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq8'>>, 'SESSION_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.SessionUser'>>, 'SIGN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sign'>>, 'SIGNUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sign'>>, 'SIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sin'>>, 'SINH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sinh'>>, 'SKEWNESS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Skewness'>>, 'SORT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.SortArray'>>, 'SOUNDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Soundex'>>, 'SOUNDEX_P123': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SoundexP123'>>, 'SPACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Space'>>, 'SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Split'>>, 'SPLIT_PART': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SplitPart'>>, 'SQRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sqrt'>>, 'ST_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StDistance'>>, 'ST_POINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StPoint'>>, 'ST_MAKEPOINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StPoint'>>, 'STANDARD_HASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StandardHash'>>, 'STAR_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StarMap'>>, 'STARTS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StartsWith'>>, 'STARTSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StartsWith'>>, 'STDDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Stddev'>>, 'STDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Stddev'>>, 'STDDEV_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.StddevPop'>>, 'STDDEV_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.StddevSamp'>>, 'STR_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StrPosition'>>, 'STR_TO_DATE': <function _build_str_to_date>, 'STR_TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StrToMap'>>, 'STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.StrToTime'>>, 'STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.StrToUnix'>>, 'STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.String'>>, 'STRING_TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StringToArray'>>, 'SPLIT_BY_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StringToArray'>>, 'STRIP_NULL_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.StripNullValue'>>, 'STRTOK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Strtok'>>, 'STRTOK_TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StrtokToArray'>>, 'STRUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Struct'>>, 'STRUCT_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StructExtract'>>, 'STUFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Stuff'>>, 'INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Stuff'>>, 'SUBSTRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Substring'>>, 'SUBSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Substring'>>, 'SUBSTRING_INDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SubstringIndex'>>, 'SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Sum'>>, 'SYSTIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Systimestamp'>>, 'TAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Tan'>>, 'TANH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Tanh'>>, 'TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Time'>>, 'TIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeAdd'>>, 'TIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeDiff'>>, 'TIME_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeFromParts'>>, 'TIMEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeFromParts'>>, 'TIME_SLICE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeSlice'>>, 'TIME_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeStrToDate'>>, 'TIME_STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeStrToTime'>>, 'TIME_STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeStrToUnix'>>, 'TIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeSub'>>, 'TIME_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeToStr'>>, 'TIME_TO_TIME_STR': <function Parser.<lambda>>, 'TIME_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeToUnix'>>, 'TIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeTrunc'>>, 'TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Timestamp'>>, 'TIMESTAMP_ADD': <function build_date_delta.<locals>._builder>, 'TIMESTAMPDIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampDiff'>>, 'TIMESTAMP_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampDiff'>>, 'TIMESTAMP_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampFromParts'>>, 'TIMESTAMPFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampFromParts'>>, 'TIMESTAMP_LTZ_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampLtzFromParts'>>, 'TIMESTAMPLTZFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampLtzFromParts'>>, 'TIMESTAMP_SUB': <function build_date_delta.<locals>._builder>, 'TIMESTAMP_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampTrunc'>>, 'TIMESTAMP_TZ_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampTzFromParts'>>, 'TIMESTAMPTZFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampTzFromParts'>>, 'TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ToArray'>>, 'TO_BASE32': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToBase32'>>, 'TO_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToBase64'>>, 'TO_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToBinary'>>, 'TO_BOOLEAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ToBoolean'>>, 'TO_CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToChar'>>, 'TO_CODE_POINTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToCodePoints'>>, 'TO_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.ToDays'>>, 'TO_DECFLOAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToDecfloat'>>, 'TO_DOUBLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToDouble'>>, 'TO_FILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToFile'>>, 'TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ToMap'>>, 'TO_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToNumber'>>, 'TO_VARIANT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ToVariant'>>, 'TRANSLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Translate'>>, 'TRIM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Trim'>>, 'TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Trunc'>>, 'TRUNCATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Trunc'>>, 'TRY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Try'>>, 'TRY_BASE64_DECODE_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryBase64DecodeBinary'>>, 'TRY_BASE64_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryBase64DecodeString'>>, 'TRY_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.TryCast'>>, 'TRY_HEX_DECODE_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryHexDecodeBinary'>>, 'TRY_HEX_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryHexDecodeString'>>, 'TRY_TO_DECFLOAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryToDecfloat'>>, 'TS_OR_DI_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDiToDi'>>, 'TS_OR_DS_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsAdd'>>, 'TS_OR_DS_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsDiff'>>, 'TS_OR_DS_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsToDate'>>, 'TS_OR_DS_TO_DATE_STR': <function Parser.<lambda>>, 'TS_OR_DS_TO_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsToDatetime'>>, 'TS_OR_DS_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsToTime'>>, 'TS_OR_DS_TO_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsToTimestamp'>>, 'TYPEOF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Typeof'>>, 'UNHEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Unhex'>>, 'UNICODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Unicode'>>, 'UNIFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Uniform'>>, 'UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixDate'>>, 'UNIX_MICROS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixMicros'>>, 'UNIX_MILLIS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixMillis'>>, 'UNIX_SECONDS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixSeconds'>>, 'UNIX_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixToStr'>>, 'UNIX_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixToTime'>>, 'UNIX_TO_TIME_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixToTimeStr'>>, 'UNNEST': <function Parser.<lambda>>, 'UPPER': <function build_upper>, 'UCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Upper'>>, 'UTC_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UtcDate'>>, 'UTC_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UtcTime'>>, 'UTC_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UtcTimestamp'>>, 'UUID': <function Parser.<lambda>>, 'GEN_RANDOM_UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Uuid'>>, 'GENERATE_UUID': <function Parser.<lambda>>, 'UUID_STRING': <function Parser.<lambda>>, 'VAR_MAP': <function build_var_map>, 'VARIANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Variance'>>, 'VARIANCE_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Variance'>>, 'VAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Variance'>>, 'VARIANCE_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.VariancePop'>>, 'VAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.VariancePop'>>, 'VECTOR_SEARCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.VectorSearch'>>, 'WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Week'>>, 'WEEK_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.WeekOfYear'>>, 'WEEKOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.WeekOfYear'>>, 'WEEK_START': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.WeekStart'>>, 'WIDTH_BUCKET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.WidthBucket'>>, 'XMLELEMENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.XMLElement'>>, 'XMLGET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.XMLGet'>>, 'X_M_L_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.XMLTable'>>, 'XOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Xor'>>, 'YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Year'>>, 'YEAR_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeek'>>, 'YEAROFWEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeek'>>, 'YEAR_OF_WEEK_ISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeekIso'>>, 'YEAROFWEEKISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeekIso'>>, 'ZIPF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Zipf'>>, 'EXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array._ExplodeOuter'>>, 'ARRAYAGG': <function Parser.<lambda>>, 'GLOB': <function Parser.<lambda>>, 'JSON_EXTRACT_PATH_TEXT': <function build_extract_json_with_path.<locals>._builder>, 'LIKE': <function build_like.<locals>._builder>, 'LOG2': <function Parser.<lambda>>, 'LOG10': <function Parser.<lambda>>, 'LPAD': <function Parser.<lambda>>, 'LEFTPAD': <function Parser.<lambda>>, 'LTRIM': <function Parser.<lambda>>, 'MOD': <function build_mod>, 'RIGHTPAD': <function Parser.<lambda>>, 'RPAD': <function Parser.<lambda>>, 'RTRIM': <function Parser.<lambda>>, 'SCOPE_RESOLUTION': <function Parser.<lambda>>, 'STRPOS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StrPosition'>>, 'CHARINDEX': <function Parser.<lambda>>, 'INSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StrPosition'>>, 'LOCATE': <function Parser.<lambda>>, 'TO_HEX': <function build_hex>, 'TOSTARTOFMINUTE': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFQUARTER': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFMONTH': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFYEAR': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFMICROSECOND': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFHOUR': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFSECOND': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFMILLISECOND': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFDAY': <function _build_timestamp_trunc.<locals>.<lambda>>, 'ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.AnyValue'>>, 'ARRAYCOMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayCompact'>>, 'ARRAYCONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayConcat'>>, 'ARRAYDISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayDistinct'>>, 'ARRAYEXCEPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayExcept'>>, 'ARRAYSUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySum'>>, 'ARRAYMAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayMax'>>, 'ARRAYMIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayMin'>>, 'ARRAYREVERSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayReverse'>>, 'ARRAYSLICE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySlice'>>, 'CURRENTDATABASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentDatabase'>>, 'CURRENTSCHEMAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSchemas'>>, 'CITYHASH64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.CityHash64'>>, 'COSINEDISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.CosineDistance'>>, 'VERSION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentVersion'>>, 'DATEADD': <function build_date_delta.<locals>._builder>, 'DATE_FORMAT': <function _build_datetime_format.<locals>._builder>, 'DATESUB': <function build_date_delta.<locals>._builder>, 'FORMATDATETIME': <function _build_datetime_format.<locals>._builder>, 'HAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContains'>>, 'ILIKE': <function build_like.<locals>._builder>, 'JSONEXTRACTSTRING': <function build_json_extract_path.<locals>._builder>, 'L2Distance': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.EuclideanDistance'>>, 'MATCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.RegexpLike'>>, 'NOTLIKE': <function build_like.<locals>._builder>, 'PARSEDATETIME': <function _build_datetime_format.<locals>._builder>, 'RANDCANONICAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Rand'>>, 'TIMESTAMPSUB': <function build_date_delta.<locals>._builder>, 'TIMESTAMPADD': <function build_date_delta.<locals>._builder>, 'TOMONDAY': <function _build_timestamp_trunc.<locals>.<lambda>>, 'UNIQ': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.ApproxDistinct'>>, 'SHA256': <function ClickHouseParser.<lambda>>, 'SHA512': <function ClickHouseParser.<lambda>>, 'SPLITBYCHAR': <function _build_split_by_char>, 'SPLITBYREGEXP': <function _build_split.<locals>.<lambda>>, 'SPLITBYSTRING': <function _build_split.<locals>.<lambda>>, 'SUBSTRINGINDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SubstringIndex'>>, 'TOTYPENAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Typeof'>>, 'EDITDISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Levenshtein'>>, 'JAROWINKLERSIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.JarowinklerSimilarity'>>, 'LEVENSHTEINDISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Levenshtein'>>, 'UTCTIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UtcTimestamp'>>}
AGG_FUNCTIONS = {'sumKahan', 'quantilesExactHigh', 'any', 'uniqTheta', 'groupBitXor', 'theilsU', 'boundingRatio', 'histogram', 'kolmogorovSmirnovTest', 'groupBitmapXor', 'quantileDeterministic', 'varPop', 'first_value', 'uniqHLL12', 'minMap', 'simpleLinearRegression', 'quantilesInterpolatedWeighted', 'max', 'quantileTDigestWeighted', 'groupUniqArray', 'meanZTest', 'stochasticLogisticRegression', 'cramersVBiasCorrected', 'covarPop', 'count', 'deltaSum', 'quantileInterpolatedWeighted', 'quantileGK', 'anyHeavy', 'uniqUpTo', 'studentTTest', 'varSamp', 'groupBitmapOr', 'argMin', 'contingency', 'quantilesExactLow', 'covarSamp', 'mannWhitneyUTest', 'quantilesExactWeighted', 'quantileTimingWeighted', 'min', 'approx_top_sum', 'uniq', 'quantilesExact', 'retention', 'uniqExact', 'stochasticLinearRegression', 'quantilesExactExclusive', 'sparkBar', 'skewPop', 'groupArrayMovingAvg', 'median', 'groupArrayLast', 'kurtPop', 'exponentialMovingAverage', 'sequenceNextNode', 'quantile', 'groupArrayInsertAt', 'sum', 'quantileBFloat16', 'rankCorr', 'quantileTDigest', 'maxIntersectionsPosition', 'sumMap', 'kurtSamp', 'exponentialTimeDecayedAvg', 'avgWeighted', 'topKWeighted', 'largestTriangleThreeBuckets', 'groupArraySample', 'quantileExactHigh', 'windowFunnel', 'quantileExactWeighted', 'quantileExactLow', 'maxMap', 'welchTTest', 'groupBitOr', 'quantiles', 'avg', 'cramersV', 'anyLast', 'quantilesGK', 'sequenceMatch', 'quantilesTimingWeighted', 'quantilesDeterministic', 'sumCount', 'maxIntersections', 'stddevSamp', 'groupBitmapAnd', 'groupArray', 'uniqCombined', 'skewSamp', 'groupBitmap', 'quantilesBFloat16', 'quantilesTDigest', 'sequenceCount', 'uniqCombined64', 'entropy', 'quantilesTDigestWeighted', 'quantileExact', 'categoricalInformationValue', 'topK', 'groupBitAnd', 'stddevPop', 'quantileBFloat16Weighted', 'quantileTiming', 'groupConcat', 'corr', 'sumWithOverflow', 'last_value', 'argMax', 'quantilesTiming', 'groupArrayMovingSum', 'deltaSumTimestamp', 'quantilesBFloat16Weighted', 'intervalLengthSum'}
AGG_FUNCTIONS_SUFFIXES = ['SimpleState', 'MergeState', 'OrDefault', 'Distinct', 'Resample', 'ArrayIf', 'ForEach', 'OrNull', 'ArgMin', 'ArgMax', 'Array', 'State', 'Merge', 'Map', 'If']
FUNC_TOKENS = {<TokenType.AND: 34>, <TokenType.OR: 35>, <TokenType.SESSION_USER: 60>, <TokenType.XOR: 65>, <TokenType.IDENTIFIER: 78>, <TokenType.TABLE: 83>, <TokenType.VAR: 88>, <TokenType.BIT: 96>, <TokenType.BOOLEAN: 97>, <TokenType.TINYINT: 98>, <TokenType.UTINYINT: 99>, <TokenType.SMALLINT: 100>, <TokenType.USMALLINT: 101>, <TokenType.MEDIUMINT: 102>, <TokenType.UMEDIUMINT: 103>, <TokenType.INT: 104>, <TokenType.UINT: 105>, <TokenType.BIGINT: 106>, <TokenType.UBIGINT: 107>, <TokenType.BIGNUM: 108>, <TokenType.INT128: 109>, <TokenType.UINT128: 110>, <TokenType.INT256: 111>, <TokenType.UINT256: 112>, <TokenType.FLOAT: 113>, <TokenType.DOUBLE: 114>, <TokenType.UDOUBLE: 115>, <TokenType.DECIMAL: 116>, <TokenType.DECIMAL32: 117>, <TokenType.DECIMAL64: 118>, <TokenType.DECIMAL128: 119>, <TokenType.DECIMAL256: 120>, <TokenType.DECFLOAT: 121>, <TokenType.UDECIMAL: 122>, <TokenType.BIGDECIMAL: 123>, <TokenType.CHAR: 124>, <TokenType.NCHAR: 125>, <TokenType.VARCHAR: 126>, <TokenType.NVARCHAR: 127>, <TokenType.BPCHAR: 128>, <TokenType.TEXT: 129>, <TokenType.MEDIUMTEXT: 130>, <TokenType.LONGTEXT: 131>, <TokenType.BLOB: 132>, <TokenType.MEDIUMBLOB: 133>, <TokenType.LONGBLOB: 134>, <TokenType.TINYBLOB: 135>, <TokenType.TINYTEXT: 136>, <TokenType.NAME: 137>, <TokenType.BINARY: 138>, <TokenType.VARBINARY: 139>, <TokenType.JSON: 140>, <TokenType.JSONB: 141>, <TokenType.TIME: 142>, <TokenType.TIMETZ: 143>, <TokenType.TIME_NS: 144>, <TokenType.TIMESTAMP: 145>, <TokenType.TIMESTAMPTZ: 146>, <TokenType.TIMESTAMPLTZ: 147>, <TokenType.TIMESTAMPNTZ: 148>, <TokenType.TIMESTAMP_S: 149>, <TokenType.TIMESTAMP_MS: 150>, <TokenType.TIMESTAMP_NS: 151>, <TokenType.DATETIME: 152>, <TokenType.DATETIME2: 153>, <TokenType.DATETIME64: 154>, <TokenType.SMALLDATETIME: 155>, <TokenType.DATE: 156>, <TokenType.DATE32: 157>, <TokenType.INT4RANGE: 158>, <TokenType.INT4MULTIRANGE: 159>, <TokenType.INT8RANGE: 160>, <TokenType.INT8MULTIRANGE: 161>, <TokenType.NUMRANGE: 162>, <TokenType.NUMMULTIRANGE: 163>, <TokenType.TSRANGE: 164>, <TokenType.TSMULTIRANGE: 165>, <TokenType.TSTZRANGE: 166>, <TokenType.TSTZMULTIRANGE: 167>, <TokenType.DATERANGE: 168>, <TokenType.DATEMULTIRANGE: 169>, <TokenType.UUID: 170>, <TokenType.GEOGRAPHY: 171>, <TokenType.GEOGRAPHYPOINT: 172>, <TokenType.NULLABLE: 173>, <TokenType.GEOMETRY: 174>, <TokenType.POINT: 175>, <TokenType.RING: 176>, <TokenType.LINESTRING: 177>, <TokenType.LOCALTIME: 178>, <TokenType.LOCALTIMESTAMP: 179>, <TokenType.MULTILINESTRING: 181>, <TokenType.POLYGON: 182>, <TokenType.MULTIPOLYGON: 183>, <TokenType.HLLSKETCH: 184>, <TokenType.HSTORE: 185>, <TokenType.SUPER: 186>, <TokenType.SERIAL: 187>, <TokenType.SMALLSERIAL: 188>, <TokenType.BIGSERIAL: 189>, <TokenType.XML: 190>, <TokenType.YEAR: 191>, <TokenType.USERDEFINED: 192>, <TokenType.MONEY: 193>, <TokenType.SMALLMONEY: 194>, <TokenType.ROWVERSION: 195>, <TokenType.IMAGE: 196>, <TokenType.VARIANT: 197>, <TokenType.OBJECT: 198>, <TokenType.INET: 199>, <TokenType.IPADDRESS: 200>, <TokenType.IPPREFIX: 201>, <TokenType.IPV4: 202>, <TokenType.IPV6: 203>, <TokenType.ENUM: 204>, <TokenType.ENUM8: 205>, <TokenType.ENUM16: 206>, <TokenType.FIXEDSTRING: 207>, <TokenType.LOWCARDINALITY: 208>, <TokenType.NESTED: 209>, <TokenType.AGGREGATEFUNCTION: 210>, <TokenType.SIMPLEAGGREGATEFUNCTION: 211>, <TokenType.TDIGEST: 212>, <TokenType.UNKNOWN: 213>, <TokenType.VECTOR: 214>, <TokenType.DYNAMIC: 215>, <TokenType.VOID: 216>, <TokenType.ALL: 219>, <TokenType.ANY: 221>, <TokenType.ARRAY: 223>, <TokenType.COLLATE: 235>, <TokenType.COMMAND: 236>, <TokenType.CURRENT_DATE: 245>, <TokenType.CURRENT_DATETIME: 246>, <TokenType.CURRENT_SCHEMA: 247>, <TokenType.CURRENT_TIME: 248>, <TokenType.CURRENT_TIMESTAMP: 249>, <TokenType.CURRENT_USER: 250>, <TokenType.CURRENT_CATALOG: 253>, <TokenType.EXISTS: 270>, <TokenType.FILE: 273>, <TokenType.FILTER: 275>, <TokenType.FIRST: 277>, <TokenType.FORMAT: 281>, <TokenType.GET: 285>, <TokenType.GLOB: 286>, <TokenType.ILIKE: 294>, <TokenType.INDEX: 296>, <TokenType.INSERT: 299>, <TokenType.INTERVAL: 303>, <TokenType.ISNULL: 308>, <TokenType.LEFT: 316>, <TokenType.LIKE: 317>, <TokenType.LIST: 319>, <TokenType.MAP: 322>, <TokenType.MERGE: 327>, <TokenType.NEXT: 331>, <TokenType.NOTHING: 332>, <TokenType.NULL: 334>, <TokenType.OBJECT_IDENTIFIER: 335>, <TokenType.OFFSET: 336>, <TokenType.PRIMARY_KEY: 361>, <TokenType.PSEUDO_TYPE: 364>, <TokenType.RANGE: 369>, <TokenType.REPLACE: 373>, <TokenType.RIGHT: 377>, <TokenType.RLIKE: 378>, <TokenType.ROW: 382>, <TokenType.SEQUENCE: 388>, <TokenType.SET: 390>, <TokenType.SOME: 394>, <TokenType.STRUCT: 401>, <TokenType.TRUNCATE: 409>, <TokenType.UNION: 413>, <TokenType.UNNEST: 414>, <TokenType.WINDOW: 427>, <TokenType.UTC_DATE: 430>, <TokenType.UTC_TIME: 431>, <TokenType.UTC_TIMESTAMP: 432>}
RESERVED_TOKENS = {<TokenType.L_PAREN: 1>, <TokenType.R_PAREN: 2>, <TokenType.L_BRACKET: 3>, <TokenType.R_BRACKET: 4>, <TokenType.L_BRACE: 5>, <TokenType.R_BRACE: 6>, <TokenType.COMMA: 7>, <TokenType.DOT: 8>, <TokenType.DASH: 9>, <TokenType.PLUS: 10>, <TokenType.COLON: 11>, <TokenType.MOD: 328>, <TokenType.SEMICOLON: 19>, <TokenType.STAR: 20>, <TokenType.BACKSLASH: 21>, <TokenType.SLASH: 22>, <TokenType.LT: 23>, <TokenType.UNKNOWN: 213>, <TokenType.GT: 25>, <TokenType.NOT: 27>, <TokenType.EQ: 28>, <TokenType.PLACEHOLDER: 355>, <TokenType.AMP: 36>, <TokenType.PIPE: 39>, <TokenType.CARET: 42>, <TokenType.TILDE: 44>, <TokenType.HASH: 48>, <TokenType.PARAMETER: 57>}
ID_VAR_TOKENS = {<TokenType.SESSION: 58>, <TokenType.SESSION_USER: 60>, <TokenType.IDENTIFIER: 78>, <TokenType.DATABASE: 79>, <TokenType.COLUMN: 80>, <TokenType.SCHEMA: 82>, <TokenType.TABLE: 83>, <TokenType.WAREHOUSE: 84>, <TokenType.STAGE: 85>, <TokenType.STREAM: 86>, <TokenType.STREAMLIT: 87>, <TokenType.VAR: 88>, <TokenType.BIT: 96>, <TokenType.BOOLEAN: 97>, <TokenType.TINYINT: 98>, <TokenType.UTINYINT: 99>, <TokenType.SMALLINT: 100>, <TokenType.USMALLINT: 101>, <TokenType.MEDIUMINT: 102>, <TokenType.UMEDIUMINT: 103>, <TokenType.INT: 104>, <TokenType.UINT: 105>, <TokenType.BIGINT: 106>, <TokenType.UBIGINT: 107>, <TokenType.BIGNUM: 108>, <TokenType.INT128: 109>, <TokenType.UINT128: 110>, <TokenType.INT256: 111>, <TokenType.UINT256: 112>, <TokenType.FLOAT: 113>, <TokenType.DOUBLE: 114>, <TokenType.UDOUBLE: 115>, <TokenType.DECIMAL: 116>, <TokenType.DECIMAL32: 117>, <TokenType.DECIMAL64: 118>, <TokenType.DECIMAL128: 119>, <TokenType.DECIMAL256: 120>, <TokenType.DECFLOAT: 121>, <TokenType.UDECIMAL: 122>, <TokenType.BIGDECIMAL: 123>, <TokenType.CHAR: 124>, <TokenType.NCHAR: 125>, <TokenType.VARCHAR: 126>, <TokenType.NVARCHAR: 127>, <TokenType.BPCHAR: 128>, <TokenType.TEXT: 129>, <TokenType.MEDIUMTEXT: 130>, <TokenType.LONGTEXT: 131>, <TokenType.BLOB: 132>, <TokenType.MEDIUMBLOB: 133>, <TokenType.LONGBLOB: 134>, <TokenType.TINYBLOB: 135>, <TokenType.TINYTEXT: 136>, <TokenType.NAME: 137>, <TokenType.BINARY: 138>, <TokenType.VARBINARY: 139>, <TokenType.JSON: 140>, <TokenType.JSONB: 141>, <TokenType.TIME: 142>, <TokenType.TIMETZ: 143>, <TokenType.TIME_NS: 144>, <TokenType.TIMESTAMP: 145>, <TokenType.TIMESTAMPTZ: 146>, <TokenType.TIMESTAMPLTZ: 147>, <TokenType.TIMESTAMPNTZ: 148>, <TokenType.TIMESTAMP_S: 149>, <TokenType.TIMESTAMP_MS: 150>, <TokenType.TIMESTAMP_NS: 151>, <TokenType.DATETIME: 152>, <TokenType.DATETIME2: 153>, <TokenType.DATETIME64: 154>, <TokenType.SMALLDATETIME: 155>, <TokenType.DATE: 156>, <TokenType.DATE32: 157>, <TokenType.INT4RANGE: 158>, <TokenType.INT4MULTIRANGE: 159>, <TokenType.INT8RANGE: 160>, <TokenType.INT8MULTIRANGE: 161>, <TokenType.NUMRANGE: 162>, <TokenType.NUMMULTIRANGE: 163>, <TokenType.TSRANGE: 164>, <TokenType.TSMULTIRANGE: 165>, <TokenType.TSTZRANGE: 166>, <TokenType.TSTZMULTIRANGE: 167>, <TokenType.DATERANGE: 168>, <TokenType.DATEMULTIRANGE: 169>, <TokenType.UUID: 170>, <TokenType.GEOGRAPHY: 171>, <TokenType.GEOGRAPHYPOINT: 172>, <TokenType.NULLABLE: 173>, <TokenType.GEOMETRY: 174>, <TokenType.POINT: 175>, <TokenType.RING: 176>, <TokenType.LINESTRING: 177>, <TokenType.LOCALTIME: 178>, <TokenType.LOCALTIMESTAMP: 179>, <TokenType.MULTILINESTRING: 181>, <TokenType.POLYGON: 182>, <TokenType.MULTIPOLYGON: 183>, <TokenType.HLLSKETCH: 184>, <TokenType.HSTORE: 185>, <TokenType.SUPER: 186>, <TokenType.SERIAL: 187>, <TokenType.SMALLSERIAL: 188>, <TokenType.BIGSERIAL: 189>, <TokenType.XML: 190>, <TokenType.YEAR: 191>, <TokenType.USERDEFINED: 192>, <TokenType.MONEY: 193>, <TokenType.SMALLMONEY: 194>, <TokenType.ROWVERSION: 195>, <TokenType.IMAGE: 196>, <TokenType.VARIANT: 197>, <TokenType.OBJECT: 198>, <TokenType.INET: 199>, <TokenType.IPADDRESS: 200>, <TokenType.IPPREFIX: 201>, <TokenType.IPV4: 202>, <TokenType.IPV6: 203>, <TokenType.ENUM: 204>, <TokenType.ENUM8: 205>, <TokenType.ENUM16: 206>, <TokenType.FIXEDSTRING: 207>, <TokenType.LOWCARDINALITY: 208>, <TokenType.NESTED: 209>, <TokenType.AGGREGATEFUNCTION: 210>, <TokenType.SIMPLEAGGREGATEFUNCTION: 211>, <TokenType.TDIGEST: 212>, <TokenType.UNKNOWN: 213>, <TokenType.VECTOR: 214>, <TokenType.DYNAMIC: 215>, <TokenType.VOID: 216>, <TokenType.ALL: 219>, <TokenType.ANTI: 220>, <TokenType.ANY: 221>, <TokenType.APPLY: 222>, <TokenType.ARRAY: 223>, <TokenType.ASC: 224>, <TokenType.ASOF: 225>, <TokenType.ATTACH: 226>, <TokenType.AUTO_INCREMENT: 227>, <TokenType.BEGIN: 228>, <TokenType.CACHE: 231>, <TokenType.CASE: 232>, <TokenType.COLLATE: 235>, <TokenType.COMMAND: 236>, <TokenType.COMMENT: 237>, <TokenType.COMMIT: 238>, <TokenType.CONSTRAINT: 240>, <TokenType.COPY: 241>, <TokenType.CUBE: 244>, <TokenType.CURRENT_DATE: 245>, <TokenType.CURRENT_DATETIME: 246>, <TokenType.CURRENT_SCHEMA: 247>, <TokenType.CURRENT_TIME: 248>, <TokenType.CURRENT_TIMESTAMP: 249>, <TokenType.CURRENT_USER: 250>, <TokenType.CURRENT_ROLE: 252>, <TokenType.CURRENT_CATALOG: 253>, <TokenType.DEFAULT: 255>, <TokenType.DELETE: 256>, <TokenType.DESC: 257>, <TokenType.DESCRIBE: 258>, <TokenType.DETACH: 259>, <TokenType.DICTIONARY: 260>, <TokenType.DIV: 263>, <TokenType.END: 266>, <TokenType.ESCAPE: 267>, <TokenType.EXECUTE: 269>, <TokenType.EXISTS: 270>, <TokenType.FALSE: 271>, <TokenType.FILE: 273>, <TokenType.FILE_FORMAT: 274>, <TokenType.FILTER: 275>, <TokenType.FINAL: 276>, <TokenType.FIRST: 277>, <TokenType.FOREIGN_KEY: 280>, <TokenType.FORMAT: 281>, <TokenType.FULL: 283>, <TokenType.FUNCTION: 284>, <TokenType.GET: 285>, <TokenType.INDEX: 296>, <TokenType.INTERVAL: 303>, <TokenType.IS: 307>, <TokenType.ISNULL: 308>, <TokenType.KEEP: 311>, <TokenType.KILL: 313>, <TokenType.LEFT: 316>, <TokenType.LIKE: 317>, <TokenType.LIMIT: 318>, <TokenType.LIST: 319>, <TokenType.LOAD: 320>, <TokenType.LOCK: 321>, <TokenType.MAP: 322>, <TokenType.MATCH: 323>, <TokenType.MERGE: 327>, <TokenType.MODEL: 329>, <TokenType.NATURAL: 330>, <TokenType.NEXT: 331>, <TokenType.NOTHING: 332>, <TokenType.NULL: 334>, <TokenType.OBJECT_IDENTIFIER: 335>, <TokenType.OFFSET: 336>, <TokenType.OPERATOR: 339>, <TokenType.ORDINALITY: 343>, <TokenType.INOUT: 345>, <TokenType.OVER: 347>, <TokenType.OVERLAPS: 348>, <TokenType.OVERWRITE: 349>, <TokenType.PARTITION: 351>, <TokenType.PERCENT: 353>, <TokenType.PIVOT: 354>, <TokenType.PRAGMA: 359>, <TokenType.PROCEDURE: 362>, <TokenType.PSEUDO_TYPE: 364>, <TokenType.PUT: 365>, <TokenType.RANGE: 369>, <TokenType.RECURSIVE: 370>, <TokenType.REFRESH: 371>, <TokenType.RENAME: 372>, <TokenType.REPLACE: 373>, <TokenType.REFERENCES: 376>, <TokenType.RIGHT: 377>, <TokenType.ROLLUP: 381>, <TokenType.ROW: 382>, <TokenType.ROWS: 383>, <TokenType.SEMI: 386>, <TokenType.SEQUENCE: 388>, <TokenType.SET: 390>, <TokenType.SETTINGS: 391>, <TokenType.SHOW: 392>, <TokenType.SOME: 394>, <TokenType.STORAGE_INTEGRATION: 399>, <TokenType.STRAIGHT_JOIN: 400>, <TokenType.STRUCT: 401>, <TokenType.TAG: 404>, <TokenType.TEMPORARY: 405>, <TokenType.TOP: 406>, <TokenType.TRUE: 408>, <TokenType.TRUNCATE: 409>, <TokenType.TRIGGER: 410>, <TokenType.TYPE: 411>, <TokenType.UNNEST: 414>, <TokenType.UNPIVOT: 415>, <TokenType.UPDATE: 416>, <TokenType.USE: 417>, <TokenType.VIEW: 421>, <TokenType.SEMANTIC_VIEW: 422>, <TokenType.VOLATILE: 423>, <TokenType.WINDOW: 427>, <TokenType.UNIQUE: 429>, <TokenType.SINK: 436>, <TokenType.SOURCE: 437>, <TokenType.ANALYZE: 438>, <TokenType.NAMESPACE: 439>, <TokenType.EXPORT: 440>}
AGG_FUNC_MAPPING = {'sumKahanSimpleState': ('sumKahan', 'SimpleState'), 'quantilesExactHighSimpleState': ('quantilesExactHigh', 'SimpleState'), 'anySimpleState': ('any', 'SimpleState'), 'uniqThetaSimpleState': ('uniqTheta', 'SimpleState'), 'groupBitXorSimpleState': ('groupBitXor', 'SimpleState'), 'theilsUSimpleState': ('theilsU', 'SimpleState'), 'boundingRatioSimpleState': ('boundingRatio', 'SimpleState'), 'histogramSimpleState': ('histogram', 'SimpleState'), 'kolmogorovSmirnovTestSimpleState': ('kolmogorovSmirnovTest', 'SimpleState'), 'groupBitmapXorSimpleState': ('groupBitmapXor', 'SimpleState'), 'quantileDeterministicSimpleState': ('quantileDeterministic', 'SimpleState'), 'varPopSimpleState': ('varPop', 'SimpleState'), 'first_valueSimpleState': ('first_value', 'SimpleState'), 'uniqHLL12SimpleState': ('uniqHLL12', 'SimpleState'), 'minMapSimpleState': ('minMap', 'SimpleState'), 'simpleLinearRegressionSimpleState': ('simpleLinearRegression', 'SimpleState'), 'quantilesInterpolatedWeightedSimpleState': ('quantilesInterpolatedWeighted', 'SimpleState'), 'maxSimpleState': ('max', 'SimpleState'), 'quantileTDigestWeightedSimpleState': ('quantileTDigestWeighted', 'SimpleState'), 'groupUniqArraySimpleState': ('groupUniqArray', 'SimpleState'), 'meanZTestSimpleState': ('meanZTest', 'SimpleState'), 'stochasticLogisticRegressionSimpleState': ('stochasticLogisticRegression', 'SimpleState'), 'cramersVBiasCorrectedSimpleState': ('cramersVBiasCorrected', 'SimpleState'), 'covarPopSimpleState': ('covarPop', 'SimpleState'), 'countSimpleState': ('count', 'SimpleState'), 'deltaSumSimpleState': ('deltaSum', 'SimpleState'), 'quantileInterpolatedWeightedSimpleState': ('quantileInterpolatedWeighted', 'SimpleState'), 'quantileGKSimpleState': ('quantileGK', 'SimpleState'), 'anyHeavySimpleState': ('anyHeavy', 'SimpleState'), 'uniqUpToSimpleState': ('uniqUpTo', 'SimpleState'), 'studentTTestSimpleState': ('studentTTest', 'SimpleState'), 'varSampSimpleState': ('varSamp', 'SimpleState'), 'groupBitmapOrSimpleState': ('groupBitmapOr', 'SimpleState'), 'argMinSimpleState': ('argMin', 'SimpleState'), 'contingencySimpleState': ('contingency', 'SimpleState'), 'quantilesExactLowSimpleState': ('quantilesExactLow', 'SimpleState'), 'covarSampSimpleState': ('covarSamp', 'SimpleState'), 'mannWhitneyUTestSimpleState': ('mannWhitneyUTest', 'SimpleState'), 'quantilesExactWeightedSimpleState': ('quantilesExactWeighted', 'SimpleState'), 'quantileTimingWeightedSimpleState': ('quantileTimingWeighted', 'SimpleState'), 'minSimpleState': ('min', 'SimpleState'), 'approx_top_sumSimpleState': ('approx_top_sum', 'SimpleState'), 'uniqSimpleState': ('uniq', 'SimpleState'), 'quantilesExactSimpleState': ('quantilesExact', 'SimpleState'), 'retentionSimpleState': ('retention', 'SimpleState'), 'uniqExactSimpleState': ('uniqExact', 'SimpleState'), 'stochasticLinearRegressionSimpleState': ('stochasticLinearRegression', 'SimpleState'), 'quantilesExactExclusiveSimpleState': ('quantilesExactExclusive', 'SimpleState'), 'sparkBarSimpleState': ('sparkBar', 'SimpleState'), 'skewPopSimpleState': ('skewPop', 'SimpleState'), 'groupArrayMovingAvgSimpleState': ('groupArrayMovingAvg', 'SimpleState'), 'medianSimpleState': ('median', 'SimpleState'), 'groupArrayLastSimpleState': ('groupArrayLast', 'SimpleState'), 'kurtPopSimpleState': ('kurtPop', 'SimpleState'), 'exponentialMovingAverageSimpleState': ('exponentialMovingAverage', 'SimpleState'), 'sequenceNextNodeSimpleState': ('sequenceNextNode', 'SimpleState'), 'quantileSimpleState': ('quantile', 'SimpleState'), 'groupArrayInsertAtSimpleState': ('groupArrayInsertAt', 'SimpleState'), 'sumSimpleState': ('sum', 'SimpleState'), 'quantileBFloat16SimpleState': ('quantileBFloat16', 'SimpleState'), 'rankCorrSimpleState': ('rankCorr', 'SimpleState'), 'quantileTDigestSimpleState': ('quantileTDigest', 'SimpleState'), 'maxIntersectionsPositionSimpleState': ('maxIntersectionsPosition', 'SimpleState'), 'sumMapSimpleState': ('sumMap', 'SimpleState'), 'kurtSampSimpleState': ('kurtSamp', 'SimpleState'), 'exponentialTimeDecayedAvgSimpleState': ('exponentialTimeDecayedAvg', 'SimpleState'), 'avgWeightedSimpleState': ('avgWeighted', 'SimpleState'), 'topKWeightedSimpleState': ('topKWeighted', 'SimpleState'), 'largestTriangleThreeBucketsSimpleState': ('largestTriangleThreeBuckets', 'SimpleState'), 'groupArraySampleSimpleState': ('groupArraySample', 'SimpleState'), 'quantileExactHighSimpleState': ('quantileExactHigh', 'SimpleState'), 'windowFunnelSimpleState': ('windowFunnel', 'SimpleState'), 'quantileExactWeightedSimpleState': ('quantileExactWeighted', 'SimpleState'), 'quantileExactLowSimpleState': ('quantileExactLow', 'SimpleState'), 'maxMapSimpleState': ('maxMap', 'SimpleState'), 'welchTTestSimpleState': ('welchTTest', 'SimpleState'), 'groupBitOrSimpleState': ('groupBitOr', 'SimpleState'), 'quantilesSimpleState': ('quantiles', 'SimpleState'), 'avgSimpleState': ('avg', 'SimpleState'), 'cramersVSimpleState': ('cramersV', 'SimpleState'), 'anyLastSimpleState': ('anyLast', 'SimpleState'), 'quantilesGKSimpleState': ('quantilesGK', 'SimpleState'), 'sequenceMatchSimpleState': ('sequenceMatch', 'SimpleState'), 'quantilesTimingWeightedSimpleState': ('quantilesTimingWeighted', 'SimpleState'), 'quantilesDeterministicSimpleState': ('quantilesDeterministic', 'SimpleState'), 'sumCountSimpleState': ('sumCount', 'SimpleState'), 'maxIntersectionsSimpleState': ('maxIntersections', 'SimpleState'), 'stddevSampSimpleState': ('stddevSamp', 'SimpleState'), 'groupBitmapAndSimpleState': ('groupBitmapAnd', 'SimpleState'), 'groupArraySimpleState': ('groupArray', 'SimpleState'), 'uniqCombinedSimpleState': ('uniqCombined', 'SimpleState'), 'skewSampSimpleState': ('skewSamp', 'SimpleState'), 'groupBitmapSimpleState': ('groupBitmap', 'SimpleState'), 'quantilesBFloat16SimpleState': ('quantilesBFloat16', 'SimpleState'), 'quantilesTDigestSimpleState': ('quantilesTDigest', 'SimpleState'), 'sequenceCountSimpleState': ('sequenceCount', 'SimpleState'), 'uniqCombined64SimpleState': ('uniqCombined64', 'SimpleState'), 'entropySimpleState': ('entropy', 'SimpleState'), 'quantilesTDigestWeightedSimpleState': ('quantilesTDigestWeighted', 'SimpleState'), 'quantileExactSimpleState': ('quantileExact', 'SimpleState'), 'categoricalInformationValueSimpleState': ('categoricalInformationValue', 'SimpleState'), 'topKSimpleState': ('topK', 'SimpleState'), 'groupBitAndSimpleState': ('groupBitAnd', 'SimpleState'), 'stddevPopSimpleState': ('stddevPop', 'SimpleState'), 'quantileBFloat16WeightedSimpleState': ('quantileBFloat16Weighted', 'SimpleState'), 'quantileTimingSimpleState': ('quantileTiming', 'SimpleState'), 'groupConcatSimpleState': ('groupConcat', 'SimpleState'), 'corrSimpleState': ('corr', 'SimpleState'), 'sumWithOverflowSimpleState': ('sumWithOverflow', 'SimpleState'), 'last_valueSimpleState': ('last_value', 'SimpleState'), 'argMaxSimpleState': ('argMax', 'SimpleState'), 'quantilesTimingSimpleState': ('quantilesTiming', 'SimpleState'), 'groupArrayMovingSumSimpleState': ('groupArrayMovingSum', 'SimpleState'), 'deltaSumTimestampSimpleState': ('deltaSumTimestamp', 'SimpleState'), 'quantilesBFloat16WeightedSimpleState': ('quantilesBFloat16Weighted', 'SimpleState'), 'intervalLengthSumSimpleState': ('intervalLengthSum', 'SimpleState'), 'sumKahanMergeState': ('sumKahan', 'MergeState'), 'quantilesExactHighMergeState': ('quantilesExactHigh', 'MergeState'), 'anyMergeState': ('any', 'MergeState'), 'uniqThetaMergeState': ('uniqTheta', 'MergeState'), 'groupBitXorMergeState': ('groupBitXor', 'MergeState'), 'theilsUMergeState': ('theilsU', 'MergeState'), 'boundingRatioMergeState': ('boundingRatio', 'MergeState'), 'histogramMergeState': ('histogram', 'MergeState'), 'kolmogorovSmirnovTestMergeState': ('kolmogorovSmirnovTest', 'MergeState'), 'groupBitmapXorMergeState': ('groupBitmapXor', 'MergeState'), 'quantileDeterministicMergeState': ('quantileDeterministic', 'MergeState'), 'varPopMergeState': ('varPop', 'MergeState'), 'first_valueMergeState': ('first_value', 'MergeState'), 'uniqHLL12MergeState': ('uniqHLL12', 'MergeState'), 'minMapMergeState': ('minMap', 'MergeState'), 'simpleLinearRegressionMergeState': ('simpleLinearRegression', 'MergeState'), 'quantilesInterpolatedWeightedMergeState': ('quantilesInterpolatedWeighted', 'MergeState'), 'maxMergeState': ('max', 'MergeState'), 'quantileTDigestWeightedMergeState': ('quantileTDigestWeighted', 'MergeState'), 'groupUniqArrayMergeState': ('groupUniqArray', 'MergeState'), 'meanZTestMergeState': ('meanZTest', 'MergeState'), 'stochasticLogisticRegressionMergeState': ('stochasticLogisticRegression', 'MergeState'), 'cramersVBiasCorrectedMergeState': ('cramersVBiasCorrected', 'MergeState'), 'covarPopMergeState': ('covarPop', 'MergeState'), 'countMergeState': ('count', 'MergeState'), 'deltaSumMergeState': ('deltaSum', 'MergeState'), 'quantileInterpolatedWeightedMergeState': ('quantileInterpolatedWeighted', 'MergeState'), 'quantileGKMergeState': ('quantileGK', 'MergeState'), 'anyHeavyMergeState': ('anyHeavy', 'MergeState'), 'uniqUpToMergeState': ('uniqUpTo', 'MergeState'), 'studentTTestMergeState': ('studentTTest', 'MergeState'), 'varSampMergeState': ('varSamp', 'MergeState'), 'groupBitmapOrMergeState': ('groupBitmapOr', 'MergeState'), 'argMinMergeState': ('argMin', 'MergeState'), 'contingencyMergeState': ('contingency', 'MergeState'), 'quantilesExactLowMergeState': ('quantilesExactLow', 'MergeState'), 'covarSampMergeState': ('covarSamp', 'MergeState'), 'mannWhitneyUTestMergeState': ('mannWhitneyUTest', 'MergeState'), 'quantilesExactWeightedMergeState': ('quantilesExactWeighted', 'MergeState'), 'quantileTimingWeightedMergeState': ('quantileTimingWeighted', 'MergeState'), 'minMergeState': ('min', 'MergeState'), 'approx_top_sumMergeState': ('approx_top_sum', 'MergeState'), 'uniqMergeState': ('uniq', 'MergeState'), 'quantilesExactMergeState': ('quantilesExact', 'MergeState'), 'retentionMergeState': ('retention', 'MergeState'), 'uniqExactMergeState': ('uniqExact', 'MergeState'), 'stochasticLinearRegressionMergeState': ('stochasticLinearRegression', 'MergeState'), 'quantilesExactExclusiveMergeState': ('quantilesExactExclusive', 'MergeState'), 'sparkBarMergeState': ('sparkBar', 'MergeState'), 'skewPopMergeState': ('skewPop', 'MergeState'), 'groupArrayMovingAvgMergeState': ('groupArrayMovingAvg', 'MergeState'), 'medianMergeState': ('median', 'MergeState'), 'groupArrayLastMergeState': ('groupArrayLast', 'MergeState'), 'kurtPopMergeState': ('kurtPop', 'MergeState'), 'exponentialMovingAverageMergeState': ('exponentialMovingAverage', 'MergeState'), 'sequenceNextNodeMergeState': ('sequenceNextNode', 'MergeState'), 'quantileMergeState': ('quantile', 'MergeState'), 'groupArrayInsertAtMergeState': ('groupArrayInsertAt', 'MergeState'), 'sumMergeState': ('sum', 'MergeState'), 'quantileBFloat16MergeState': ('quantileBFloat16', 'MergeState'), 'rankCorrMergeState': ('rankCorr', 'MergeState'), 'quantileTDigestMergeState': ('quantileTDigest', 'MergeState'), 'maxIntersectionsPositionMergeState': ('maxIntersectionsPosition', 'MergeState'), 'sumMapMergeState': ('sumMap', 'MergeState'), 'kurtSampMergeState': ('kurtSamp', 'MergeState'), 'exponentialTimeDecayedAvgMergeState': ('exponentialTimeDecayedAvg', 'MergeState'), 'avgWeightedMergeState': ('avgWeighted', 'MergeState'), 'topKWeightedMergeState': ('topKWeighted', 'MergeState'), 'largestTriangleThreeBucketsMergeState': ('largestTriangleThreeBuckets', 'MergeState'), 'groupArraySampleMergeState': ('groupArraySample', 'MergeState'), 'quantileExactHighMergeState': ('quantileExactHigh', 'MergeState'), 'windowFunnelMergeState': ('windowFunnel', 'MergeState'), 'quantileExactWeightedMergeState': ('quantileExactWeighted', 'MergeState'), 'quantileExactLowMergeState': ('quantileExactLow', 'MergeState'), 'maxMapMergeState': ('maxMap', 'MergeState'), 'welchTTestMergeState': ('welchTTest', 'MergeState'), 'groupBitOrMergeState': ('groupBitOr', 'MergeState'), 'quantilesMergeState': ('quantiles', 'MergeState'), 'avgMergeState': ('avg', 'MergeState'), 'cramersVMergeState': ('cramersV', 'MergeState'), 'anyLastMergeState': ('anyLast', 'MergeState'), 'quantilesGKMergeState': ('quantilesGK', 'MergeState'), 'sequenceMatchMergeState': ('sequenceMatch', 'MergeState'), 'quantilesTimingWeightedMergeState': ('quantilesTimingWeighted', 'MergeState'), 'quantilesDeterministicMergeState': ('quantilesDeterministic', 'MergeState'), 'sumCountMergeState': ('sumCount', 'MergeState'), 'maxIntersectionsMergeState': ('maxIntersections', 'MergeState'), 'stddevSampMergeState': ('stddevSamp', 'MergeState'), 'groupBitmapAndMergeState': ('groupBitmapAnd', 'MergeState'), 'groupArrayMergeState': ('groupArray', 'MergeState'), 'uniqCombinedMergeState': ('uniqCombined', 'MergeState'), 'skewSampMergeState': ('skewSamp', 'MergeState'), 'groupBitmapMergeState': ('groupBitmap', 'MergeState'), 'quantilesBFloat16MergeState': ('quantilesBFloat16', 'MergeState'), 'quantilesTDigestMergeState': ('quantilesTDigest', 'MergeState'), 'sequenceCountMergeState': ('sequenceCount', 'MergeState'), 'uniqCombined64MergeState': ('uniqCombined64', 'MergeState'), 'entropyMergeState': ('entropy', 'MergeState'), 'quantilesTDigestWeightedMergeState': ('quantilesTDigestWeighted', 'MergeState'), 'quantileExactMergeState': ('quantileExact', 'MergeState'), 'categoricalInformationValueMergeState': ('categoricalInformationValue', 'MergeState'), 'topKMergeState': ('topK', 'MergeState'), 'groupBitAndMergeState': ('groupBitAnd', 'MergeState'), 'stddevPopMergeState': ('stddevPop', 'MergeState'), 'quantileBFloat16WeightedMergeState': ('quantileBFloat16Weighted', 'MergeState'), 'quantileTimingMergeState': ('quantileTiming', 'MergeState'), 'groupConcatMergeState': ('groupConcat', 'MergeState'), 'corrMergeState': ('corr', 'MergeState'), 'sumWithOverflowMergeState': ('sumWithOverflow', 'MergeState'), 'last_valueMergeState': ('last_value', 'MergeState'), 'argMaxMergeState': ('argMax', 'MergeState'), 'quantilesTimingMergeState': ('quantilesTiming', 'MergeState'), 'groupArrayMovingSumMergeState': ('groupArrayMovingSum', 'MergeState'), 'deltaSumTimestampMergeState': ('deltaSumTimestamp', 'MergeState'), 'quantilesBFloat16WeightedMergeState': ('quantilesBFloat16Weighted', 'MergeState'), 'intervalLengthSumMergeState': ('intervalLengthSum', 'MergeState'), 'sumKahanOrDefault': ('sumKahan', 'OrDefault'), 'quantilesExactHighOrDefault': ('quantilesExactHigh', 'OrDefault'), 'anyOrDefault': ('any', 'OrDefault'), 'uniqThetaOrDefault': ('uniqTheta', 'OrDefault'), 'groupBitXorOrDefault': ('groupBitXor', 'OrDefault'), 'theilsUOrDefault': ('theilsU', 'OrDefault'), 'boundingRatioOrDefault': ('boundingRatio', 'OrDefault'), 'histogramOrDefault': ('histogram', 'OrDefault'), 'kolmogorovSmirnovTestOrDefault': ('kolmogorovSmirnovTest', 'OrDefault'), 'groupBitmapXorOrDefault': ('groupBitmapXor', 'OrDefault'), 'quantileDeterministicOrDefault': ('quantileDeterministic', 'OrDefault'), 'varPopOrDefault': ('varPop', 'OrDefault'), 'first_valueOrDefault': ('first_value', 'OrDefault'), 'uniqHLL12OrDefault': ('uniqHLL12', 'OrDefault'), 'minMapOrDefault': ('minMap', 'OrDefault'), 'simpleLinearRegressionOrDefault': ('simpleLinearRegression', 'OrDefault'), 'quantilesInterpolatedWeightedOrDefault': ('quantilesInterpolatedWeighted', 'OrDefault'), 'maxOrDefault': ('max', 'OrDefault'), 'quantileTDigestWeightedOrDefault': ('quantileTDigestWeighted', 'OrDefault'), 'groupUniqArrayOrDefault': ('groupUniqArray', 'OrDefault'), 'meanZTestOrDefault': ('meanZTest', 'OrDefault'), 'stochasticLogisticRegressionOrDefault': ('stochasticLogisticRegression', 'OrDefault'), 'cramersVBiasCorrectedOrDefault': ('cramersVBiasCorrected', 'OrDefault'), 'covarPopOrDefault': ('covarPop', 'OrDefault'), 'countOrDefault': ('count', 'OrDefault'), 'deltaSumOrDefault': ('deltaSum', 'OrDefault'), 'quantileInterpolatedWeightedOrDefault': ('quantileInterpolatedWeighted', 'OrDefault'), 'quantileGKOrDefault': ('quantileGK', 'OrDefault'), 'anyHeavyOrDefault': ('anyHeavy', 'OrDefault'), 'uniqUpToOrDefault': ('uniqUpTo', 'OrDefault'), 'studentTTestOrDefault': ('studentTTest', 'OrDefault'), 'varSampOrDefault': ('varSamp', 'OrDefault'), 'groupBitmapOrOrDefault': ('groupBitmapOr', 'OrDefault'), 'argMinOrDefault': ('argMin', 'OrDefault'), 'contingencyOrDefault': ('contingency', 'OrDefault'), 'quantilesExactLowOrDefault': ('quantilesExactLow', 'OrDefault'), 'covarSampOrDefault': ('covarSamp', 'OrDefault'), 'mannWhitneyUTestOrDefault': ('mannWhitneyUTest', 'OrDefault'), 'quantilesExactWeightedOrDefault': ('quantilesExactWeighted', 'OrDefault'), 'quantileTimingWeightedOrDefault': ('quantileTimingWeighted', 'OrDefault'), 'minOrDefault': ('min', 'OrDefault'), 'approx_top_sumOrDefault': ('approx_top_sum', 'OrDefault'), 'uniqOrDefault': ('uniq', 'OrDefault'), 'quantilesExactOrDefault': ('quantilesExact', 'OrDefault'), 'retentionOrDefault': ('retention', 'OrDefault'), 'uniqExactOrDefault': ('uniqExact', 'OrDefault'), 'stochasticLinearRegressionOrDefault': ('stochasticLinearRegression', 'OrDefault'), 'quantilesExactExclusiveOrDefault': ('quantilesExactExclusive', 'OrDefault'), 'sparkBarOrDefault': ('sparkBar', 'OrDefault'), 'skewPopOrDefault': ('skewPop', 'OrDefault'), 'groupArrayMovingAvgOrDefault': ('groupArrayMovingAvg', 'OrDefault'), 'medianOrDefault': ('median', 'OrDefault'), 'groupArrayLastOrDefault': ('groupArrayLast', 'OrDefault'), 'kurtPopOrDefault': ('kurtPop', 'OrDefault'), 'exponentialMovingAverageOrDefault': ('exponentialMovingAverage', 'OrDefault'), 'sequenceNextNodeOrDefault': ('sequenceNextNode', 'OrDefault'), 'quantileOrDefault': ('quantile', 'OrDefault'), 'groupArrayInsertAtOrDefault': ('groupArrayInsertAt', 'OrDefault'), 'sumOrDefault': ('sum', 'OrDefault'), 'quantileBFloat16OrDefault': ('quantileBFloat16', 'OrDefault'), 'rankCorrOrDefault': ('rankCorr', 'OrDefault'), 'quantileTDigestOrDefault': ('quantileTDigest', 'OrDefault'), 'maxIntersectionsPositionOrDefault': ('maxIntersectionsPosition', 'OrDefault'), 'sumMapOrDefault': ('sumMap', 'OrDefault'), 'kurtSampOrDefault': ('kurtSamp', 'OrDefault'), 'exponentialTimeDecayedAvgOrDefault': ('exponentialTimeDecayedAvg', 'OrDefault'), 'avgWeightedOrDefault': ('avgWeighted', 'OrDefault'), 'topKWeightedOrDefault': ('topKWeighted', 'OrDefault'), 'largestTriangleThreeBucketsOrDefault': ('largestTriangleThreeBuckets', 'OrDefault'), 'groupArraySampleOrDefault': ('groupArraySample', 'OrDefault'), 'quantileExactHighOrDefault': ('quantileExactHigh', 'OrDefault'), 'windowFunnelOrDefault': ('windowFunnel', 'OrDefault'), 'quantileExactWeightedOrDefault': ('quantileExactWeighted', 'OrDefault'), 'quantileExactLowOrDefault': ('quantileExactLow', 'OrDefault'), 'maxMapOrDefault': ('maxMap', 'OrDefault'), 'welchTTestOrDefault': ('welchTTest', 'OrDefault'), 'groupBitOrOrDefault': ('groupBitOr', 'OrDefault'), 'quantilesOrDefault': ('quantiles', 'OrDefault'), 'avgOrDefault': ('avg', 'OrDefault'), 'cramersVOrDefault': ('cramersV', 'OrDefault'), 'anyLastOrDefault': ('anyLast', 'OrDefault'), 'quantilesGKOrDefault': ('quantilesGK', 'OrDefault'), 'sequenceMatchOrDefault': ('sequenceMatch', 'OrDefault'), 'quantilesTimingWeightedOrDefault': ('quantilesTimingWeighted', 'OrDefault'), 'quantilesDeterministicOrDefault': ('quantilesDeterministic', 'OrDefault'), 'sumCountOrDefault': ('sumCount', 'OrDefault'), 'maxIntersectionsOrDefault': ('maxIntersections', 'OrDefault'), 'stddevSampOrDefault': ('stddevSamp', 'OrDefault'), 'groupBitmapAndOrDefault': ('groupBitmapAnd', 'OrDefault'), 'groupArrayOrDefault': ('groupArray', 'OrDefault'), 'uniqCombinedOrDefault': ('uniqCombined', 'OrDefault'), 'skewSampOrDefault': ('skewSamp', 'OrDefault'), 'groupBitmapOrDefault': ('groupBitmap', 'OrDefault'), 'quantilesBFloat16OrDefault': ('quantilesBFloat16', 'OrDefault'), 'quantilesTDigestOrDefault': ('quantilesTDigest', 'OrDefault'), 'sequenceCountOrDefault': ('sequenceCount', 'OrDefault'), 'uniqCombined64OrDefault': ('uniqCombined64', 'OrDefault'), 'entropyOrDefault': ('entropy', 'OrDefault'), 'quantilesTDigestWeightedOrDefault': ('quantilesTDigestWeighted', 'OrDefault'), 'quantileExactOrDefault': ('quantileExact', 'OrDefault'), 'categoricalInformationValueOrDefault': ('categoricalInformationValue', 'OrDefault'), 'topKOrDefault': ('topK', 'OrDefault'), 'groupBitAndOrDefault': ('groupBitAnd', 'OrDefault'), 'stddevPopOrDefault': ('stddevPop', 'OrDefault'), 'quantileBFloat16WeightedOrDefault': ('quantileBFloat16Weighted', 'OrDefault'), 'quantileTimingOrDefault': ('quantileTiming', 'OrDefault'), 'groupConcatOrDefault': ('groupConcat', 'OrDefault'), 'corrOrDefault': ('corr', 'OrDefault'), 'sumWithOverflowOrDefault': ('sumWithOverflow', 'OrDefault'), 'last_valueOrDefault': ('last_value', 'OrDefault'), 'argMaxOrDefault': ('argMax', 'OrDefault'), 'quantilesTimingOrDefault': ('quantilesTiming', 'OrDefault'), 'groupArrayMovingSumOrDefault': ('groupArrayMovingSum', 'OrDefault'), 'deltaSumTimestampOrDefault': ('deltaSumTimestamp', 'OrDefault'), 'quantilesBFloat16WeightedOrDefault': ('quantilesBFloat16Weighted', 'OrDefault'), 'intervalLengthSumOrDefault': ('intervalLengthSum', 'OrDefault'), 'sumKahanDistinct': ('sumKahan', 'Distinct'), 'quantilesExactHighDistinct': ('quantilesExactHigh', 'Distinct'), 'anyDistinct': ('any', 'Distinct'), 'uniqThetaDistinct': ('uniqTheta', 'Distinct'), 'groupBitXorDistinct': ('groupBitXor', 'Distinct'), 'theilsUDistinct': ('theilsU', 'Distinct'), 'boundingRatioDistinct': ('boundingRatio', 'Distinct'), 'histogramDistinct': ('histogram', 'Distinct'), 'kolmogorovSmirnovTestDistinct': ('kolmogorovSmirnovTest', 'Distinct'), 'groupBitmapXorDistinct': ('groupBitmapXor', 'Distinct'), 'quantileDeterministicDistinct': ('quantileDeterministic', 'Distinct'), 'varPopDistinct': ('varPop', 'Distinct'), 'first_valueDistinct': ('first_value', 'Distinct'), 'uniqHLL12Distinct': ('uniqHLL12', 'Distinct'), 'minMapDistinct': ('minMap', 'Distinct'), 'simpleLinearRegressionDistinct': ('simpleLinearRegression', 'Distinct'), 'quantilesInterpolatedWeightedDistinct': ('quantilesInterpolatedWeighted', 'Distinct'), 'maxDistinct': ('max', 'Distinct'), 'quantileTDigestWeightedDistinct': ('quantileTDigestWeighted', 'Distinct'), 'groupUniqArrayDistinct': ('groupUniqArray', 'Distinct'), 'meanZTestDistinct': ('meanZTest', 'Distinct'), 'stochasticLogisticRegressionDistinct': ('stochasticLogisticRegression', 'Distinct'), 'cramersVBiasCorrectedDistinct': ('cramersVBiasCorrected', 'Distinct'), 'covarPopDistinct': ('covarPop', 'Distinct'), 'countDistinct': ('count', 'Distinct'), 'deltaSumDistinct': ('deltaSum', 'Distinct'), 'quantileInterpolatedWeightedDistinct': ('quantileInterpolatedWeighted', 'Distinct'), 'quantileGKDistinct': ('quantileGK', 'Distinct'), 'anyHeavyDistinct': ('anyHeavy', 'Distinct'), 'uniqUpToDistinct': ('uniqUpTo', 'Distinct'), 'studentTTestDistinct': ('studentTTest', 'Distinct'), 'varSampDistinct': ('varSamp', 'Distinct'), 'groupBitmapOrDistinct': ('groupBitmapOr', 'Distinct'), 'argMinDistinct': ('argMin', 'Distinct'), 'contingencyDistinct': ('contingency', 'Distinct'), 'quantilesExactLowDistinct': ('quantilesExactLow', 'Distinct'), 'covarSampDistinct': ('covarSamp', 'Distinct'), 'mannWhitneyUTestDistinct': ('mannWhitneyUTest', 'Distinct'), 'quantilesExactWeightedDistinct': ('quantilesExactWeighted', 'Distinct'), 'quantileTimingWeightedDistinct': ('quantileTimingWeighted', 'Distinct'), 'minDistinct': ('min', 'Distinct'), 'approx_top_sumDistinct': ('approx_top_sum', 'Distinct'), 'uniqDistinct': ('uniq', 'Distinct'), 'quantilesExactDistinct': ('quantilesExact', 'Distinct'), 'retentionDistinct': ('retention', 'Distinct'), 'uniqExactDistinct': ('uniqExact', 'Distinct'), 'stochasticLinearRegressionDistinct': ('stochasticLinearRegression', 'Distinct'), 'quantilesExactExclusiveDistinct': ('quantilesExactExclusive', 'Distinct'), 'sparkBarDistinct': ('sparkBar', 'Distinct'), 'skewPopDistinct': ('skewPop', 'Distinct'), 'groupArrayMovingAvgDistinct': ('groupArrayMovingAvg', 'Distinct'), 'medianDistinct': ('median', 'Distinct'), 'groupArrayLastDistinct': ('groupArrayLast', 'Distinct'), 'kurtPopDistinct': ('kurtPop', 'Distinct'), 'exponentialMovingAverageDistinct': ('exponentialMovingAverage', 'Distinct'), 'sequenceNextNodeDistinct': ('sequenceNextNode', 'Distinct'), 'quantileDistinct': ('quantile', 'Distinct'), 'groupArrayInsertAtDistinct': ('groupArrayInsertAt', 'Distinct'), 'sumDistinct': ('sum', 'Distinct'), 'quantileBFloat16Distinct': ('quantileBFloat16', 'Distinct'), 'rankCorrDistinct': ('rankCorr', 'Distinct'), 'quantileTDigestDistinct': ('quantileTDigest', 'Distinct'), 'maxIntersectionsPositionDistinct': ('maxIntersectionsPosition', 'Distinct'), 'sumMapDistinct': ('sumMap', 'Distinct'), 'kurtSampDistinct': ('kurtSamp', 'Distinct'), 'exponentialTimeDecayedAvgDistinct': ('exponentialTimeDecayedAvg', 'Distinct'), 'avgWeightedDistinct': ('avgWeighted', 'Distinct'), 'topKWeightedDistinct': ('topKWeighted', 'Distinct'), 'largestTriangleThreeBucketsDistinct': ('largestTriangleThreeBuckets', 'Distinct'), 'groupArraySampleDistinct': ('groupArraySample', 'Distinct'), 'quantileExactHighDistinct': ('quantileExactHigh', 'Distinct'), 'windowFunnelDistinct': ('windowFunnel', 'Distinct'), 'quantileExactWeightedDistinct': ('quantileExactWeighted', 'Distinct'), 'quantileExactLowDistinct': ('quantileExactLow', 'Distinct'), 'maxMapDistinct': ('maxMap', 'Distinct'), 'welchTTestDistinct': ('welchTTest', 'Distinct'), 'groupBitOrDistinct': ('groupBitOr', 'Distinct'), 'quantilesDistinct': ('quantiles', 'Distinct'), 'avgDistinct': ('avg', 'Distinct'), 'cramersVDistinct': ('cramersV', 'Distinct'), 'anyLastDistinct': ('anyLast', 'Distinct'), 'quantilesGKDistinct': ('quantilesGK', 'Distinct'), 'sequenceMatchDistinct': ('sequenceMatch', 'Distinct'), 'quantilesTimingWeightedDistinct': ('quantilesTimingWeighted', 'Distinct'), 'quantilesDeterministicDistinct': ('quantilesDeterministic', 'Distinct'), 'sumCountDistinct': ('sumCount', 'Distinct'), 'maxIntersectionsDistinct': ('maxIntersections', 'Distinct'), 'stddevSampDistinct': ('stddevSamp', 'Distinct'), 'groupBitmapAndDistinct': ('groupBitmapAnd', 'Distinct'), 'groupArrayDistinct': ('groupArray', 'Distinct'), 'uniqCombinedDistinct': ('uniqCombined', 'Distinct'), 'skewSampDistinct': ('skewSamp', 'Distinct'), 'groupBitmapDistinct': ('groupBitmap', 'Distinct'), 'quantilesBFloat16Distinct': ('quantilesBFloat16', 'Distinct'), 'quantilesTDigestDistinct': ('quantilesTDigest', 'Distinct'), 'sequenceCountDistinct': ('sequenceCount', 'Distinct'), 'uniqCombined64Distinct': ('uniqCombined64', 'Distinct'), 'entropyDistinct': ('entropy', 'Distinct'), 'quantilesTDigestWeightedDistinct': ('quantilesTDigestWeighted', 'Distinct'), 'quantileExactDistinct': ('quantileExact', 'Distinct'), 'categoricalInformationValueDistinct': ('categoricalInformationValue', 'Distinct'), 'topKDistinct': ('topK', 'Distinct'), 'groupBitAndDistinct': ('groupBitAnd', 'Distinct'), 'stddevPopDistinct': ('stddevPop', 'Distinct'), 'quantileBFloat16WeightedDistinct': ('quantileBFloat16Weighted', 'Distinct'), 'quantileTimingDistinct': ('quantileTiming', 'Distinct'), 'groupConcatDistinct': ('groupConcat', 'Distinct'), 'corrDistinct': ('corr', 'Distinct'), 'sumWithOverflowDistinct': ('sumWithOverflow', 'Distinct'), 'last_valueDistinct': ('last_value', 'Distinct'), 'argMaxDistinct': ('argMax', 'Distinct'), 'quantilesTimingDistinct': ('quantilesTiming', 'Distinct'), 'groupArrayMovingSumDistinct': ('groupArrayMovingSum', 'Distinct'), 'deltaSumTimestampDistinct': ('deltaSumTimestamp', 'Distinct'), 'quantilesBFloat16WeightedDistinct': ('quantilesBFloat16Weighted', 'Distinct'), 'intervalLengthSumDistinct': ('intervalLengthSum', 'Distinct'), 'sumKahanResample': ('sumKahan', 'Resample'), 'quantilesExactHighResample': ('quantilesExactHigh', 'Resample'), 'anyResample': ('any', 'Resample'), 'uniqThetaResample': ('uniqTheta', 'Resample'), 'groupBitXorResample': ('groupBitXor', 'Resample'), 'theilsUResample': ('theilsU', 'Resample'), 'boundingRatioResample': ('boundingRatio', 'Resample'), 'histogramResample': ('histogram', 'Resample'), 'kolmogorovSmirnovTestResample': ('kolmogorovSmirnovTest', 'Resample'), 'groupBitmapXorResample': ('groupBitmapXor', 'Resample'), 'quantileDeterministicResample': ('quantileDeterministic', 'Resample'), 'varPopResample': ('varPop', 'Resample'), 'first_valueResample': ('first_value', 'Resample'), 'uniqHLL12Resample': ('uniqHLL12', 'Resample'), 'minMapResample': ('minMap', 'Resample'), 'simpleLinearRegressionResample': ('simpleLinearRegression', 'Resample'), 'quantilesInterpolatedWeightedResample': ('quantilesInterpolatedWeighted', 'Resample'), 'maxResample': ('max', 'Resample'), 'quantileTDigestWeightedResample': ('quantileTDigestWeighted', 'Resample'), 'groupUniqArrayResample': ('groupUniqArray', 'Resample'), 'meanZTestResample': ('meanZTest', 'Resample'), 'stochasticLogisticRegressionResample': ('stochasticLogisticRegression', 'Resample'), 'cramersVBiasCorrectedResample': ('cramersVBiasCorrected', 'Resample'), 'covarPopResample': ('covarPop', 'Resample'), 'countResample': ('count', 'Resample'), 'deltaSumResample': ('deltaSum', 'Resample'), 'quantileInterpolatedWeightedResample': ('quantileInterpolatedWeighted', 'Resample'), 'quantileGKResample': ('quantileGK', 'Resample'), 'anyHeavyResample': ('anyHeavy', 'Resample'), 'uniqUpToResample': ('uniqUpTo', 'Resample'), 'studentTTestResample': ('studentTTest', 'Resample'), 'varSampResample': ('varSamp', 'Resample'), 'groupBitmapOrResample': ('groupBitmapOr', 'Resample'), 'argMinResample': ('argMin', 'Resample'), 'contingencyResample': ('contingency', 'Resample'), 'quantilesExactLowResample': ('quantilesExactLow', 'Resample'), 'covarSampResample': ('covarSamp', 'Resample'), 'mannWhitneyUTestResample': ('mannWhitneyUTest', 'Resample'), 'quantilesExactWeightedResample': ('quantilesExactWeighted', 'Resample'), 'quantileTimingWeightedResample': ('quantileTimingWeighted', 'Resample'), 'minResample': ('min', 'Resample'), 'approx_top_sumResample': ('approx_top_sum', 'Resample'), 'uniqResample': ('uniq', 'Resample'), 'quantilesExactResample': ('quantilesExact', 'Resample'), 'retentionResample': ('retention', 'Resample'), 'uniqExactResample': ('uniqExact', 'Resample'), 'stochasticLinearRegressionResample': ('stochasticLinearRegression', 'Resample'), 'quantilesExactExclusiveResample': ('quantilesExactExclusive', 'Resample'), 'sparkBarResample': ('sparkBar', 'Resample'), 'skewPopResample': ('skewPop', 'Resample'), 'groupArrayMovingAvgResample': ('groupArrayMovingAvg', 'Resample'), 'medianResample': ('median', 'Resample'), 'groupArrayLastResample': ('groupArrayLast', 'Resample'), 'kurtPopResample': ('kurtPop', 'Resample'), 'exponentialMovingAverageResample': ('exponentialMovingAverage', 'Resample'), 'sequenceNextNodeResample': ('sequenceNextNode', 'Resample'), 'quantileResample': ('quantile', 'Resample'), 'groupArrayInsertAtResample': ('groupArrayInsertAt', 'Resample'), 'sumResample': ('sum', 'Resample'), 'quantileBFloat16Resample': ('quantileBFloat16', 'Resample'), 'rankCorrResample': ('rankCorr', 'Resample'), 'quantileTDigestResample': ('quantileTDigest', 'Resample'), 'maxIntersectionsPositionResample': ('maxIntersectionsPosition', 'Resample'), 'sumMapResample': ('sumMap', 'Resample'), 'kurtSampResample': ('kurtSamp', 'Resample'), 'exponentialTimeDecayedAvgResample': ('exponentialTimeDecayedAvg', 'Resample'), 'avgWeightedResample': ('avgWeighted', 'Resample'), 'topKWeightedResample': ('topKWeighted', 'Resample'), 'largestTriangleThreeBucketsResample': ('largestTriangleThreeBuckets', 'Resample'), 'groupArraySampleResample': ('groupArraySample', 'Resample'), 'quantileExactHighResample': ('quantileExactHigh', 'Resample'), 'windowFunnelResample': ('windowFunnel', 'Resample'), 'quantileExactWeightedResample': ('quantileExactWeighted', 'Resample'), 'quantileExactLowResample': ('quantileExactLow', 'Resample'), 'maxMapResample': ('maxMap', 'Resample'), 'welchTTestResample': ('welchTTest', 'Resample'), 'groupBitOrResample': ('groupBitOr', 'Resample'), 'quantilesResample': ('quantiles', 'Resample'), 'avgResample': ('avg', 'Resample'), 'cramersVResample': ('cramersV', 'Resample'), 'anyLastResample': ('anyLast', 'Resample'), 'quantilesGKResample': ('quantilesGK', 'Resample'), 'sequenceMatchResample': ('sequenceMatch', 'Resample'), 'quantilesTimingWeightedResample': ('quantilesTimingWeighted', 'Resample'), 'quantilesDeterministicResample': ('quantilesDeterministic', 'Resample'), 'sumCountResample': ('sumCount', 'Resample'), 'maxIntersectionsResample': ('maxIntersections', 'Resample'), 'stddevSampResample': ('stddevSamp', 'Resample'), 'groupBitmapAndResample': ('groupBitmapAnd', 'Resample'), 'groupArrayResample': ('groupArray', 'Resample'), 'uniqCombinedResample': ('uniqCombined', 'Resample'), 'skewSampResample': ('skewSamp', 'Resample'), 'groupBitmapResample': ('groupBitmap', 'Resample'), 'quantilesBFloat16Resample': ('quantilesBFloat16', 'Resample'), 'quantilesTDigestResample': ('quantilesTDigest', 'Resample'), 'sequenceCountResample': ('sequenceCount', 'Resample'), 'uniqCombined64Resample': ('uniqCombined64', 'Resample'), 'entropyResample': ('entropy', 'Resample'), 'quantilesTDigestWeightedResample': ('quantilesTDigestWeighted', 'Resample'), 'quantileExactResample': ('quantileExact', 'Resample'), 'categoricalInformationValueResample': ('categoricalInformationValue', 'Resample'), 'topKResample': ('topK', 'Resample'), 'groupBitAndResample': ('groupBitAnd', 'Resample'), 'stddevPopResample': ('stddevPop', 'Resample'), 'quantileBFloat16WeightedResample': ('quantileBFloat16Weighted', 'Resample'), 'quantileTimingResample': ('quantileTiming', 'Resample'), 'groupConcatResample': ('groupConcat', 'Resample'), 'corrResample': ('corr', 'Resample'), 'sumWithOverflowResample': ('sumWithOverflow', 'Resample'), 'last_valueResample': ('last_value', 'Resample'), 'argMaxResample': ('argMax', 'Resample'), 'quantilesTimingResample': ('quantilesTiming', 'Resample'), 'groupArrayMovingSumResample': ('groupArrayMovingSum', 'Resample'), 'deltaSumTimestampResample': ('deltaSumTimestamp', 'Resample'), 'quantilesBFloat16WeightedResample': ('quantilesBFloat16Weighted', 'Resample'), 'intervalLengthSumResample': ('intervalLengthSum', 'Resample'), 'sumKahanArrayIf': ('sumKahan', 'ArrayIf'), 'quantilesExactHighArrayIf': ('quantilesExactHigh', 'ArrayIf'), 'anyArrayIf': ('any', 'ArrayIf'), 'uniqThetaArrayIf': ('uniqTheta', 'ArrayIf'), 'groupBitXorArrayIf': ('groupBitXor', 'ArrayIf'), 'theilsUArrayIf': ('theilsU', 'ArrayIf'), 'boundingRatioArrayIf': ('boundingRatio', 'ArrayIf'), 'histogramArrayIf': ('histogram', 'ArrayIf'), 'kolmogorovSmirnovTestArrayIf': ('kolmogorovSmirnovTest', 'ArrayIf'), 'groupBitmapXorArrayIf': ('groupBitmapXor', 'ArrayIf'), 'quantileDeterministicArrayIf': ('quantileDeterministic', 'ArrayIf'), 'varPopArrayIf': ('varPop', 'ArrayIf'), 'first_valueArrayIf': ('first_value', 'ArrayIf'), 'uniqHLL12ArrayIf': ('uniqHLL12', 'ArrayIf'), 'minMapArrayIf': ('minMap', 'ArrayIf'), 'simpleLinearRegressionArrayIf': ('simpleLinearRegression', 'ArrayIf'), 'quantilesInterpolatedWeightedArrayIf': ('quantilesInterpolatedWeighted', 'ArrayIf'), 'maxArrayIf': ('max', 'ArrayIf'), 'quantileTDigestWeightedArrayIf': ('quantileTDigestWeighted', 'ArrayIf'), 'groupUniqArrayArrayIf': ('groupUniqArray', 'ArrayIf'), 'meanZTestArrayIf': ('meanZTest', 'ArrayIf'), 'stochasticLogisticRegressionArrayIf': ('stochasticLogisticRegression', 'ArrayIf'), 'cramersVBiasCorrectedArrayIf': ('cramersVBiasCorrected', 'ArrayIf'), 'covarPopArrayIf': ('covarPop', 'ArrayIf'), 'countArrayIf': ('count', 'ArrayIf'), 'deltaSumArrayIf': ('deltaSum', 'ArrayIf'), 'quantileInterpolatedWeightedArrayIf': ('quantileInterpolatedWeighted', 'ArrayIf'), 'quantileGKArrayIf': ('quantileGK', 'ArrayIf'), 'anyHeavyArrayIf': ('anyHeavy', 'ArrayIf'), 'uniqUpToArrayIf': ('uniqUpTo', 'ArrayIf'), 'studentTTestArrayIf': ('studentTTest', 'ArrayIf'), 'varSampArrayIf': ('varSamp', 'ArrayIf'), 'groupBitmapOrArrayIf': ('groupBitmapOr', 'ArrayIf'), 'argMinArrayIf': ('argMin', 'ArrayIf'), 'contingencyArrayIf': ('contingency', 'ArrayIf'), 'quantilesExactLowArrayIf': ('quantilesExactLow', 'ArrayIf'), 'covarSampArrayIf': ('covarSamp', 'ArrayIf'), 'mannWhitneyUTestArrayIf': ('mannWhitneyUTest', 'ArrayIf'), 'quantilesExactWeightedArrayIf': ('quantilesExactWeighted', 'ArrayIf'), 'quantileTimingWeightedArrayIf': ('quantileTimingWeighted', 'ArrayIf'), 'minArrayIf': ('min', 'ArrayIf'), 'approx_top_sumArrayIf': ('approx_top_sum', 'ArrayIf'), 'uniqArrayIf': ('uniq', 'ArrayIf'), 'quantilesExactArrayIf': ('quantilesExact', 'ArrayIf'), 'retentionArrayIf': ('retention', 'ArrayIf'), 'uniqExactArrayIf': ('uniqExact', 'ArrayIf'), 'stochasticLinearRegressionArrayIf': ('stochasticLinearRegression', 'ArrayIf'), 'quantilesExactExclusiveArrayIf': ('quantilesExactExclusive', 'ArrayIf'), 'sparkBarArrayIf': ('sparkBar', 'ArrayIf'), 'skewPopArrayIf': ('skewPop', 'ArrayIf'), 'groupArrayMovingAvgArrayIf': ('groupArrayMovingAvg', 'ArrayIf'), 'medianArrayIf': ('median', 'ArrayIf'), 'groupArrayLastArrayIf': ('groupArrayLast', 'ArrayIf'), 'kurtPopArrayIf': ('kurtPop', 'ArrayIf'), 'exponentialMovingAverageArrayIf': ('exponentialMovingAverage', 'ArrayIf'), 'sequenceNextNodeArrayIf': ('sequenceNextNode', 'ArrayIf'), 'quantileArrayIf': ('quantile', 'ArrayIf'), 'groupArrayInsertAtArrayIf': ('groupArrayInsertAt', 'ArrayIf'), 'sumArrayIf': ('sum', 'ArrayIf'), 'quantileBFloat16ArrayIf': ('quantileBFloat16', 'ArrayIf'), 'rankCorrArrayIf': ('rankCorr', 'ArrayIf'), 'quantileTDigestArrayIf': ('quantileTDigest', 'ArrayIf'), 'maxIntersectionsPositionArrayIf': ('maxIntersectionsPosition', 'ArrayIf'), 'sumMapArrayIf': ('sumMap', 'ArrayIf'), 'kurtSampArrayIf': ('kurtSamp', 'ArrayIf'), 'exponentialTimeDecayedAvgArrayIf': ('exponentialTimeDecayedAvg', 'ArrayIf'), 'avgWeightedArrayIf': ('avgWeighted', 'ArrayIf'), 'topKWeightedArrayIf': ('topKWeighted', 'ArrayIf'), 'largestTriangleThreeBucketsArrayIf': ('largestTriangleThreeBuckets', 'ArrayIf'), 'groupArraySampleArrayIf': ('groupArraySample', 'ArrayIf'), 'quantileExactHighArrayIf': ('quantileExactHigh', 'ArrayIf'), 'windowFunnelArrayIf': ('windowFunnel', 'ArrayIf'), 'quantileExactWeightedArrayIf': ('quantileExactWeighted', 'ArrayIf'), 'quantileExactLowArrayIf': ('quantileExactLow', 'ArrayIf'), 'maxMapArrayIf': ('maxMap', 'ArrayIf'), 'welchTTestArrayIf': ('welchTTest', 'ArrayIf'), 'groupBitOrArrayIf': ('groupBitOr', 'ArrayIf'), 'quantilesArrayIf': ('quantiles', 'ArrayIf'), 'avgArrayIf': ('avg', 'ArrayIf'), 'cramersVArrayIf': ('cramersV', 'ArrayIf'), 'anyLastArrayIf': ('anyLast', 'ArrayIf'), 'quantilesGKArrayIf': ('quantilesGK', 'ArrayIf'), 'sequenceMatchArrayIf': ('sequenceMatch', 'ArrayIf'), 'quantilesTimingWeightedArrayIf': ('quantilesTimingWeighted', 'ArrayIf'), 'quantilesDeterministicArrayIf': ('quantilesDeterministic', 'ArrayIf'), 'sumCountArrayIf': ('sumCount', 'ArrayIf'), 'maxIntersectionsArrayIf': ('maxIntersections', 'ArrayIf'), 'stddevSampArrayIf': ('stddevSamp', 'ArrayIf'), 'groupBitmapAndArrayIf': ('groupBitmapAnd', 'ArrayIf'), 'groupArrayArrayIf': ('groupArray', 'ArrayIf'), 'uniqCombinedArrayIf': ('uniqCombined', 'ArrayIf'), 'skewSampArrayIf': ('skewSamp', 'ArrayIf'), 'groupBitmapArrayIf': ('groupBitmap', 'ArrayIf'), 'quantilesBFloat16ArrayIf': ('quantilesBFloat16', 'ArrayIf'), 'quantilesTDigestArrayIf': ('quantilesTDigest', 'ArrayIf'), 'sequenceCountArrayIf': ('sequenceCount', 'ArrayIf'), 'uniqCombined64ArrayIf': ('uniqCombined64', 'ArrayIf'), 'entropyArrayIf': ('entropy', 'ArrayIf'), 'quantilesTDigestWeightedArrayIf': ('quantilesTDigestWeighted', 'ArrayIf'), 'quantileExactArrayIf': ('quantileExact', 'ArrayIf'), 'categoricalInformationValueArrayIf': ('categoricalInformationValue', 'ArrayIf'), 'topKArrayIf': ('topK', 'ArrayIf'), 'groupBitAndArrayIf': ('groupBitAnd', 'ArrayIf'), 'stddevPopArrayIf': ('stddevPop', 'ArrayIf'), 'quantileBFloat16WeightedArrayIf': ('quantileBFloat16Weighted', 'ArrayIf'), 'quantileTimingArrayIf': ('quantileTiming', 'ArrayIf'), 'groupConcatArrayIf': ('groupConcat', 'ArrayIf'), 'corrArrayIf': ('corr', 'ArrayIf'), 'sumWithOverflowArrayIf': ('sumWithOverflow', 'ArrayIf'), 'last_valueArrayIf': ('last_value', 'ArrayIf'), 'argMaxArrayIf': ('argMax', 'ArrayIf'), 'quantilesTimingArrayIf': ('quantilesTiming', 'ArrayIf'), 'groupArrayMovingSumArrayIf': ('groupArrayMovingSum', 'ArrayIf'), 'deltaSumTimestampArrayIf': ('deltaSumTimestamp', 'ArrayIf'), 'quantilesBFloat16WeightedArrayIf': ('quantilesBFloat16Weighted', 'ArrayIf'), 'intervalLengthSumArrayIf': ('intervalLengthSum', 'ArrayIf'), 'sumKahanForEach': ('sumKahan', 'ForEach'), 'quantilesExactHighForEach': ('quantilesExactHigh', 'ForEach'), 'anyForEach': ('any', 'ForEach'), 'uniqThetaForEach': ('uniqTheta', 'ForEach'), 'groupBitXorForEach': ('groupBitXor', 'ForEach'), 'theilsUForEach': ('theilsU', 'ForEach'), 'boundingRatioForEach': ('boundingRatio', 'ForEach'), 'histogramForEach': ('histogram', 'ForEach'), 'kolmogorovSmirnovTestForEach': ('kolmogorovSmirnovTest', 'ForEach'), 'groupBitmapXorForEach': ('groupBitmapXor', 'ForEach'), 'quantileDeterministicForEach': ('quantileDeterministic', 'ForEach'), 'varPopForEach': ('varPop', 'ForEach'), 'first_valueForEach': ('first_value', 'ForEach'), 'uniqHLL12ForEach': ('uniqHLL12', 'ForEach'), 'minMapForEach': ('minMap', 'ForEach'), 'simpleLinearRegressionForEach': ('simpleLinearRegression', 'ForEach'), 'quantilesInterpolatedWeightedForEach': ('quantilesInterpolatedWeighted', 'ForEach'), 'maxForEach': ('max', 'ForEach'), 'quantileTDigestWeightedForEach': ('quantileTDigestWeighted', 'ForEach'), 'groupUniqArrayForEach': ('groupUniqArray', 'ForEach'), 'meanZTestForEach': ('meanZTest', 'ForEach'), 'stochasticLogisticRegressionForEach': ('stochasticLogisticRegression', 'ForEach'), 'cramersVBiasCorrectedForEach': ('cramersVBiasCorrected', 'ForEach'), 'covarPopForEach': ('covarPop', 'ForEach'), 'countForEach': ('count', 'ForEach'), 'deltaSumForEach': ('deltaSum', 'ForEach'), 'quantileInterpolatedWeightedForEach': ('quantileInterpolatedWeighted', 'ForEach'), 'quantileGKForEach': ('quantileGK', 'ForEach'), 'anyHeavyForEach': ('anyHeavy', 'ForEach'), 'uniqUpToForEach': ('uniqUpTo', 'ForEach'), 'studentTTestForEach': ('studentTTest', 'ForEach'), 'varSampForEach': ('varSamp', 'ForEach'), 'groupBitmapOrForEach': ('groupBitmapOr', 'ForEach'), 'argMinForEach': ('argMin', 'ForEach'), 'contingencyForEach': ('contingency', 'ForEach'), 'quantilesExactLowForEach': ('quantilesExactLow', 'ForEach'), 'covarSampForEach': ('covarSamp', 'ForEach'), 'mannWhitneyUTestForEach': ('mannWhitneyUTest', 'ForEach'), 'quantilesExactWeightedForEach': ('quantilesExactWeighted', 'ForEach'), 'quantileTimingWeightedForEach': ('quantileTimingWeighted', 'ForEach'), 'minForEach': ('min', 'ForEach'), 'approx_top_sumForEach': ('approx_top_sum', 'ForEach'), 'uniqForEach': ('uniq', 'ForEach'), 'quantilesExactForEach': ('quantilesExact', 'ForEach'), 'retentionForEach': ('retention', 'ForEach'), 'uniqExactForEach': ('uniqExact', 'ForEach'), 'stochasticLinearRegressionForEach': ('stochasticLinearRegression', 'ForEach'), 'quantilesExactExclusiveForEach': ('quantilesExactExclusive', 'ForEach'), 'sparkBarForEach': ('sparkBar', 'ForEach'), 'skewPopForEach': ('skewPop', 'ForEach'), 'groupArrayMovingAvgForEach': ('groupArrayMovingAvg', 'ForEach'), 'medianForEach': ('median', 'ForEach'), 'groupArrayLastForEach': ('groupArrayLast', 'ForEach'), 'kurtPopForEach': ('kurtPop', 'ForEach'), 'exponentialMovingAverageForEach': ('exponentialMovingAverage', 'ForEach'), 'sequenceNextNodeForEach': ('sequenceNextNode', 'ForEach'), 'quantileForEach': ('quantile', 'ForEach'), 'groupArrayInsertAtForEach': ('groupArrayInsertAt', 'ForEach'), 'sumForEach': ('sum', 'ForEach'), 'quantileBFloat16ForEach': ('quantileBFloat16', 'ForEach'), 'rankCorrForEach': ('rankCorr', 'ForEach'), 'quantileTDigestForEach': ('quantileTDigest', 'ForEach'), 'maxIntersectionsPositionForEach': ('maxIntersectionsPosition', 'ForEach'), 'sumMapForEach': ('sumMap', 'ForEach'), 'kurtSampForEach': ('kurtSamp', 'ForEach'), 'exponentialTimeDecayedAvgForEach': ('exponentialTimeDecayedAvg', 'ForEach'), 'avgWeightedForEach': ('avgWeighted', 'ForEach'), 'topKWeightedForEach': ('topKWeighted', 'ForEach'), 'largestTriangleThreeBucketsForEach': ('largestTriangleThreeBuckets', 'ForEach'), 'groupArraySampleForEach': ('groupArraySample', 'ForEach'), 'quantileExactHighForEach': ('quantileExactHigh', 'ForEach'), 'windowFunnelForEach': ('windowFunnel', 'ForEach'), 'quantileExactWeightedForEach': ('quantileExactWeighted', 'ForEach'), 'quantileExactLowForEach': ('quantileExactLow', 'ForEach'), 'maxMapForEach': ('maxMap', 'ForEach'), 'welchTTestForEach': ('welchTTest', 'ForEach'), 'groupBitOrForEach': ('groupBitOr', 'ForEach'), 'quantilesForEach': ('quantiles', 'ForEach'), 'avgForEach': ('avg', 'ForEach'), 'cramersVForEach': ('cramersV', 'ForEach'), 'anyLastForEach': ('anyLast', 'ForEach'), 'quantilesGKForEach': ('quantilesGK', 'ForEach'), 'sequenceMatchForEach': ('sequenceMatch', 'ForEach'), 'quantilesTimingWeightedForEach': ('quantilesTimingWeighted', 'ForEach'), 'quantilesDeterministicForEach': ('quantilesDeterministic', 'ForEach'), 'sumCountForEach': ('sumCount', 'ForEach'), 'maxIntersectionsForEach': ('maxIntersections', 'ForEach'), 'stddevSampForEach': ('stddevSamp', 'ForEach'), 'groupBitmapAndForEach': ('groupBitmapAnd', 'ForEach'), 'groupArrayForEach': ('groupArray', 'ForEach'), 'uniqCombinedForEach': ('uniqCombined', 'ForEach'), 'skewSampForEach': ('skewSamp', 'ForEach'), 'groupBitmapForEach': ('groupBitmap', 'ForEach'), 'quantilesBFloat16ForEach': ('quantilesBFloat16', 'ForEach'), 'quantilesTDigestForEach': ('quantilesTDigest', 'ForEach'), 'sequenceCountForEach': ('sequenceCount', 'ForEach'), 'uniqCombined64ForEach': ('uniqCombined64', 'ForEach'), 'entropyForEach': ('entropy', 'ForEach'), 'quantilesTDigestWeightedForEach': ('quantilesTDigestWeighted', 'ForEach'), 'quantileExactForEach': ('quantileExact', 'ForEach'), 'categoricalInformationValueForEach': ('categoricalInformationValue', 'ForEach'), 'topKForEach': ('topK', 'ForEach'), 'groupBitAndForEach': ('groupBitAnd', 'ForEach'), 'stddevPopForEach': ('stddevPop', 'ForEach'), 'quantileBFloat16WeightedForEach': ('quantileBFloat16Weighted', 'ForEach'), 'quantileTimingForEach': ('quantileTiming', 'ForEach'), 'groupConcatForEach': ('groupConcat', 'ForEach'), 'corrForEach': ('corr', 'ForEach'), 'sumWithOverflowForEach': ('sumWithOverflow', 'ForEach'), 'last_valueForEach': ('last_value', 'ForEach'), 'argMaxForEach': ('argMax', 'ForEach'), 'quantilesTimingForEach': ('quantilesTiming', 'ForEach'), 'groupArrayMovingSumForEach': ('groupArrayMovingSum', 'ForEach'), 'deltaSumTimestampForEach': ('deltaSumTimestamp', 'ForEach'), 'quantilesBFloat16WeightedForEach': ('quantilesBFloat16Weighted', 'ForEach'), 'intervalLengthSumForEach': ('intervalLengthSum', 'ForEach'), 'sumKahanOrNull': ('sumKahan', 'OrNull'), 'quantilesExactHighOrNull': ('quantilesExactHigh', 'OrNull'), 'anyOrNull': ('any', 'OrNull'), 'uniqThetaOrNull': ('uniqTheta', 'OrNull'), 'groupBitXorOrNull': ('groupBitXor', 'OrNull'), 'theilsUOrNull': ('theilsU', 'OrNull'), 'boundingRatioOrNull': ('boundingRatio', 'OrNull'), 'histogramOrNull': ('histogram', 'OrNull'), 'kolmogorovSmirnovTestOrNull': ('kolmogorovSmirnovTest', 'OrNull'), 'groupBitmapXorOrNull': ('groupBitmapXor', 'OrNull'), 'quantileDeterministicOrNull': ('quantileDeterministic', 'OrNull'), 'varPopOrNull': ('varPop', 'OrNull'), 'first_valueOrNull': ('first_value', 'OrNull'), 'uniqHLL12OrNull': ('uniqHLL12', 'OrNull'), 'minMapOrNull': ('minMap', 'OrNull'), 'simpleLinearRegressionOrNull': ('simpleLinearRegression', 'OrNull'), 'quantilesInterpolatedWeightedOrNull': ('quantilesInterpolatedWeighted', 'OrNull'), 'maxOrNull': ('max', 'OrNull'), 'quantileTDigestWeightedOrNull': ('quantileTDigestWeighted', 'OrNull'), 'groupUniqArrayOrNull': ('groupUniqArray', 'OrNull'), 'meanZTestOrNull': ('meanZTest', 'OrNull'), 'stochasticLogisticRegressionOrNull': ('stochasticLogisticRegression', 'OrNull'), 'cramersVBiasCorrectedOrNull': ('cramersVBiasCorrected', 'OrNull'), 'covarPopOrNull': ('covarPop', 'OrNull'), 'countOrNull': ('count', 'OrNull'), 'deltaSumOrNull': ('deltaSum', 'OrNull'), 'quantileInterpolatedWeightedOrNull': ('quantileInterpolatedWeighted', 'OrNull'), 'quantileGKOrNull': ('quantileGK', 'OrNull'), 'anyHeavyOrNull': ('anyHeavy', 'OrNull'), 'uniqUpToOrNull': ('uniqUpTo', 'OrNull'), 'studentTTestOrNull': ('studentTTest', 'OrNull'), 'varSampOrNull': ('varSamp', 'OrNull'), 'groupBitmapOrOrNull': ('groupBitmapOr', 'OrNull'), 'argMinOrNull': ('argMin', 'OrNull'), 'contingencyOrNull': ('contingency', 'OrNull'), 'quantilesExactLowOrNull': ('quantilesExactLow', 'OrNull'), 'covarSampOrNull': ('covarSamp', 'OrNull'), 'mannWhitneyUTestOrNull': ('mannWhitneyUTest', 'OrNull'), 'quantilesExactWeightedOrNull': ('quantilesExactWeighted', 'OrNull'), 'quantileTimingWeightedOrNull': ('quantileTimingWeighted', 'OrNull'), 'minOrNull': ('min', 'OrNull'), 'approx_top_sumOrNull': ('approx_top_sum', 'OrNull'), 'uniqOrNull': ('uniq', 'OrNull'), 'quantilesExactOrNull': ('quantilesExact', 'OrNull'), 'retentionOrNull': ('retention', 'OrNull'), 'uniqExactOrNull': ('uniqExact', 'OrNull'), 'stochasticLinearRegressionOrNull': ('stochasticLinearRegression', 'OrNull'), 'quantilesExactExclusiveOrNull': ('quantilesExactExclusive', 'OrNull'), 'sparkBarOrNull': ('sparkBar', 'OrNull'), 'skewPopOrNull': ('skewPop', 'OrNull'), 'groupArrayMovingAvgOrNull': ('groupArrayMovingAvg', 'OrNull'), 'medianOrNull': ('median', 'OrNull'), 'groupArrayLastOrNull': ('groupArrayLast', 'OrNull'), 'kurtPopOrNull': ('kurtPop', 'OrNull'), 'exponentialMovingAverageOrNull': ('exponentialMovingAverage', 'OrNull'), 'sequenceNextNodeOrNull': ('sequenceNextNode', 'OrNull'), 'quantileOrNull': ('quantile', 'OrNull'), 'groupArrayInsertAtOrNull': ('groupArrayInsertAt', 'OrNull'), 'sumOrNull': ('sum', 'OrNull'), 'quantileBFloat16OrNull': ('quantileBFloat16', 'OrNull'), 'rankCorrOrNull': ('rankCorr', 'OrNull'), 'quantileTDigestOrNull': ('quantileTDigest', 'OrNull'), 'maxIntersectionsPositionOrNull': ('maxIntersectionsPosition', 'OrNull'), 'sumMapOrNull': ('sumMap', 'OrNull'), 'kurtSampOrNull': ('kurtSamp', 'OrNull'), 'exponentialTimeDecayedAvgOrNull': ('exponentialTimeDecayedAvg', 'OrNull'), 'avgWeightedOrNull': ('avgWeighted', 'OrNull'), 'topKWeightedOrNull': ('topKWeighted', 'OrNull'), 'largestTriangleThreeBucketsOrNull': ('largestTriangleThreeBuckets', 'OrNull'), 'groupArraySampleOrNull': ('groupArraySample', 'OrNull'), 'quantileExactHighOrNull': ('quantileExactHigh', 'OrNull'), 'windowFunnelOrNull': ('windowFunnel', 'OrNull'), 'quantileExactWeightedOrNull': ('quantileExactWeighted', 'OrNull'), 'quantileExactLowOrNull': ('quantileExactLow', 'OrNull'), 'maxMapOrNull': ('maxMap', 'OrNull'), 'welchTTestOrNull': ('welchTTest', 'OrNull'), 'groupBitOrOrNull': ('groupBitOr', 'OrNull'), 'quantilesOrNull': ('quantiles', 'OrNull'), 'avgOrNull': ('avg', 'OrNull'), 'cramersVOrNull': ('cramersV', 'OrNull'), 'anyLastOrNull': ('anyLast', 'OrNull'), 'quantilesGKOrNull': ('quantilesGK', 'OrNull'), 'sequenceMatchOrNull': ('sequenceMatch', 'OrNull'), 'quantilesTimingWeightedOrNull': ('quantilesTimingWeighted', 'OrNull'), 'quantilesDeterministicOrNull': ('quantilesDeterministic', 'OrNull'), 'sumCountOrNull': ('sumCount', 'OrNull'), 'maxIntersectionsOrNull': ('maxIntersections', 'OrNull'), 'stddevSampOrNull': ('stddevSamp', 'OrNull'), 'groupBitmapAndOrNull': ('groupBitmapAnd', 'OrNull'), 'groupArrayOrNull': ('groupArray', 'OrNull'), 'uniqCombinedOrNull': ('uniqCombined', 'OrNull'), 'skewSampOrNull': ('skewSamp', 'OrNull'), 'groupBitmapOrNull': ('groupBitmap', 'OrNull'), 'quantilesBFloat16OrNull': ('quantilesBFloat16', 'OrNull'), 'quantilesTDigestOrNull': ('quantilesTDigest', 'OrNull'), 'sequenceCountOrNull': ('sequenceCount', 'OrNull'), 'uniqCombined64OrNull': ('uniqCombined64', 'OrNull'), 'entropyOrNull': ('entropy', 'OrNull'), 'quantilesTDigestWeightedOrNull': ('quantilesTDigestWeighted', 'OrNull'), 'quantileExactOrNull': ('quantileExact', 'OrNull'), 'categoricalInformationValueOrNull': ('categoricalInformationValue', 'OrNull'), 'topKOrNull': ('topK', 'OrNull'), 'groupBitAndOrNull': ('groupBitAnd', 'OrNull'), 'stddevPopOrNull': ('stddevPop', 'OrNull'), 'quantileBFloat16WeightedOrNull': ('quantileBFloat16Weighted', 'OrNull'), 'quantileTimingOrNull': ('quantileTiming', 'OrNull'), 'groupConcatOrNull': ('groupConcat', 'OrNull'), 'corrOrNull': ('corr', 'OrNull'), 'sumWithOverflowOrNull': ('sumWithOverflow', 'OrNull'), 'last_valueOrNull': ('last_value', 'OrNull'), 'argMaxOrNull': ('argMax', 'OrNull'), 'quantilesTimingOrNull': ('quantilesTiming', 'OrNull'), 'groupArrayMovingSumOrNull': ('groupArrayMovingSum', 'OrNull'), 'deltaSumTimestampOrNull': ('deltaSumTimestamp', 'OrNull'), 'quantilesBFloat16WeightedOrNull': ('quantilesBFloat16Weighted', 'OrNull'), 'intervalLengthSumOrNull': ('intervalLengthSum', 'OrNull'), 'sumKahanArgMin': ('sumKahan', 'ArgMin'), 'quantilesExactHighArgMin': ('quantilesExactHigh', 'ArgMin'), 'anyArgMin': ('any', 'ArgMin'), 'uniqThetaArgMin': ('uniqTheta', 'ArgMin'), 'groupBitXorArgMin': ('groupBitXor', 'ArgMin'), 'theilsUArgMin': ('theilsU', 'ArgMin'), 'boundingRatioArgMin': ('boundingRatio', 'ArgMin'), 'histogramArgMin': ('histogram', 'ArgMin'), 'kolmogorovSmirnovTestArgMin': ('kolmogorovSmirnovTest', 'ArgMin'), 'groupBitmapXorArgMin': ('groupBitmapXor', 'ArgMin'), 'quantileDeterministicArgMin': ('quantileDeterministic', 'ArgMin'), 'varPopArgMin': ('varPop', 'ArgMin'), 'first_valueArgMin': ('first_value', 'ArgMin'), 'uniqHLL12ArgMin': ('uniqHLL12', 'ArgMin'), 'minMapArgMin': ('minMap', 'ArgMin'), 'simpleLinearRegressionArgMin': ('simpleLinearRegression', 'ArgMin'), 'quantilesInterpolatedWeightedArgMin': ('quantilesInterpolatedWeighted', 'ArgMin'), 'maxArgMin': ('max', 'ArgMin'), 'quantileTDigestWeightedArgMin': ('quantileTDigestWeighted', 'ArgMin'), 'groupUniqArrayArgMin': ('groupUniqArray', 'ArgMin'), 'meanZTestArgMin': ('meanZTest', 'ArgMin'), 'stochasticLogisticRegressionArgMin': ('stochasticLogisticRegression', 'ArgMin'), 'cramersVBiasCorrectedArgMin': ('cramersVBiasCorrected', 'ArgMin'), 'covarPopArgMin': ('covarPop', 'ArgMin'), 'countArgMin': ('count', 'ArgMin'), 'deltaSumArgMin': ('deltaSum', 'ArgMin'), 'quantileInterpolatedWeightedArgMin': ('quantileInterpolatedWeighted', 'ArgMin'), 'quantileGKArgMin': ('quantileGK', 'ArgMin'), 'anyHeavyArgMin': ('anyHeavy', 'ArgMin'), 'uniqUpToArgMin': ('uniqUpTo', 'ArgMin'), 'studentTTestArgMin': ('studentTTest', 'ArgMin'), 'varSampArgMin': ('varSamp', 'ArgMin'), 'groupBitmapOrArgMin': ('groupBitmapOr', 'ArgMin'), 'argMinArgMin': ('argMin', 'ArgMin'), 'contingencyArgMin': ('contingency', 'ArgMin'), 'quantilesExactLowArgMin': ('quantilesExactLow', 'ArgMin'), 'covarSampArgMin': ('covarSamp', 'ArgMin'), 'mannWhitneyUTestArgMin': ('mannWhitneyUTest', 'ArgMin'), 'quantilesExactWeightedArgMin': ('quantilesExactWeighted', 'ArgMin'), 'quantileTimingWeightedArgMin': ('quantileTimingWeighted', 'ArgMin'), 'minArgMin': ('min', 'ArgMin'), 'approx_top_sumArgMin': ('approx_top_sum', 'ArgMin'), 'uniqArgMin': ('uniq', 'ArgMin'), 'quantilesExactArgMin': ('quantilesExact', 'ArgMin'), 'retentionArgMin': ('retention', 'ArgMin'), 'uniqExactArgMin': ('uniqExact', 'ArgMin'), 'stochasticLinearRegressionArgMin': ('stochasticLinearRegression', 'ArgMin'), 'quantilesExactExclusiveArgMin': ('quantilesExactExclusive', 'ArgMin'), 'sparkBarArgMin': ('sparkBar', 'ArgMin'), 'skewPopArgMin': ('skewPop', 'ArgMin'), 'groupArrayMovingAvgArgMin': ('groupArrayMovingAvg', 'ArgMin'), 'medianArgMin': ('median', 'ArgMin'), 'groupArrayLastArgMin': ('groupArrayLast', 'ArgMin'), 'kurtPopArgMin': ('kurtPop', 'ArgMin'), 'exponentialMovingAverageArgMin': ('exponentialMovingAverage', 'ArgMin'), 'sequenceNextNodeArgMin': ('sequenceNextNode', 'ArgMin'), 'quantileArgMin': ('quantile', 'ArgMin'), 'groupArrayInsertAtArgMin': ('groupArrayInsertAt', 'ArgMin'), 'sumArgMin': ('sum', 'ArgMin'), 'quantileBFloat16ArgMin': ('quantileBFloat16', 'ArgMin'), 'rankCorrArgMin': ('rankCorr', 'ArgMin'), 'quantileTDigestArgMin': ('quantileTDigest', 'ArgMin'), 'maxIntersectionsPositionArgMin': ('maxIntersectionsPosition', 'ArgMin'), 'sumMapArgMin': ('sumMap', 'ArgMin'), 'kurtSampArgMin': ('kurtSamp', 'ArgMin'), 'exponentialTimeDecayedAvgArgMin': ('exponentialTimeDecayedAvg', 'ArgMin'), 'avgWeightedArgMin': ('avgWeighted', 'ArgMin'), 'topKWeightedArgMin': ('topKWeighted', 'ArgMin'), 'largestTriangleThreeBucketsArgMin': ('largestTriangleThreeBuckets', 'ArgMin'), 'groupArraySampleArgMin': ('groupArraySample', 'ArgMin'), 'quantileExactHighArgMin': ('quantileExactHigh', 'ArgMin'), 'windowFunnelArgMin': ('windowFunnel', 'ArgMin'), 'quantileExactWeightedArgMin': ('quantileExactWeighted', 'ArgMin'), 'quantileExactLowArgMin': ('quantileExactLow', 'ArgMin'), 'maxMapArgMin': ('maxMap', 'ArgMin'), 'welchTTestArgMin': ('welchTTest', 'ArgMin'), 'groupBitOrArgMin': ('groupBitOr', 'ArgMin'), 'quantilesArgMin': ('quantiles', 'ArgMin'), 'avgArgMin': ('avg', 'ArgMin'), 'cramersVArgMin': ('cramersV', 'ArgMin'), 'anyLastArgMin': ('anyLast', 'ArgMin'), 'quantilesGKArgMin': ('quantilesGK', 'ArgMin'), 'sequenceMatchArgMin': ('sequenceMatch', 'ArgMin'), 'quantilesTimingWeightedArgMin': ('quantilesTimingWeighted', 'ArgMin'), 'quantilesDeterministicArgMin': ('quantilesDeterministic', 'ArgMin'), 'sumCountArgMin': ('sumCount', 'ArgMin'), 'maxIntersectionsArgMin': ('maxIntersections', 'ArgMin'), 'stddevSampArgMin': ('stddevSamp', 'ArgMin'), 'groupBitmapAndArgMin': ('groupBitmapAnd', 'ArgMin'), 'groupArrayArgMin': ('groupArray', 'ArgMin'), 'uniqCombinedArgMin': ('uniqCombined', 'ArgMin'), 'skewSampArgMin': ('skewSamp', 'ArgMin'), 'groupBitmapArgMin': ('groupBitmap', 'ArgMin'), 'quantilesBFloat16ArgMin': ('quantilesBFloat16', 'ArgMin'), 'quantilesTDigestArgMin': ('quantilesTDigest', 'ArgMin'), 'sequenceCountArgMin': ('sequenceCount', 'ArgMin'), 'uniqCombined64ArgMin': ('uniqCombined64', 'ArgMin'), 'entropyArgMin': ('entropy', 'ArgMin'), 'quantilesTDigestWeightedArgMin': ('quantilesTDigestWeighted', 'ArgMin'), 'quantileExactArgMin': ('quantileExact', 'ArgMin'), 'categoricalInformationValueArgMin': ('categoricalInformationValue', 'ArgMin'), 'topKArgMin': ('topK', 'ArgMin'), 'groupBitAndArgMin': ('groupBitAnd', 'ArgMin'), 'stddevPopArgMin': ('stddevPop', 'ArgMin'), 'quantileBFloat16WeightedArgMin': ('quantileBFloat16Weighted', 'ArgMin'), 'quantileTimingArgMin': ('quantileTiming', 'ArgMin'), 'groupConcatArgMin': ('groupConcat', 'ArgMin'), 'corrArgMin': ('corr', 'ArgMin'), 'sumWithOverflowArgMin': ('sumWithOverflow', 'ArgMin'), 'last_valueArgMin': ('last_value', 'ArgMin'), 'argMaxArgMin': ('argMax', 'ArgMin'), 'quantilesTimingArgMin': ('quantilesTiming', 'ArgMin'), 'groupArrayMovingSumArgMin': ('groupArrayMovingSum', 'ArgMin'), 'deltaSumTimestampArgMin': ('deltaSumTimestamp', 'ArgMin'), 'quantilesBFloat16WeightedArgMin': ('quantilesBFloat16Weighted', 'ArgMin'), 'intervalLengthSumArgMin': ('intervalLengthSum', 'ArgMin'), 'sumKahanArgMax': ('sumKahan', 'ArgMax'), 'quantilesExactHighArgMax': ('quantilesExactHigh', 'ArgMax'), 'anyArgMax': ('any', 'ArgMax'), 'uniqThetaArgMax': ('uniqTheta', 'ArgMax'), 'groupBitXorArgMax': ('groupBitXor', 'ArgMax'), 'theilsUArgMax': ('theilsU', 'ArgMax'), 'boundingRatioArgMax': ('boundingRatio', 'ArgMax'), 'histogramArgMax': ('histogram', 'ArgMax'), 'kolmogorovSmirnovTestArgMax': ('kolmogorovSmirnovTest', 'ArgMax'), 'groupBitmapXorArgMax': ('groupBitmapXor', 'ArgMax'), 'quantileDeterministicArgMax': ('quantileDeterministic', 'ArgMax'), 'varPopArgMax': ('varPop', 'ArgMax'), 'first_valueArgMax': ('first_value', 'ArgMax'), 'uniqHLL12ArgMax': ('uniqHLL12', 'ArgMax'), 'minMapArgMax': ('minMap', 'ArgMax'), 'simpleLinearRegressionArgMax': ('simpleLinearRegression', 'ArgMax'), 'quantilesInterpolatedWeightedArgMax': ('quantilesInterpolatedWeighted', 'ArgMax'), 'maxArgMax': ('max', 'ArgMax'), 'quantileTDigestWeightedArgMax': ('quantileTDigestWeighted', 'ArgMax'), 'groupUniqArrayArgMax': ('groupUniqArray', 'ArgMax'), 'meanZTestArgMax': ('meanZTest', 'ArgMax'), 'stochasticLogisticRegressionArgMax': ('stochasticLogisticRegression', 'ArgMax'), 'cramersVBiasCorrectedArgMax': ('cramersVBiasCorrected', 'ArgMax'), 'covarPopArgMax': ('covarPop', 'ArgMax'), 'countArgMax': ('count', 'ArgMax'), 'deltaSumArgMax': ('deltaSum', 'ArgMax'), 'quantileInterpolatedWeightedArgMax': ('quantileInterpolatedWeighted', 'ArgMax'), 'quantileGKArgMax': ('quantileGK', 'ArgMax'), 'anyHeavyArgMax': ('anyHeavy', 'ArgMax'), 'uniqUpToArgMax': ('uniqUpTo', 'ArgMax'), 'studentTTestArgMax': ('studentTTest', 'ArgMax'), 'varSampArgMax': ('varSamp', 'ArgMax'), 'groupBitmapOrArgMax': ('groupBitmapOr', 'ArgMax'), 'argMinArgMax': ('argMin', 'ArgMax'), 'contingencyArgMax': ('contingency', 'ArgMax'), 'quantilesExactLowArgMax': ('quantilesExactLow', 'ArgMax'), 'covarSampArgMax': ('covarSamp', 'ArgMax'), 'mannWhitneyUTestArgMax': ('mannWhitneyUTest', 'ArgMax'), 'quantilesExactWeightedArgMax': ('quantilesExactWeighted', 'ArgMax'), 'quantileTimingWeightedArgMax': ('quantileTimingWeighted', 'ArgMax'), 'minArgMax': ('min', 'ArgMax'), 'approx_top_sumArgMax': ('approx_top_sum', 'ArgMax'), 'uniqArgMax': ('uniq', 'ArgMax'), 'quantilesExactArgMax': ('quantilesExact', 'ArgMax'), 'retentionArgMax': ('retention', 'ArgMax'), 'uniqExactArgMax': ('uniqExact', 'ArgMax'), 'stochasticLinearRegressionArgMax': ('stochasticLinearRegression', 'ArgMax'), 'quantilesExactExclusiveArgMax': ('quantilesExactExclusive', 'ArgMax'), 'sparkBarArgMax': ('sparkBar', 'ArgMax'), 'skewPopArgMax': ('skewPop', 'ArgMax'), 'groupArrayMovingAvgArgMax': ('groupArrayMovingAvg', 'ArgMax'), 'medianArgMax': ('median', 'ArgMax'), 'groupArrayLastArgMax': ('groupArrayLast', 'ArgMax'), 'kurtPopArgMax': ('kurtPop', 'ArgMax'), 'exponentialMovingAverageArgMax': ('exponentialMovingAverage', 'ArgMax'), 'sequenceNextNodeArgMax': ('sequenceNextNode', 'ArgMax'), 'quantileArgMax': ('quantile', 'ArgMax'), 'groupArrayInsertAtArgMax': ('groupArrayInsertAt', 'ArgMax'), 'sumArgMax': ('sum', 'ArgMax'), 'quantileBFloat16ArgMax': ('quantileBFloat16', 'ArgMax'), 'rankCorrArgMax': ('rankCorr', 'ArgMax'), 'quantileTDigestArgMax': ('quantileTDigest', 'ArgMax'), 'maxIntersectionsPositionArgMax': ('maxIntersectionsPosition', 'ArgMax'), 'sumMapArgMax': ('sumMap', 'ArgMax'), 'kurtSampArgMax': ('kurtSamp', 'ArgMax'), 'exponentialTimeDecayedAvgArgMax': ('exponentialTimeDecayedAvg', 'ArgMax'), 'avgWeightedArgMax': ('avgWeighted', 'ArgMax'), 'topKWeightedArgMax': ('topKWeighted', 'ArgMax'), 'largestTriangleThreeBucketsArgMax': ('largestTriangleThreeBuckets', 'ArgMax'), 'groupArraySampleArgMax': ('groupArraySample', 'ArgMax'), 'quantileExactHighArgMax': ('quantileExactHigh', 'ArgMax'), 'windowFunnelArgMax': ('windowFunnel', 'ArgMax'), 'quantileExactWeightedArgMax': ('quantileExactWeighted', 'ArgMax'), 'quantileExactLowArgMax': ('quantileExactLow', 'ArgMax'), 'maxMapArgMax': ('maxMap', 'ArgMax'), 'welchTTestArgMax': ('welchTTest', 'ArgMax'), 'groupBitOrArgMax': ('groupBitOr', 'ArgMax'), 'quantilesArgMax': ('quantiles', 'ArgMax'), 'avgArgMax': ('avg', 'ArgMax'), 'cramersVArgMax': ('cramersV', 'ArgMax'), 'anyLastArgMax': ('anyLast', 'ArgMax'), 'quantilesGKArgMax': ('quantilesGK', 'ArgMax'), 'sequenceMatchArgMax': ('sequenceMatch', 'ArgMax'), 'quantilesTimingWeightedArgMax': ('quantilesTimingWeighted', 'ArgMax'), 'quantilesDeterministicArgMax': ('quantilesDeterministic', 'ArgMax'), 'sumCountArgMax': ('sumCount', 'ArgMax'), 'maxIntersectionsArgMax': ('maxIntersections', 'ArgMax'), 'stddevSampArgMax': ('stddevSamp', 'ArgMax'), 'groupBitmapAndArgMax': ('groupBitmapAnd', 'ArgMax'), 'groupArrayArgMax': ('groupArray', 'ArgMax'), 'uniqCombinedArgMax': ('uniqCombined', 'ArgMax'), 'skewSampArgMax': ('skewSamp', 'ArgMax'), 'groupBitmapArgMax': ('groupBitmap', 'ArgMax'), 'quantilesBFloat16ArgMax': ('quantilesBFloat16', 'ArgMax'), 'quantilesTDigestArgMax': ('quantilesTDigest', 'ArgMax'), 'sequenceCountArgMax': ('sequenceCount', 'ArgMax'), 'uniqCombined64ArgMax': ('uniqCombined64', 'ArgMax'), 'entropyArgMax': ('entropy', 'ArgMax'), 'quantilesTDigestWeightedArgMax': ('quantilesTDigestWeighted', 'ArgMax'), 'quantileExactArgMax': ('quantileExact', 'ArgMax'), 'categoricalInformationValueArgMax': ('categoricalInformationValue', 'ArgMax'), 'topKArgMax': ('topK', 'ArgMax'), 'groupBitAndArgMax': ('groupBitAnd', 'ArgMax'), 'stddevPopArgMax': ('stddevPop', 'ArgMax'), 'quantileBFloat16WeightedArgMax': ('quantileBFloat16Weighted', 'ArgMax'), 'quantileTimingArgMax': ('quantileTiming', 'ArgMax'), 'groupConcatArgMax': ('groupConcat', 'ArgMax'), 'corrArgMax': ('corr', 'ArgMax'), 'sumWithOverflowArgMax': ('sumWithOverflow', 'ArgMax'), 'last_valueArgMax': ('last_value', 'ArgMax'), 'argMaxArgMax': ('argMax', 'ArgMax'), 'quantilesTimingArgMax': ('quantilesTiming', 'ArgMax'), 'groupArrayMovingSumArgMax': ('groupArrayMovingSum', 'ArgMax'), 'deltaSumTimestampArgMax': ('deltaSumTimestamp', 'ArgMax'), 'quantilesBFloat16WeightedArgMax': ('quantilesBFloat16Weighted', 'ArgMax'), 'intervalLengthSumArgMax': ('intervalLengthSum', 'ArgMax'), 'sumKahanArray': ('sumKahan', 'Array'), 'quantilesExactHighArray': ('quantilesExactHigh', 'Array'), 'anyArray': ('any', 'Array'), 'uniqThetaArray': ('uniqTheta', 'Array'), 'groupBitXorArray': ('groupBitXor', 'Array'), 'theilsUArray': ('theilsU', 'Array'), 'boundingRatioArray': ('boundingRatio', 'Array'), 'histogramArray': ('histogram', 'Array'), 'kolmogorovSmirnovTestArray': ('kolmogorovSmirnovTest', 'Array'), 'groupBitmapXorArray': ('groupBitmapXor', 'Array'), 'quantileDeterministicArray': ('quantileDeterministic', 'Array'), 'varPopArray': ('varPop', 'Array'), 'first_valueArray': ('first_value', 'Array'), 'uniqHLL12Array': ('uniqHLL12', 'Array'), 'minMapArray': ('minMap', 'Array'), 'simpleLinearRegressionArray': ('simpleLinearRegression', 'Array'), 'quantilesInterpolatedWeightedArray': ('quantilesInterpolatedWeighted', 'Array'), 'maxArray': ('max', 'Array'), 'quantileTDigestWeightedArray': ('quantileTDigestWeighted', 'Array'), 'groupUniqArrayArray': ('groupUniqArray', 'Array'), 'meanZTestArray': ('meanZTest', 'Array'), 'stochasticLogisticRegressionArray': ('stochasticLogisticRegression', 'Array'), 'cramersVBiasCorrectedArray': ('cramersVBiasCorrected', 'Array'), 'covarPopArray': ('covarPop', 'Array'), 'countArray': ('count', 'Array'), 'deltaSumArray': ('deltaSum', 'Array'), 'quantileInterpolatedWeightedArray': ('quantileInterpolatedWeighted', 'Array'), 'quantileGKArray': ('quantileGK', 'Array'), 'anyHeavyArray': ('anyHeavy', 'Array'), 'uniqUpToArray': ('uniqUpTo', 'Array'), 'studentTTestArray': ('studentTTest', 'Array'), 'varSampArray': ('varSamp', 'Array'), 'groupBitmapOrArray': ('groupBitmapOr', 'Array'), 'argMinArray': ('argMin', 'Array'), 'contingencyArray': ('contingency', 'Array'), 'quantilesExactLowArray': ('quantilesExactLow', 'Array'), 'covarSampArray': ('covarSamp', 'Array'), 'mannWhitneyUTestArray': ('mannWhitneyUTest', 'Array'), 'quantilesExactWeightedArray': ('quantilesExactWeighted', 'Array'), 'quantileTimingWeightedArray': ('quantileTimingWeighted', 'Array'), 'minArray': ('min', 'Array'), 'approx_top_sumArray': ('approx_top_sum', 'Array'), 'uniqArray': ('uniq', 'Array'), 'quantilesExactArray': ('quantilesExact', 'Array'), 'retentionArray': ('retention', 'Array'), 'uniqExactArray': ('uniqExact', 'Array'), 'stochasticLinearRegressionArray': ('stochasticLinearRegression', 'Array'), 'quantilesExactExclusiveArray': ('quantilesExactExclusive', 'Array'), 'sparkBarArray': ('sparkBar', 'Array'), 'skewPopArray': ('skewPop', 'Array'), 'groupArrayMovingAvgArray': ('groupArrayMovingAvg', 'Array'), 'medianArray': ('median', 'Array'), 'groupArrayLastArray': ('groupArrayLast', 'Array'), 'kurtPopArray': ('kurtPop', 'Array'), 'exponentialMovingAverageArray': ('exponentialMovingAverage', 'Array'), 'sequenceNextNodeArray': ('sequenceNextNode', 'Array'), 'quantileArray': ('quantile', 'Array'), 'groupArrayInsertAtArray': ('groupArrayInsertAt', 'Array'), 'sumArray': ('sum', 'Array'), 'quantileBFloat16Array': ('quantileBFloat16', 'Array'), 'rankCorrArray': ('rankCorr', 'Array'), 'quantileTDigestArray': ('quantileTDigest', 'Array'), 'maxIntersectionsPositionArray': ('maxIntersectionsPosition', 'Array'), 'sumMapArray': ('sumMap', 'Array'), 'kurtSampArray': ('kurtSamp', 'Array'), 'exponentialTimeDecayedAvgArray': ('exponentialTimeDecayedAvg', 'Array'), 'avgWeightedArray': ('avgWeighted', 'Array'), 'topKWeightedArray': ('topKWeighted', 'Array'), 'largestTriangleThreeBucketsArray': ('largestTriangleThreeBuckets', 'Array'), 'groupArraySampleArray': ('groupArraySample', 'Array'), 'quantileExactHighArray': ('quantileExactHigh', 'Array'), 'windowFunnelArray': ('windowFunnel', 'Array'), 'quantileExactWeightedArray': ('quantileExactWeighted', 'Array'), 'quantileExactLowArray': ('quantileExactLow', 'Array'), 'maxMapArray': ('maxMap', 'Array'), 'welchTTestArray': ('welchTTest', 'Array'), 'groupBitOrArray': ('groupBitOr', 'Array'), 'quantilesArray': ('quantiles', 'Array'), 'avgArray': ('avg', 'Array'), 'cramersVArray': ('cramersV', 'Array'), 'anyLastArray': ('anyLast', 'Array'), 'quantilesGKArray': ('quantilesGK', 'Array'), 'sequenceMatchArray': ('sequenceMatch', 'Array'), 'quantilesTimingWeightedArray': ('quantilesTimingWeighted', 'Array'), 'quantilesDeterministicArray': ('quantilesDeterministic', 'Array'), 'sumCountArray': ('sumCount', 'Array'), 'maxIntersectionsArray': ('maxIntersections', 'Array'), 'stddevSampArray': ('stddevSamp', 'Array'), 'groupBitmapAndArray': ('groupBitmapAnd', 'Array'), 'groupArrayArray': ('groupArray', 'Array'), 'uniqCombinedArray': ('uniqCombined', 'Array'), 'skewSampArray': ('skewSamp', 'Array'), 'groupBitmapArray': ('groupBitmap', 'Array'), 'quantilesBFloat16Array': ('quantilesBFloat16', 'Array'), 'quantilesTDigestArray': ('quantilesTDigest', 'Array'), 'sequenceCountArray': ('sequenceCount', 'Array'), 'uniqCombined64Array': ('uniqCombined64', 'Array'), 'entropyArray': ('entropy', 'Array'), 'quantilesTDigestWeightedArray': ('quantilesTDigestWeighted', 'Array'), 'quantileExactArray': ('quantileExact', 'Array'), 'categoricalInformationValueArray': ('categoricalInformationValue', 'Array'), 'topKArray': ('topK', 'Array'), 'groupBitAndArray': ('groupBitAnd', 'Array'), 'stddevPopArray': ('stddevPop', 'Array'), 'quantileBFloat16WeightedArray': ('quantileBFloat16Weighted', 'Array'), 'quantileTimingArray': ('quantileTiming', 'Array'), 'groupConcatArray': ('groupConcat', 'Array'), 'corrArray': ('corr', 'Array'), 'sumWithOverflowArray': ('sumWithOverflow', 'Array'), 'last_valueArray': ('last_value', 'Array'), 'argMaxArray': ('argMax', 'Array'), 'quantilesTimingArray': ('quantilesTiming', 'Array'), 'groupArrayMovingSumArray': ('groupArrayMovingSum', 'Array'), 'deltaSumTimestampArray': ('deltaSumTimestamp', 'Array'), 'quantilesBFloat16WeightedArray': ('quantilesBFloat16Weighted', 'Array'), 'intervalLengthSumArray': ('intervalLengthSum', 'Array'), 'sumKahanState': ('sumKahan', 'State'), 'quantilesExactHighState': ('quantilesExactHigh', 'State'), 'anyState': ('any', 'State'), 'uniqThetaState': ('uniqTheta', 'State'), 'groupBitXorState': ('groupBitXor', 'State'), 'theilsUState': ('theilsU', 'State'), 'boundingRatioState': ('boundingRatio', 'State'), 'histogramState': ('histogram', 'State'), 'kolmogorovSmirnovTestState': ('kolmogorovSmirnovTest', 'State'), 'groupBitmapXorState': ('groupBitmapXor', 'State'), 'quantileDeterministicState': ('quantileDeterministic', 'State'), 'varPopState': ('varPop', 'State'), 'first_valueState': ('first_value', 'State'), 'uniqHLL12State': ('uniqHLL12', 'State'), 'minMapState': ('minMap', 'State'), 'simpleLinearRegressionState': ('simpleLinearRegression', 'State'), 'quantilesInterpolatedWeightedState': ('quantilesInterpolatedWeighted', 'State'), 'maxState': ('max', 'State'), 'quantileTDigestWeightedState': ('quantileTDigestWeighted', 'State'), 'groupUniqArrayState': ('groupUniqArray', 'State'), 'meanZTestState': ('meanZTest', 'State'), 'stochasticLogisticRegressionState': ('stochasticLogisticRegression', 'State'), 'cramersVBiasCorrectedState': ('cramersVBiasCorrected', 'State'), 'covarPopState': ('covarPop', 'State'), 'countState': ('count', 'State'), 'deltaSumState': ('deltaSum', 'State'), 'quantileInterpolatedWeightedState': ('quantileInterpolatedWeighted', 'State'), 'quantileGKState': ('quantileGK', 'State'), 'anyHeavyState': ('anyHeavy', 'State'), 'uniqUpToState': ('uniqUpTo', 'State'), 'studentTTestState': ('studentTTest', 'State'), 'varSampState': ('varSamp', 'State'), 'groupBitmapOrState': ('groupBitmapOr', 'State'), 'argMinState': ('argMin', 'State'), 'contingencyState': ('contingency', 'State'), 'quantilesExactLowState': ('quantilesExactLow', 'State'), 'covarSampState': ('covarSamp', 'State'), 'mannWhitneyUTestState': ('mannWhitneyUTest', 'State'), 'quantilesExactWeightedState': ('quantilesExactWeighted', 'State'), 'quantileTimingWeightedState': ('quantileTimingWeighted', 'State'), 'minState': ('min', 'State'), 'approx_top_sumState': ('approx_top_sum', 'State'), 'uniqState': ('uniq', 'State'), 'quantilesExactState': ('quantilesExact', 'State'), 'retentionState': ('retention', 'State'), 'uniqExactState': ('uniqExact', 'State'), 'stochasticLinearRegressionState': ('stochasticLinearRegression', 'State'), 'quantilesExactExclusiveState': ('quantilesExactExclusive', 'State'), 'sparkBarState': ('sparkBar', 'State'), 'skewPopState': ('skewPop', 'State'), 'groupArrayMovingAvgState': ('groupArrayMovingAvg', 'State'), 'medianState': ('median', 'State'), 'groupArrayLastState': ('groupArrayLast', 'State'), 'kurtPopState': ('kurtPop', 'State'), 'exponentialMovingAverageState': ('exponentialMovingAverage', 'State'), 'sequenceNextNodeState': ('sequenceNextNode', 'State'), 'quantileState': ('quantile', 'State'), 'groupArrayInsertAtState': ('groupArrayInsertAt', 'State'), 'sumState': ('sum', 'State'), 'quantileBFloat16State': ('quantileBFloat16', 'State'), 'rankCorrState': ('rankCorr', 'State'), 'quantileTDigestState': ('quantileTDigest', 'State'), 'maxIntersectionsPositionState': ('maxIntersectionsPosition', 'State'), 'sumMapState': ('sumMap', 'State'), 'kurtSampState': ('kurtSamp', 'State'), 'exponentialTimeDecayedAvgState': ('exponentialTimeDecayedAvg', 'State'), 'avgWeightedState': ('avgWeighted', 'State'), 'topKWeightedState': ('topKWeighted', 'State'), 'largestTriangleThreeBucketsState': ('largestTriangleThreeBuckets', 'State'), 'groupArraySampleState': ('groupArraySample', 'State'), 'quantileExactHighState': ('quantileExactHigh', 'State'), 'windowFunnelState': ('windowFunnel', 'State'), 'quantileExactWeightedState': ('quantileExactWeighted', 'State'), 'quantileExactLowState': ('quantileExactLow', 'State'), 'maxMapState': ('maxMap', 'State'), 'welchTTestState': ('welchTTest', 'State'), 'groupBitOrState': ('groupBitOr', 'State'), 'quantilesState': ('quantiles', 'State'), 'avgState': ('avg', 'State'), 'cramersVState': ('cramersV', 'State'), 'anyLastState': ('anyLast', 'State'), 'quantilesGKState': ('quantilesGK', 'State'), 'sequenceMatchState': ('sequenceMatch', 'State'), 'quantilesTimingWeightedState': ('quantilesTimingWeighted', 'State'), 'quantilesDeterministicState': ('quantilesDeterministic', 'State'), 'sumCountState': ('sumCount', 'State'), 'maxIntersectionsState': ('maxIntersections', 'State'), 'stddevSampState': ('stddevSamp', 'State'), 'groupBitmapAndState': ('groupBitmapAnd', 'State'), 'groupArrayState': ('groupArray', 'State'), 'uniqCombinedState': ('uniqCombined', 'State'), 'skewSampState': ('skewSamp', 'State'), 'groupBitmapState': ('groupBitmap', 'State'), 'quantilesBFloat16State': ('quantilesBFloat16', 'State'), 'quantilesTDigestState': ('quantilesTDigest', 'State'), 'sequenceCountState': ('sequenceCount', 'State'), 'uniqCombined64State': ('uniqCombined64', 'State'), 'entropyState': ('entropy', 'State'), 'quantilesTDigestWeightedState': ('quantilesTDigestWeighted', 'State'), 'quantileExactState': ('quantileExact', 'State'), 'categoricalInformationValueState': ('categoricalInformationValue', 'State'), 'topKState': ('topK', 'State'), 'groupBitAndState': ('groupBitAnd', 'State'), 'stddevPopState': ('stddevPop', 'State'), 'quantileBFloat16WeightedState': ('quantileBFloat16Weighted', 'State'), 'quantileTimingState': ('quantileTiming', 'State'), 'groupConcatState': ('groupConcat', 'State'), 'corrState': ('corr', 'State'), 'sumWithOverflowState': ('sumWithOverflow', 'State'), 'last_valueState': ('last_value', 'State'), 'argMaxState': ('argMax', 'State'), 'quantilesTimingState': ('quantilesTiming', 'State'), 'groupArrayMovingSumState': ('groupArrayMovingSum', 'State'), 'deltaSumTimestampState': ('deltaSumTimestamp', 'State'), 'quantilesBFloat16WeightedState': ('quantilesBFloat16Weighted', 'State'), 'intervalLengthSumState': ('intervalLengthSum', 'State'), 'sumKahanMerge': ('sumKahan', 'Merge'), 'quantilesExactHighMerge': ('quantilesExactHigh', 'Merge'), 'anyMerge': ('any', 'Merge'), 'uniqThetaMerge': ('uniqTheta', 'Merge'), 'groupBitXorMerge': ('groupBitXor', 'Merge'), 'theilsUMerge': ('theilsU', 'Merge'), 'boundingRatioMerge': ('boundingRatio', 'Merge'), 'histogramMerge': ('histogram', 'Merge'), 'kolmogorovSmirnovTestMerge': ('kolmogorovSmirnovTest', 'Merge'), 'groupBitmapXorMerge': ('groupBitmapXor', 'Merge'), 'quantileDeterministicMerge': ('quantileDeterministic', 'Merge'), 'varPopMerge': ('varPop', 'Merge'), 'first_valueMerge': ('first_value', 'Merge'), 'uniqHLL12Merge': ('uniqHLL12', 'Merge'), 'minMapMerge': ('minMap', 'Merge'), 'simpleLinearRegressionMerge': ('simpleLinearRegression', 'Merge'), 'quantilesInterpolatedWeightedMerge': ('quantilesInterpolatedWeighted', 'Merge'), 'maxMerge': ('max', 'Merge'), 'quantileTDigestWeightedMerge': ('quantileTDigestWeighted', 'Merge'), 'groupUniqArrayMerge': ('groupUniqArray', 'Merge'), 'meanZTestMerge': ('meanZTest', 'Merge'), 'stochasticLogisticRegressionMerge': ('stochasticLogisticRegression', 'Merge'), 'cramersVBiasCorrectedMerge': ('cramersVBiasCorrected', 'Merge'), 'covarPopMerge': ('covarPop', 'Merge'), 'countMerge': ('count', 'Merge'), 'deltaSumMerge': ('deltaSum', 'Merge'), 'quantileInterpolatedWeightedMerge': ('quantileInterpolatedWeighted', 'Merge'), 'quantileGKMerge': ('quantileGK', 'Merge'), 'anyHeavyMerge': ('anyHeavy', 'Merge'), 'uniqUpToMerge': ('uniqUpTo', 'Merge'), 'studentTTestMerge': ('studentTTest', 'Merge'), 'varSampMerge': ('varSamp', 'Merge'), 'groupBitmapOrMerge': ('groupBitmapOr', 'Merge'), 'argMinMerge': ('argMin', 'Merge'), 'contingencyMerge': ('contingency', 'Merge'), 'quantilesExactLowMerge': ('quantilesExactLow', 'Merge'), 'covarSampMerge': ('covarSamp', 'Merge'), 'mannWhitneyUTestMerge': ('mannWhitneyUTest', 'Merge'), 'quantilesExactWeightedMerge': ('quantilesExactWeighted', 'Merge'), 'quantileTimingWeightedMerge': ('quantileTimingWeighted', 'Merge'), 'minMerge': ('min', 'Merge'), 'approx_top_sumMerge': ('approx_top_sum', 'Merge'), 'uniqMerge': ('uniq', 'Merge'), 'quantilesExactMerge': ('quantilesExact', 'Merge'), 'retentionMerge': ('retention', 'Merge'), 'uniqExactMerge': ('uniqExact', 'Merge'), 'stochasticLinearRegressionMerge': ('stochasticLinearRegression', 'Merge'), 'quantilesExactExclusiveMerge': ('quantilesExactExclusive', 'Merge'), 'sparkBarMerge': ('sparkBar', 'Merge'), 'skewPopMerge': ('skewPop', 'Merge'), 'groupArrayMovingAvgMerge': ('groupArrayMovingAvg', 'Merge'), 'medianMerge': ('median', 'Merge'), 'groupArrayLastMerge': ('groupArrayLast', 'Merge'), 'kurtPopMerge': ('kurtPop', 'Merge'), 'exponentialMovingAverageMerge': ('exponentialMovingAverage', 'Merge'), 'sequenceNextNodeMerge': ('sequenceNextNode', 'Merge'), 'quantileMerge': ('quantile', 'Merge'), 'groupArrayInsertAtMerge': ('groupArrayInsertAt', 'Merge'), 'sumMerge': ('sum', 'Merge'), 'quantileBFloat16Merge': ('quantileBFloat16', 'Merge'), 'rankCorrMerge': ('rankCorr', 'Merge'), 'quantileTDigestMerge': ('quantileTDigest', 'Merge'), 'maxIntersectionsPositionMerge': ('maxIntersectionsPosition', 'Merge'), 'sumMapMerge': ('sumMap', 'Merge'), 'kurtSampMerge': ('kurtSamp', 'Merge'), 'exponentialTimeDecayedAvgMerge': ('exponentialTimeDecayedAvg', 'Merge'), 'avgWeightedMerge': ('avgWeighted', 'Merge'), 'topKWeightedMerge': ('topKWeighted', 'Merge'), 'largestTriangleThreeBucketsMerge': ('largestTriangleThreeBuckets', 'Merge'), 'groupArraySampleMerge': ('groupArraySample', 'Merge'), 'quantileExactHighMerge': ('quantileExactHigh', 'Merge'), 'windowFunnelMerge': ('windowFunnel', 'Merge'), 'quantileExactWeightedMerge': ('quantileExactWeighted', 'Merge'), 'quantileExactLowMerge': ('quantileExactLow', 'Merge'), 'maxMapMerge': ('maxMap', 'Merge'), 'welchTTestMerge': ('welchTTest', 'Merge'), 'groupBitOrMerge': ('groupBitOr', 'Merge'), 'quantilesMerge': ('quantiles', 'Merge'), 'avgMerge': ('avg', 'Merge'), 'cramersVMerge': ('cramersV', 'Merge'), 'anyLastMerge': ('anyLast', 'Merge'), 'quantilesGKMerge': ('quantilesGK', 'Merge'), 'sequenceMatchMerge': ('sequenceMatch', 'Merge'), 'quantilesTimingWeightedMerge': ('quantilesTimingWeighted', 'Merge'), 'quantilesDeterministicMerge': ('quantilesDeterministic', 'Merge'), 'sumCountMerge': ('sumCount', 'Merge'), 'maxIntersectionsMerge': ('maxIntersections', 'Merge'), 'stddevSampMerge': ('stddevSamp', 'Merge'), 'groupBitmapAndMerge': ('groupBitmapAnd', 'Merge'), 'groupArrayMerge': ('groupArray', 'Merge'), 'uniqCombinedMerge': ('uniqCombined', 'Merge'), 'skewSampMerge': ('skewSamp', 'Merge'), 'groupBitmapMerge': ('groupBitmap', 'Merge'), 'quantilesBFloat16Merge': ('quantilesBFloat16', 'Merge'), 'quantilesTDigestMerge': ('quantilesTDigest', 'Merge'), 'sequenceCountMerge': ('sequenceCount', 'Merge'), 'uniqCombined64Merge': ('uniqCombined64', 'Merge'), 'entropyMerge': ('entropy', 'Merge'), 'quantilesTDigestWeightedMerge': ('quantilesTDigestWeighted', 'Merge'), 'quantileExactMerge': ('quantileExact', 'Merge'), 'categoricalInformationValueMerge': ('categoricalInformationValue', 'Merge'), 'topKMerge': ('topK', 'Merge'), 'groupBitAndMerge': ('groupBitAnd', 'Merge'), 'stddevPopMerge': ('stddevPop', 'Merge'), 'quantileBFloat16WeightedMerge': ('quantileBFloat16Weighted', 'Merge'), 'quantileTimingMerge': ('quantileTiming', 'Merge'), 'groupConcatMerge': ('groupConcat', 'Merge'), 'corrMerge': ('corr', 'Merge'), 'sumWithOverflowMerge': ('sumWithOverflow', 'Merge'), 'last_valueMerge': ('last_value', 'Merge'), 'argMaxMerge': ('argMax', 'Merge'), 'quantilesTimingMerge': ('quantilesTiming', 'Merge'), 'groupArrayMovingSumMerge': ('groupArrayMovingSum', 'Merge'), 'deltaSumTimestampMerge': ('deltaSumTimestamp', 'Merge'), 'quantilesBFloat16WeightedMerge': ('quantilesBFloat16Weighted', 'Merge'), 'intervalLengthSumMerge': ('intervalLengthSum', 'Merge'), 'sumKahanMap': ('sumKahan', 'Map'), 'quantilesExactHighMap': ('quantilesExactHigh', 'Map'), 'anyMap': ('any', 'Map'), 'uniqThetaMap': ('uniqTheta', 'Map'), 'groupBitXorMap': ('groupBitXor', 'Map'), 'theilsUMap': ('theilsU', 'Map'), 'boundingRatioMap': ('boundingRatio', 'Map'), 'histogramMap': ('histogram', 'Map'), 'kolmogorovSmirnovTestMap': ('kolmogorovSmirnovTest', 'Map'), 'groupBitmapXorMap': ('groupBitmapXor', 'Map'), 'quantileDeterministicMap': ('quantileDeterministic', 'Map'), 'varPopMap': ('varPop', 'Map'), 'first_valueMap': ('first_value', 'Map'), 'uniqHLL12Map': ('uniqHLL12', 'Map'), 'minMapMap': ('minMap', 'Map'), 'simpleLinearRegressionMap': ('simpleLinearRegression', 'Map'), 'quantilesInterpolatedWeightedMap': ('quantilesInterpolatedWeighted', 'Map'), 'maxMap': ('maxMap', None), 'quantileTDigestWeightedMap': ('quantileTDigestWeighted', 'Map'), 'groupUniqArrayMap': ('groupUniqArray', 'Map'), 'meanZTestMap': ('meanZTest', 'Map'), 'stochasticLogisticRegressionMap': ('stochasticLogisticRegression', 'Map'), 'cramersVBiasCorrectedMap': ('cramersVBiasCorrected', 'Map'), 'covarPopMap': ('covarPop', 'Map'), 'countMap': ('count', 'Map'), 'deltaSumMap': ('deltaSum', 'Map'), 'quantileInterpolatedWeightedMap': ('quantileInterpolatedWeighted', 'Map'), 'quantileGKMap': ('quantileGK', 'Map'), 'anyHeavyMap': ('anyHeavy', 'Map'), 'uniqUpToMap': ('uniqUpTo', 'Map'), 'studentTTestMap': ('studentTTest', 'Map'), 'varSampMap': ('varSamp', 'Map'), 'groupBitmapOrMap': ('groupBitmapOr', 'Map'), 'argMinMap': ('argMin', 'Map'), 'contingencyMap': ('contingency', 'Map'), 'quantilesExactLowMap': ('quantilesExactLow', 'Map'), 'covarSampMap': ('covarSamp', 'Map'), 'mannWhitneyUTestMap': ('mannWhitneyUTest', 'Map'), 'quantilesExactWeightedMap': ('quantilesExactWeighted', 'Map'), 'quantileTimingWeightedMap': ('quantileTimingWeighted', 'Map'), 'minMap': ('minMap', None), 'approx_top_sumMap': ('approx_top_sum', 'Map'), 'uniqMap': ('uniq', 'Map'), 'quantilesExactMap': ('quantilesExact', 'Map'), 'retentionMap': ('retention', 'Map'), 'uniqExactMap': ('uniqExact', 'Map'), 'stochasticLinearRegressionMap': ('stochasticLinearRegression', 'Map'), 'quantilesExactExclusiveMap': ('quantilesExactExclusive', 'Map'), 'sparkBarMap': ('sparkBar', 'Map'), 'skewPopMap': ('skewPop', 'Map'), 'groupArrayMovingAvgMap': ('groupArrayMovingAvg', 'Map'), 'medianMap': ('median', 'Map'), 'groupArrayLastMap': ('groupArrayLast', 'Map'), 'kurtPopMap': ('kurtPop', 'Map'), 'exponentialMovingAverageMap': ('exponentialMovingAverage', 'Map'), 'sequenceNextNodeMap': ('sequenceNextNode', 'Map'), 'quantileMap': ('quantile', 'Map'), 'groupArrayInsertAtMap': ('groupArrayInsertAt', 'Map'), 'sumMap': ('sumMap', None), 'quantileBFloat16Map': ('quantileBFloat16', 'Map'), 'rankCorrMap': ('rankCorr', 'Map'), 'quantileTDigestMap': ('quantileTDigest', 'Map'), 'maxIntersectionsPositionMap': ('maxIntersectionsPosition', 'Map'), 'sumMapMap': ('sumMap', 'Map'), 'kurtSampMap': ('kurtSamp', 'Map'), 'exponentialTimeDecayedAvgMap': ('exponentialTimeDecayedAvg', 'Map'), 'avgWeightedMap': ('avgWeighted', 'Map'), 'topKWeightedMap': ('topKWeighted', 'Map'), 'largestTriangleThreeBucketsMap': ('largestTriangleThreeBuckets', 'Map'), 'groupArraySampleMap': ('groupArraySample', 'Map'), 'quantileExactHighMap': ('quantileExactHigh', 'Map'), 'windowFunnelMap': ('windowFunnel', 'Map'), 'quantileExactWeightedMap': ('quantileExactWeighted', 'Map'), 'quantileExactLowMap': ('quantileExactLow', 'Map'), 'maxMapMap': ('maxMap', 'Map'), 'welchTTestMap': ('welchTTest', 'Map'), 'groupBitOrMap': ('groupBitOr', 'Map'), 'quantilesMap': ('quantiles', 'Map'), 'avgMap': ('avg', 'Map'), 'cramersVMap': ('cramersV', 'Map'), 'anyLastMap': ('anyLast', 'Map'), 'quantilesGKMap': ('quantilesGK', 'Map'), 'sequenceMatchMap': ('sequenceMatch', 'Map'), 'quantilesTimingWeightedMap': ('quantilesTimingWeighted', 'Map'), 'quantilesDeterministicMap': ('quantilesDeterministic', 'Map'), 'sumCountMap': ('sumCount', 'Map'), 'maxIntersectionsMap': ('maxIntersections', 'Map'), 'stddevSampMap': ('stddevSamp', 'Map'), 'groupBitmapAndMap': ('groupBitmapAnd', 'Map'), 'groupArrayMap': ('groupArray', 'Map'), 'uniqCombinedMap': ('uniqCombined', 'Map'), 'skewSampMap': ('skewSamp', 'Map'), 'groupBitmapMap': ('groupBitmap', 'Map'), 'quantilesBFloat16Map': ('quantilesBFloat16', 'Map'), 'quantilesTDigestMap': ('quantilesTDigest', 'Map'), 'sequenceCountMap': ('sequenceCount', 'Map'), 'uniqCombined64Map': ('uniqCombined64', 'Map'), 'entropyMap': ('entropy', 'Map'), 'quantilesTDigestWeightedMap': ('quantilesTDigestWeighted', 'Map'), 'quantileExactMap': ('quantileExact', 'Map'), 'categoricalInformationValueMap': ('categoricalInformationValue', 'Map'), 'topKMap': ('topK', 'Map'), 'groupBitAndMap': ('groupBitAnd', 'Map'), 'stddevPopMap': ('stddevPop', 'Map'), 'quantileBFloat16WeightedMap': ('quantileBFloat16Weighted', 'Map'), 'quantileTimingMap': ('quantileTiming', 'Map'), 'groupConcatMap': ('groupConcat', 'Map'), 'corrMap': ('corr', 'Map'), 'sumWithOverflowMap': ('sumWithOverflow', 'Map'), 'last_valueMap': ('last_value', 'Map'), 'argMaxMap': ('argMax', 'Map'), 'quantilesTimingMap': ('quantilesTiming', 'Map'), 'groupArrayMovingSumMap': ('groupArrayMovingSum', 'Map'), 'deltaSumTimestampMap': ('deltaSumTimestamp', 'Map'), 'quantilesBFloat16WeightedMap': ('quantilesBFloat16Weighted', 'Map'), 'intervalLengthSumMap': ('intervalLengthSum', 'Map'), 'sumKahanIf': ('sumKahan', 'If'), 'quantilesExactHighIf': ('quantilesExactHigh', 'If'), 'anyIf': ('any', 'If'), 'uniqThetaIf': ('uniqTheta', 'If'), 'groupBitXorIf': ('groupBitXor', 'If'), 'theilsUIf': ('theilsU', 'If'), 'boundingRatioIf': ('boundingRatio', 'If'), 'histogramIf': ('histogram', 'If'), 'kolmogorovSmirnovTestIf': ('kolmogorovSmirnovTest', 'If'), 'groupBitmapXorIf': ('groupBitmapXor', 'If'), 'quantileDeterministicIf': ('quantileDeterministic', 'If'), 'varPopIf': ('varPop', 'If'), 'first_valueIf': ('first_value', 'If'), 'uniqHLL12If': ('uniqHLL12', 'If'), 'minMapIf': ('minMap', 'If'), 'simpleLinearRegressionIf': ('simpleLinearRegression', 'If'), 'quantilesInterpolatedWeightedIf': ('quantilesInterpolatedWeighted', 'If'), 'maxIf': ('max', 'If'), 'quantileTDigestWeightedIf': ('quantileTDigestWeighted', 'If'), 'groupUniqArrayIf': ('groupUniqArray', 'If'), 'meanZTestIf': ('meanZTest', 'If'), 'stochasticLogisticRegressionIf': ('stochasticLogisticRegression', 'If'), 'cramersVBiasCorrectedIf': ('cramersVBiasCorrected', 'If'), 'covarPopIf': ('covarPop', 'If'), 'countIf': ('count', 'If'), 'deltaSumIf': ('deltaSum', 'If'), 'quantileInterpolatedWeightedIf': ('quantileInterpolatedWeighted', 'If'), 'quantileGKIf': ('quantileGK', 'If'), 'anyHeavyIf': ('anyHeavy', 'If'), 'uniqUpToIf': ('uniqUpTo', 'If'), 'studentTTestIf': ('studentTTest', 'If'), 'varSampIf': ('varSamp', 'If'), 'groupBitmapOrIf': ('groupBitmapOr', 'If'), 'argMinIf': ('argMin', 'If'), 'contingencyIf': ('contingency', 'If'), 'quantilesExactLowIf': ('quantilesExactLow', 'If'), 'covarSampIf': ('covarSamp', 'If'), 'mannWhitneyUTestIf': ('mannWhitneyUTest', 'If'), 'quantilesExactWeightedIf': ('quantilesExactWeighted', 'If'), 'quantileTimingWeightedIf': ('quantileTimingWeighted', 'If'), 'minIf': ('min', 'If'), 'approx_top_sumIf': ('approx_top_sum', 'If'), 'uniqIf': ('uniq', 'If'), 'quantilesExactIf': ('quantilesExact', 'If'), 'retentionIf': ('retention', 'If'), 'uniqExactIf': ('uniqExact', 'If'), 'stochasticLinearRegressionIf': ('stochasticLinearRegression', 'If'), 'quantilesExactExclusiveIf': ('quantilesExactExclusive', 'If'), 'sparkBarIf': ('sparkBar', 'If'), 'skewPopIf': ('skewPop', 'If'), 'groupArrayMovingAvgIf': ('groupArrayMovingAvg', 'If'), 'medianIf': ('median', 'If'), 'groupArrayLastIf': ('groupArrayLast', 'If'), 'kurtPopIf': ('kurtPop', 'If'), 'exponentialMovingAverageIf': ('exponentialMovingAverage', 'If'), 'sequenceNextNodeIf': ('sequenceNextNode', 'If'), 'quantileIf': ('quantile', 'If'), 'groupArrayInsertAtIf': ('groupArrayInsertAt', 'If'), 'sumIf': ('sum', 'If'), 'quantileBFloat16If': ('quantileBFloat16', 'If'), 'rankCorrIf': ('rankCorr', 'If'), 'quantileTDigestIf': ('quantileTDigest', 'If'), 'maxIntersectionsPositionIf': ('maxIntersectionsPosition', 'If'), 'sumMapIf': ('sumMap', 'If'), 'kurtSampIf': ('kurtSamp', 'If'), 'exponentialTimeDecayedAvgIf': ('exponentialTimeDecayedAvg', 'If'), 'avgWeightedIf': ('avgWeighted', 'If'), 'topKWeightedIf': ('topKWeighted', 'If'), 'largestTriangleThreeBucketsIf': ('largestTriangleThreeBuckets', 'If'), 'groupArraySampleIf': ('groupArraySample', 'If'), 'quantileExactHighIf': ('quantileExactHigh', 'If'), 'windowFunnelIf': ('windowFunnel', 'If'), 'quantileExactWeightedIf': ('quantileExactWeighted', 'If'), 'quantileExactLowIf': ('quantileExactLow', 'If'), 'maxMapIf': ('maxMap', 'If'), 'welchTTestIf': ('welchTTest', 'If'), 'groupBitOrIf': ('groupBitOr', 'If'), 'quantilesIf': ('quantiles', 'If'), 'avgIf': ('avg', 'If'), 'cramersVIf': ('cramersV', 'If'), 'anyLastIf': ('anyLast', 'If'), 'quantilesGKIf': ('quantilesGK', 'If'), 'sequenceMatchIf': ('sequenceMatch', 'If'), 'quantilesTimingWeightedIf': ('quantilesTimingWeighted', 'If'), 'quantilesDeterministicIf': ('quantilesDeterministic', 'If'), 'sumCountIf': ('sumCount', 'If'), 'maxIntersectionsIf': ('maxIntersections', 'If'), 'stddevSampIf': ('stddevSamp', 'If'), 'groupBitmapAndIf': ('groupBitmapAnd', 'If'), 'groupArrayIf': ('groupArray', 'If'), 'uniqCombinedIf': ('uniqCombined', 'If'), 'skewSampIf': ('skewSamp', 'If'), 'groupBitmapIf': ('groupBitmap', 'If'), 'quantilesBFloat16If': ('quantilesBFloat16', 'If'), 'quantilesTDigestIf': ('quantilesTDigest', 'If'), 'sequenceCountIf': ('sequenceCount', 'If'), 'uniqCombined64If': ('uniqCombined64', 'If'), 'entropyIf': ('entropy', 'If'), 'quantilesTDigestWeightedIf': ('quantilesTDigestWeighted', 'If'), 'quantileExactIf': ('quantileExact', 'If'), 'categoricalInformationValueIf': ('categoricalInformationValue', 'If'), 'topKIf': ('topK', 'If'), 'groupBitAndIf': ('groupBitAnd', 'If'), 'stddevPopIf': ('stddevPop', 'If'), 'quantileBFloat16WeightedIf': ('quantileBFloat16Weighted', 'If'), 'quantileTimingIf': ('quantileTiming', 'If'), 'groupConcatIf': ('groupConcat', 'If'), 'corrIf': ('corr', 'If'), 'sumWithOverflowIf': ('sumWithOverflow', 'If'), 'last_valueIf': ('last_value', 'If'), 'argMaxIf': ('argMax', 'If'), 'quantilesTimingIf': ('quantilesTiming', 'If'), 'groupArrayMovingSumIf': ('groupArrayMovingSum', 'If'), 'deltaSumTimestampIf': ('deltaSumTimestamp', 'If'), 'quantilesBFloat16WeightedIf': ('quantilesBFloat16Weighted', 'If'), 'intervalLengthSumIf': ('intervalLengthSum', 'If'), 'sumKahan': ('sumKahan', None), 'quantilesExactHigh': ('quantilesExactHigh', None), 'any': ('any', None), 'uniqTheta': ('uniqTheta', None), 'groupBitXor': ('groupBitXor', None), 'theilsU': ('theilsU', None), 'boundingRatio': ('boundingRatio', None), 'histogram': ('histogram', None), 'kolmogorovSmirnovTest': ('kolmogorovSmirnovTest', None), 'groupBitmapXor': ('groupBitmapXor', None), 'quantileDeterministic': ('quantileDeterministic', None), 'varPop': ('varPop', None), 'first_value': ('first_value', None), 'uniqHLL12': ('uniqHLL12', None), 'simpleLinearRegression': ('simpleLinearRegression', None), 'quantilesInterpolatedWeighted': ('quantilesInterpolatedWeighted', None), 'max': ('max', None), 'quantileTDigestWeighted': ('quantileTDigestWeighted', None), 'groupUniqArray': ('groupUniqArray', None), 'meanZTest': ('meanZTest', None), 'stochasticLogisticRegression': ('stochasticLogisticRegression', None), 'cramersVBiasCorrected': ('cramersVBiasCorrected', None), 'covarPop': ('covarPop', None), 'count': ('count', None), 'deltaSum': ('deltaSum', None), 'quantileInterpolatedWeighted': ('quantileInterpolatedWeighted', None), 'quantileGK': ('quantileGK', None), 'anyHeavy': ('anyHeavy', None), 'uniqUpTo': ('uniqUpTo', None), 'studentTTest': ('studentTTest', None), 'varSamp': ('varSamp', None), 'groupBitmapOr': ('groupBitmapOr', None), 'argMin': ('argMin', None), 'contingency': ('contingency', None), 'quantilesExactLow': ('quantilesExactLow', None), 'covarSamp': ('covarSamp', None), 'mannWhitneyUTest': ('mannWhitneyUTest', None), 'quantilesExactWeighted': ('quantilesExactWeighted', None), 'quantileTimingWeighted': ('quantileTimingWeighted', None), 'min': ('min', None), 'approx_top_sum': ('approx_top_sum', None), 'uniq': ('uniq', None), 'quantilesExact': ('quantilesExact', None), 'retention': ('retention', None), 'uniqExact': ('uniqExact', None), 'stochasticLinearRegression': ('stochasticLinearRegression', None), 'quantilesExactExclusive': ('quantilesExactExclusive', None), 'sparkBar': ('sparkBar', None), 'skewPop': ('skewPop', None), 'groupArrayMovingAvg': ('groupArrayMovingAvg', None), 'median': ('median', None), 'groupArrayLast': ('groupArrayLast', None), 'kurtPop': ('kurtPop', None), 'exponentialMovingAverage': ('exponentialMovingAverage', None), 'sequenceNextNode': ('sequenceNextNode', None), 'quantile': ('quantile', None), 'groupArrayInsertAt': ('groupArrayInsertAt', None), 'sum': ('sum', None), 'quantileBFloat16': ('quantileBFloat16', None), 'rankCorr': ('rankCorr', None), 'quantileTDigest': ('quantileTDigest', None), 'maxIntersectionsPosition': ('maxIntersectionsPosition', None), 'kurtSamp': ('kurtSamp', None), 'exponentialTimeDecayedAvg': ('exponentialTimeDecayedAvg', None), 'avgWeighted': ('avgWeighted', None), 'topKWeighted': ('topKWeighted', None), 'largestTriangleThreeBuckets': ('largestTriangleThreeBuckets', None), 'groupArraySample': ('groupArraySample', None), 'quantileExactHigh': ('quantileExactHigh', None), 'windowFunnel': ('windowFunnel', None), 'quantileExactWeighted': ('quantileExactWeighted', None), 'quantileExactLow': ('quantileExactLow', None), 'welchTTest': ('welchTTest', None), 'groupBitOr': ('groupBitOr', None), 'quantiles': ('quantiles', None), 'avg': ('avg', None), 'cramersV': ('cramersV', None), 'anyLast': ('anyLast', None), 'quantilesGK': ('quantilesGK', None), 'sequenceMatch': ('sequenceMatch', None), 'quantilesTimingWeighted': ('quantilesTimingWeighted', None), 'quantilesDeterministic': ('quantilesDeterministic', None), 'sumCount': ('sumCount', None), 'maxIntersections': ('maxIntersections', None), 'stddevSamp': ('stddevSamp', None), 'groupBitmapAnd': ('groupBitmapAnd', None), 'groupArray': ('groupArray', None), 'uniqCombined': ('uniqCombined', None), 'skewSamp': ('skewSamp', None), 'groupBitmap': ('groupBitmap', None), 'quantilesBFloat16': ('quantilesBFloat16', None), 'quantilesTDigest': ('quantilesTDigest', None), 'sequenceCount': ('sequenceCount', None), 'uniqCombined64': ('uniqCombined64', None), 'entropy': ('entropy', None), 'quantilesTDigestWeighted': ('quantilesTDigestWeighted', None), 'quantileExact': ('quantileExact', None), 'categoricalInformationValue': ('categoricalInformationValue', None), 'topK': ('topK', None), 'groupBitAnd': ('groupBitAnd', None), 'stddevPop': ('stddevPop', None), 'quantileBFloat16Weighted': ('quantileBFloat16Weighted', None), 'quantileTiming': ('quantileTiming', None), 'groupConcat': ('groupConcat', None), 'corr': ('corr', None), 'sumWithOverflow': ('sumWithOverflow', None), 'last_value': ('last_value', None), 'argMax': ('argMax', None), 'quantilesTiming': ('quantilesTiming', None), 'groupArrayMovingSum': ('groupArrayMovingSum', None), 'deltaSumTimestamp': ('deltaSumTimestamp', None), 'quantilesBFloat16Weighted': ('quantilesBFloat16Weighted', None), 'intervalLengthSum': ('intervalLengthSum', None)}
FUNCTION_PARSERS = {'ARG_MAX': <function Parser.<dictcomp>.<lambda>>, 'ARGMAX': <function Parser.<dictcomp>.<lambda>>, 'MAX_BY': <function Parser.<dictcomp>.<lambda>>, 'ARG_MIN': <function Parser.<dictcomp>.<lambda>>, 'ARGMIN': <function Parser.<dictcomp>.<lambda>>, 'MIN_BY': <function Parser.<dictcomp>.<lambda>>, 'CAST': <function Parser.<lambda>>, 'CEIL': <function Parser.<lambda>>, 'CONVERT': <function Parser.<lambda>>, 'CHAR': <function Parser.<lambda>>, 'CHR': <function Parser.<lambda>>, 'DECODE': <function Parser.<lambda>>, 'EXTRACT': <function Parser.<lambda>>, 'FLOOR': <function Parser.<lambda>>, 'GAP_FILL': <function Parser.<lambda>>, 'INITCAP': <function Parser.<lambda>>, 'JSON_OBJECT': <function Parser.<lambda>>, 'JSON_OBJECTAGG': <function Parser.<lambda>>, 'JSON_TABLE': <function Parser.<lambda>>, 'NORMALIZE': <function Parser.<lambda>>, 'OPENJSON': <function Parser.<lambda>>, 'OVERLAY': <function Parser.<lambda>>, 'POSITION': <function Parser.<lambda>>, 'SAFE_CAST': <function Parser.<lambda>>, 'STRING_AGG': <function Parser.<lambda>>, 'SUBSTRING': <function Parser.<lambda>>, 'TRIM': <function Parser.<lambda>>, 'TRY_CAST': <function Parser.<lambda>>, 'TRY_CONVERT': <function Parser.<lambda>>, 'XMLELEMENT': <function Parser.<lambda>>, 'XMLTABLE': <function Parser.<lambda>>, 'ARRAYJOIN': <function ClickHouseParser.<lambda>>, 'GROUPCONCAT': <function ClickHouseParser.<lambda>>, 'QUANTILE': <function ClickHouseParser.<lambda>>, 'MEDIAN': <function ClickHouseParser.<lambda>>, 'COLUMNS': <function ClickHouseParser.<lambda>>, 'TUPLE': <function ClickHouseParser.<lambda>>, 'AND': <function ClickHouseParser.<lambda>>, 'OR': <function ClickHouseParser.<lambda>>, 'XOR': <function ClickHouseParser.<lambda>>}
PROPERTY_PARSERS = {'ALLOWED_VALUES': <function Parser.<lambda>>, 'ALGORITHM': <function Parser.<lambda>>, 'AUTO': <function Parser.<lambda>>, 'AUTO_INCREMENT': <function Parser.<lambda>>, 'BACKUP': <function Parser.<lambda>>, 'BLOCKCOMPRESSION': <function Parser.<lambda>>, 'CHARSET': <function Parser.<lambda>>, 'CHARACTER SET': <function Parser.<lambda>>, 'CHECKSUM': <function Parser.<lambda>>, 'CLUSTER BY': <function Parser.<lambda>>, 'CLUSTERED': <function Parser.<lambda>>, 'COLLATE': <function Parser.<lambda>>, 'COMMENT': <function Parser.<lambda>>, 'CONTAINS': <function Parser.<lambda>>, 'COPY': <function Parser.<lambda>>, 'DATABLOCKSIZE': <function Parser.<lambda>>, 'DATA_DELETION': <function Parser.<lambda>>, 'DEFINER': <function Parser.<lambda>>, 'DETERMINISTIC': <function Parser.<lambda>>, 'DISTRIBUTED': <function Parser.<lambda>>, 'DUPLICATE': <function Parser.<lambda>>, 'DISTKEY': <function Parser.<lambda>>, 'DISTSTYLE': <function Parser.<lambda>>, 'EMPTY': <function Parser.<lambda>>, 'ENGINE': <function ClickHouseParser.<lambda>>, 'ENVIRONMENT': <function Parser.<lambda>>, 'HANDLER': <function Parser.<lambda>>, 'EXECUTE': <function Parser.<lambda>>, 'EXTERNAL': <function Parser.<lambda>>, 'FALLBACK': <function Parser.<lambda>>, 'FORMAT': <function Parser.<lambda>>, 'FREESPACE': <function Parser.<lambda>>, 'GLOBAL': <function Parser.<lambda>>, 'HEAP': <function Parser.<lambda>>, 'ICEBERG': <function Parser.<lambda>>, 'IMMUTABLE': <function Parser.<lambda>>, 'INHERITS': <function Parser.<lambda>>, 'INPUT': <function Parser.<lambda>>, 'JOURNAL': <function Parser.<lambda>>, 'LANGUAGE': <function Parser.<lambda>>, 'LAYOUT': <function Parser.<lambda>>, 'LIFETIME': <function Parser.<lambda>>, 'LIKE': <function Parser.<lambda>>, 'LOCATION': <function Parser.<lambda>>, 'LOCK': <function Parser.<lambda>>, 'LOCKING': <function Parser.<lambda>>, 'LOG': <function Parser.<lambda>>, 'MATERIALIZED': <function Parser.<lambda>>, 'MERGEBLOCKRATIO': <function Parser.<lambda>>, 'MODIFIES': <function Parser.<lambda>>, 'MULTISET': <function Parser.<lambda>>, 'NO': <function Parser.<lambda>>, 'ON': <function Parser.<lambda>>, 'ORDER BY': <function Parser.<lambda>>, 'OUTPUT': <function Parser.<lambda>>, 'PARTITION': <function Parser.<lambda>>, 'PARTITION BY': <function Parser.<lambda>>, 'PARTITIONED BY': <function Parser.<lambda>>, 'PARTITIONED_BY': <function Parser.<lambda>>, 'PRIMARY KEY': <function Parser.<lambda>>, 'RANGE': <function Parser.<lambda>>, 'READS': <function Parser.<lambda>>, 'REMOTE': <function Parser.<lambda>>, 'RETURNS': <function Parser.<lambda>>, 'STRICT': <function Parser.<lambda>>, 'STREAMING': <function Parser.<lambda>>, 'ROW': <function Parser.<lambda>>, 'ROW_FORMAT': <function Parser.<lambda>>, 'SAMPLE': <function Parser.<lambda>>, 'SECURE': <function Parser.<lambda>>, 'SECURITY': <function Parser.<lambda>>, 'SQL SECURITY': <function Parser.<lambda>>, 'SET': <function Parser.<lambda>>, 'SETTINGS': <function Parser.<lambda>>, 'SHARING': <function Parser.<lambda>>, 'SORTKEY': <function Parser.<lambda>>, 'SOURCE': <function Parser.<lambda>>, 'STABLE': <function Parser.<lambda>>, 'STORED': <function Parser.<lambda>>, 'SYSTEM_VERSIONING': <function Parser.<lambda>>, 'TBLPROPERTIES': <function Parser.<lambda>>, 'TEMP': <function Parser.<lambda>>, 'TEMPORARY': <function Parser.<lambda>>, 'TO': <function Parser.<lambda>>, 'TRANSIENT': <function Parser.<lambda>>, 'TRANSFORM': <function Parser.<lambda>>, 'TTL': <function Parser.<lambda>>, 'USING': <function Parser.<lambda>>, 'UNLOGGED': <function Parser.<lambda>>, 'VOLATILE': <function Parser.<lambda>>, 'WITH': <function Parser.<lambda>>, 'UUID': <function ClickHouseParser.<lambda>>}
NO_PAREN_FUNCTION_PARSERS = {'CASE': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <function Parser.<lambda>>, 'IF': <function Parser.<lambda>>}
NO_PAREN_FUNCTIONS = {<TokenType.CURRENT_DATE: 245>: <class 'sqlglot.expressions.temporal.CurrentDate'>, <TokenType.CURRENT_DATETIME: 246>: <class 'sqlglot.expressions.temporal.CurrentDate'>, <TokenType.CURRENT_TIME: 248>: <class 'sqlglot.expressions.temporal.CurrentTime'>, <TokenType.CURRENT_USER: 250>: <class 'sqlglot.expressions.functions.CurrentUser'>, <TokenType.CURRENT_ROLE: 252>: <class 'sqlglot.expressions.functions.CurrentRole'>}
RANGE_PARSERS = {<TokenType.AT_GT: 55>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.BETWEEN: 229>: <function Parser.<lambda>>, <TokenType.GLOB: 286>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.ILIKE: 294>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IN: 295>: <function Parser.<lambda>>, <TokenType.IRLIKE: 306>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IS: 307>: <function Parser.<lambda>>, <TokenType.LIKE: 317>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.LT_AT: 54>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.OVERLAPS: 348>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.RLIKE: 378>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.SIMILAR_TO: 393>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.FOR: 278>: <function Parser.<lambda>>, <TokenType.QMARK_AMP: 67>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.QMARK_PIPE: 68>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.HASH_DASH: 69>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.ADJACENT: 64>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.OPERATOR: 339>: <function Parser.<lambda>>, <TokenType.AMP_LT: 62>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.AMP_GT: 63>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.GLOBAL: 287>: <function ClickHouseParser.<lambda>>}
COLUMN_OPERATORS = {<TokenType.DOT: 8>: None, <TokenType.DOTCOLON: 12>: <function Parser.<lambda>>, <TokenType.DCOLON: 14>: <function Parser.<lambda>>, <TokenType.ARROW: 45>: <function Parser.<lambda>>, <TokenType.DARROW: 46>: <function Parser.<lambda>>, <TokenType.HASH_ARROW: 49>: <function Parser.<lambda>>, <TokenType.DHASH_ARROW: 50>: <function Parser.<lambda>>, <TokenType.DOTCARET: 13>: <function ClickHouseParser.<lambda>>}
JOIN_KINDS = {<TokenType.SEMI: 386>, <TokenType.STRAIGHT_JOIN: 400>, <TokenType.OUTER: 346>, <TokenType.ALL: 219>, <TokenType.ANTI: 220>, <TokenType.ANY: 221>, <TokenType.ARRAY: 223>, <TokenType.ASOF: 225>, <TokenType.INNER: 298>, <TokenType.CROSS: 243>}
TABLE_ALIAS_TOKENS = {<TokenType.SESSION: 58>, <TokenType.SESSION_USER: 60>, <TokenType.IDENTIFIER: 78>, <TokenType.DATABASE: 79>, <TokenType.COLUMN: 80>, <TokenType.SCHEMA: 82>, <TokenType.TABLE: 83>, <TokenType.WAREHOUSE: 84>, <TokenType.STAGE: 85>, <TokenType.STREAM: 86>, <TokenType.STREAMLIT: 87>, <TokenType.VAR: 88>, <TokenType.BIT: 96>, <TokenType.BOOLEAN: 97>, <TokenType.TINYINT: 98>, <TokenType.UTINYINT: 99>, <TokenType.SMALLINT: 100>, <TokenType.USMALLINT: 101>, <TokenType.MEDIUMINT: 102>, <TokenType.UMEDIUMINT: 103>, <TokenType.INT: 104>, <TokenType.UINT: 105>, <TokenType.BIGINT: 106>, <TokenType.UBIGINT: 107>, <TokenType.BIGNUM: 108>, <TokenType.INT128: 109>, <TokenType.UINT128: 110>, <TokenType.INT256: 111>, <TokenType.UINT256: 112>, <TokenType.FLOAT: 113>, <TokenType.DOUBLE: 114>, <TokenType.UDOUBLE: 115>, <TokenType.DECIMAL: 116>, <TokenType.DECIMAL32: 117>, <TokenType.DECIMAL64: 118>, <TokenType.DECIMAL128: 119>, <TokenType.DECIMAL256: 120>, <TokenType.DECFLOAT: 121>, <TokenType.UDECIMAL: 122>, <TokenType.BIGDECIMAL: 123>, <TokenType.CHAR: 124>, <TokenType.NCHAR: 125>, <TokenType.VARCHAR: 126>, <TokenType.NVARCHAR: 127>, <TokenType.BPCHAR: 128>, <TokenType.TEXT: 129>, <TokenType.MEDIUMTEXT: 130>, <TokenType.LONGTEXT: 131>, <TokenType.BLOB: 132>, <TokenType.MEDIUMBLOB: 133>, <TokenType.LONGBLOB: 134>, <TokenType.TINYBLOB: 135>, <TokenType.TINYTEXT: 136>, <TokenType.NAME: 137>, <TokenType.BINARY: 138>, <TokenType.VARBINARY: 139>, <TokenType.JSON: 140>, <TokenType.JSONB: 141>, <TokenType.TIME: 142>, <TokenType.TIMETZ: 143>, <TokenType.TIME_NS: 144>, <TokenType.TIMESTAMP: 145>, <TokenType.TIMESTAMPTZ: 146>, <TokenType.TIMESTAMPLTZ: 147>, <TokenType.TIMESTAMPNTZ: 148>, <TokenType.TIMESTAMP_S: 149>, <TokenType.TIMESTAMP_MS: 150>, <TokenType.TIMESTAMP_NS: 151>, <TokenType.DATETIME: 152>, <TokenType.DATETIME2: 153>, <TokenType.DATETIME64: 154>, <TokenType.SMALLDATETIME: 155>, <TokenType.DATE: 156>, <TokenType.DATE32: 157>, <TokenType.INT4RANGE: 158>, <TokenType.INT4MULTIRANGE: 159>, <TokenType.INT8RANGE: 160>, <TokenType.INT8MULTIRANGE: 161>, <TokenType.NUMRANGE: 162>, <TokenType.NUMMULTIRANGE: 163>, <TokenType.TSRANGE: 164>, <TokenType.TSMULTIRANGE: 165>, <TokenType.TSTZRANGE: 166>, <TokenType.TSTZMULTIRANGE: 167>, <TokenType.DATERANGE: 168>, <TokenType.DATEMULTIRANGE: 169>, <TokenType.UUID: 170>, <TokenType.GEOGRAPHY: 171>, <TokenType.GEOGRAPHYPOINT: 172>, <TokenType.NULLABLE: 173>, <TokenType.GEOMETRY: 174>, <TokenType.POINT: 175>, <TokenType.RING: 176>, <TokenType.LINESTRING: 177>, <TokenType.LOCALTIME: 178>, <TokenType.LOCALTIMESTAMP: 179>, <TokenType.MULTILINESTRING: 181>, <TokenType.POLYGON: 182>, <TokenType.MULTIPOLYGON: 183>, <TokenType.HLLSKETCH: 184>, <TokenType.HSTORE: 185>, <TokenType.SUPER: 186>, <TokenType.SERIAL: 187>, <TokenType.SMALLSERIAL: 188>, <TokenType.BIGSERIAL: 189>, <TokenType.XML: 190>, <TokenType.YEAR: 191>, <TokenType.USERDEFINED: 192>, <TokenType.MONEY: 193>, <TokenType.SMALLMONEY: 194>, <TokenType.ROWVERSION: 195>, <TokenType.IMAGE: 196>, <TokenType.VARIANT: 197>, <TokenType.OBJECT: 198>, <TokenType.INET: 199>, <TokenType.IPADDRESS: 200>, <TokenType.IPPREFIX: 201>, <TokenType.IPV4: 202>, <TokenType.IPV6: 203>, <TokenType.ENUM: 204>, <TokenType.ENUM8: 205>, <TokenType.ENUM16: 206>, <TokenType.FIXEDSTRING: 207>, <TokenType.LOWCARDINALITY: 208>, <TokenType.NESTED: 209>, <TokenType.AGGREGATEFUNCTION: 210>, <TokenType.SIMPLEAGGREGATEFUNCTION: 211>, <TokenType.TDIGEST: 212>, <TokenType.UNKNOWN: 213>, <TokenType.VECTOR: 214>, <TokenType.DYNAMIC: 215>, <TokenType.VOID: 216>, <TokenType.APPLY: 222>, <TokenType.ASC: 224>, <TokenType.ATTACH: 226>, <TokenType.AUTO_INCREMENT: 227>, <TokenType.BEGIN: 228>, <TokenType.CACHE: 231>, <TokenType.CASE: 232>, <TokenType.COLLATE: 235>, <TokenType.COMMAND: 236>, <TokenType.COMMENT: 237>, <TokenType.COMMIT: 238>, <TokenType.CONSTRAINT: 240>, <TokenType.COPY: 241>, <TokenType.CUBE: 244>, <TokenType.CURRENT_DATE: 245>, <TokenType.CURRENT_DATETIME: 246>, <TokenType.CURRENT_SCHEMA: 247>, <TokenType.CURRENT_TIME: 248>, <TokenType.CURRENT_TIMESTAMP: 249>, <TokenType.CURRENT_USER: 250>, <TokenType.CURRENT_ROLE: 252>, <TokenType.CURRENT_CATALOG: 253>, <TokenType.DEFAULT: 255>, <TokenType.DELETE: 256>, <TokenType.DESC: 257>, <TokenType.DESCRIBE: 258>, <TokenType.DETACH: 259>, <TokenType.DICTIONARY: 260>, <TokenType.DIV: 263>, <TokenType.END: 266>, <TokenType.ESCAPE: 267>, <TokenType.EXECUTE: 269>, <TokenType.EXISTS: 270>, <TokenType.FALSE: 271>, <TokenType.FILE: 273>, <TokenType.FILE_FORMAT: 274>, <TokenType.FILTER: 275>, <TokenType.FIRST: 277>, <TokenType.FOREIGN_KEY: 280>, <TokenType.FUNCTION: 284>, <TokenType.GET: 285>, <TokenType.INDEX: 296>, <TokenType.INTERVAL: 303>, <TokenType.IS: 307>, <TokenType.ISNULL: 308>, <TokenType.KEEP: 311>, <TokenType.KILL: 313>, <TokenType.LIMIT: 318>, <TokenType.LIST: 319>, <TokenType.LOAD: 320>, <TokenType.MAP: 322>, <TokenType.MATCH: 323>, <TokenType.MERGE: 327>, <TokenType.MODEL: 329>, <TokenType.NEXT: 331>, <TokenType.NOTHING: 332>, <TokenType.NULL: 334>, <TokenType.OBJECT_IDENTIFIER: 335>, <TokenType.OFFSET: 336>, <TokenType.OPERATOR: 339>, <TokenType.ORDINALITY: 343>, <TokenType.INOUT: 345>, <TokenType.OVER: 347>, <TokenType.OVERLAPS: 348>, <TokenType.OVERWRITE: 349>, <TokenType.PARTITION: 351>, <TokenType.PERCENT: 353>, <TokenType.PIVOT: 354>, <TokenType.PRAGMA: 359>, <TokenType.PROCEDURE: 362>, <TokenType.PSEUDO_TYPE: 364>, <TokenType.PUT: 365>, <TokenType.RANGE: 369>, <TokenType.RECURSIVE: 370>, <TokenType.REFRESH: 371>, <TokenType.RENAME: 372>, <TokenType.REPLACE: 373>, <TokenType.REFERENCES: 376>, <TokenType.ROLLUP: 381>, <TokenType.ROW: 382>, <TokenType.ROWS: 383>, <TokenType.SEQUENCE: 388>, <TokenType.SET: 390>, <TokenType.SHOW: 392>, <TokenType.SOME: 394>, <TokenType.STORAGE_INTEGRATION: 399>, <TokenType.STRAIGHT_JOIN: 400>, <TokenType.STRUCT: 401>, <TokenType.TAG: 404>, <TokenType.TEMPORARY: 405>, <TokenType.TOP: 406>, <TokenType.TRUE: 408>, <TokenType.TRUNCATE: 409>, <TokenType.TRIGGER: 410>, <TokenType.TYPE: 411>, <TokenType.UNNEST: 414>, <TokenType.UNPIVOT: 415>, <TokenType.UPDATE: 416>, <TokenType.USE: 417>, <TokenType.VIEW: 421>, <TokenType.SEMANTIC_VIEW: 422>, <TokenType.VOLATILE: 423>, <TokenType.UNIQUE: 429>, <TokenType.SINK: 436>, <TokenType.SOURCE: 437>, <TokenType.ANALYZE: 438>, <TokenType.NAMESPACE: 439>, <TokenType.EXPORT: 440>}
ALIAS_TOKENS = {<TokenType.SESSION: 58>, <TokenType.SESSION_USER: 60>, <TokenType.IDENTIFIER: 78>, <TokenType.DATABASE: 79>, <TokenType.COLUMN: 80>, <TokenType.SCHEMA: 82>, <TokenType.TABLE: 83>, <TokenType.WAREHOUSE: 84>, <TokenType.STAGE: 85>, <TokenType.STREAM: 86>, <TokenType.STREAMLIT: 87>, <TokenType.VAR: 88>, <TokenType.BIT: 96>, <TokenType.BOOLEAN: 97>, <TokenType.TINYINT: 98>, <TokenType.UTINYINT: 99>, <TokenType.SMALLINT: 100>, <TokenType.USMALLINT: 101>, <TokenType.MEDIUMINT: 102>, <TokenType.UMEDIUMINT: 103>, <TokenType.INT: 104>, <TokenType.UINT: 105>, <TokenType.BIGINT: 106>, <TokenType.UBIGINT: 107>, <TokenType.BIGNUM: 108>, <TokenType.INT128: 109>, <TokenType.UINT128: 110>, <TokenType.INT256: 111>, <TokenType.UINT256: 112>, <TokenType.FLOAT: 113>, <TokenType.DOUBLE: 114>, <TokenType.UDOUBLE: 115>, <TokenType.DECIMAL: 116>, <TokenType.DECIMAL32: 117>, <TokenType.DECIMAL64: 118>, <TokenType.DECIMAL128: 119>, <TokenType.DECIMAL256: 120>, <TokenType.DECFLOAT: 121>, <TokenType.UDECIMAL: 122>, <TokenType.BIGDECIMAL: 123>, <TokenType.CHAR: 124>, <TokenType.NCHAR: 125>, <TokenType.VARCHAR: 126>, <TokenType.NVARCHAR: 127>, <TokenType.BPCHAR: 128>, <TokenType.TEXT: 129>, <TokenType.MEDIUMTEXT: 130>, <TokenType.LONGTEXT: 131>, <TokenType.BLOB: 132>, <TokenType.MEDIUMBLOB: 133>, <TokenType.LONGBLOB: 134>, <TokenType.TINYBLOB: 135>, <TokenType.TINYTEXT: 136>, <TokenType.NAME: 137>, <TokenType.BINARY: 138>, <TokenType.VARBINARY: 139>, <TokenType.JSON: 140>, <TokenType.JSONB: 141>, <TokenType.TIME: 142>, <TokenType.TIMETZ: 143>, <TokenType.TIME_NS: 144>, <TokenType.TIMESTAMP: 145>, <TokenType.TIMESTAMPTZ: 146>, <TokenType.TIMESTAMPLTZ: 147>, <TokenType.TIMESTAMPNTZ: 148>, <TokenType.TIMESTAMP_S: 149>, <TokenType.TIMESTAMP_MS: 150>, <TokenType.TIMESTAMP_NS: 151>, <TokenType.DATETIME: 152>, <TokenType.DATETIME2: 153>, <TokenType.DATETIME64: 154>, <TokenType.SMALLDATETIME: 155>, <TokenType.DATE: 156>, <TokenType.DATE32: 157>, <TokenType.INT4RANGE: 158>, <TokenType.INT4MULTIRANGE: 159>, <TokenType.INT8RANGE: 160>, <TokenType.INT8MULTIRANGE: 161>, <TokenType.NUMRANGE: 162>, <TokenType.NUMMULTIRANGE: 163>, <TokenType.TSRANGE: 164>, <TokenType.TSMULTIRANGE: 165>, <TokenType.TSTZRANGE: 166>, <TokenType.TSTZMULTIRANGE: 167>, <TokenType.DATERANGE: 168>, <TokenType.DATEMULTIRANGE: 169>, <TokenType.UUID: 170>, <TokenType.GEOGRAPHY: 171>, <TokenType.GEOGRAPHYPOINT: 172>, <TokenType.NULLABLE: 173>, <TokenType.GEOMETRY: 174>, <TokenType.POINT: 175>, <TokenType.RING: 176>, <TokenType.LINESTRING: 177>, <TokenType.LOCALTIME: 178>, <TokenType.LOCALTIMESTAMP: 179>, <TokenType.MULTILINESTRING: 181>, <TokenType.POLYGON: 182>, <TokenType.MULTIPOLYGON: 183>, <TokenType.HLLSKETCH: 184>, <TokenType.HSTORE: 185>, <TokenType.SUPER: 186>, <TokenType.SERIAL: 187>, <TokenType.SMALLSERIAL: 188>, <TokenType.BIGSERIAL: 189>, <TokenType.XML: 190>, <TokenType.YEAR: 191>, <TokenType.USERDEFINED: 192>, <TokenType.MONEY: 193>, <TokenType.SMALLMONEY: 194>, <TokenType.ROWVERSION: 195>, <TokenType.IMAGE: 196>, <TokenType.VARIANT: 197>, <TokenType.OBJECT: 198>, <TokenType.INET: 199>, <TokenType.IPADDRESS: 200>, <TokenType.IPPREFIX: 201>, <TokenType.IPV4: 202>, <TokenType.IPV6: 203>, <TokenType.ENUM: 204>, <TokenType.ENUM8: 205>, <TokenType.ENUM16: 206>, <TokenType.FIXEDSTRING: 207>, <TokenType.LOWCARDINALITY: 208>, <TokenType.NESTED: 209>, <TokenType.AGGREGATEFUNCTION: 210>, <TokenType.SIMPLEAGGREGATEFUNCTION: 211>, <TokenType.TDIGEST: 212>, <TokenType.UNKNOWN: 213>, <TokenType.VECTOR: 214>, <TokenType.DYNAMIC: 215>, <TokenType.VOID: 216>, <TokenType.ALL: 219>, <TokenType.ANTI: 220>, <TokenType.ANY: 221>, <TokenType.APPLY: 222>, <TokenType.ARRAY: 223>, <TokenType.ASC: 224>, <TokenType.ASOF: 225>, <TokenType.ATTACH: 226>, <TokenType.AUTO_INCREMENT: 227>, <TokenType.BEGIN: 228>, <TokenType.CACHE: 231>, <TokenType.CASE: 232>, <TokenType.COLLATE: 235>, <TokenType.COMMAND: 236>, <TokenType.COMMENT: 237>, <TokenType.COMMIT: 238>, <TokenType.CONSTRAINT: 240>, <TokenType.COPY: 241>, <TokenType.CUBE: 244>, <TokenType.CURRENT_DATE: 245>, <TokenType.CURRENT_DATETIME: 246>, <TokenType.CURRENT_SCHEMA: 247>, <TokenType.CURRENT_TIME: 248>, <TokenType.CURRENT_TIMESTAMP: 249>, <TokenType.CURRENT_USER: 250>, <TokenType.CURRENT_ROLE: 252>, <TokenType.CURRENT_CATALOG: 253>, <TokenType.DEFAULT: 255>, <TokenType.DELETE: 256>, <TokenType.DESC: 257>, <TokenType.DESCRIBE: 258>, <TokenType.DETACH: 259>, <TokenType.DICTIONARY: 260>, <TokenType.DIV: 263>, <TokenType.END: 266>, <TokenType.ESCAPE: 267>, <TokenType.EXECUTE: 269>, <TokenType.EXISTS: 270>, <TokenType.FALSE: 271>, <TokenType.FILE: 273>, <TokenType.FILE_FORMAT: 274>, <TokenType.FILTER: 275>, <TokenType.FINAL: 276>, <TokenType.FIRST: 277>, <TokenType.FOREIGN_KEY: 280>, <TokenType.FULL: 283>, <TokenType.FUNCTION: 284>, <TokenType.GET: 285>, <TokenType.INDEX: 296>, <TokenType.INTERVAL: 303>, <TokenType.IS: 307>, <TokenType.ISNULL: 308>, <TokenType.KEEP: 311>, <TokenType.KILL: 313>, <TokenType.LEFT: 316>, <TokenType.LIMIT: 318>, <TokenType.LIST: 319>, <TokenType.LOAD: 320>, <TokenType.LOCK: 321>, <TokenType.MAP: 322>, <TokenType.MATCH: 323>, <TokenType.MERGE: 327>, <TokenType.MODEL: 329>, <TokenType.NATURAL: 330>, <TokenType.NEXT: 331>, <TokenType.NOTHING: 332>, <TokenType.NULL: 334>, <TokenType.OBJECT_IDENTIFIER: 335>, <TokenType.OFFSET: 336>, <TokenType.OPERATOR: 339>, <TokenType.ORDINALITY: 343>, <TokenType.INOUT: 345>, <TokenType.OVER: 347>, <TokenType.OVERLAPS: 348>, <TokenType.OVERWRITE: 349>, <TokenType.PARTITION: 351>, <TokenType.PERCENT: 353>, <TokenType.PIVOT: 354>, <TokenType.PRAGMA: 359>, <TokenType.PROCEDURE: 362>, <TokenType.PSEUDO_TYPE: 364>, <TokenType.PUT: 365>, <TokenType.RANGE: 369>, <TokenType.RECURSIVE: 370>, <TokenType.REFRESH: 371>, <TokenType.RENAME: 372>, <TokenType.REPLACE: 373>, <TokenType.REFERENCES: 376>, <TokenType.RIGHT: 377>, <TokenType.ROLLUP: 381>, <TokenType.ROW: 382>, <TokenType.ROWS: 383>, <TokenType.SEMI: 386>, <TokenType.SEQUENCE: 388>, <TokenType.SET: 390>, <TokenType.SETTINGS: 391>, <TokenType.SHOW: 392>, <TokenType.SOME: 394>, <TokenType.STORAGE_INTEGRATION: 399>, <TokenType.STRAIGHT_JOIN: 400>, <TokenType.STRUCT: 401>, <TokenType.TAG: 404>, <TokenType.TEMPORARY: 405>, <TokenType.TOP: 406>, <TokenType.TRUE: 408>, <TokenType.TRUNCATE: 409>, <TokenType.TRIGGER: 410>, <TokenType.TYPE: 411>, <TokenType.UNNEST: 414>, <TokenType.UNPIVOT: 415>, <TokenType.UPDATE: 416>, <TokenType.USE: 417>, <TokenType.VIEW: 421>, <TokenType.SEMANTIC_VIEW: 422>, <TokenType.VOLATILE: 423>, <TokenType.WINDOW: 427>, <TokenType.UNIQUE: 429>, <TokenType.SINK: 436>, <TokenType.SOURCE: 437>, <TokenType.ANALYZE: 438>, <TokenType.NAMESPACE: 439>, <TokenType.EXPORT: 440>}
LOG_DEFAULTS_TO_LN = True
QUERY_MODIFIER_PARSERS = {<TokenType.MATCH_RECOGNIZE: 325>: <function Parser.<lambda>>, <TokenType.PREWHERE: 360>: <function Parser.<lambda>>, <TokenType.WHERE: 426>: <function Parser.<lambda>>, <TokenType.GROUP_BY: 289>: <function Parser.<lambda>>, <TokenType.HAVING: 291>: <function Parser.<lambda>>, <TokenType.QUALIFY: 366>: <function Parser.<lambda>>, <TokenType.WINDOW: 427>: <function Parser.<lambda>>, <TokenType.ORDER_BY: 340>: <function Parser.<lambda>>, <TokenType.LIMIT: 318>: <function Parser.<lambda>>, <TokenType.FETCH: 272>: <function Parser.<lambda>>, <TokenType.OFFSET: 336>: <function Parser.<lambda>>, <TokenType.FOR: 278>: <function Parser.<lambda>>, <TokenType.LOCK: 321>: <function Parser.<lambda>>, <TokenType.TABLE_SAMPLE: 403>: <function Parser.<lambda>>, <TokenType.USING: 418>: <function Parser.<lambda>>, <TokenType.CLUSTER_BY: 234>: <function Parser.<lambda>>, <TokenType.DISTRIBUTE_BY: 262>: <function Parser.<lambda>>, <TokenType.SORT_BY: 395>: <function Parser.<lambda>>, <TokenType.CONNECT_BY: 239>: <function Parser.<lambda>>, <TokenType.START_WITH: 398>: <function Parser.<lambda>>, <TokenType.SETTINGS: 391>: <function ClickHouseParser.<lambda>>, <TokenType.FORMAT: 281>: <function ClickHouseParser.<lambda>>}
CONSTRAINT_PARSERS = {'AUTOINCREMENT': <function Parser.<lambda>>, 'AUTO_INCREMENT': <function Parser.<lambda>>, 'CASESPECIFIC': <function Parser.<lambda>>, 'CHARACTER SET': <function Parser.<lambda>>, 'CHECK': <function Parser.<lambda>>, 'COLLATE': <function Parser.<lambda>>, 'COMMENT': <function Parser.<lambda>>, 'COMPRESS': <function Parser.<lambda>>, 'CLUSTERED': <function Parser.<lambda>>, 'NONCLUSTERED': <function Parser.<lambda>>, 'DEFAULT': <function Parser.<lambda>>, 'ENCODE': <function Parser.<lambda>>, 'EPHEMERAL': <function Parser.<lambda>>, 'EXCLUDE': <function Parser.<lambda>>, 'FOREIGN KEY': <function Parser.<lambda>>, 'FORMAT': <function Parser.<lambda>>, 'GENERATED': <function Parser.<lambda>>, 'IDENTITY': <function Parser.<lambda>>, 'INLINE': <function Parser.<lambda>>, 'LIKE': <function Parser.<lambda>>, 'NOT': <function Parser.<lambda>>, 'NULL': <function Parser.<lambda>>, 'ON': <function Parser.<lambda>>, 'PATH': <function Parser.<lambda>>, 'PERIOD': <function Parser.<lambda>>, 'PRIMARY KEY': <function Parser.<lambda>>, 'REFERENCES': <function Parser.<lambda>>, 'TITLE': <function Parser.<lambda>>, 'TTL': <function Parser.<lambda>>, 'UNIQUE': <function Parser.<lambda>>, 'UPPERCASE': <function Parser.<lambda>>, 'WITH': <function Parser.<lambda>>, 'BUCKET': <function Parser.<lambda>>, 'TRUNCATE': <function Parser.<lambda>>, 'INDEX': <function ClickHouseParser.<lambda>>, 'CODEC': <function ClickHouseParser.<lambda>>, 'ASSUME': <function ClickHouseParser.<lambda>>}
ALTER_PARSERS = {'ADD': <function Parser.<lambda>>, 'AS': <function Parser.<lambda>>, 'ALTER': <function Parser.<lambda>>, 'CLUSTER BY': <function Parser.<lambda>>, 'DELETE': <function Parser.<lambda>>, 'DROP': <function Parser.<lambda>>, 'RENAME': <function Parser.<lambda>>, 'SET': <function Parser.<lambda>>, 'SWAP': <function Parser.<lambda>>, 'MODIFY': <function ClickHouseParser.<lambda>>, 'REPLACE': <function ClickHouseParser.<lambda>>}
SCHEMA_UNNAMED_CONSTRAINTS = {'UNIQUE', 'PRIMARY KEY', 'PERIOD', 'FOREIGN KEY', 'INDEX', 'EXCLUDE', 'BUCKET', 'LIKE', 'TRUNCATE'}
PLACEHOLDER_PARSERS = {<TokenType.PLACEHOLDER: 355>: <function Parser.<lambda>>, <TokenType.PARAMETER: 57>: <function Parser.<lambda>>, <TokenType.COLON: 11>: <function Parser.<lambda>>, <TokenType.L_BRACE: 5>: <function ClickHouseParser.<lambda>>}
STATEMENT_PARSERS = {<TokenType.ALTER: 218>: <function Parser.<lambda>>, <TokenType.ANALYZE: 438>: <function Parser.<lambda>>, <TokenType.BEGIN: 228>: <function Parser.<lambda>>, <TokenType.CACHE: 231>: <function Parser.<lambda>>, <TokenType.COMMENT: 237>: <function Parser.<lambda>>, <TokenType.COMMIT: 238>: <function Parser.<lambda>>, <TokenType.COPY: 241>: <function Parser.<lambda>>, <TokenType.CREATE: 242>: <function Parser.<lambda>>, <TokenType.DELETE: 256>: <function Parser.<lambda>>, <TokenType.DESC: 257>: <function Parser.<lambda>>, <TokenType.DESCRIBE: 258>: <function Parser.<lambda>>, <TokenType.DROP: 264>: <function Parser.<lambda>>, <TokenType.GRANT: 288>: <function Parser.<lambda>>, <TokenType.REVOKE: 375>: <function Parser.<lambda>>, <TokenType.INSERT: 299>: <function Parser.<lambda>>, <TokenType.KILL: 313>: <function Parser.<lambda>>, <TokenType.LOAD: 320>: <function Parser.<lambda>>, <TokenType.MERGE: 327>: <function Parser.<lambda>>, <TokenType.PIVOT: 354>: <function Parser.<lambda>>, <TokenType.PRAGMA: 359>: <function Parser.<lambda>>, <TokenType.REFRESH: 371>: <function Parser.<lambda>>, <TokenType.ROLLBACK: 380>: <function Parser.<lambda>>, <TokenType.SET: 390>: <function Parser.<lambda>>, <TokenType.TRUNCATE: 409>: <function Parser.<lambda>>, <TokenType.UNCACHE: 412>: <function Parser.<lambda>>, <TokenType.UNPIVOT: 415>: <function Parser.<lambda>>, <TokenType.UPDATE: 416>: <function Parser.<lambda>>, <TokenType.USE: 417>: <function Parser.<lambda>>, <TokenType.SEMICOLON: 19>: <function Parser.<lambda>>, <TokenType.DETACH: 259>: <function ClickHouseParser.<lambda>>}
Inherited Members
sqlglot.parser.Parser
Parser
STRUCT_TYPE_TOKENS
NESTED_TYPE_TOKENS
ENUM_TYPE_TOKENS
AGGREGATE_TYPE_TOKENS
TYPE_TOKENS
SIGNED_TO_UNSIGNED_TYPE_TOKEN
SUBQUERY_PREDICATES
SUBQUERY_TOKENS
DB_CREATABLES
CREATABLES
TRIGGER_EVENTS
ALTERABLES
COLON_PLACEHOLDER_TOKENS
ARRAY_CONSTRUCTORS
COMMENT_TABLE_ALIAS_TOKENS
UPDATE_ALIAS_TOKENS
TRIM_TYPES
IDENTIFIER_TOKENS
BRACKETS
COLUMN_POSTFIX_TOKENS
TABLE_POSTFIX_TOKENS
CONJUNCTION
ASSIGNMENT
DISJUNCTION
EQUALITY
COMPARISON
BITWISE
TERM
FACTOR
EXPONENT
TIMES
TIMESTAMPS
SET_OPERATIONS
JOIN_METHODS
JOIN_SIDES
JOIN_HINTS
TABLE_TERMINATORS
LAMBDAS
TYPED_LAMBDA_ARGS
LAMBDA_ARG_TERMINATORS
CAST_COLUMN_OPERATORS
EXPRESSION_PARSERS
UNARY_PARSERS
STRING_PARSERS
NUMERIC_PARSERS
PRIMARY_PARSERS
PIPE_SYNTAX_TRANSFORM_PARSERS
ALTER_ALTER_PARSERS
INVALID_FUNC_NAME_TOKENS
FUNCTIONS_WITH_ALIASED_ARGS
KEY_VALUE_DEFINITIONS
QUERY_MODIFIER_TOKENS
SET_PARSERS
SHOW_PARSERS
TYPE_LITERAL_PARSERS
TYPE_CONVERTERS
DDL_SELECT_TOKENS
PRE_VOLATILE_TOKENS
TRANSACTION_KIND
TRANSACTION_CHARACTERISTICS
CONFLICT_ACTIONS
TRIGGER_TIMING
TRIGGER_DEFERRABLE
CREATE_SEQUENCE
ISOLATED_LOADING_OPTIONS
USABLES
CAST_ACTIONS
SCHEMA_BINDING_OPTIONS
PROCEDURE_OPTIONS
EXECUTE_AS_OPTIONS
KEY_CONSTRAINT_OPTIONS
WINDOW_EXCLUDE_OPTIONS
INSERT_ALTERNATIVES
CLONE_KEYWORDS
HISTORICAL_DATA_PREFIX
HISTORICAL_DATA_KIND
OPCLASS_FOLLOW_KEYWORDS
OPTYPE_FOLLOW_TOKENS
TABLE_INDEX_HINT_TOKENS
VIEW_ATTRIBUTES
WINDOW_ALIAS_TOKENS
WINDOW_BEFORE_PAREN_TOKENS
WINDOW_SIDES
JSON_KEY_VALUE_SEPARATOR_TOKENS
FETCH_TOKENS
ADD_CONSTRAINT_TOKENS
DISTINCT_TOKENS
UNNEST_OFFSET_ALIAS_TOKENS
SELECT_START_TOKENS
COPY_INTO_VARLEN_OPTIONS
IS_JSON_PREDICATE_KIND
ODBC_DATETIME_LITERALS
ON_CONDITION_TOKENS
PRIVILEGE_FOLLOW_TOKENS
DESCRIBE_STYLES
SET_ASSIGNMENT_DELIMITERS
ANALYZE_STYLES
ANALYZE_EXPRESSION_PARSERS
PARTITION_KEYWORDS
AMBIGUOUS_ALIAS_TOKENS
OPERATION_MODIFIERS
RECURSIVE_CTE_SEARCH_KIND
SECURITY_PROPERTY_KEYWORDS
MODIFIABLES
STRICT_CAST
PREFIXED_PIVOT_COLUMNS
IDENTIFY_PIVOT_STRINGS
PIVOT_COLUMN_NAMING
TABLESAMPLE_CSV
DEFAULT_SAMPLING_METHOD
SET_REQUIRES_ASSIGNMENT_DELIMITER
TRIM_PATTERN_FIRST
STRING_ALIASES
SET_OP_MODIFIERS
NO_PAREN_IF_COMMANDS
JSON_ARROWS_REQUIRE_JSON_TYPE
COLON_IS_VARIANT_EXTRACT
VALUES_FOLLOWED_BY_PAREN
SUPPORTS_IMPLICIT_UNNEST
SUPPORTS_PARTITION_SELECTION
WRAPPED_TRANSFORM_COLUMN_CONSTRAINT
ALTER_RENAME_REQUIRES_COLUMN
ALTER_TABLE_PARTITIONS
ZONE_AWARE_TIMESTAMP_CONSTRUCTOR
MAP_KEYS_ARE_ARBITRARY_EXPRESSIONS
JSON_EXTRACT_REQUIRES_JSON_EXPRESSION
ADD_JOIN_ON_TRUE
SUPPORTS_OMITTED_INTERVAL_SPAN_UNIT
SHOW_TRIE
SET_TRIE
error_level
error_message_context
max_errors
max_nodes
dialect
sql
errors
reset
raise_error
validate_expression
parse
parse_into
check_errors
expression
parse_set_operation
build_cast