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

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

class ClickHouseParser(sqlglot.parser.Parser): View Source

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

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

Arguments:

error_level: The desired error level. Default: ErrorLevel.IMMEDIATE
error_message_context: The amount of context to capture from a query string when displaying the error message (in number of characters). Default: 100
max_errors: Maximum number of error messages to include in a raised ParseError. This is only relevant if error_level is ErrorLevel.RAISE. Default: 3
max_nodes: Maximum number of AST nodes to prevent memory exhaustion. Set to -1 (default) to disable the check.

MODIFIERS_ATTACHED_TO_SET_OP = False

INTERVAL_SPANS = False

OPTIONAL_ALIAS_TOKEN_CTE = False

JOINS_HAVE_EQUAL_PRECEDENCE = True

FUNCTIONS = {'AI_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.AIAgg'>>, 'AI_CLASSIFY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIClassify'>>, 'AI_EMBED': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIEmbed'>>, 'A_I_FORECAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIForecast'>>, 'AI_GENERATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AIGenerate'>>, 'AI_SIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.AISimilarity'>>, 'AI_SUMMARIZE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.AISummarizeAgg'>>, 'ABS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Abs'>>, 'ACOS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Acos'>>, 'ACOSH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Acosh'>>, 'ADD_MONTHS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.AddMonths'>>, 'AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.And'>>, 'ANONYMOUS_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.AnonymousAggFunc'>>, 'ANY_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.AnyValue'>>, 'APPLY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Apply'>>, 'APPROX_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.ApproxDistinct'>>, 'APPROX_COUNT_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.ApproxDistinct'>>, 'APPROX_PERCENTILE_ACCUMULATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxPercentileAccumulate'>>, 'APPROX_PERCENTILE_COMBINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxPercentileCombine'>>, 'APPROX_PERCENTILE_ESTIMATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxPercentileEstimate'>>, 'APPROX_QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxQuantile'>>, 'APPROX_QUANTILES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxQuantiles'>>, 'APPROX_TOP_K': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopK'>>, 'APPROX_TOP_K_ACCUMULATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopKAccumulate'>>, 'APPROX_TOP_K_COMBINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopKCombine'>>, 'APPROX_TOP_K_ESTIMATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproxTopKEstimate'>>, 'APPROXIMATE_SIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproximateSimilarity'>>, 'APPROXIMATE_JACCARD_INDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ApproximateSimilarity'>>, 'ARG_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMax'>>, 'ARGMAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMax'>>, 'MAX_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMax'>>, 'ARG_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMin'>>, 'ARGMIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMin'>>, 'MIN_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArgMin'>>, 'ARRAY': <function Parser.<lambda>>, 'ARRAY_AGG': <function Parser.<lambda>>, 'ARRAY_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayAll'>>, 'ARRAY_ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayAny'>>, 'ARRAY_APPEND': <function build_array_append>, 'ARRAY_COMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayCompact'>>, 'ARRAY_CONCAT': <function build_array_concat>, 'ARRAY_CAT': <function build_array_concat>, 'ARRAY_CONCAT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArrayConcatAgg'>>, 'ARRAY_CONSTRUCT_COMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayConstructCompact'>>, 'ARRAY_CONTAINED_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContainedBy'>>, 'ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContains'>>, 'ARRAY_HAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContains'>>, 'ARRAY_CONTAINS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContainsAll'>>, 'ARRAY_HAS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContainsAll'>>, 'ARRAY_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayDistinct'>>, 'ARRAY_EXCEPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayExcept'>>, 'FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayFilter'>>, 'ARRAY_FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayFilter'>>, 'ARRAY_FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayFirst'>>, 'ARRAY_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayInsert'>>, 'ARRAY_INTERSECT': <function Parser.<lambda>>, 'ARRAY_INTERSECTION': <function Parser.<lambda>>, 'ARRAY_LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayLast'>>, 'ARRAY_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayMax'>>, 'ARRAY_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayMin'>>, 'ARRAY_OVERLAPS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayOverlaps'>>, 'ARRAY_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayPosition'>>, 'ARRAY_PREPEND': <function build_array_prepend>, 'ARRAY_REMOVE': <function build_array_remove>, 'ARRAY_REMOVE_AT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayRemoveAt'>>, 'ARRAY_REVERSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayReverse'>>, 'ARRAY_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySize'>>, 'ARRAY_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySize'>>, 'ARRAY_SLICE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySlice'>>, 'ARRAY_SORT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySort'>>, 'ARRAY_SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySum'>>, 'ARRAY_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayToString'>>, 'ARRAY_JOIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayToString'>>, 'ARRAY_UNION_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArrayUnionAgg'>>, 'ARRAY_UNIQUE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ArrayUniqueAgg'>>, 'ARRAYS_ZIP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraysZip'>>, 'ASCII': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Ascii'>>, 'ASIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Asin'>>, 'ASINH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Asinh'>>, 'ATAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Atan'>>, 'ATAN2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Atan2'>>, 'ATANH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Atanh'>>, 'AVG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Avg'>>, 'BASE64_DECODE_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Base64DecodeBinary'>>, 'BASE64_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Base64DecodeString'>>, 'BASE64_ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Base64Encode'>>, 'BIT_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.BitLength'>>, 'BITMAP_BIT_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapBitPosition'>>, 'BITMAP_BUCKET_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapBucketNumber'>>, 'BITMAP_CONSTRUCT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapConstructAgg'>>, 'BITMAP_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapCount'>>, 'BITMAP_OR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitmapOrAgg'>>, 'BITWISE_AND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseAndAgg'>>, 'BITWISE_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseCount'>>, 'BITWISE_OR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseOrAgg'>>, 'BITWISE_XOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BitwiseXorAgg'>>, 'BOOLAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Booland'>>, 'BOOLNOT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Boolnot'>>, 'BOOLOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Boolor'>>, 'BOOLXOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.BoolxorAgg'>>, 'BYTE_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ByteLength'>>, 'CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Case'>>, 'CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Cast'>>, 'CAST_TO_STR_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CastToStrType'>>, 'CBRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cbrt'>>, 'CEIL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Ceil'>>, 'CEILING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Ceil'>>, 'CHECK_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.CheckJson'>>, 'CHECK_XML': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CheckXml'>>, 'CHR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Chr'>>, 'CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Chr'>>, 'CITY_HASH64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.CityHash64'>>, 'COALESCE': <function build_coalesce>, 'IFNULL': <function build_coalesce>, 'NVL': <function build_coalesce>, 'CODE_POINTS_TO_BYTES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.CodePointsToBytes'>>, 'CODE_POINTS_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.CodePointsToString'>>, 'COLLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Collate'>>, 'COLLATION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Collation'>>, 'COLUMNS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Columns'>>, 'COMBINED_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.CombinedAggFunc'>>, 'COMBINED_PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.CombinedParameterizedAgg'>>, 'COMPRESS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Compress'>>, 'CONCAT': <function Parser.<lambda>>, 'CONCAT_WS': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ConnectByRoot'>>, 'CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Contains'>>, 'CONVERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Convert'>>, 'CONVERT_TIMEZONE': <function build_convert_timezone>, 'CONVERT_TO_CHARSET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ConvertToCharset'>>, 'CORR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Corr'>>, 'COS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cos'>>, 'COSH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cosh'>>, 'COSINE_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.CosineDistance'>>, 'COT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Cot'>>, 'COTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Coth'>>, 'COUNT': <function Parser.<lambda>>, 'COUNT_IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CountIf'>>, 'COUNTIF': <function _build_count_if>, 'COVAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CovarPop'>>, 'COVAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CovarSamp'>>, 'CSC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Csc'>>, 'CSCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Csch'>>, 'CUME_DIST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.CumeDist'>>, 'CURRENT_ACCOUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentAccount'>>, 'CURRENT_ACCOUNT_NAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentAccountName'>>, 'CURRENT_AVAILABLE_ROLES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentAvailableRoles'>>, 'CURRENT_CATALOG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentCatalog'>>, 'CURRENT_CLIENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentClient'>>, 'CURRENT_DATABASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentDatabase'>>, 'CURRENT_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentDate'>>, 'CURRENT_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentDatetime'>>, 'CURRENT_IP_ADDRESS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentIpAddress'>>, 'CURRENT_ORGANIZATION_NAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentOrganizationName'>>, 'CURRENT_ORGANIZATION_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentOrganizationUser'>>, 'CURRENT_REGION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentRegion'>>, 'CURRENT_ROLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentRole'>>, 'CURRENT_ROLE_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentRoleType'>>, 'CURRENT_SCHEMA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSchema'>>, 'CURRENT_SCHEMAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSchemas'>>, 'CURRENT_SECONDARY_ROLES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSecondaryRoles'>>, 'CURRENT_SESSION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSession'>>, 'CURRENT_STATEMENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentStatement'>>, 'CURRENT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTime'>>, 'CURRENT_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTimestamp'>>, 'CURRENT_TIMESTAMP_L_T_Z': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTimestampLTZ'>>, 'CURRENT_TIMEZONE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.CurrentTimezone'>>, 'CURRENT_TRANSACTION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentTransaction'>>, 'CURRENT_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentUser'>>, 'CURRENT_USER_ID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentUserId'>>, 'CURRENT_VERSION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentVersion'>>, 'CURRENT_WAREHOUSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentWarehouse'>>, 'DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Date'>>, 'DATE_ADD': <function build_date_delta.<locals>._builder>, 'DATE_BIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateBin'>>, 'DATEDIFF': <function build_date_delta.<locals>._builder>, 'DATE_DIFF': <function build_date_delta.<locals>._builder>, 'DATE_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateFromParts'>>, 'DATEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateFromParts'>>, 'DATE_FROM_UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateFromUnixDate'>>, 'DATE_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateStrToDate'>>, 'DATE_SUB': <function build_date_delta.<locals>._builder>, 'DATE_TO_DATE_STR': <function Parser.<lambda>>, 'DATE_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateToDi'>>, 'DATE_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateTrunc'>>, 'DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Datetime'>>, 'DATETIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeAdd'>>, 'DATETIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeDiff'>>, 'DATETIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeSub'>>, 'DATETIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DatetimeTrunc'>>, 'DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Day'>>, 'DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfMonth'>>, 'DAYOFMONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfMonth'>>, 'DAY_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeek'>>, 'DAYOFWEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeek'>>, 'DAYOFWEEK_ISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeekIso'>>, 'ISODOW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfWeekIso'>>, 'DAY_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfYear'>>, 'DAYOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DayOfYear'>>, 'DAYNAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Dayname'>>, 'DECODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Decode'>>, 'DECODE_CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.DecodeCase'>>, 'DECOMPRESS_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.DecompressBinary'>>, 'DECOMPRESS_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.DecompressString'>>, 'DECRYPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Decrypt'>>, 'DECRYPT_RAW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.DecryptRaw'>>, 'DEGREES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Degrees'>>, 'DENSE_RANK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.DenseRank'>>, 'DI_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DiToDate'>>, 'DOT_PRODUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.DotProduct'>>, 'DYNAMIC_IDENTIFIER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.DynamicIdentifier'>>, 'ELT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Elt'>>, 'ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Encode'>>, 'ENCRYPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Encrypt'>>, 'ENCRYPT_RAW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.EncryptRaw'>>, 'ENDS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.EndsWith'>>, 'ENDSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.EndsWith'>>, 'EQUAL_NULL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.EqualNull'>>, 'EUCLIDEAN_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.EuclideanDistance'>>, 'EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Exists'>>, 'EXP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Exp'>>, 'EXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Explode'>>, 'EXPLODING_GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ExplodingGenerateSeries'>>, 'EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Extract'>>, 'FACTORIAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Factorial'>>, 'FARM_FINGERPRINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FarmFingerprint'>>, 'FARMFINGERPRINT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FarmFingerprint'>>, 'FEATURES_AT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.FeaturesAtTime'>>, 'FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.First'>>, 'FIRST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.FirstValue'>>, 'FLATTEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Flatten'>>, 'FLOAT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Float64'>>, 'FLOOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Floor'>>, 'FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Format'>>, 'FROM_BASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FromBase'>>, 'FROM_BASE32': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FromBase32'>>, 'FROM_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.FromBase64'>>, 'FROM_ISO8601_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.FromISO8601Date'>>, 'FROM_ISO8601_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.FromISO8601Timestamp'>>, 'FROM_ISO8601_TIMESTAMP_NANOS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.FromISO8601TimestampNanos'>>, 'GAP_FILL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.GapFill'>>, 'GENERATE_BOOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateBool'>>, 'GENERATE_DATE_ARRAY': <function Parser.<lambda>>, 'GENERATE_DOUBLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateDouble'>>, 'GENERATE_EMBEDDING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateEmbedding'>>, 'GENERATE_INT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateInt'>>, 'GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.GenerateSeries'>>, 'GENERATE_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateTable'>>, 'GENERATE_TEXT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GenerateText'>>, 'GENERATE_TIMESTAMP_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.GenerateTimestampArray'>>, 'GENERATOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Generator'>>, 'GET_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.GetExtract'>>, 'GET_IGNORE_CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.GetIgnoreCase'>>, 'GETBIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Getbit'>>, 'GET_BIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Getbit'>>, 'GREATEST': <function Parser.<lambda>>, 'GROUP_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.GroupConcat'>>, 'GROUPING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Grouping'>>, 'GROUPING_ID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.GroupingId'>>, 'HASH_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.HashAgg'>>, 'HEX': <function build_hex>, 'HEX_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.HexDecodeString'>>, 'HLL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Hll'>>, 'HOST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Host'>>, 'HOUR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Hour'>>, 'IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.If'>>, 'IIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.If'>>, 'INITCAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Initcap'>>, 'INLINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Inline'>>, 'INT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Int64'>>, 'IS_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.IsArray'>>, 'IS_ASCII': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.IsAscii'>>, 'IS_INF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsInf'>>, 'ISINF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsInf'>>, 'IS_NAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsNan'>>, 'ISNAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.IsNan'>>, 'IS_NULL_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.IsNullValue'>>, 'J_S_O_N_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArray'>>, 'J_S_O_N_ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayAgg'>>, 'JSON_ARRAY_APPEND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayAppend'>>, 'JSON_ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayContains'>>, 'JSON_ARRAY_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONArrayInsert'>>, 'JSONB_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBContains'>>, 'J_S_O_N_B_CONTAINS_ALL_TOP_KEYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBContainsAllTopKeys'>>, 'J_S_O_N_B_CONTAINS_ANY_TOP_KEYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBContainsAnyTopKeys'>>, 'J_S_O_N_B_DELETE_AT_PATH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBDeleteAtPath'>>, 'JSONB_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBExists'>>, 'JSONB_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBExtract'>>, 'JSONB_EXTRACT_SCALAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBExtractScalar'>>, 'J_S_O_N_B_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBObjectAgg'>>, 'J_S_O_N_B_PATH_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBPathExists'>>, 'J_S_O_N_BOOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONBool'>>, 'J_S_O_N_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.JSONCast'>>, 'J_S_O_N_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONExists'>>, 'JSON_EXTRACT': <function build_extract_json_with_path.<locals>._builder>, 'JSON_EXTRACT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONExtractArray'>>, 'JSON_EXTRACT_SCALAR': <function build_extract_json_with_path.<locals>._builder>, 'JSON_FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONFormat'>>, 'JSON_KEYS': <function Parser.<lambda>>, 'J_S_O_N_KEYS_AT_DEPTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONKeysAtDepth'>>, 'J_S_O_N_OBJECT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONObject'>>, 'J_S_O_N_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONObjectAgg'>>, 'JSON_REMOVE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONRemove'>>, 'JSON_SET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONSet'>>, 'JSON_STRIP_NULLS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONStripNulls'>>, 'J_S_O_N_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONTable'>>, 'JSON_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.JSONType'>>, 'J_S_O_N_VALUE_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.query.JSONValueArray'>>, 'JAROWINKLER_SIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.JarowinklerSimilarity'>>, 'JUSTIFY_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.JustifyDays'>>, 'JUSTIFY_HOURS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.JustifyHours'>>, 'JUSTIFY_INTERVAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.JustifyInterval'>>, 'KURTOSIS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Kurtosis'>>, 'LAG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Lag'>>, 'LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Last'>>, 'LAST_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.LastDay'>>, 'LAST_DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.LastDay'>>, 'LAST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LastValue'>>, 'LAX_BOOL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxBool'>>, 'LAX_FLOAT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxFloat64'>>, 'LAX_INT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxInt64'>>, 'LAX_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.LaxString'>>, 'LEAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Lead'>>, 'LEAST': <function Parser.<lambda>>, 'LEFT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Left'>>, 'LENGTH': <function ClickHouseParser.<lambda>>, 'LEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Length'>>, 'CHAR_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Length'>>, 'CHARACTER_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Length'>>, 'LEVENSHTEIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Levenshtein'>>, 'LIST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.List'>>, 'LN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Ln'>>, 'LOCALTIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Localtime'>>, 'LOCALTIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Localtimestamp'>>, 'LOG': <function build_logarithm>, 'LOGICAL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalAnd'>>, 'BOOL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalAnd'>>, 'BOOLAND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalAnd'>>, 'LOGICAL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalOr'>>, 'BOOL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalOr'>>, 'BOOLOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.LogicalOr'>>, 'LOWER': <function build_lower>, 'LCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Lower'>>, 'LOWER_HEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.LowerHex'>>, 'MD5': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5Digest'>>, 'MD5_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5Digest'>>, 'M_D5_NUMBER_LOWER64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5NumberLower64'>>, 'M_D5_NUMBER_UPPER64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MD5NumberUpper64'>>, 'M_L_FORECAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.MLForecast'>>, 'M_L_TRANSLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.MLTranslate'>>, 'MAKE_INTERVAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.MakeInterval'>>, 'MANHATTAN_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.ManhattanDistance'>>, 'MAP': <function build_var_map>, 'MAP_CAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapCat'>>, 'MAP_CONTAINS_KEY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapContainsKey'>>, 'MAP_DELETE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapDelete'>>, 'MAP_FROM_ENTRIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapFromEntries'>>, 'MAP_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapInsert'>>, 'MAP_KEYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapKeys'>>, 'MAP_PICK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapPick'>>, 'MAP_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.MapSize'>>, 'MATCH_AGAINST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.MatchAgainst'>>, 'MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Max'>>, 'MEDIAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Median'>>, 'MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Min'>>, 'MINHASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Minhash'>>, 'MINHASH_COMBINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.MinhashCombine'>>, 'MINUTE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Minute'>>, 'MODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Mode'>>, 'MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Month'>>, 'MONTHNAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Monthname'>>, 'MONTHS_BETWEEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.MonthsBetween'>>, 'NANVL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Nanvl'>>, 'NEGATIVE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Negative'>>, 'NET_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.NetFunc'>>, 'NEXT_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.NextDay'>>, 'NEXT_VALUE_FOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ddl.NextValueFor'>>, 'NORMAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Normal'>>, 'NORMALIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Normalize'>>, 'NTH_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.NthValue'>>, 'NTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Ntile'>>, 'NULLIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Nullif'>>, 'NUMBER_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.NumberToStr'>>, 'NVL2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Nvl2'>>, 'OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.ObjectAgg'>>, 'OBJECT_ID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ObjectId'>>, 'OBJECT_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ObjectInsert'>>, 'OBJECT_TRANSFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ObjectTransform'>>, 'OPEN_J_S_O_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.OpenJSON'>>, 'OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Or'>>, 'OVERLAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Overlay'>>, 'PAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Pad'>>, 'PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.ParameterizedAgg'>>, 'PARSE_BIGNUMERIC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ParseBignumeric'>>, 'PARSE_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.ParseDatetime'>>, 'PARSE_IP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ParseIp'>>, 'PARSE_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ParseJSON'>>, 'JSON_PARSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.ParseJSON'>>, 'PARSE_NUMERIC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ParseNumeric'>>, 'PARSE_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.ParseTime'>>, 'PARSE_URL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ParseUrl'>>, 'PERCENT_RANK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.PercentRank'>>, 'PERCENTILE_CONT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.PercentileCont'>>, 'PERCENTILE_DISC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.PercentileDisc'>>, 'PI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Pi'>>, 'POSEXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Posexplode'>>, 'POSEXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.PosexplodeOuter'>>, 'POWER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Pow'>>, 'POW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Pow'>>, 'PREDICT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Predict'>>, 'PREVIOUS_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.PreviousDay'>>, 'QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Quantile'>>, 'QUARTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Quarter'>>, 'RADIANS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Radians'>>, 'RAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Rand'>>, 'RANDOM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Rand'>>, 'RANDN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Randn'>>, 'RANDSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Randstr'>>, 'RANGE_BUCKET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.RangeBucket'>>, 'RANGE_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.RangeN'>>, 'RANK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Rank'>>, 'READ_CSV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ReadCSV'>>, 'READ_PARQUET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ReadParquet'>>, 'REDUCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Reduce'>>, 'REG_DOMAIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.RegDomain'>>, 'REGEXP_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpCount'>>, 'REGEXP_EXTRACT': <function ClickHouseParser.<dictcomp>.<lambda>>, 'REGEXP_EXTRACT_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpExtractAll'>>, 'REGEXP_FULL_MATCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpFullMatch'>>, 'REGEXP_I_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpILike'>>, 'REGEXP_INSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpInstr'>>, 'REGEXP_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.RegexpLike'>>, 'REGEXP_REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpReplace'>>, 'REGEXP_SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RegexpSplit'>>, 'REGEXP_SUBSTR': <function ClickHouseParser.<dictcomp>.<lambda>>, 'REGR_AVGX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrAvgx'>>, 'REGR_AVGY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrAvgy'>>, 'REGR_COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrCount'>>, 'REGR_INTERCEPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrIntercept'>>, 'REGR_R2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrR2'>>, 'REGR_SLOPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSlope'>>, 'REGR_SXX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSxx'>>, 'REGR_SXY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSxy'>>, 'REGR_SYY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrSyy'>>, 'REGR_VALX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrValx'>>, 'REGR_VALY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RegrValy'>>, 'REPEAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Repeat'>>, 'REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Replace'>>, 'REVERSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Reverse'>>, 'RIGHT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Right'>>, 'RINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Rint'>>, 'ROUND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Round'>>, 'ROW_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.RowNumber'>>, 'RTRIMMED_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.RtrimmedLength'>>, 'SHA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA'>>, 'SHA1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA'>>, 'S_H_A1_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA1Digest'>>, 'SHA2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA2'>>, 'S_H_A2_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SHA2Digest'>>, 'SAFE_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeAdd'>>, 'SAFE_CONVERT_BYTES_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SafeConvertBytesToString'>>, 'SAFE_DIVIDE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeDivide'>>, 'SAFE_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.SafeFunc'>>, 'SAFE_MULTIPLY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeMultiply'>>, 'SAFE_NEGATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeNegate'>>, 'SAFE_SUBTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.SafeSubtract'>>, 'SEARCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Search'>>, 'SEARCH_IP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SearchIp'>>, 'SEC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sec'>>, 'SECH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sech'>>, 'SECOND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Second'>>, 'SECRET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Secret'>>, 'SEQ1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq1'>>, 'SEQ2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq2'>>, 'SEQ4': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq4'>>, 'SEQ8': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Seq8'>>, 'SESSION_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.SessionUser'>>, 'SHUFFLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Shuffle'>>, 'SIGN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sign'>>, 'SIGNUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sign'>>, 'SIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sin'>>, 'SINH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sinh'>>, 'SKEWNESS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Skewness'>>, 'SORT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.SortArray'>>, 'SOUNDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Soundex'>>, 'SOUNDEX_P123': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SoundexP123'>>, 'SPACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Space'>>, 'SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Split'>>, 'SPLIT_PART': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SplitPart'>>, 'SQRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Sqrt'>>, 'ST_DISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StDistance'>>, 'ST_POINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StPoint'>>, 'ST_MAKEPOINT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StPoint'>>, 'STANDARD_HASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StandardHash'>>, 'STAR_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StarMap'>>, 'STARTS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StartsWith'>>, 'STARTSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StartsWith'>>, 'STDDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Stddev'>>, 'STDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Stddev'>>, 'STDDEV_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.StddevPop'>>, 'STDDEV_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.StddevSamp'>>, 'STR_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StrPosition'>>, 'STR_TO_DATE': <function _build_str_to_date>, 'STR_TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StrToMap'>>, 'STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.StrToTime'>>, 'STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.StrToUnix'>>, 'STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.String'>>, 'STRING_TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StringToArray'>>, 'SPLIT_BY_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StringToArray'>>, 'STRIP_NULL_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.json.StripNullValue'>>, 'STRTOK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Strtok'>>, 'STRTOK_TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StrtokToArray'>>, 'STRUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.Struct'>>, 'STRUCT_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.StructExtract'>>, 'STUFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Stuff'>>, 'INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Stuff'>>, 'SUBSTRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Substring'>>, 'SUBSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Substring'>>, 'SUBSTRING_INDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SubstringIndex'>>, 'SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Sum'>>, 'SYSTIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Systimestamp'>>, 'TAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Tan'>>, 'TANH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Tanh'>>, 'TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Time'>>, 'TIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeAdd'>>, 'TIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeDiff'>>, 'TIME_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeFromParts'>>, 'TIMEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeFromParts'>>, 'TIME_SLICE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeSlice'>>, 'TIME_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeStrToDate'>>, 'TIME_STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeStrToTime'>>, 'TIME_STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeStrToUnix'>>, 'TIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeSub'>>, 'TIME_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeToStr'>>, 'TIME_TO_TIME_STR': <function Parser.<lambda>>, 'TIME_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeToUnix'>>, 'TIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimeTrunc'>>, 'TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Timestamp'>>, 'TIMESTAMP_ADD': <function build_date_delta.<locals>._builder>, 'TIMESTAMPDIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampDiff'>>, 'TIMESTAMP_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampDiff'>>, 'TIMESTAMP_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampFromParts'>>, 'TIMESTAMPFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampFromParts'>>, 'TIMESTAMP_LTZ_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampLtzFromParts'>>, 'TIMESTAMPLTZFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampLtzFromParts'>>, 'TIMESTAMP_SUB': <function build_date_delta.<locals>._builder>, 'TIMESTAMP_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampTrunc'>>, 'TIMESTAMP_TZ_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampTzFromParts'>>, 'TIMESTAMPTZFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TimestampTzFromParts'>>, 'TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ToArray'>>, 'TO_BASE32': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToBase32'>>, 'TO_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToBase64'>>, 'TO_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToBinary'>>, 'TO_BOOLEAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ToBoolean'>>, 'TO_CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToChar'>>, 'TO_CODE_POINTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToCodePoints'>>, 'TO_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.ToDays'>>, 'TO_DECFLOAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToDecfloat'>>, 'TO_DOUBLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToDouble'>>, 'TO_FILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToFile'>>, 'TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ToMap'>>, 'TO_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.ToNumber'>>, 'TO_VARIANT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.ToVariant'>>, 'TRANSLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Translate'>>, 'TRIM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Trim'>>, 'TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Trunc'>>, 'TRUNCATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.Trunc'>>, 'TRY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Try'>>, 'TRY_BASE64_DECODE_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryBase64DecodeBinary'>>, 'TRY_BASE64_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryBase64DecodeString'>>, 'TRY_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.TryCast'>>, 'TRY_HEX_DECODE_BINARY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryHexDecodeBinary'>>, 'TRY_HEX_DECODE_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryHexDecodeString'>>, 'TRY_TO_DECFLOAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.TryToDecfloat'>>, 'TS_OR_DI_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDiToDi'>>, 'TS_OR_DS_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsAdd'>>, 'TS_OR_DS_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsDiff'>>, 'TS_OR_DS_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsToDate'>>, 'TS_OR_DS_TO_DATE_STR': <function Parser.<lambda>>, 'TS_OR_DS_TO_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsToDatetime'>>, 'TS_OR_DS_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsToTime'>>, 'TS_OR_DS_TO_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.TsOrDsToTimestamp'>>, 'TYPEOF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Typeof'>>, 'UNHEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Unhex'>>, 'UNICODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Unicode'>>, 'UNIFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Uniform'>>, 'UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixDate'>>, 'UNIX_MICROS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixMicros'>>, 'UNIX_MILLIS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixMillis'>>, 'UNIX_SECONDS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixSeconds'>>, 'UNIX_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixToStr'>>, 'UNIX_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixToTime'>>, 'UNIX_TO_TIME_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UnixToTimeStr'>>, 'UNNEST': <function Parser.<lambda>>, 'UPPER': <function build_upper>, 'UCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Upper'>>, 'UTC_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UtcDate'>>, 'UTC_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UtcTime'>>, 'UTC_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UtcTimestamp'>>, 'UUID': <function Parser.<lambda>>, 'GEN_RANDOM_UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Uuid'>>, 'GENERATE_UUID': <function Parser.<lambda>>, 'UUID_STRING': <function Parser.<lambda>>, 'VAR_MAP': <function build_var_map>, 'VARIANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Variance'>>, 'VARIANCE_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Variance'>>, 'VAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.Variance'>>, 'VARIANCE_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.VariancePop'>>, 'VAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.VariancePop'>>, 'VECTOR_SEARCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.VectorSearch'>>, 'WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Week'>>, 'WEEK_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.WeekOfYear'>>, 'WEEKOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.WeekOfYear'>>, 'WEEK_START': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.WeekStart'>>, 'WIDTH_BUCKET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.WidthBucket'>>, 'XMLELEMENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.XMLElement'>>, 'XMLGET': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.XMLGet'>>, 'X_M_L_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.XMLTable'>>, 'XOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Xor'>>, 'YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.Year'>>, 'YEAR_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeek'>>, 'YEAROFWEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeek'>>, 'YEAR_OF_WEEK_ISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeekIso'>>, 'YEAROFWEEKISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.YearOfWeekIso'>>, 'ZIPF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Zipf'>>, 'EXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array._ExplodeOuter'>>, 'ARRAYAGG': <function Parser.<lambda>>, 'GLOB': <function Parser.<lambda>>, 'JSON_EXTRACT_PATH_TEXT': <function build_extract_json_with_path.<locals>._builder>, 'LIKE': <function build_like.<locals>._builder>, 'LOG2': <function Parser.<lambda>>, 'LOG10': <function Parser.<lambda>>, 'LPAD': <function Parser.<lambda>>, 'LEFTPAD': <function Parser.<lambda>>, 'LTRIM': <function Parser.<lambda>>, 'MOD': <function build_mod>, 'RIGHTPAD': <function Parser.<lambda>>, 'RPAD': <function Parser.<lambda>>, 'RTRIM': <function Parser.<lambda>>, 'SCOPE_RESOLUTION': <function Parser.<lambda>>, 'STRPOS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StrPosition'>>, 'CHARINDEX': <function Parser.<lambda>>, 'INSTR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.StrPosition'>>, 'LOCATE': <function Parser.<lambda>>, 'TO_HEX': <function build_hex>, 'REGEXPEXTRACT': <function ClickHouseParser.<dictcomp>.<lambda>>, 'TOSTARTOFMINUTE': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFMICROSECOND': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFMILLISECOND': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFQUARTER': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFSECOND': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFHOUR': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFDAY': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFMONTH': <function _build_timestamp_trunc.<locals>.<lambda>>, 'TOSTARTOFYEAR': <function _build_timestamp_trunc.<locals>.<lambda>>, 'ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.aggregate.AnyValue'>>, 'ARRAYCOMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayCompact'>>, 'ARRAYCONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayConcat'>>, 'ARRAYDISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayDistinct'>>, 'ARRAYEXCEPT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayExcept'>>, 'ARRAYSUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySum'>>, 'ARRAYMAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayMax'>>, 'ARRAYMIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayMin'>>, 'ARRAYREVERSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayReverse'>>, 'ARRAYSLICE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArraySlice'>>, 'ARRAYFILTER': <function ClickHouseParser.<lambda>>, 'ARRAYMAP': <function ClickHouseParser.<lambda>>, 'CURRENTDATABASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentDatabase'>>, 'CURRENTSCHEMAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentSchemas'>>, 'CITYHASH64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.CityHash64'>>, 'COSINEDISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.CosineDistance'>>, 'VERSION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.CurrentVersion'>>, 'DATEADD': <function build_date_delta.<locals>._builder>, 'DATE_FORMAT': <function _build_datetime_format.<locals>._builder>, 'DATESUB': <function build_date_delta.<locals>._builder>, 'DATETRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.DateTrunc'>>, 'FORMATDATETIME': <function _build_datetime_format.<locals>._builder>, 'HAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.array.ArrayContains'>>, 'ILIKE': <function build_like.<locals>._builder>, 'JSONEXTRACTSTRING': <function build_json_extract_path.<locals>._builder>, 'L2Distance': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.EuclideanDistance'>>, 'MATCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.RegexpLike'>>, 'NOTLIKE': <function build_like.<locals>._builder>, 'PARSEDATETIME': <function _build_datetime_format.<locals>._builder>, 'RANDCANONICAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.functions.Rand'>>, 'TIMESTAMPSUB': <function build_date_delta.<locals>._builder>, 'TIMESTAMPADD': <function build_date_delta.<locals>._builder>, 'TOMONDAY': <function _build_timestamp_trunc.<locals>.<lambda>>, 'UNIQ': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.ApproxDistinct'>>, 'SHA256': <function ClickHouseParser.<lambda>>, 'SHA512': <function ClickHouseParser.<lambda>>, 'SPLITBYCHAR': <function _build_split_by_char>, 'SPLITBYREGEXP': <function _build_split.<locals>.<lambda>>, 'SPLITBYSTRING': <function _build_split.<locals>.<lambda>>, 'SUBSTRINGINDEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.SubstringIndex'>>, 'TOTYPENAME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.core.Typeof'>>, 'EDITDISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Levenshtein'>>, 'JAROWINKLERSIMILARITY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.math.JarowinklerSimilarity'>>, 'LEVENSHTEINDISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.string.Levenshtein'>>, 'UTCTIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.temporal.UtcTimestamp'>>}

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

AGG_FUNCTIONS_SUFFIXES: ClassVar = ['SimpleState', 'MergeState', 'OrDefault', 'Distinct', 'Resample', 'ArrayIf', 'ForEach', 'OrNull', 'ArgMin', 'ArgMax', 'Array', 'State', 'Merge', 'Map', 'If']

FUNC_TOKENS = {<TokenType.AND: 34>, <TokenType.OR: 35>, <TokenType.SESSION_USER: 61>, <TokenType.XOR: 66>, <TokenType.IDENTIFIER: 79>, <TokenType.TABLE: 84>, <TokenType.VAR: 89>, <TokenType.BIT: 97>, <TokenType.BOOLEAN: 98>, <TokenType.TINYINT: 99>, <TokenType.UTINYINT: 100>, <TokenType.SMALLINT: 101>, <TokenType.USMALLINT: 102>, <TokenType.MEDIUMINT: 103>, <TokenType.UMEDIUMINT: 104>, <TokenType.INT: 105>, <TokenType.UINT: 106>, <TokenType.BIGINT: 107>, <TokenType.UBIGINT: 108>, <TokenType.BIGNUM: 109>, <TokenType.INT128: 110>, <TokenType.UINT128: 111>, <TokenType.INT256: 112>, <TokenType.UINT256: 113>, <TokenType.FLOAT: 114>, <TokenType.DOUBLE: 115>, <TokenType.UDOUBLE: 116>, <TokenType.DECIMAL: 117>, <TokenType.DECIMAL32: 118>, <TokenType.DECIMAL64: 119>, <TokenType.DECIMAL128: 120>, <TokenType.DECIMAL256: 121>, <TokenType.DECFLOAT: 122>, <TokenType.UDECIMAL: 123>, <TokenType.BIGDECIMAL: 124>, <TokenType.CHAR: 125>, <TokenType.NCHAR: 126>, <TokenType.VARCHAR: 127>, <TokenType.NVARCHAR: 128>, <TokenType.BPCHAR: 129>, <TokenType.TEXT: 130>, <TokenType.MEDIUMTEXT: 131>, <TokenType.LONGTEXT: 132>, <TokenType.BLOB: 133>, <TokenType.MEDIUMBLOB: 134>, <TokenType.LONGBLOB: 135>, <TokenType.TINYBLOB: 136>, <TokenType.TINYTEXT: 137>, <TokenType.NAME: 138>, <TokenType.BINARY: 139>, <TokenType.VARBINARY: 140>, <TokenType.JSON: 141>, <TokenType.JSONB: 142>, <TokenType.TIME: 143>, <TokenType.TIMETZ: 144>, <TokenType.TIME_NS: 145>, <TokenType.TIMESTAMP: 146>, <TokenType.TIMESTAMPTZ: 147>, <TokenType.TIMESTAMPLTZ: 148>, <TokenType.TIMESTAMPNTZ: 149>, <TokenType.TIMESTAMP_S: 150>, <TokenType.TIMESTAMP_MS: 151>, <TokenType.TIMESTAMP_NS: 152>, <TokenType.DATETIME: 153>, <TokenType.DATETIME2: 154>, <TokenType.DATETIME64: 155>, <TokenType.SMALLDATETIME: 156>, <TokenType.DATE: 157>, <TokenType.DATE32: 158>, <TokenType.INT4RANGE: 159>, <TokenType.INT4MULTIRANGE: 160>, <TokenType.INT8RANGE: 161>, <TokenType.INT8MULTIRANGE: 162>, <TokenType.NUMRANGE: 163>, <TokenType.NUMMULTIRANGE: 164>, <TokenType.TSRANGE: 165>, <TokenType.TSMULTIRANGE: 166>, <TokenType.TSTZRANGE: 167>, <TokenType.TSTZMULTIRANGE: 168>, <TokenType.DATERANGE: 169>, <TokenType.DATEMULTIRANGE: 170>, <TokenType.UUID: 171>, <TokenType.GEOGRAPHY: 172>, <TokenType.GEOGRAPHYPOINT: 173>, <TokenType.NULLABLE: 174>, <TokenType.GEOMETRY: 175>, <TokenType.POINT: 176>, <TokenType.RING: 177>, <TokenType.LINESTRING: 178>, <TokenType.LOCALTIME: 179>, <TokenType.LOCALTIMESTAMP: 180>, <TokenType.MULTILINESTRING: 182>, <TokenType.POLYGON: 183>, <TokenType.MULTIPOLYGON: 184>, <TokenType.HLLSKETCH: 185>, <TokenType.HSTORE: 186>, <TokenType.SUPER: 187>, <TokenType.SERIAL: 188>, <TokenType.SMALLSERIAL: 189>, <TokenType.BIGSERIAL: 190>, <TokenType.XML: 191>, <TokenType.YEAR: 192>, <TokenType.USERDEFINED: 193>, <TokenType.MONEY: 194>, <TokenType.SMALLMONEY: 195>, <TokenType.ROWVERSION: 196>, <TokenType.IMAGE: 197>, <TokenType.VARIANT: 198>, <TokenType.OBJECT: 199>, <TokenType.INET: 200>, <TokenType.IPADDRESS: 201>, <TokenType.IPPREFIX: 202>, <TokenType.IPV4: 203>, <TokenType.IPV6: 204>, <TokenType.ENUM: 205>, <TokenType.ENUM8: 206>, <TokenType.ENUM16: 207>, <TokenType.FIXEDSTRING: 208>, <TokenType.LOWCARDINALITY: 209>, <TokenType.NESTED: 210>, <TokenType.AGGREGATEFUNCTION: 211>, <TokenType.SIMPLEAGGREGATEFUNCTION: 212>, <TokenType.TDIGEST: 213>, <TokenType.UNKNOWN: 214>, <TokenType.VECTOR: 215>, <TokenType.DYNAMIC: 216>, <TokenType.VOID: 217>, <TokenType.ALL: 220>, <TokenType.ANY: 222>, <TokenType.ARRAY: 224>, <TokenType.COLLATE: 236>, <TokenType.COMMAND: 237>, <TokenType.CURRENT_DATE: 246>, <TokenType.CURRENT_DATETIME: 247>, <TokenType.CURRENT_SCHEMA: 248>, <TokenType.CURRENT_TIME: 249>, <TokenType.CURRENT_TIMESTAMP: 250>, <TokenType.CURRENT_USER: 251>, <TokenType.CURRENT_CATALOG: 254>, <TokenType.DECLARE: 255>, <TokenType.EXISTS: 271>, <TokenType.FILE: 274>, <TokenType.FILTER: 276>, <TokenType.FIRST: 278>, <TokenType.FORMAT: 282>, <TokenType.GET: 286>, <TokenType.GLOB: 287>, <TokenType.ILIKE: 295>, <TokenType.INDEX: 297>, <TokenType.INSERT: 300>, <TokenType.INTERVAL: 304>, <TokenType.ISNULL: 309>, <TokenType.LEFT: 317>, <TokenType.LIKE: 318>, <TokenType.LIST: 320>, <TokenType.MAP: 323>, <TokenType.MERGE: 328>, <TokenType.NEXT: 332>, <TokenType.NOTHING: 333>, <TokenType.NULL: 335>, <TokenType.OBJECT_IDENTIFIER: 336>, <TokenType.OFFSET: 337>, <TokenType.PRIMARY_KEY: 362>, <TokenType.PSEUDO_TYPE: 366>, <TokenType.RANGE: 371>, <TokenType.REPLACE: 375>, <TokenType.RIGHT: 379>, <TokenType.RLIKE: 380>, <TokenType.ROW: 384>, <TokenType.SEQUENCE: 390>, <TokenType.SET: 392>, <TokenType.SOME: 396>, <TokenType.STRUCT: 403>, <TokenType.TRUNCATE: 411>, <TokenType.UNION: 416>, <TokenType.UNNEST: 417>, <TokenType.WINDOW: 430>, <TokenType.UTC_DATE: 433>, <TokenType.UTC_TIME: 434>, <TokenType.UTC_TIMESTAMP: 435>}

RESERVED_TOKENS = {<TokenType.L_PAREN: 1>, <TokenType.R_PAREN: 2>, <TokenType.L_BRACKET: 3>, <TokenType.R_BRACKET: 4>, <TokenType.L_BRACE: 5>, <TokenType.R_BRACE: 6>, <TokenType.COMMA: 7>, <TokenType.DOT: 8>, <TokenType.DASH: 9>, <TokenType.PLUS: 10>, <TokenType.COLON: 11>, <TokenType.MOD: 329>, <TokenType.SEMICOLON: 19>, <TokenType.STAR: 20>, <TokenType.BACKSLASH: 21>, <TokenType.SLASH: 22>, <TokenType.LT: 23>, <TokenType.UNKNOWN: 214>, <TokenType.GT: 25>, <TokenType.NOT: 27>, <TokenType.EQ: 28>, <TokenType.AMP: 36>, <TokenType.PLACEHOLDER: 356>, <TokenType.PIPE: 39>, <TokenType.CARET: 42>, <TokenType.TILDE: 44>, <TokenType.HASH: 48>, <TokenType.PARAMETER: 58>}

ID_VAR_TOKENS = {<TokenType.SESSION: 59>, <TokenType.SESSION_USER: 61>, <TokenType.IDENTIFIER: 79>, <TokenType.DATABASE: 80>, <TokenType.COLUMN: 81>, <TokenType.SCHEMA: 83>, <TokenType.TABLE: 84>, <TokenType.WAREHOUSE: 85>, <TokenType.STAGE: 86>, <TokenType.STREAM: 87>, <TokenType.STREAMLIT: 88>, <TokenType.VAR: 89>, <TokenType.BIT: 97>, <TokenType.BOOLEAN: 98>, <TokenType.TINYINT: 99>, <TokenType.UTINYINT: 100>, <TokenType.SMALLINT: 101>, <TokenType.USMALLINT: 102>, <TokenType.MEDIUMINT: 103>, <TokenType.UMEDIUMINT: 104>, <TokenType.INT: 105>, <TokenType.UINT: 106>, <TokenType.BIGINT: 107>, <TokenType.UBIGINT: 108>, <TokenType.BIGNUM: 109>, <TokenType.INT128: 110>, <TokenType.UINT128: 111>, <TokenType.INT256: 112>, <TokenType.UINT256: 113>, <TokenType.FLOAT: 114>, <TokenType.DOUBLE: 115>, <TokenType.UDOUBLE: 116>, <TokenType.DECIMAL: 117>, <TokenType.DECIMAL32: 118>, <TokenType.DECIMAL64: 119>, <TokenType.DECIMAL128: 120>, <TokenType.DECIMAL256: 121>, <TokenType.DECFLOAT: 122>, <TokenType.UDECIMAL: 123>, <TokenType.BIGDECIMAL: 124>, <TokenType.CHAR: 125>, <TokenType.NCHAR: 126>, <TokenType.VARCHAR: 127>, <TokenType.NVARCHAR: 128>, <TokenType.BPCHAR: 129>, <TokenType.TEXT: 130>, <TokenType.MEDIUMTEXT: 131>, <TokenType.LONGTEXT: 132>, <TokenType.BLOB: 133>, <TokenType.MEDIUMBLOB: 134>, <TokenType.LONGBLOB: 135>, <TokenType.TINYBLOB: 136>, <TokenType.TINYTEXT: 137>, <TokenType.NAME: 138>, <TokenType.BINARY: 139>, <TokenType.VARBINARY: 140>, <TokenType.JSON: 141>, <TokenType.JSONB: 142>, <TokenType.TIME: 143>, <TokenType.TIMETZ: 144>, <TokenType.TIME_NS: 145>, <TokenType.TIMESTAMP: 146>, <TokenType.TIMESTAMPTZ: 147>, <TokenType.TIMESTAMPLTZ: 148>, <TokenType.TIMESTAMPNTZ: 149>, <TokenType.TIMESTAMP_S: 150>, <TokenType.TIMESTAMP_MS: 151>, <TokenType.TIMESTAMP_NS: 152>, <TokenType.DATETIME: 153>, <TokenType.DATETIME2: 154>, <TokenType.DATETIME64: 155>, <TokenType.SMALLDATETIME: 156>, <TokenType.DATE: 157>, <TokenType.DATE32: 158>, <TokenType.INT4RANGE: 159>, <TokenType.INT4MULTIRANGE: 160>, <TokenType.INT8RANGE: 161>, <TokenType.INT8MULTIRANGE: 162>, <TokenType.NUMRANGE: 163>, <TokenType.NUMMULTIRANGE: 164>, <TokenType.TSRANGE: 165>, <TokenType.TSMULTIRANGE: 166>, <TokenType.TSTZRANGE: 167>, <TokenType.TSTZMULTIRANGE: 168>, <TokenType.DATERANGE: 169>, <TokenType.DATEMULTIRANGE: 170>, <TokenType.UUID: 171>, <TokenType.GEOGRAPHY: 172>, <TokenType.GEOGRAPHYPOINT: 173>, <TokenType.NULLABLE: 174>, <TokenType.GEOMETRY: 175>, <TokenType.POINT: 176>, <TokenType.RING: 177>, <TokenType.LINESTRING: 178>, <TokenType.LOCALTIME: 179>, <TokenType.LOCALTIMESTAMP: 180>, <TokenType.MULTILINESTRING: 182>, <TokenType.POLYGON: 183>, <TokenType.MULTIPOLYGON: 184>, <TokenType.HLLSKETCH: 185>, <TokenType.HSTORE: 186>, <TokenType.SUPER: 187>, <TokenType.SERIAL: 188>, <TokenType.SMALLSERIAL: 189>, <TokenType.BIGSERIAL: 190>, <TokenType.XML: 191>, <TokenType.YEAR: 192>, <TokenType.USERDEFINED: 193>, <TokenType.MONEY: 194>, <TokenType.SMALLMONEY: 195>, <TokenType.ROWVERSION: 196>, <TokenType.IMAGE: 197>, <TokenType.VARIANT: 198>, <TokenType.OBJECT: 199>, <TokenType.INET: 200>, <TokenType.IPADDRESS: 201>, <TokenType.IPPREFIX: 202>, <TokenType.IPV4: 203>, <TokenType.IPV6: 204>, <TokenType.ENUM: 205>, <TokenType.ENUM8: 206>, <TokenType.ENUM16: 207>, <TokenType.FIXEDSTRING: 208>, <TokenType.LOWCARDINALITY: 209>, <TokenType.NESTED: 210>, <TokenType.AGGREGATEFUNCTION: 211>, <TokenType.SIMPLEAGGREGATEFUNCTION: 212>, <TokenType.TDIGEST: 213>, <TokenType.UNKNOWN: 214>, <TokenType.VECTOR: 215>, <TokenType.DYNAMIC: 216>, <TokenType.VOID: 217>, <TokenType.ALL: 220>, <TokenType.ANTI: 221>, <TokenType.ANY: 222>, <TokenType.APPLY: 223>, <TokenType.ARRAY: 224>, <TokenType.ASC: 225>, <TokenType.ASOF: 226>, <TokenType.ATTACH: 227>, <TokenType.AUTO_INCREMENT: 228>, <TokenType.BEGIN: 229>, <TokenType.CACHE: 232>, <TokenType.CASE: 233>, <TokenType.COLLATE: 236>, <TokenType.COMMAND: 237>, <TokenType.COMMENT: 238>, <TokenType.COMMIT: 239>, <TokenType.CONSTRAINT: 241>, <TokenType.COPY: 242>, <TokenType.CUBE: 245>, <TokenType.CURRENT_DATE: 246>, <TokenType.CURRENT_DATETIME: 247>, <TokenType.CURRENT_SCHEMA: 248>, <TokenType.CURRENT_TIME: 249>, <TokenType.CURRENT_TIMESTAMP: 250>, <TokenType.CURRENT_USER: 251>, <TokenType.CURRENT_ROLE: 253>, <TokenType.CURRENT_CATALOG: 254>, <TokenType.DECLARE: 255>, <TokenType.DEFAULT: 256>, <TokenType.DELETE: 257>, <TokenType.DESC: 258>, <TokenType.DESCRIBE: 259>, <TokenType.DETACH: 260>, <TokenType.DICTIONARY: 261>, <TokenType.DIV: 264>, <TokenType.END: 267>, <TokenType.ESCAPE: 268>, <TokenType.EXECUTE: 270>, <TokenType.EXISTS: 271>, <TokenType.FALSE: 272>, <TokenType.FILE: 274>, <TokenType.FILE_FORMAT: 275>, <TokenType.FILTER: 276>, <TokenType.FINAL: 277>, <TokenType.FIRST: 278>, <TokenType.FOREIGN_KEY: 281>, <TokenType.FORMAT: 282>, <TokenType.FULL: 284>, <TokenType.FUNCTION: 285>, <TokenType.GET: 286>, <TokenType.INDEX: 297>, <TokenType.INTERVAL: 304>, <TokenType.IS: 308>, <TokenType.ISNULL: 309>, <TokenType.KEEP: 312>, <TokenType.KILL: 314>, <TokenType.LEFT: 317>, <TokenType.LIKE: 318>, <TokenType.LIMIT: 319>, <TokenType.LIST: 320>, <TokenType.LOAD: 321>, <TokenType.LOCK: 322>, <TokenType.MAP: 323>, <TokenType.MATCH: 324>, <TokenType.MERGE: 328>, <TokenType.MODEL: 330>, <TokenType.NATURAL: 331>, <TokenType.NEXT: 332>, <TokenType.NOTHING: 333>, <TokenType.NULL: 335>, <TokenType.OBJECT_IDENTIFIER: 336>, <TokenType.OFFSET: 337>, <TokenType.OPERATOR: 340>, <TokenType.ORDINALITY: 344>, <TokenType.OUT: 345>, <TokenType.INOUT: 346>, <TokenType.OVER: 348>, <TokenType.OVERLAPS: 349>, <TokenType.OVERWRITE: 350>, <TokenType.PARTITION: 352>, <TokenType.PERCENT: 354>, <TokenType.PIVOT: 355>, <TokenType.PRAGMA: 360>, <TokenType.PROCEDURE: 363>, <TokenType.PROJECTION: 365>, <TokenType.PSEUDO_TYPE: 366>, <TokenType.PUT: 367>, <TokenType.RANGE: 371>, <TokenType.RECURSIVE: 372>, <TokenType.REFRESH: 373>, <TokenType.RENAME: 374>, <TokenType.REPLACE: 375>, <TokenType.REFERENCES: 378>, <TokenType.RIGHT: 379>, <TokenType.ROLLUP: 383>, <TokenType.ROW: 384>, <TokenType.ROWS: 385>, <TokenType.SEMI: 388>, <TokenType.SEQUENCE: 390>, <TokenType.SET: 392>, <TokenType.SETTINGS: 393>, <TokenType.SHOW: 394>, <TokenType.SOME: 396>, <TokenType.STORAGE_INTEGRATION: 401>, <TokenType.STRAIGHT_JOIN: 402>, <TokenType.STRUCT: 403>, <TokenType.TAG: 406>, <TokenType.TEMPORARY: 407>, <TokenType.TOP: 408>, <TokenType.TRUE: 410>, <TokenType.TRUNCATE: 411>, <TokenType.TRIGGER: 412>, <TokenType.TYPE: 413>, <TokenType.UNNEST: 417>, <TokenType.UNPIVOT: 418>, <TokenType.UPDATE: 419>, <TokenType.USE: 420>, <TokenType.VIEW: 424>, <TokenType.SEMANTIC_VIEW: 425>, <TokenType.VOLATILE: 426>, <TokenType.WINDOW: 430>, <TokenType.UNIQUE: 432>, <TokenType.SINK: 437>, <TokenType.SOURCE: 438>, <TokenType.ANALYZE: 439>, <TokenType.NAMESPACE: 440>, <TokenType.EXPORT: 441>}

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

FUNCTION_PARSERS = {'ARG_MAX': <function Parser.<dictcomp>.<lambda>>, 'ARGMAX': <function Parser.<dictcomp>.<lambda>>, 'MAX_BY': <function Parser.<dictcomp>.<lambda>>, 'ARG_MIN': <function Parser.<dictcomp>.<lambda>>, 'ARGMIN': <function Parser.<dictcomp>.<lambda>>, 'MIN_BY': <function Parser.<dictcomp>.<lambda>>, 'CAST': <function Parser.<lambda>>, 'CEIL': <function Parser.<lambda>>, 'CONVERT': <function Parser.<lambda>>, 'CHAR': <function Parser.<lambda>>, 'CHR': <function Parser.<lambda>>, 'DECODE': <function Parser.<lambda>>, 'EXTRACT': <function Parser.<lambda>>, 'FLOOR': <function Parser.<lambda>>, 'GAP_FILL': <function Parser.<lambda>>, 'INITCAP': <function Parser.<lambda>>, 'JSON_OBJECT': <function Parser.<lambda>>, 'JSON_OBJECTAGG': <function Parser.<lambda>>, 'JSON_TABLE': <function Parser.<lambda>>, 'NORMALIZE': <function Parser.<lambda>>, 'OPENJSON': <function Parser.<lambda>>, 'OVERLAY': <function Parser.<lambda>>, 'POSITION': <function Parser.<lambda>>, 'SAFE_CAST': <function Parser.<lambda>>, 'STRING_AGG': <function Parser.<lambda>>, 'SUBSTRING': <function Parser.<lambda>>, 'TRIM': <function Parser.<lambda>>, 'TRY_CAST': <function Parser.<lambda>>, 'TRY_CONVERT': <function Parser.<lambda>>, 'XMLELEMENT': <function Parser.<lambda>>, 'XMLTABLE': <function Parser.<lambda>>, 'ARRAYJOIN': <function ClickHouseParser.<lambda>>, 'GROUPCONCAT': <function ClickHouseParser.<lambda>>, 'QUANTILE': <function ClickHouseParser.<lambda>>, 'MEDIAN': <function ClickHouseParser.<lambda>>, 'COLUMNS': <function ClickHouseParser.<lambda>>, 'TUPLE': <function ClickHouseParser.<lambda>>, 'AND': <function ClickHouseParser.<lambda>>, 'OR': <function ClickHouseParser.<lambda>>, 'XOR': <function ClickHouseParser.<lambda>>}

PROPERTY_PARSERS = {'ALLOWED_VALUES': <function Parser.<lambda>>, 'ALGORITHM': <function Parser.<lambda>>, 'AUTO': <function Parser.<lambda>>, 'AUTO_INCREMENT': <function Parser.<lambda>>, 'BACKUP': <function Parser.<lambda>>, 'BLOCKCOMPRESSION': <function Parser.<lambda>>, 'CALLED': <function Parser.<lambda>>, 'CHARSET': <function Parser.<lambda>>, 'CHECKSUM': <function Parser.<lambda>>, 'CLUSTER BY': <function Parser.<lambda>>, 'CLUSTERED': <function Parser.<lambda>>, 'COLLATE': <function Parser.<lambda>>, 'COMMENT': <function Parser.<lambda>>, 'CONTAINS': <function Parser.<lambda>>, 'COPY': <function Parser.<lambda>>, 'DATABLOCKSIZE': <function Parser.<lambda>>, 'DATA_DELETION': <function Parser.<lambda>>, 'DEFINER': <function Parser.<lambda>>, 'DETERMINISTIC': <function Parser.<lambda>>, 'DISTRIBUTED': <function Parser.<lambda>>, 'DUPLICATE': <function Parser.<lambda>>, 'DISTKEY': <function Parser.<lambda>>, 'DISTSTYLE': <function Parser.<lambda>>, 'EMPTY': <function Parser.<lambda>>, 'ENGINE': <function ClickHouseParser.<lambda>>, 'ENVIRONMENT': <function Parser.<lambda>>, 'HANDLER': <function Parser.<lambda>>, 'EXECUTE': <function Parser.<lambda>>, 'EXTERNAL': <function Parser.<lambda>>, 'FALLBACK': <function Parser.<lambda>>, 'FORMAT': <function Parser.<lambda>>, 'FREESPACE': <function Parser.<lambda>>, 'GLOBAL': <function Parser.<lambda>>, 'HEAP': <function Parser.<lambda>>, 'ICEBERG': <function Parser.<lambda>>, 'IMMUTABLE': <function Parser.<lambda>>, 'INHERITS': <function Parser.<lambda>>, 'INPUT': <function Parser.<lambda>>, 'JOURNAL': <function Parser.<lambda>>, 'LANGUAGE': <function Parser.<lambda>>, 'LAYOUT': <function Parser.<lambda>>, 'LIFETIME': <function Parser.<lambda>>, 'LIKE': <function Parser.<lambda>>, 'LOCATION': <function Parser.<lambda>>, 'LOCK': <function Parser.<lambda>>, 'LOCKING': <function Parser.<lambda>>, 'LOG': <function Parser.<lambda>>, 'MATERIALIZED': <function Parser.<lambda>>, 'MERGEBLOCKRATIO': <function Parser.<lambda>>, 'MODIFIES': <function Parser.<lambda>>, 'MULTISET': <function Parser.<lambda>>, 'NO': <function Parser.<lambda>>, 'ON': <function Parser.<lambda>>, 'ORDER BY': <function Parser.<lambda>>, 'OUTPUT': <function Parser.<lambda>>, 'PARTITION': <function Parser.<lambda>>, 'PARTITION BY': <function Parser.<lambda>>, 'PARTITIONED BY': <function Parser.<lambda>>, 'PARTITIONED_BY': <function Parser.<lambda>>, 'PRIMARY KEY': <function Parser.<lambda>>, 'RANGE': <function Parser.<lambda>>, 'READS': <function Parser.<lambda>>, 'REMOTE': <function Parser.<lambda>>, 'RETURNS': <function Parser.<lambda>>, 'STRICT': <function Parser.<lambda>>, 'STREAMING': <function Parser.<lambda>>, 'ROW': <function Parser.<lambda>>, 'ROW_FORMAT': <function Parser.<lambda>>, 'SAMPLE': <function Parser.<lambda>>, 'SECURE': <function Parser.<lambda>>, 'SECURITY': <function Parser.<lambda>>, 'SQL SECURITY': <function Parser.<lambda>>, 'SET': <function Parser.<lambda>>, 'SETTINGS': <function Parser.<lambda>>, 'SHARING': <function Parser.<lambda>>, 'SORTKEY': <function Parser.<lambda>>, 'SOURCE': <function Parser.<lambda>>, 'STABLE': <function Parser.<lambda>>, 'STORED': <function Parser.<lambda>>, 'SYSTEM_VERSIONING': <function Parser.<lambda>>, 'TBLPROPERTIES': <function Parser.<lambda>>, 'TEMP': <function Parser.<lambda>>, 'TEMPORARY': <function Parser.<lambda>>, 'TO': <function Parser.<lambda>>, 'TRANSIENT': <function Parser.<lambda>>, 'TRANSFORM': <function Parser.<lambda>>, 'TTL': <function Parser.<lambda>>, 'USING': <function Parser.<lambda>>, 'UNLOGGED': <function Parser.<lambda>>, 'VOLATILE': <function Parser.<lambda>>, 'WITH': <function Parser.<lambda>>, 'REFRESH': <function ClickHouseParser.<lambda>>, 'UUID': <function ClickHouseParser.<lambda>>}

NO_PAREN_FUNCTION_PARSERS = {'CASE': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <function Parser.<lambda>>, 'IF': <function Parser.<lambda>>}

NO_PAREN_FUNCTIONS = {<TokenType.CURRENT_DATE: 246>: <class 'sqlglot.expressions.temporal.CurrentDate'>, <TokenType.CURRENT_DATETIME: 247>: <class 'sqlglot.expressions.temporal.CurrentDate'>, <TokenType.CURRENT_TIME: 249>: <class 'sqlglot.expressions.temporal.CurrentTime'>, <TokenType.CURRENT_USER: 251>: <class 'sqlglot.expressions.functions.CurrentUser'>, <TokenType.CURRENT_ROLE: 253>: <class 'sqlglot.expressions.functions.CurrentRole'>}

RANGE_PARSERS = {<TokenType.AT_GT: 56>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.BETWEEN: 230>: <function Parser.<lambda>>, <TokenType.GLOB: 287>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.ILIKE: 295>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IN: 296>: <function Parser.<lambda>>, <TokenType.IRLIKE: 307>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IS: 308>: <function Parser.<lambda>>, <TokenType.LIKE: 318>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.LT_AT: 55>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.OVERLAPS: 349>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.RLIKE: 380>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.SIMILAR_TO: 395>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.FOR: 279>: <function Parser.<lambda>>, <TokenType.QMARK_AMP: 68>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.QMARK_PIPE: 69>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.HASH_DASH: 70>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.AT_QMARK: 54>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.ADJACENT: 65>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.OPERATOR: 340>: <function Parser.<lambda>>, <TokenType.AMP_LT: 63>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.AMP_GT: 64>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.GLOBAL: 288>: <function ClickHouseParser.<lambda>>}

COLUMN_OPERATORS = {<TokenType.DOT: 8>: None, <TokenType.DOTCOLON: 12>: <function Parser.<lambda>>, <TokenType.DCOLON: 14>: <function Parser.<lambda>>, <TokenType.ARROW: 45>: <function Parser.<lambda>>, <TokenType.DARROW: 46>: <function Parser.<lambda>>, <TokenType.HASH_ARROW: 49>: <function Parser.<lambda>>, <TokenType.DHASH_ARROW: 50>: <function Parser.<lambda>>, <TokenType.DOTCARET: 13>: <function ClickHouseParser.<lambda>>}

JOIN_KINDS = {<TokenType.SEMI: 388>, <TokenType.STRAIGHT_JOIN: 402>, <TokenType.OUTER: 347>, <TokenType.ALL: 220>, <TokenType.ANTI: 221>, <TokenType.ANY: 222>, <TokenType.ARRAY: 224>, <TokenType.ASOF: 226>, <TokenType.INNER: 299>, <TokenType.CROSS: 244>}

TABLE_ALIAS_TOKENS = {<TokenType.SESSION: 59>, <TokenType.SESSION_USER: 61>, <TokenType.IDENTIFIER: 79>, <TokenType.DATABASE: 80>, <TokenType.COLUMN: 81>, <TokenType.SCHEMA: 83>, <TokenType.TABLE: 84>, <TokenType.WAREHOUSE: 85>, <TokenType.STAGE: 86>, <TokenType.STREAM: 87>, <TokenType.STREAMLIT: 88>, <TokenType.VAR: 89>, <TokenType.BIT: 97>, <TokenType.BOOLEAN: 98>, <TokenType.TINYINT: 99>, <TokenType.UTINYINT: 100>, <TokenType.SMALLINT: 101>, <TokenType.USMALLINT: 102>, <TokenType.MEDIUMINT: 103>, <TokenType.UMEDIUMINT: 104>, <TokenType.INT: 105>, <TokenType.UINT: 106>, <TokenType.BIGINT: 107>, <TokenType.UBIGINT: 108>, <TokenType.BIGNUM: 109>, <TokenType.INT128: 110>, <TokenType.UINT128: 111>, <TokenType.INT256: 112>, <TokenType.UINT256: 113>, <TokenType.FLOAT: 114>, <TokenType.DOUBLE: 115>, <TokenType.UDOUBLE: 116>, <TokenType.DECIMAL: 117>, <TokenType.DECIMAL32: 118>, <TokenType.DECIMAL64: 119>, <TokenType.DECIMAL128: 120>, <TokenType.DECIMAL256: 121>, <TokenType.DECFLOAT: 122>, <TokenType.UDECIMAL: 123>, <TokenType.BIGDECIMAL: 124>, <TokenType.CHAR: 125>, <TokenType.NCHAR: 126>, <TokenType.VARCHAR: 127>, <TokenType.NVARCHAR: 128>, <TokenType.BPCHAR: 129>, <TokenType.TEXT: 130>, <TokenType.MEDIUMTEXT: 131>, <TokenType.LONGTEXT: 132>, <TokenType.BLOB: 133>, <TokenType.MEDIUMBLOB: 134>, <TokenType.LONGBLOB: 135>, <TokenType.TINYBLOB: 136>, <TokenType.TINYTEXT: 137>, <TokenType.NAME: 138>, <TokenType.BINARY: 139>, <TokenType.VARBINARY: 140>, <TokenType.JSON: 141>, <TokenType.JSONB: 142>, <TokenType.TIME: 143>, <TokenType.TIMETZ: 144>, <TokenType.TIME_NS: 145>, <TokenType.TIMESTAMP: 146>, <TokenType.TIMESTAMPTZ: 147>, <TokenType.TIMESTAMPLTZ: 148>, <TokenType.TIMESTAMPNTZ: 149>, <TokenType.TIMESTAMP_S: 150>, <TokenType.TIMESTAMP_MS: 151>, <TokenType.TIMESTAMP_NS: 152>, <TokenType.DATETIME: 153>, <TokenType.DATETIME2: 154>, <TokenType.DATETIME64: 155>, <TokenType.SMALLDATETIME: 156>, <TokenType.DATE: 157>, <TokenType.DATE32: 158>, <TokenType.INT4RANGE: 159>, <TokenType.INT4MULTIRANGE: 160>, <TokenType.INT8RANGE: 161>, <TokenType.INT8MULTIRANGE: 162>, <TokenType.NUMRANGE: 163>, <TokenType.NUMMULTIRANGE: 164>, <TokenType.TSRANGE: 165>, <TokenType.TSMULTIRANGE: 166>, <TokenType.TSTZRANGE: 167>, <TokenType.TSTZMULTIRANGE: 168>, <TokenType.DATERANGE: 169>, <TokenType.DATEMULTIRANGE: 170>, <TokenType.UUID: 171>, <TokenType.GEOGRAPHY: 172>, <TokenType.GEOGRAPHYPOINT: 173>, <TokenType.NULLABLE: 174>, <TokenType.GEOMETRY: 175>, <TokenType.POINT: 176>, <TokenType.RING: 177>, <TokenType.LINESTRING: 178>, <TokenType.LOCALTIME: 179>, <TokenType.LOCALTIMESTAMP: 180>, <TokenType.MULTILINESTRING: 182>, <TokenType.POLYGON: 183>, <TokenType.MULTIPOLYGON: 184>, <TokenType.HLLSKETCH: 185>, <TokenType.HSTORE: 186>, <TokenType.SUPER: 187>, <TokenType.SERIAL: 188>, <TokenType.SMALLSERIAL: 189>, <TokenType.BIGSERIAL: 190>, <TokenType.XML: 191>, <TokenType.YEAR: 192>, <TokenType.USERDEFINED: 193>, <TokenType.MONEY: 194>, <TokenType.SMALLMONEY: 195>, <TokenType.ROWVERSION: 196>, <TokenType.IMAGE: 197>, <TokenType.VARIANT: 198>, <TokenType.OBJECT: 199>, <TokenType.INET: 200>, <TokenType.IPADDRESS: 201>, <TokenType.IPPREFIX: 202>, <TokenType.IPV4: 203>, <TokenType.IPV6: 204>, <TokenType.ENUM: 205>, <TokenType.ENUM8: 206>, <TokenType.ENUM16: 207>, <TokenType.FIXEDSTRING: 208>, <TokenType.LOWCARDINALITY: 209>, <TokenType.NESTED: 210>, <TokenType.AGGREGATEFUNCTION: 211>, <TokenType.SIMPLEAGGREGATEFUNCTION: 212>, <TokenType.TDIGEST: 213>, <TokenType.UNKNOWN: 214>, <TokenType.VECTOR: 215>, <TokenType.DYNAMIC: 216>, <TokenType.VOID: 217>, <TokenType.APPLY: 223>, <TokenType.ASC: 225>, <TokenType.ATTACH: 227>, <TokenType.AUTO_INCREMENT: 228>, <TokenType.BEGIN: 229>, <TokenType.CACHE: 232>, <TokenType.CASE: 233>, <TokenType.COLLATE: 236>, <TokenType.COMMAND: 237>, <TokenType.COMMENT: 238>, <TokenType.COMMIT: 239>, <TokenType.CONSTRAINT: 241>, <TokenType.COPY: 242>, <TokenType.CUBE: 245>, <TokenType.CURRENT_DATE: 246>, <TokenType.CURRENT_DATETIME: 247>, <TokenType.CURRENT_SCHEMA: 248>, <TokenType.CURRENT_TIME: 249>, <TokenType.CURRENT_TIMESTAMP: 250>, <TokenType.CURRENT_USER: 251>, <TokenType.CURRENT_ROLE: 253>, <TokenType.CURRENT_CATALOG: 254>, <TokenType.DECLARE: 255>, <TokenType.DEFAULT: 256>, <TokenType.DELETE: 257>, <TokenType.DESC: 258>, <TokenType.DESCRIBE: 259>, <TokenType.DETACH: 260>, <TokenType.DICTIONARY: 261>, <TokenType.DIV: 264>, <TokenType.END: 267>, <TokenType.ESCAPE: 268>, <TokenType.EXECUTE: 270>, <TokenType.EXISTS: 271>, <TokenType.FALSE: 272>, <TokenType.FILE: 274>, <TokenType.FILE_FORMAT: 275>, <TokenType.FILTER: 276>, <TokenType.FIRST: 278>, <TokenType.FOREIGN_KEY: 281>, <TokenType.FUNCTION: 285>, <TokenType.GET: 286>, <TokenType.INDEX: 297>, <TokenType.INTERVAL: 304>, <TokenType.IS: 308>, <TokenType.ISNULL: 309>, <TokenType.KEEP: 312>, <TokenType.KILL: 314>, <TokenType.LIMIT: 319>, <TokenType.LIST: 320>, <TokenType.LOAD: 321>, <TokenType.MAP: 323>, <TokenType.MATCH: 324>, <TokenType.MERGE: 328>, <TokenType.MODEL: 330>, <TokenType.NEXT: 332>, <TokenType.NOTHING: 333>, <TokenType.NULL: 335>, <TokenType.OBJECT_IDENTIFIER: 336>, <TokenType.OFFSET: 337>, <TokenType.OPERATOR: 340>, <TokenType.ORDINALITY: 344>, <TokenType.OUT: 345>, <TokenType.INOUT: 346>, <TokenType.OVER: 348>, <TokenType.OVERLAPS: 349>, <TokenType.OVERWRITE: 350>, <TokenType.PARTITION: 352>, <TokenType.PERCENT: 354>, <TokenType.PIVOT: 355>, <TokenType.PRAGMA: 360>, <TokenType.PROCEDURE: 363>, <TokenType.PROJECTION: 365>, <TokenType.PSEUDO_TYPE: 366>, <TokenType.PUT: 367>, <TokenType.RANGE: 371>, <TokenType.RECURSIVE: 372>, <TokenType.REFRESH: 373>, <TokenType.RENAME: 374>, <TokenType.REPLACE: 375>, <TokenType.REFERENCES: 378>, <TokenType.ROLLUP: 383>, <TokenType.ROW: 384>, <TokenType.ROWS: 385>, <TokenType.SEQUENCE: 390>, <TokenType.SET: 392>, <TokenType.SHOW: 394>, <TokenType.SOME: 396>, <TokenType.STORAGE_INTEGRATION: 401>, <TokenType.STRAIGHT_JOIN: 402>, <TokenType.STRUCT: 403>, <TokenType.TAG: 406>, <TokenType.TEMPORARY: 407>, <TokenType.TOP: 408>, <TokenType.TRUE: 410>, <TokenType.TRUNCATE: 411>, <TokenType.TRIGGER: 412>, <TokenType.TYPE: 413>, <TokenType.UNNEST: 417>, <TokenType.UNPIVOT: 418>, <TokenType.UPDATE: 419>, <TokenType.USE: 420>, <TokenType.VIEW: 424>, <TokenType.SEMANTIC_VIEW: 425>, <TokenType.VOLATILE: 426>, <TokenType.UNIQUE: 432>, <TokenType.SINK: 437>, <TokenType.SOURCE: 438>, <TokenType.ANALYZE: 439>, <TokenType.NAMESPACE: 440>, <TokenType.EXPORT: 441>}

ALIAS_TOKENS = {<TokenType.SESSION: 59>, <TokenType.SESSION_USER: 61>, <TokenType.IDENTIFIER: 79>, <TokenType.DATABASE: 80>, <TokenType.COLUMN: 81>, <TokenType.SCHEMA: 83>, <TokenType.TABLE: 84>, <TokenType.WAREHOUSE: 85>, <TokenType.STAGE: 86>, <TokenType.STREAM: 87>, <TokenType.STREAMLIT: 88>, <TokenType.VAR: 89>, <TokenType.BIT: 97>, <TokenType.BOOLEAN: 98>, <TokenType.TINYINT: 99>, <TokenType.UTINYINT: 100>, <TokenType.SMALLINT: 101>, <TokenType.USMALLINT: 102>, <TokenType.MEDIUMINT: 103>, <TokenType.UMEDIUMINT: 104>, <TokenType.INT: 105>, <TokenType.UINT: 106>, <TokenType.BIGINT: 107>, <TokenType.UBIGINT: 108>, <TokenType.BIGNUM: 109>, <TokenType.INT128: 110>, <TokenType.UINT128: 111>, <TokenType.INT256: 112>, <TokenType.UINT256: 113>, <TokenType.FLOAT: 114>, <TokenType.DOUBLE: 115>, <TokenType.UDOUBLE: 116>, <TokenType.DECIMAL: 117>, <TokenType.DECIMAL32: 118>, <TokenType.DECIMAL64: 119>, <TokenType.DECIMAL128: 120>, <TokenType.DECIMAL256: 121>, <TokenType.DECFLOAT: 122>, <TokenType.UDECIMAL: 123>, <TokenType.BIGDECIMAL: 124>, <TokenType.CHAR: 125>, <TokenType.NCHAR: 126>, <TokenType.VARCHAR: 127>, <TokenType.NVARCHAR: 128>, <TokenType.BPCHAR: 129>, <TokenType.TEXT: 130>, <TokenType.MEDIUMTEXT: 131>, <TokenType.LONGTEXT: 132>, <TokenType.BLOB: 133>, <TokenType.MEDIUMBLOB: 134>, <TokenType.LONGBLOB: 135>, <TokenType.TINYBLOB: 136>, <TokenType.TINYTEXT: 137>, <TokenType.NAME: 138>, <TokenType.BINARY: 139>, <TokenType.VARBINARY: 140>, <TokenType.JSON: 141>, <TokenType.JSONB: 142>, <TokenType.TIME: 143>, <TokenType.TIMETZ: 144>, <TokenType.TIME_NS: 145>, <TokenType.TIMESTAMP: 146>, <TokenType.TIMESTAMPTZ: 147>, <TokenType.TIMESTAMPLTZ: 148>, <TokenType.TIMESTAMPNTZ: 149>, <TokenType.TIMESTAMP_S: 150>, <TokenType.TIMESTAMP_MS: 151>, <TokenType.TIMESTAMP_NS: 152>, <TokenType.DATETIME: 153>, <TokenType.DATETIME2: 154>, <TokenType.DATETIME64: 155>, <TokenType.SMALLDATETIME: 156>, <TokenType.DATE: 157>, <TokenType.DATE32: 158>, <TokenType.INT4RANGE: 159>, <TokenType.INT4MULTIRANGE: 160>, <TokenType.INT8RANGE: 161>, <TokenType.INT8MULTIRANGE: 162>, <TokenType.NUMRANGE: 163>, <TokenType.NUMMULTIRANGE: 164>, <TokenType.TSRANGE: 165>, <TokenType.TSMULTIRANGE: 166>, <TokenType.TSTZRANGE: 167>, <TokenType.TSTZMULTIRANGE: 168>, <TokenType.DATERANGE: 169>, <TokenType.DATEMULTIRANGE: 170>, <TokenType.UUID: 171>, <TokenType.GEOGRAPHY: 172>, <TokenType.GEOGRAPHYPOINT: 173>, <TokenType.NULLABLE: 174>, <TokenType.GEOMETRY: 175>, <TokenType.POINT: 176>, <TokenType.RING: 177>, <TokenType.LINESTRING: 178>, <TokenType.LOCALTIME: 179>, <TokenType.LOCALTIMESTAMP: 180>, <TokenType.MULTILINESTRING: 182>, <TokenType.POLYGON: 183>, <TokenType.MULTIPOLYGON: 184>, <TokenType.HLLSKETCH: 185>, <TokenType.HSTORE: 186>, <TokenType.SUPER: 187>, <TokenType.SERIAL: 188>, <TokenType.SMALLSERIAL: 189>, <TokenType.BIGSERIAL: 190>, <TokenType.XML: 191>, <TokenType.YEAR: 192>, <TokenType.USERDEFINED: 193>, <TokenType.MONEY: 194>, <TokenType.SMALLMONEY: 195>, <TokenType.ROWVERSION: 196>, <TokenType.IMAGE: 197>, <TokenType.VARIANT: 198>, <TokenType.OBJECT: 199>, <TokenType.INET: 200>, <TokenType.IPADDRESS: 201>, <TokenType.IPPREFIX: 202>, <TokenType.IPV4: 203>, <TokenType.IPV6: 204>, <TokenType.ENUM: 205>, <TokenType.ENUM8: 206>, <TokenType.ENUM16: 207>, <TokenType.FIXEDSTRING: 208>, <TokenType.LOWCARDINALITY: 209>, <TokenType.NESTED: 210>, <TokenType.AGGREGATEFUNCTION: 211>, <TokenType.SIMPLEAGGREGATEFUNCTION: 212>, <TokenType.TDIGEST: 213>, <TokenType.UNKNOWN: 214>, <TokenType.VECTOR: 215>, <TokenType.DYNAMIC: 216>, <TokenType.VOID: 217>, <TokenType.ALL: 220>, <TokenType.ANTI: 221>, <TokenType.ANY: 222>, <TokenType.APPLY: 223>, <TokenType.ARRAY: 224>, <TokenType.ASC: 225>, <TokenType.ASOF: 226>, <TokenType.ATTACH: 227>, <TokenType.AUTO_INCREMENT: 228>, <TokenType.BEGIN: 229>, <TokenType.CACHE: 232>, <TokenType.CASE: 233>, <TokenType.COLLATE: 236>, <TokenType.COMMAND: 237>, <TokenType.COMMENT: 238>, <TokenType.COMMIT: 239>, <TokenType.CONSTRAINT: 241>, <TokenType.COPY: 242>, <TokenType.CUBE: 245>, <TokenType.CURRENT_DATE: 246>, <TokenType.CURRENT_DATETIME: 247>, <TokenType.CURRENT_SCHEMA: 248>, <TokenType.CURRENT_TIME: 249>, <TokenType.CURRENT_TIMESTAMP: 250>, <TokenType.CURRENT_USER: 251>, <TokenType.CURRENT_ROLE: 253>, <TokenType.CURRENT_CATALOG: 254>, <TokenType.DECLARE: 255>, <TokenType.DEFAULT: 256>, <TokenType.DELETE: 257>, <TokenType.DESC: 258>, <TokenType.DESCRIBE: 259>, <TokenType.DETACH: 260>, <TokenType.DICTIONARY: 261>, <TokenType.DIV: 264>, <TokenType.END: 267>, <TokenType.ESCAPE: 268>, <TokenType.EXECUTE: 270>, <TokenType.EXISTS: 271>, <TokenType.FALSE: 272>, <TokenType.FILE: 274>, <TokenType.FILE_FORMAT: 275>, <TokenType.FILTER: 276>, <TokenType.FINAL: 277>, <TokenType.FIRST: 278>, <TokenType.FOREIGN_KEY: 281>, <TokenType.FULL: 284>, <TokenType.FUNCTION: 285>, <TokenType.GET: 286>, <TokenType.INDEX: 297>, <TokenType.INTERVAL: 304>, <TokenType.IS: 308>, <TokenType.ISNULL: 309>, <TokenType.KEEP: 312>, <TokenType.KILL: 314>, <TokenType.LEFT: 317>, <TokenType.LIMIT: 319>, <TokenType.LIST: 320>, <TokenType.LOAD: 321>, <TokenType.LOCK: 322>, <TokenType.MAP: 323>, <TokenType.MATCH: 324>, <TokenType.MERGE: 328>, <TokenType.MODEL: 330>, <TokenType.NATURAL: 331>, <TokenType.NEXT: 332>, <TokenType.NOTHING: 333>, <TokenType.NULL: 335>, <TokenType.OBJECT_IDENTIFIER: 336>, <TokenType.OFFSET: 337>, <TokenType.OPERATOR: 340>, <TokenType.ORDINALITY: 344>, <TokenType.OUT: 345>, <TokenType.INOUT: 346>, <TokenType.OVER: 348>, <TokenType.OVERLAPS: 349>, <TokenType.OVERWRITE: 350>, <TokenType.PARTITION: 352>, <TokenType.PERCENT: 354>, <TokenType.PIVOT: 355>, <TokenType.PRAGMA: 360>, <TokenType.PROCEDURE: 363>, <TokenType.PROJECTION: 365>, <TokenType.PSEUDO_TYPE: 366>, <TokenType.PUT: 367>, <TokenType.RANGE: 371>, <TokenType.RECURSIVE: 372>, <TokenType.REFRESH: 373>, <TokenType.RENAME: 374>, <TokenType.REPLACE: 375>, <TokenType.REFERENCES: 378>, <TokenType.RIGHT: 379>, <TokenType.ROLLUP: 383>, <TokenType.ROW: 384>, <TokenType.ROWS: 385>, <TokenType.SEMI: 388>, <TokenType.SEQUENCE: 390>, <TokenType.SET: 392>, <TokenType.SHOW: 394>, <TokenType.SOME: 396>, <TokenType.STORAGE_INTEGRATION: 401>, <TokenType.STRAIGHT_JOIN: 402>, <TokenType.STRUCT: 403>, <TokenType.TAG: 406>, <TokenType.TEMPORARY: 407>, <TokenType.TOP: 408>, <TokenType.TRUE: 410>, <TokenType.TRUNCATE: 411>, <TokenType.TRIGGER: 412>, <TokenType.TYPE: 413>, <TokenType.UNNEST: 417>, <TokenType.UNPIVOT: 418>, <TokenType.UPDATE: 419>, <TokenType.USE: 420>, <TokenType.VIEW: 424>, <TokenType.SEMANTIC_VIEW: 425>, <TokenType.VOLATILE: 426>, <TokenType.WINDOW: 430>, <TokenType.UNIQUE: 432>, <TokenType.SINK: 437>, <TokenType.SOURCE: 438>, <TokenType.ANALYZE: 439>, <TokenType.NAMESPACE: 440>, <TokenType.EXPORT: 441>}

LOG_DEFAULTS_TO_LN = True

QUERY_MODIFIER_PARSERS = {<TokenType.MATCH_RECOGNIZE: 326>: <function Parser.<lambda>>, <TokenType.PREWHERE: 361>: <function Parser.<lambda>>, <TokenType.WHERE: 429>: <function Parser.<lambda>>, <TokenType.GROUP_BY: 290>: <function Parser.<lambda>>, <TokenType.HAVING: 292>: <function Parser.<lambda>>, <TokenType.QUALIFY: 368>: <function Parser.<lambda>>, <TokenType.WINDOW: 430>: <function Parser.<lambda>>, <TokenType.ORDER_BY: 341>: <function Parser.<lambda>>, <TokenType.LIMIT: 319>: <function Parser.<lambda>>, <TokenType.FETCH: 273>: <function Parser.<lambda>>, <TokenType.OFFSET: 337>: <function Parser.<lambda>>, <TokenType.FOR: 279>: <function Parser.<lambda>>, <TokenType.LOCK: 322>: <function Parser.<lambda>>, <TokenType.TABLE_SAMPLE: 405>: <function Parser.<lambda>>, <TokenType.USING: 421>: <function Parser.<lambda>>, <TokenType.CLUSTER_BY: 235>: <function Parser.<lambda>>, <TokenType.DISTRIBUTE_BY: 263>: <function Parser.<lambda>>, <TokenType.SORT_BY: 397>: <function Parser.<lambda>>, <TokenType.CONNECT_BY: 240>: <function Parser.<lambda>>, <TokenType.SETTINGS: 393>: <function ClickHouseParser.<lambda>>, <TokenType.FORMAT: 282>: <function ClickHouseParser.<lambda>>}

CONSTRAINT_PARSERS = {'AUTOINCREMENT': <function Parser.<lambda>>, 'AUTO_INCREMENT': <function Parser.<lambda>>, 'CASESPECIFIC': <function Parser.<lambda>>, 'CHECK': <function Parser.<lambda>>, 'COLLATE': <function Parser.<lambda>>, 'COMMENT': <function Parser.<lambda>>, 'COMPRESS': <function Parser.<lambda>>, 'CLUSTERED': <function Parser.<lambda>>, 'NONCLUSTERED': <function Parser.<lambda>>, 'DEFAULT': <function Parser.<lambda>>, 'ENCODE': <function Parser.<lambda>>, 'EPHEMERAL': <function Parser.<lambda>>, 'EXCLUDE': <function Parser.<lambda>>, 'FOREIGN KEY': <function Parser.<lambda>>, 'FORMAT': <function Parser.<lambda>>, 'GENERATED': <function Parser.<lambda>>, 'IDENTITY': <function Parser.<lambda>>, 'INLINE': <function Parser.<lambda>>, 'LIKE': <function Parser.<lambda>>, 'NOT': <function Parser.<lambda>>, 'NULL': <function Parser.<lambda>>, 'ON': <function Parser.<lambda>>, 'PATH': <function Parser.<lambda>>, 'PERIOD': <function Parser.<lambda>>, 'PRIMARY KEY': <function Parser.<lambda>>, 'REFERENCES': <function Parser.<lambda>>, 'TITLE': <function Parser.<lambda>>, 'TTL': <function Parser.<lambda>>, 'UNIQUE': <function Parser.<lambda>>, 'UPPERCASE': <function Parser.<lambda>>, 'WITH': <function Parser.<lambda>>, 'BUCKET': <function Parser.<lambda>>, 'TRUNCATE': <function Parser.<lambda>>, 'INDEX': <function ClickHouseParser.<lambda>>, 'CODEC': <function ClickHouseParser.<lambda>>, 'ASSUME': <function ClickHouseParser.<lambda>>}

ALTER_PARSERS = {'ADD': <function Parser.<lambda>>, 'AS': <function Parser.<lambda>>, 'ALTER': <function Parser.<lambda>>, 'CLUSTER BY': <function Parser.<lambda>>, 'DELETE': <function Parser.<lambda>>, 'DROP': <function Parser.<lambda>>, 'RENAME': <function Parser.<lambda>>, 'SET': <function Parser.<lambda>>, 'SWAP': <function Parser.<lambda>>, 'MODIFY': <function ClickHouseParser.<lambda>>, 'REPLACE': <function ClickHouseParser.<lambda>>}

SCHEMA_UNNAMED_CONSTRAINTS = {'FOREIGN KEY', 'UNIQUE', 'PRIMARY KEY', 'TRUNCATE', 'EXCLUDE', 'PERIOD', 'INDEX', 'LIKE', 'BUCKET'}

PLACEHOLDER_PARSERS = {<TokenType.PLACEHOLDER: 356>: <function Parser.<lambda>>, <TokenType.PARAMETER: 58>: <function Parser.<lambda>>, <TokenType.COLON: 11>: <function Parser.<lambda>>, <TokenType.L_BRACE: 5>: <function ClickHouseParser.<lambda>>}

STATEMENT_PARSERS = {<TokenType.ALTER: 219>: <function Parser.<lambda>>, <TokenType.ANALYZE: 439>: <function Parser.<lambda>>, <TokenType.BEGIN: 229>: <function Parser.<lambda>>, <TokenType.CACHE: 232>: <function Parser.<lambda>>, <TokenType.COMMENT: 238>: <function Parser.<lambda>>, <TokenType.COMMIT: 239>: <function Parser.<lambda>>, <TokenType.COPY: 242>: <function Parser.<lambda>>, <TokenType.CREATE: 243>: <function Parser.<lambda>>, <TokenType.DECLARE: 255>: <function Parser.<lambda>>, <TokenType.DELETE: 257>: <function Parser.<lambda>>, <TokenType.DESC: 258>: <function Parser.<lambda>>, <TokenType.DESCRIBE: 259>: <function Parser.<lambda>>, <TokenType.DROP: 265>: <function Parser.<lambda>>, <TokenType.GRANT: 289>: <function Parser.<lambda>>, <TokenType.REVOKE: 377>: <function Parser.<lambda>>, <TokenType.INSERT: 300>: <function Parser.<lambda>>, <TokenType.KILL: 314>: <function Parser.<lambda>>, <TokenType.LOAD: 321>: <function Parser.<lambda>>, <TokenType.MERGE: 328>: <function Parser.<lambda>>, <TokenType.PIVOT: 355>: <function Parser.<lambda>>, <TokenType.PRAGMA: 360>: <function Parser.<lambda>>, <TokenType.REFRESH: 373>: <function Parser.<lambda>>, <TokenType.ROLLBACK: 382>: <function Parser.<lambda>>, <TokenType.SET: 392>: <function Parser.<lambda>>, <TokenType.TRUNCATE: 411>: <function Parser.<lambda>>, <TokenType.UNCACHE: 414>: <function Parser.<lambda>>, <TokenType.UNPIVOT: 418>: <function Parser.<lambda>>, <TokenType.UPDATE: 419>: <function Parser.<lambda>>, <TokenType.USE: 420>: <function Parser.<lambda>>, <TokenType.SEMICOLON: 19>: <function Parser.<lambda>>, <TokenType.DETACH: 260>: <function ClickHouseParser.<lambda>>}

Inherited Members

sqlglot.parser.Parser: Parser; STRUCT_TYPE_TOKENS; NESTED_TYPE_TOKENS; ENUM_TYPE_TOKENS; AGGREGATE_TYPE_TOKENS; TYPE_TOKENS; SIGNED_TO_UNSIGNED_TYPE_TOKEN; SUBQUERY_PREDICATES; SUBQUERY_TOKENS; TEXT_MATCH_EXCLUDED_TOKENS; DB_CREATABLES; CREATABLES; TRIGGER_EVENTS; ALTERABLES; COLON_PLACEHOLDER_TOKENS; ARRAY_CONSTRUCTORS; COMMENT_TABLE_ALIAS_TOKENS; UPDATE_ALIAS_TOKENS; TRIM_TYPES; IDENTIFIER_TOKENS; BRACKETS; COLUMN_POSTFIX_TOKENS; TABLE_POSTFIX_TOKENS; CONJUNCTION; ASSIGNMENT; DISJUNCTION; EQUALITY; COMPARISON; BITWISE; TERM; FACTOR; EXPONENT; TIMES; TIMESTAMPS; SET_OPERATIONS; JOIN_METHODS; JOIN_SIDES; JOIN_HINTS; TABLE_TERMINATORS; LAMBDAS; TYPED_LAMBDA_ARGS; LAMBDA_ARG_TERMINATORS; JSON_OPERATORS; CAST_COLUMN_OPERATORS; EXPRESSION_PARSERS; UNARY_PARSERS; STRING_PARSERS; NUMERIC_PARSERS; PRIMARY_PARSERS; PIPE_SYNTAX_TRANSFORM_PARSERS; ALTER_ALTER_PARSERS; INVALID_FUNC_NAME_TOKENS; FUNCTIONS_WITH_ALIASED_ARGS; KEY_VALUE_DEFINITIONS; QUERY_MODIFIER_TOKENS; SET_PARSERS; SHOW_PARSERS; TYPE_LITERAL_PARSERS; TYPE_CONVERTERS; DDL_SELECT_TOKENS; PRE_VOLATILE_TOKENS; TRANSACTION_KIND; TRANSACTION_CHARACTERISTICS; CONFLICT_ACTIONS; TRIGGER_TIMING; TRIGGER_DEFERRABLE; CREATE_SEQUENCE; ISOLATED_LOADING_OPTIONS; USABLES; CAST_ACTIONS; SCHEMA_BINDING_OPTIONS; PROCEDURE_OPTIONS; EXECUTE_AS_OPTIONS; KEY_CONSTRAINT_OPTIONS; WINDOW_EXCLUDE_OPTIONS; INSERT_ALTERNATIVES; CLONE_KEYWORDS; VERSION_PHRASES; HISTORICAL_DATA_PREFIX; HISTORICAL_DATA_KIND; OPCLASS_FOLLOW_KEYWORDS; OPTYPE_FOLLOW_TOKENS; TABLE_INDEX_HINT_TOKENS; VIEW_ATTRIBUTES; WINDOW_ALIAS_TOKENS; WINDOW_BEFORE_PAREN_TOKENS; WINDOW_SIDES; JSON_KEY_VALUE_SEPARATOR_TOKENS; FETCH_TOKENS; ADD_CONSTRAINT_TOKENS; DISTINCT_TOKENS; UNNEST_OFFSET_ALIAS_TOKENS; SELECT_START_TOKENS; COPY_INTO_VARLEN_OPTIONS; IS_JSON_PREDICATE_KIND; ODBC_DATETIME_LITERALS; ON_CONDITION_TOKENS; PRIVILEGE_FOLLOW_TOKENS; DESCRIBE_STYLES; SET_ASSIGNMENT_DELIMITERS; ANALYZE_STYLES; ANALYZE_EXPRESSION_PARSERS; PARTITION_KEYWORDS; AMBIGUOUS_ALIAS_TOKENS; OPERATION_MODIFIERS; RECURSIVE_CTE_SEARCH_KIND; SECURITY_PROPERTY_KEYWORDS; MODIFIABLES; STRICT_CAST; PREFIXED_PIVOT_COLUMNS; IDENTIFY_PIVOT_STRINGS; UNPIVOT_VALUE_COLUMNS_FIRST; PIVOT_COLUMN_NAMING; TABLESAMPLE_CSV; DEFAULT_SAMPLING_METHOD; SET_REQUIRES_ASSIGNMENT_DELIMITER; TRIM_PATTERN_FIRST; STRING_ALIASES; SET_OP_MODIFIERS; NO_PAREN_IF_COMMANDS; JSON_ARROWS_REQUIRE_JSON_TYPE; COLON_IS_VARIANT_EXTRACT; COLON_CHAIN_IS_SINGLE_EXTRACT; VALUES_FOLLOWED_BY_PAREN; SUPPORTS_IMPLICIT_UNNEST; SUPPORTS_PARTITION_SELECTION; WRAPPED_TRANSFORM_COLUMN_CONSTRAINT; ALTER_RENAME_REQUIRES_COLUMN; ALTER_TABLE_PARTITIONS; ZONE_AWARE_TIMESTAMP_CONSTRUCTOR; MAP_KEYS_ARE_ARBITRARY_EXPRESSIONS; JSON_EXTRACT_REQUIRES_JSON_EXPRESSION; ADD_JOIN_ON_TRUE; SUPPORTS_OMITTED_INTERVAL_SPAN_UNIT; ADJACENT_STRINGS_CANNOT_BE_CONNECTED; SHOW_TRIE; SET_TRIE; error_level; error_message_context; max_errors; max_nodes; dialect; sql; errors; reset; raise_error; validate_expression; parse; parse_into; check_errors; expression; parse_set_operation; build_cast