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

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'>>, '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': <function ClickHouseParser.<lambda>>, '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>, 'TOSTARTOFMONTH': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFSECOND': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFHOUR': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFMILLISECOND': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFDAY': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFMINUTE': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFMICROSECOND': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFYEAR': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFQUARTER': <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 = {'quantileTDigest', 'deltaSum', 'groupBitmapAnd', 'studentTTest', 'rankCorr', 'topKWeighted', 'largestTriangleThreeBuckets', 'kurtPop', 'sequenceCount', 'argMax', 'quantilesExactLow', 'quantileExact', 'sumMap', 'entropy', 'approx_top_sum', 'topK', 'maxIntersectionsPosition', 'groupBitmap', 'quantilesTDigestWeighted', 'groupArrayLast', 'groupBitXor', 'corr', 'groupArrayInsertAt', 'mannWhitneyUTest', 'histogram', 'uniqExact', 'quantilesTiming', 'contingency', 'stochasticLogisticRegression', 'quantilesGK', 'max', 'sequenceNextNode', 'quantileTimingWeighted', 'quantilesTimingWeighted', 'quantilesExactWeighted', 'sumKahan', 'groupBitOr', 'exponentialTimeDecayedAvg', 'exponentialMovingAverage', 'groupArray', 'quantileBFloat16', 'sequenceMatch', 'quantile', 'welchTTest', 'sumCount', 'groupBitmapXor', 'quantilesBFloat16', 'anyHeavy', 'kurtSamp', 'varPop', 'theilsU', 'groupUniqArray', 'quantiles', 'quantilesBFloat16Weighted', 'windowFunnel', 'avg', 'sum', 'stddevSamp', 'stddevPop', 'groupArrayMovingAvg', 'retention', 'groupConcat', 'skewSamp', 'last_value', 'argMin', 'quantileBFloat16Weighted', 'meanZTest', 'quantilesDeterministic', 'intervalLengthSum', 'quantilesTDigest', 'quantileInterpolatedWeighted', 'quantilesExact', 'any', 'quantilesInterpolatedWeighted', 'count', 'cramersVBiasCorrected', 'uniqCombined', 'maxIntersections', 'uniqHLL12', 'quantileTiming', 'first_value', 'covarSamp', 'maxMap', 'avgWeighted', 'sumWithOverflow', 'groupBitmapOr', 'quantilesExactExclusive', 'boundingRatio', 'groupBitAnd', 'skewPop', 'quantileTDigestWeighted', 'quantileExactWeighted', 'stochasticLinearRegression', 'uniqCombined64', 'anyLast', 'uniqTheta', 'varSamp', 'deltaSumTimestamp', 'simpleLinearRegression', 'quantileExactLow', 'median', 'cramersV', 'categoricalInformationValue', 'quantileGK', 'covarPop', 'uniq', 'min', 'groupArrayMovingSum', 'sparkBar', 'quantilesExactHigh', 'quantileDeterministic', 'uniqUpTo', 'kolmogorovSmirnovTest', 'quantileExactHigh', 'groupArraySample', 'minMap'}
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: 59>, <TokenType.XOR: 64>, <TokenType.IDENTIFIER: 77>, <TokenType.TABLE: 82>, <TokenType.VAR: 87>, <TokenType.BIT: 95>, <TokenType.BOOLEAN: 96>, <TokenType.TINYINT: 97>, <TokenType.UTINYINT: 98>, <TokenType.SMALLINT: 99>, <TokenType.USMALLINT: 100>, <TokenType.MEDIUMINT: 101>, <TokenType.UMEDIUMINT: 102>, <TokenType.INT: 103>, <TokenType.UINT: 104>, <TokenType.BIGINT: 105>, <TokenType.UBIGINT: 106>, <TokenType.BIGNUM: 107>, <TokenType.INT128: 108>, <TokenType.UINT128: 109>, <TokenType.INT256: 110>, <TokenType.UINT256: 111>, <TokenType.FLOAT: 112>, <TokenType.DOUBLE: 113>, <TokenType.UDOUBLE: 114>, <TokenType.DECIMAL: 115>, <TokenType.DECIMAL32: 116>, <TokenType.DECIMAL64: 117>, <TokenType.DECIMAL128: 118>, <TokenType.DECIMAL256: 119>, <TokenType.DECFLOAT: 120>, <TokenType.UDECIMAL: 121>, <TokenType.BIGDECIMAL: 122>, <TokenType.CHAR: 123>, <TokenType.NCHAR: 124>, <TokenType.VARCHAR: 125>, <TokenType.NVARCHAR: 126>, <TokenType.BPCHAR: 127>, <TokenType.TEXT: 128>, <TokenType.MEDIUMTEXT: 129>, <TokenType.LONGTEXT: 130>, <TokenType.BLOB: 131>, <TokenType.MEDIUMBLOB: 132>, <TokenType.LONGBLOB: 133>, <TokenType.TINYBLOB: 134>, <TokenType.TINYTEXT: 135>, <TokenType.NAME: 136>, <TokenType.BINARY: 137>, <TokenType.VARBINARY: 138>, <TokenType.JSON: 139>, <TokenType.JSONB: 140>, <TokenType.TIME: 141>, <TokenType.TIMETZ: 142>, <TokenType.TIME_NS: 143>, <TokenType.TIMESTAMP: 144>, <TokenType.TIMESTAMPTZ: 145>, <TokenType.TIMESTAMPLTZ: 146>, <TokenType.TIMESTAMPNTZ: 147>, <TokenType.TIMESTAMP_S: 148>, <TokenType.TIMESTAMP_MS: 149>, <TokenType.TIMESTAMP_NS: 150>, <TokenType.DATETIME: 151>, <TokenType.DATETIME2: 152>, <TokenType.DATETIME64: 153>, <TokenType.SMALLDATETIME: 154>, <TokenType.DATE: 155>, <TokenType.DATE32: 156>, <TokenType.INT4RANGE: 157>, <TokenType.INT4MULTIRANGE: 158>, <TokenType.INT8RANGE: 159>, <TokenType.INT8MULTIRANGE: 160>, <TokenType.NUMRANGE: 161>, <TokenType.NUMMULTIRANGE: 162>, <TokenType.TSRANGE: 163>, <TokenType.TSMULTIRANGE: 164>, <TokenType.TSTZRANGE: 165>, <TokenType.TSTZMULTIRANGE: 166>, <TokenType.DATERANGE: 167>, <TokenType.DATEMULTIRANGE: 168>, <TokenType.UUID: 169>, <TokenType.GEOGRAPHY: 170>, <TokenType.GEOGRAPHYPOINT: 171>, <TokenType.NULLABLE: 172>, <TokenType.GEOMETRY: 173>, <TokenType.POINT: 174>, <TokenType.RING: 175>, <TokenType.LINESTRING: 176>, <TokenType.LOCALTIME: 177>, <TokenType.LOCALTIMESTAMP: 178>, <TokenType.MULTILINESTRING: 180>, <TokenType.POLYGON: 181>, <TokenType.MULTIPOLYGON: 182>, <TokenType.HLLSKETCH: 183>, <TokenType.HSTORE: 184>, <TokenType.SUPER: 185>, <TokenType.SERIAL: 186>, <TokenType.SMALLSERIAL: 187>, <TokenType.BIGSERIAL: 188>, <TokenType.XML: 189>, <TokenType.YEAR: 190>, <TokenType.USERDEFINED: 191>, <TokenType.MONEY: 192>, <TokenType.SMALLMONEY: 193>, <TokenType.ROWVERSION: 194>, <TokenType.IMAGE: 195>, <TokenType.VARIANT: 196>, <TokenType.OBJECT: 197>, <TokenType.INET: 198>, <TokenType.IPADDRESS: 199>, <TokenType.IPPREFIX: 200>, <TokenType.IPV4: 201>, <TokenType.IPV6: 202>, <TokenType.ENUM: 203>, <TokenType.ENUM8: 204>, <TokenType.ENUM16: 205>, <TokenType.FIXEDSTRING: 206>, <TokenType.LOWCARDINALITY: 207>, <TokenType.NESTED: 208>, <TokenType.AGGREGATEFUNCTION: 209>, <TokenType.SIMPLEAGGREGATEFUNCTION: 210>, <TokenType.TDIGEST: 211>, <TokenType.UNKNOWN: 212>, <TokenType.VECTOR: 213>, <TokenType.DYNAMIC: 214>, <TokenType.VOID: 215>, <TokenType.ALL: 218>, <TokenType.ANY: 220>, <TokenType.ARRAY: 222>, <TokenType.COLLATE: 234>, <TokenType.COMMAND: 235>, <TokenType.CURRENT_DATE: 244>, <TokenType.CURRENT_DATETIME: 245>, <TokenType.CURRENT_SCHEMA: 246>, <TokenType.CURRENT_TIME: 247>, <TokenType.CURRENT_TIMESTAMP: 248>, <TokenType.CURRENT_USER: 249>, <TokenType.CURRENT_CATALOG: 252>, <TokenType.EXISTS: 269>, <TokenType.FILTER: 274>, <TokenType.FIRST: 276>, <TokenType.FORMAT: 280>, <TokenType.GET: 284>, <TokenType.GLOB: 285>, <TokenType.ILIKE: 293>, <TokenType.INDEX: 295>, <TokenType.INSERT: 298>, <TokenType.INTERVAL: 302>, <TokenType.ISNULL: 307>, <TokenType.LEFT: 315>, <TokenType.LIKE: 316>, <TokenType.LIST: 318>, <TokenType.MAP: 321>, <TokenType.MERGE: 326>, <TokenType.NEXT: 330>, <TokenType.NOTHING: 331>, <TokenType.NULL: 333>, <TokenType.OBJECT_IDENTIFIER: 334>, <TokenType.OFFSET: 335>, <TokenType.PRIMARY_KEY: 360>, <TokenType.PSEUDO_TYPE: 363>, <TokenType.RANGE: 368>, <TokenType.REPLACE: 372>, <TokenType.RIGHT: 376>, <TokenType.RLIKE: 377>, <TokenType.ROW: 381>, <TokenType.SEQUENCE: 387>, <TokenType.SET: 389>, <TokenType.SOME: 393>, <TokenType.STRUCT: 400>, <TokenType.TRUNCATE: 408>, <TokenType.UNION: 412>, <TokenType.UNNEST: 413>, <TokenType.WINDOW: 426>, <TokenType.UTC_DATE: 429>, <TokenType.UTC_TIME: 430>, <TokenType.UTC_TIMESTAMP: 431>}
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: 327>, <TokenType.SEMICOLON: 19>, <TokenType.STAR: 20>, <TokenType.BACKSLASH: 21>, <TokenType.SLASH: 22>, <TokenType.LT: 23>, <TokenType.UNKNOWN: 212>, <TokenType.GT: 25>, <TokenType.NOT: 27>, <TokenType.EQ: 28>, <TokenType.PLACEHOLDER: 354>, <TokenType.AMP: 36>, <TokenType.PIPE: 39>, <TokenType.CARET: 42>, <TokenType.TILDE: 44>, <TokenType.HASH: 48>, <TokenType.PARAMETER: 56>}
ID_VAR_TOKENS = {<TokenType.SESSION: 57>, <TokenType.SESSION_USER: 59>, <TokenType.IDENTIFIER: 77>, <TokenType.DATABASE: 78>, <TokenType.COLUMN: 79>, <TokenType.SCHEMA: 81>, <TokenType.TABLE: 82>, <TokenType.WAREHOUSE: 83>, <TokenType.STAGE: 84>, <TokenType.STREAM: 85>, <TokenType.STREAMLIT: 86>, <TokenType.VAR: 87>, <TokenType.BIT: 95>, <TokenType.BOOLEAN: 96>, <TokenType.TINYINT: 97>, <TokenType.UTINYINT: 98>, <TokenType.SMALLINT: 99>, <TokenType.USMALLINT: 100>, <TokenType.MEDIUMINT: 101>, <TokenType.UMEDIUMINT: 102>, <TokenType.INT: 103>, <TokenType.UINT: 104>, <TokenType.BIGINT: 105>, <TokenType.UBIGINT: 106>, <TokenType.BIGNUM: 107>, <TokenType.INT128: 108>, <TokenType.UINT128: 109>, <TokenType.INT256: 110>, <TokenType.UINT256: 111>, <TokenType.FLOAT: 112>, <TokenType.DOUBLE: 113>, <TokenType.UDOUBLE: 114>, <TokenType.DECIMAL: 115>, <TokenType.DECIMAL32: 116>, <TokenType.DECIMAL64: 117>, <TokenType.DECIMAL128: 118>, <TokenType.DECIMAL256: 119>, <TokenType.DECFLOAT: 120>, <TokenType.UDECIMAL: 121>, <TokenType.BIGDECIMAL: 122>, <TokenType.CHAR: 123>, <TokenType.NCHAR: 124>, <TokenType.VARCHAR: 125>, <TokenType.NVARCHAR: 126>, <TokenType.BPCHAR: 127>, <TokenType.TEXT: 128>, <TokenType.MEDIUMTEXT: 129>, <TokenType.LONGTEXT: 130>, <TokenType.BLOB: 131>, <TokenType.MEDIUMBLOB: 132>, <TokenType.LONGBLOB: 133>, <TokenType.TINYBLOB: 134>, <TokenType.TINYTEXT: 135>, <TokenType.NAME: 136>, <TokenType.BINARY: 137>, <TokenType.VARBINARY: 138>, <TokenType.JSON: 139>, <TokenType.JSONB: 140>, <TokenType.TIME: 141>, <TokenType.TIMETZ: 142>, <TokenType.TIME_NS: 143>, <TokenType.TIMESTAMP: 144>, <TokenType.TIMESTAMPTZ: 145>, <TokenType.TIMESTAMPLTZ: 146>, <TokenType.TIMESTAMPNTZ: 147>, <TokenType.TIMESTAMP_S: 148>, <TokenType.TIMESTAMP_MS: 149>, <TokenType.TIMESTAMP_NS: 150>, <TokenType.DATETIME: 151>, <TokenType.DATETIME2: 152>, <TokenType.DATETIME64: 153>, <TokenType.SMALLDATETIME: 154>, <TokenType.DATE: 155>, <TokenType.DATE32: 156>, <TokenType.INT4RANGE: 157>, <TokenType.INT4MULTIRANGE: 158>, <TokenType.INT8RANGE: 159>, <TokenType.INT8MULTIRANGE: 160>, <TokenType.NUMRANGE: 161>, <TokenType.NUMMULTIRANGE: 162>, <TokenType.TSRANGE: 163>, <TokenType.TSMULTIRANGE: 164>, <TokenType.TSTZRANGE: 165>, <TokenType.TSTZMULTIRANGE: 166>, <TokenType.DATERANGE: 167>, <TokenType.DATEMULTIRANGE: 168>, <TokenType.UUID: 169>, <TokenType.GEOGRAPHY: 170>, <TokenType.GEOGRAPHYPOINT: 171>, <TokenType.NULLABLE: 172>, <TokenType.GEOMETRY: 173>, <TokenType.POINT: 174>, <TokenType.RING: 175>, <TokenType.LINESTRING: 176>, <TokenType.LOCALTIME: 177>, <TokenType.LOCALTIMESTAMP: 178>, <TokenType.MULTILINESTRING: 180>, <TokenType.POLYGON: 181>, <TokenType.MULTIPOLYGON: 182>, <TokenType.HLLSKETCH: 183>, <TokenType.HSTORE: 184>, <TokenType.SUPER: 185>, <TokenType.SERIAL: 186>, <TokenType.SMALLSERIAL: 187>, <TokenType.BIGSERIAL: 188>, <TokenType.XML: 189>, <TokenType.YEAR: 190>, <TokenType.USERDEFINED: 191>, <TokenType.MONEY: 192>, <TokenType.SMALLMONEY: 193>, <TokenType.ROWVERSION: 194>, <TokenType.IMAGE: 195>, <TokenType.VARIANT: 196>, <TokenType.OBJECT: 197>, <TokenType.INET: 198>, <TokenType.IPADDRESS: 199>, <TokenType.IPPREFIX: 200>, <TokenType.IPV4: 201>, <TokenType.IPV6: 202>, <TokenType.ENUM: 203>, <TokenType.ENUM8: 204>, <TokenType.ENUM16: 205>, <TokenType.FIXEDSTRING: 206>, <TokenType.LOWCARDINALITY: 207>, <TokenType.NESTED: 208>, <TokenType.AGGREGATEFUNCTION: 209>, <TokenType.SIMPLEAGGREGATEFUNCTION: 210>, <TokenType.TDIGEST: 211>, <TokenType.UNKNOWN: 212>, <TokenType.VECTOR: 213>, <TokenType.DYNAMIC: 214>, <TokenType.VOID: 215>, <TokenType.ALL: 218>, <TokenType.ANTI: 219>, <TokenType.ANY: 220>, <TokenType.APPLY: 221>, <TokenType.ARRAY: 222>, <TokenType.ASC: 223>, <TokenType.ASOF: 224>, <TokenType.ATTACH: 225>, <TokenType.AUTO_INCREMENT: 226>, <TokenType.BEGIN: 227>, <TokenType.CACHE: 230>, <TokenType.CASE: 231>, <TokenType.COLLATE: 234>, <TokenType.COMMAND: 235>, <TokenType.COMMENT: 236>, <TokenType.COMMIT: 237>, <TokenType.CONSTRAINT: 239>, <TokenType.COPY: 240>, <TokenType.CUBE: 243>, <TokenType.CURRENT_DATE: 244>, <TokenType.CURRENT_DATETIME: 245>, <TokenType.CURRENT_SCHEMA: 246>, <TokenType.CURRENT_TIME: 247>, <TokenType.CURRENT_TIMESTAMP: 248>, <TokenType.CURRENT_USER: 249>, <TokenType.CURRENT_ROLE: 251>, <TokenType.CURRENT_CATALOG: 252>, <TokenType.DEFAULT: 254>, <TokenType.DELETE: 255>, <TokenType.DESC: 256>, <TokenType.DESCRIBE: 257>, <TokenType.DETACH: 258>, <TokenType.DICTIONARY: 259>, <TokenType.DIV: 262>, <TokenType.END: 265>, <TokenType.ESCAPE: 266>, <TokenType.EXECUTE: 268>, <TokenType.EXISTS: 269>, <TokenType.FALSE: 270>, <TokenType.FILE: 272>, <TokenType.FILE_FORMAT: 273>, <TokenType.FILTER: 274>, <TokenType.FINAL: 275>, <TokenType.FIRST: 276>, <TokenType.FOREIGN_KEY: 279>, <TokenType.FORMAT: 280>, <TokenType.FULL: 282>, <TokenType.FUNCTION: 283>, <TokenType.GET: 284>, <TokenType.INDEX: 295>, <TokenType.INTERVAL: 302>, <TokenType.IS: 306>, <TokenType.ISNULL: 307>, <TokenType.KEEP: 310>, <TokenType.KILL: 312>, <TokenType.LEFT: 315>, <TokenType.LIKE: 316>, <TokenType.LIMIT: 317>, <TokenType.LIST: 318>, <TokenType.LOAD: 319>, <TokenType.LOCK: 320>, <TokenType.MAP: 321>, <TokenType.MATCH: 322>, <TokenType.MERGE: 326>, <TokenType.MODEL: 328>, <TokenType.NATURAL: 329>, <TokenType.NEXT: 330>, <TokenType.NOTHING: 331>, <TokenType.NULL: 333>, <TokenType.OBJECT_IDENTIFIER: 334>, <TokenType.OFFSET: 335>, <TokenType.OPERATOR: 338>, <TokenType.ORDINALITY: 342>, <TokenType.INOUT: 344>, <TokenType.OVER: 346>, <TokenType.OVERLAPS: 347>, <TokenType.OVERWRITE: 348>, <TokenType.PARTITION: 350>, <TokenType.PERCENT: 352>, <TokenType.PIVOT: 353>, <TokenType.PRAGMA: 358>, <TokenType.PROCEDURE: 361>, <TokenType.PSEUDO_TYPE: 363>, <TokenType.PUT: 364>, <TokenType.RANGE: 368>, <TokenType.RECURSIVE: 369>, <TokenType.REFRESH: 370>, <TokenType.RENAME: 371>, <TokenType.REPLACE: 372>, <TokenType.REFERENCES: 375>, <TokenType.RIGHT: 376>, <TokenType.ROLLUP: 380>, <TokenType.ROW: 381>, <TokenType.ROWS: 382>, <TokenType.SEMI: 385>, <TokenType.SEQUENCE: 387>, <TokenType.SET: 389>, <TokenType.SETTINGS: 390>, <TokenType.SHOW: 391>, <TokenType.SOME: 393>, <TokenType.STORAGE_INTEGRATION: 398>, <TokenType.STRAIGHT_JOIN: 399>, <TokenType.STRUCT: 400>, <TokenType.TAG: 403>, <TokenType.TEMPORARY: 404>, <TokenType.TOP: 405>, <TokenType.TRUE: 407>, <TokenType.TRUNCATE: 408>, <TokenType.TRIGGER: 409>, <TokenType.TYPE: 410>, <TokenType.UNNEST: 413>, <TokenType.UNPIVOT: 414>, <TokenType.UPDATE: 415>, <TokenType.USE: 416>, <TokenType.VIEW: 420>, <TokenType.SEMANTIC_VIEW: 421>, <TokenType.VOLATILE: 422>, <TokenType.WINDOW: 426>, <TokenType.UNIQUE: 428>, <TokenType.SINK: 435>, <TokenType.SOURCE: 436>, <TokenType.ANALYZE: 437>, <TokenType.NAMESPACE: 438>, <TokenType.EXPORT: 439>}
AGG_FUNC_MAPPING = {'quantileTDigestSimpleState': ('quantileTDigest', 'SimpleState'), 'deltaSumSimpleState': ('deltaSum', 'SimpleState'), 'groupBitmapAndSimpleState': ('groupBitmapAnd', 'SimpleState'), 'studentTTestSimpleState': ('studentTTest', 'SimpleState'), 'rankCorrSimpleState': ('rankCorr', 'SimpleState'), 'topKWeightedSimpleState': ('topKWeighted', 'SimpleState'), 'largestTriangleThreeBucketsSimpleState': ('largestTriangleThreeBuckets', 'SimpleState'), 'kurtPopSimpleState': ('kurtPop', 'SimpleState'), 'sequenceCountSimpleState': ('sequenceCount', 'SimpleState'), 'argMaxSimpleState': ('argMax', 'SimpleState'), 'quantilesExactLowSimpleState': ('quantilesExactLow', 'SimpleState'), 'quantileExactSimpleState': ('quantileExact', 'SimpleState'), 'sumMapSimpleState': ('sumMap', 'SimpleState'), 'entropySimpleState': ('entropy', 'SimpleState'), 'approx_top_sumSimpleState': ('approx_top_sum', 'SimpleState'), 'topKSimpleState': ('topK', 'SimpleState'), 'maxIntersectionsPositionSimpleState': ('maxIntersectionsPosition', 'SimpleState'), 'groupBitmapSimpleState': ('groupBitmap', 'SimpleState'), 'quantilesTDigestWeightedSimpleState': ('quantilesTDigestWeighted', 'SimpleState'), 'groupArrayLastSimpleState': ('groupArrayLast', 'SimpleState'), 'groupBitXorSimpleState': ('groupBitXor', 'SimpleState'), 'corrSimpleState': ('corr', 'SimpleState'), 'groupArrayInsertAtSimpleState': ('groupArrayInsertAt', 'SimpleState'), 'mannWhitneyUTestSimpleState': ('mannWhitneyUTest', 'SimpleState'), 'histogramSimpleState': ('histogram', 'SimpleState'), 'uniqExactSimpleState': ('uniqExact', 'SimpleState'), 'quantilesTimingSimpleState': ('quantilesTiming', 'SimpleState'), 'contingencySimpleState': ('contingency', 'SimpleState'), 'stochasticLogisticRegressionSimpleState': ('stochasticLogisticRegression', 'SimpleState'), 'quantilesGKSimpleState': ('quantilesGK', 'SimpleState'), 'maxSimpleState': ('max', 'SimpleState'), 'sequenceNextNodeSimpleState': ('sequenceNextNode', 'SimpleState'), 'quantileTimingWeightedSimpleState': ('quantileTimingWeighted', 'SimpleState'), 'quantilesTimingWeightedSimpleState': ('quantilesTimingWeighted', 'SimpleState'), 'quantilesExactWeightedSimpleState': ('quantilesExactWeighted', 'SimpleState'), 'sumKahanSimpleState': ('sumKahan', 'SimpleState'), 'groupBitOrSimpleState': ('groupBitOr', 'SimpleState'), 'exponentialTimeDecayedAvgSimpleState': ('exponentialTimeDecayedAvg', 'SimpleState'), 'exponentialMovingAverageSimpleState': ('exponentialMovingAverage', 'SimpleState'), 'groupArraySimpleState': ('groupArray', 'SimpleState'), 'quantileBFloat16SimpleState': ('quantileBFloat16', 'SimpleState'), 'sequenceMatchSimpleState': ('sequenceMatch', 'SimpleState'), 'quantileSimpleState': ('quantile', 'SimpleState'), 'welchTTestSimpleState': ('welchTTest', 'SimpleState'), 'sumCountSimpleState': ('sumCount', 'SimpleState'), 'groupBitmapXorSimpleState': ('groupBitmapXor', 'SimpleState'), 'quantilesBFloat16SimpleState': ('quantilesBFloat16', 'SimpleState'), 'anyHeavySimpleState': ('anyHeavy', 'SimpleState'), 'kurtSampSimpleState': ('kurtSamp', 'SimpleState'), 'varPopSimpleState': ('varPop', 'SimpleState'), 'theilsUSimpleState': ('theilsU', 'SimpleState'), 'groupUniqArraySimpleState': ('groupUniqArray', 'SimpleState'), 'quantilesSimpleState': ('quantiles', 'SimpleState'), 'quantilesBFloat16WeightedSimpleState': ('quantilesBFloat16Weighted', 'SimpleState'), 'windowFunnelSimpleState': ('windowFunnel', 'SimpleState'), 'avgSimpleState': ('avg', 'SimpleState'), 'sumSimpleState': ('sum', 'SimpleState'), 'stddevSampSimpleState': ('stddevSamp', 'SimpleState'), 'stddevPopSimpleState': ('stddevPop', 'SimpleState'), 'groupArrayMovingAvgSimpleState': ('groupArrayMovingAvg', 'SimpleState'), 'retentionSimpleState': ('retention', 'SimpleState'), 'groupConcatSimpleState': ('groupConcat', 'SimpleState'), 'skewSampSimpleState': ('skewSamp', 'SimpleState'), 'last_valueSimpleState': ('last_value', 'SimpleState'), 'argMinSimpleState': ('argMin', 'SimpleState'), 'quantileBFloat16WeightedSimpleState': ('quantileBFloat16Weighted', 'SimpleState'), 'meanZTestSimpleState': ('meanZTest', 'SimpleState'), 'quantilesDeterministicSimpleState': ('quantilesDeterministic', 'SimpleState'), 'intervalLengthSumSimpleState': ('intervalLengthSum', 'SimpleState'), 'quantilesTDigestSimpleState': ('quantilesTDigest', 'SimpleState'), 'quantileInterpolatedWeightedSimpleState': ('quantileInterpolatedWeighted', 'SimpleState'), 'quantilesExactSimpleState': ('quantilesExact', 'SimpleState'), 'anySimpleState': ('any', 'SimpleState'), 'quantilesInterpolatedWeightedSimpleState': ('quantilesInterpolatedWeighted', 'SimpleState'), 'countSimpleState': ('count', 'SimpleState'), 'cramersVBiasCorrectedSimpleState': ('cramersVBiasCorrected', 'SimpleState'), 'uniqCombinedSimpleState': ('uniqCombined', 'SimpleState'), 'maxIntersectionsSimpleState': ('maxIntersections', 'SimpleState'), 'uniqHLL12SimpleState': ('uniqHLL12', 'SimpleState'), 'quantileTimingSimpleState': ('quantileTiming', 'SimpleState'), 'first_valueSimpleState': ('first_value', 'SimpleState'), 'covarSampSimpleState': ('covarSamp', 'SimpleState'), 'maxMapSimpleState': ('maxMap', 'SimpleState'), 'avgWeightedSimpleState': ('avgWeighted', 'SimpleState'), 'sumWithOverflowSimpleState': ('sumWithOverflow', 'SimpleState'), 'groupBitmapOrSimpleState': ('groupBitmapOr', 'SimpleState'), 'quantilesExactExclusiveSimpleState': ('quantilesExactExclusive', 'SimpleState'), 'boundingRatioSimpleState': ('boundingRatio', 'SimpleState'), 'groupBitAndSimpleState': ('groupBitAnd', 'SimpleState'), 'skewPopSimpleState': ('skewPop', 'SimpleState'), 'quantileTDigestWeightedSimpleState': ('quantileTDigestWeighted', 'SimpleState'), 'quantileExactWeightedSimpleState': ('quantileExactWeighted', 'SimpleState'), 'stochasticLinearRegressionSimpleState': ('stochasticLinearRegression', 'SimpleState'), 'uniqCombined64SimpleState': ('uniqCombined64', 'SimpleState'), 'anyLastSimpleState': ('anyLast', 'SimpleState'), 'uniqThetaSimpleState': ('uniqTheta', 'SimpleState'), 'varSampSimpleState': ('varSamp', 'SimpleState'), 'deltaSumTimestampSimpleState': ('deltaSumTimestamp', 'SimpleState'), 'simpleLinearRegressionSimpleState': ('simpleLinearRegression', 'SimpleState'), 'quantileExactLowSimpleState': ('quantileExactLow', 'SimpleState'), 'medianSimpleState': ('median', 'SimpleState'), 'cramersVSimpleState': ('cramersV', 'SimpleState'), 'categoricalInformationValueSimpleState': ('categoricalInformationValue', 'SimpleState'), 'quantileGKSimpleState': ('quantileGK', 'SimpleState'), 'covarPopSimpleState': ('covarPop', 'SimpleState'), 'uniqSimpleState': ('uniq', 'SimpleState'), 'minSimpleState': ('min', 'SimpleState'), 'groupArrayMovingSumSimpleState': ('groupArrayMovingSum', 'SimpleState'), 'sparkBarSimpleState': ('sparkBar', 'SimpleState'), 'quantilesExactHighSimpleState': ('quantilesExactHigh', 'SimpleState'), 'quantileDeterministicSimpleState': ('quantileDeterministic', 'SimpleState'), 'uniqUpToSimpleState': ('uniqUpTo', 'SimpleState'), 'kolmogorovSmirnovTestSimpleState': ('kolmogorovSmirnovTest', 'SimpleState'), 'quantileExactHighSimpleState': ('quantileExactHigh', 'SimpleState'), 'groupArraySampleSimpleState': ('groupArraySample', 'SimpleState'), 'minMapSimpleState': ('minMap', 'SimpleState'), 'quantileTDigestMergeState': ('quantileTDigest', 'MergeState'), 'deltaSumMergeState': ('deltaSum', 'MergeState'), 'groupBitmapAndMergeState': ('groupBitmapAnd', 'MergeState'), 'studentTTestMergeState': ('studentTTest', 'MergeState'), 'rankCorrMergeState': ('rankCorr', 'MergeState'), 'topKWeightedMergeState': ('topKWeighted', 'MergeState'), 'largestTriangleThreeBucketsMergeState': ('largestTriangleThreeBuckets', 'MergeState'), 'kurtPopMergeState': ('kurtPop', 'MergeState'), 'sequenceCountMergeState': ('sequenceCount', 'MergeState'), 'argMaxMergeState': ('argMax', 'MergeState'), 'quantilesExactLowMergeState': ('quantilesExactLow', 'MergeState'), 'quantileExactMergeState': ('quantileExact', 'MergeState'), 'sumMapMergeState': ('sumMap', 'MergeState'), 'entropyMergeState': ('entropy', 'MergeState'), 'approx_top_sumMergeState': ('approx_top_sum', 'MergeState'), 'topKMergeState': ('topK', 'MergeState'), 'maxIntersectionsPositionMergeState': ('maxIntersectionsPosition', 'MergeState'), 'groupBitmapMergeState': ('groupBitmap', 'MergeState'), 'quantilesTDigestWeightedMergeState': ('quantilesTDigestWeighted', 'MergeState'), 'groupArrayLastMergeState': ('groupArrayLast', 'MergeState'), 'groupBitXorMergeState': ('groupBitXor', 'MergeState'), 'corrMergeState': ('corr', 'MergeState'), 'groupArrayInsertAtMergeState': ('groupArrayInsertAt', 'MergeState'), 'mannWhitneyUTestMergeState': ('mannWhitneyUTest', 'MergeState'), 'histogramMergeState': ('histogram', 'MergeState'), 'uniqExactMergeState': ('uniqExact', 'MergeState'), 'quantilesTimingMergeState': ('quantilesTiming', 'MergeState'), 'contingencyMergeState': ('contingency', 'MergeState'), 'stochasticLogisticRegressionMergeState': ('stochasticLogisticRegression', 'MergeState'), 'quantilesGKMergeState': ('quantilesGK', 'MergeState'), 'maxMergeState': ('max', 'MergeState'), 'sequenceNextNodeMergeState': ('sequenceNextNode', 'MergeState'), 'quantileTimingWeightedMergeState': ('quantileTimingWeighted', 'MergeState'), 'quantilesTimingWeightedMergeState': ('quantilesTimingWeighted', 'MergeState'), 'quantilesExactWeightedMergeState': ('quantilesExactWeighted', 'MergeState'), 'sumKahanMergeState': ('sumKahan', 'MergeState'), 'groupBitOrMergeState': ('groupBitOr', 'MergeState'), 'exponentialTimeDecayedAvgMergeState': ('exponentialTimeDecayedAvg', 'MergeState'), 'exponentialMovingAverageMergeState': ('exponentialMovingAverage', 'MergeState'), 'groupArrayMergeState': ('groupArray', 'MergeState'), 'quantileBFloat16MergeState': ('quantileBFloat16', 'MergeState'), 'sequenceMatchMergeState': ('sequenceMatch', 'MergeState'), 'quantileMergeState': ('quantile', 'MergeState'), 'welchTTestMergeState': ('welchTTest', 'MergeState'), 'sumCountMergeState': ('sumCount', 'MergeState'), 'groupBitmapXorMergeState': ('groupBitmapXor', 'MergeState'), 'quantilesBFloat16MergeState': ('quantilesBFloat16', 'MergeState'), 'anyHeavyMergeState': ('anyHeavy', 'MergeState'), 'kurtSampMergeState': ('kurtSamp', 'MergeState'), 'varPopMergeState': ('varPop', 'MergeState'), 'theilsUMergeState': ('theilsU', 'MergeState'), 'groupUniqArrayMergeState': ('groupUniqArray', 'MergeState'), 'quantilesMergeState': ('quantiles', 'MergeState'), 'quantilesBFloat16WeightedMergeState': ('quantilesBFloat16Weighted', 'MergeState'), 'windowFunnelMergeState': ('windowFunnel', 'MergeState'), 'avgMergeState': ('avg', 'MergeState'), 'sumMergeState': ('sum', 'MergeState'), 'stddevSampMergeState': ('stddevSamp', 'MergeState'), 'stddevPopMergeState': ('stddevPop', 'MergeState'), 'groupArrayMovingAvgMergeState': ('groupArrayMovingAvg', 'MergeState'), 'retentionMergeState': ('retention', 'MergeState'), 'groupConcatMergeState': ('groupConcat', 'MergeState'), 'skewSampMergeState': ('skewSamp', 'MergeState'), 'last_valueMergeState': ('last_value', 'MergeState'), 'argMinMergeState': ('argMin', 'MergeState'), 'quantileBFloat16WeightedMergeState': ('quantileBFloat16Weighted', 'MergeState'), 'meanZTestMergeState': ('meanZTest', 'MergeState'), 'quantilesDeterministicMergeState': ('quantilesDeterministic', 'MergeState'), 'intervalLengthSumMergeState': ('intervalLengthSum', 'MergeState'), 'quantilesTDigestMergeState': ('quantilesTDigest', 'MergeState'), 'quantileInterpolatedWeightedMergeState': ('quantileInterpolatedWeighted', 'MergeState'), 'quantilesExactMergeState': ('quantilesExact', 'MergeState'), 'anyMergeState': ('any', 'MergeState'), 'quantilesInterpolatedWeightedMergeState': ('quantilesInterpolatedWeighted', 'MergeState'), 'countMergeState': ('count', 'MergeState'), 'cramersVBiasCorrectedMergeState': ('cramersVBiasCorrected', 'MergeState'), 'uniqCombinedMergeState': ('uniqCombined', 'MergeState'), 'maxIntersectionsMergeState': ('maxIntersections', 'MergeState'), 'uniqHLL12MergeState': ('uniqHLL12', 'MergeState'), 'quantileTimingMergeState': ('quantileTiming', 'MergeState'), 'first_valueMergeState': ('first_value', 'MergeState'), 'covarSampMergeState': ('covarSamp', 'MergeState'), 'maxMapMergeState': ('maxMap', 'MergeState'), 'avgWeightedMergeState': ('avgWeighted', 'MergeState'), 'sumWithOverflowMergeState': ('sumWithOverflow', 'MergeState'), 'groupBitmapOrMergeState': ('groupBitmapOr', 'MergeState'), 'quantilesExactExclusiveMergeState': ('quantilesExactExclusive', 'MergeState'), 'boundingRatioMergeState': ('boundingRatio', 'MergeState'), 'groupBitAndMergeState': ('groupBitAnd', 'MergeState'), 'skewPopMergeState': ('skewPop', 'MergeState'), 'quantileTDigestWeightedMergeState': ('quantileTDigestWeighted', 'MergeState'), 'quantileExactWeightedMergeState': ('quantileExactWeighted', 'MergeState'), 'stochasticLinearRegressionMergeState': ('stochasticLinearRegression', 'MergeState'), 'uniqCombined64MergeState': ('uniqCombined64', 'MergeState'), 'anyLastMergeState': ('anyLast', 'MergeState'), 'uniqThetaMergeState': ('uniqTheta', 'MergeState'), 'varSampMergeState': ('varSamp', 'MergeState'), 'deltaSumTimestampMergeState': ('deltaSumTimestamp', 'MergeState'), 'simpleLinearRegressionMergeState': ('simpleLinearRegression', 'MergeState'), 'quantileExactLowMergeState': ('quantileExactLow', 'MergeState'), 'medianMergeState': ('median', 'MergeState'), 'cramersVMergeState': ('cramersV', 'MergeState'), 'categoricalInformationValueMergeState': ('categoricalInformationValue', 'MergeState'), 'quantileGKMergeState': ('quantileGK', 'MergeState'), 'covarPopMergeState': ('covarPop', 'MergeState'), 'uniqMergeState': ('uniq', 'MergeState'), 'minMergeState': ('min', 'MergeState'), 'groupArrayMovingSumMergeState': ('groupArrayMovingSum', 'MergeState'), 'sparkBarMergeState': ('sparkBar', 'MergeState'), 'quantilesExactHighMergeState': ('quantilesExactHigh', 'MergeState'), 'quantileDeterministicMergeState': ('quantileDeterministic', 'MergeState'), 'uniqUpToMergeState': ('uniqUpTo', 'MergeState'), 'kolmogorovSmirnovTestMergeState': ('kolmogorovSmirnovTest', 'MergeState'), 'quantileExactHighMergeState': ('quantileExactHigh', 'MergeState'), 'groupArraySampleMergeState': ('groupArraySample', 'MergeState'), 'minMapMergeState': ('minMap', 'MergeState'), 'quantileTDigestOrDefault': ('quantileTDigest', 'OrDefault'), 'deltaSumOrDefault': ('deltaSum', 'OrDefault'), 'groupBitmapAndOrDefault': ('groupBitmapAnd', 'OrDefault'), 'studentTTestOrDefault': ('studentTTest', 'OrDefault'), 'rankCorrOrDefault': ('rankCorr', 'OrDefault'), 'topKWeightedOrDefault': ('topKWeighted', 'OrDefault'), 'largestTriangleThreeBucketsOrDefault': ('largestTriangleThreeBuckets', 'OrDefault'), 'kurtPopOrDefault': ('kurtPop', 'OrDefault'), 'sequenceCountOrDefault': ('sequenceCount', 'OrDefault'), 'argMaxOrDefault': ('argMax', 'OrDefault'), 'quantilesExactLowOrDefault': ('quantilesExactLow', 'OrDefault'), 'quantileExactOrDefault': ('quantileExact', 'OrDefault'), 'sumMapOrDefault': ('sumMap', 'OrDefault'), 'entropyOrDefault': ('entropy', 'OrDefault'), 'approx_top_sumOrDefault': ('approx_top_sum', 'OrDefault'), 'topKOrDefault': ('topK', 'OrDefault'), 'maxIntersectionsPositionOrDefault': ('maxIntersectionsPosition', 'OrDefault'), 'groupBitmapOrDefault': ('groupBitmap', 'OrDefault'), 'quantilesTDigestWeightedOrDefault': ('quantilesTDigestWeighted', 'OrDefault'), 'groupArrayLastOrDefault': ('groupArrayLast', 'OrDefault'), 'groupBitXorOrDefault': ('groupBitXor', 'OrDefault'), 'corrOrDefault': ('corr', 'OrDefault'), 'groupArrayInsertAtOrDefault': ('groupArrayInsertAt', 'OrDefault'), 'mannWhitneyUTestOrDefault': ('mannWhitneyUTest', 'OrDefault'), 'histogramOrDefault': ('histogram', 'OrDefault'), 'uniqExactOrDefault': ('uniqExact', 'OrDefault'), 'quantilesTimingOrDefault': ('quantilesTiming', 'OrDefault'), 'contingencyOrDefault': ('contingency', 'OrDefault'), 'stochasticLogisticRegressionOrDefault': ('stochasticLogisticRegression', 'OrDefault'), 'quantilesGKOrDefault': ('quantilesGK', 'OrDefault'), 'maxOrDefault': ('max', 'OrDefault'), 'sequenceNextNodeOrDefault': ('sequenceNextNode', 'OrDefault'), 'quantileTimingWeightedOrDefault': ('quantileTimingWeighted', 'OrDefault'), 'quantilesTimingWeightedOrDefault': ('quantilesTimingWeighted', 'OrDefault'), 'quantilesExactWeightedOrDefault': ('quantilesExactWeighted', 'OrDefault'), 'sumKahanOrDefault': ('sumKahan', 'OrDefault'), 'groupBitOrOrDefault': ('groupBitOr', 'OrDefault'), 'exponentialTimeDecayedAvgOrDefault': ('exponentialTimeDecayedAvg', 'OrDefault'), 'exponentialMovingAverageOrDefault': ('exponentialMovingAverage', 'OrDefault'), 'groupArrayOrDefault': ('groupArray', 'OrDefault'), 'quantileBFloat16OrDefault': ('quantileBFloat16', 'OrDefault'), 'sequenceMatchOrDefault': ('sequenceMatch', 'OrDefault'), 'quantileOrDefault': ('quantile', 'OrDefault'), 'welchTTestOrDefault': ('welchTTest', 'OrDefault'), 'sumCountOrDefault': ('sumCount', 'OrDefault'), 'groupBitmapXorOrDefault': ('groupBitmapXor', 'OrDefault'), 'quantilesBFloat16OrDefault': ('quantilesBFloat16', 'OrDefault'), 'anyHeavyOrDefault': ('anyHeavy', 'OrDefault'), 'kurtSampOrDefault': ('kurtSamp', 'OrDefault'), 'varPopOrDefault': ('varPop', 'OrDefault'), 'theilsUOrDefault': ('theilsU', 'OrDefault'), 'groupUniqArrayOrDefault': ('groupUniqArray', 'OrDefault'), 'quantilesOrDefault': ('quantiles', 'OrDefault'), 'quantilesBFloat16WeightedOrDefault': ('quantilesBFloat16Weighted', 'OrDefault'), 'windowFunnelOrDefault': ('windowFunnel', 'OrDefault'), 'avgOrDefault': ('avg', 'OrDefault'), 'sumOrDefault': ('sum', 'OrDefault'), 'stddevSampOrDefault': ('stddevSamp', 'OrDefault'), 'stddevPopOrDefault': ('stddevPop', 'OrDefault'), 'groupArrayMovingAvgOrDefault': ('groupArrayMovingAvg', 'OrDefault'), 'retentionOrDefault': ('retention', 'OrDefault'), 'groupConcatOrDefault': ('groupConcat', 'OrDefault'), 'skewSampOrDefault': ('skewSamp', 'OrDefault'), 'last_valueOrDefault': ('last_value', 'OrDefault'), 'argMinOrDefault': ('argMin', 'OrDefault'), 'quantileBFloat16WeightedOrDefault': ('quantileBFloat16Weighted', 'OrDefault'), 'meanZTestOrDefault': ('meanZTest', 'OrDefault'), 'quantilesDeterministicOrDefault': ('quantilesDeterministic', 'OrDefault'), 'intervalLengthSumOrDefault': ('intervalLengthSum', 'OrDefault'), 'quantilesTDigestOrDefault': ('quantilesTDigest', 'OrDefault'), 'quantileInterpolatedWeightedOrDefault': ('quantileInterpolatedWeighted', 'OrDefault'), 'quantilesExactOrDefault': ('quantilesExact', 'OrDefault'), 'anyOrDefault': ('any', 'OrDefault'), 'quantilesInterpolatedWeightedOrDefault': ('quantilesInterpolatedWeighted', 'OrDefault'), 'countOrDefault': ('count', 'OrDefault'), 'cramersVBiasCorrectedOrDefault': ('cramersVBiasCorrected', 'OrDefault'), 'uniqCombinedOrDefault': ('uniqCombined', 'OrDefault'), 'maxIntersectionsOrDefault': ('maxIntersections', 'OrDefault'), 'uniqHLL12OrDefault': ('uniqHLL12', 'OrDefault'), 'quantileTimingOrDefault': ('quantileTiming', 'OrDefault'), 'first_valueOrDefault': ('first_value', 'OrDefault'), 'covarSampOrDefault': ('covarSamp', 'OrDefault'), 'maxMapOrDefault': ('maxMap', 'OrDefault'), 'avgWeightedOrDefault': ('avgWeighted', 'OrDefault'), 'sumWithOverflowOrDefault': ('sumWithOverflow', 'OrDefault'), 'groupBitmapOrOrDefault': ('groupBitmapOr', 'OrDefault'), 'quantilesExactExclusiveOrDefault': ('quantilesExactExclusive', 'OrDefault'), 'boundingRatioOrDefault': ('boundingRatio', 'OrDefault'), 'groupBitAndOrDefault': ('groupBitAnd', 'OrDefault'), 'skewPopOrDefault': ('skewPop', 'OrDefault'), 'quantileTDigestWeightedOrDefault': ('quantileTDigestWeighted', 'OrDefault'), 'quantileExactWeightedOrDefault': ('quantileExactWeighted', 'OrDefault'), 'stochasticLinearRegressionOrDefault': ('stochasticLinearRegression', 'OrDefault'), 'uniqCombined64OrDefault': ('uniqCombined64', 'OrDefault'), 'anyLastOrDefault': ('anyLast', 'OrDefault'), 'uniqThetaOrDefault': ('uniqTheta', 'OrDefault'), 'varSampOrDefault': ('varSamp', 'OrDefault'), 'deltaSumTimestampOrDefault': ('deltaSumTimestamp', 'OrDefault'), 'simpleLinearRegressionOrDefault': ('simpleLinearRegression', 'OrDefault'), 'quantileExactLowOrDefault': ('quantileExactLow', 'OrDefault'), 'medianOrDefault': ('median', 'OrDefault'), 'cramersVOrDefault': ('cramersV', 'OrDefault'), 'categoricalInformationValueOrDefault': ('categoricalInformationValue', 'OrDefault'), 'quantileGKOrDefault': ('quantileGK', 'OrDefault'), 'covarPopOrDefault': ('covarPop', 'OrDefault'), 'uniqOrDefault': ('uniq', 'OrDefault'), 'minOrDefault': ('min', 'OrDefault'), 'groupArrayMovingSumOrDefault': ('groupArrayMovingSum', 'OrDefault'), 'sparkBarOrDefault': ('sparkBar', 'OrDefault'), 'quantilesExactHighOrDefault': ('quantilesExactHigh', 'OrDefault'), 'quantileDeterministicOrDefault': ('quantileDeterministic', 'OrDefault'), 'uniqUpToOrDefault': ('uniqUpTo', 'OrDefault'), 'kolmogorovSmirnovTestOrDefault': ('kolmogorovSmirnovTest', 'OrDefault'), 'quantileExactHighOrDefault': ('quantileExactHigh', 'OrDefault'), 'groupArraySampleOrDefault': ('groupArraySample', 'OrDefault'), 'minMapOrDefault': ('minMap', 'OrDefault'), 'quantileTDigestDistinct': ('quantileTDigest', 'Distinct'), 'deltaSumDistinct': ('deltaSum', 'Distinct'), 'groupBitmapAndDistinct': ('groupBitmapAnd', 'Distinct'), 'studentTTestDistinct': ('studentTTest', 'Distinct'), 'rankCorrDistinct': ('rankCorr', 'Distinct'), 'topKWeightedDistinct': ('topKWeighted', 'Distinct'), 'largestTriangleThreeBucketsDistinct': ('largestTriangleThreeBuckets', 'Distinct'), 'kurtPopDistinct': ('kurtPop', 'Distinct'), 'sequenceCountDistinct': ('sequenceCount', 'Distinct'), 'argMaxDistinct': ('argMax', 'Distinct'), 'quantilesExactLowDistinct': ('quantilesExactLow', 'Distinct'), 'quantileExactDistinct': ('quantileExact', 'Distinct'), 'sumMapDistinct': ('sumMap', 'Distinct'), 'entropyDistinct': ('entropy', 'Distinct'), 'approx_top_sumDistinct': ('approx_top_sum', 'Distinct'), 'topKDistinct': ('topK', 'Distinct'), 'maxIntersectionsPositionDistinct': ('maxIntersectionsPosition', 'Distinct'), 'groupBitmapDistinct': ('groupBitmap', 'Distinct'), 'quantilesTDigestWeightedDistinct': ('quantilesTDigestWeighted', 'Distinct'), 'groupArrayLastDistinct': ('groupArrayLast', 'Distinct'), 'groupBitXorDistinct': ('groupBitXor', 'Distinct'), 'corrDistinct': ('corr', 'Distinct'), 'groupArrayInsertAtDistinct': ('groupArrayInsertAt', 'Distinct'), 'mannWhitneyUTestDistinct': ('mannWhitneyUTest', 'Distinct'), 'histogramDistinct': ('histogram', 'Distinct'), 'uniqExactDistinct': ('uniqExact', 'Distinct'), 'quantilesTimingDistinct': ('quantilesTiming', 'Distinct'), 'contingencyDistinct': ('contingency', 'Distinct'), 'stochasticLogisticRegressionDistinct': ('stochasticLogisticRegression', 'Distinct'), 'quantilesGKDistinct': ('quantilesGK', 'Distinct'), 'maxDistinct': ('max', 'Distinct'), 'sequenceNextNodeDistinct': ('sequenceNextNode', 'Distinct'), 'quantileTimingWeightedDistinct': ('quantileTimingWeighted', 'Distinct'), 'quantilesTimingWeightedDistinct': ('quantilesTimingWeighted', 'Distinct'), 'quantilesExactWeightedDistinct': ('quantilesExactWeighted', 'Distinct'), 'sumKahanDistinct': ('sumKahan', 'Distinct'), 'groupBitOrDistinct': ('groupBitOr', 'Distinct'), 'exponentialTimeDecayedAvgDistinct': ('exponentialTimeDecayedAvg', 'Distinct'), 'exponentialMovingAverageDistinct': ('exponentialMovingAverage', 'Distinct'), 'groupArrayDistinct': ('groupArray', 'Distinct'), 'quantileBFloat16Distinct': ('quantileBFloat16', 'Distinct'), 'sequenceMatchDistinct': ('sequenceMatch', 'Distinct'), 'quantileDistinct': ('quantile', 'Distinct'), 'welchTTestDistinct': ('welchTTest', 'Distinct'), 'sumCountDistinct': ('sumCount', 'Distinct'), 'groupBitmapXorDistinct': ('groupBitmapXor', 'Distinct'), 'quantilesBFloat16Distinct': ('quantilesBFloat16', 'Distinct'), 'anyHeavyDistinct': ('anyHeavy', 'Distinct'), 'kurtSampDistinct': ('kurtSamp', 'Distinct'), 'varPopDistinct': ('varPop', 'Distinct'), 'theilsUDistinct': ('theilsU', 'Distinct'), 'groupUniqArrayDistinct': ('groupUniqArray', 'Distinct'), 'quantilesDistinct': ('quantiles', 'Distinct'), 'quantilesBFloat16WeightedDistinct': ('quantilesBFloat16Weighted', 'Distinct'), 'windowFunnelDistinct': ('windowFunnel', 'Distinct'), 'avgDistinct': ('avg', 'Distinct'), 'sumDistinct': ('sum', 'Distinct'), 'stddevSampDistinct': ('stddevSamp', 'Distinct'), 'stddevPopDistinct': ('stddevPop', 'Distinct'), 'groupArrayMovingAvgDistinct': ('groupArrayMovingAvg', 'Distinct'), 'retentionDistinct': ('retention', 'Distinct'), 'groupConcatDistinct': ('groupConcat', 'Distinct'), 'skewSampDistinct': ('skewSamp', 'Distinct'), 'last_valueDistinct': ('last_value', 'Distinct'), 'argMinDistinct': ('argMin', 'Distinct'), 'quantileBFloat16WeightedDistinct': ('quantileBFloat16Weighted', 'Distinct'), 'meanZTestDistinct': ('meanZTest', 'Distinct'), 'quantilesDeterministicDistinct': ('quantilesDeterministic', 'Distinct'), 'intervalLengthSumDistinct': ('intervalLengthSum', 'Distinct'), 'quantilesTDigestDistinct': ('quantilesTDigest', 'Distinct'), 'quantileInterpolatedWeightedDistinct': ('quantileInterpolatedWeighted', 'Distinct'), 'quantilesExactDistinct': ('quantilesExact', 'Distinct'), 'anyDistinct': ('any', 'Distinct'), 'quantilesInterpolatedWeightedDistinct': ('quantilesInterpolatedWeighted', 'Distinct'), 'countDistinct': ('count', 'Distinct'), 'cramersVBiasCorrectedDistinct': ('cramersVBiasCorrected', 'Distinct'), 'uniqCombinedDistinct': ('uniqCombined', 'Distinct'), 'maxIntersectionsDistinct': ('maxIntersections', 'Distinct'), 'uniqHLL12Distinct': ('uniqHLL12', 'Distinct'), 'quantileTimingDistinct': ('quantileTiming', 'Distinct'), 'first_valueDistinct': ('first_value', 'Distinct'), 'covarSampDistinct': ('covarSamp', 'Distinct'), 'maxMapDistinct': ('maxMap', 'Distinct'), 'avgWeightedDistinct': ('avgWeighted', 'Distinct'), 'sumWithOverflowDistinct': ('sumWithOverflow', 'Distinct'), 'groupBitmapOrDistinct': ('groupBitmapOr', 'Distinct'), 'quantilesExactExclusiveDistinct': ('quantilesExactExclusive', 'Distinct'), 'boundingRatioDistinct': ('boundingRatio', 'Distinct'), 'groupBitAndDistinct': ('groupBitAnd', 'Distinct'), 'skewPopDistinct': ('skewPop', 'Distinct'), 'quantileTDigestWeightedDistinct': ('quantileTDigestWeighted', 'Distinct'), 'quantileExactWeightedDistinct': ('quantileExactWeighted', 'Distinct'), 'stochasticLinearRegressionDistinct': ('stochasticLinearRegression', 'Distinct'), 'uniqCombined64Distinct': ('uniqCombined64', 'Distinct'), 'anyLastDistinct': ('anyLast', 'Distinct'), 'uniqThetaDistinct': ('uniqTheta', 'Distinct'), 'varSampDistinct': ('varSamp', 'Distinct'), 'deltaSumTimestampDistinct': ('deltaSumTimestamp', 'Distinct'), 'simpleLinearRegressionDistinct': ('simpleLinearRegression', 'Distinct'), 'quantileExactLowDistinct': ('quantileExactLow', 'Distinct'), 'medianDistinct': ('median', 'Distinct'), 'cramersVDistinct': ('cramersV', 'Distinct'), 'categoricalInformationValueDistinct': ('categoricalInformationValue', 'Distinct'), 'quantileGKDistinct': ('quantileGK', 'Distinct'), 'covarPopDistinct': ('covarPop', 'Distinct'), 'uniqDistinct': ('uniq', 'Distinct'), 'minDistinct': ('min', 'Distinct'), 'groupArrayMovingSumDistinct': ('groupArrayMovingSum', 'Distinct'), 'sparkBarDistinct': ('sparkBar', 'Distinct'), 'quantilesExactHighDistinct': ('quantilesExactHigh', 'Distinct'), 'quantileDeterministicDistinct': ('quantileDeterministic', 'Distinct'), 'uniqUpToDistinct': ('uniqUpTo', 'Distinct'), 'kolmogorovSmirnovTestDistinct': ('kolmogorovSmirnovTest', 'Distinct'), 'quantileExactHighDistinct': ('quantileExactHigh', 'Distinct'), 'groupArraySampleDistinct': ('groupArraySample', 'Distinct'), 'minMapDistinct': ('minMap', 'Distinct'), 'quantileTDigestResample': ('quantileTDigest', 'Resample'), 'deltaSumResample': ('deltaSum', 'Resample'), 'groupBitmapAndResample': ('groupBitmapAnd', 'Resample'), 'studentTTestResample': ('studentTTest', 'Resample'), 'rankCorrResample': ('rankCorr', 'Resample'), 'topKWeightedResample': ('topKWeighted', 'Resample'), 'largestTriangleThreeBucketsResample': ('largestTriangleThreeBuckets', 'Resample'), 'kurtPopResample': ('kurtPop', 'Resample'), 'sequenceCountResample': ('sequenceCount', 'Resample'), 'argMaxResample': ('argMax', 'Resample'), 'quantilesExactLowResample': ('quantilesExactLow', 'Resample'), 'quantileExactResample': ('quantileExact', 'Resample'), 'sumMapResample': ('sumMap', 'Resample'), 'entropyResample': ('entropy', 'Resample'), 'approx_top_sumResample': ('approx_top_sum', 'Resample'), 'topKResample': ('topK', 'Resample'), 'maxIntersectionsPositionResample': ('maxIntersectionsPosition', 'Resample'), 'groupBitmapResample': ('groupBitmap', 'Resample'), 'quantilesTDigestWeightedResample': ('quantilesTDigestWeighted', 'Resample'), 'groupArrayLastResample': ('groupArrayLast', 'Resample'), 'groupBitXorResample': ('groupBitXor', 'Resample'), 'corrResample': ('corr', 'Resample'), 'groupArrayInsertAtResample': ('groupArrayInsertAt', 'Resample'), 'mannWhitneyUTestResample': ('mannWhitneyUTest', 'Resample'), 'histogramResample': ('histogram', 'Resample'), 'uniqExactResample': ('uniqExact', 'Resample'), 'quantilesTimingResample': ('quantilesTiming', 'Resample'), 'contingencyResample': ('contingency', 'Resample'), 'stochasticLogisticRegressionResample': ('stochasticLogisticRegression', 'Resample'), 'quantilesGKResample': ('quantilesGK', 'Resample'), 'maxResample': ('max', 'Resample'), 'sequenceNextNodeResample': ('sequenceNextNode', 'Resample'), 'quantileTimingWeightedResample': ('quantileTimingWeighted', 'Resample'), 'quantilesTimingWeightedResample': ('quantilesTimingWeighted', 'Resample'), 'quantilesExactWeightedResample': ('quantilesExactWeighted', 'Resample'), 'sumKahanResample': ('sumKahan', 'Resample'), 'groupBitOrResample': ('groupBitOr', 'Resample'), 'exponentialTimeDecayedAvgResample': ('exponentialTimeDecayedAvg', 'Resample'), 'exponentialMovingAverageResample': ('exponentialMovingAverage', 'Resample'), 'groupArrayResample': ('groupArray', 'Resample'), 'quantileBFloat16Resample': ('quantileBFloat16', 'Resample'), 'sequenceMatchResample': ('sequenceMatch', 'Resample'), 'quantileResample': ('quantile', 'Resample'), 'welchTTestResample': ('welchTTest', 'Resample'), 'sumCountResample': ('sumCount', 'Resample'), 'groupBitmapXorResample': ('groupBitmapXor', 'Resample'), 'quantilesBFloat16Resample': ('quantilesBFloat16', 'Resample'), 'anyHeavyResample': ('anyHeavy', 'Resample'), 'kurtSampResample': ('kurtSamp', 'Resample'), 'varPopResample': ('varPop', 'Resample'), 'theilsUResample': ('theilsU', 'Resample'), 'groupUniqArrayResample': ('groupUniqArray', 'Resample'), 'quantilesResample': ('quantiles', 'Resample'), 'quantilesBFloat16WeightedResample': ('quantilesBFloat16Weighted', 'Resample'), 'windowFunnelResample': ('windowFunnel', 'Resample'), 'avgResample': ('avg', 'Resample'), 'sumResample': ('sum', 'Resample'), 'stddevSampResample': ('stddevSamp', 'Resample'), 'stddevPopResample': ('stddevPop', 'Resample'), 'groupArrayMovingAvgResample': ('groupArrayMovingAvg', 'Resample'), 'retentionResample': ('retention', 'Resample'), 'groupConcatResample': ('groupConcat', 'Resample'), 'skewSampResample': ('skewSamp', 'Resample'), 'last_valueResample': ('last_value', 'Resample'), 'argMinResample': ('argMin', 'Resample'), 'quantileBFloat16WeightedResample': ('quantileBFloat16Weighted', 'Resample'), 'meanZTestResample': ('meanZTest', 'Resample'), 'quantilesDeterministicResample': ('quantilesDeterministic', 'Resample'), 'intervalLengthSumResample': ('intervalLengthSum', 'Resample'), 'quantilesTDigestResample': ('quantilesTDigest', 'Resample'), 'quantileInterpolatedWeightedResample': ('quantileInterpolatedWeighted', 'Resample'), 'quantilesExactResample': ('quantilesExact', 'Resample'), 'anyResample': ('any', 'Resample'), 'quantilesInterpolatedWeightedResample': ('quantilesInterpolatedWeighted', 'Resample'), 'countResample': ('count', 'Resample'), 'cramersVBiasCorrectedResample': ('cramersVBiasCorrected', 'Resample'), 'uniqCombinedResample': ('uniqCombined', 'Resample'), 'maxIntersectionsResample': ('maxIntersections', 'Resample'), 'uniqHLL12Resample': ('uniqHLL12', 'Resample'), 'quantileTimingResample': ('quantileTiming', 'Resample'), 'first_valueResample': ('first_value', 'Resample'), 'covarSampResample': ('covarSamp', 'Resample'), 'maxMapResample': ('maxMap', 'Resample'), 'avgWeightedResample': ('avgWeighted', 'Resample'), 'sumWithOverflowResample': ('sumWithOverflow', 'Resample'), 'groupBitmapOrResample': ('groupBitmapOr', 'Resample'), 'quantilesExactExclusiveResample': ('quantilesExactExclusive', 'Resample'), 'boundingRatioResample': ('boundingRatio', 'Resample'), 'groupBitAndResample': ('groupBitAnd', 'Resample'), 'skewPopResample': ('skewPop', 'Resample'), 'quantileTDigestWeightedResample': ('quantileTDigestWeighted', 'Resample'), 'quantileExactWeightedResample': ('quantileExactWeighted', 'Resample'), 'stochasticLinearRegressionResample': ('stochasticLinearRegression', 'Resample'), 'uniqCombined64Resample': ('uniqCombined64', 'Resample'), 'anyLastResample': ('anyLast', 'Resample'), 'uniqThetaResample': ('uniqTheta', 'Resample'), 'varSampResample': ('varSamp', 'Resample'), 'deltaSumTimestampResample': ('deltaSumTimestamp', 'Resample'), 'simpleLinearRegressionResample': ('simpleLinearRegression', 'Resample'), 'quantileExactLowResample': ('quantileExactLow', 'Resample'), 'medianResample': ('median', 'Resample'), 'cramersVResample': ('cramersV', 'Resample'), 'categoricalInformationValueResample': ('categoricalInformationValue', 'Resample'), 'quantileGKResample': ('quantileGK', 'Resample'), 'covarPopResample': ('covarPop', 'Resample'), 'uniqResample': ('uniq', 'Resample'), 'minResample': ('min', 'Resample'), 'groupArrayMovingSumResample': ('groupArrayMovingSum', 'Resample'), 'sparkBarResample': ('sparkBar', 'Resample'), 'quantilesExactHighResample': ('quantilesExactHigh', 'Resample'), 'quantileDeterministicResample': ('quantileDeterministic', 'Resample'), 'uniqUpToResample': ('uniqUpTo', 'Resample'), 'kolmogorovSmirnovTestResample': ('kolmogorovSmirnovTest', 'Resample'), 'quantileExactHighResample': ('quantileExactHigh', 'Resample'), 'groupArraySampleResample': ('groupArraySample', 'Resample'), 'minMapResample': ('minMap', 'Resample'), 'quantileTDigestArrayIf': ('quantileTDigest', 'ArrayIf'), 'deltaSumArrayIf': ('deltaSum', 'ArrayIf'), 'groupBitmapAndArrayIf': ('groupBitmapAnd', 'ArrayIf'), 'studentTTestArrayIf': ('studentTTest', 'ArrayIf'), 'rankCorrArrayIf': ('rankCorr', 'ArrayIf'), 'topKWeightedArrayIf': ('topKWeighted', 'ArrayIf'), 'largestTriangleThreeBucketsArrayIf': ('largestTriangleThreeBuckets', 'ArrayIf'), 'kurtPopArrayIf': ('kurtPop', 'ArrayIf'), 'sequenceCountArrayIf': ('sequenceCount', 'ArrayIf'), 'argMaxArrayIf': ('argMax', 'ArrayIf'), 'quantilesExactLowArrayIf': ('quantilesExactLow', 'ArrayIf'), 'quantileExactArrayIf': ('quantileExact', 'ArrayIf'), 'sumMapArrayIf': ('sumMap', 'ArrayIf'), 'entropyArrayIf': ('entropy', 'ArrayIf'), 'approx_top_sumArrayIf': ('approx_top_sum', 'ArrayIf'), 'topKArrayIf': ('topK', 'ArrayIf'), 'maxIntersectionsPositionArrayIf': ('maxIntersectionsPosition', 'ArrayIf'), 'groupBitmapArrayIf': ('groupBitmap', 'ArrayIf'), 'quantilesTDigestWeightedArrayIf': ('quantilesTDigestWeighted', 'ArrayIf'), 'groupArrayLastArrayIf': ('groupArrayLast', 'ArrayIf'), 'groupBitXorArrayIf': ('groupBitXor', 'ArrayIf'), 'corrArrayIf': ('corr', 'ArrayIf'), 'groupArrayInsertAtArrayIf': ('groupArrayInsertAt', 'ArrayIf'), 'mannWhitneyUTestArrayIf': ('mannWhitneyUTest', 'ArrayIf'), 'histogramArrayIf': ('histogram', 'ArrayIf'), 'uniqExactArrayIf': ('uniqExact', 'ArrayIf'), 'quantilesTimingArrayIf': ('quantilesTiming', 'ArrayIf'), 'contingencyArrayIf': ('contingency', 'ArrayIf'), 'stochasticLogisticRegressionArrayIf': ('stochasticLogisticRegression', 'ArrayIf'), 'quantilesGKArrayIf': ('quantilesGK', 'ArrayIf'), 'maxArrayIf': ('max', 'ArrayIf'), 'sequenceNextNodeArrayIf': ('sequenceNextNode', 'ArrayIf'), 'quantileTimingWeightedArrayIf': ('quantileTimingWeighted', 'ArrayIf'), 'quantilesTimingWeightedArrayIf': ('quantilesTimingWeighted', 'ArrayIf'), 'quantilesExactWeightedArrayIf': ('quantilesExactWeighted', 'ArrayIf'), 'sumKahanArrayIf': ('sumKahan', 'ArrayIf'), 'groupBitOrArrayIf': ('groupBitOr', 'ArrayIf'), 'exponentialTimeDecayedAvgArrayIf': ('exponentialTimeDecayedAvg', 'ArrayIf'), 'exponentialMovingAverageArrayIf': ('exponentialMovingAverage', 'ArrayIf'), 'groupArrayArrayIf': ('groupArray', 'ArrayIf'), 'quantileBFloat16ArrayIf': ('quantileBFloat16', 'ArrayIf'), 'sequenceMatchArrayIf': ('sequenceMatch', 'ArrayIf'), 'quantileArrayIf': ('quantile', 'ArrayIf'), 'welchTTestArrayIf': ('welchTTest', 'ArrayIf'), 'sumCountArrayIf': ('sumCount', 'ArrayIf'), 'groupBitmapXorArrayIf': ('groupBitmapXor', 'ArrayIf'), 'quantilesBFloat16ArrayIf': ('quantilesBFloat16', 'ArrayIf'), 'anyHeavyArrayIf': ('anyHeavy', 'ArrayIf'), 'kurtSampArrayIf': ('kurtSamp', 'ArrayIf'), 'varPopArrayIf': ('varPop', 'ArrayIf'), 'theilsUArrayIf': ('theilsU', 'ArrayIf'), 'groupUniqArrayArrayIf': ('groupUniqArray', 'ArrayIf'), 'quantilesArrayIf': ('quantiles', 'ArrayIf'), 'quantilesBFloat16WeightedArrayIf': ('quantilesBFloat16Weighted', 'ArrayIf'), 'windowFunnelArrayIf': ('windowFunnel', 'ArrayIf'), 'avgArrayIf': ('avg', 'ArrayIf'), 'sumArrayIf': ('sum', 'ArrayIf'), 'stddevSampArrayIf': ('stddevSamp', 'ArrayIf'), 'stddevPopArrayIf': ('stddevPop', 'ArrayIf'), 'groupArrayMovingAvgArrayIf': ('groupArrayMovingAvg', 'ArrayIf'), 'retentionArrayIf': ('retention', 'ArrayIf'), 'groupConcatArrayIf': ('groupConcat', 'ArrayIf'), 'skewSampArrayIf': ('skewSamp', 'ArrayIf'), 'last_valueArrayIf': ('last_value', 'ArrayIf'), 'argMinArrayIf': ('argMin', 'ArrayIf'), 'quantileBFloat16WeightedArrayIf': ('quantileBFloat16Weighted', 'ArrayIf'), 'meanZTestArrayIf': ('meanZTest', 'ArrayIf'), 'quantilesDeterministicArrayIf': ('quantilesDeterministic', 'ArrayIf'), 'intervalLengthSumArrayIf': ('intervalLengthSum', 'ArrayIf'), 'quantilesTDigestArrayIf': ('quantilesTDigest', 'ArrayIf'), 'quantileInterpolatedWeightedArrayIf': ('quantileInterpolatedWeighted', 'ArrayIf'), 'quantilesExactArrayIf': ('quantilesExact', 'ArrayIf'), 'anyArrayIf': ('any', 'ArrayIf'), 'quantilesInterpolatedWeightedArrayIf': ('quantilesInterpolatedWeighted', 'ArrayIf'), 'countArrayIf': ('count', 'ArrayIf'), 'cramersVBiasCorrectedArrayIf': ('cramersVBiasCorrected', 'ArrayIf'), 'uniqCombinedArrayIf': ('uniqCombined', 'ArrayIf'), 'maxIntersectionsArrayIf': ('maxIntersections', 'ArrayIf'), 'uniqHLL12ArrayIf': ('uniqHLL12', 'ArrayIf'), 'quantileTimingArrayIf': ('quantileTiming', 'ArrayIf'), 'first_valueArrayIf': ('first_value', 'ArrayIf'), 'covarSampArrayIf': ('covarSamp', 'ArrayIf'), 'maxMapArrayIf': ('maxMap', 'ArrayIf'), 'avgWeightedArrayIf': ('avgWeighted', 'ArrayIf'), 'sumWithOverflowArrayIf': ('sumWithOverflow', 'ArrayIf'), 'groupBitmapOrArrayIf': ('groupBitmapOr', 'ArrayIf'), 'quantilesExactExclusiveArrayIf': ('quantilesExactExclusive', 'ArrayIf'), 'boundingRatioArrayIf': ('boundingRatio', 'ArrayIf'), 'groupBitAndArrayIf': ('groupBitAnd', 'ArrayIf'), 'skewPopArrayIf': ('skewPop', 'ArrayIf'), 'quantileTDigestWeightedArrayIf': ('quantileTDigestWeighted', 'ArrayIf'), 'quantileExactWeightedArrayIf': ('quantileExactWeighted', 'ArrayIf'), 'stochasticLinearRegressionArrayIf': ('stochasticLinearRegression', 'ArrayIf'), 'uniqCombined64ArrayIf': ('uniqCombined64', 'ArrayIf'), 'anyLastArrayIf': ('anyLast', 'ArrayIf'), 'uniqThetaArrayIf': ('uniqTheta', 'ArrayIf'), 'varSampArrayIf': ('varSamp', 'ArrayIf'), 'deltaSumTimestampArrayIf': ('deltaSumTimestamp', 'ArrayIf'), 'simpleLinearRegressionArrayIf': ('simpleLinearRegression', 'ArrayIf'), 'quantileExactLowArrayIf': ('quantileExactLow', 'ArrayIf'), 'medianArrayIf': ('median', 'ArrayIf'), 'cramersVArrayIf': ('cramersV', 'ArrayIf'), 'categoricalInformationValueArrayIf': ('categoricalInformationValue', 'ArrayIf'), 'quantileGKArrayIf': ('quantileGK', 'ArrayIf'), 'covarPopArrayIf': ('covarPop', 'ArrayIf'), 'uniqArrayIf': ('uniq', 'ArrayIf'), 'minArrayIf': ('min', 'ArrayIf'), 'groupArrayMovingSumArrayIf': ('groupArrayMovingSum', 'ArrayIf'), 'sparkBarArrayIf': ('sparkBar', 'ArrayIf'), 'quantilesExactHighArrayIf': ('quantilesExactHigh', 'ArrayIf'), 'quantileDeterministicArrayIf': ('quantileDeterministic', 'ArrayIf'), 'uniqUpToArrayIf': ('uniqUpTo', 'ArrayIf'), 'kolmogorovSmirnovTestArrayIf': ('kolmogorovSmirnovTest', 'ArrayIf'), 'quantileExactHighArrayIf': ('quantileExactHigh', 'ArrayIf'), 'groupArraySampleArrayIf': ('groupArraySample', 'ArrayIf'), 'minMapArrayIf': ('minMap', 'ArrayIf'), 'quantileTDigestForEach': ('quantileTDigest', 'ForEach'), 'deltaSumForEach': ('deltaSum', 'ForEach'), 'groupBitmapAndForEach': ('groupBitmapAnd', 'ForEach'), 'studentTTestForEach': ('studentTTest', 'ForEach'), 'rankCorrForEach': ('rankCorr', 'ForEach'), 'topKWeightedForEach': ('topKWeighted', 'ForEach'), 'largestTriangleThreeBucketsForEach': ('largestTriangleThreeBuckets', 'ForEach'), 'kurtPopForEach': ('kurtPop', 'ForEach'), 'sequenceCountForEach': ('sequenceCount', 'ForEach'), 'argMaxForEach': ('argMax', 'ForEach'), 'quantilesExactLowForEach': ('quantilesExactLow', 'ForEach'), 'quantileExactForEach': ('quantileExact', 'ForEach'), 'sumMapForEach': ('sumMap', 'ForEach'), 'entropyForEach': ('entropy', 'ForEach'), 'approx_top_sumForEach': ('approx_top_sum', 'ForEach'), 'topKForEach': ('topK', 'ForEach'), 'maxIntersectionsPositionForEach': ('maxIntersectionsPosition', 'ForEach'), 'groupBitmapForEach': ('groupBitmap', 'ForEach'), 'quantilesTDigestWeightedForEach': ('quantilesTDigestWeighted', 'ForEach'), 'groupArrayLastForEach': ('groupArrayLast', 'ForEach'), 'groupBitXorForEach': ('groupBitXor', 'ForEach'), 'corrForEach': ('corr', 'ForEach'), 'groupArrayInsertAtForEach': ('groupArrayInsertAt', 'ForEach'), 'mannWhitneyUTestForEach': ('mannWhitneyUTest', 'ForEach'), 'histogramForEach': ('histogram', 'ForEach'), 'uniqExactForEach': ('uniqExact', 'ForEach'), 'quantilesTimingForEach': ('quantilesTiming', 'ForEach'), 'contingencyForEach': ('contingency', 'ForEach'), 'stochasticLogisticRegressionForEach': ('stochasticLogisticRegression', 'ForEach'), 'quantilesGKForEach': ('quantilesGK', 'ForEach'), 'maxForEach': ('max', 'ForEach'), 'sequenceNextNodeForEach': ('sequenceNextNode', 'ForEach'), 'quantileTimingWeightedForEach': ('quantileTimingWeighted', 'ForEach'), 'quantilesTimingWeightedForEach': ('quantilesTimingWeighted', 'ForEach'), 'quantilesExactWeightedForEach': ('quantilesExactWeighted', 'ForEach'), 'sumKahanForEach': ('sumKahan', 'ForEach'), 'groupBitOrForEach': ('groupBitOr', 'ForEach'), 'exponentialTimeDecayedAvgForEach': ('exponentialTimeDecayedAvg', 'ForEach'), 'exponentialMovingAverageForEach': ('exponentialMovingAverage', 'ForEach'), 'groupArrayForEach': ('groupArray', 'ForEach'), 'quantileBFloat16ForEach': ('quantileBFloat16', 'ForEach'), 'sequenceMatchForEach': ('sequenceMatch', 'ForEach'), 'quantileForEach': ('quantile', 'ForEach'), 'welchTTestForEach': ('welchTTest', 'ForEach'), 'sumCountForEach': ('sumCount', 'ForEach'), 'groupBitmapXorForEach': ('groupBitmapXor', 'ForEach'), 'quantilesBFloat16ForEach': ('quantilesBFloat16', 'ForEach'), 'anyHeavyForEach': ('anyHeavy', 'ForEach'), 'kurtSampForEach': ('kurtSamp', 'ForEach'), 'varPopForEach': ('varPop', 'ForEach'), 'theilsUForEach': ('theilsU', 'ForEach'), 'groupUniqArrayForEach': ('groupUniqArray', 'ForEach'), 'quantilesForEach': ('quantiles', 'ForEach'), 'quantilesBFloat16WeightedForEach': ('quantilesBFloat16Weighted', 'ForEach'), 'windowFunnelForEach': ('windowFunnel', 'ForEach'), 'avgForEach': ('avg', 'ForEach'), 'sumForEach': ('sum', 'ForEach'), 'stddevSampForEach': ('stddevSamp', 'ForEach'), 'stddevPopForEach': ('stddevPop', 'ForEach'), 'groupArrayMovingAvgForEach': ('groupArrayMovingAvg', 'ForEach'), 'retentionForEach': ('retention', 'ForEach'), 'groupConcatForEach': ('groupConcat', 'ForEach'), 'skewSampForEach': ('skewSamp', 'ForEach'), 'last_valueForEach': ('last_value', 'ForEach'), 'argMinForEach': ('argMin', 'ForEach'), 'quantileBFloat16WeightedForEach': ('quantileBFloat16Weighted', 'ForEach'), 'meanZTestForEach': ('meanZTest', 'ForEach'), 'quantilesDeterministicForEach': ('quantilesDeterministic', 'ForEach'), 'intervalLengthSumForEach': ('intervalLengthSum', 'ForEach'), 'quantilesTDigestForEach': ('quantilesTDigest', 'ForEach'), 'quantileInterpolatedWeightedForEach': ('quantileInterpolatedWeighted', 'ForEach'), 'quantilesExactForEach': ('quantilesExact', 'ForEach'), 'anyForEach': ('any', 'ForEach'), 'quantilesInterpolatedWeightedForEach': ('quantilesInterpolatedWeighted', 'ForEach'), 'countForEach': ('count', 'ForEach'), 'cramersVBiasCorrectedForEach': ('cramersVBiasCorrected', 'ForEach'), 'uniqCombinedForEach': ('uniqCombined', 'ForEach'), 'maxIntersectionsForEach': ('maxIntersections', 'ForEach'), 'uniqHLL12ForEach': ('uniqHLL12', 'ForEach'), 'quantileTimingForEach': ('quantileTiming', 'ForEach'), 'first_valueForEach': ('first_value', 'ForEach'), 'covarSampForEach': ('covarSamp', 'ForEach'), 'maxMapForEach': ('maxMap', 'ForEach'), 'avgWeightedForEach': ('avgWeighted', 'ForEach'), 'sumWithOverflowForEach': ('sumWithOverflow', 'ForEach'), 'groupBitmapOrForEach': ('groupBitmapOr', 'ForEach'), 'quantilesExactExclusiveForEach': ('quantilesExactExclusive', 'ForEach'), 'boundingRatioForEach': ('boundingRatio', 'ForEach'), 'groupBitAndForEach': ('groupBitAnd', 'ForEach'), 'skewPopForEach': ('skewPop', 'ForEach'), 'quantileTDigestWeightedForEach': ('quantileTDigestWeighted', 'ForEach'), 'quantileExactWeightedForEach': ('quantileExactWeighted', 'ForEach'), 'stochasticLinearRegressionForEach': ('stochasticLinearRegression', 'ForEach'), 'uniqCombined64ForEach': ('uniqCombined64', 'ForEach'), 'anyLastForEach': ('anyLast', 'ForEach'), 'uniqThetaForEach': ('uniqTheta', 'ForEach'), 'varSampForEach': ('varSamp', 'ForEach'), 'deltaSumTimestampForEach': ('deltaSumTimestamp', 'ForEach'), 'simpleLinearRegressionForEach': ('simpleLinearRegression', 'ForEach'), 'quantileExactLowForEach': ('quantileExactLow', 'ForEach'), 'medianForEach': ('median', 'ForEach'), 'cramersVForEach': ('cramersV', 'ForEach'), 'categoricalInformationValueForEach': ('categoricalInformationValue', 'ForEach'), 'quantileGKForEach': ('quantileGK', 'ForEach'), 'covarPopForEach': ('covarPop', 'ForEach'), 'uniqForEach': ('uniq', 'ForEach'), 'minForEach': ('min', 'ForEach'), 'groupArrayMovingSumForEach': ('groupArrayMovingSum', 'ForEach'), 'sparkBarForEach': ('sparkBar', 'ForEach'), 'quantilesExactHighForEach': ('quantilesExactHigh', 'ForEach'), 'quantileDeterministicForEach': ('quantileDeterministic', 'ForEach'), 'uniqUpToForEach': ('uniqUpTo', 'ForEach'), 'kolmogorovSmirnovTestForEach': ('kolmogorovSmirnovTest', 'ForEach'), 'quantileExactHighForEach': ('quantileExactHigh', 'ForEach'), 'groupArraySampleForEach': ('groupArraySample', 'ForEach'), 'minMapForEach': ('minMap', 'ForEach'), 'quantileTDigestOrNull': ('quantileTDigest', 'OrNull'), 'deltaSumOrNull': ('deltaSum', 'OrNull'), 'groupBitmapAndOrNull': ('groupBitmapAnd', 'OrNull'), 'studentTTestOrNull': ('studentTTest', 'OrNull'), 'rankCorrOrNull': ('rankCorr', 'OrNull'), 'topKWeightedOrNull': ('topKWeighted', 'OrNull'), 'largestTriangleThreeBucketsOrNull': ('largestTriangleThreeBuckets', 'OrNull'), 'kurtPopOrNull': ('kurtPop', 'OrNull'), 'sequenceCountOrNull': ('sequenceCount', 'OrNull'), 'argMaxOrNull': ('argMax', 'OrNull'), 'quantilesExactLowOrNull': ('quantilesExactLow', 'OrNull'), 'quantileExactOrNull': ('quantileExact', 'OrNull'), 'sumMapOrNull': ('sumMap', 'OrNull'), 'entropyOrNull': ('entropy', 'OrNull'), 'approx_top_sumOrNull': ('approx_top_sum', 'OrNull'), 'topKOrNull': ('topK', 'OrNull'), 'maxIntersectionsPositionOrNull': ('maxIntersectionsPosition', 'OrNull'), 'groupBitmapOrNull': ('groupBitmap', 'OrNull'), 'quantilesTDigestWeightedOrNull': ('quantilesTDigestWeighted', 'OrNull'), 'groupArrayLastOrNull': ('groupArrayLast', 'OrNull'), 'groupBitXorOrNull': ('groupBitXor', 'OrNull'), 'corrOrNull': ('corr', 'OrNull'), 'groupArrayInsertAtOrNull': ('groupArrayInsertAt', 'OrNull'), 'mannWhitneyUTestOrNull': ('mannWhitneyUTest', 'OrNull'), 'histogramOrNull': ('histogram', 'OrNull'), 'uniqExactOrNull': ('uniqExact', 'OrNull'), 'quantilesTimingOrNull': ('quantilesTiming', 'OrNull'), 'contingencyOrNull': ('contingency', 'OrNull'), 'stochasticLogisticRegressionOrNull': ('stochasticLogisticRegression', 'OrNull'), 'quantilesGKOrNull': ('quantilesGK', 'OrNull'), 'maxOrNull': ('max', 'OrNull'), 'sequenceNextNodeOrNull': ('sequenceNextNode', 'OrNull'), 'quantileTimingWeightedOrNull': ('quantileTimingWeighted', 'OrNull'), 'quantilesTimingWeightedOrNull': ('quantilesTimingWeighted', 'OrNull'), 'quantilesExactWeightedOrNull': ('quantilesExactWeighted', 'OrNull'), 'sumKahanOrNull': ('sumKahan', 'OrNull'), 'groupBitOrOrNull': ('groupBitOr', 'OrNull'), 'exponentialTimeDecayedAvgOrNull': ('exponentialTimeDecayedAvg', 'OrNull'), 'exponentialMovingAverageOrNull': ('exponentialMovingAverage', 'OrNull'), 'groupArrayOrNull': ('groupArray', 'OrNull'), 'quantileBFloat16OrNull': ('quantileBFloat16', 'OrNull'), 'sequenceMatchOrNull': ('sequenceMatch', 'OrNull'), 'quantileOrNull': ('quantile', 'OrNull'), 'welchTTestOrNull': ('welchTTest', 'OrNull'), 'sumCountOrNull': ('sumCount', 'OrNull'), 'groupBitmapXorOrNull': ('groupBitmapXor', 'OrNull'), 'quantilesBFloat16OrNull': ('quantilesBFloat16', 'OrNull'), 'anyHeavyOrNull': ('anyHeavy', 'OrNull'), 'kurtSampOrNull': ('kurtSamp', 'OrNull'), 'varPopOrNull': ('varPop', 'OrNull'), 'theilsUOrNull': ('theilsU', 'OrNull'), 'groupUniqArrayOrNull': ('groupUniqArray', 'OrNull'), 'quantilesOrNull': ('quantiles', 'OrNull'), 'quantilesBFloat16WeightedOrNull': ('quantilesBFloat16Weighted', 'OrNull'), 'windowFunnelOrNull': ('windowFunnel', 'OrNull'), 'avgOrNull': ('avg', 'OrNull'), 'sumOrNull': ('sum', 'OrNull'), 'stddevSampOrNull': ('stddevSamp', 'OrNull'), 'stddevPopOrNull': ('stddevPop', 'OrNull'), 'groupArrayMovingAvgOrNull': ('groupArrayMovingAvg', 'OrNull'), 'retentionOrNull': ('retention', 'OrNull'), 'groupConcatOrNull': ('groupConcat', 'OrNull'), 'skewSampOrNull': ('skewSamp', 'OrNull'), 'last_valueOrNull': ('last_value', 'OrNull'), 'argMinOrNull': ('argMin', 'OrNull'), 'quantileBFloat16WeightedOrNull': ('quantileBFloat16Weighted', 'OrNull'), 'meanZTestOrNull': ('meanZTest', 'OrNull'), 'quantilesDeterministicOrNull': ('quantilesDeterministic', 'OrNull'), 'intervalLengthSumOrNull': ('intervalLengthSum', 'OrNull'), 'quantilesTDigestOrNull': ('quantilesTDigest', 'OrNull'), 'quantileInterpolatedWeightedOrNull': ('quantileInterpolatedWeighted', 'OrNull'), 'quantilesExactOrNull': ('quantilesExact', 'OrNull'), 'anyOrNull': ('any', 'OrNull'), 'quantilesInterpolatedWeightedOrNull': ('quantilesInterpolatedWeighted', 'OrNull'), 'countOrNull': ('count', 'OrNull'), 'cramersVBiasCorrectedOrNull': ('cramersVBiasCorrected', 'OrNull'), 'uniqCombinedOrNull': ('uniqCombined', 'OrNull'), 'maxIntersectionsOrNull': ('maxIntersections', 'OrNull'), 'uniqHLL12OrNull': ('uniqHLL12', 'OrNull'), 'quantileTimingOrNull': ('quantileTiming', 'OrNull'), 'first_valueOrNull': ('first_value', 'OrNull'), 'covarSampOrNull': ('covarSamp', 'OrNull'), 'maxMapOrNull': ('maxMap', 'OrNull'), 'avgWeightedOrNull': ('avgWeighted', 'OrNull'), 'sumWithOverflowOrNull': ('sumWithOverflow', 'OrNull'), 'groupBitmapOrOrNull': ('groupBitmapOr', 'OrNull'), 'quantilesExactExclusiveOrNull': ('quantilesExactExclusive', 'OrNull'), 'boundingRatioOrNull': ('boundingRatio', 'OrNull'), 'groupBitAndOrNull': ('groupBitAnd', 'OrNull'), 'skewPopOrNull': ('skewPop', 'OrNull'), 'quantileTDigestWeightedOrNull': ('quantileTDigestWeighted', 'OrNull'), 'quantileExactWeightedOrNull': ('quantileExactWeighted', 'OrNull'), 'stochasticLinearRegressionOrNull': ('stochasticLinearRegression', 'OrNull'), 'uniqCombined64OrNull': ('uniqCombined64', 'OrNull'), 'anyLastOrNull': ('anyLast', 'OrNull'), 'uniqThetaOrNull': ('uniqTheta', 'OrNull'), 'varSampOrNull': ('varSamp', 'OrNull'), 'deltaSumTimestampOrNull': ('deltaSumTimestamp', 'OrNull'), 'simpleLinearRegressionOrNull': ('simpleLinearRegression', 'OrNull'), 'quantileExactLowOrNull': ('quantileExactLow', 'OrNull'), 'medianOrNull': ('median', 'OrNull'), 'cramersVOrNull': ('cramersV', 'OrNull'), 'categoricalInformationValueOrNull': ('categoricalInformationValue', 'OrNull'), 'quantileGKOrNull': ('quantileGK', 'OrNull'), 'covarPopOrNull': ('covarPop', 'OrNull'), 'uniqOrNull': ('uniq', 'OrNull'), 'minOrNull': ('min', 'OrNull'), 'groupArrayMovingSumOrNull': ('groupArrayMovingSum', 'OrNull'), 'sparkBarOrNull': ('sparkBar', 'OrNull'), 'quantilesExactHighOrNull': ('quantilesExactHigh', 'OrNull'), 'quantileDeterministicOrNull': ('quantileDeterministic', 'OrNull'), 'uniqUpToOrNull': ('uniqUpTo', 'OrNull'), 'kolmogorovSmirnovTestOrNull': ('kolmogorovSmirnovTest', 'OrNull'), 'quantileExactHighOrNull': ('quantileExactHigh', 'OrNull'), 'groupArraySampleOrNull': ('groupArraySample', 'OrNull'), 'minMapOrNull': ('minMap', 'OrNull'), 'quantileTDigestArgMin': ('quantileTDigest', 'ArgMin'), 'deltaSumArgMin': ('deltaSum', 'ArgMin'), 'groupBitmapAndArgMin': ('groupBitmapAnd', 'ArgMin'), 'studentTTestArgMin': ('studentTTest', 'ArgMin'), 'rankCorrArgMin': ('rankCorr', 'ArgMin'), 'topKWeightedArgMin': ('topKWeighted', 'ArgMin'), 'largestTriangleThreeBucketsArgMin': ('largestTriangleThreeBuckets', 'ArgMin'), 'kurtPopArgMin': ('kurtPop', 'ArgMin'), 'sequenceCountArgMin': ('sequenceCount', 'ArgMin'), 'argMaxArgMin': ('argMax', 'ArgMin'), 'quantilesExactLowArgMin': ('quantilesExactLow', 'ArgMin'), 'quantileExactArgMin': ('quantileExact', 'ArgMin'), 'sumMapArgMin': ('sumMap', 'ArgMin'), 'entropyArgMin': ('entropy', 'ArgMin'), 'approx_top_sumArgMin': ('approx_top_sum', 'ArgMin'), 'topKArgMin': ('topK', 'ArgMin'), 'maxIntersectionsPositionArgMin': ('maxIntersectionsPosition', 'ArgMin'), 'groupBitmapArgMin': ('groupBitmap', 'ArgMin'), 'quantilesTDigestWeightedArgMin': ('quantilesTDigestWeighted', 'ArgMin'), 'groupArrayLastArgMin': ('groupArrayLast', 'ArgMin'), 'groupBitXorArgMin': ('groupBitXor', 'ArgMin'), 'corrArgMin': ('corr', 'ArgMin'), 'groupArrayInsertAtArgMin': ('groupArrayInsertAt', 'ArgMin'), 'mannWhitneyUTestArgMin': ('mannWhitneyUTest', 'ArgMin'), 'histogramArgMin': ('histogram', 'ArgMin'), 'uniqExactArgMin': ('uniqExact', 'ArgMin'), 'quantilesTimingArgMin': ('quantilesTiming', 'ArgMin'), 'contingencyArgMin': ('contingency', 'ArgMin'), 'stochasticLogisticRegressionArgMin': ('stochasticLogisticRegression', 'ArgMin'), 'quantilesGKArgMin': ('quantilesGK', 'ArgMin'), 'maxArgMin': ('max', 'ArgMin'), 'sequenceNextNodeArgMin': ('sequenceNextNode', 'ArgMin'), 'quantileTimingWeightedArgMin': ('quantileTimingWeighted', 'ArgMin'), 'quantilesTimingWeightedArgMin': ('quantilesTimingWeighted', 'ArgMin'), 'quantilesExactWeightedArgMin': ('quantilesExactWeighted', 'ArgMin'), 'sumKahanArgMin': ('sumKahan', 'ArgMin'), 'groupBitOrArgMin': ('groupBitOr', 'ArgMin'), 'exponentialTimeDecayedAvgArgMin': ('exponentialTimeDecayedAvg', 'ArgMin'), 'exponentialMovingAverageArgMin': ('exponentialMovingAverage', 'ArgMin'), 'groupArrayArgMin': ('groupArray', 'ArgMin'), 'quantileBFloat16ArgMin': ('quantileBFloat16', 'ArgMin'), 'sequenceMatchArgMin': ('sequenceMatch', 'ArgMin'), 'quantileArgMin': ('quantile', 'ArgMin'), 'welchTTestArgMin': ('welchTTest', 'ArgMin'), 'sumCountArgMin': ('sumCount', 'ArgMin'), 'groupBitmapXorArgMin': ('groupBitmapXor', 'ArgMin'), 'quantilesBFloat16ArgMin': ('quantilesBFloat16', 'ArgMin'), 'anyHeavyArgMin': ('anyHeavy', 'ArgMin'), 'kurtSampArgMin': ('kurtSamp', 'ArgMin'), 'varPopArgMin': ('varPop', 'ArgMin'), 'theilsUArgMin': ('theilsU', 'ArgMin'), 'groupUniqArrayArgMin': ('groupUniqArray', 'ArgMin'), 'quantilesArgMin': ('quantiles', 'ArgMin'), 'quantilesBFloat16WeightedArgMin': ('quantilesBFloat16Weighted', 'ArgMin'), 'windowFunnelArgMin': ('windowFunnel', 'ArgMin'), 'avgArgMin': ('avg', 'ArgMin'), 'sumArgMin': ('sum', 'ArgMin'), 'stddevSampArgMin': ('stddevSamp', 'ArgMin'), 'stddevPopArgMin': ('stddevPop', 'ArgMin'), 'groupArrayMovingAvgArgMin': ('groupArrayMovingAvg', 'ArgMin'), 'retentionArgMin': ('retention', 'ArgMin'), 'groupConcatArgMin': ('groupConcat', 'ArgMin'), 'skewSampArgMin': ('skewSamp', 'ArgMin'), 'last_valueArgMin': ('last_value', 'ArgMin'), 'argMinArgMin': ('argMin', 'ArgMin'), 'quantileBFloat16WeightedArgMin': ('quantileBFloat16Weighted', 'ArgMin'), 'meanZTestArgMin': ('meanZTest', 'ArgMin'), 'quantilesDeterministicArgMin': ('quantilesDeterministic', 'ArgMin'), 'intervalLengthSumArgMin': ('intervalLengthSum', 'ArgMin'), 'quantilesTDigestArgMin': ('quantilesTDigest', 'ArgMin'), 'quantileInterpolatedWeightedArgMin': ('quantileInterpolatedWeighted', 'ArgMin'), 'quantilesExactArgMin': ('quantilesExact', 'ArgMin'), 'anyArgMin': ('any', 'ArgMin'), 'quantilesInterpolatedWeightedArgMin': ('quantilesInterpolatedWeighted', 'ArgMin'), 'countArgMin': ('count', 'ArgMin'), 'cramersVBiasCorrectedArgMin': ('cramersVBiasCorrected', 'ArgMin'), 'uniqCombinedArgMin': ('uniqCombined', 'ArgMin'), 'maxIntersectionsArgMin': ('maxIntersections', 'ArgMin'), 'uniqHLL12ArgMin': ('uniqHLL12', 'ArgMin'), 'quantileTimingArgMin': ('quantileTiming', 'ArgMin'), 'first_valueArgMin': ('first_value', 'ArgMin'), 'covarSampArgMin': ('covarSamp', 'ArgMin'), 'maxMapArgMin': ('maxMap', 'ArgMin'), 'avgWeightedArgMin': ('avgWeighted', 'ArgMin'), 'sumWithOverflowArgMin': ('sumWithOverflow', 'ArgMin'), 'groupBitmapOrArgMin': ('groupBitmapOr', 'ArgMin'), 'quantilesExactExclusiveArgMin': ('quantilesExactExclusive', 'ArgMin'), 'boundingRatioArgMin': ('boundingRatio', 'ArgMin'), 'groupBitAndArgMin': ('groupBitAnd', 'ArgMin'), 'skewPopArgMin': ('skewPop', 'ArgMin'), 'quantileTDigestWeightedArgMin': ('quantileTDigestWeighted', 'ArgMin'), 'quantileExactWeightedArgMin': ('quantileExactWeighted', 'ArgMin'), 'stochasticLinearRegressionArgMin': ('stochasticLinearRegression', 'ArgMin'), 'uniqCombined64ArgMin': ('uniqCombined64', 'ArgMin'), 'anyLastArgMin': ('anyLast', 'ArgMin'), 'uniqThetaArgMin': ('uniqTheta', 'ArgMin'), 'varSampArgMin': ('varSamp', 'ArgMin'), 'deltaSumTimestampArgMin': ('deltaSumTimestamp', 'ArgMin'), 'simpleLinearRegressionArgMin': ('simpleLinearRegression', 'ArgMin'), 'quantileExactLowArgMin': ('quantileExactLow', 'ArgMin'), 'medianArgMin': ('median', 'ArgMin'), 'cramersVArgMin': ('cramersV', 'ArgMin'), 'categoricalInformationValueArgMin': ('categoricalInformationValue', 'ArgMin'), 'quantileGKArgMin': ('quantileGK', 'ArgMin'), 'covarPopArgMin': ('covarPop', 'ArgMin'), 'uniqArgMin': ('uniq', 'ArgMin'), 'minArgMin': ('min', 'ArgMin'), 'groupArrayMovingSumArgMin': ('groupArrayMovingSum', 'ArgMin'), 'sparkBarArgMin': ('sparkBar', 'ArgMin'), 'quantilesExactHighArgMin': ('quantilesExactHigh', 'ArgMin'), 'quantileDeterministicArgMin': ('quantileDeterministic', 'ArgMin'), 'uniqUpToArgMin': ('uniqUpTo', 'ArgMin'), 'kolmogorovSmirnovTestArgMin': ('kolmogorovSmirnovTest', 'ArgMin'), 'quantileExactHighArgMin': ('quantileExactHigh', 'ArgMin'), 'groupArraySampleArgMin': ('groupArraySample', 'ArgMin'), 'minMapArgMin': ('minMap', 'ArgMin'), 'quantileTDigestArgMax': ('quantileTDigest', 'ArgMax'), 'deltaSumArgMax': ('deltaSum', 'ArgMax'), 'groupBitmapAndArgMax': ('groupBitmapAnd', 'ArgMax'), 'studentTTestArgMax': ('studentTTest', 'ArgMax'), 'rankCorrArgMax': ('rankCorr', 'ArgMax'), 'topKWeightedArgMax': ('topKWeighted', 'ArgMax'), 'largestTriangleThreeBucketsArgMax': ('largestTriangleThreeBuckets', 'ArgMax'), 'kurtPopArgMax': ('kurtPop', 'ArgMax'), 'sequenceCountArgMax': ('sequenceCount', 'ArgMax'), 'argMaxArgMax': ('argMax', 'ArgMax'), 'quantilesExactLowArgMax': ('quantilesExactLow', 'ArgMax'), 'quantileExactArgMax': ('quantileExact', 'ArgMax'), 'sumMapArgMax': ('sumMap', 'ArgMax'), 'entropyArgMax': ('entropy', 'ArgMax'), 'approx_top_sumArgMax': ('approx_top_sum', 'ArgMax'), 'topKArgMax': ('topK', 'ArgMax'), 'maxIntersectionsPositionArgMax': ('maxIntersectionsPosition', 'ArgMax'), 'groupBitmapArgMax': ('groupBitmap', 'ArgMax'), 'quantilesTDigestWeightedArgMax': ('quantilesTDigestWeighted', 'ArgMax'), 'groupArrayLastArgMax': ('groupArrayLast', 'ArgMax'), 'groupBitXorArgMax': ('groupBitXor', 'ArgMax'), 'corrArgMax': ('corr', 'ArgMax'), 'groupArrayInsertAtArgMax': ('groupArrayInsertAt', 'ArgMax'), 'mannWhitneyUTestArgMax': ('mannWhitneyUTest', 'ArgMax'), 'histogramArgMax': ('histogram', 'ArgMax'), 'uniqExactArgMax': ('uniqExact', 'ArgMax'), 'quantilesTimingArgMax': ('quantilesTiming', 'ArgMax'), 'contingencyArgMax': ('contingency', 'ArgMax'), 'stochasticLogisticRegressionArgMax': ('stochasticLogisticRegression', 'ArgMax'), 'quantilesGKArgMax': ('quantilesGK', 'ArgMax'), 'maxArgMax': ('max', 'ArgMax'), 'sequenceNextNodeArgMax': ('sequenceNextNode', 'ArgMax'), 'quantileTimingWeightedArgMax': ('quantileTimingWeighted', 'ArgMax'), 'quantilesTimingWeightedArgMax': ('quantilesTimingWeighted', 'ArgMax'), 'quantilesExactWeightedArgMax': ('quantilesExactWeighted', 'ArgMax'), 'sumKahanArgMax': ('sumKahan', 'ArgMax'), 'groupBitOrArgMax': ('groupBitOr', 'ArgMax'), 'exponentialTimeDecayedAvgArgMax': ('exponentialTimeDecayedAvg', 'ArgMax'), 'exponentialMovingAverageArgMax': ('exponentialMovingAverage', 'ArgMax'), 'groupArrayArgMax': ('groupArray', 'ArgMax'), 'quantileBFloat16ArgMax': ('quantileBFloat16', 'ArgMax'), 'sequenceMatchArgMax': ('sequenceMatch', 'ArgMax'), 'quantileArgMax': ('quantile', 'ArgMax'), 'welchTTestArgMax': ('welchTTest', 'ArgMax'), 'sumCountArgMax': ('sumCount', 'ArgMax'), 'groupBitmapXorArgMax': ('groupBitmapXor', 'ArgMax'), 'quantilesBFloat16ArgMax': ('quantilesBFloat16', 'ArgMax'), 'anyHeavyArgMax': ('anyHeavy', 'ArgMax'), 'kurtSampArgMax': ('kurtSamp', 'ArgMax'), 'varPopArgMax': ('varPop', 'ArgMax'), 'theilsUArgMax': ('theilsU', 'ArgMax'), 'groupUniqArrayArgMax': ('groupUniqArray', 'ArgMax'), 'quantilesArgMax': ('quantiles', 'ArgMax'), 'quantilesBFloat16WeightedArgMax': ('quantilesBFloat16Weighted', 'ArgMax'), 'windowFunnelArgMax': ('windowFunnel', 'ArgMax'), 'avgArgMax': ('avg', 'ArgMax'), 'sumArgMax': ('sum', 'ArgMax'), 'stddevSampArgMax': ('stddevSamp', 'ArgMax'), 'stddevPopArgMax': ('stddevPop', 'ArgMax'), 'groupArrayMovingAvgArgMax': ('groupArrayMovingAvg', 'ArgMax'), 'retentionArgMax': ('retention', 'ArgMax'), 'groupConcatArgMax': ('groupConcat', 'ArgMax'), 'skewSampArgMax': ('skewSamp', 'ArgMax'), 'last_valueArgMax': ('last_value', 'ArgMax'), 'argMinArgMax': ('argMin', 'ArgMax'), 'quantileBFloat16WeightedArgMax': ('quantileBFloat16Weighted', 'ArgMax'), 'meanZTestArgMax': ('meanZTest', 'ArgMax'), 'quantilesDeterministicArgMax': ('quantilesDeterministic', 'ArgMax'), 'intervalLengthSumArgMax': ('intervalLengthSum', 'ArgMax'), 'quantilesTDigestArgMax': ('quantilesTDigest', 'ArgMax'), 'quantileInterpolatedWeightedArgMax': ('quantileInterpolatedWeighted', 'ArgMax'), 'quantilesExactArgMax': ('quantilesExact', 'ArgMax'), 'anyArgMax': ('any', 'ArgMax'), 'quantilesInterpolatedWeightedArgMax': ('quantilesInterpolatedWeighted', 'ArgMax'), 'countArgMax': ('count', 'ArgMax'), 'cramersVBiasCorrectedArgMax': ('cramersVBiasCorrected', 'ArgMax'), 'uniqCombinedArgMax': ('uniqCombined', 'ArgMax'), 'maxIntersectionsArgMax': ('maxIntersections', 'ArgMax'), 'uniqHLL12ArgMax': ('uniqHLL12', 'ArgMax'), 'quantileTimingArgMax': ('quantileTiming', 'ArgMax'), 'first_valueArgMax': ('first_value', 'ArgMax'), 'covarSampArgMax': ('covarSamp', 'ArgMax'), 'maxMapArgMax': ('maxMap', 'ArgMax'), 'avgWeightedArgMax': ('avgWeighted', 'ArgMax'), 'sumWithOverflowArgMax': ('sumWithOverflow', 'ArgMax'), 'groupBitmapOrArgMax': ('groupBitmapOr', 'ArgMax'), 'quantilesExactExclusiveArgMax': ('quantilesExactExclusive', 'ArgMax'), 'boundingRatioArgMax': ('boundingRatio', 'ArgMax'), 'groupBitAndArgMax': ('groupBitAnd', 'ArgMax'), 'skewPopArgMax': ('skewPop', 'ArgMax'), 'quantileTDigestWeightedArgMax': ('quantileTDigestWeighted', 'ArgMax'), 'quantileExactWeightedArgMax': ('quantileExactWeighted', 'ArgMax'), 'stochasticLinearRegressionArgMax': ('stochasticLinearRegression', 'ArgMax'), 'uniqCombined64ArgMax': ('uniqCombined64', 'ArgMax'), 'anyLastArgMax': ('anyLast', 'ArgMax'), 'uniqThetaArgMax': ('uniqTheta', 'ArgMax'), 'varSampArgMax': ('varSamp', 'ArgMax'), 'deltaSumTimestampArgMax': ('deltaSumTimestamp', 'ArgMax'), 'simpleLinearRegressionArgMax': ('simpleLinearRegression', 'ArgMax'), 'quantileExactLowArgMax': ('quantileExactLow', 'ArgMax'), 'medianArgMax': ('median', 'ArgMax'), 'cramersVArgMax': ('cramersV', 'ArgMax'), 'categoricalInformationValueArgMax': ('categoricalInformationValue', 'ArgMax'), 'quantileGKArgMax': ('quantileGK', 'ArgMax'), 'covarPopArgMax': ('covarPop', 'ArgMax'), 'uniqArgMax': ('uniq', 'ArgMax'), 'minArgMax': ('min', 'ArgMax'), 'groupArrayMovingSumArgMax': ('groupArrayMovingSum', 'ArgMax'), 'sparkBarArgMax': ('sparkBar', 'ArgMax'), 'quantilesExactHighArgMax': ('quantilesExactHigh', 'ArgMax'), 'quantileDeterministicArgMax': ('quantileDeterministic', 'ArgMax'), 'uniqUpToArgMax': ('uniqUpTo', 'ArgMax'), 'kolmogorovSmirnovTestArgMax': ('kolmogorovSmirnovTest', 'ArgMax'), 'quantileExactHighArgMax': ('quantileExactHigh', 'ArgMax'), 'groupArraySampleArgMax': ('groupArraySample', 'ArgMax'), 'minMapArgMax': ('minMap', 'ArgMax'), 'quantileTDigestArray': ('quantileTDigest', 'Array'), 'deltaSumArray': ('deltaSum', 'Array'), 'groupBitmapAndArray': ('groupBitmapAnd', 'Array'), 'studentTTestArray': ('studentTTest', 'Array'), 'rankCorrArray': ('rankCorr', 'Array'), 'topKWeightedArray': ('topKWeighted', 'Array'), 'largestTriangleThreeBucketsArray': ('largestTriangleThreeBuckets', 'Array'), 'kurtPopArray': ('kurtPop', 'Array'), 'sequenceCountArray': ('sequenceCount', 'Array'), 'argMaxArray': ('argMax', 'Array'), 'quantilesExactLowArray': ('quantilesExactLow', 'Array'), 'quantileExactArray': ('quantileExact', 'Array'), 'sumMapArray': ('sumMap', 'Array'), 'entropyArray': ('entropy', 'Array'), 'approx_top_sumArray': ('approx_top_sum', 'Array'), 'topKArray': ('topK', 'Array'), 'maxIntersectionsPositionArray': ('maxIntersectionsPosition', 'Array'), 'groupBitmapArray': ('groupBitmap', 'Array'), 'quantilesTDigestWeightedArray': ('quantilesTDigestWeighted', 'Array'), 'groupArrayLastArray': ('groupArrayLast', 'Array'), 'groupBitXorArray': ('groupBitXor', 'Array'), 'corrArray': ('corr', 'Array'), 'groupArrayInsertAtArray': ('groupArrayInsertAt', 'Array'), 'mannWhitneyUTestArray': ('mannWhitneyUTest', 'Array'), 'histogramArray': ('histogram', 'Array'), 'uniqExactArray': ('uniqExact', 'Array'), 'quantilesTimingArray': ('quantilesTiming', 'Array'), 'contingencyArray': ('contingency', 'Array'), 'stochasticLogisticRegressionArray': ('stochasticLogisticRegression', 'Array'), 'quantilesGKArray': ('quantilesGK', 'Array'), 'maxArray': ('max', 'Array'), 'sequenceNextNodeArray': ('sequenceNextNode', 'Array'), 'quantileTimingWeightedArray': ('quantileTimingWeighted', 'Array'), 'quantilesTimingWeightedArray': ('quantilesTimingWeighted', 'Array'), 'quantilesExactWeightedArray': ('quantilesExactWeighted', 'Array'), 'sumKahanArray': ('sumKahan', 'Array'), 'groupBitOrArray': ('groupBitOr', 'Array'), 'exponentialTimeDecayedAvgArray': ('exponentialTimeDecayedAvg', 'Array'), 'exponentialMovingAverageArray': ('exponentialMovingAverage', 'Array'), 'groupArrayArray': ('groupArray', 'Array'), 'quantileBFloat16Array': ('quantileBFloat16', 'Array'), 'sequenceMatchArray': ('sequenceMatch', 'Array'), 'quantileArray': ('quantile', 'Array'), 'welchTTestArray': ('welchTTest', 'Array'), 'sumCountArray': ('sumCount', 'Array'), 'groupBitmapXorArray': ('groupBitmapXor', 'Array'), 'quantilesBFloat16Array': ('quantilesBFloat16', 'Array'), 'anyHeavyArray': ('anyHeavy', 'Array'), 'kurtSampArray': ('kurtSamp', 'Array'), 'varPopArray': ('varPop', 'Array'), 'theilsUArray': ('theilsU', 'Array'), 'groupUniqArrayArray': ('groupUniqArray', 'Array'), 'quantilesArray': ('quantiles', 'Array'), 'quantilesBFloat16WeightedArray': ('quantilesBFloat16Weighted', 'Array'), 'windowFunnelArray': ('windowFunnel', 'Array'), 'avgArray': ('avg', 'Array'), 'sumArray': ('sum', 'Array'), 'stddevSampArray': ('stddevSamp', 'Array'), 'stddevPopArray': ('stddevPop', 'Array'), 'groupArrayMovingAvgArray': ('groupArrayMovingAvg', 'Array'), 'retentionArray': ('retention', 'Array'), 'groupConcatArray': ('groupConcat', 'Array'), 'skewSampArray': ('skewSamp', 'Array'), 'last_valueArray': ('last_value', 'Array'), 'argMinArray': ('argMin', 'Array'), 'quantileBFloat16WeightedArray': ('quantileBFloat16Weighted', 'Array'), 'meanZTestArray': ('meanZTest', 'Array'), 'quantilesDeterministicArray': ('quantilesDeterministic', 'Array'), 'intervalLengthSumArray': ('intervalLengthSum', 'Array'), 'quantilesTDigestArray': ('quantilesTDigest', 'Array'), 'quantileInterpolatedWeightedArray': ('quantileInterpolatedWeighted', 'Array'), 'quantilesExactArray': ('quantilesExact', 'Array'), 'anyArray': ('any', 'Array'), 'quantilesInterpolatedWeightedArray': ('quantilesInterpolatedWeighted', 'Array'), 'countArray': ('count', 'Array'), 'cramersVBiasCorrectedArray': ('cramersVBiasCorrected', 'Array'), 'uniqCombinedArray': ('uniqCombined', 'Array'), 'maxIntersectionsArray': ('maxIntersections', 'Array'), 'uniqHLL12Array': ('uniqHLL12', 'Array'), 'quantileTimingArray': ('quantileTiming', 'Array'), 'first_valueArray': ('first_value', 'Array'), 'covarSampArray': ('covarSamp', 'Array'), 'maxMapArray': ('maxMap', 'Array'), 'avgWeightedArray': ('avgWeighted', 'Array'), 'sumWithOverflowArray': ('sumWithOverflow', 'Array'), 'groupBitmapOrArray': ('groupBitmapOr', 'Array'), 'quantilesExactExclusiveArray': ('quantilesExactExclusive', 'Array'), 'boundingRatioArray': ('boundingRatio', 'Array'), 'groupBitAndArray': ('groupBitAnd', 'Array'), 'skewPopArray': ('skewPop', 'Array'), 'quantileTDigestWeightedArray': ('quantileTDigestWeighted', 'Array'), 'quantileExactWeightedArray': ('quantileExactWeighted', 'Array'), 'stochasticLinearRegressionArray': ('stochasticLinearRegression', 'Array'), 'uniqCombined64Array': ('uniqCombined64', 'Array'), 'anyLastArray': ('anyLast', 'Array'), 'uniqThetaArray': ('uniqTheta', 'Array'), 'varSampArray': ('varSamp', 'Array'), 'deltaSumTimestampArray': ('deltaSumTimestamp', 'Array'), 'simpleLinearRegressionArray': ('simpleLinearRegression', 'Array'), 'quantileExactLowArray': ('quantileExactLow', 'Array'), 'medianArray': ('median', 'Array'), 'cramersVArray': ('cramersV', 'Array'), 'categoricalInformationValueArray': ('categoricalInformationValue', 'Array'), 'quantileGKArray': ('quantileGK', 'Array'), 'covarPopArray': ('covarPop', 'Array'), 'uniqArray': ('uniq', 'Array'), 'minArray': ('min', 'Array'), 'groupArrayMovingSumArray': ('groupArrayMovingSum', 'Array'), 'sparkBarArray': ('sparkBar', 'Array'), 'quantilesExactHighArray': ('quantilesExactHigh', 'Array'), 'quantileDeterministicArray': ('quantileDeterministic', 'Array'), 'uniqUpToArray': ('uniqUpTo', 'Array'), 'kolmogorovSmirnovTestArray': ('kolmogorovSmirnovTest', 'Array'), 'quantileExactHighArray': ('quantileExactHigh', 'Array'), 'groupArraySampleArray': ('groupArraySample', 'Array'), 'minMapArray': ('minMap', 'Array'), 'quantileTDigestState': ('quantileTDigest', 'State'), 'deltaSumState': ('deltaSum', 'State'), 'groupBitmapAndState': ('groupBitmapAnd', 'State'), 'studentTTestState': ('studentTTest', 'State'), 'rankCorrState': ('rankCorr', 'State'), 'topKWeightedState': ('topKWeighted', 'State'), 'largestTriangleThreeBucketsState': ('largestTriangleThreeBuckets', 'State'), 'kurtPopState': ('kurtPop', 'State'), 'sequenceCountState': ('sequenceCount', 'State'), 'argMaxState': ('argMax', 'State'), 'quantilesExactLowState': ('quantilesExactLow', 'State'), 'quantileExactState': ('quantileExact', 'State'), 'sumMapState': ('sumMap', 'State'), 'entropyState': ('entropy', 'State'), 'approx_top_sumState': ('approx_top_sum', 'State'), 'topKState': ('topK', 'State'), 'maxIntersectionsPositionState': ('maxIntersectionsPosition', 'State'), 'groupBitmapState': ('groupBitmap', 'State'), 'quantilesTDigestWeightedState': ('quantilesTDigestWeighted', 'State'), 'groupArrayLastState': ('groupArrayLast', 'State'), 'groupBitXorState': ('groupBitXor', 'State'), 'corrState': ('corr', 'State'), 'groupArrayInsertAtState': ('groupArrayInsertAt', 'State'), 'mannWhitneyUTestState': ('mannWhitneyUTest', 'State'), 'histogramState': ('histogram', 'State'), 'uniqExactState': ('uniqExact', 'State'), 'quantilesTimingState': ('quantilesTiming', 'State'), 'contingencyState': ('contingency', 'State'), 'stochasticLogisticRegressionState': ('stochasticLogisticRegression', 'State'), 'quantilesGKState': ('quantilesGK', 'State'), 'maxState': ('max', 'State'), 'sequenceNextNodeState': ('sequenceNextNode', 'State'), 'quantileTimingWeightedState': ('quantileTimingWeighted', 'State'), 'quantilesTimingWeightedState': ('quantilesTimingWeighted', 'State'), 'quantilesExactWeightedState': ('quantilesExactWeighted', 'State'), 'sumKahanState': ('sumKahan', 'State'), 'groupBitOrState': ('groupBitOr', 'State'), 'exponentialTimeDecayedAvgState': ('exponentialTimeDecayedAvg', 'State'), 'exponentialMovingAverageState': ('exponentialMovingAverage', 'State'), 'groupArrayState': ('groupArray', 'State'), 'quantileBFloat16State': ('quantileBFloat16', 'State'), 'sequenceMatchState': ('sequenceMatch', 'State'), 'quantileState': ('quantile', 'State'), 'welchTTestState': ('welchTTest', 'State'), 'sumCountState': ('sumCount', 'State'), 'groupBitmapXorState': ('groupBitmapXor', 'State'), 'quantilesBFloat16State': ('quantilesBFloat16', 'State'), 'anyHeavyState': ('anyHeavy', 'State'), 'kurtSampState': ('kurtSamp', 'State'), 'varPopState': ('varPop', 'State'), 'theilsUState': ('theilsU', 'State'), 'groupUniqArrayState': ('groupUniqArray', 'State'), 'quantilesState': ('quantiles', 'State'), 'quantilesBFloat16WeightedState': ('quantilesBFloat16Weighted', 'State'), 'windowFunnelState': ('windowFunnel', 'State'), 'avgState': ('avg', 'State'), 'sumState': ('sum', 'State'), 'stddevSampState': ('stddevSamp', 'State'), 'stddevPopState': ('stddevPop', 'State'), 'groupArrayMovingAvgState': ('groupArrayMovingAvg', 'State'), 'retentionState': ('retention', 'State'), 'groupConcatState': ('groupConcat', 'State'), 'skewSampState': ('skewSamp', 'State'), 'last_valueState': ('last_value', 'State'), 'argMinState': ('argMin', 'State'), 'quantileBFloat16WeightedState': ('quantileBFloat16Weighted', 'State'), 'meanZTestState': ('meanZTest', 'State'), 'quantilesDeterministicState': ('quantilesDeterministic', 'State'), 'intervalLengthSumState': ('intervalLengthSum', 'State'), 'quantilesTDigestState': ('quantilesTDigest', 'State'), 'quantileInterpolatedWeightedState': ('quantileInterpolatedWeighted', 'State'), 'quantilesExactState': ('quantilesExact', 'State'), 'anyState': ('any', 'State'), 'quantilesInterpolatedWeightedState': ('quantilesInterpolatedWeighted', 'State'), 'countState': ('count', 'State'), 'cramersVBiasCorrectedState': ('cramersVBiasCorrected', 'State'), 'uniqCombinedState': ('uniqCombined', 'State'), 'maxIntersectionsState': ('maxIntersections', 'State'), 'uniqHLL12State': ('uniqHLL12', 'State'), 'quantileTimingState': ('quantileTiming', 'State'), 'first_valueState': ('first_value', 'State'), 'covarSampState': ('covarSamp', 'State'), 'maxMapState': ('maxMap', 'State'), 'avgWeightedState': ('avgWeighted', 'State'), 'sumWithOverflowState': ('sumWithOverflow', 'State'), 'groupBitmapOrState': ('groupBitmapOr', 'State'), 'quantilesExactExclusiveState': ('quantilesExactExclusive', 'State'), 'boundingRatioState': ('boundingRatio', 'State'), 'groupBitAndState': ('groupBitAnd', 'State'), 'skewPopState': ('skewPop', 'State'), 'quantileTDigestWeightedState': ('quantileTDigestWeighted', 'State'), 'quantileExactWeightedState': ('quantileExactWeighted', 'State'), 'stochasticLinearRegressionState': ('stochasticLinearRegression', 'State'), 'uniqCombined64State': ('uniqCombined64', 'State'), 'anyLastState': ('anyLast', 'State'), 'uniqThetaState': ('uniqTheta', 'State'), 'varSampState': ('varSamp', 'State'), 'deltaSumTimestampState': ('deltaSumTimestamp', 'State'), 'simpleLinearRegressionState': ('simpleLinearRegression', 'State'), 'quantileExactLowState': ('quantileExactLow', 'State'), 'medianState': ('median', 'State'), 'cramersVState': ('cramersV', 'State'), 'categoricalInformationValueState': ('categoricalInformationValue', 'State'), 'quantileGKState': ('quantileGK', 'State'), 'covarPopState': ('covarPop', 'State'), 'uniqState': ('uniq', 'State'), 'minState': ('min', 'State'), 'groupArrayMovingSumState': ('groupArrayMovingSum', 'State'), 'sparkBarState': ('sparkBar', 'State'), 'quantilesExactHighState': ('quantilesExactHigh', 'State'), 'quantileDeterministicState': ('quantileDeterministic', 'State'), 'uniqUpToState': ('uniqUpTo', 'State'), 'kolmogorovSmirnovTestState': ('kolmogorovSmirnovTest', 'State'), 'quantileExactHighState': ('quantileExactHigh', 'State'), 'groupArraySampleState': ('groupArraySample', 'State'), 'minMapState': ('minMap', 'State'), 'quantileTDigestMerge': ('quantileTDigest', 'Merge'), 'deltaSumMerge': ('deltaSum', 'Merge'), 'groupBitmapAndMerge': ('groupBitmapAnd', 'Merge'), 'studentTTestMerge': ('studentTTest', 'Merge'), 'rankCorrMerge': ('rankCorr', 'Merge'), 'topKWeightedMerge': ('topKWeighted', 'Merge'), 'largestTriangleThreeBucketsMerge': ('largestTriangleThreeBuckets', 'Merge'), 'kurtPopMerge': ('kurtPop', 'Merge'), 'sequenceCountMerge': ('sequenceCount', 'Merge'), 'argMaxMerge': ('argMax', 'Merge'), 'quantilesExactLowMerge': ('quantilesExactLow', 'Merge'), 'quantileExactMerge': ('quantileExact', 'Merge'), 'sumMapMerge': ('sumMap', 'Merge'), 'entropyMerge': ('entropy', 'Merge'), 'approx_top_sumMerge': ('approx_top_sum', 'Merge'), 'topKMerge': ('topK', 'Merge'), 'maxIntersectionsPositionMerge': ('maxIntersectionsPosition', 'Merge'), 'groupBitmapMerge': ('groupBitmap', 'Merge'), 'quantilesTDigestWeightedMerge': ('quantilesTDigestWeighted', 'Merge'), 'groupArrayLastMerge': ('groupArrayLast', 'Merge'), 'groupBitXorMerge': ('groupBitXor', 'Merge'), 'corrMerge': ('corr', 'Merge'), 'groupArrayInsertAtMerge': ('groupArrayInsertAt', 'Merge'), 'mannWhitneyUTestMerge': ('mannWhitneyUTest', 'Merge'), 'histogramMerge': ('histogram', 'Merge'), 'uniqExactMerge': ('uniqExact', 'Merge'), 'quantilesTimingMerge': ('quantilesTiming', 'Merge'), 'contingencyMerge': ('contingency', 'Merge'), 'stochasticLogisticRegressionMerge': ('stochasticLogisticRegression', 'Merge'), 'quantilesGKMerge': ('quantilesGK', 'Merge'), 'maxMerge': ('max', 'Merge'), 'sequenceNextNodeMerge': ('sequenceNextNode', 'Merge'), 'quantileTimingWeightedMerge': ('quantileTimingWeighted', 'Merge'), 'quantilesTimingWeightedMerge': ('quantilesTimingWeighted', 'Merge'), 'quantilesExactWeightedMerge': ('quantilesExactWeighted', 'Merge'), 'sumKahanMerge': ('sumKahan', 'Merge'), 'groupBitOrMerge': ('groupBitOr', 'Merge'), 'exponentialTimeDecayedAvgMerge': ('exponentialTimeDecayedAvg', 'Merge'), 'exponentialMovingAverageMerge': ('exponentialMovingAverage', 'Merge'), 'groupArrayMerge': ('groupArray', 'Merge'), 'quantileBFloat16Merge': ('quantileBFloat16', 'Merge'), 'sequenceMatchMerge': ('sequenceMatch', 'Merge'), 'quantileMerge': ('quantile', 'Merge'), 'welchTTestMerge': ('welchTTest', 'Merge'), 'sumCountMerge': ('sumCount', 'Merge'), 'groupBitmapXorMerge': ('groupBitmapXor', 'Merge'), 'quantilesBFloat16Merge': ('quantilesBFloat16', 'Merge'), 'anyHeavyMerge': ('anyHeavy', 'Merge'), 'kurtSampMerge': ('kurtSamp', 'Merge'), 'varPopMerge': ('varPop', 'Merge'), 'theilsUMerge': ('theilsU', 'Merge'), 'groupUniqArrayMerge': ('groupUniqArray', 'Merge'), 'quantilesMerge': ('quantiles', 'Merge'), 'quantilesBFloat16WeightedMerge': ('quantilesBFloat16Weighted', 'Merge'), 'windowFunnelMerge': ('windowFunnel', 'Merge'), 'avgMerge': ('avg', 'Merge'), 'sumMerge': ('sum', 'Merge'), 'stddevSampMerge': ('stddevSamp', 'Merge'), 'stddevPopMerge': ('stddevPop', 'Merge'), 'groupArrayMovingAvgMerge': ('groupArrayMovingAvg', 'Merge'), 'retentionMerge': ('retention', 'Merge'), 'groupConcatMerge': ('groupConcat', 'Merge'), 'skewSampMerge': ('skewSamp', 'Merge'), 'last_valueMerge': ('last_value', 'Merge'), 'argMinMerge': ('argMin', 'Merge'), 'quantileBFloat16WeightedMerge': ('quantileBFloat16Weighted', 'Merge'), 'meanZTestMerge': ('meanZTest', 'Merge'), 'quantilesDeterministicMerge': ('quantilesDeterministic', 'Merge'), 'intervalLengthSumMerge': ('intervalLengthSum', 'Merge'), 'quantilesTDigestMerge': ('quantilesTDigest', 'Merge'), 'quantileInterpolatedWeightedMerge': ('quantileInterpolatedWeighted', 'Merge'), 'quantilesExactMerge': ('quantilesExact', 'Merge'), 'anyMerge': ('any', 'Merge'), 'quantilesInterpolatedWeightedMerge': ('quantilesInterpolatedWeighted', 'Merge'), 'countMerge': ('count', 'Merge'), 'cramersVBiasCorrectedMerge': ('cramersVBiasCorrected', 'Merge'), 'uniqCombinedMerge': ('uniqCombined', 'Merge'), 'maxIntersectionsMerge': ('maxIntersections', 'Merge'), 'uniqHLL12Merge': ('uniqHLL12', 'Merge'), 'quantileTimingMerge': ('quantileTiming', 'Merge'), 'first_valueMerge': ('first_value', 'Merge'), 'covarSampMerge': ('covarSamp', 'Merge'), 'maxMapMerge': ('maxMap', 'Merge'), 'avgWeightedMerge': ('avgWeighted', 'Merge'), 'sumWithOverflowMerge': ('sumWithOverflow', 'Merge'), 'groupBitmapOrMerge': ('groupBitmapOr', 'Merge'), 'quantilesExactExclusiveMerge': ('quantilesExactExclusive', 'Merge'), 'boundingRatioMerge': ('boundingRatio', 'Merge'), 'groupBitAndMerge': ('groupBitAnd', 'Merge'), 'skewPopMerge': ('skewPop', 'Merge'), 'quantileTDigestWeightedMerge': ('quantileTDigestWeighted', 'Merge'), 'quantileExactWeightedMerge': ('quantileExactWeighted', 'Merge'), 'stochasticLinearRegressionMerge': ('stochasticLinearRegression', 'Merge'), 'uniqCombined64Merge': ('uniqCombined64', 'Merge'), 'anyLastMerge': ('anyLast', 'Merge'), 'uniqThetaMerge': ('uniqTheta', 'Merge'), 'varSampMerge': ('varSamp', 'Merge'), 'deltaSumTimestampMerge': ('deltaSumTimestamp', 'Merge'), 'simpleLinearRegressionMerge': ('simpleLinearRegression', 'Merge'), 'quantileExactLowMerge': ('quantileExactLow', 'Merge'), 'medianMerge': ('median', 'Merge'), 'cramersVMerge': ('cramersV', 'Merge'), 'categoricalInformationValueMerge': ('categoricalInformationValue', 'Merge'), 'quantileGKMerge': ('quantileGK', 'Merge'), 'covarPopMerge': ('covarPop', 'Merge'), 'uniqMerge': ('uniq', 'Merge'), 'minMerge': ('min', 'Merge'), 'groupArrayMovingSumMerge': ('groupArrayMovingSum', 'Merge'), 'sparkBarMerge': ('sparkBar', 'Merge'), 'quantilesExactHighMerge': ('quantilesExactHigh', 'Merge'), 'quantileDeterministicMerge': ('quantileDeterministic', 'Merge'), 'uniqUpToMerge': ('uniqUpTo', 'Merge'), 'kolmogorovSmirnovTestMerge': ('kolmogorovSmirnovTest', 'Merge'), 'quantileExactHighMerge': ('quantileExactHigh', 'Merge'), 'groupArraySampleMerge': ('groupArraySample', 'Merge'), 'minMapMerge': ('minMap', 'Merge'), 'quantileTDigestMap': ('quantileTDigest', 'Map'), 'deltaSumMap': ('deltaSum', 'Map'), 'groupBitmapAndMap': ('groupBitmapAnd', 'Map'), 'studentTTestMap': ('studentTTest', 'Map'), 'rankCorrMap': ('rankCorr', 'Map'), 'topKWeightedMap': ('topKWeighted', 'Map'), 'largestTriangleThreeBucketsMap': ('largestTriangleThreeBuckets', 'Map'), 'kurtPopMap': ('kurtPop', 'Map'), 'sequenceCountMap': ('sequenceCount', 'Map'), 'argMaxMap': ('argMax', 'Map'), 'quantilesExactLowMap': ('quantilesExactLow', 'Map'), 'quantileExactMap': ('quantileExact', 'Map'), 'sumMapMap': ('sumMap', 'Map'), 'entropyMap': ('entropy', 'Map'), 'approx_top_sumMap': ('approx_top_sum', 'Map'), 'topKMap': ('topK', 'Map'), 'maxIntersectionsPositionMap': ('maxIntersectionsPosition', 'Map'), 'groupBitmapMap': ('groupBitmap', 'Map'), 'quantilesTDigestWeightedMap': ('quantilesTDigestWeighted', 'Map'), 'groupArrayLastMap': ('groupArrayLast', 'Map'), 'groupBitXorMap': ('groupBitXor', 'Map'), 'corrMap': ('corr', 'Map'), 'groupArrayInsertAtMap': ('groupArrayInsertAt', 'Map'), 'mannWhitneyUTestMap': ('mannWhitneyUTest', 'Map'), 'histogramMap': ('histogram', 'Map'), 'uniqExactMap': ('uniqExact', 'Map'), 'quantilesTimingMap': ('quantilesTiming', 'Map'), 'contingencyMap': ('contingency', 'Map'), 'stochasticLogisticRegressionMap': ('stochasticLogisticRegression', 'Map'), 'quantilesGKMap': ('quantilesGK', 'Map'), 'maxMap': ('maxMap', None), 'sequenceNextNodeMap': ('sequenceNextNode', 'Map'), 'quantileTimingWeightedMap': ('quantileTimingWeighted', 'Map'), 'quantilesTimingWeightedMap': ('quantilesTimingWeighted', 'Map'), 'quantilesExactWeightedMap': ('quantilesExactWeighted', 'Map'), 'sumKahanMap': ('sumKahan', 'Map'), 'groupBitOrMap': ('groupBitOr', 'Map'), 'exponentialTimeDecayedAvgMap': ('exponentialTimeDecayedAvg', 'Map'), 'exponentialMovingAverageMap': ('exponentialMovingAverage', 'Map'), 'groupArrayMap': ('groupArray', 'Map'), 'quantileBFloat16Map': ('quantileBFloat16', 'Map'), 'sequenceMatchMap': ('sequenceMatch', 'Map'), 'quantileMap': ('quantile', 'Map'), 'welchTTestMap': ('welchTTest', 'Map'), 'sumCountMap': ('sumCount', 'Map'), 'groupBitmapXorMap': ('groupBitmapXor', 'Map'), 'quantilesBFloat16Map': ('quantilesBFloat16', 'Map'), 'anyHeavyMap': ('anyHeavy', 'Map'), 'kurtSampMap': ('kurtSamp', 'Map'), 'varPopMap': ('varPop', 'Map'), 'theilsUMap': ('theilsU', 'Map'), 'groupUniqArrayMap': ('groupUniqArray', 'Map'), 'quantilesMap': ('quantiles', 'Map'), 'quantilesBFloat16WeightedMap': ('quantilesBFloat16Weighted', 'Map'), 'windowFunnelMap': ('windowFunnel', 'Map'), 'avgMap': ('avg', 'Map'), 'sumMap': ('sumMap', None), 'stddevSampMap': ('stddevSamp', 'Map'), 'stddevPopMap': ('stddevPop', 'Map'), 'groupArrayMovingAvgMap': ('groupArrayMovingAvg', 'Map'), 'retentionMap': ('retention', 'Map'), 'groupConcatMap': ('groupConcat', 'Map'), 'skewSampMap': ('skewSamp', 'Map'), 'last_valueMap': ('last_value', 'Map'), 'argMinMap': ('argMin', 'Map'), 'quantileBFloat16WeightedMap': ('quantileBFloat16Weighted', 'Map'), 'meanZTestMap': ('meanZTest', 'Map'), 'quantilesDeterministicMap': ('quantilesDeterministic', 'Map'), 'intervalLengthSumMap': ('intervalLengthSum', 'Map'), 'quantilesTDigestMap': ('quantilesTDigest', 'Map'), 'quantileInterpolatedWeightedMap': ('quantileInterpolatedWeighted', 'Map'), 'quantilesExactMap': ('quantilesExact', 'Map'), 'anyMap': ('any', 'Map'), 'quantilesInterpolatedWeightedMap': ('quantilesInterpolatedWeighted', 'Map'), 'countMap': ('count', 'Map'), 'cramersVBiasCorrectedMap': ('cramersVBiasCorrected', 'Map'), 'uniqCombinedMap': ('uniqCombined', 'Map'), 'maxIntersectionsMap': ('maxIntersections', 'Map'), 'uniqHLL12Map': ('uniqHLL12', 'Map'), 'quantileTimingMap': ('quantileTiming', 'Map'), 'first_valueMap': ('first_value', 'Map'), 'covarSampMap': ('covarSamp', 'Map'), 'maxMapMap': ('maxMap', 'Map'), 'avgWeightedMap': ('avgWeighted', 'Map'), 'sumWithOverflowMap': ('sumWithOverflow', 'Map'), 'groupBitmapOrMap': ('groupBitmapOr', 'Map'), 'quantilesExactExclusiveMap': ('quantilesExactExclusive', 'Map'), 'boundingRatioMap': ('boundingRatio', 'Map'), 'groupBitAndMap': ('groupBitAnd', 'Map'), 'skewPopMap': ('skewPop', 'Map'), 'quantileTDigestWeightedMap': ('quantileTDigestWeighted', 'Map'), 'quantileExactWeightedMap': ('quantileExactWeighted', 'Map'), 'stochasticLinearRegressionMap': ('stochasticLinearRegression', 'Map'), 'uniqCombined64Map': ('uniqCombined64', 'Map'), 'anyLastMap': ('anyLast', 'Map'), 'uniqThetaMap': ('uniqTheta', 'Map'), 'varSampMap': ('varSamp', 'Map'), 'deltaSumTimestampMap': ('deltaSumTimestamp', 'Map'), 'simpleLinearRegressionMap': ('simpleLinearRegression', 'Map'), 'quantileExactLowMap': ('quantileExactLow', 'Map'), 'medianMap': ('median', 'Map'), 'cramersVMap': ('cramersV', 'Map'), 'categoricalInformationValueMap': ('categoricalInformationValue', 'Map'), 'quantileGKMap': ('quantileGK', 'Map'), 'covarPopMap': ('covarPop', 'Map'), 'uniqMap': ('uniq', 'Map'), 'minMap': ('minMap', None), 'groupArrayMovingSumMap': ('groupArrayMovingSum', 'Map'), 'sparkBarMap': ('sparkBar', 'Map'), 'quantilesExactHighMap': ('quantilesExactHigh', 'Map'), 'quantileDeterministicMap': ('quantileDeterministic', 'Map'), 'uniqUpToMap': ('uniqUpTo', 'Map'), 'kolmogorovSmirnovTestMap': ('kolmogorovSmirnovTest', 'Map'), 'quantileExactHighMap': ('quantileExactHigh', 'Map'), 'groupArraySampleMap': ('groupArraySample', 'Map'), 'minMapMap': ('minMap', 'Map'), 'quantileTDigestIf': ('quantileTDigest', 'If'), 'deltaSumIf': ('deltaSum', 'If'), 'groupBitmapAndIf': ('groupBitmapAnd', 'If'), 'studentTTestIf': ('studentTTest', 'If'), 'rankCorrIf': ('rankCorr', 'If'), 'topKWeightedIf': ('topKWeighted', 'If'), 'largestTriangleThreeBucketsIf': ('largestTriangleThreeBuckets', 'If'), 'kurtPopIf': ('kurtPop', 'If'), 'sequenceCountIf': ('sequenceCount', 'If'), 'argMaxIf': ('argMax', 'If'), 'quantilesExactLowIf': ('quantilesExactLow', 'If'), 'quantileExactIf': ('quantileExact', 'If'), 'sumMapIf': ('sumMap', 'If'), 'entropyIf': ('entropy', 'If'), 'approx_top_sumIf': ('approx_top_sum', 'If'), 'topKIf': ('topK', 'If'), 'maxIntersectionsPositionIf': ('maxIntersectionsPosition', 'If'), 'groupBitmapIf': ('groupBitmap', 'If'), 'quantilesTDigestWeightedIf': ('quantilesTDigestWeighted', 'If'), 'groupArrayLastIf': ('groupArrayLast', 'If'), 'groupBitXorIf': ('groupBitXor', 'If'), 'corrIf': ('corr', 'If'), 'groupArrayInsertAtIf': ('groupArrayInsertAt', 'If'), 'mannWhitneyUTestIf': ('mannWhitneyUTest', 'If'), 'histogramIf': ('histogram', 'If'), 'uniqExactIf': ('uniqExact', 'If'), 'quantilesTimingIf': ('quantilesTiming', 'If'), 'contingencyIf': ('contingency', 'If'), 'stochasticLogisticRegressionIf': ('stochasticLogisticRegression', 'If'), 'quantilesGKIf': ('quantilesGK', 'If'), 'maxIf': ('max', 'If'), 'sequenceNextNodeIf': ('sequenceNextNode', 'If'), 'quantileTimingWeightedIf': ('quantileTimingWeighted', 'If'), 'quantilesTimingWeightedIf': ('quantilesTimingWeighted', 'If'), 'quantilesExactWeightedIf': ('quantilesExactWeighted', 'If'), 'sumKahanIf': ('sumKahan', 'If'), 'groupBitOrIf': ('groupBitOr', 'If'), 'exponentialTimeDecayedAvgIf': ('exponentialTimeDecayedAvg', 'If'), 'exponentialMovingAverageIf': ('exponentialMovingAverage', 'If'), 'groupArrayIf': ('groupArray', 'If'), 'quantileBFloat16If': ('quantileBFloat16', 'If'), 'sequenceMatchIf': ('sequenceMatch', 'If'), 'quantileIf': ('quantile', 'If'), 'welchTTestIf': ('welchTTest', 'If'), 'sumCountIf': ('sumCount', 'If'), 'groupBitmapXorIf': ('groupBitmapXor', 'If'), 'quantilesBFloat16If': ('quantilesBFloat16', 'If'), 'anyHeavyIf': ('anyHeavy', 'If'), 'kurtSampIf': ('kurtSamp', 'If'), 'varPopIf': ('varPop', 'If'), 'theilsUIf': ('theilsU', 'If'), 'groupUniqArrayIf': ('groupUniqArray', 'If'), 'quantilesIf': ('quantiles', 'If'), 'quantilesBFloat16WeightedIf': ('quantilesBFloat16Weighted', 'If'), 'windowFunnelIf': ('windowFunnel', 'If'), 'avgIf': ('avg', 'If'), 'sumIf': ('sum', 'If'), 'stddevSampIf': ('stddevSamp', 'If'), 'stddevPopIf': ('stddevPop', 'If'), 'groupArrayMovingAvgIf': ('groupArrayMovingAvg', 'If'), 'retentionIf': ('retention', 'If'), 'groupConcatIf': ('groupConcat', 'If'), 'skewSampIf': ('skewSamp', 'If'), 'last_valueIf': ('last_value', 'If'), 'argMinIf': ('argMin', 'If'), 'quantileBFloat16WeightedIf': ('quantileBFloat16Weighted', 'If'), 'meanZTestIf': ('meanZTest', 'If'), 'quantilesDeterministicIf': ('quantilesDeterministic', 'If'), 'intervalLengthSumIf': ('intervalLengthSum', 'If'), 'quantilesTDigestIf': ('quantilesTDigest', 'If'), 'quantileInterpolatedWeightedIf': ('quantileInterpolatedWeighted', 'If'), 'quantilesExactIf': ('quantilesExact', 'If'), 'anyIf': ('any', 'If'), 'quantilesInterpolatedWeightedIf': ('quantilesInterpolatedWeighted', 'If'), 'countIf': ('count', 'If'), 'cramersVBiasCorrectedIf': ('cramersVBiasCorrected', 'If'), 'uniqCombinedIf': ('uniqCombined', 'If'), 'maxIntersectionsIf': ('maxIntersections', 'If'), 'uniqHLL12If': ('uniqHLL12', 'If'), 'quantileTimingIf': ('quantileTiming', 'If'), 'first_valueIf': ('first_value', 'If'), 'covarSampIf': ('covarSamp', 'If'), 'maxMapIf': ('maxMap', 'If'), 'avgWeightedIf': ('avgWeighted', 'If'), 'sumWithOverflowIf': ('sumWithOverflow', 'If'), 'groupBitmapOrIf': ('groupBitmapOr', 'If'), 'quantilesExactExclusiveIf': ('quantilesExactExclusive', 'If'), 'boundingRatioIf': ('boundingRatio', 'If'), 'groupBitAndIf': ('groupBitAnd', 'If'), 'skewPopIf': ('skewPop', 'If'), 'quantileTDigestWeightedIf': ('quantileTDigestWeighted', 'If'), 'quantileExactWeightedIf': ('quantileExactWeighted', 'If'), 'stochasticLinearRegressionIf': ('stochasticLinearRegression', 'If'), 'uniqCombined64If': ('uniqCombined64', 'If'), 'anyLastIf': ('anyLast', 'If'), 'uniqThetaIf': ('uniqTheta', 'If'), 'varSampIf': ('varSamp', 'If'), 'deltaSumTimestampIf': ('deltaSumTimestamp', 'If'), 'simpleLinearRegressionIf': ('simpleLinearRegression', 'If'), 'quantileExactLowIf': ('quantileExactLow', 'If'), 'medianIf': ('median', 'If'), 'cramersVIf': ('cramersV', 'If'), 'categoricalInformationValueIf': ('categoricalInformationValue', 'If'), 'quantileGKIf': ('quantileGK', 'If'), 'covarPopIf': ('covarPop', 'If'), 'uniqIf': ('uniq', 'If'), 'minIf': ('min', 'If'), 'groupArrayMovingSumIf': ('groupArrayMovingSum', 'If'), 'sparkBarIf': ('sparkBar', 'If'), 'quantilesExactHighIf': ('quantilesExactHigh', 'If'), 'quantileDeterministicIf': ('quantileDeterministic', 'If'), 'uniqUpToIf': ('uniqUpTo', 'If'), 'kolmogorovSmirnovTestIf': ('kolmogorovSmirnovTest', 'If'), 'quantileExactHighIf': ('quantileExactHigh', 'If'), 'groupArraySampleIf': ('groupArraySample', 'If'), 'minMapIf': ('minMap', 'If'), 'quantileTDigest': ('quantileTDigest', None), 'deltaSum': ('deltaSum', None), 'groupBitmapAnd': ('groupBitmapAnd', None), 'studentTTest': ('studentTTest', None), 'rankCorr': ('rankCorr', None), 'topKWeighted': ('topKWeighted', None), 'largestTriangleThreeBuckets': ('largestTriangleThreeBuckets', None), 'kurtPop': ('kurtPop', None), 'sequenceCount': ('sequenceCount', None), 'argMax': ('argMax', None), 'quantilesExactLow': ('quantilesExactLow', None), 'quantileExact': ('quantileExact', None), 'entropy': ('entropy', None), 'approx_top_sum': ('approx_top_sum', None), 'topK': ('topK', None), 'maxIntersectionsPosition': ('maxIntersectionsPosition', None), 'groupBitmap': ('groupBitmap', None), 'quantilesTDigestWeighted': ('quantilesTDigestWeighted', None), 'groupArrayLast': ('groupArrayLast', None), 'groupBitXor': ('groupBitXor', None), 'corr': ('corr', None), 'groupArrayInsertAt': ('groupArrayInsertAt', None), 'mannWhitneyUTest': ('mannWhitneyUTest', None), 'histogram': ('histogram', None), 'uniqExact': ('uniqExact', None), 'quantilesTiming': ('quantilesTiming', None), 'contingency': ('contingency', None), 'stochasticLogisticRegression': ('stochasticLogisticRegression', None), 'quantilesGK': ('quantilesGK', None), 'max': ('max', None), 'sequenceNextNode': ('sequenceNextNode', None), 'quantileTimingWeighted': ('quantileTimingWeighted', None), 'quantilesTimingWeighted': ('quantilesTimingWeighted', None), 'quantilesExactWeighted': ('quantilesExactWeighted', None), 'sumKahan': ('sumKahan', None), 'groupBitOr': ('groupBitOr', None), 'exponentialTimeDecayedAvg': ('exponentialTimeDecayedAvg', None), 'exponentialMovingAverage': ('exponentialMovingAverage', None), 'groupArray': ('groupArray', None), 'quantileBFloat16': ('quantileBFloat16', None), 'sequenceMatch': ('sequenceMatch', None), 'quantile': ('quantile', None), 'welchTTest': ('welchTTest', None), 'sumCount': ('sumCount', None), 'groupBitmapXor': ('groupBitmapXor', None), 'quantilesBFloat16': ('quantilesBFloat16', None), 'anyHeavy': ('anyHeavy', None), 'kurtSamp': ('kurtSamp', None), 'varPop': ('varPop', None), 'theilsU': ('theilsU', None), 'groupUniqArray': ('groupUniqArray', None), 'quantiles': ('quantiles', None), 'quantilesBFloat16Weighted': ('quantilesBFloat16Weighted', None), 'windowFunnel': ('windowFunnel', None), 'avg': ('avg', None), 'sum': ('sum', None), 'stddevSamp': ('stddevSamp', None), 'stddevPop': ('stddevPop', None), 'groupArrayMovingAvg': ('groupArrayMovingAvg', None), 'retention': ('retention', None), 'groupConcat': ('groupConcat', None), 'skewSamp': ('skewSamp', None), 'last_value': ('last_value', None), 'argMin': ('argMin', None), 'quantileBFloat16Weighted': ('quantileBFloat16Weighted', None), 'meanZTest': ('meanZTest', None), 'quantilesDeterministic': ('quantilesDeterministic', None), 'intervalLengthSum': ('intervalLengthSum', None), 'quantilesTDigest': ('quantilesTDigest', None), 'quantileInterpolatedWeighted': ('quantileInterpolatedWeighted', None), 'quantilesExact': ('quantilesExact', None), 'any': ('any', None), 'quantilesInterpolatedWeighted': ('quantilesInterpolatedWeighted', None), 'count': ('count', None), 'cramersVBiasCorrected': ('cramersVBiasCorrected', None), 'uniqCombined': ('uniqCombined', None), 'maxIntersections': ('maxIntersections', None), 'uniqHLL12': ('uniqHLL12', None), 'quantileTiming': ('quantileTiming', None), 'first_value': ('first_value', None), 'covarSamp': ('covarSamp', None), 'avgWeighted': ('avgWeighted', None), 'sumWithOverflow': ('sumWithOverflow', None), 'groupBitmapOr': ('groupBitmapOr', None), 'quantilesExactExclusive': ('quantilesExactExclusive', None), 'boundingRatio': ('boundingRatio', None), 'groupBitAnd': ('groupBitAnd', None), 'skewPop': ('skewPop', None), 'quantileTDigestWeighted': ('quantileTDigestWeighted', None), 'quantileExactWeighted': ('quantileExactWeighted', None), 'stochasticLinearRegression': ('stochasticLinearRegression', None), 'uniqCombined64': ('uniqCombined64', None), 'anyLast': ('anyLast', None), 'uniqTheta': ('uniqTheta', None), 'varSamp': ('varSamp', None), 'deltaSumTimestamp': ('deltaSumTimestamp', None), 'simpleLinearRegression': ('simpleLinearRegression', None), 'quantileExactLow': ('quantileExactLow', None), 'median': ('median', None), 'cramersV': ('cramersV', None), 'categoricalInformationValue': ('categoricalInformationValue', None), 'quantileGK': ('quantileGK', None), 'covarPop': ('covarPop', None), 'uniq': ('uniq', None), 'min': ('min', None), 'groupArrayMovingSum': ('groupArrayMovingSum', None), 'sparkBar': ('sparkBar', None), 'quantilesExactHigh': ('quantilesExactHigh', None), 'quantileDeterministic': ('quantileDeterministic', None), 'uniqUpTo': ('uniqUpTo', None), 'kolmogorovSmirnovTest': ('kolmogorovSmirnovTest', None), 'quantileExactHigh': ('quantileExactHigh', None), 'groupArraySample': ('groupArraySample', 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>>}
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: 244>: <class 'sqlglot.expressions.temporal.CurrentDate'>, <TokenType.CURRENT_DATETIME: 245>: <class 'sqlglot.expressions.temporal.CurrentDate'>, <TokenType.CURRENT_TIME: 247>: <class 'sqlglot.expressions.temporal.CurrentTime'>, <TokenType.CURRENT_USER: 249>: <class 'sqlglot.expressions.functions.CurrentUser'>, <TokenType.CURRENT_ROLE: 251>: <class 'sqlglot.expressions.functions.CurrentRole'>}
RANGE_PARSERS = {<TokenType.AT_GT: 54>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.BETWEEN: 228>: <function Parser.<lambda>>, <TokenType.GLOB: 285>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.ILIKE: 293>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IN: 294>: <function Parser.<lambda>>, <TokenType.IRLIKE: 305>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IS: 306>: <function Parser.<lambda>>, <TokenType.LIKE: 316>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.LT_AT: 53>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.OVERLAPS: 347>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.RLIKE: 377>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.SIMILAR_TO: 392>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.FOR: 277>: <function Parser.<lambda>>, <TokenType.QMARK_AMP: 66>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.QMARK_PIPE: 67>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.HASH_DASH: 68>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.ADJACENT: 63>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.OPERATOR: 338>: <function Parser.<lambda>>, <TokenType.AMP_LT: 61>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.AMP_GT: 62>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.GLOBAL: 286>: <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: 385>, <TokenType.STRAIGHT_JOIN: 399>, <TokenType.OUTER: 345>, <TokenType.ALL: 218>, <TokenType.ANTI: 219>, <TokenType.ANY: 220>, <TokenType.ARRAY: 222>, <TokenType.ASOF: 224>, <TokenType.INNER: 297>, <TokenType.CROSS: 242>}
TABLE_ALIAS_TOKENS = {<TokenType.SESSION: 57>, <TokenType.SESSION_USER: 59>, <TokenType.IDENTIFIER: 77>, <TokenType.DATABASE: 78>, <TokenType.COLUMN: 79>, <TokenType.SCHEMA: 81>, <TokenType.TABLE: 82>, <TokenType.WAREHOUSE: 83>, <TokenType.STAGE: 84>, <TokenType.STREAM: 85>, <TokenType.STREAMLIT: 86>, <TokenType.VAR: 87>, <TokenType.BIT: 95>, <TokenType.BOOLEAN: 96>, <TokenType.TINYINT: 97>, <TokenType.UTINYINT: 98>, <TokenType.SMALLINT: 99>, <TokenType.USMALLINT: 100>, <TokenType.MEDIUMINT: 101>, <TokenType.UMEDIUMINT: 102>, <TokenType.INT: 103>, <TokenType.UINT: 104>, <TokenType.BIGINT: 105>, <TokenType.UBIGINT: 106>, <TokenType.BIGNUM: 107>, <TokenType.INT128: 108>, <TokenType.UINT128: 109>, <TokenType.INT256: 110>, <TokenType.UINT256: 111>, <TokenType.FLOAT: 112>, <TokenType.DOUBLE: 113>, <TokenType.UDOUBLE: 114>, <TokenType.DECIMAL: 115>, <TokenType.DECIMAL32: 116>, <TokenType.DECIMAL64: 117>, <TokenType.DECIMAL128: 118>, <TokenType.DECIMAL256: 119>, <TokenType.DECFLOAT: 120>, <TokenType.UDECIMAL: 121>, <TokenType.BIGDECIMAL: 122>, <TokenType.CHAR: 123>, <TokenType.NCHAR: 124>, <TokenType.VARCHAR: 125>, <TokenType.NVARCHAR: 126>, <TokenType.BPCHAR: 127>, <TokenType.TEXT: 128>, <TokenType.MEDIUMTEXT: 129>, <TokenType.LONGTEXT: 130>, <TokenType.BLOB: 131>, <TokenType.MEDIUMBLOB: 132>, <TokenType.LONGBLOB: 133>, <TokenType.TINYBLOB: 134>, <TokenType.TINYTEXT: 135>, <TokenType.NAME: 136>, <TokenType.BINARY: 137>, <TokenType.VARBINARY: 138>, <TokenType.JSON: 139>, <TokenType.JSONB: 140>, <TokenType.TIME: 141>, <TokenType.TIMETZ: 142>, <TokenType.TIME_NS: 143>, <TokenType.TIMESTAMP: 144>, <TokenType.TIMESTAMPTZ: 145>, <TokenType.TIMESTAMPLTZ: 146>, <TokenType.TIMESTAMPNTZ: 147>, <TokenType.TIMESTAMP_S: 148>, <TokenType.TIMESTAMP_MS: 149>, <TokenType.TIMESTAMP_NS: 150>, <TokenType.DATETIME: 151>, <TokenType.DATETIME2: 152>, <TokenType.DATETIME64: 153>, <TokenType.SMALLDATETIME: 154>, <TokenType.DATE: 155>, <TokenType.DATE32: 156>, <TokenType.INT4RANGE: 157>, <TokenType.INT4MULTIRANGE: 158>, <TokenType.INT8RANGE: 159>, <TokenType.INT8MULTIRANGE: 160>, <TokenType.NUMRANGE: 161>, <TokenType.NUMMULTIRANGE: 162>, <TokenType.TSRANGE: 163>, <TokenType.TSMULTIRANGE: 164>, <TokenType.TSTZRANGE: 165>, <TokenType.TSTZMULTIRANGE: 166>, <TokenType.DATERANGE: 167>, <TokenType.DATEMULTIRANGE: 168>, <TokenType.UUID: 169>, <TokenType.GEOGRAPHY: 170>, <TokenType.GEOGRAPHYPOINT: 171>, <TokenType.NULLABLE: 172>, <TokenType.GEOMETRY: 173>, <TokenType.POINT: 174>, <TokenType.RING: 175>, <TokenType.LINESTRING: 176>, <TokenType.LOCALTIME: 177>, <TokenType.LOCALTIMESTAMP: 178>, <TokenType.MULTILINESTRING: 180>, <TokenType.POLYGON: 181>, <TokenType.MULTIPOLYGON: 182>, <TokenType.HLLSKETCH: 183>, <TokenType.HSTORE: 184>, <TokenType.SUPER: 185>, <TokenType.SERIAL: 186>, <TokenType.SMALLSERIAL: 187>, <TokenType.BIGSERIAL: 188>, <TokenType.XML: 189>, <TokenType.YEAR: 190>, <TokenType.USERDEFINED: 191>, <TokenType.MONEY: 192>, <TokenType.SMALLMONEY: 193>, <TokenType.ROWVERSION: 194>, <TokenType.IMAGE: 195>, <TokenType.VARIANT: 196>, <TokenType.OBJECT: 197>, <TokenType.INET: 198>, <TokenType.IPADDRESS: 199>, <TokenType.IPPREFIX: 200>, <TokenType.IPV4: 201>, <TokenType.IPV6: 202>, <TokenType.ENUM: 203>, <TokenType.ENUM8: 204>, <TokenType.ENUM16: 205>, <TokenType.FIXEDSTRING: 206>, <TokenType.LOWCARDINALITY: 207>, <TokenType.NESTED: 208>, <TokenType.AGGREGATEFUNCTION: 209>, <TokenType.SIMPLEAGGREGATEFUNCTION: 210>, <TokenType.TDIGEST: 211>, <TokenType.UNKNOWN: 212>, <TokenType.VECTOR: 213>, <TokenType.DYNAMIC: 214>, <TokenType.VOID: 215>, <TokenType.APPLY: 221>, <TokenType.ASC: 223>, <TokenType.ATTACH: 225>, <TokenType.AUTO_INCREMENT: 226>, <TokenType.BEGIN: 227>, <TokenType.CACHE: 230>, <TokenType.CASE: 231>, <TokenType.COLLATE: 234>, <TokenType.COMMAND: 235>, <TokenType.COMMENT: 236>, <TokenType.COMMIT: 237>, <TokenType.CONSTRAINT: 239>, <TokenType.COPY: 240>, <TokenType.CUBE: 243>, <TokenType.CURRENT_DATE: 244>, <TokenType.CURRENT_DATETIME: 245>, <TokenType.CURRENT_SCHEMA: 246>, <TokenType.CURRENT_TIME: 247>, <TokenType.CURRENT_TIMESTAMP: 248>, <TokenType.CURRENT_USER: 249>, <TokenType.CURRENT_ROLE: 251>, <TokenType.CURRENT_CATALOG: 252>, <TokenType.DEFAULT: 254>, <TokenType.DELETE: 255>, <TokenType.DESC: 256>, <TokenType.DESCRIBE: 257>, <TokenType.DETACH: 258>, <TokenType.DICTIONARY: 259>, <TokenType.DIV: 262>, <TokenType.END: 265>, <TokenType.ESCAPE: 266>, <TokenType.EXECUTE: 268>, <TokenType.EXISTS: 269>, <TokenType.FALSE: 270>, <TokenType.FILE: 272>, <TokenType.FILE_FORMAT: 273>, <TokenType.FILTER: 274>, <TokenType.FIRST: 276>, <TokenType.FOREIGN_KEY: 279>, <TokenType.FUNCTION: 283>, <TokenType.GET: 284>, <TokenType.INDEX: 295>, <TokenType.INTERVAL: 302>, <TokenType.IS: 306>, <TokenType.ISNULL: 307>, <TokenType.KEEP: 310>, <TokenType.KILL: 312>, <TokenType.LIMIT: 317>, <TokenType.LIST: 318>, <TokenType.LOAD: 319>, <TokenType.MAP: 321>, <TokenType.MATCH: 322>, <TokenType.MERGE: 326>, <TokenType.MODEL: 328>, <TokenType.NEXT: 330>, <TokenType.NOTHING: 331>, <TokenType.NULL: 333>, <TokenType.OBJECT_IDENTIFIER: 334>, <TokenType.OFFSET: 335>, <TokenType.OPERATOR: 338>, <TokenType.ORDINALITY: 342>, <TokenType.INOUT: 344>, <TokenType.OVER: 346>, <TokenType.OVERLAPS: 347>, <TokenType.OVERWRITE: 348>, <TokenType.PARTITION: 350>, <TokenType.PERCENT: 352>, <TokenType.PIVOT: 353>, <TokenType.PRAGMA: 358>, <TokenType.PROCEDURE: 361>, <TokenType.PSEUDO_TYPE: 363>, <TokenType.PUT: 364>, <TokenType.RANGE: 368>, <TokenType.RECURSIVE: 369>, <TokenType.REFRESH: 370>, <TokenType.RENAME: 371>, <TokenType.REPLACE: 372>, <TokenType.REFERENCES: 375>, <TokenType.ROLLUP: 380>, <TokenType.ROW: 381>, <TokenType.ROWS: 382>, <TokenType.SEQUENCE: 387>, <TokenType.SET: 389>, <TokenType.SHOW: 391>, <TokenType.SOME: 393>, <TokenType.STORAGE_INTEGRATION: 398>, <TokenType.STRAIGHT_JOIN: 399>, <TokenType.STRUCT: 400>, <TokenType.TAG: 403>, <TokenType.TEMPORARY: 404>, <TokenType.TOP: 405>, <TokenType.TRUE: 407>, <TokenType.TRUNCATE: 408>, <TokenType.TRIGGER: 409>, <TokenType.TYPE: 410>, <TokenType.UNNEST: 413>, <TokenType.UNPIVOT: 414>, <TokenType.UPDATE: 415>, <TokenType.USE: 416>, <TokenType.VIEW: 420>, <TokenType.SEMANTIC_VIEW: 421>, <TokenType.VOLATILE: 422>, <TokenType.UNIQUE: 428>, <TokenType.SINK: 435>, <TokenType.SOURCE: 436>, <TokenType.ANALYZE: 437>, <TokenType.NAMESPACE: 438>, <TokenType.EXPORT: 439>}
ALIAS_TOKENS = {<TokenType.SESSION: 57>, <TokenType.SESSION_USER: 59>, <TokenType.IDENTIFIER: 77>, <TokenType.DATABASE: 78>, <TokenType.COLUMN: 79>, <TokenType.SCHEMA: 81>, <TokenType.TABLE: 82>, <TokenType.WAREHOUSE: 83>, <TokenType.STAGE: 84>, <TokenType.STREAM: 85>, <TokenType.STREAMLIT: 86>, <TokenType.VAR: 87>, <TokenType.BIT: 95>, <TokenType.BOOLEAN: 96>, <TokenType.TINYINT: 97>, <TokenType.UTINYINT: 98>, <TokenType.SMALLINT: 99>, <TokenType.USMALLINT: 100>, <TokenType.MEDIUMINT: 101>, <TokenType.UMEDIUMINT: 102>, <TokenType.INT: 103>, <TokenType.UINT: 104>, <TokenType.BIGINT: 105>, <TokenType.UBIGINT: 106>, <TokenType.BIGNUM: 107>, <TokenType.INT128: 108>, <TokenType.UINT128: 109>, <TokenType.INT256: 110>, <TokenType.UINT256: 111>, <TokenType.FLOAT: 112>, <TokenType.DOUBLE: 113>, <TokenType.UDOUBLE: 114>, <TokenType.DECIMAL: 115>, <TokenType.DECIMAL32: 116>, <TokenType.DECIMAL64: 117>, <TokenType.DECIMAL128: 118>, <TokenType.DECIMAL256: 119>, <TokenType.DECFLOAT: 120>, <TokenType.UDECIMAL: 121>, <TokenType.BIGDECIMAL: 122>, <TokenType.CHAR: 123>, <TokenType.NCHAR: 124>, <TokenType.VARCHAR: 125>, <TokenType.NVARCHAR: 126>, <TokenType.BPCHAR: 127>, <TokenType.TEXT: 128>, <TokenType.MEDIUMTEXT: 129>, <TokenType.LONGTEXT: 130>, <TokenType.BLOB: 131>, <TokenType.MEDIUMBLOB: 132>, <TokenType.LONGBLOB: 133>, <TokenType.TINYBLOB: 134>, <TokenType.TINYTEXT: 135>, <TokenType.NAME: 136>, <TokenType.BINARY: 137>, <TokenType.VARBINARY: 138>, <TokenType.JSON: 139>, <TokenType.JSONB: 140>, <TokenType.TIME: 141>, <TokenType.TIMETZ: 142>, <TokenType.TIME_NS: 143>, <TokenType.TIMESTAMP: 144>, <TokenType.TIMESTAMPTZ: 145>, <TokenType.TIMESTAMPLTZ: 146>, <TokenType.TIMESTAMPNTZ: 147>, <TokenType.TIMESTAMP_S: 148>, <TokenType.TIMESTAMP_MS: 149>, <TokenType.TIMESTAMP_NS: 150>, <TokenType.DATETIME: 151>, <TokenType.DATETIME2: 152>, <TokenType.DATETIME64: 153>, <TokenType.SMALLDATETIME: 154>, <TokenType.DATE: 155>, <TokenType.DATE32: 156>, <TokenType.INT4RANGE: 157>, <TokenType.INT4MULTIRANGE: 158>, <TokenType.INT8RANGE: 159>, <TokenType.INT8MULTIRANGE: 160>, <TokenType.NUMRANGE: 161>, <TokenType.NUMMULTIRANGE: 162>, <TokenType.TSRANGE: 163>, <TokenType.TSMULTIRANGE: 164>, <TokenType.TSTZRANGE: 165>, <TokenType.TSTZMULTIRANGE: 166>, <TokenType.DATERANGE: 167>, <TokenType.DATEMULTIRANGE: 168>, <TokenType.UUID: 169>, <TokenType.GEOGRAPHY: 170>, <TokenType.GEOGRAPHYPOINT: 171>, <TokenType.NULLABLE: 172>, <TokenType.GEOMETRY: 173>, <TokenType.POINT: 174>, <TokenType.RING: 175>, <TokenType.LINESTRING: 176>, <TokenType.LOCALTIME: 177>, <TokenType.LOCALTIMESTAMP: 178>, <TokenType.MULTILINESTRING: 180>, <TokenType.POLYGON: 181>, <TokenType.MULTIPOLYGON: 182>, <TokenType.HLLSKETCH: 183>, <TokenType.HSTORE: 184>, <TokenType.SUPER: 185>, <TokenType.SERIAL: 186>, <TokenType.SMALLSERIAL: 187>, <TokenType.BIGSERIAL: 188>, <TokenType.XML: 189>, <TokenType.YEAR: 190>, <TokenType.USERDEFINED: 191>, <TokenType.MONEY: 192>, <TokenType.SMALLMONEY: 193>, <TokenType.ROWVERSION: 194>, <TokenType.IMAGE: 195>, <TokenType.VARIANT: 196>, <TokenType.OBJECT: 197>, <TokenType.INET: 198>, <TokenType.IPADDRESS: 199>, <TokenType.IPPREFIX: 200>, <TokenType.IPV4: 201>, <TokenType.IPV6: 202>, <TokenType.ENUM: 203>, <TokenType.ENUM8: 204>, <TokenType.ENUM16: 205>, <TokenType.FIXEDSTRING: 206>, <TokenType.LOWCARDINALITY: 207>, <TokenType.NESTED: 208>, <TokenType.AGGREGATEFUNCTION: 209>, <TokenType.SIMPLEAGGREGATEFUNCTION: 210>, <TokenType.TDIGEST: 211>, <TokenType.UNKNOWN: 212>, <TokenType.VECTOR: 213>, <TokenType.DYNAMIC: 214>, <TokenType.VOID: 215>, <TokenType.ALL: 218>, <TokenType.ANTI: 219>, <TokenType.ANY: 220>, <TokenType.APPLY: 221>, <TokenType.ARRAY: 222>, <TokenType.ASC: 223>, <TokenType.ASOF: 224>, <TokenType.ATTACH: 225>, <TokenType.AUTO_INCREMENT: 226>, <TokenType.BEGIN: 227>, <TokenType.CACHE: 230>, <TokenType.CASE: 231>, <TokenType.COLLATE: 234>, <TokenType.COMMAND: 235>, <TokenType.COMMENT: 236>, <TokenType.COMMIT: 237>, <TokenType.CONSTRAINT: 239>, <TokenType.COPY: 240>, <TokenType.CUBE: 243>, <TokenType.CURRENT_DATE: 244>, <TokenType.CURRENT_DATETIME: 245>, <TokenType.CURRENT_SCHEMA: 246>, <TokenType.CURRENT_TIME: 247>, <TokenType.CURRENT_TIMESTAMP: 248>, <TokenType.CURRENT_USER: 249>, <TokenType.CURRENT_ROLE: 251>, <TokenType.CURRENT_CATALOG: 252>, <TokenType.DEFAULT: 254>, <TokenType.DELETE: 255>, <TokenType.DESC: 256>, <TokenType.DESCRIBE: 257>, <TokenType.DETACH: 258>, <TokenType.DICTIONARY: 259>, <TokenType.DIV: 262>, <TokenType.END: 265>, <TokenType.ESCAPE: 266>, <TokenType.EXECUTE: 268>, <TokenType.EXISTS: 269>, <TokenType.FALSE: 270>, <TokenType.FILE: 272>, <TokenType.FILE_FORMAT: 273>, <TokenType.FILTER: 274>, <TokenType.FINAL: 275>, <TokenType.FIRST: 276>, <TokenType.FOREIGN_KEY: 279>, <TokenType.FULL: 282>, <TokenType.FUNCTION: 283>, <TokenType.GET: 284>, <TokenType.INDEX: 295>, <TokenType.INTERVAL: 302>, <TokenType.IS: 306>, <TokenType.ISNULL: 307>, <TokenType.KEEP: 310>, <TokenType.KILL: 312>, <TokenType.LEFT: 315>, <TokenType.LIMIT: 317>, <TokenType.LIST: 318>, <TokenType.LOAD: 319>, <TokenType.LOCK: 320>, <TokenType.MAP: 321>, <TokenType.MATCH: 322>, <TokenType.MERGE: 326>, <TokenType.MODEL: 328>, <TokenType.NATURAL: 329>, <TokenType.NEXT: 330>, <TokenType.NOTHING: 331>, <TokenType.NULL: 333>, <TokenType.OBJECT_IDENTIFIER: 334>, <TokenType.OFFSET: 335>, <TokenType.OPERATOR: 338>, <TokenType.ORDINALITY: 342>, <TokenType.INOUT: 344>, <TokenType.OVER: 346>, <TokenType.OVERLAPS: 347>, <TokenType.OVERWRITE: 348>, <TokenType.PARTITION: 350>, <TokenType.PERCENT: 352>, <TokenType.PIVOT: 353>, <TokenType.PRAGMA: 358>, <TokenType.PROCEDURE: 361>, <TokenType.PSEUDO_TYPE: 363>, <TokenType.PUT: 364>, <TokenType.RANGE: 368>, <TokenType.RECURSIVE: 369>, <TokenType.REFRESH: 370>, <TokenType.RENAME: 371>, <TokenType.REPLACE: 372>, <TokenType.REFERENCES: 375>, <TokenType.RIGHT: 376>, <TokenType.ROLLUP: 380>, <TokenType.ROW: 381>, <TokenType.ROWS: 382>, <TokenType.SEMI: 385>, <TokenType.SEQUENCE: 387>, <TokenType.SET: 389>, <TokenType.SETTINGS: 390>, <TokenType.SHOW: 391>, <TokenType.SOME: 393>, <TokenType.STORAGE_INTEGRATION: 398>, <TokenType.STRAIGHT_JOIN: 399>, <TokenType.STRUCT: 400>, <TokenType.TAG: 403>, <TokenType.TEMPORARY: 404>, <TokenType.TOP: 405>, <TokenType.TRUE: 407>, <TokenType.TRUNCATE: 408>, <TokenType.TRIGGER: 409>, <TokenType.TYPE: 410>, <TokenType.UNNEST: 413>, <TokenType.UNPIVOT: 414>, <TokenType.UPDATE: 415>, <TokenType.USE: 416>, <TokenType.VIEW: 420>, <TokenType.SEMANTIC_VIEW: 421>, <TokenType.VOLATILE: 422>, <TokenType.WINDOW: 426>, <TokenType.UNIQUE: 428>, <TokenType.SINK: 435>, <TokenType.SOURCE: 436>, <TokenType.ANALYZE: 437>, <TokenType.NAMESPACE: 438>, <TokenType.EXPORT: 439>}
LOG_DEFAULTS_TO_LN = True
QUERY_MODIFIER_PARSERS = {<TokenType.MATCH_RECOGNIZE: 324>: <function Parser.<lambda>>, <TokenType.PREWHERE: 359>: <function Parser.<lambda>>, <TokenType.WHERE: 425>: <function Parser.<lambda>>, <TokenType.GROUP_BY: 288>: <function Parser.<lambda>>, <TokenType.HAVING: 290>: <function Parser.<lambda>>, <TokenType.QUALIFY: 365>: <function Parser.<lambda>>, <TokenType.WINDOW: 426>: <function Parser.<lambda>>, <TokenType.ORDER_BY: 339>: <function Parser.<lambda>>, <TokenType.LIMIT: 317>: <function Parser.<lambda>>, <TokenType.FETCH: 271>: <function Parser.<lambda>>, <TokenType.OFFSET: 335>: <function Parser.<lambda>>, <TokenType.FOR: 277>: <function Parser.<lambda>>, <TokenType.LOCK: 320>: <function Parser.<lambda>>, <TokenType.TABLE_SAMPLE: 402>: <function Parser.<lambda>>, <TokenType.USING: 417>: <function Parser.<lambda>>, <TokenType.CLUSTER_BY: 233>: <function Parser.<lambda>>, <TokenType.DISTRIBUTE_BY: 261>: <function Parser.<lambda>>, <TokenType.SORT_BY: 394>: <function Parser.<lambda>>, <TokenType.CONNECT_BY: 238>: <function Parser.<lambda>>, <TokenType.START_WITH: 397>: <function Parser.<lambda>>, <TokenType.SETTINGS: 390>: <function ClickHouseParser.<lambda>>, <TokenType.FORMAT: 280>: <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 = {'PERIOD', 'TRUNCATE', 'FOREIGN KEY', 'BUCKET', 'EXCLUDE', 'PRIMARY KEY', 'LIKE', 'UNIQUE', 'INDEX'}
PLACEHOLDER_PARSERS = {<TokenType.PLACEHOLDER: 354>: <function Parser.<lambda>>, <TokenType.PARAMETER: 56>: <function Parser.<lambda>>, <TokenType.COLON: 11>: <function Parser.<lambda>>, <TokenType.L_BRACE: 5>: <function ClickHouseParser.<lambda>>}
STATEMENT_PARSERS = {<TokenType.ALTER: 217>: <function Parser.<lambda>>, <TokenType.ANALYZE: 437>: <function Parser.<lambda>>, <TokenType.BEGIN: 227>: <function Parser.<lambda>>, <TokenType.CACHE: 230>: <function Parser.<lambda>>, <TokenType.COMMENT: 236>: <function Parser.<lambda>>, <TokenType.COMMIT: 237>: <function Parser.<lambda>>, <TokenType.COPY: 240>: <function Parser.<lambda>>, <TokenType.CREATE: 241>: <function Parser.<lambda>>, <TokenType.DELETE: 255>: <function Parser.<lambda>>, <TokenType.DESC: 256>: <function Parser.<lambda>>, <TokenType.DESCRIBE: 257>: <function Parser.<lambda>>, <TokenType.DROP: 263>: <function Parser.<lambda>>, <TokenType.GRANT: 287>: <function Parser.<lambda>>, <TokenType.REVOKE: 374>: <function Parser.<lambda>>, <TokenType.INSERT: 298>: <function Parser.<lambda>>, <TokenType.KILL: 312>: <function Parser.<lambda>>, <TokenType.LOAD: 319>: <function Parser.<lambda>>, <TokenType.MERGE: 326>: <function Parser.<lambda>>, <TokenType.PIVOT: 353>: <function Parser.<lambda>>, <TokenType.PRAGMA: 358>: <function Parser.<lambda>>, <TokenType.REFRESH: 370>: <function Parser.<lambda>>, <TokenType.ROLLBACK: 379>: <function Parser.<lambda>>, <TokenType.SET: 389>: <function Parser.<lambda>>, <TokenType.TRUNCATE: 408>: <function Parser.<lambda>>, <TokenType.UNCACHE: 411>: <function Parser.<lambda>>, <TokenType.UNPIVOT: 414>: <function Parser.<lambda>>, <TokenType.UPDATE: 415>: <function Parser.<lambda>>, <TokenType.USE: 416>: <function Parser.<lambda>>, <TokenType.SEMICOLON: 19>: <function Parser.<lambda>>, <TokenType.DETACH: 258>: <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
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