Edit on GitHub

sqlglot.parsers.clickhouse

View Source

  1from __future__ import annotations
  2
  3import typing as t
  4
  5from collections import deque
  6
  7from sqlglot import exp, parser
  8from sqlglot.dialects.dialect import (
  9    build_date_delta,
 10    build_formatted_time,
 11    build_json_extract_path,
 12    build_like,
 13)
 14from sqlglot.helper import seq_get
 15from sqlglot.tokens import Token, TokenType
 16from builtins import type as Type
 17
 18if t.TYPE_CHECKING:
 19    from sqlglot._typing import E
 20    from collections.abc import Mapping, Sequence, Collection
 21
 22
 23def _build_datetime_format(
 24    expr_type: Type[E],
 25) -> t.Callable:
 26    def _builder(args: list, dialect: t.Any) -> E:
 27        expr = build_formatted_time(expr_type)(args, dialect)
 28
 29        timezone = seq_get(args, 2)
 30        if timezone:
 31            expr.set("zone", timezone)
 32
 33        return expr
 34
 35    return _builder
 36
 37
 38def _build_count_if(args: list) -> exp.CountIf | exp.CombinedAggFunc:
 39    if len(args) == 1:
 40        return exp.CountIf(this=seq_get(args, 0))
 41
 42    return exp.CombinedAggFunc(this="countIf", expressions=args)
 43
 44
 45def _build_str_to_date(args: list) -> exp.Cast | exp.Anonymous:
 46    if len(args) == 3:
 47        return exp.Anonymous(this="STR_TO_DATE", expressions=args)
 48
 49    strtodate = exp.StrToDate.from_arg_list(args)
 50    return exp.cast(strtodate, exp.DType.DATETIME.into_expr())
 51
 52
 53def _build_timestamp_trunc(unit: str) -> t.Callable[[list], exp.TimestampTrunc]:
 54    return lambda args: exp.TimestampTrunc(
 55        this=seq_get(args, 0), unit=exp.var(unit), zone=seq_get(args, 1)
 56    )
 57
 58
 59def _build_split_by_char(args: list) -> exp.Split | exp.Anonymous:
 60    sep = seq_get(args, 0)
 61    if isinstance(sep, exp.Literal):
 62        sep_value = sep.to_py()
 63        if isinstance(sep_value, str) and len(sep_value.encode("utf-8")) == 1:
 64            return _build_split(exp.Split)(args)
 65
 66    return exp.Anonymous(this="splitByChar", expressions=args)
 67
 68
 69def _build_split(exp_class: Type[E]) -> t.Callable[[list], E]:
 70    return lambda args: exp_class(
 71        this=seq_get(args, 1), expression=seq_get(args, 0), limit=seq_get(args, 2)
 72    )
 73
 74
 75# Skip the 'week' unit since ClickHouse's toStartOfWeek
 76# uses an extra mode argument to specify the first day of the week
 77TIMESTAMP_TRUNC_UNITS = {
 78    "MICROSECOND",
 79    "MILLISECOND",
 80    "SECOND",
 81    "MINUTE",
 82    "HOUR",
 83    "DAY",
 84    "MONTH",
 85    "QUARTER",
 86    "YEAR",
 87}
 88
 89
 90AGG_FUNCTIONS = {
 91    "count",
 92    "min",
 93    "max",
 94    "sum",
 95    "avg",
 96    "any",
 97    "stddevPop",
 98    "stddevSamp",
 99    "varPop",
100    "varSamp",
101    "corr",
102    "covarPop",
103    "covarSamp",
104    "entropy",
105    "exponentialMovingAverage",
106    "intervalLengthSum",
107    "kolmogorovSmirnovTest",
108    "mannWhitneyUTest",
109    "median",
110    "rankCorr",
111    "sumKahan",
112    "studentTTest",
113    "welchTTest",
114    "anyHeavy",
115    "anyLast",
116    "boundingRatio",
117    "first_value",
118    "last_value",
119    "argMin",
120    "argMax",
121    "avgWeighted",
122    "topK",
123    "approx_top_sum",
124    "topKWeighted",
125    "deltaSum",
126    "deltaSumTimestamp",
127    "groupArray",
128    "groupArrayLast",
129    "groupConcat",
130    "groupUniqArray",
131    "groupArrayInsertAt",
132    "groupArrayMovingAvg",
133    "groupArrayMovingSum",
134    "groupArraySample",
135    "groupBitAnd",
136    "groupBitOr",
137    "groupBitXor",
138    "groupBitmap",
139    "groupBitmapAnd",
140    "groupBitmapOr",
141    "groupBitmapXor",
142    "sumWithOverflow",
143    "sumMap",
144    "minMap",
145    "maxMap",
146    "skewSamp",
147    "skewPop",
148    "kurtSamp",
149    "kurtPop",
150    "uniq",
151    "uniqExact",
152    "uniqCombined",
153    "uniqCombined64",
154    "uniqHLL12",
155    "uniqTheta",
156    "quantile",
157    "quantiles",
158    "quantileExact",
159    "quantileExactInclusive",
160    "quantilesExact",
161    "quantilesExactExclusive",
162    "quantileExactLow",
163    "quantilesExactLow",
164    "quantileExactHigh",
165    "quantilesExactHigh",
166    "quantileExactWeighted",
167    "quantilesExactWeighted",
168    "quantileTiming",
169    "quantilesTiming",
170    "quantileTimingWeighted",
171    "quantilesTimingWeighted",
172    "quantileDeterministic",
173    "quantilesDeterministic",
174    "quantileTDigest",
175    "quantilesTDigest",
176    "quantileTDigestWeighted",
177    "quantilesTDigestWeighted",
178    "quantileBFloat16",
179    "quantilesBFloat16",
180    "quantileBFloat16Weighted",
181    "quantilesBFloat16Weighted",
182    "simpleLinearRegression",
183    "stochasticLinearRegression",
184    "stochasticLogisticRegression",
185    "categoricalInformationValue",
186    "contingency",
187    "cramersV",
188    "cramersVBiasCorrected",
189    "theilsU",
190    "maxIntersections",
191    "maxIntersectionsPosition",
192    "meanZTest",
193    "quantileInterpolatedWeighted",
194    "quantilesInterpolatedWeighted",
195    "quantileGK",
196    "quantilesGK",
197    "sparkBar",
198    "sumCount",
199    "largestTriangleThreeBuckets",
200    "histogram",
201    "sequenceMatch",
202    "sequenceCount",
203    "windowFunnel",
204    "retention",
205    "uniqUpTo",
206    "sequenceNextNode",
207    "exponentialTimeDecayedAvg",
208}
209
210# Sorted longest-first so that compound suffixes (e.g. "SimpleState") are matched
211# before their sub-suffixes (e.g. "State") when resolving multi-combinator functions.
212AGG_FUNCTIONS_SUFFIXES: list[str] = sorted(
213    [
214        "If",
215        "Array",
216        "ArrayIf",
217        "Map",
218        "SimpleState",
219        "State",
220        "Merge",
221        "MergeState",
222        "ForEach",
223        "Distinct",
224        "OrDefault",
225        "OrNull",
226        "Resample",
227        "ArgMin",
228        "ArgMax",
229    ],
230    key=len,
231    reverse=True,
232)
233
234# Memoized examples of all 0- and 1-suffix aggregate function names
235AGG_FUNC_MAPPING: Mapping[str, tuple[str, str | None]] = {
236    f"{f}{sfx}": (f, sfx) for sfx in AGG_FUNCTIONS_SUFFIXES for f in AGG_FUNCTIONS
237} | {f: (f, None) for f in AGG_FUNCTIONS}
238
239
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        **{
256            regexp_extract: lambda args: exp.RegexpExtract(
257                this=seq_get(args, 0),
258                expression=seq_get(args, 1),
259                group=seq_get(args, 2),
260            )
261            for regexp_extract in ("REGEXPEXTRACT", "REGEXP_EXTRACT", "REGEXP_SUBSTR")
262        },
263        **{f"TOSTARTOF{unit}": _build_timestamp_trunc(unit=unit) for unit in TIMESTAMP_TRUNC_UNITS},
264        "ANY": exp.AnyValue.from_arg_list,
265        "ARRAYCOMPACT": exp.ArrayCompact.from_arg_list,
266        "ARRAYCONCAT": exp.ArrayConcat.from_arg_list,
267        "ARRAYDISTINCT": exp.ArrayDistinct.from_arg_list,
268        "ARRAYEXCEPT": exp.ArrayExcept.from_arg_list,
269        "ARRAYSUM": exp.ArraySum.from_arg_list,
270        "ARRAYMAX": exp.ArrayMax.from_arg_list,
271        "ARRAYMIN": exp.ArrayMin.from_arg_list,
272        "ARRAYREVERSE": exp.ArrayReverse.from_arg_list,
273        "ARRAYSLICE": exp.ArraySlice.from_arg_list,
274        "ARRAYFILTER": lambda args: exp.ArrayFilter(
275            this=seq_get(args, 1), expression=seq_get(args, 0)
276        ),
277        "ARRAYMAP": lambda args: exp.Transform(this=seq_get(args, 1), expression=seq_get(args, 0)),
278        "CURRENTDATABASE": exp.CurrentDatabase.from_arg_list,
279        "CURRENTSCHEMAS": exp.CurrentSchemas.from_arg_list,
280        "COUNTIF": _build_count_if,
281        "CITYHASH64": exp.CityHash64.from_arg_list,
282        "COSINEDISTANCE": exp.CosineDistance.from_arg_list,
283        "VERSION": exp.CurrentVersion.from_arg_list,
284        "DATE_ADD": build_date_delta(exp.DateAdd, default_unit=None),
285        "DATEADD": build_date_delta(exp.DateAdd, default_unit=None),
286        "DATE_DIFF": build_date_delta(exp.DateDiff, default_unit=None, supports_timezone=True),
287        "DATEDIFF": build_date_delta(exp.DateDiff, default_unit=None, supports_timezone=True),
288        "DATE_FORMAT": _build_datetime_format(exp.TimeToStr),
289        "DATE_SUB": build_date_delta(exp.DateSub, default_unit=None),
290        "DATESUB": build_date_delta(exp.DateSub, default_unit=None),
291        "DATETRUNC": exp.DateTrunc.from_arg_list,
292        "FORMATDATETIME": _build_datetime_format(exp.TimeToStr),
293        "HAS": exp.ArrayContains.from_arg_list,
294        "ILIKE": build_like(exp.ILike),
295        "JSONEXTRACTSTRING": build_json_extract_path(
296            exp.JSONExtractScalar, zero_based_indexing=False
297        ),
298        "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
299        "LIKE": build_like(exp.Like),
300        "L2Distance": exp.EuclideanDistance.from_arg_list,
301        "MAP": parser.build_var_map,
302        "MATCH": exp.RegexpLike.from_arg_list,
303        "NOTLIKE": build_like(exp.Like, not_like=True),
304        "PARSEDATETIME": _build_datetime_format(exp.ParseDatetime),
305        "RANDCANONICAL": exp.Rand.from_arg_list,
306        "STR_TO_DATE": _build_str_to_date,
307        "TIMESTAMP_SUB": build_date_delta(exp.TimestampSub, default_unit=None),
308        "TIMESTAMPSUB": build_date_delta(exp.TimestampSub, default_unit=None),
309        "TIMESTAMP_ADD": build_date_delta(exp.TimestampAdd, default_unit=None),
310        "TIMESTAMPADD": build_date_delta(exp.TimestampAdd, default_unit=None),
311        "TOMONDAY": _build_timestamp_trunc("WEEK"),
312        "UNIQ": exp.ApproxDistinct.from_arg_list,
313        "MD5": exp.MD5Digest.from_arg_list,
314        "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
315        "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
316        "SPLITBYCHAR": _build_split_by_char,
317        "SPLITBYREGEXP": _build_split(exp.RegexpSplit),
318        "SPLITBYSTRING": _build_split(exp.Split),
319        "SUBSTRINGINDEX": exp.SubstringIndex.from_arg_list,
320        "TOTYPENAME": exp.Typeof.from_arg_list,
321        "EDITDISTANCE": exp.Levenshtein.from_arg_list,
322        "JAROWINKLERSIMILARITY": exp.JarowinklerSimilarity.from_arg_list,
323        "LEVENSHTEINDISTANCE": exp.Levenshtein.from_arg_list,
324        "UTCTIMESTAMP": exp.UtcTimestamp.from_arg_list,
325    }
326
327    AGG_FUNCTIONS = AGG_FUNCTIONS
328    AGG_FUNCTIONS_SUFFIXES = AGG_FUNCTIONS_SUFFIXES
329
330    FUNC_TOKENS = {
331        *parser.Parser.FUNC_TOKENS,
332        TokenType.AND,
333        TokenType.FILE,
334        TokenType.OR,
335        TokenType.SET,
336    }
337
338    RESERVED_TOKENS = parser.Parser.RESERVED_TOKENS - {TokenType.SELECT}
339
340    ID_VAR_TOKENS = {
341        *parser.Parser.ID_VAR_TOKENS,
342        TokenType.LIKE,
343    }
344
345    AGG_FUNC_MAPPING = AGG_FUNC_MAPPING
346
347    @classmethod
348    def _resolve_clickhouse_agg(cls, name: str) -> tuple[str, Sequence[str]] | None:
349        # ClickHouse allows chaining multiple combinators on aggregate functions.
350        # See https://clickhouse.com/docs/sql-reference/aggregate-functions/combinators
351        # N.B. this resolution allows any suffix stack, including ones that ClickHouse rejects
352        # syntactically such as sumMergeMerge (due to repeated adjacent suffixes)
353
354        # Until we are able to identify a 1- or 0-suffix aggregate function by name,
355        # repeatedly strip and queue suffixes (checking longer suffixes first, see comment on
356        # AGG_FUNCTIONS_SUFFIXES_SORTED). This loop only runs for 2 or more suffixes,
357        # as AGG_FUNC_MAPPING memoizes all 0- and 1-suffix
358        accumulated_suffixes: deque[str] = deque()
359        while (parts := AGG_FUNC_MAPPING.get(name)) is None:
360            for suffix in AGG_FUNCTIONS_SUFFIXES:
361                if name.endswith(suffix) and len(name) != len(suffix):
362                    accumulated_suffixes.appendleft(suffix)
363                    name = name[: -len(suffix)]
364                    break
365            else:
366                return None
367
368        # We now have a 0- or 1-suffix aggregate
369        agg_func_name, inner_suffix = parts
370        if inner_suffix:
371            # this is a 1-suffix aggregate (either naturally or via repeated suffix
372            # stripping). prepend the innermost suffix.
373            accumulated_suffixes.appendleft(inner_suffix)
374
375        return (agg_func_name, accumulated_suffixes)
376
377    FUNCTION_PARSERS = {
378        **{k: v for k, v in parser.Parser.FUNCTION_PARSERS.items() if k != "MATCH"},
379        "ARRAYJOIN": lambda self: self.expression(exp.Explode(this=self._parse_expression())),
380        "GROUPCONCAT": lambda self: self._parse_group_concat(),
381        "QUANTILE": lambda self: self._parse_quantile(),
382        "MEDIAN": lambda self: self._parse_quantile(),
383        "COLUMNS": lambda self: self._parse_columns(),
384        "TUPLE": lambda self: exp.Struct.from_arg_list(self._parse_function_args(alias=True)),
385        "AND": lambda self: exp.and_(*self._parse_function_args(alias=False)),
386        "OR": lambda self: exp.or_(*self._parse_function_args(alias=False)),
387        "XOR": lambda self: exp.xor(*self._parse_function_args(alias=False)),
388    }
389
390    PROPERTY_PARSERS = {
391        **{k: v for k, v in parser.Parser.PROPERTY_PARSERS.items() if k != "DYNAMIC"},
392        "ENGINE": lambda self: self._parse_engine_property(),
393        "REFRESH": lambda self: self._parse_auto_refresh_property(),
394        "UUID": lambda self: self.expression(exp.UuidProperty(this=self._parse_string())),
395    }
396
397    NO_PAREN_FUNCTION_PARSERS = {
398        k: v for k, v in parser.Parser.NO_PAREN_FUNCTION_PARSERS.items() if k != "ANY"
399    }
400
401    NO_PAREN_FUNCTIONS = {
402        k: v
403        for k, v in parser.Parser.NO_PAREN_FUNCTIONS.items()
404        if k != TokenType.CURRENT_TIMESTAMP
405    }
406
407    RANGE_PARSERS = {
408        **parser.Parser.RANGE_PARSERS,
409        TokenType.GLOBAL: lambda self, this: self._parse_global_in(this),
410    }
411
412    COLUMN_OPERATORS = {
413        **{k: v for k, v in parser.Parser.COLUMN_OPERATORS.items() if k != TokenType.PLACEHOLDER},
414        TokenType.DOTCARET: lambda self, this, field: self.expression(
415            exp.NestedJSONSelect(this=this, expression=field)
416        ),
417    }
418
419    JOIN_KINDS = {
420        *parser.Parser.JOIN_KINDS,
421        TokenType.ALL,
422        TokenType.ANY,
423        TokenType.ASOF,
424        TokenType.ARRAY,
425    }
426
427    TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
428        TokenType.ALL,
429        TokenType.ANY,
430        TokenType.ARRAY,
431        TokenType.ASOF,
432        TokenType.FINAL,
433        TokenType.FORMAT,
434        TokenType.SETTINGS,
435    }
436
437    ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
438        TokenType.FORMAT,
439        TokenType.SETTINGS,
440    }
441
442    LOG_DEFAULTS_TO_LN = True
443
444    QUERY_MODIFIER_PARSERS = {
445        **parser.Parser.QUERY_MODIFIER_PARSERS,
446        TokenType.SETTINGS: lambda self: (
447            "settings",
448            self._advance() or self._parse_csv(self._parse_assignment),
449        ),
450        TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
451    }
452
453    CONSTRAINT_PARSERS = {
454        **parser.Parser.CONSTRAINT_PARSERS,
455        "INDEX": lambda self: self._parse_index_constraint(),
456        "CODEC": lambda self: self._parse_compress(),
457        "ASSUME": lambda self: self._parse_assume_constraint(),
458    }
459
460    ALTER_PARSERS = {
461        **parser.Parser.ALTER_PARSERS,
462        "MODIFY": lambda self: self._parse_alter_table_modify(),
463        "REPLACE": lambda self: self._parse_alter_table_replace(),
464    }
465
466    SCHEMA_UNNAMED_CONSTRAINTS = {
467        *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
468        "INDEX",
469    } - {"CHECK"}
470
471    PLACEHOLDER_PARSERS = {
472        **parser.Parser.PLACEHOLDER_PARSERS,
473        TokenType.L_BRACE: lambda self: self._parse_query_parameter(),
474    }
475
476    STATEMENT_PARSERS = {
477        **parser.Parser.STATEMENT_PARSERS,
478        TokenType.DETACH: lambda self: self._parse_detach(),
479    }
480
481    def _parse_wrapped_select_or_assignment(self) -> exp.Expr | None:
482        return self._parse_wrapped(
483            lambda: self._parse_select() or self._parse_assignment(), optional=True
484        )
485
486    def _parse_check_constraint(self) -> exp.CheckColumnConstraint | None:
487        return self.expression(
488            exp.CheckColumnConstraint(this=self._parse_wrapped_select_or_assignment())
489        )
490
491    def _parse_assume_constraint(self) -> exp.AssumeColumnConstraint | None:
492        return self.expression(
493            exp.AssumeColumnConstraint(this=self._parse_wrapped_select_or_assignment())
494        )
495
496    def _parse_engine_property(self) -> exp.EngineProperty:
497        self._match(TokenType.EQ)
498        return self.expression(
499            exp.EngineProperty(this=self._parse_field(any_token=True, anonymous_func=True))
500        )
501
502    # https://clickhouse.com/docs/en/sql-reference/statements/create/function
503    def _parse_user_defined_function_expression(self) -> exp.Expr | None:
504        return self._parse_lambda()
505
506    def _parse_types(
507        self,
508        check_func: bool = False,
509        schema: bool = False,
510        allow_identifiers: bool = True,
511        with_collation: bool = False,
512    ) -> exp.Expr | None:
513        dtype = super()._parse_types(
514            check_func=check_func,
515            schema=schema,
516            allow_identifiers=allow_identifiers,
517            with_collation=with_collation,
518        )
519        if isinstance(dtype, exp.DataType) and dtype.args.get("nullable") is not True:
520            # Mark every type as non-nullable which is ClickHouse's default, unless it's
521            # already marked as nullable. This marker helps us transpile types from other
522            # dialects to ClickHouse, so that we can e.g. produce `CAST(x AS Nullable(String))`
523            # from `CAST(x AS TEXT)`. If there is a `NULL` value in `x`, the former would
524            # fail in ClickHouse without the `Nullable` type constructor.
525            dtype.set("nullable", False)
526
527        return dtype
528
529    def _parse_extract(self) -> exp.Extract | exp.Anonymous:
530        index = self._index
531        this = self._parse_bitwise()
532        if self._match(TokenType.FROM):
533            self._retreat(index)
534            return super()._parse_extract()
535
536        # We return Anonymous here because extract and regexpExtract have different semantics,
537        # so parsing extract(foo, bar) into RegexpExtract can potentially break queries. E.g.,
538        # `extract('foobar', 'b')` works, but ClickHouse crashes for `regexpExtract('foobar', 'b')`.
539        #
540        # TODO: can we somehow convert the former into an equivalent `regexpExtract` call?
541        self._match(TokenType.COMMA)
542        return self.expression(
543            exp.Anonymous(this="extract", expressions=[this, self._parse_bitwise()])
544        )
545
546    def _parse_assignment(self) -> exp.Expr | None:
547        this = super()._parse_assignment()
548
549        if self._match(TokenType.PLACEHOLDER):
550            return self.expression(
551                exp.If(
552                    this=this,
553                    true=self._parse_assignment(),
554                    false=self._match(TokenType.COLON) and self._parse_assignment(),
555                )
556            )
557
558        return this
559
560    def _parse_query_parameter(self) -> exp.Expr | None:
561        """
562        Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
563        https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
564        """
565        index = self._index
566
567        this = self._parse_id_var()
568        self._match(TokenType.COLON)
569        kind = self._parse_types(check_func=False, allow_identifiers=False) or (
570            self._match_text_seq("IDENTIFIER") and "Identifier"
571        )
572
573        if not kind:
574            self._retreat(index)
575            return None
576        elif not self._match(TokenType.R_BRACE):
577            self.raise_error("Expecting }")
578
579        if isinstance(this, exp.Identifier) and not this.quoted:
580            this = exp.var(this.name)
581
582        return self.expression(exp.Placeholder(this=this, kind=kind))
583
584    def _parse_bracket(self, this: exp.Expr | None = None) -> exp.Expr | None:
585        if this:
586            bracket_json_type = None
587
588            while self._match_pair(TokenType.L_BRACKET, TokenType.R_BRACKET):
589                bracket_json_type = exp.DataType(
590                    this=exp.DType.ARRAY,
591                    expressions=[
592                        bracket_json_type
593                        or exp.DType.JSON.into_expr(dialect=self.dialect, nullable=False)
594                    ],
595                    nested=True,
596                )
597
598            if bracket_json_type:
599                return self.expression(exp.JSONCast(this=this, to=bracket_json_type))
600
601        l_brace = self._match(TokenType.L_BRACE, advance=False)
602        bracket = super()._parse_bracket(this)
603
604        if l_brace and isinstance(bracket, exp.Struct):
605            varmap = exp.VarMap(keys=exp.Array(), values=exp.Array())
606            for expression in bracket.expressions:
607                if not isinstance(expression, exp.PropertyEQ):
608                    break
609
610                varmap.args["keys"].append("expressions", exp.Literal.string(expression.name))
611                varmap.args["values"].append("expressions", expression.expression)
612
613            return varmap
614
615        return bracket
616
617    def _parse_global_in(self, this: exp.Expr | None) -> exp.Not | exp.In:
618        is_negated = self._match(TokenType.NOT)
619        in_expr: exp.In | None = None
620        if self._match(TokenType.IN):
621            in_expr = self._parse_in(this)
622            in_expr.set("is_global", True)
623        return self.expression(exp.Not(this=in_expr)) if is_negated else t.cast(exp.In, in_expr)
624
625    def _parse_table(
626        self,
627        schema: bool = False,
628        joins: bool = False,
629        alias_tokens: Collection[TokenType] | None = None,
630        parse_bracket: bool = False,
631        is_db_reference: bool = False,
632        parse_partition: bool = False,
633        consume_pipe: bool = False,
634    ) -> exp.Expr | None:
635        this = super()._parse_table(
636            schema=schema,
637            joins=joins,
638            alias_tokens=alias_tokens,
639            parse_bracket=parse_bracket,
640            is_db_reference=is_db_reference,
641        )
642
643        if isinstance(this, exp.Table):
644            inner = this.this
645            alias = this.args.get("alias")
646
647            if isinstance(inner, exp.GenerateSeries) and alias and not alias.columns:
648                alias.set("columns", [exp.to_identifier("generate_series")])
649
650        if self._match(TokenType.FINAL):
651            this = self.expression(exp.Final(this=this))
652
653        return this
654
655    def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
656        return super()._parse_position(haystack_first=True)
657
658    # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
659    def _parse_cte(self) -> exp.CTE | exp.FunctionSpecification | None:
660        # WITH <identifier> AS <subquery expression>
661        cte: exp.CTE | exp.FunctionSpecification | None = self._try_parse(super()._parse_cte)
662
663        if not cte:
664            # WITH <expression> AS <identifier>
665            cte = self.expression(
666                exp.CTE(this=self._parse_assignment(), alias=self._parse_table_alias(), scalar=True)
667            )
668
669        return cte
670
671    def _parse_join_parts(
672        self,
673    ) -> tuple[Token | None, Token | None, Token | None]:
674        is_global = self._prev if self._match(TokenType.GLOBAL) else None
675
676        kind_pre = self._prev if self._match_set(self.JOIN_KINDS) else None
677        side = self._prev if self._match_set(self.JOIN_SIDES) else None
678        kind = self._prev if self._match_set(self.JOIN_KINDS) else None
679
680        return is_global, side or kind, kind_pre or kind
681
682    def _parse_join(
683        self,
684        skip_join_token: bool = False,
685        parse_bracket: bool = False,
686        alias_tokens: t.Collection[TokenType] | None = None,
687    ) -> exp.Join | None:
688        join = super()._parse_join(
689            skip_join_token=skip_join_token, parse_bracket=True, alias_tokens=alias_tokens
690        )
691        if join:
692            method = join.args.get("method")
693            join.set("method", None)
694            join.set("global_", method)
695
696            # tbl ARRAY JOIN arr <-- this should be a `Column` reference, not a `Table`
697            # https://clickhouse.com/docs/en/sql-reference/statements/select/array-join
698            if join.kind == "ARRAY":
699                for table in join.find_all(exp.Table):
700                    table.replace(table.to_column())
701
702        return join
703
704    def _parse_function(
705        self,
706        functions: dict[str, t.Callable] | None = None,
707        anonymous: bool = False,
708        optional_parens: bool = True,
709        any_token: bool = False,
710    ) -> exp.Expr | None:
711        expr = super()._parse_function(
712            functions=functions,
713            anonymous=anonymous,
714            optional_parens=optional_parens,
715            any_token=any_token,
716        )
717
718        func = expr.this if isinstance(expr, exp.Window) else expr
719
720        # Aggregate functions can be split in 2 parts: <func_name><suffix[es]>
721        parts = self._resolve_clickhouse_agg(func.this) if isinstance(func, exp.Anonymous) else None
722
723        if parts:
724            anon_func: exp.Anonymous = t.cast(exp.Anonymous, func)
725            params = self._parse_func_params(anon_func)
726
727            if len(parts[1]) > 0:
728                exp_class: Type[exp.Expr] = (
729                    exp.CombinedParameterizedAgg if params else exp.CombinedAggFunc
730                )
731            else:
732                exp_class = exp.ParameterizedAgg if params else exp.AnonymousAggFunc
733
734            instance = exp_class(this=anon_func.this, expressions=anon_func.expressions)
735            if params:
736                instance.set("params", params)
737            func = self.expression(instance)
738
739            if isinstance(expr, exp.Window):
740                # The window's func was parsed as Anonymous in base parser, fix its
741                # type to be ClickHouse style CombinedAnonymousAggFunc / AnonymousAggFunc
742                expr.set("this", func)
743            elif params:
744                # Params have blocked super()._parse_function() from parsing the following window
745                # (if that exists) as they're standing between the function call and the window spec
746                expr = self._parse_window(func)
747            else:
748                expr = func
749
750        return expr
751
752    def _parse_func_params(self, this: exp.Func | None = None) -> list[exp.Expr] | None:
753        if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
754            return self._parse_csv(self._parse_lambda)
755
756        if self._match(TokenType.L_PAREN):
757            params = self._parse_csv(self._parse_lambda)
758            self._match_r_paren(this)
759            return params
760
761        return None
762
763    def _parse_group_concat(self) -> exp.GroupConcat:
764        args = self._parse_csv(self._parse_lambda)
765        params = self._parse_func_params()
766
767        if params:
768            # groupConcat(sep [, limit])(expr)
769            separator = seq_get(args, 0)
770            limit = seq_get(args, 1)
771            this: exp.Expr | None = seq_get(params, 0)
772            if limit is not None:
773                this = exp.Limit(this=this, expression=limit)
774            return self.expression(exp.GroupConcat(this=this, separator=separator))
775
776        # groupConcat(expr)
777        return self.expression(exp.GroupConcat(this=seq_get(args, 0)))
778
779    def _parse_quantile(self) -> exp.Quantile:
780        this = self._parse_lambda()
781        params = self._parse_func_params()
782        if params:
783            return self.expression(exp.Quantile(this=params[0], quantile=this))
784        return self.expression(exp.Quantile(this=this, quantile=exp.Literal.number(0.5)))
785
786    def _parse_wrapped_id_vars(self, optional: bool = False) -> list[exp.Expr]:
787        return super()._parse_wrapped_id_vars(optional=True)
788
789    def _parse_column_def(
790        self, this: exp.Expr | None, computed_column: bool = True
791    ) -> exp.Expr | None:
792        if self._match(TokenType.DOT):
793            return exp.Dot(this=this, expression=self._parse_id_var())
794
795        return super()._parse_column_def(this, computed_column=computed_column)
796
797    def _parse_primary_key(
798        self,
799        wrapped_optional: bool = False,
800        in_props: bool = False,
801        named_primary_key: bool = False,
802    ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
803        return super()._parse_primary_key(
804            wrapped_optional=wrapped_optional or in_props,
805            in_props=in_props,
806            named_primary_key=named_primary_key,
807        )
808
809    def _parse_on_property(self) -> exp.Expr | None:
810        index = self._index
811        if self._match_text_seq("CLUSTER"):
812            this = self._parse_string() or self._parse_id_var()
813            if this:
814                return self.expression(exp.OnCluster(this=this))
815            else:
816                self._retreat(index)
817        return None
818
819    def _parse_auto_refresh_property(self) -> exp.AutoRefreshProperty | None:
820        index = self._index - 1
821        cadence = self._prev.text.upper() if self._match_texts(("EVERY", "AFTER")) else None
822        interval = (
823            self._parse_interval(require_interval=False, parse_function_unit=False)
824            if cadence
825            else None
826        )
827
828        if cadence and not interval:
829            self._retreat(index)
830            return None
831
832        offset = None
833        if self._match_text_seq("OFFSET"):
834            offset = self._parse_interval(require_interval=False, parse_function_unit=False)
835            if not offset:
836                self._retreat(index)
837                return None
838
839        randomize = None
840        if self._match_text_seq("RANDOMIZE", "FOR"):
841            randomize = self._parse_interval(require_interval=False, parse_function_unit=False)
842            if not randomize:
843                self._retreat(index)
844                return None
845
846        dependencies = None
847        if self._match_text_seq("DEPENDS", "ON"):
848            dependencies = self._parse_csv(lambda: self._parse_table_parts(schema=True))
849            if not dependencies:
850                self._retreat(index)
851                return None
852
853        if not cadence and not dependencies:
854            self._retreat(index)
855            return None
856
857        settings = self._parse_settings_property() if self._match_text_seq("SETTINGS") else None
858
859        return self.expression(
860            exp.AutoRefreshProperty(
861                this=interval,
862                cadence=cadence,
863                offset=offset,
864                randomize=randomize,
865                expressions=dependencies,
866                settings=settings,
867                append=self._match_text_seq("APPEND"),
868            )
869        )
870
871    def _parse_index_constraint(self, kind: str | None = None) -> exp.IndexColumnConstraint:
872        # INDEX name1 expr TYPE type1(args) GRANULARITY value
873        this = self._parse_id_var()
874        expression = self._parse_assignment()
875
876        index_type = self._match_text_seq("TYPE") and (self._parse_function() or self._parse_var())
877
878        granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
879
880        return self.expression(
881            exp.IndexColumnConstraint(
882                this=this, expression=expression, index_type=index_type, granularity=granularity
883            )
884        )
885
886    def _parse_partition(self) -> exp.Partition | None:
887        # https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#how-to-set-partition-expression
888        if not self._match(TokenType.PARTITION):
889            return None
890
891        if self._match_text_seq("ID"):
892            # Corresponds to the PARTITION ID <string_value> syntax
893            expressions: list[exp.Expr] = [
894                self.expression(exp.PartitionId(this=self._parse_string()))
895            ]
896        else:
897            expressions = self._parse_expressions()
898
899        return self.expression(exp.Partition(expressions=expressions))
900
901    def _parse_alter_table_replace(self) -> exp.Expr | None:
902        partition = self._parse_partition()
903
904        if not partition or not self._match(TokenType.FROM):
905            return None
906
907        return self.expression(
908            exp.ReplacePartition(expression=partition, source=self._parse_table_parts())
909        )
910
911    def _parse_alter_table_modify(self) -> exp.Expr | None:
912        if properties := self._parse_properties():
913            return self.expression(exp.AlterModifySqlSecurity(expressions=properties.expressions))
914        return None
915
916    def _parse_definer(self) -> exp.DefinerProperty | None:
917        self._match(TokenType.EQ)
918        if self._match(TokenType.CURRENT_USER):
919            return exp.DefinerProperty(this=exp.Var(this=self._prev.text.upper()))
920        return exp.DefinerProperty(this=self._parse_string())
921
922    def _parse_projection_def(self) -> exp.ProjectionDef | None:
923        if not self._match(TokenType.PROJECTION):
924            return None
925
926        return self.expression(
927            exp.ProjectionDef(
928                this=self._parse_id_var(), expression=self._parse_wrapped(self._parse_statement)
929            )
930        )
931
932    def _parse_constraint(self) -> exp.Expr | None:
933        return super()._parse_constraint() or self._parse_projection_def()
934
935    def _parse_alias(self, this: exp.Expr | None, explicit: bool = False) -> exp.Expr | None:
936        # In clickhouse "SELECT <expr> APPLY(...)" is a query modifier,
937        # so "APPLY" shouldn't be parsed as <expr>'s alias. However, "SELECT <expr> apply" is a valid alias
938        if self._match_pair(TokenType.APPLY, TokenType.L_PAREN, advance=False):
939            return this
940
941        return super()._parse_alias(this=this, explicit=explicit)
942
943    def _parse_expression(self) -> exp.Expr | None:
944        this = super()._parse_expression()
945
946        # Clickhouse allows "SELECT <expr> [APPLY(func)] [...]]" modifier
947        while self._match_pair(TokenType.APPLY, TokenType.L_PAREN):
948            this = exp.Apply(this=this, expression=self._parse_var(any_token=True))
949            self._match(TokenType.R_PAREN)
950
951        return this
952
953    def _parse_columns(self) -> exp.Expr:
954        this: exp.Expr = self.expression(exp.Columns(this=self._parse_lambda()))
955
956        while self._next and self._match_text_seq(")", "APPLY", "("):
957            self._match(TokenType.R_PAREN)
958            this = exp.Apply(this=this, expression=self._parse_var(any_token=True))
959        return this
960
961    def _parse_value(self, values: bool = True) -> exp.Tuple | None:
962        value = super()._parse_value(values=values)
963        if not value:
964            return None
965
966        # In Clickhouse "SELECT * FROM VALUES (1, 2, 3)" generates a table with a single column, in contrast
967        # to other dialects. For this case, we canonicalize the values into a tuple-of-tuples AST if it's not already one.
968        # In INSERT INTO statements the same clause actually references multiple columns (opposite semantics),
969        # but the final result is not altered by the extra parentheses.
970        # Note: Clickhouse allows VALUES([structure], value, ...) so the branch checks for the last expression
971        expressions = value.expressions
972        if values and not isinstance(expressions[-1], exp.Tuple):
973            value.set(
974                "expressions",
975                [self.expression(exp.Tuple(expressions=[expr])) for expr in expressions],
976            )
977
978        return value
979
980    def _parse_partitioned_by(self) -> exp.PartitionedByProperty:
981        # ClickHouse allows custom expressions as partition key
982        # https://clickhouse.com/docs/engines/table-engines/mergetree-family/custom-partitioning-key
983        return self.expression(exp.PartitionedByProperty(this=self._parse_assignment()))
984
985    def _parse_detach(self) -> exp.Detach:
986        kind = self._match_set(self.DB_CREATABLES) and self._prev.text.upper()
987        exists = self._parse_exists()
988        this = self._parse_table_parts()
989
990        return self.expression(
991            exp.Detach(
992                this=this,
993                kind=kind,
994                exists=exists,
995                cluster=self._parse_on_property() if self._match(TokenType.ON) else None,
996                permanent=self._match_text_seq("PERMANENTLY"),
997                sync=self._match_text_seq("SYNC"),
998            )
999        )

TIMESTAMP_TRUNC_UNITS = {'MINUTE', 'MICROSECOND', 'SECOND', 'MONTH', 'QUARTER', 'MILLISECOND', 'HOUR', 'DAY', 'YEAR'}

AGG_FUNCTIONS = {'simpleLinearRegression', 'quantilesTimingWeighted', 'intervalLengthSum', 'quantilesBFloat16', 'deltaSum', 'maxIntersections', 'quantilesExactLow', 'contingency', 'anyLast', 'last_value', 'sparkBar', 'groupArray', 'stddevPop', 'quantilesTiming', 'uniqHLL12', 'quantilesExactHigh', 'uniqCombined', 'quantilesExactExclusive', 'quantilesExact', 'exponentialMovingAverage', 'stochasticLogisticRegression', 'quantileExactLow', 'maxIntersectionsPosition', 'first_value', 'mannWhitneyUTest', 'quantilesTDigestWeighted', 'groupBitmap', 'sumMap', 'groupBitmapOr', 'rankCorr', 'count', 'quantileTimingWeighted', 'uniqExact', 'stddevSamp', 'windowFunnel', 'quantilesTDigest', 'theilsU', 'groupBitAnd', 'groupBitOr', 'groupBitmapAnd', 'welchTTest', 'entropy', 'argMin', 'any', 'retention', 'sequenceNextNode', 'corr', 'uniqUpTo', 'quantile', 'groupArrayMovingSum', 'varSamp', 'stochasticLinearRegression', 'sequenceCount', 'uniqCombined64', 'quantileTiming', 'quantilesExactWeighted', 'anyHeavy', 'quantileTDigest', 'kolmogorovSmirnovTest', 'uniqTheta', 'histogram', 'quantileTDigestWeighted', 'covarPop', 'quantileExactInclusive', 'boundingRatio', 'quantileExact', 'varPop', 'sumKahan', 'minMap', 'meanZTest', 'topKWeighted', 'uniq', 'largestTriangleThreeBuckets', 'quantileExactHigh', 'kurtPop', 'quantilesInterpolatedWeighted', 'quantileBFloat16', 'approx_top_sum', 'sum', 'topK', 'skewSamp', 'groupArrayInsertAt', 'quantilesDeterministic', 'sumCount', 'sumWithOverflow', 'avg', 'skewPop', 'cramersV', 'groupArrayMovingAvg', 'exponentialTimeDecayedAvg', 'quantileDeterministic', 'median', 'groupUniqArray', 'covarSamp', 'argMax', 'groupBitXor', 'deltaSumTimestamp', 'groupArraySample', 'quantilesGK', 'quantileExactWeighted', 'quantileGK', 'quantilesBFloat16Weighted', 'cramersVBiasCorrected', 'maxMap', 'sequenceMatch', 'quantileBFloat16Weighted', 'avgWeighted', 'quantileInterpolatedWeighted', 'categoricalInformationValue', 'studentTTest', 'min', 'max', 'quantiles', 'groupConcat', 'groupArrayLast', 'groupBitmapXor', 'kurtSamp'}

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

sqlglot.parsers.clickhouse

Arguments:

Inherited Members