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

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