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    "quantilesExact",
160    "quantilesExactExclusive",
161    "quantileExactLow",
162    "quantilesExactLow",
163    "quantileExactHigh",
164    "quantilesExactHigh",
165    "quantileExactWeighted",
166    "quantilesExactWeighted",
167    "quantileTiming",
168    "quantilesTiming",
169    "quantileTimingWeighted",
170    "quantilesTimingWeighted",
171    "quantileDeterministic",
172    "quantilesDeterministic",
173    "quantileTDigest",
174    "quantilesTDigest",
175    "quantileTDigestWeighted",
176    "quantilesTDigestWeighted",
177    "quantileBFloat16",
178    "quantilesBFloat16",
179    "quantileBFloat16Weighted",
180    "quantilesBFloat16Weighted",
181    "simpleLinearRegression",
182    "stochasticLinearRegression",
183    "stochasticLogisticRegression",
184    "categoricalInformationValue",
185    "contingency",
186    "cramersV",
187    "cramersVBiasCorrected",
188    "theilsU",
189    "maxIntersections",
190    "maxIntersectionsPosition",
191    "meanZTest",
192    "quantileInterpolatedWeighted",
193    "quantilesInterpolatedWeighted",
194    "quantileGK",
195    "quantilesGK",
196    "sparkBar",
197    "sumCount",
198    "largestTriangleThreeBuckets",
199    "histogram",
200    "sequenceMatch",
201    "sequenceCount",
202    "windowFunnel",
203    "retention",
204    "uniqUpTo",
205    "sequenceNextNode",
206    "exponentialTimeDecayedAvg",
207}
208
209# Sorted longest-first so that compound suffixes (e.g. "SimpleState") are matched
210# before their sub-suffixes (e.g. "State") when resolving multi-combinator functions.
211AGG_FUNCTIONS_SUFFIXES: list[str] = sorted(
212    [
213        "If",
214        "Array",
215        "ArrayIf",
216        "Map",
217        "SimpleState",
218        "State",
219        "Merge",
220        "MergeState",
221        "ForEach",
222        "Distinct",
223        "OrDefault",
224        "OrNull",
225        "Resample",
226        "ArgMin",
227        "ArgMax",
228    ],
229    key=len,
230    reverse=True,
231)
232
233# Memoized examples of all 0- and 1-suffix aggregate function names
234AGG_FUNC_MAPPING: Mapping[str, tuple[str, str | None]] = {
235    f"{f}{sfx}": (f, sfx) for sfx in AGG_FUNCTIONS_SUFFIXES for f in AGG_FUNCTIONS
236} | {f: (f, None) for f in AGG_FUNCTIONS}
237
238
239class ClickHouseParser(parser.Parser):
240    # Tested in ClickHouse's playground, it seems that the following two queries do the same thing
241    # * select x from t1 union all select x from t2 limit 1;
242    # * select x from t1 union all (select x from t2 limit 1);
243    MODIFIERS_ATTACHED_TO_SET_OP = False
244    INTERVAL_SPANS = False
245    OPTIONAL_ALIAS_TOKEN_CTE = False
246    JOINS_HAVE_EQUAL_PRECEDENCE = True
247
248    FUNCTIONS = {
249        **{
250            k: v
251            for k, v in parser.Parser.FUNCTIONS.items()
252            if k not in ("TRANSFORM", "APPROX_TOP_SUM")
253        },
254        **{f"TOSTARTOF{unit}": _build_timestamp_trunc(unit=unit) for unit in TIMESTAMP_TRUNC_UNITS},
255        "ANY": exp.AnyValue.from_arg_list,
256        "ARRAYCOMPACT": exp.ArrayCompact.from_arg_list,
257        "ARRAYCONCAT": exp.ArrayConcat.from_arg_list,
258        "ARRAYDISTINCT": exp.ArrayDistinct.from_arg_list,
259        "ARRAYEXCEPT": exp.ArrayExcept.from_arg_list,
260        "ARRAYSUM": exp.ArraySum.from_arg_list,
261        "ARRAYMAX": exp.ArrayMax.from_arg_list,
262        "ARRAYMIN": exp.ArrayMin.from_arg_list,
263        "ARRAYREVERSE": exp.ArrayReverse.from_arg_list,
264        "ARRAYSLICE": exp.ArraySlice.from_arg_list,
265        "ARRAYFILTER": lambda args: exp.ArrayFilter(
266            this=seq_get(args, 1), expression=seq_get(args, 0)
267        ),
268        "ARRAYMAP": lambda args: exp.Transform(this=seq_get(args, 1), expression=seq_get(args, 0)),
269        "CURRENTDATABASE": exp.CurrentDatabase.from_arg_list,
270        "CURRENTSCHEMAS": exp.CurrentSchemas.from_arg_list,
271        "COUNTIF": _build_count_if,
272        "CITYHASH64": exp.CityHash64.from_arg_list,
273        "COSINEDISTANCE": exp.CosineDistance.from_arg_list,
274        "VERSION": exp.CurrentVersion.from_arg_list,
275        "DATE_ADD": build_date_delta(exp.DateAdd, default_unit=None),
276        "DATEADD": build_date_delta(exp.DateAdd, default_unit=None),
277        "DATE_DIFF": build_date_delta(exp.DateDiff, default_unit=None, supports_timezone=True),
278        "DATEDIFF": build_date_delta(exp.DateDiff, default_unit=None, supports_timezone=True),
279        "DATE_FORMAT": _build_datetime_format(exp.TimeToStr),
280        "DATE_SUB": build_date_delta(exp.DateSub, default_unit=None),
281        "DATESUB": build_date_delta(exp.DateSub, default_unit=None),
282        "FORMATDATETIME": _build_datetime_format(exp.TimeToStr),
283        "HAS": exp.ArrayContains.from_arg_list,
284        "ILIKE": build_like(exp.ILike),
285        "JSONEXTRACTSTRING": build_json_extract_path(
286            exp.JSONExtractScalar, zero_based_indexing=False
287        ),
288        "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
289        "LIKE": build_like(exp.Like),
290        "L2Distance": exp.EuclideanDistance.from_arg_list,
291        "MAP": parser.build_var_map,
292        "MATCH": exp.RegexpLike.from_arg_list,
293        "NOTLIKE": build_like(exp.Like, not_like=True),
294        "PARSEDATETIME": _build_datetime_format(exp.ParseDatetime),
295        "RANDCANONICAL": exp.Rand.from_arg_list,
296        "STR_TO_DATE": _build_str_to_date,
297        "TIMESTAMP_SUB": build_date_delta(exp.TimestampSub, default_unit=None),
298        "TIMESTAMPSUB": build_date_delta(exp.TimestampSub, default_unit=None),
299        "TIMESTAMP_ADD": build_date_delta(exp.TimestampAdd, default_unit=None),
300        "TIMESTAMPADD": build_date_delta(exp.TimestampAdd, default_unit=None),
301        "TOMONDAY": _build_timestamp_trunc("WEEK"),
302        "UNIQ": exp.ApproxDistinct.from_arg_list,
303        "MD5": exp.MD5Digest.from_arg_list,
304        "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
305        "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
306        "SPLITBYCHAR": _build_split_by_char,
307        "SPLITBYREGEXP": _build_split(exp.RegexpSplit),
308        "SPLITBYSTRING": _build_split(exp.Split),
309        "SUBSTRINGINDEX": exp.SubstringIndex.from_arg_list,
310        "TOTYPENAME": exp.Typeof.from_arg_list,
311        "EDITDISTANCE": exp.Levenshtein.from_arg_list,
312        "JAROWINKLERSIMILARITY": exp.JarowinklerSimilarity.from_arg_list,
313        "LEVENSHTEINDISTANCE": exp.Levenshtein.from_arg_list,
314        "UTCTIMESTAMP": exp.UtcTimestamp.from_arg_list,
315    }
316
317    AGG_FUNCTIONS = AGG_FUNCTIONS
318    AGG_FUNCTIONS_SUFFIXES = AGG_FUNCTIONS_SUFFIXES
319
320    FUNC_TOKENS = {
321        *parser.Parser.FUNC_TOKENS,
322        TokenType.AND,
323        TokenType.FILE,
324        TokenType.OR,
325        TokenType.SET,
326    }
327
328    RESERVED_TOKENS = parser.Parser.RESERVED_TOKENS - {TokenType.SELECT}
329
330    ID_VAR_TOKENS = {
331        *parser.Parser.ID_VAR_TOKENS,
332        TokenType.LIKE,
333    }
334
335    AGG_FUNC_MAPPING = AGG_FUNC_MAPPING
336
337    @classmethod
338    def _resolve_clickhouse_agg(cls, name: str) -> tuple[str, Sequence[str]] | None:
339        # ClickHouse allows chaining multiple combinators on aggregate functions.
340        # See https://clickhouse.com/docs/sql-reference/aggregate-functions/combinators
341        # N.B. this resolution allows any suffix stack, including ones that ClickHouse rejects
342        # syntactically such as sumMergeMerge (due to repeated adjacent suffixes)
343
344        # Until we are able to identify a 1- or 0-suffix aggregate function by name,
345        # repeatedly strip and queue suffixes (checking longer suffixes first, see comment on
346        # AGG_FUNCTIONS_SUFFIXES_SORTED). This loop only runs for 2 or more suffixes,
347        # as AGG_FUNC_MAPPING memoizes all 0- and 1-suffix
348        accumulated_suffixes: deque[str] = deque()
349        while (parts := AGG_FUNC_MAPPING.get(name)) is None:
350            for suffix in AGG_FUNCTIONS_SUFFIXES:
351                if name.endswith(suffix) and len(name) != len(suffix):
352                    accumulated_suffixes.appendleft(suffix)
353                    name = name[: -len(suffix)]
354                    break
355            else:
356                return None
357
358        # We now have a 0- or 1-suffix aggregate
359        agg_func_name, inner_suffix = parts
360        if inner_suffix:
361            # this is a 1-suffix aggregate (either naturally or via repeated suffix
362            # stripping). prepend the innermost suffix.
363            accumulated_suffixes.appendleft(inner_suffix)
364
365        return (agg_func_name, accumulated_suffixes)
366
367    FUNCTION_PARSERS = {
368        **{k: v for k, v in parser.Parser.FUNCTION_PARSERS.items() if k != "MATCH"},
369        "ARRAYJOIN": lambda self: self.expression(exp.Explode(this=self._parse_expression())),
370        "GROUPCONCAT": lambda self: self._parse_group_concat(),
371        "QUANTILE": lambda self: self._parse_quantile(),
372        "MEDIAN": lambda self: self._parse_quantile(),
373        "COLUMNS": lambda self: self._parse_columns(),
374        "TUPLE": lambda self: exp.Struct.from_arg_list(self._parse_function_args(alias=True)),
375        "AND": lambda self: exp.and_(*self._parse_function_args(alias=False)),
376        "OR": lambda self: exp.or_(*self._parse_function_args(alias=False)),
377        "XOR": lambda self: exp.xor(*self._parse_function_args(alias=False)),
378    }
379
380    PROPERTY_PARSERS = {
381        **{k: v for k, v in parser.Parser.PROPERTY_PARSERS.items() if k != "DYNAMIC"},
382        "ENGINE": lambda self: self._parse_engine_property(),
383        "UUID": lambda self: self.expression(exp.UuidProperty(this=self._parse_string())),
384    }
385
386    NO_PAREN_FUNCTION_PARSERS = {
387        k: v for k, v in parser.Parser.NO_PAREN_FUNCTION_PARSERS.items() if k != "ANY"
388    }
389
390    NO_PAREN_FUNCTIONS = {
391        k: v
392        for k, v in parser.Parser.NO_PAREN_FUNCTIONS.items()
393        if k != TokenType.CURRENT_TIMESTAMP
394    }
395
396    RANGE_PARSERS = {
397        **parser.Parser.RANGE_PARSERS,
398        TokenType.GLOBAL: lambda self, this: self._parse_global_in(this),
399    }
400
401    COLUMN_OPERATORS = {
402        **{k: v for k, v in parser.Parser.COLUMN_OPERATORS.items() if k != TokenType.PLACEHOLDER},
403        TokenType.DOTCARET: lambda self, this, field: self.expression(
404            exp.NestedJSONSelect(this=this, expression=field)
405        ),
406    }
407
408    JOIN_KINDS = {
409        *parser.Parser.JOIN_KINDS,
410        TokenType.ALL,
411        TokenType.ANY,
412        TokenType.ASOF,
413        TokenType.ARRAY,
414    }
415
416    TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
417        TokenType.ALL,
418        TokenType.ANY,
419        TokenType.ARRAY,
420        TokenType.ASOF,
421        TokenType.FINAL,
422        TokenType.FORMAT,
423        TokenType.SETTINGS,
424    }
425
426    ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
427        TokenType.FORMAT,
428        TokenType.SETTINGS,
429    }
430
431    LOG_DEFAULTS_TO_LN = True
432
433    QUERY_MODIFIER_PARSERS = {
434        **parser.Parser.QUERY_MODIFIER_PARSERS,
435        TokenType.SETTINGS: lambda self: (
436            "settings",
437            self._advance() or self._parse_csv(self._parse_assignment),
438        ),
439        TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
440    }
441
442    CONSTRAINT_PARSERS = {
443        **parser.Parser.CONSTRAINT_PARSERS,
444        "INDEX": lambda self: self._parse_index_constraint(),
445        "CODEC": lambda self: self._parse_compress(),
446        "ASSUME": lambda self: self._parse_assume_constraint(),
447    }
448
449    ALTER_PARSERS = {
450        **parser.Parser.ALTER_PARSERS,
451        "MODIFY": lambda self: self._parse_alter_table_modify(),
452        "REPLACE": lambda self: self._parse_alter_table_replace(),
453    }
454
455    SCHEMA_UNNAMED_CONSTRAINTS = {
456        *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
457        "INDEX",
458    } - {"CHECK"}
459
460    PLACEHOLDER_PARSERS = {
461        **parser.Parser.PLACEHOLDER_PARSERS,
462        TokenType.L_BRACE: lambda self: self._parse_query_parameter(),
463    }
464
465    STATEMENT_PARSERS = {
466        **parser.Parser.STATEMENT_PARSERS,
467        TokenType.DETACH: lambda self: self._parse_detach(),
468    }
469
470    def _parse_wrapped_select_or_assignment(self) -> exp.Expr | None:
471        return self._parse_wrapped(
472            lambda: self._parse_select() or self._parse_assignment(), optional=True
473        )
474
475    def _parse_check_constraint(self) -> exp.CheckColumnConstraint | None:
476        return self.expression(
477            exp.CheckColumnConstraint(this=self._parse_wrapped_select_or_assignment())
478        )
479
480    def _parse_assume_constraint(self) -> exp.AssumeColumnConstraint | None:
481        return self.expression(
482            exp.AssumeColumnConstraint(this=self._parse_wrapped_select_or_assignment())
483        )
484
485    def _parse_engine_property(self) -> exp.EngineProperty:
486        self._match(TokenType.EQ)
487        return self.expression(
488            exp.EngineProperty(this=self._parse_field(any_token=True, anonymous_func=True))
489        )
490
491    # https://clickhouse.com/docs/en/sql-reference/statements/create/function
492    def _parse_user_defined_function_expression(self) -> exp.Expr | None:
493        return self._parse_lambda()
494
495    def _parse_types(
496        self,
497        check_func: bool = False,
498        schema: bool = False,
499        allow_identifiers: bool = True,
500        with_collation: bool = False,
501    ) -> exp.Expr | None:
502        dtype = super()._parse_types(
503            check_func=check_func,
504            schema=schema,
505            allow_identifiers=allow_identifiers,
506            with_collation=with_collation,
507        )
508        if isinstance(dtype, exp.DataType) and dtype.args.get("nullable") is not True:
509            # Mark every type as non-nullable which is ClickHouse's default, unless it's
510            # already marked as nullable. This marker helps us transpile types from other
511            # dialects to ClickHouse, so that we can e.g. produce `CAST(x AS Nullable(String))`
512            # from `CAST(x AS TEXT)`. If there is a `NULL` value in `x`, the former would
513            # fail in ClickHouse without the `Nullable` type constructor.
514            dtype.set("nullable", False)
515
516        return dtype
517
518    def _parse_extract(self) -> exp.Extract | exp.Anonymous:
519        index = self._index
520        this = self._parse_bitwise()
521        if self._match(TokenType.FROM):
522            self._retreat(index)
523            return super()._parse_extract()
524
525        # We return Anonymous here because extract and regexpExtract have different semantics,
526        # so parsing extract(foo, bar) into RegexpExtract can potentially break queries. E.g.,
527        # `extract('foobar', 'b')` works, but ClickHouse crashes for `regexpExtract('foobar', 'b')`.
528        #
529        # TODO: can we somehow convert the former into an equivalent `regexpExtract` call?
530        self._match(TokenType.COMMA)
531        return self.expression(
532            exp.Anonymous(this="extract", expressions=[this, self._parse_bitwise()])
533        )
534
535    def _parse_assignment(self) -> exp.Expr | None:
536        this = super()._parse_assignment()
537
538        if self._match(TokenType.PLACEHOLDER):
539            return self.expression(
540                exp.If(
541                    this=this,
542                    true=self._parse_assignment(),
543                    false=self._match(TokenType.COLON) and self._parse_assignment(),
544                )
545            )
546
547        return this
548
549    def _parse_query_parameter(self) -> exp.Expr | None:
550        """
551        Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
552        https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
553        """
554        index = self._index
555
556        this = self._parse_id_var()
557        self._match(TokenType.COLON)
558        kind = self._parse_types(check_func=False, allow_identifiers=False) or (
559            self._match_text_seq("IDENTIFIER") and "Identifier"
560        )
561
562        if not kind:
563            self._retreat(index)
564            return None
565        elif not self._match(TokenType.R_BRACE):
566            self.raise_error("Expecting }")
567
568        if isinstance(this, exp.Identifier) and not this.quoted:
569            this = exp.var(this.name)
570
571        return self.expression(exp.Placeholder(this=this, kind=kind))
572
573    def _parse_bracket(self, this: exp.Expr | None = None) -> exp.Expr | None:
574        if this:
575            bracket_json_type = None
576
577            while self._match_pair(TokenType.L_BRACKET, TokenType.R_BRACKET):
578                bracket_json_type = exp.DataType(
579                    this=exp.DType.ARRAY,
580                    expressions=[
581                        bracket_json_type
582                        or exp.DType.JSON.into_expr(dialect=self.dialect, nullable=False)
583                    ],
584                    nested=True,
585                )
586
587            if bracket_json_type:
588                return self.expression(exp.JSONCast(this=this, to=bracket_json_type))
589
590        l_brace = self._match(TokenType.L_BRACE, advance=False)
591        bracket = super()._parse_bracket(this)
592
593        if l_brace and isinstance(bracket, exp.Struct):
594            varmap = exp.VarMap(keys=exp.Array(), values=exp.Array())
595            for expression in bracket.expressions:
596                if not isinstance(expression, exp.PropertyEQ):
597                    break
598
599                varmap.args["keys"].append("expressions", exp.Literal.string(expression.name))
600                varmap.args["values"].append("expressions", expression.expression)
601
602            return varmap
603
604        return bracket
605
606    def _parse_global_in(self, this: exp.Expr | None) -> exp.Not | exp.In:
607        is_negated = self._match(TokenType.NOT)
608        in_expr: exp.In | None = None
609        if self._match(TokenType.IN):
610            in_expr = self._parse_in(this)
611            in_expr.set("is_global", True)
612        return self.expression(exp.Not(this=in_expr)) if is_negated else t.cast(exp.In, in_expr)
613
614    def _parse_table(
615        self,
616        schema: bool = False,
617        joins: bool = False,
618        alias_tokens: Collection[TokenType] | None = None,
619        parse_bracket: bool = False,
620        is_db_reference: bool = False,
621        parse_partition: bool = False,
622        consume_pipe: bool = False,
623    ) -> exp.Expr | None:
624        this = super()._parse_table(
625            schema=schema,
626            joins=joins,
627            alias_tokens=alias_tokens,
628            parse_bracket=parse_bracket,
629            is_db_reference=is_db_reference,
630        )
631
632        if isinstance(this, exp.Table):
633            inner = this.this
634            alias = this.args.get("alias")
635
636            if isinstance(inner, exp.GenerateSeries) and alias and not alias.columns:
637                alias.set("columns", [exp.to_identifier("generate_series")])
638
639        if self._match(TokenType.FINAL):
640            this = self.expression(exp.Final(this=this))
641
642        return this
643
644    def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
645        return super()._parse_position(haystack_first=True)
646
647    # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
648    def _parse_cte(self) -> exp.CTE | None:
649        # WITH <identifier> AS <subquery expression>
650        cte: exp.CTE | None = self._try_parse(super()._parse_cte)
651
652        if not cte:
653            # WITH <expression> AS <identifier>
654            cte = self.expression(
655                exp.CTE(this=self._parse_assignment(), alias=self._parse_table_alias(), scalar=True)
656            )
657
658        return cte
659
660    def _parse_join_parts(
661        self,
662    ) -> tuple[Token | None, Token | None, Token | None]:
663        is_global = self._prev if self._match(TokenType.GLOBAL) else None
664
665        kind_pre = self._prev if self._match_set(self.JOIN_KINDS) else None
666        side = self._prev if self._match_set(self.JOIN_SIDES) else None
667        kind = self._prev if self._match_set(self.JOIN_KINDS) else None
668
669        return is_global, side or kind, kind_pre or kind
670
671    def _parse_join(
672        self,
673        skip_join_token: bool = False,
674        parse_bracket: bool = False,
675        alias_tokens: t.Collection[TokenType] | None = None,
676    ) -> exp.Join | None:
677        join = super()._parse_join(
678            skip_join_token=skip_join_token, parse_bracket=True, alias_tokens=alias_tokens
679        )
680        if join:
681            method = join.args.get("method")
682            join.set("method", None)
683            join.set("global_", method)
684
685            # tbl ARRAY JOIN arr <-- this should be a `Column` reference, not a `Table`
686            # https://clickhouse.com/docs/en/sql-reference/statements/select/array-join
687            if join.kind == "ARRAY":
688                for table in join.find_all(exp.Table):
689                    table.replace(table.to_column())
690
691        return join
692
693    def _parse_function(
694        self,
695        functions: dict[str, t.Callable] | None = None,
696        anonymous: bool = False,
697        optional_parens: bool = True,
698        any_token: bool = False,
699    ) -> exp.Expr | None:
700        expr = super()._parse_function(
701            functions=functions,
702            anonymous=anonymous,
703            optional_parens=optional_parens,
704            any_token=any_token,
705        )
706
707        func = expr.this if isinstance(expr, exp.Window) else expr
708
709        # Aggregate functions can be split in 2 parts: <func_name><suffix[es]>
710        parts = self._resolve_clickhouse_agg(func.this) if isinstance(func, exp.Anonymous) else None
711
712        if parts:
713            anon_func: exp.Anonymous = t.cast(exp.Anonymous, func)
714            params = self._parse_func_params(anon_func)
715
716            if len(parts[1]) > 0:
717                exp_class: Type[exp.Expr] = (
718                    exp.CombinedParameterizedAgg if params else exp.CombinedAggFunc
719                )
720            else:
721                exp_class = exp.ParameterizedAgg if params else exp.AnonymousAggFunc
722
723            instance = exp_class(this=anon_func.this, expressions=anon_func.expressions)
724            if params:
725                instance.set("params", params)
726            func = self.expression(instance)
727
728            if isinstance(expr, exp.Window):
729                # The window's func was parsed as Anonymous in base parser, fix its
730                # type to be ClickHouse style CombinedAnonymousAggFunc / AnonymousAggFunc
731                expr.set("this", func)
732            elif params:
733                # Params have blocked super()._parse_function() from parsing the following window
734                # (if that exists) as they're standing between the function call and the window spec
735                expr = self._parse_window(func)
736            else:
737                expr = func
738
739        return expr
740
741    def _parse_func_params(self, this: exp.Func | None = None) -> list[exp.Expr] | None:
742        if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
743            return self._parse_csv(self._parse_lambda)
744
745        if self._match(TokenType.L_PAREN):
746            params = self._parse_csv(self._parse_lambda)
747            self._match_r_paren(this)
748            return params
749
750        return None
751
752    def _parse_group_concat(self) -> exp.GroupConcat:
753        args = self._parse_csv(self._parse_lambda)
754        params = self._parse_func_params()
755
756        if params:
757            # groupConcat(sep [, limit])(expr)
758            separator = seq_get(args, 0)
759            limit = seq_get(args, 1)
760            this: exp.Expr | None = seq_get(params, 0)
761            if limit is not None:
762                this = exp.Limit(this=this, expression=limit)
763            return self.expression(exp.GroupConcat(this=this, separator=separator))
764
765        # groupConcat(expr)
766        return self.expression(exp.GroupConcat(this=seq_get(args, 0)))
767
768    def _parse_quantile(self) -> exp.Quantile:
769        this = self._parse_lambda()
770        params = self._parse_func_params()
771        if params:
772            return self.expression(exp.Quantile(this=params[0], quantile=this))
773        return self.expression(exp.Quantile(this=this, quantile=exp.Literal.number(0.5)))
774
775    def _parse_wrapped_id_vars(self, optional: bool = False) -> list[exp.Expr]:
776        return super()._parse_wrapped_id_vars(optional=True)
777
778    def _parse_column_def(
779        self, this: exp.Expr | None, computed_column: bool = True
780    ) -> exp.Expr | None:
781        if self._match(TokenType.DOT):
782            return exp.Dot(this=this, expression=self._parse_id_var())
783
784        return super()._parse_column_def(this, computed_column=computed_column)
785
786    def _parse_primary_key(
787        self,
788        wrapped_optional: bool = False,
789        in_props: bool = False,
790        named_primary_key: bool = False,
791    ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
792        return super()._parse_primary_key(
793            wrapped_optional=wrapped_optional or in_props,
794            in_props=in_props,
795            named_primary_key=named_primary_key,
796        )
797
798    def _parse_on_property(self) -> exp.Expr | None:
799        index = self._index
800        if self._match_text_seq("CLUSTER"):
801            this = self._parse_string() or self._parse_id_var()
802            if this:
803                return self.expression(exp.OnCluster(this=this))
804            else:
805                self._retreat(index)
806        return None
807
808    def _parse_index_constraint(self, kind: str | None = None) -> exp.IndexColumnConstraint:
809        # INDEX name1 expr TYPE type1(args) GRANULARITY value
810        this = self._parse_id_var()
811        expression = self._parse_assignment()
812
813        index_type = self._match_text_seq("TYPE") and (self._parse_function() or self._parse_var())
814
815        granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
816
817        return self.expression(
818            exp.IndexColumnConstraint(
819                this=this, expression=expression, index_type=index_type, granularity=granularity
820            )
821        )
822
823    def _parse_partition(self) -> exp.Partition | None:
824        # https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#how-to-set-partition-expression
825        if not self._match(TokenType.PARTITION):
826            return None
827
828        if self._match_text_seq("ID"):
829            # Corresponds to the PARTITION ID <string_value> syntax
830            expressions: list[exp.Expr] = [
831                self.expression(exp.PartitionId(this=self._parse_string()))
832            ]
833        else:
834            expressions = self._parse_expressions()
835
836        return self.expression(exp.Partition(expressions=expressions))
837
838    def _parse_alter_table_replace(self) -> exp.Expr | None:
839        partition = self._parse_partition()
840
841        if not partition or not self._match(TokenType.FROM):
842            return None
843
844        return self.expression(
845            exp.ReplacePartition(expression=partition, source=self._parse_table_parts())
846        )
847
848    def _parse_alter_table_modify(self) -> exp.Expr | None:
849        if properties := self._parse_properties():
850            return self.expression(exp.AlterModifySqlSecurity(expressions=properties.expressions))
851        return None
852
853    def _parse_definer(self) -> exp.DefinerProperty | None:
854        self._match(TokenType.EQ)
855        if self._match(TokenType.CURRENT_USER):
856            return exp.DefinerProperty(this=exp.Var(this=self._prev.text.upper()))
857        return exp.DefinerProperty(this=self._parse_string())
858
859    def _parse_projection_def(self) -> exp.ProjectionDef | None:
860        if not self._match_text_seq("PROJECTION"):
861            return None
862
863        return self.expression(
864            exp.ProjectionDef(
865                this=self._parse_id_var(), expression=self._parse_wrapped(self._parse_statement)
866            )
867        )
868
869    def _parse_constraint(self) -> exp.Expr | None:
870        return super()._parse_constraint() or self._parse_projection_def()
871
872    def _parse_alias(self, this: exp.Expr | None, explicit: bool = False) -> exp.Expr | None:
873        # In clickhouse "SELECT <expr> APPLY(...)" is a query modifier,
874        # so "APPLY" shouldn't be parsed as <expr>'s alias. However, "SELECT <expr> apply" is a valid alias
875        if self._match_pair(TokenType.APPLY, TokenType.L_PAREN, advance=False):
876            return this
877
878        return super()._parse_alias(this=this, explicit=explicit)
879
880    def _parse_expression(self) -> exp.Expr | None:
881        this = super()._parse_expression()
882
883        # Clickhouse allows "SELECT <expr> [APPLY(func)] [...]]" modifier
884        while self._match_pair(TokenType.APPLY, TokenType.L_PAREN):
885            this = exp.Apply(this=this, expression=self._parse_var(any_token=True))
886            self._match(TokenType.R_PAREN)
887
888        return this
889
890    def _parse_columns(self) -> exp.Expr:
891        this: exp.Expr = self.expression(exp.Columns(this=self._parse_lambda()))
892
893        while self._next and self._match_text_seq(")", "APPLY", "("):
894            self._match(TokenType.R_PAREN)
895            this = exp.Apply(this=this, expression=self._parse_var(any_token=True))
896        return this
897
898    def _parse_value(self, values: bool = True) -> exp.Tuple | None:
899        value = super()._parse_value(values=values)
900        if not value:
901            return None
902
903        # In Clickhouse "SELECT * FROM VALUES (1, 2, 3)" generates a table with a single column, in contrast
904        # to other dialects. For this case, we canonicalize the values into a tuple-of-tuples AST if it's not already one.
905        # In INSERT INTO statements the same clause actually references multiple columns (opposite semantics),
906        # but the final result is not altered by the extra parentheses.
907        # Note: Clickhouse allows VALUES([structure], value, ...) so the branch checks for the last expression
908        expressions = value.expressions
909        if values and not isinstance(expressions[-1], exp.Tuple):
910            value.set(
911                "expressions",
912                [self.expression(exp.Tuple(expressions=[expr])) for expr in expressions],
913            )
914
915        return value
916
917    def _parse_partitioned_by(self) -> exp.PartitionedByProperty:
918        # ClickHouse allows custom expressions as partition key
919        # https://clickhouse.com/docs/engines/table-engines/mergetree-family/custom-partitioning-key
920        return self.expression(exp.PartitionedByProperty(this=self._parse_assignment()))
921
922    def _parse_detach(self) -> exp.Detach:
923        kind = self._match_set(self.DB_CREATABLES) and self._prev.text.upper()
924        exists = self._parse_exists()
925        this = self._parse_table_parts()
926
927        return self.expression(
928            exp.Detach(
929                this=this,
930                kind=kind,
931                exists=exists,
932                cluster=self._parse_on_property() if self._match(TokenType.ON) else None,
933                permanent=self._match_text_seq("PERMANENTLY"),
934                sync=self._match_text_seq("SYNC"),
935            )
936        )

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

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

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

sqlglot.parsers.clickhouse

Arguments:

Inherited Members