Edit on GitHub

sqlglot.dialects.clickhouse

   1from __future__ import annotations
   2
   3import typing as t
   4
   5from sqlglot import exp, generator, parser, tokens
   6from sqlglot.dialects.dialect import (
   7    Dialect,
   8    NormalizationStrategy,
   9    arg_max_or_min_no_count,
  10    build_date_delta,
  11    build_formatted_time,
  12    inline_array_sql,
  13    json_extract_segments,
  14    json_path_key_only_name,
  15    no_pivot_sql,
  16    build_json_extract_path,
  17    rename_func,
  18    sha256_sql,
  19    var_map_sql,
  20    timestamptrunc_sql,
  21    unit_to_var,
  22)
  23from sqlglot.generator import Generator
  24from sqlglot.helper import is_int, seq_get
  25from sqlglot.tokens import Token, TokenType
  26
  27DATEΤΙΜΕ_DELTA = t.Union[exp.DateAdd, exp.DateDiff, exp.DateSub, exp.TimestampSub, exp.TimestampAdd]
  28
  29
  30def _build_date_format(args: t.List) -> exp.TimeToStr:
  31    expr = build_formatted_time(exp.TimeToStr, "clickhouse")(args)
  32
  33    timezone = seq_get(args, 2)
  34    if timezone:
  35        expr.set("timezone", timezone)
  36
  37    return expr
  38
  39
  40def _unix_to_time_sql(self: ClickHouse.Generator, expression: exp.UnixToTime) -> str:
  41    scale = expression.args.get("scale")
  42    timestamp = expression.this
  43
  44    if scale in (None, exp.UnixToTime.SECONDS):
  45        return self.func("fromUnixTimestamp", exp.cast(timestamp, exp.DataType.Type.BIGINT))
  46    if scale == exp.UnixToTime.MILLIS:
  47        return self.func("fromUnixTimestamp64Milli", exp.cast(timestamp, exp.DataType.Type.BIGINT))
  48    if scale == exp.UnixToTime.MICROS:
  49        return self.func("fromUnixTimestamp64Micro", exp.cast(timestamp, exp.DataType.Type.BIGINT))
  50    if scale == exp.UnixToTime.NANOS:
  51        return self.func("fromUnixTimestamp64Nano", exp.cast(timestamp, exp.DataType.Type.BIGINT))
  52
  53    return self.func(
  54        "fromUnixTimestamp",
  55        exp.cast(
  56            exp.Div(this=timestamp, expression=exp.func("POW", 10, scale)), exp.DataType.Type.BIGINT
  57        ),
  58    )
  59
  60
  61def _lower_func(sql: str) -> str:
  62    index = sql.index("(")
  63    return sql[:index].lower() + sql[index:]
  64
  65
  66def _quantile_sql(self: ClickHouse.Generator, expression: exp.Quantile) -> str:
  67    quantile = expression.args["quantile"]
  68    args = f"({self.sql(expression, 'this')})"
  69
  70    if isinstance(quantile, exp.Array):
  71        func = self.func("quantiles", *quantile)
  72    else:
  73        func = self.func("quantile", quantile)
  74
  75    return func + args
  76
  77
  78def _build_count_if(args: t.List) -> exp.CountIf | exp.CombinedAggFunc:
  79    if len(args) == 1:
  80        return exp.CountIf(this=seq_get(args, 0))
  81
  82    return exp.CombinedAggFunc(this="countIf", expressions=args, parts=("count", "If"))
  83
  84
  85def _build_str_to_date(args: t.List) -> exp.Cast | exp.Anonymous:
  86    if len(args) == 3:
  87        return exp.Anonymous(this="STR_TO_DATE", expressions=args)
  88
  89    strtodate = exp.StrToDate.from_arg_list(args)
  90    return exp.cast(strtodate, exp.DataType.build(exp.DataType.Type.DATETIME))
  91
  92
  93def _datetime_delta_sql(name: str) -> t.Callable[[Generator, DATEΤΙΜΕ_DELTA], str]:
  94    def _delta_sql(self: Generator, expression: DATEΤΙΜΕ_DELTA) -> str:
  95        if not expression.unit:
  96            return rename_func(name)(self, expression)
  97
  98        return self.func(
  99            name,
 100            unit_to_var(expression),
 101            expression.expression,
 102            expression.this,
 103        )
 104
 105    return _delta_sql
 106
 107
 108class ClickHouse(Dialect):
 109    NORMALIZE_FUNCTIONS: bool | str = False
 110    NULL_ORDERING = "nulls_are_last"
 111    SUPPORTS_USER_DEFINED_TYPES = False
 112    SAFE_DIVISION = True
 113    LOG_BASE_FIRST: t.Optional[bool] = None
 114    FORCE_EARLY_ALIAS_REF_EXPANSION = True
 115
 116    # https://github.com/ClickHouse/ClickHouse/issues/33935#issue-1112165779
 117    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_SENSITIVE
 118
 119    UNESCAPED_SEQUENCES = {
 120        "\\0": "\0",
 121    }
 122
 123    class Tokenizer(tokens.Tokenizer):
 124        COMMENTS = ["--", "#", "#!", ("/*", "*/")]
 125        IDENTIFIERS = ['"', "`"]
 126        STRING_ESCAPES = ["'", "\\"]
 127        BIT_STRINGS = [("0b", "")]
 128        HEX_STRINGS = [("0x", ""), ("0X", "")]
 129        HEREDOC_STRINGS = ["$"]
 130
 131        KEYWORDS = {
 132            **tokens.Tokenizer.KEYWORDS,
 133            "ATTACH": TokenType.COMMAND,
 134            "DATE32": TokenType.DATE32,
 135            "DATETIME64": TokenType.DATETIME64,
 136            "DICTIONARY": TokenType.DICTIONARY,
 137            "ENUM8": TokenType.ENUM8,
 138            "ENUM16": TokenType.ENUM16,
 139            "FINAL": TokenType.FINAL,
 140            "FIXEDSTRING": TokenType.FIXEDSTRING,
 141            "FLOAT32": TokenType.FLOAT,
 142            "FLOAT64": TokenType.DOUBLE,
 143            "GLOBAL": TokenType.GLOBAL,
 144            "INT256": TokenType.INT256,
 145            "LOWCARDINALITY": TokenType.LOWCARDINALITY,
 146            "MAP": TokenType.MAP,
 147            "NESTED": TokenType.NESTED,
 148            "SAMPLE": TokenType.TABLE_SAMPLE,
 149            "TUPLE": TokenType.STRUCT,
 150            "UINT128": TokenType.UINT128,
 151            "UINT16": TokenType.USMALLINT,
 152            "UINT256": TokenType.UINT256,
 153            "UINT32": TokenType.UINT,
 154            "UINT64": TokenType.UBIGINT,
 155            "UINT8": TokenType.UTINYINT,
 156            "IPV4": TokenType.IPV4,
 157            "IPV6": TokenType.IPV6,
 158            "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION,
 159            "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION,
 160            "SYSTEM": TokenType.COMMAND,
 161            "PREWHERE": TokenType.PREWHERE,
 162        }
 163        KEYWORDS.pop("/*+")
 164
 165        SINGLE_TOKENS = {
 166            **tokens.Tokenizer.SINGLE_TOKENS,
 167            "$": TokenType.HEREDOC_STRING,
 168        }
 169
 170    class Parser(parser.Parser):
 171        # Tested in ClickHouse's playground, it seems that the following two queries do the same thing
 172        # * select x from t1 union all select x from t2 limit 1;
 173        # * select x from t1 union all (select x from t2 limit 1);
 174        MODIFIERS_ATTACHED_TO_SET_OP = False
 175        INTERVAL_SPANS = False
 176
 177        FUNCTIONS = {
 178            **parser.Parser.FUNCTIONS,
 179            "ANY": exp.AnyValue.from_arg_list,
 180            "ARRAYSUM": exp.ArraySum.from_arg_list,
 181            "COUNTIF": _build_count_if,
 182            "DATE_ADD": build_date_delta(exp.DateAdd, default_unit=None),
 183            "DATEADD": build_date_delta(exp.DateAdd, default_unit=None),
 184            "DATE_DIFF": build_date_delta(exp.DateDiff, default_unit=None),
 185            "DATEDIFF": build_date_delta(exp.DateDiff, default_unit=None),
 186            "DATE_FORMAT": _build_date_format,
 187            "DATE_SUB": build_date_delta(exp.DateSub, default_unit=None),
 188            "DATESUB": build_date_delta(exp.DateSub, default_unit=None),
 189            "FORMATDATETIME": _build_date_format,
 190            "JSONEXTRACTSTRING": build_json_extract_path(
 191                exp.JSONExtractScalar, zero_based_indexing=False
 192            ),
 193            "MAP": parser.build_var_map,
 194            "MATCH": exp.RegexpLike.from_arg_list,
 195            "RANDCANONICAL": exp.Rand.from_arg_list,
 196            "STR_TO_DATE": _build_str_to_date,
 197            "TUPLE": exp.Struct.from_arg_list,
 198            "TIMESTAMP_SUB": build_date_delta(exp.TimestampSub, default_unit=None),
 199            "TIMESTAMPSUB": build_date_delta(exp.TimestampSub, default_unit=None),
 200            "TIMESTAMP_ADD": build_date_delta(exp.TimestampAdd, default_unit=None),
 201            "TIMESTAMPADD": build_date_delta(exp.TimestampAdd, default_unit=None),
 202            "UNIQ": exp.ApproxDistinct.from_arg_list,
 203            "XOR": lambda args: exp.Xor(expressions=args),
 204            "MD5": exp.MD5Digest.from_arg_list,
 205            "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
 206            "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
 207        }
 208
 209        AGG_FUNCTIONS = {
 210            "count",
 211            "min",
 212            "max",
 213            "sum",
 214            "avg",
 215            "any",
 216            "stddevPop",
 217            "stddevSamp",
 218            "varPop",
 219            "varSamp",
 220            "corr",
 221            "covarPop",
 222            "covarSamp",
 223            "entropy",
 224            "exponentialMovingAverage",
 225            "intervalLengthSum",
 226            "kolmogorovSmirnovTest",
 227            "mannWhitneyUTest",
 228            "median",
 229            "rankCorr",
 230            "sumKahan",
 231            "studentTTest",
 232            "welchTTest",
 233            "anyHeavy",
 234            "anyLast",
 235            "boundingRatio",
 236            "first_value",
 237            "last_value",
 238            "argMin",
 239            "argMax",
 240            "avgWeighted",
 241            "topK",
 242            "topKWeighted",
 243            "deltaSum",
 244            "deltaSumTimestamp",
 245            "groupArray",
 246            "groupArrayLast",
 247            "groupUniqArray",
 248            "groupArrayInsertAt",
 249            "groupArrayMovingAvg",
 250            "groupArrayMovingSum",
 251            "groupArraySample",
 252            "groupBitAnd",
 253            "groupBitOr",
 254            "groupBitXor",
 255            "groupBitmap",
 256            "groupBitmapAnd",
 257            "groupBitmapOr",
 258            "groupBitmapXor",
 259            "sumWithOverflow",
 260            "sumMap",
 261            "minMap",
 262            "maxMap",
 263            "skewSamp",
 264            "skewPop",
 265            "kurtSamp",
 266            "kurtPop",
 267            "uniq",
 268            "uniqExact",
 269            "uniqCombined",
 270            "uniqCombined64",
 271            "uniqHLL12",
 272            "uniqTheta",
 273            "quantile",
 274            "quantiles",
 275            "quantileExact",
 276            "quantilesExact",
 277            "quantileExactLow",
 278            "quantilesExactLow",
 279            "quantileExactHigh",
 280            "quantilesExactHigh",
 281            "quantileExactWeighted",
 282            "quantilesExactWeighted",
 283            "quantileTiming",
 284            "quantilesTiming",
 285            "quantileTimingWeighted",
 286            "quantilesTimingWeighted",
 287            "quantileDeterministic",
 288            "quantilesDeterministic",
 289            "quantileTDigest",
 290            "quantilesTDigest",
 291            "quantileTDigestWeighted",
 292            "quantilesTDigestWeighted",
 293            "quantileBFloat16",
 294            "quantilesBFloat16",
 295            "quantileBFloat16Weighted",
 296            "quantilesBFloat16Weighted",
 297            "simpleLinearRegression",
 298            "stochasticLinearRegression",
 299            "stochasticLogisticRegression",
 300            "categoricalInformationValue",
 301            "contingency",
 302            "cramersV",
 303            "cramersVBiasCorrected",
 304            "theilsU",
 305            "maxIntersections",
 306            "maxIntersectionsPosition",
 307            "meanZTest",
 308            "quantileInterpolatedWeighted",
 309            "quantilesInterpolatedWeighted",
 310            "quantileGK",
 311            "quantilesGK",
 312            "sparkBar",
 313            "sumCount",
 314            "largestTriangleThreeBuckets",
 315            "histogram",
 316            "sequenceMatch",
 317            "sequenceCount",
 318            "windowFunnel",
 319            "retention",
 320            "uniqUpTo",
 321            "sequenceNextNode",
 322            "exponentialTimeDecayedAvg",
 323        }
 324
 325        AGG_FUNCTIONS_SUFFIXES = [
 326            "If",
 327            "Array",
 328            "ArrayIf",
 329            "Map",
 330            "SimpleState",
 331            "State",
 332            "Merge",
 333            "MergeState",
 334            "ForEach",
 335            "Distinct",
 336            "OrDefault",
 337            "OrNull",
 338            "Resample",
 339            "ArgMin",
 340            "ArgMax",
 341        ]
 342
 343        FUNC_TOKENS = {
 344            *parser.Parser.FUNC_TOKENS,
 345            TokenType.SET,
 346        }
 347
 348        RESERVED_TOKENS = parser.Parser.RESERVED_TOKENS - {TokenType.SELECT}
 349
 350        ID_VAR_TOKENS = {
 351            *parser.Parser.ID_VAR_TOKENS,
 352            TokenType.LIKE,
 353        }
 354
 355        AGG_FUNC_MAPPING = (
 356            lambda functions, suffixes: {
 357                f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions
 358            }
 359        )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES)
 360
 361        FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"}
 362
 363        FUNCTION_PARSERS = {
 364            **parser.Parser.FUNCTION_PARSERS,
 365            "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()),
 366            "QUANTILE": lambda self: self._parse_quantile(),
 367        }
 368
 369        FUNCTION_PARSERS.pop("MATCH")
 370
 371        NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy()
 372        NO_PAREN_FUNCTION_PARSERS.pop("ANY")
 373
 374        RANGE_PARSERS = {
 375            **parser.Parser.RANGE_PARSERS,
 376            TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN)
 377            and self._parse_in(this, is_global=True),
 378        }
 379
 380        # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to
 381        # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler.
 382        COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy()
 383        COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
 384
 385        JOIN_KINDS = {
 386            *parser.Parser.JOIN_KINDS,
 387            TokenType.ANY,
 388            TokenType.ASOF,
 389            TokenType.ARRAY,
 390        }
 391
 392        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
 393            TokenType.ANY,
 394            TokenType.ARRAY,
 395            TokenType.FINAL,
 396            TokenType.FORMAT,
 397            TokenType.SETTINGS,
 398        }
 399
 400        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
 401            TokenType.FORMAT,
 402        }
 403
 404        LOG_DEFAULTS_TO_LN = True
 405
 406        QUERY_MODIFIER_PARSERS = {
 407            **parser.Parser.QUERY_MODIFIER_PARSERS,
 408            TokenType.SETTINGS: lambda self: (
 409                "settings",
 410                self._advance() or self._parse_csv(self._parse_assignment),
 411            ),
 412            TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
 413        }
 414
 415        CONSTRAINT_PARSERS = {
 416            **parser.Parser.CONSTRAINT_PARSERS,
 417            "INDEX": lambda self: self._parse_index_constraint(),
 418            "CODEC": lambda self: self._parse_compress(),
 419        }
 420
 421        ALTER_PARSERS = {
 422            **parser.Parser.ALTER_PARSERS,
 423            "REPLACE": lambda self: self._parse_alter_table_replace(),
 424        }
 425
 426        SCHEMA_UNNAMED_CONSTRAINTS = {
 427            *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
 428            "INDEX",
 429        }
 430
 431        def _parse_create(self) -> exp.Create | exp.Command:
 432            create = super()._parse_create()
 433
 434            # DATABASE in ClickHouse is the same as SCHEMA in other dialects
 435            if isinstance(create, exp.Create) and create.kind == "DATABASE":
 436                create.set("kind", "SCHEMA")
 437
 438            return create
 439
 440        def _parse_extract(self) -> exp.Extract | exp.Anonymous:
 441            index = self._index
 442            this = self._parse_bitwise()
 443            if self._match(TokenType.FROM):
 444                self._retreat(index)
 445                return super()._parse_extract()
 446
 447            # We return Anonymous here because extract and regexpExtract have different semantics,
 448            # so parsing extract(foo, bar) into RegexpExtract can potentially break queries. E.g.,
 449            # `extract('foobar', 'b')` works, but ClickHouse crashes for `regexpExtract('foobar', 'b')`.
 450            #
 451            # TODO: can we somehow convert the former into an equivalent `regexpExtract` call?
 452            self._match(TokenType.COMMA)
 453            return self.expression(
 454                exp.Anonymous, this="extract", expressions=[this, self._parse_bitwise()]
 455            )
 456
 457        def _parse_assignment(self) -> t.Optional[exp.Expression]:
 458            this = super()._parse_assignment()
 459
 460            if self._match(TokenType.PLACEHOLDER):
 461                return self.expression(
 462                    exp.If,
 463                    this=this,
 464                    true=self._parse_assignment(),
 465                    false=self._match(TokenType.COLON) and self._parse_assignment(),
 466                )
 467
 468            return this
 469
 470        def _parse_placeholder(self) -> t.Optional[exp.Expression]:
 471            """
 472            Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
 473            https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
 474            """
 475            if not self._match(TokenType.L_BRACE):
 476                return None
 477
 478            this = self._parse_id_var()
 479            self._match(TokenType.COLON)
 480            kind = self._parse_types(check_func=False, allow_identifiers=False) or (
 481                self._match_text_seq("IDENTIFIER") and "Identifier"
 482            )
 483
 484            if not kind:
 485                self.raise_error("Expecting a placeholder type or 'Identifier' for tables")
 486            elif not self._match(TokenType.R_BRACE):
 487                self.raise_error("Expecting }")
 488
 489            return self.expression(exp.Placeholder, this=this, kind=kind)
 490
 491        def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In:
 492            this = super()._parse_in(this)
 493            this.set("is_global", is_global)
 494            return this
 495
 496        def _parse_table(
 497            self,
 498            schema: bool = False,
 499            joins: bool = False,
 500            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
 501            parse_bracket: bool = False,
 502            is_db_reference: bool = False,
 503            parse_partition: bool = False,
 504        ) -> t.Optional[exp.Expression]:
 505            this = super()._parse_table(
 506                schema=schema,
 507                joins=joins,
 508                alias_tokens=alias_tokens,
 509                parse_bracket=parse_bracket,
 510                is_db_reference=is_db_reference,
 511            )
 512
 513            if self._match(TokenType.FINAL):
 514                this = self.expression(exp.Final, this=this)
 515
 516            return this
 517
 518        def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
 519            return super()._parse_position(haystack_first=True)
 520
 521        # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
 522        def _parse_cte(self) -> exp.CTE:
 523            # WITH <identifier> AS <subquery expression>
 524            cte: t.Optional[exp.CTE] = self._try_parse(super()._parse_cte)
 525
 526            if not cte:
 527                # WITH <expression> AS <identifier>
 528                cte = self.expression(
 529                    exp.CTE,
 530                    this=self._parse_assignment(),
 531                    alias=self._parse_table_alias(),
 532                    scalar=True,
 533                )
 534
 535            return cte
 536
 537        def _parse_join_parts(
 538            self,
 539        ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
 540            is_global = self._match(TokenType.GLOBAL) and self._prev
 541            kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev
 542
 543            if kind_pre:
 544                kind = self._match_set(self.JOIN_KINDS) and self._prev
 545                side = self._match_set(self.JOIN_SIDES) and self._prev
 546                return is_global, side, kind
 547
 548            return (
 549                is_global,
 550                self._match_set(self.JOIN_SIDES) and self._prev,
 551                self._match_set(self.JOIN_KINDS) and self._prev,
 552            )
 553
 554        def _parse_join(
 555            self, skip_join_token: bool = False, parse_bracket: bool = False
 556        ) -> t.Optional[exp.Join]:
 557            join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True)
 558            if join:
 559                join.set("global", join.args.pop("method", None))
 560
 561            return join
 562
 563        def _parse_function(
 564            self,
 565            functions: t.Optional[t.Dict[str, t.Callable]] = None,
 566            anonymous: bool = False,
 567            optional_parens: bool = True,
 568            any_token: bool = False,
 569        ) -> t.Optional[exp.Expression]:
 570            expr = super()._parse_function(
 571                functions=functions,
 572                anonymous=anonymous,
 573                optional_parens=optional_parens,
 574                any_token=any_token,
 575            )
 576
 577            func = expr.this if isinstance(expr, exp.Window) else expr
 578
 579            # Aggregate functions can be split in 2 parts: <func_name><suffix>
 580            parts = (
 581                self.AGG_FUNC_MAPPING.get(func.this) if isinstance(func, exp.Anonymous) else None
 582            )
 583
 584            if parts:
 585                params = self._parse_func_params(func)
 586
 587                kwargs = {
 588                    "this": func.this,
 589                    "expressions": func.expressions,
 590                }
 591                if parts[1]:
 592                    kwargs["parts"] = parts
 593                    exp_class = exp.CombinedParameterizedAgg if params else exp.CombinedAggFunc
 594                else:
 595                    exp_class = exp.ParameterizedAgg if params else exp.AnonymousAggFunc
 596
 597                kwargs["exp_class"] = exp_class
 598                if params:
 599                    kwargs["params"] = params
 600
 601                func = self.expression(**kwargs)
 602
 603                if isinstance(expr, exp.Window):
 604                    # The window's func was parsed as Anonymous in base parser, fix its
 605                    # type to be ClickHouse style CombinedAnonymousAggFunc / AnonymousAggFunc
 606                    expr.set("this", func)
 607                elif params:
 608                    # Params have blocked super()._parse_function() from parsing the following window
 609                    # (if that exists) as they're standing between the function call and the window spec
 610                    expr = self._parse_window(func)
 611                else:
 612                    expr = func
 613
 614            return expr
 615
 616        def _parse_func_params(
 617            self, this: t.Optional[exp.Func] = None
 618        ) -> t.Optional[t.List[exp.Expression]]:
 619            if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
 620                return self._parse_csv(self._parse_lambda)
 621
 622            if self._match(TokenType.L_PAREN):
 623                params = self._parse_csv(self._parse_lambda)
 624                self._match_r_paren(this)
 625                return params
 626
 627            return None
 628
 629        def _parse_quantile(self) -> exp.Quantile:
 630            this = self._parse_lambda()
 631            params = self._parse_func_params()
 632            if params:
 633                return self.expression(exp.Quantile, this=params[0], quantile=this)
 634            return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5))
 635
 636        def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
 637            return super()._parse_wrapped_id_vars(optional=True)
 638
 639        def _parse_primary_key(
 640            self, wrapped_optional: bool = False, in_props: bool = False
 641        ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
 642            return super()._parse_primary_key(
 643                wrapped_optional=wrapped_optional or in_props, in_props=in_props
 644            )
 645
 646        def _parse_on_property(self) -> t.Optional[exp.Expression]:
 647            index = self._index
 648            if self._match_text_seq("CLUSTER"):
 649                this = self._parse_id_var()
 650                if this:
 651                    return self.expression(exp.OnCluster, this=this)
 652                else:
 653                    self._retreat(index)
 654            return None
 655
 656        def _parse_index_constraint(
 657            self, kind: t.Optional[str] = None
 658        ) -> exp.IndexColumnConstraint:
 659            # INDEX name1 expr TYPE type1(args) GRANULARITY value
 660            this = self._parse_id_var()
 661            expression = self._parse_assignment()
 662
 663            index_type = self._match_text_seq("TYPE") and (
 664                self._parse_function() or self._parse_var()
 665            )
 666
 667            granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
 668
 669            return self.expression(
 670                exp.IndexColumnConstraint,
 671                this=this,
 672                expression=expression,
 673                index_type=index_type,
 674                granularity=granularity,
 675            )
 676
 677        def _parse_partition(self) -> t.Optional[exp.Partition]:
 678            # https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#how-to-set-partition-expression
 679            if not self._match(TokenType.PARTITION):
 680                return None
 681
 682            if self._match_text_seq("ID"):
 683                # Corresponds to the PARTITION ID <string_value> syntax
 684                expressions: t.List[exp.Expression] = [
 685                    self.expression(exp.PartitionId, this=self._parse_string())
 686                ]
 687            else:
 688                expressions = self._parse_expressions()
 689
 690            return self.expression(exp.Partition, expressions=expressions)
 691
 692        def _parse_alter_table_replace(self) -> t.Optional[exp.Expression]:
 693            partition = self._parse_partition()
 694
 695            if not partition or not self._match(TokenType.FROM):
 696                return None
 697
 698            return self.expression(
 699                exp.ReplacePartition, expression=partition, source=self._parse_table_parts()
 700            )
 701
 702        def _parse_projection_def(self) -> t.Optional[exp.ProjectionDef]:
 703            if not self._match_text_seq("PROJECTION"):
 704                return None
 705
 706            return self.expression(
 707                exp.ProjectionDef,
 708                this=self._parse_id_var(),
 709                expression=self._parse_wrapped(self._parse_statement),
 710            )
 711
 712        def _parse_constraint(self) -> t.Optional[exp.Expression]:
 713            return super()._parse_constraint() or self._parse_projection_def()
 714
 715    class Generator(generator.Generator):
 716        QUERY_HINTS = False
 717        STRUCT_DELIMITER = ("(", ")")
 718        NVL2_SUPPORTED = False
 719        TABLESAMPLE_REQUIRES_PARENS = False
 720        TABLESAMPLE_SIZE_IS_ROWS = False
 721        TABLESAMPLE_KEYWORDS = "SAMPLE"
 722        LAST_DAY_SUPPORTS_DATE_PART = False
 723        CAN_IMPLEMENT_ARRAY_ANY = True
 724        SUPPORTS_TO_NUMBER = False
 725        JOIN_HINTS = False
 726        TABLE_HINTS = False
 727        EXPLICIT_SET_OP = True
 728        GROUPINGS_SEP = ""
 729        SET_OP_MODIFIERS = False
 730        SUPPORTS_TABLE_ALIAS_COLUMNS = False
 731        VALUES_AS_TABLE = False
 732
 733        STRING_TYPE_MAPPING = {
 734            exp.DataType.Type.CHAR: "String",
 735            exp.DataType.Type.LONGBLOB: "String",
 736            exp.DataType.Type.LONGTEXT: "String",
 737            exp.DataType.Type.MEDIUMBLOB: "String",
 738            exp.DataType.Type.MEDIUMTEXT: "String",
 739            exp.DataType.Type.TINYBLOB: "String",
 740            exp.DataType.Type.TINYTEXT: "String",
 741            exp.DataType.Type.TEXT: "String",
 742            exp.DataType.Type.VARBINARY: "String",
 743            exp.DataType.Type.VARCHAR: "String",
 744        }
 745
 746        SUPPORTED_JSON_PATH_PARTS = {
 747            exp.JSONPathKey,
 748            exp.JSONPathRoot,
 749            exp.JSONPathSubscript,
 750        }
 751
 752        TYPE_MAPPING = {
 753            **generator.Generator.TYPE_MAPPING,
 754            **STRING_TYPE_MAPPING,
 755            exp.DataType.Type.ARRAY: "Array",
 756            exp.DataType.Type.BIGINT: "Int64",
 757            exp.DataType.Type.DATE32: "Date32",
 758            exp.DataType.Type.DATETIME64: "DateTime64",
 759            exp.DataType.Type.DOUBLE: "Float64",
 760            exp.DataType.Type.ENUM: "Enum",
 761            exp.DataType.Type.ENUM8: "Enum8",
 762            exp.DataType.Type.ENUM16: "Enum16",
 763            exp.DataType.Type.FIXEDSTRING: "FixedString",
 764            exp.DataType.Type.FLOAT: "Float32",
 765            exp.DataType.Type.INT: "Int32",
 766            exp.DataType.Type.MEDIUMINT: "Int32",
 767            exp.DataType.Type.INT128: "Int128",
 768            exp.DataType.Type.INT256: "Int256",
 769            exp.DataType.Type.LOWCARDINALITY: "LowCardinality",
 770            exp.DataType.Type.MAP: "Map",
 771            exp.DataType.Type.NESTED: "Nested",
 772            exp.DataType.Type.NULLABLE: "Nullable",
 773            exp.DataType.Type.SMALLINT: "Int16",
 774            exp.DataType.Type.STRUCT: "Tuple",
 775            exp.DataType.Type.TINYINT: "Int8",
 776            exp.DataType.Type.UBIGINT: "UInt64",
 777            exp.DataType.Type.UINT: "UInt32",
 778            exp.DataType.Type.UINT128: "UInt128",
 779            exp.DataType.Type.UINT256: "UInt256",
 780            exp.DataType.Type.USMALLINT: "UInt16",
 781            exp.DataType.Type.UTINYINT: "UInt8",
 782            exp.DataType.Type.IPV4: "IPv4",
 783            exp.DataType.Type.IPV6: "IPv6",
 784            exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction",
 785            exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction",
 786        }
 787
 788        TRANSFORMS = {
 789            **generator.Generator.TRANSFORMS,
 790            exp.AnyValue: rename_func("any"),
 791            exp.ApproxDistinct: rename_func("uniq"),
 792            exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this),
 793            exp.ArraySize: rename_func("LENGTH"),
 794            exp.ArraySum: rename_func("arraySum"),
 795            exp.ArgMax: arg_max_or_min_no_count("argMax"),
 796            exp.ArgMin: arg_max_or_min_no_count("argMin"),
 797            exp.Array: inline_array_sql,
 798            exp.CastToStrType: rename_func("CAST"),
 799            exp.CountIf: rename_func("countIf"),
 800            exp.CompressColumnConstraint: lambda self,
 801            e: f"CODEC({self.expressions(e, key='this', flat=True)})",
 802            exp.ComputedColumnConstraint: lambda self,
 803            e: f"{'MATERIALIZED' if e.args.get('persisted') else 'ALIAS'} {self.sql(e, 'this')}",
 804            exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"),
 805            exp.DateAdd: _datetime_delta_sql("DATE_ADD"),
 806            exp.DateDiff: _datetime_delta_sql("DATE_DIFF"),
 807            exp.DateStrToDate: rename_func("toDate"),
 808            exp.DateSub: _datetime_delta_sql("DATE_SUB"),
 809            exp.Explode: rename_func("arrayJoin"),
 810            exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL",
 811            exp.IsNan: rename_func("isNaN"),
 812            exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False),
 813            exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False),
 814            exp.JSONPathKey: json_path_key_only_name,
 815            exp.JSONPathRoot: lambda *_: "",
 816            exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)),
 817            exp.Nullif: rename_func("nullIf"),
 818            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
 819            exp.Pivot: no_pivot_sql,
 820            exp.Quantile: _quantile_sql,
 821            exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression),
 822            exp.Rand: rename_func("randCanonical"),
 823            exp.StartsWith: rename_func("startsWith"),
 824            exp.StrPosition: lambda self, e: self.func(
 825                "position", e.this, e.args.get("substr"), e.args.get("position")
 826            ),
 827            exp.TimeToStr: lambda self, e: self.func(
 828                "DATE_FORMAT", e.this, self.format_time(e), e.args.get("timezone")
 829            ),
 830            exp.TimestampAdd: _datetime_delta_sql("TIMESTAMP_ADD"),
 831            exp.TimestampSub: _datetime_delta_sql("TIMESTAMP_SUB"),
 832            exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)),
 833            exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions),
 834            exp.MD5Digest: rename_func("MD5"),
 835            exp.MD5: lambda self, e: self.func("LOWER", self.func("HEX", self.func("MD5", e.this))),
 836            exp.SHA: rename_func("SHA1"),
 837            exp.SHA2: sha256_sql,
 838            exp.UnixToTime: _unix_to_time_sql,
 839            exp.TimestampTrunc: timestamptrunc_sql(zone=True),
 840            exp.Variance: rename_func("varSamp"),
 841            exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
 842            exp.Stddev: rename_func("stddevSamp"),
 843        }
 844
 845        PROPERTIES_LOCATION = {
 846            **generator.Generator.PROPERTIES_LOCATION,
 847            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
 848            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
 849            exp.OnCluster: exp.Properties.Location.POST_NAME,
 850        }
 851
 852        # there's no list in docs, but it can be found in Clickhouse code
 853        # see `ClickHouse/src/Parsers/ParserCreate*.cpp`
 854        ON_CLUSTER_TARGETS = {
 855            "DATABASE",
 856            "TABLE",
 857            "VIEW",
 858            "DICTIONARY",
 859            "INDEX",
 860            "FUNCTION",
 861            "NAMED COLLECTION",
 862        }
 863
 864        # https://github.com/ClickHouse/ClickHouse/blob/275de04b8f6bb8c9334bf8070001afe2dab0b17d/src/Functions/FunctionsConversion.cpp#L2939-L2989
 865        TRY_CAST_TYPES = {
 866            "DATE",
 867            "DATE32",
 868            "DATETIME",
 869            "DATETIME64",
 870            "DECIMAL32",
 871            "DECIMAL64",
 872            "DECIMAL128",
 873            "DECIMAL256",
 874            "FLOAT32",
 875            "FLOAT64",
 876            "INT8",
 877            "INT16",
 878            "INT32",
 879            "INT64",
 880            "INT128",
 881            "INT256",
 882            "IPV4",
 883            "IPV6",
 884            "UINT8",
 885            "UINT16",
 886            "UINT32",
 887            "UINT64",
 888            "UINT128",
 889            "UINT256",
 890            "UUID",
 891        }
 892
 893        def strtodate_sql(self, expression: exp.StrToDate) -> str:
 894            strtodate_sql = self.function_fallback_sql(expression)
 895
 896            if not isinstance(expression.parent, exp.Cast):
 897                # StrToDate returns DATEs in other dialects (eg. postgres), so
 898                # this branch aims to improve the transpilation to clickhouse
 899                return f"CAST({strtodate_sql} AS DATE)"
 900
 901            return strtodate_sql
 902
 903        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
 904            this = expression.this
 905
 906            if isinstance(this, exp.StrToDate) and expression.to == exp.DataType.build("datetime"):
 907                return self.sql(this)
 908
 909            return super().cast_sql(expression, safe_prefix=safe_prefix)
 910
 911        def trycast_sql(self, expression: exp.TryCast) -> str:
 912            target_type = self.sql(expression.to)
 913            if target_type.upper() in self.TRY_CAST_TYPES:
 914                return self.func(f"to{target_type}OrNull", expression.this)
 915
 916            self.unsupported(f"There is no `to<Type>OrNull` for type {target_type}.")
 917            return super().cast_sql(expression)
 918
 919        def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str:
 920            this = self.json_path_part(expression.this)
 921            return str(int(this) + 1) if is_int(this) else this
 922
 923        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
 924            return f"AS {self.sql(expression, 'this')}"
 925
 926        def _any_to_has(
 927            self,
 928            expression: exp.EQ | exp.NEQ,
 929            default: t.Callable[[t.Any], str],
 930            prefix: str = "",
 931        ) -> str:
 932            if isinstance(expression.left, exp.Any):
 933                arr = expression.left
 934                this = expression.right
 935            elif isinstance(expression.right, exp.Any):
 936                arr = expression.right
 937                this = expression.left
 938            else:
 939                return default(expression)
 940
 941            return prefix + self.func("has", arr.this.unnest(), this)
 942
 943        def eq_sql(self, expression: exp.EQ) -> str:
 944            return self._any_to_has(expression, super().eq_sql)
 945
 946        def neq_sql(self, expression: exp.NEQ) -> str:
 947            return self._any_to_has(expression, super().neq_sql, "NOT ")
 948
 949        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
 950            # Manually add a flag to make the search case-insensitive
 951            regex = self.func("CONCAT", "'(?i)'", expression.expression)
 952            return self.func("match", expression.this, regex)
 953
 954        def datatype_sql(self, expression: exp.DataType) -> str:
 955            # String is the standard ClickHouse type, every other variant is just an alias.
 956            # Additionally, any supplied length parameter will be ignored.
 957            #
 958            # https://clickhouse.com/docs/en/sql-reference/data-types/string
 959            if expression.this in self.STRING_TYPE_MAPPING:
 960                return "String"
 961
 962            return super().datatype_sql(expression)
 963
 964        def cte_sql(self, expression: exp.CTE) -> str:
 965            if expression.args.get("scalar"):
 966                this = self.sql(expression, "this")
 967                alias = self.sql(expression, "alias")
 968                return f"{this} AS {alias}"
 969
 970            return super().cte_sql(expression)
 971
 972        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
 973            return super().after_limit_modifiers(expression) + [
 974                (
 975                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
 976                    if expression.args.get("settings")
 977                    else ""
 978                ),
 979                (
 980                    self.seg("FORMAT ") + self.sql(expression, "format")
 981                    if expression.args.get("format")
 982                    else ""
 983                ),
 984            ]
 985
 986        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
 987            params = self.expressions(expression, key="params", flat=True)
 988            return self.func(expression.name, *expression.expressions) + f"({params})"
 989
 990        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
 991            return self.func(expression.name, *expression.expressions)
 992
 993        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
 994            return self.anonymousaggfunc_sql(expression)
 995
 996        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
 997            return self.parameterizedagg_sql(expression)
 998
 999        def placeholder_sql(self, expression: exp.Placeholder) -> str:
1000            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
1001
1002        def oncluster_sql(self, expression: exp.OnCluster) -> str:
1003            return f"ON CLUSTER {self.sql(expression, 'this')}"
1004
1005        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
1006            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
1007                exp.Properties.Location.POST_NAME
1008            ):
1009                this_name = self.sql(
1010                    expression.this if isinstance(expression.this, exp.Schema) else expression,
1011                    "this",
1012                )
1013                this_properties = " ".join(
1014                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
1015                )
1016                this_schema = self.schema_columns_sql(expression.this)
1017                return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}"
1018
1019            return super().createable_sql(expression, locations)
1020
1021        def create_sql(self, expression: exp.Create) -> str:
1022            # The comment property comes last in CTAS statements, i.e. after the query
1023            query = expression.expression
1024            if isinstance(query, exp.Query):
1025                comment_prop = expression.find(exp.SchemaCommentProperty)
1026                if comment_prop:
1027                    comment_prop.pop()
1028                    query.replace(exp.paren(query))
1029            else:
1030                comment_prop = None
1031
1032            # ClickHouse only has DATABASEs and objects under them, eg. TABLEs, VIEWs, etc
1033            if expression.kind == "SCHEMA":
1034                expression.set("kind", "DATABASE")
1035
1036            create_sql = super().create_sql(expression)
1037
1038            comment_sql = self.sql(comment_prop)
1039            comment_sql = f" {comment_sql}" if comment_sql else ""
1040
1041            return f"{create_sql}{comment_sql}"
1042
1043        def prewhere_sql(self, expression: exp.PreWhere) -> str:
1044            this = self.indent(self.sql(expression, "this"))
1045            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
1046
1047        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
1048            this = self.sql(expression, "this")
1049            this = f" {this}" if this else ""
1050            expr = self.sql(expression, "expression")
1051            expr = f" {expr}" if expr else ""
1052            index_type = self.sql(expression, "index_type")
1053            index_type = f" TYPE {index_type}" if index_type else ""
1054            granularity = self.sql(expression, "granularity")
1055            granularity = f" GRANULARITY {granularity}" if granularity else ""
1056
1057            return f"INDEX{this}{expr}{index_type}{granularity}"
1058
1059        def partition_sql(self, expression: exp.Partition) -> str:
1060            return f"PARTITION {self.expressions(expression, flat=True)}"
1061
1062        def partitionid_sql(self, expression: exp.PartitionId) -> str:
1063            return f"ID {self.sql(expression.this)}"
1064
1065        def replacepartition_sql(self, expression: exp.ReplacePartition) -> str:
1066            return (
1067                f"REPLACE {self.sql(expression.expression)} FROM {self.sql(expression, 'source')}"
1068            )
1069
1070        def projectiondef_sql(self, expression: exp.ProjectionDef) -> str:
1071            return f"PROJECTION {self.sql(expression.this)} {self.wrap(expression.expression)}"
class ClickHouse(sqlglot.dialects.dialect.Dialect):
 109class ClickHouse(Dialect):
 110    NORMALIZE_FUNCTIONS: bool | str = False
 111    NULL_ORDERING = "nulls_are_last"
 112    SUPPORTS_USER_DEFINED_TYPES = False
 113    SAFE_DIVISION = True
 114    LOG_BASE_FIRST: t.Optional[bool] = None
 115    FORCE_EARLY_ALIAS_REF_EXPANSION = True
 116
 117    # https://github.com/ClickHouse/ClickHouse/issues/33935#issue-1112165779
 118    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_SENSITIVE
 119
 120    UNESCAPED_SEQUENCES = {
 121        "\\0": "\0",
 122    }
 123
 124    class Tokenizer(tokens.Tokenizer):
 125        COMMENTS = ["--", "#", "#!", ("/*", "*/")]
 126        IDENTIFIERS = ['"', "`"]
 127        STRING_ESCAPES = ["'", "\\"]
 128        BIT_STRINGS = [("0b", "")]
 129        HEX_STRINGS = [("0x", ""), ("0X", "")]
 130        HEREDOC_STRINGS = ["$"]
 131
 132        KEYWORDS = {
 133            **tokens.Tokenizer.KEYWORDS,
 134            "ATTACH": TokenType.COMMAND,
 135            "DATE32": TokenType.DATE32,
 136            "DATETIME64": TokenType.DATETIME64,
 137            "DICTIONARY": TokenType.DICTIONARY,
 138            "ENUM8": TokenType.ENUM8,
 139            "ENUM16": TokenType.ENUM16,
 140            "FINAL": TokenType.FINAL,
 141            "FIXEDSTRING": TokenType.FIXEDSTRING,
 142            "FLOAT32": TokenType.FLOAT,
 143            "FLOAT64": TokenType.DOUBLE,
 144            "GLOBAL": TokenType.GLOBAL,
 145            "INT256": TokenType.INT256,
 146            "LOWCARDINALITY": TokenType.LOWCARDINALITY,
 147            "MAP": TokenType.MAP,
 148            "NESTED": TokenType.NESTED,
 149            "SAMPLE": TokenType.TABLE_SAMPLE,
 150            "TUPLE": TokenType.STRUCT,
 151            "UINT128": TokenType.UINT128,
 152            "UINT16": TokenType.USMALLINT,
 153            "UINT256": TokenType.UINT256,
 154            "UINT32": TokenType.UINT,
 155            "UINT64": TokenType.UBIGINT,
 156            "UINT8": TokenType.UTINYINT,
 157            "IPV4": TokenType.IPV4,
 158            "IPV6": TokenType.IPV6,
 159            "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION,
 160            "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION,
 161            "SYSTEM": TokenType.COMMAND,
 162            "PREWHERE": TokenType.PREWHERE,
 163        }
 164        KEYWORDS.pop("/*+")
 165
 166        SINGLE_TOKENS = {
 167            **tokens.Tokenizer.SINGLE_TOKENS,
 168            "$": TokenType.HEREDOC_STRING,
 169        }
 170
 171    class Parser(parser.Parser):
 172        # Tested in ClickHouse's playground, it seems that the following two queries do the same thing
 173        # * select x from t1 union all select x from t2 limit 1;
 174        # * select x from t1 union all (select x from t2 limit 1);
 175        MODIFIERS_ATTACHED_TO_SET_OP = False
 176        INTERVAL_SPANS = False
 177
 178        FUNCTIONS = {
 179            **parser.Parser.FUNCTIONS,
 180            "ANY": exp.AnyValue.from_arg_list,
 181            "ARRAYSUM": exp.ArraySum.from_arg_list,
 182            "COUNTIF": _build_count_if,
 183            "DATE_ADD": build_date_delta(exp.DateAdd, default_unit=None),
 184            "DATEADD": build_date_delta(exp.DateAdd, default_unit=None),
 185            "DATE_DIFF": build_date_delta(exp.DateDiff, default_unit=None),
 186            "DATEDIFF": build_date_delta(exp.DateDiff, default_unit=None),
 187            "DATE_FORMAT": _build_date_format,
 188            "DATE_SUB": build_date_delta(exp.DateSub, default_unit=None),
 189            "DATESUB": build_date_delta(exp.DateSub, default_unit=None),
 190            "FORMATDATETIME": _build_date_format,
 191            "JSONEXTRACTSTRING": build_json_extract_path(
 192                exp.JSONExtractScalar, zero_based_indexing=False
 193            ),
 194            "MAP": parser.build_var_map,
 195            "MATCH": exp.RegexpLike.from_arg_list,
 196            "RANDCANONICAL": exp.Rand.from_arg_list,
 197            "STR_TO_DATE": _build_str_to_date,
 198            "TUPLE": exp.Struct.from_arg_list,
 199            "TIMESTAMP_SUB": build_date_delta(exp.TimestampSub, default_unit=None),
 200            "TIMESTAMPSUB": build_date_delta(exp.TimestampSub, default_unit=None),
 201            "TIMESTAMP_ADD": build_date_delta(exp.TimestampAdd, default_unit=None),
 202            "TIMESTAMPADD": build_date_delta(exp.TimestampAdd, default_unit=None),
 203            "UNIQ": exp.ApproxDistinct.from_arg_list,
 204            "XOR": lambda args: exp.Xor(expressions=args),
 205            "MD5": exp.MD5Digest.from_arg_list,
 206            "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
 207            "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
 208        }
 209
 210        AGG_FUNCTIONS = {
 211            "count",
 212            "min",
 213            "max",
 214            "sum",
 215            "avg",
 216            "any",
 217            "stddevPop",
 218            "stddevSamp",
 219            "varPop",
 220            "varSamp",
 221            "corr",
 222            "covarPop",
 223            "covarSamp",
 224            "entropy",
 225            "exponentialMovingAverage",
 226            "intervalLengthSum",
 227            "kolmogorovSmirnovTest",
 228            "mannWhitneyUTest",
 229            "median",
 230            "rankCorr",
 231            "sumKahan",
 232            "studentTTest",
 233            "welchTTest",
 234            "anyHeavy",
 235            "anyLast",
 236            "boundingRatio",
 237            "first_value",
 238            "last_value",
 239            "argMin",
 240            "argMax",
 241            "avgWeighted",
 242            "topK",
 243            "topKWeighted",
 244            "deltaSum",
 245            "deltaSumTimestamp",
 246            "groupArray",
 247            "groupArrayLast",
 248            "groupUniqArray",
 249            "groupArrayInsertAt",
 250            "groupArrayMovingAvg",
 251            "groupArrayMovingSum",
 252            "groupArraySample",
 253            "groupBitAnd",
 254            "groupBitOr",
 255            "groupBitXor",
 256            "groupBitmap",
 257            "groupBitmapAnd",
 258            "groupBitmapOr",
 259            "groupBitmapXor",
 260            "sumWithOverflow",
 261            "sumMap",
 262            "minMap",
 263            "maxMap",
 264            "skewSamp",
 265            "skewPop",
 266            "kurtSamp",
 267            "kurtPop",
 268            "uniq",
 269            "uniqExact",
 270            "uniqCombined",
 271            "uniqCombined64",
 272            "uniqHLL12",
 273            "uniqTheta",
 274            "quantile",
 275            "quantiles",
 276            "quantileExact",
 277            "quantilesExact",
 278            "quantileExactLow",
 279            "quantilesExactLow",
 280            "quantileExactHigh",
 281            "quantilesExactHigh",
 282            "quantileExactWeighted",
 283            "quantilesExactWeighted",
 284            "quantileTiming",
 285            "quantilesTiming",
 286            "quantileTimingWeighted",
 287            "quantilesTimingWeighted",
 288            "quantileDeterministic",
 289            "quantilesDeterministic",
 290            "quantileTDigest",
 291            "quantilesTDigest",
 292            "quantileTDigestWeighted",
 293            "quantilesTDigestWeighted",
 294            "quantileBFloat16",
 295            "quantilesBFloat16",
 296            "quantileBFloat16Weighted",
 297            "quantilesBFloat16Weighted",
 298            "simpleLinearRegression",
 299            "stochasticLinearRegression",
 300            "stochasticLogisticRegression",
 301            "categoricalInformationValue",
 302            "contingency",
 303            "cramersV",
 304            "cramersVBiasCorrected",
 305            "theilsU",
 306            "maxIntersections",
 307            "maxIntersectionsPosition",
 308            "meanZTest",
 309            "quantileInterpolatedWeighted",
 310            "quantilesInterpolatedWeighted",
 311            "quantileGK",
 312            "quantilesGK",
 313            "sparkBar",
 314            "sumCount",
 315            "largestTriangleThreeBuckets",
 316            "histogram",
 317            "sequenceMatch",
 318            "sequenceCount",
 319            "windowFunnel",
 320            "retention",
 321            "uniqUpTo",
 322            "sequenceNextNode",
 323            "exponentialTimeDecayedAvg",
 324        }
 325
 326        AGG_FUNCTIONS_SUFFIXES = [
 327            "If",
 328            "Array",
 329            "ArrayIf",
 330            "Map",
 331            "SimpleState",
 332            "State",
 333            "Merge",
 334            "MergeState",
 335            "ForEach",
 336            "Distinct",
 337            "OrDefault",
 338            "OrNull",
 339            "Resample",
 340            "ArgMin",
 341            "ArgMax",
 342        ]
 343
 344        FUNC_TOKENS = {
 345            *parser.Parser.FUNC_TOKENS,
 346            TokenType.SET,
 347        }
 348
 349        RESERVED_TOKENS = parser.Parser.RESERVED_TOKENS - {TokenType.SELECT}
 350
 351        ID_VAR_TOKENS = {
 352            *parser.Parser.ID_VAR_TOKENS,
 353            TokenType.LIKE,
 354        }
 355
 356        AGG_FUNC_MAPPING = (
 357            lambda functions, suffixes: {
 358                f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions
 359            }
 360        )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES)
 361
 362        FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"}
 363
 364        FUNCTION_PARSERS = {
 365            **parser.Parser.FUNCTION_PARSERS,
 366            "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()),
 367            "QUANTILE": lambda self: self._parse_quantile(),
 368        }
 369
 370        FUNCTION_PARSERS.pop("MATCH")
 371
 372        NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy()
 373        NO_PAREN_FUNCTION_PARSERS.pop("ANY")
 374
 375        RANGE_PARSERS = {
 376            **parser.Parser.RANGE_PARSERS,
 377            TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN)
 378            and self._parse_in(this, is_global=True),
 379        }
 380
 381        # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to
 382        # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler.
 383        COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy()
 384        COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
 385
 386        JOIN_KINDS = {
 387            *parser.Parser.JOIN_KINDS,
 388            TokenType.ANY,
 389            TokenType.ASOF,
 390            TokenType.ARRAY,
 391        }
 392
 393        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
 394            TokenType.ANY,
 395            TokenType.ARRAY,
 396            TokenType.FINAL,
 397            TokenType.FORMAT,
 398            TokenType.SETTINGS,
 399        }
 400
 401        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
 402            TokenType.FORMAT,
 403        }
 404
 405        LOG_DEFAULTS_TO_LN = True
 406
 407        QUERY_MODIFIER_PARSERS = {
 408            **parser.Parser.QUERY_MODIFIER_PARSERS,
 409            TokenType.SETTINGS: lambda self: (
 410                "settings",
 411                self._advance() or self._parse_csv(self._parse_assignment),
 412            ),
 413            TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
 414        }
 415
 416        CONSTRAINT_PARSERS = {
 417            **parser.Parser.CONSTRAINT_PARSERS,
 418            "INDEX": lambda self: self._parse_index_constraint(),
 419            "CODEC": lambda self: self._parse_compress(),
 420        }
 421
 422        ALTER_PARSERS = {
 423            **parser.Parser.ALTER_PARSERS,
 424            "REPLACE": lambda self: self._parse_alter_table_replace(),
 425        }
 426
 427        SCHEMA_UNNAMED_CONSTRAINTS = {
 428            *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
 429            "INDEX",
 430        }
 431
 432        def _parse_create(self) -> exp.Create | exp.Command:
 433            create = super()._parse_create()
 434
 435            # DATABASE in ClickHouse is the same as SCHEMA in other dialects
 436            if isinstance(create, exp.Create) and create.kind == "DATABASE":
 437                create.set("kind", "SCHEMA")
 438
 439            return create
 440
 441        def _parse_extract(self) -> exp.Extract | exp.Anonymous:
 442            index = self._index
 443            this = self._parse_bitwise()
 444            if self._match(TokenType.FROM):
 445                self._retreat(index)
 446                return super()._parse_extract()
 447
 448            # We return Anonymous here because extract and regexpExtract have different semantics,
 449            # so parsing extract(foo, bar) into RegexpExtract can potentially break queries. E.g.,
 450            # `extract('foobar', 'b')` works, but ClickHouse crashes for `regexpExtract('foobar', 'b')`.
 451            #
 452            # TODO: can we somehow convert the former into an equivalent `regexpExtract` call?
 453            self._match(TokenType.COMMA)
 454            return self.expression(
 455                exp.Anonymous, this="extract", expressions=[this, self._parse_bitwise()]
 456            )
 457
 458        def _parse_assignment(self) -> t.Optional[exp.Expression]:
 459            this = super()._parse_assignment()
 460
 461            if self._match(TokenType.PLACEHOLDER):
 462                return self.expression(
 463                    exp.If,
 464                    this=this,
 465                    true=self._parse_assignment(),
 466                    false=self._match(TokenType.COLON) and self._parse_assignment(),
 467                )
 468
 469            return this
 470
 471        def _parse_placeholder(self) -> t.Optional[exp.Expression]:
 472            """
 473            Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
 474            https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
 475            """
 476            if not self._match(TokenType.L_BRACE):
 477                return None
 478
 479            this = self._parse_id_var()
 480            self._match(TokenType.COLON)
 481            kind = self._parse_types(check_func=False, allow_identifiers=False) or (
 482                self._match_text_seq("IDENTIFIER") and "Identifier"
 483            )
 484
 485            if not kind:
 486                self.raise_error("Expecting a placeholder type or 'Identifier' for tables")
 487            elif not self._match(TokenType.R_BRACE):
 488                self.raise_error("Expecting }")
 489
 490            return self.expression(exp.Placeholder, this=this, kind=kind)
 491
 492        def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In:
 493            this = super()._parse_in(this)
 494            this.set("is_global", is_global)
 495            return this
 496
 497        def _parse_table(
 498            self,
 499            schema: bool = False,
 500            joins: bool = False,
 501            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
 502            parse_bracket: bool = False,
 503            is_db_reference: bool = False,
 504            parse_partition: bool = False,
 505        ) -> t.Optional[exp.Expression]:
 506            this = super()._parse_table(
 507                schema=schema,
 508                joins=joins,
 509                alias_tokens=alias_tokens,
 510                parse_bracket=parse_bracket,
 511                is_db_reference=is_db_reference,
 512            )
 513
 514            if self._match(TokenType.FINAL):
 515                this = self.expression(exp.Final, this=this)
 516
 517            return this
 518
 519        def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
 520            return super()._parse_position(haystack_first=True)
 521
 522        # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
 523        def _parse_cte(self) -> exp.CTE:
 524            # WITH <identifier> AS <subquery expression>
 525            cte: t.Optional[exp.CTE] = self._try_parse(super()._parse_cte)
 526
 527            if not cte:
 528                # WITH <expression> AS <identifier>
 529                cte = self.expression(
 530                    exp.CTE,
 531                    this=self._parse_assignment(),
 532                    alias=self._parse_table_alias(),
 533                    scalar=True,
 534                )
 535
 536            return cte
 537
 538        def _parse_join_parts(
 539            self,
 540        ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
 541            is_global = self._match(TokenType.GLOBAL) and self._prev
 542            kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev
 543
 544            if kind_pre:
 545                kind = self._match_set(self.JOIN_KINDS) and self._prev
 546                side = self._match_set(self.JOIN_SIDES) and self._prev
 547                return is_global, side, kind
 548
 549            return (
 550                is_global,
 551                self._match_set(self.JOIN_SIDES) and self._prev,
 552                self._match_set(self.JOIN_KINDS) and self._prev,
 553            )
 554
 555        def _parse_join(
 556            self, skip_join_token: bool = False, parse_bracket: bool = False
 557        ) -> t.Optional[exp.Join]:
 558            join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True)
 559            if join:
 560                join.set("global", join.args.pop("method", None))
 561
 562            return join
 563
 564        def _parse_function(
 565            self,
 566            functions: t.Optional[t.Dict[str, t.Callable]] = None,
 567            anonymous: bool = False,
 568            optional_parens: bool = True,
 569            any_token: bool = False,
 570        ) -> t.Optional[exp.Expression]:
 571            expr = super()._parse_function(
 572                functions=functions,
 573                anonymous=anonymous,
 574                optional_parens=optional_parens,
 575                any_token=any_token,
 576            )
 577
 578            func = expr.this if isinstance(expr, exp.Window) else expr
 579
 580            # Aggregate functions can be split in 2 parts: <func_name><suffix>
 581            parts = (
 582                self.AGG_FUNC_MAPPING.get(func.this) if isinstance(func, exp.Anonymous) else None
 583            )
 584
 585            if parts:
 586                params = self._parse_func_params(func)
 587
 588                kwargs = {
 589                    "this": func.this,
 590                    "expressions": func.expressions,
 591                }
 592                if parts[1]:
 593                    kwargs["parts"] = parts
 594                    exp_class = exp.CombinedParameterizedAgg if params else exp.CombinedAggFunc
 595                else:
 596                    exp_class = exp.ParameterizedAgg if params else exp.AnonymousAggFunc
 597
 598                kwargs["exp_class"] = exp_class
 599                if params:
 600                    kwargs["params"] = params
 601
 602                func = self.expression(**kwargs)
 603
 604                if isinstance(expr, exp.Window):
 605                    # The window's func was parsed as Anonymous in base parser, fix its
 606                    # type to be ClickHouse style CombinedAnonymousAggFunc / AnonymousAggFunc
 607                    expr.set("this", func)
 608                elif params:
 609                    # Params have blocked super()._parse_function() from parsing the following window
 610                    # (if that exists) as they're standing between the function call and the window spec
 611                    expr = self._parse_window(func)
 612                else:
 613                    expr = func
 614
 615            return expr
 616
 617        def _parse_func_params(
 618            self, this: t.Optional[exp.Func] = None
 619        ) -> t.Optional[t.List[exp.Expression]]:
 620            if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
 621                return self._parse_csv(self._parse_lambda)
 622
 623            if self._match(TokenType.L_PAREN):
 624                params = self._parse_csv(self._parse_lambda)
 625                self._match_r_paren(this)
 626                return params
 627
 628            return None
 629
 630        def _parse_quantile(self) -> exp.Quantile:
 631            this = self._parse_lambda()
 632            params = self._parse_func_params()
 633            if params:
 634                return self.expression(exp.Quantile, this=params[0], quantile=this)
 635            return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5))
 636
 637        def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
 638            return super()._parse_wrapped_id_vars(optional=True)
 639
 640        def _parse_primary_key(
 641            self, wrapped_optional: bool = False, in_props: bool = False
 642        ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
 643            return super()._parse_primary_key(
 644                wrapped_optional=wrapped_optional or in_props, in_props=in_props
 645            )
 646
 647        def _parse_on_property(self) -> t.Optional[exp.Expression]:
 648            index = self._index
 649            if self._match_text_seq("CLUSTER"):
 650                this = self._parse_id_var()
 651                if this:
 652                    return self.expression(exp.OnCluster, this=this)
 653                else:
 654                    self._retreat(index)
 655            return None
 656
 657        def _parse_index_constraint(
 658            self, kind: t.Optional[str] = None
 659        ) -> exp.IndexColumnConstraint:
 660            # INDEX name1 expr TYPE type1(args) GRANULARITY value
 661            this = self._parse_id_var()
 662            expression = self._parse_assignment()
 663
 664            index_type = self._match_text_seq("TYPE") and (
 665                self._parse_function() or self._parse_var()
 666            )
 667
 668            granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
 669
 670            return self.expression(
 671                exp.IndexColumnConstraint,
 672                this=this,
 673                expression=expression,
 674                index_type=index_type,
 675                granularity=granularity,
 676            )
 677
 678        def _parse_partition(self) -> t.Optional[exp.Partition]:
 679            # https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#how-to-set-partition-expression
 680            if not self._match(TokenType.PARTITION):
 681                return None
 682
 683            if self._match_text_seq("ID"):
 684                # Corresponds to the PARTITION ID <string_value> syntax
 685                expressions: t.List[exp.Expression] = [
 686                    self.expression(exp.PartitionId, this=self._parse_string())
 687                ]
 688            else:
 689                expressions = self._parse_expressions()
 690
 691            return self.expression(exp.Partition, expressions=expressions)
 692
 693        def _parse_alter_table_replace(self) -> t.Optional[exp.Expression]:
 694            partition = self._parse_partition()
 695
 696            if not partition or not self._match(TokenType.FROM):
 697                return None
 698
 699            return self.expression(
 700                exp.ReplacePartition, expression=partition, source=self._parse_table_parts()
 701            )
 702
 703        def _parse_projection_def(self) -> t.Optional[exp.ProjectionDef]:
 704            if not self._match_text_seq("PROJECTION"):
 705                return None
 706
 707            return self.expression(
 708                exp.ProjectionDef,
 709                this=self._parse_id_var(),
 710                expression=self._parse_wrapped(self._parse_statement),
 711            )
 712
 713        def _parse_constraint(self) -> t.Optional[exp.Expression]:
 714            return super()._parse_constraint() or self._parse_projection_def()
 715
 716    class Generator(generator.Generator):
 717        QUERY_HINTS = False
 718        STRUCT_DELIMITER = ("(", ")")
 719        NVL2_SUPPORTED = False
 720        TABLESAMPLE_REQUIRES_PARENS = False
 721        TABLESAMPLE_SIZE_IS_ROWS = False
 722        TABLESAMPLE_KEYWORDS = "SAMPLE"
 723        LAST_DAY_SUPPORTS_DATE_PART = False
 724        CAN_IMPLEMENT_ARRAY_ANY = True
 725        SUPPORTS_TO_NUMBER = False
 726        JOIN_HINTS = False
 727        TABLE_HINTS = False
 728        EXPLICIT_SET_OP = True
 729        GROUPINGS_SEP = ""
 730        SET_OP_MODIFIERS = False
 731        SUPPORTS_TABLE_ALIAS_COLUMNS = False
 732        VALUES_AS_TABLE = False
 733
 734        STRING_TYPE_MAPPING = {
 735            exp.DataType.Type.CHAR: "String",
 736            exp.DataType.Type.LONGBLOB: "String",
 737            exp.DataType.Type.LONGTEXT: "String",
 738            exp.DataType.Type.MEDIUMBLOB: "String",
 739            exp.DataType.Type.MEDIUMTEXT: "String",
 740            exp.DataType.Type.TINYBLOB: "String",
 741            exp.DataType.Type.TINYTEXT: "String",
 742            exp.DataType.Type.TEXT: "String",
 743            exp.DataType.Type.VARBINARY: "String",
 744            exp.DataType.Type.VARCHAR: "String",
 745        }
 746
 747        SUPPORTED_JSON_PATH_PARTS = {
 748            exp.JSONPathKey,
 749            exp.JSONPathRoot,
 750            exp.JSONPathSubscript,
 751        }
 752
 753        TYPE_MAPPING = {
 754            **generator.Generator.TYPE_MAPPING,
 755            **STRING_TYPE_MAPPING,
 756            exp.DataType.Type.ARRAY: "Array",
 757            exp.DataType.Type.BIGINT: "Int64",
 758            exp.DataType.Type.DATE32: "Date32",
 759            exp.DataType.Type.DATETIME64: "DateTime64",
 760            exp.DataType.Type.DOUBLE: "Float64",
 761            exp.DataType.Type.ENUM: "Enum",
 762            exp.DataType.Type.ENUM8: "Enum8",
 763            exp.DataType.Type.ENUM16: "Enum16",
 764            exp.DataType.Type.FIXEDSTRING: "FixedString",
 765            exp.DataType.Type.FLOAT: "Float32",
 766            exp.DataType.Type.INT: "Int32",
 767            exp.DataType.Type.MEDIUMINT: "Int32",
 768            exp.DataType.Type.INT128: "Int128",
 769            exp.DataType.Type.INT256: "Int256",
 770            exp.DataType.Type.LOWCARDINALITY: "LowCardinality",
 771            exp.DataType.Type.MAP: "Map",
 772            exp.DataType.Type.NESTED: "Nested",
 773            exp.DataType.Type.NULLABLE: "Nullable",
 774            exp.DataType.Type.SMALLINT: "Int16",
 775            exp.DataType.Type.STRUCT: "Tuple",
 776            exp.DataType.Type.TINYINT: "Int8",
 777            exp.DataType.Type.UBIGINT: "UInt64",
 778            exp.DataType.Type.UINT: "UInt32",
 779            exp.DataType.Type.UINT128: "UInt128",
 780            exp.DataType.Type.UINT256: "UInt256",
 781            exp.DataType.Type.USMALLINT: "UInt16",
 782            exp.DataType.Type.UTINYINT: "UInt8",
 783            exp.DataType.Type.IPV4: "IPv4",
 784            exp.DataType.Type.IPV6: "IPv6",
 785            exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction",
 786            exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction",
 787        }
 788
 789        TRANSFORMS = {
 790            **generator.Generator.TRANSFORMS,
 791            exp.AnyValue: rename_func("any"),
 792            exp.ApproxDistinct: rename_func("uniq"),
 793            exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this),
 794            exp.ArraySize: rename_func("LENGTH"),
 795            exp.ArraySum: rename_func("arraySum"),
 796            exp.ArgMax: arg_max_or_min_no_count("argMax"),
 797            exp.ArgMin: arg_max_or_min_no_count("argMin"),
 798            exp.Array: inline_array_sql,
 799            exp.CastToStrType: rename_func("CAST"),
 800            exp.CountIf: rename_func("countIf"),
 801            exp.CompressColumnConstraint: lambda self,
 802            e: f"CODEC({self.expressions(e, key='this', flat=True)})",
 803            exp.ComputedColumnConstraint: lambda self,
 804            e: f"{'MATERIALIZED' if e.args.get('persisted') else 'ALIAS'} {self.sql(e, 'this')}",
 805            exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"),
 806            exp.DateAdd: _datetime_delta_sql("DATE_ADD"),
 807            exp.DateDiff: _datetime_delta_sql("DATE_DIFF"),
 808            exp.DateStrToDate: rename_func("toDate"),
 809            exp.DateSub: _datetime_delta_sql("DATE_SUB"),
 810            exp.Explode: rename_func("arrayJoin"),
 811            exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL",
 812            exp.IsNan: rename_func("isNaN"),
 813            exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False),
 814            exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False),
 815            exp.JSONPathKey: json_path_key_only_name,
 816            exp.JSONPathRoot: lambda *_: "",
 817            exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)),
 818            exp.Nullif: rename_func("nullIf"),
 819            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
 820            exp.Pivot: no_pivot_sql,
 821            exp.Quantile: _quantile_sql,
 822            exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression),
 823            exp.Rand: rename_func("randCanonical"),
 824            exp.StartsWith: rename_func("startsWith"),
 825            exp.StrPosition: lambda self, e: self.func(
 826                "position", e.this, e.args.get("substr"), e.args.get("position")
 827            ),
 828            exp.TimeToStr: lambda self, e: self.func(
 829                "DATE_FORMAT", e.this, self.format_time(e), e.args.get("timezone")
 830            ),
 831            exp.TimestampAdd: _datetime_delta_sql("TIMESTAMP_ADD"),
 832            exp.TimestampSub: _datetime_delta_sql("TIMESTAMP_SUB"),
 833            exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)),
 834            exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions),
 835            exp.MD5Digest: rename_func("MD5"),
 836            exp.MD5: lambda self, e: self.func("LOWER", self.func("HEX", self.func("MD5", e.this))),
 837            exp.SHA: rename_func("SHA1"),
 838            exp.SHA2: sha256_sql,
 839            exp.UnixToTime: _unix_to_time_sql,
 840            exp.TimestampTrunc: timestamptrunc_sql(zone=True),
 841            exp.Variance: rename_func("varSamp"),
 842            exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
 843            exp.Stddev: rename_func("stddevSamp"),
 844        }
 845
 846        PROPERTIES_LOCATION = {
 847            **generator.Generator.PROPERTIES_LOCATION,
 848            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
 849            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
 850            exp.OnCluster: exp.Properties.Location.POST_NAME,
 851        }
 852
 853        # there's no list in docs, but it can be found in Clickhouse code
 854        # see `ClickHouse/src/Parsers/ParserCreate*.cpp`
 855        ON_CLUSTER_TARGETS = {
 856            "DATABASE",
 857            "TABLE",
 858            "VIEW",
 859            "DICTIONARY",
 860            "INDEX",
 861            "FUNCTION",
 862            "NAMED COLLECTION",
 863        }
 864
 865        # https://github.com/ClickHouse/ClickHouse/blob/275de04b8f6bb8c9334bf8070001afe2dab0b17d/src/Functions/FunctionsConversion.cpp#L2939-L2989
 866        TRY_CAST_TYPES = {
 867            "DATE",
 868            "DATE32",
 869            "DATETIME",
 870            "DATETIME64",
 871            "DECIMAL32",
 872            "DECIMAL64",
 873            "DECIMAL128",
 874            "DECIMAL256",
 875            "FLOAT32",
 876            "FLOAT64",
 877            "INT8",
 878            "INT16",
 879            "INT32",
 880            "INT64",
 881            "INT128",
 882            "INT256",
 883            "IPV4",
 884            "IPV6",
 885            "UINT8",
 886            "UINT16",
 887            "UINT32",
 888            "UINT64",
 889            "UINT128",
 890            "UINT256",
 891            "UUID",
 892        }
 893
 894        def strtodate_sql(self, expression: exp.StrToDate) -> str:
 895            strtodate_sql = self.function_fallback_sql(expression)
 896
 897            if not isinstance(expression.parent, exp.Cast):
 898                # StrToDate returns DATEs in other dialects (eg. postgres), so
 899                # this branch aims to improve the transpilation to clickhouse
 900                return f"CAST({strtodate_sql} AS DATE)"
 901
 902            return strtodate_sql
 903
 904        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
 905            this = expression.this
 906
 907            if isinstance(this, exp.StrToDate) and expression.to == exp.DataType.build("datetime"):
 908                return self.sql(this)
 909
 910            return super().cast_sql(expression, safe_prefix=safe_prefix)
 911
 912        def trycast_sql(self, expression: exp.TryCast) -> str:
 913            target_type = self.sql(expression.to)
 914            if target_type.upper() in self.TRY_CAST_TYPES:
 915                return self.func(f"to{target_type}OrNull", expression.this)
 916
 917            self.unsupported(f"There is no `to<Type>OrNull` for type {target_type}.")
 918            return super().cast_sql(expression)
 919
 920        def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str:
 921            this = self.json_path_part(expression.this)
 922            return str(int(this) + 1) if is_int(this) else this
 923
 924        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
 925            return f"AS {self.sql(expression, 'this')}"
 926
 927        def _any_to_has(
 928            self,
 929            expression: exp.EQ | exp.NEQ,
 930            default: t.Callable[[t.Any], str],
 931            prefix: str = "",
 932        ) -> str:
 933            if isinstance(expression.left, exp.Any):
 934                arr = expression.left
 935                this = expression.right
 936            elif isinstance(expression.right, exp.Any):
 937                arr = expression.right
 938                this = expression.left
 939            else:
 940                return default(expression)
 941
 942            return prefix + self.func("has", arr.this.unnest(), this)
 943
 944        def eq_sql(self, expression: exp.EQ) -> str:
 945            return self._any_to_has(expression, super().eq_sql)
 946
 947        def neq_sql(self, expression: exp.NEQ) -> str:
 948            return self._any_to_has(expression, super().neq_sql, "NOT ")
 949
 950        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
 951            # Manually add a flag to make the search case-insensitive
 952            regex = self.func("CONCAT", "'(?i)'", expression.expression)
 953            return self.func("match", expression.this, regex)
 954
 955        def datatype_sql(self, expression: exp.DataType) -> str:
 956            # String is the standard ClickHouse type, every other variant is just an alias.
 957            # Additionally, any supplied length parameter will be ignored.
 958            #
 959            # https://clickhouse.com/docs/en/sql-reference/data-types/string
 960            if expression.this in self.STRING_TYPE_MAPPING:
 961                return "String"
 962
 963            return super().datatype_sql(expression)
 964
 965        def cte_sql(self, expression: exp.CTE) -> str:
 966            if expression.args.get("scalar"):
 967                this = self.sql(expression, "this")
 968                alias = self.sql(expression, "alias")
 969                return f"{this} AS {alias}"
 970
 971            return super().cte_sql(expression)
 972
 973        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
 974            return super().after_limit_modifiers(expression) + [
 975                (
 976                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
 977                    if expression.args.get("settings")
 978                    else ""
 979                ),
 980                (
 981                    self.seg("FORMAT ") + self.sql(expression, "format")
 982                    if expression.args.get("format")
 983                    else ""
 984                ),
 985            ]
 986
 987        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
 988            params = self.expressions(expression, key="params", flat=True)
 989            return self.func(expression.name, *expression.expressions) + f"({params})"
 990
 991        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
 992            return self.func(expression.name, *expression.expressions)
 993
 994        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
 995            return self.anonymousaggfunc_sql(expression)
 996
 997        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
 998            return self.parameterizedagg_sql(expression)
 999
1000        def placeholder_sql(self, expression: exp.Placeholder) -> str:
1001            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
1002
1003        def oncluster_sql(self, expression: exp.OnCluster) -> str:
1004            return f"ON CLUSTER {self.sql(expression, 'this')}"
1005
1006        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
1007            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
1008                exp.Properties.Location.POST_NAME
1009            ):
1010                this_name = self.sql(
1011                    expression.this if isinstance(expression.this, exp.Schema) else expression,
1012                    "this",
1013                )
1014                this_properties = " ".join(
1015                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
1016                )
1017                this_schema = self.schema_columns_sql(expression.this)
1018                return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}"
1019
1020            return super().createable_sql(expression, locations)
1021
1022        def create_sql(self, expression: exp.Create) -> str:
1023            # The comment property comes last in CTAS statements, i.e. after the query
1024            query = expression.expression
1025            if isinstance(query, exp.Query):
1026                comment_prop = expression.find(exp.SchemaCommentProperty)
1027                if comment_prop:
1028                    comment_prop.pop()
1029                    query.replace(exp.paren(query))
1030            else:
1031                comment_prop = None
1032
1033            # ClickHouse only has DATABASEs and objects under them, eg. TABLEs, VIEWs, etc
1034            if expression.kind == "SCHEMA":
1035                expression.set("kind", "DATABASE")
1036
1037            create_sql = super().create_sql(expression)
1038
1039            comment_sql = self.sql(comment_prop)
1040            comment_sql = f" {comment_sql}" if comment_sql else ""
1041
1042            return f"{create_sql}{comment_sql}"
1043
1044        def prewhere_sql(self, expression: exp.PreWhere) -> str:
1045            this = self.indent(self.sql(expression, "this"))
1046            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
1047
1048        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
1049            this = self.sql(expression, "this")
1050            this = f" {this}" if this else ""
1051            expr = self.sql(expression, "expression")
1052            expr = f" {expr}" if expr else ""
1053            index_type = self.sql(expression, "index_type")
1054            index_type = f" TYPE {index_type}" if index_type else ""
1055            granularity = self.sql(expression, "granularity")
1056            granularity = f" GRANULARITY {granularity}" if granularity else ""
1057
1058            return f"INDEX{this}{expr}{index_type}{granularity}"
1059
1060        def partition_sql(self, expression: exp.Partition) -> str:
1061            return f"PARTITION {self.expressions(expression, flat=True)}"
1062
1063        def partitionid_sql(self, expression: exp.PartitionId) -> str:
1064            return f"ID {self.sql(expression.this)}"
1065
1066        def replacepartition_sql(self, expression: exp.ReplacePartition) -> str:
1067            return (
1068                f"REPLACE {self.sql(expression.expression)} FROM {self.sql(expression, 'source')}"
1069            )
1070
1071        def projectiondef_sql(self, expression: exp.ProjectionDef) -> str:
1072            return f"PROJECTION {self.sql(expression.this)} {self.wrap(expression.expression)}"
NORMALIZE_FUNCTIONS: bool | str = False

Determines how function names are going to be normalized.

Possible values:

"upper" or True: Convert names to uppercase. "lower": Convert names to lowercase. False: Disables function name normalization.

NULL_ORDERING = 'nulls_are_last'

Default NULL ordering method to use if not explicitly set. Possible values: "nulls_are_small", "nulls_are_large", "nulls_are_last"

SUPPORTS_USER_DEFINED_TYPES = False

Whether user-defined data types are supported.

SAFE_DIVISION = True

Whether division by zero throws an error (False) or returns NULL (True).

LOG_BASE_FIRST: Optional[bool] = None

Whether the base comes first in the LOG function. Possible values: True, False, None (two arguments are not supported by LOG)

FORCE_EARLY_ALIAS_REF_EXPANSION = True

Whether alias reference expansion (_expand_alias_refs()) should run before column qualification (_qualify_columns()).

For example:

WITH data AS ( SELECT 1 AS id, 2 AS my_id ) SELECT id AS my_id FROM data WHERE my_id = 1 GROUP BY my_id, HAVING my_id = 1

In most dialects "my_id" would refer to "data.my_id" (which is done in _qualify_columns()) across the query, except: - BigQuery, which will forward the alias to GROUP BY + HAVING clauses i.e it resolves to "WHERE my_id = 1 GROUP BY id HAVING id = 1" - Clickhouse, which will forward the alias across the query i.e it resolves to "WHERE id = 1 GROUP BY id HAVING id = 1"

NORMALIZATION_STRATEGY = <NormalizationStrategy.CASE_SENSITIVE: 'CASE_SENSITIVE'>

Specifies the strategy according to which identifiers should be normalized.

UNESCAPED_SEQUENCES = {'\\a': '\x07', '\\b': '\x08', '\\f': '\x0c', '\\n': '\n', '\\r': '\r', '\\t': '\t', '\\v': '\x0b', '\\\\': '\\', '\\0': '\x00'}

Mapping of an escaped sequence (\n) to its unescaped version ( ).

SUPPORTS_COLUMN_JOIN_MARKS = False

Whether the old-style outer join (+) syntax is supported.

tokenizer_class = <class 'ClickHouse.Tokenizer'>
jsonpath_tokenizer_class = <class 'sqlglot.tokens.JSONPathTokenizer'>
parser_class = <class 'ClickHouse.Parser'>
generator_class = <class 'ClickHouse.Generator'>
TIME_TRIE: Dict = {}
FORMAT_TRIE: Dict = {}
INVERSE_TIME_MAPPING: Dict[str, str] = {}
INVERSE_TIME_TRIE: Dict = {}
INVERSE_FORMAT_MAPPING: Dict[str, str] = {}
INVERSE_FORMAT_TRIE: Dict = {}
ESCAPED_SEQUENCES: Dict[str, str] = {'\x07': '\\a', '\x08': '\\b', '\x0c': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t', '\x0b': '\\v', '\\': '\\\\', '\x00': '\\0'}
QUOTE_START = "'"
QUOTE_END = "'"
IDENTIFIER_START = '"'
IDENTIFIER_END = '"'
BIT_START: Optional[str] = '0b'
BIT_END: Optional[str] = ''
HEX_START: Optional[str] = '0x'
HEX_END: Optional[str] = ''
BYTE_START: Optional[str] = None
BYTE_END: Optional[str] = None
UNICODE_START: Optional[str] = None
UNICODE_END: Optional[str] = None
class ClickHouse.Tokenizer(sqlglot.tokens.Tokenizer):
124    class Tokenizer(tokens.Tokenizer):
125        COMMENTS = ["--", "#", "#!", ("/*", "*/")]
126        IDENTIFIERS = ['"', "`"]
127        STRING_ESCAPES = ["'", "\\"]
128        BIT_STRINGS = [("0b", "")]
129        HEX_STRINGS = [("0x", ""), ("0X", "")]
130        HEREDOC_STRINGS = ["$"]
131
132        KEYWORDS = {
133            **tokens.Tokenizer.KEYWORDS,
134            "ATTACH": TokenType.COMMAND,
135            "DATE32": TokenType.DATE32,
136            "DATETIME64": TokenType.DATETIME64,
137            "DICTIONARY": TokenType.DICTIONARY,
138            "ENUM8": TokenType.ENUM8,
139            "ENUM16": TokenType.ENUM16,
140            "FINAL": TokenType.FINAL,
141            "FIXEDSTRING": TokenType.FIXEDSTRING,
142            "FLOAT32": TokenType.FLOAT,
143            "FLOAT64": TokenType.DOUBLE,
144            "GLOBAL": TokenType.GLOBAL,
145            "INT256": TokenType.INT256,
146            "LOWCARDINALITY": TokenType.LOWCARDINALITY,
147            "MAP": TokenType.MAP,
148            "NESTED": TokenType.NESTED,
149            "SAMPLE": TokenType.TABLE_SAMPLE,
150            "TUPLE": TokenType.STRUCT,
151            "UINT128": TokenType.UINT128,
152            "UINT16": TokenType.USMALLINT,
153            "UINT256": TokenType.UINT256,
154            "UINT32": TokenType.UINT,
155            "UINT64": TokenType.UBIGINT,
156            "UINT8": TokenType.UTINYINT,
157            "IPV4": TokenType.IPV4,
158            "IPV6": TokenType.IPV6,
159            "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION,
160            "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION,
161            "SYSTEM": TokenType.COMMAND,
162            "PREWHERE": TokenType.PREWHERE,
163        }
164        KEYWORDS.pop("/*+")
165
166        SINGLE_TOKENS = {
167            **tokens.Tokenizer.SINGLE_TOKENS,
168            "$": TokenType.HEREDOC_STRING,
169        }
COMMENTS = ['--', '#', '#!', ('/*', '*/')]
IDENTIFIERS = ['"', '`']
STRING_ESCAPES = ["'", '\\']
BIT_STRINGS = [('0b', '')]
HEX_STRINGS = [('0x', ''), ('0X', '')]
HEREDOC_STRINGS = ['$']
KEYWORDS = {'{%': <TokenType.BLOCK_START: 'BLOCK_START'>, '{%+': <TokenType.BLOCK_START: 'BLOCK_START'>, '{%-': <TokenType.BLOCK_START: 'BLOCK_START'>, '%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '+%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '-%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '{{+': <TokenType.BLOCK_START: 'BLOCK_START'>, '{{-': <TokenType.BLOCK_START: 'BLOCK_START'>, '+}}': <TokenType.BLOCK_END: 'BLOCK_END'>, '-}}': <TokenType.BLOCK_END: 'BLOCK_END'>, '==': <TokenType.EQ: 'EQ'>, '::': <TokenType.DCOLON: 'DCOLON'>, '||': <TokenType.DPIPE: 'DPIPE'>, '>=': <TokenType.GTE: 'GTE'>, '<=': <TokenType.LTE: 'LTE'>, '<>': <TokenType.NEQ: 'NEQ'>, '!=': <TokenType.NEQ: 'NEQ'>, ':=': <TokenType.COLON_EQ: 'COLON_EQ'>, '<=>': <TokenType.NULLSAFE_EQ: 'NULLSAFE_EQ'>, '->': <TokenType.ARROW: 'ARROW'>, '->>': <TokenType.DARROW: 'DARROW'>, '=>': <TokenType.FARROW: 'FARROW'>, '#>': <TokenType.HASH_ARROW: 'HASH_ARROW'>, '#>>': <TokenType.DHASH_ARROW: 'DHASH_ARROW'>, '<->': <TokenType.LR_ARROW: 'LR_ARROW'>, '&&': <TokenType.DAMP: 'DAMP'>, '??': <TokenType.DQMARK: 'DQMARK'>, 'ALL': <TokenType.ALL: 'ALL'>, 'ALWAYS': <TokenType.ALWAYS: 'ALWAYS'>, 'AND': <TokenType.AND: 'AND'>, 'ANTI': <TokenType.ANTI: 'ANTI'>, 'ANY': <TokenType.ANY: 'ANY'>, 'ASC': <TokenType.ASC: 'ASC'>, 'AS': <TokenType.ALIAS: 'ALIAS'>, 'ASOF': <TokenType.ASOF: 'ASOF'>, 'AUTOINCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'AUTO_INCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'BEGIN': <TokenType.BEGIN: 'BEGIN'>, 'BETWEEN': <TokenType.BETWEEN: 'BETWEEN'>, 'CACHE': <TokenType.CACHE: 'CACHE'>, 'UNCACHE': <TokenType.UNCACHE: 'UNCACHE'>, 'CASE': <TokenType.CASE: 'CASE'>, 'CHARACTER SET': <TokenType.CHARACTER_SET: 'CHARACTER_SET'>, 'CLUSTER BY': <TokenType.CLUSTER_BY: 'CLUSTER_BY'>, 'COLLATE': <TokenType.COLLATE: 'COLLATE'>, 'COLUMN': <TokenType.COLUMN: 'COLUMN'>, 'COMMIT': <TokenType.COMMIT: 'COMMIT'>, 'CONNECT BY': <TokenType.CONNECT_BY: 'CONNECT_BY'>, 'CONSTRAINT': <TokenType.CONSTRAINT: 'CONSTRAINT'>, 'COPY': <TokenType.COPY: 'COPY'>, 'CREATE': <TokenType.CREATE: 'CREATE'>, 'CROSS': <TokenType.CROSS: 'CROSS'>, 'CUBE': <TokenType.CUBE: 'CUBE'>, 'CURRENT_DATE': <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, 'CURRENT_TIME': <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, 'CURRENT_TIMESTAMP': <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, 'CURRENT_USER': <TokenType.CURRENT_USER: 'CURRENT_USER'>, 'DATABASE': <TokenType.DATABASE: 'DATABASE'>, 'DEFAULT': <TokenType.DEFAULT: 'DEFAULT'>, 'DELETE': <TokenType.DELETE: 'DELETE'>, 'DESC': <TokenType.DESC: 'DESC'>, 'DESCRIBE': <TokenType.DESCRIBE: 'DESCRIBE'>, 'DISTINCT': <TokenType.DISTINCT: 'DISTINCT'>, 'DISTRIBUTE BY': <TokenType.DISTRIBUTE_BY: 'DISTRIBUTE_BY'>, 'DIV': <TokenType.DIV: 'DIV'>, 'DROP': <TokenType.DROP: 'DROP'>, 'ELSE': <TokenType.ELSE: 'ELSE'>, 'END': <TokenType.END: 'END'>, 'ENUM': <TokenType.ENUM: 'ENUM'>, 'ESCAPE': <TokenType.ESCAPE: 'ESCAPE'>, 'EXCEPT': <TokenType.EXCEPT: 'EXCEPT'>, 'EXECUTE': <TokenType.EXECUTE: 'EXECUTE'>, 'EXISTS': <TokenType.EXISTS: 'EXISTS'>, 'FALSE': <TokenType.FALSE: 'FALSE'>, 'FETCH': <TokenType.FETCH: 'FETCH'>, 'FILTER': <TokenType.FILTER: 'FILTER'>, 'FIRST': <TokenType.FIRST: 'FIRST'>, 'FULL': <TokenType.FULL: 'FULL'>, 'FUNCTION': <TokenType.FUNCTION: 'FUNCTION'>, 'FOR': <TokenType.FOR: 'FOR'>, 'FOREIGN KEY': <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, 'FORMAT': <TokenType.FORMAT: 'FORMAT'>, 'FROM': <TokenType.FROM: 'FROM'>, 'GEOGRAPHY': <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, 'GEOMETRY': <TokenType.GEOMETRY: 'GEOMETRY'>, 'GLOB': <TokenType.GLOB: 'GLOB'>, 'GROUP BY': <TokenType.GROUP_BY: 'GROUP_BY'>, 'GROUPING SETS': <TokenType.GROUPING_SETS: 'GROUPING_SETS'>, 'HAVING': <TokenType.HAVING: 'HAVING'>, 'ILIKE': <TokenType.ILIKE: 'ILIKE'>, 'IN': <TokenType.IN: 'IN'>, 'INDEX': <TokenType.INDEX: 'INDEX'>, 'INET': <TokenType.INET: 'INET'>, 'INNER': <TokenType.INNER: 'INNER'>, 'INSERT': <TokenType.INSERT: 'INSERT'>, 'INTERVAL': <TokenType.INTERVAL: 'INTERVAL'>, 'INTERSECT': <TokenType.INTERSECT: 'INTERSECT'>, 'INTO': <TokenType.INTO: 'INTO'>, 'IS': <TokenType.IS: 'IS'>, 'ISNULL': <TokenType.ISNULL: 'ISNULL'>, 'JOIN': <TokenType.JOIN: 'JOIN'>, 'KEEP': <TokenType.KEEP: 'KEEP'>, 'KILL': <TokenType.KILL: 'KILL'>, 'LATERAL': <TokenType.LATERAL: 'LATERAL'>, 'LEFT': <TokenType.LEFT: 'LEFT'>, 'LIKE': <TokenType.LIKE: 'LIKE'>, 'LIMIT': <TokenType.LIMIT: 'LIMIT'>, 'LOAD': <TokenType.LOAD: 'LOAD'>, 'LOCK': <TokenType.LOCK: 'LOCK'>, 'MERGE': <TokenType.MERGE: 'MERGE'>, 'NATURAL': <TokenType.NATURAL: 'NATURAL'>, 'NEXT': <TokenType.NEXT: 'NEXT'>, 'NOT': <TokenType.NOT: 'NOT'>, 'NOTNULL': <TokenType.NOTNULL: 'NOTNULL'>, 'NULL': <TokenType.NULL: 'NULL'>, 'OBJECT': <TokenType.OBJECT: 'OBJECT'>, 'OFFSET': <TokenType.OFFSET: 'OFFSET'>, 'ON': <TokenType.ON: 'ON'>, 'OR': <TokenType.OR: 'OR'>, 'XOR': <TokenType.XOR: 'XOR'>, 'ORDER BY': <TokenType.ORDER_BY: 'ORDER_BY'>, 'ORDINALITY': <TokenType.ORDINALITY: 'ORDINALITY'>, 'OUTER': <TokenType.OUTER: 'OUTER'>, 'OVER': <TokenType.OVER: 'OVER'>, 'OVERLAPS': <TokenType.OVERLAPS: 'OVERLAPS'>, 'OVERWRITE': <TokenType.OVERWRITE: 'OVERWRITE'>, 'PARTITION': <TokenType.PARTITION: 'PARTITION'>, 'PARTITION BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED_BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PERCENT': <TokenType.PERCENT: 'PERCENT'>, 'PIVOT': <TokenType.PIVOT: 'PIVOT'>, 'PRAGMA': <TokenType.PRAGMA: 'PRAGMA'>, 'PRIMARY KEY': <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, 'PROCEDURE': <TokenType.PROCEDURE: 'PROCEDURE'>, 'QUALIFY': <TokenType.QUALIFY: 'QUALIFY'>, 'RANGE': <TokenType.RANGE: 'RANGE'>, 'RECURSIVE': <TokenType.RECURSIVE: 'RECURSIVE'>, 'REGEXP': <TokenType.RLIKE: 'RLIKE'>, 'RENAME': <TokenType.RENAME: 'RENAME'>, 'REPLACE': <TokenType.REPLACE: 'REPLACE'>, 'RETURNING': <TokenType.RETURNING: 'RETURNING'>, 'REFERENCES': <TokenType.REFERENCES: 'REFERENCES'>, 'RIGHT': <TokenType.RIGHT: 'RIGHT'>, 'RLIKE': <TokenType.RLIKE: 'RLIKE'>, 'ROLLBACK': <TokenType.ROLLBACK: 'ROLLBACK'>, 'ROLLUP': <TokenType.ROLLUP: 'ROLLUP'>, 'ROW': <TokenType.ROW: 'ROW'>, 'ROWS': <TokenType.ROWS: 'ROWS'>, 'SCHEMA': <TokenType.SCHEMA: 'SCHEMA'>, 'SELECT': <TokenType.SELECT: 'SELECT'>, 'SEMI': <TokenType.SEMI: 'SEMI'>, 'SET': <TokenType.SET: 'SET'>, 'SETTINGS': <TokenType.SETTINGS: 'SETTINGS'>, 'SHOW': <TokenType.SHOW: 'SHOW'>, 'SIMILAR TO': <TokenType.SIMILAR_TO: 'SIMILAR_TO'>, 'SOME': <TokenType.SOME: 'SOME'>, 'SORT BY': <TokenType.SORT_BY: 'SORT_BY'>, 'START WITH': <TokenType.START_WITH: 'START_WITH'>, 'STRAIGHT_JOIN': <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, 'TABLE': <TokenType.TABLE: 'TABLE'>, 'TABLESAMPLE': <TokenType.TABLE_SAMPLE: 'TABLE_SAMPLE'>, 'TEMP': <TokenType.TEMPORARY: 'TEMPORARY'>, 'TEMPORARY': <TokenType.TEMPORARY: 'TEMPORARY'>, 'THEN': <TokenType.THEN: 'THEN'>, 'TRUE': <TokenType.TRUE: 'TRUE'>, 'TRUNCATE': <TokenType.TRUNCATE: 'TRUNCATE'>, 'UNION': <TokenType.UNION: 'UNION'>, 'UNKNOWN': <TokenType.UNKNOWN: 'UNKNOWN'>, 'UNNEST': <TokenType.UNNEST: 'UNNEST'>, 'UNPIVOT': <TokenType.UNPIVOT: 'UNPIVOT'>, 'UPDATE': <TokenType.UPDATE: 'UPDATE'>, 'USE': <TokenType.USE: 'USE'>, 'USING': <TokenType.USING: 'USING'>, 'UUID': <TokenType.UUID: 'UUID'>, 'VALUES': <TokenType.VALUES: 'VALUES'>, 'VIEW': <TokenType.VIEW: 'VIEW'>, 'VOLATILE': <TokenType.VOLATILE: 'VOLATILE'>, 'WHEN': <TokenType.WHEN: 'WHEN'>, 'WHERE': <TokenType.WHERE: 'WHERE'>, 'WINDOW': <TokenType.WINDOW: 'WINDOW'>, 'WITH': <TokenType.WITH: 'WITH'>, 'APPLY': <TokenType.APPLY: 'APPLY'>, 'ARRAY': <TokenType.ARRAY: 'ARRAY'>, 'BIT': <TokenType.BIT: 'BIT'>, 'BOOL': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BOOLEAN': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BYTE': <TokenType.TINYINT: 'TINYINT'>, 'MEDIUMINT': <TokenType.MEDIUMINT: 'MEDIUMINT'>, 'INT1': <TokenType.TINYINT: 'TINYINT'>, 'TINYINT': <TokenType.TINYINT: 'TINYINT'>, 'INT16': <TokenType.SMALLINT: 'SMALLINT'>, 'SHORT': <TokenType.SMALLINT: 'SMALLINT'>, 'SMALLINT': <TokenType.SMALLINT: 'SMALLINT'>, 'INT128': <TokenType.INT128: 'INT128'>, 'HUGEINT': <TokenType.INT128: 'INT128'>, 'INT2': <TokenType.SMALLINT: 'SMALLINT'>, 'INTEGER': <TokenType.INT: 'INT'>, 'INT': <TokenType.INT: 'INT'>, 'INT4': <TokenType.INT: 'INT'>, 'INT32': <TokenType.INT: 'INT'>, 'INT64': <TokenType.BIGINT: 'BIGINT'>, 'LONG': <TokenType.BIGINT: 'BIGINT'>, 'BIGINT': <TokenType.BIGINT: 'BIGINT'>, 'INT8': <TokenType.TINYINT: 'TINYINT'>, 'UINT': <TokenType.UINT: 'UINT'>, 'DEC': <TokenType.DECIMAL: 'DECIMAL'>, 'DECIMAL': <TokenType.DECIMAL: 'DECIMAL'>, 'BIGDECIMAL': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, 'BIGNUMERIC': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, 'LIST': <TokenType.LIST: 'LIST'>, 'MAP': <TokenType.MAP: 'MAP'>, 'NULLABLE': <TokenType.NULLABLE: 'NULLABLE'>, 'NUMBER': <TokenType.DECIMAL: 'DECIMAL'>, 'NUMERIC': <TokenType.DECIMAL: 'DECIMAL'>, 'FIXED': <TokenType.DECIMAL: 'DECIMAL'>, 'REAL': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT4': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT8': <TokenType.DOUBLE: 'DOUBLE'>, 'DOUBLE': <TokenType.DOUBLE: 'DOUBLE'>, 'DOUBLE PRECISION': <TokenType.DOUBLE: 'DOUBLE'>, 'JSON': <TokenType.JSON: 'JSON'>, 'JSONB': <TokenType.JSONB: 'JSONB'>, 'CHAR': <TokenType.CHAR: 'CHAR'>, 'CHARACTER': <TokenType.CHAR: 'CHAR'>, 'NCHAR': <TokenType.NCHAR: 'NCHAR'>, 'VARCHAR': <TokenType.VARCHAR: 'VARCHAR'>, 'VARCHAR2': <TokenType.VARCHAR: 'VARCHAR'>, 'NVARCHAR': <TokenType.NVARCHAR: 'NVARCHAR'>, 'NVARCHAR2': <TokenType.NVARCHAR: 'NVARCHAR'>, 'BPCHAR': <TokenType.BPCHAR: 'BPCHAR'>, 'STR': <TokenType.TEXT: 'TEXT'>, 'STRING': <TokenType.TEXT: 'TEXT'>, 'TEXT': <TokenType.TEXT: 'TEXT'>, 'LONGTEXT': <TokenType.LONGTEXT: 'LONGTEXT'>, 'MEDIUMTEXT': <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, 'TINYTEXT': <TokenType.TINYTEXT: 'TINYTEXT'>, 'CLOB': <TokenType.TEXT: 'TEXT'>, 'LONGVARCHAR': <TokenType.TEXT: 'TEXT'>, 'BINARY': <TokenType.BINARY: 'BINARY'>, 'BLOB': <TokenType.VARBINARY: 'VARBINARY'>, 'LONGBLOB': <TokenType.LONGBLOB: 'LONGBLOB'>, 'MEDIUMBLOB': <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, 'TINYBLOB': <TokenType.TINYBLOB: 'TINYBLOB'>, 'BYTEA': <TokenType.VARBINARY: 'VARBINARY'>, 'VARBINARY': <TokenType.VARBINARY: 'VARBINARY'>, 'TIME': <TokenType.TIME: 'TIME'>, 'TIMETZ': <TokenType.TIMETZ: 'TIMETZ'>, 'TIMESTAMP': <TokenType.TIMESTAMP: 'TIMESTAMP'>, 'TIMESTAMPTZ': <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, 'TIMESTAMPLTZ': <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, 'TIMESTAMP_LTZ': <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, 'TIMESTAMPNTZ': <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, 'TIMESTAMP_NTZ': <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, 'DATE': <TokenType.DATE: 'DATE'>, 'DATETIME': <TokenType.DATETIME: 'DATETIME'>, 'INT4RANGE': <TokenType.INT4RANGE: 'INT4RANGE'>, 'INT4MULTIRANGE': <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, 'INT8RANGE': <TokenType.INT8RANGE: 'INT8RANGE'>, 'INT8MULTIRANGE': <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, 'NUMRANGE': <TokenType.NUMRANGE: 'NUMRANGE'>, 'NUMMULTIRANGE': <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, 'TSRANGE': <TokenType.TSRANGE: 'TSRANGE'>, 'TSMULTIRANGE': <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, 'TSTZRANGE': <TokenType.TSTZRANGE: 'TSTZRANGE'>, 'TSTZMULTIRANGE': <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, 'DATERANGE': <TokenType.DATERANGE: 'DATERANGE'>, 'DATEMULTIRANGE': <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, 'UNIQUE': <TokenType.UNIQUE: 'UNIQUE'>, 'VECTOR': <TokenType.VECTOR: 'VECTOR'>, 'STRUCT': <TokenType.STRUCT: 'STRUCT'>, 'SEQUENCE': <TokenType.SEQUENCE: 'SEQUENCE'>, 'VARIANT': <TokenType.VARIANT: 'VARIANT'>, 'ALTER': <TokenType.ALTER: 'ALTER'>, 'ANALYZE': <TokenType.COMMAND: 'COMMAND'>, 'CALL': <TokenType.COMMAND: 'COMMAND'>, 'COMMENT': <TokenType.COMMENT: 'COMMENT'>, 'EXPLAIN': <TokenType.COMMAND: 'COMMAND'>, 'GRANT': <TokenType.COMMAND: 'COMMAND'>, 'OPTIMIZE': <TokenType.COMMAND: 'COMMAND'>, 'PREPARE': <TokenType.COMMAND: 'COMMAND'>, 'VACUUM': <TokenType.COMMAND: 'COMMAND'>, 'USER-DEFINED': <TokenType.USERDEFINED: 'USERDEFINED'>, 'FOR VERSION': <TokenType.VERSION_SNAPSHOT: 'VERSION_SNAPSHOT'>, 'FOR TIMESTAMP': <TokenType.TIMESTAMP_SNAPSHOT: 'TIMESTAMP_SNAPSHOT'>, 'ATTACH': <TokenType.COMMAND: 'COMMAND'>, 'DATE32': <TokenType.DATE32: 'DATE32'>, 'DATETIME64': <TokenType.DATETIME64: 'DATETIME64'>, 'DICTIONARY': <TokenType.DICTIONARY: 'DICTIONARY'>, 'ENUM8': <TokenType.ENUM8: 'ENUM8'>, 'ENUM16': <TokenType.ENUM16: 'ENUM16'>, 'FINAL': <TokenType.FINAL: 'FINAL'>, 'FIXEDSTRING': <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, 'FLOAT32': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT64': <TokenType.DOUBLE: 'DOUBLE'>, 'GLOBAL': <TokenType.GLOBAL: 'GLOBAL'>, 'INT256': <TokenType.INT256: 'INT256'>, 'LOWCARDINALITY': <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, 'NESTED': <TokenType.NESTED: 'NESTED'>, 'SAMPLE': <TokenType.TABLE_SAMPLE: 'TABLE_SAMPLE'>, 'TUPLE': <TokenType.STRUCT: 'STRUCT'>, 'UINT128': <TokenType.UINT128: 'UINT128'>, 'UINT16': <TokenType.USMALLINT: 'USMALLINT'>, 'UINT256': <TokenType.UINT256: 'UINT256'>, 'UINT32': <TokenType.UINT: 'UINT'>, 'UINT64': <TokenType.UBIGINT: 'UBIGINT'>, 'UINT8': <TokenType.UTINYINT: 'UTINYINT'>, 'IPV4': <TokenType.IPV4: 'IPV4'>, 'IPV6': <TokenType.IPV6: 'IPV6'>, 'AGGREGATEFUNCTION': <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, 'SIMPLEAGGREGATEFUNCTION': <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, 'SYSTEM': <TokenType.COMMAND: 'COMMAND'>, 'PREWHERE': <TokenType.PREWHERE: 'PREWHERE'>}
SINGLE_TOKENS = {'(': <TokenType.L_PAREN: 'L_PAREN'>, ')': <TokenType.R_PAREN: 'R_PAREN'>, '[': <TokenType.L_BRACKET: 'L_BRACKET'>, ']': <TokenType.R_BRACKET: 'R_BRACKET'>, '{': <TokenType.L_BRACE: 'L_BRACE'>, '}': <TokenType.R_BRACE: 'R_BRACE'>, '&': <TokenType.AMP: 'AMP'>, '^': <TokenType.CARET: 'CARET'>, ':': <TokenType.COLON: 'COLON'>, ',': <TokenType.COMMA: 'COMMA'>, '.': <TokenType.DOT: 'DOT'>, '-': <TokenType.DASH: 'DASH'>, '=': <TokenType.EQ: 'EQ'>, '>': <TokenType.GT: 'GT'>, '<': <TokenType.LT: 'LT'>, '%': <TokenType.MOD: 'MOD'>, '!': <TokenType.NOT: 'NOT'>, '|': <TokenType.PIPE: 'PIPE'>, '+': <TokenType.PLUS: 'PLUS'>, ';': <TokenType.SEMICOLON: 'SEMICOLON'>, '/': <TokenType.SLASH: 'SLASH'>, '\\': <TokenType.BACKSLASH: 'BACKSLASH'>, '*': <TokenType.STAR: 'STAR'>, '~': <TokenType.TILDA: 'TILDA'>, '?': <TokenType.PLACEHOLDER: 'PLACEHOLDER'>, '@': <TokenType.PARAMETER: 'PARAMETER'>, '#': <TokenType.HASH: 'HASH'>, "'": <TokenType.UNKNOWN: 'UNKNOWN'>, '`': <TokenType.UNKNOWN: 'UNKNOWN'>, '"': <TokenType.UNKNOWN: 'UNKNOWN'>, '$': <TokenType.HEREDOC_STRING: 'HEREDOC_STRING'>}
class ClickHouse.Parser(sqlglot.parser.Parser):
171    class Parser(parser.Parser):
172        # Tested in ClickHouse's playground, it seems that the following two queries do the same thing
173        # * select x from t1 union all select x from t2 limit 1;
174        # * select x from t1 union all (select x from t2 limit 1);
175        MODIFIERS_ATTACHED_TO_SET_OP = False
176        INTERVAL_SPANS = False
177
178        FUNCTIONS = {
179            **parser.Parser.FUNCTIONS,
180            "ANY": exp.AnyValue.from_arg_list,
181            "ARRAYSUM": exp.ArraySum.from_arg_list,
182            "COUNTIF": _build_count_if,
183            "DATE_ADD": build_date_delta(exp.DateAdd, default_unit=None),
184            "DATEADD": build_date_delta(exp.DateAdd, default_unit=None),
185            "DATE_DIFF": build_date_delta(exp.DateDiff, default_unit=None),
186            "DATEDIFF": build_date_delta(exp.DateDiff, default_unit=None),
187            "DATE_FORMAT": _build_date_format,
188            "DATE_SUB": build_date_delta(exp.DateSub, default_unit=None),
189            "DATESUB": build_date_delta(exp.DateSub, default_unit=None),
190            "FORMATDATETIME": _build_date_format,
191            "JSONEXTRACTSTRING": build_json_extract_path(
192                exp.JSONExtractScalar, zero_based_indexing=False
193            ),
194            "MAP": parser.build_var_map,
195            "MATCH": exp.RegexpLike.from_arg_list,
196            "RANDCANONICAL": exp.Rand.from_arg_list,
197            "STR_TO_DATE": _build_str_to_date,
198            "TUPLE": exp.Struct.from_arg_list,
199            "TIMESTAMP_SUB": build_date_delta(exp.TimestampSub, default_unit=None),
200            "TIMESTAMPSUB": build_date_delta(exp.TimestampSub, default_unit=None),
201            "TIMESTAMP_ADD": build_date_delta(exp.TimestampAdd, default_unit=None),
202            "TIMESTAMPADD": build_date_delta(exp.TimestampAdd, default_unit=None),
203            "UNIQ": exp.ApproxDistinct.from_arg_list,
204            "XOR": lambda args: exp.Xor(expressions=args),
205            "MD5": exp.MD5Digest.from_arg_list,
206            "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
207            "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
208        }
209
210        AGG_FUNCTIONS = {
211            "count",
212            "min",
213            "max",
214            "sum",
215            "avg",
216            "any",
217            "stddevPop",
218            "stddevSamp",
219            "varPop",
220            "varSamp",
221            "corr",
222            "covarPop",
223            "covarSamp",
224            "entropy",
225            "exponentialMovingAverage",
226            "intervalLengthSum",
227            "kolmogorovSmirnovTest",
228            "mannWhitneyUTest",
229            "median",
230            "rankCorr",
231            "sumKahan",
232            "studentTTest",
233            "welchTTest",
234            "anyHeavy",
235            "anyLast",
236            "boundingRatio",
237            "first_value",
238            "last_value",
239            "argMin",
240            "argMax",
241            "avgWeighted",
242            "topK",
243            "topKWeighted",
244            "deltaSum",
245            "deltaSumTimestamp",
246            "groupArray",
247            "groupArrayLast",
248            "groupUniqArray",
249            "groupArrayInsertAt",
250            "groupArrayMovingAvg",
251            "groupArrayMovingSum",
252            "groupArraySample",
253            "groupBitAnd",
254            "groupBitOr",
255            "groupBitXor",
256            "groupBitmap",
257            "groupBitmapAnd",
258            "groupBitmapOr",
259            "groupBitmapXor",
260            "sumWithOverflow",
261            "sumMap",
262            "minMap",
263            "maxMap",
264            "skewSamp",
265            "skewPop",
266            "kurtSamp",
267            "kurtPop",
268            "uniq",
269            "uniqExact",
270            "uniqCombined",
271            "uniqCombined64",
272            "uniqHLL12",
273            "uniqTheta",
274            "quantile",
275            "quantiles",
276            "quantileExact",
277            "quantilesExact",
278            "quantileExactLow",
279            "quantilesExactLow",
280            "quantileExactHigh",
281            "quantilesExactHigh",
282            "quantileExactWeighted",
283            "quantilesExactWeighted",
284            "quantileTiming",
285            "quantilesTiming",
286            "quantileTimingWeighted",
287            "quantilesTimingWeighted",
288            "quantileDeterministic",
289            "quantilesDeterministic",
290            "quantileTDigest",
291            "quantilesTDigest",
292            "quantileTDigestWeighted",
293            "quantilesTDigestWeighted",
294            "quantileBFloat16",
295            "quantilesBFloat16",
296            "quantileBFloat16Weighted",
297            "quantilesBFloat16Weighted",
298            "simpleLinearRegression",
299            "stochasticLinearRegression",
300            "stochasticLogisticRegression",
301            "categoricalInformationValue",
302            "contingency",
303            "cramersV",
304            "cramersVBiasCorrected",
305            "theilsU",
306            "maxIntersections",
307            "maxIntersectionsPosition",
308            "meanZTest",
309            "quantileInterpolatedWeighted",
310            "quantilesInterpolatedWeighted",
311            "quantileGK",
312            "quantilesGK",
313            "sparkBar",
314            "sumCount",
315            "largestTriangleThreeBuckets",
316            "histogram",
317            "sequenceMatch",
318            "sequenceCount",
319            "windowFunnel",
320            "retention",
321            "uniqUpTo",
322            "sequenceNextNode",
323            "exponentialTimeDecayedAvg",
324        }
325
326        AGG_FUNCTIONS_SUFFIXES = [
327            "If",
328            "Array",
329            "ArrayIf",
330            "Map",
331            "SimpleState",
332            "State",
333            "Merge",
334            "MergeState",
335            "ForEach",
336            "Distinct",
337            "OrDefault",
338            "OrNull",
339            "Resample",
340            "ArgMin",
341            "ArgMax",
342        ]
343
344        FUNC_TOKENS = {
345            *parser.Parser.FUNC_TOKENS,
346            TokenType.SET,
347        }
348
349        RESERVED_TOKENS = parser.Parser.RESERVED_TOKENS - {TokenType.SELECT}
350
351        ID_VAR_TOKENS = {
352            *parser.Parser.ID_VAR_TOKENS,
353            TokenType.LIKE,
354        }
355
356        AGG_FUNC_MAPPING = (
357            lambda functions, suffixes: {
358                f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions
359            }
360        )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES)
361
362        FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"}
363
364        FUNCTION_PARSERS = {
365            **parser.Parser.FUNCTION_PARSERS,
366            "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()),
367            "QUANTILE": lambda self: self._parse_quantile(),
368        }
369
370        FUNCTION_PARSERS.pop("MATCH")
371
372        NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy()
373        NO_PAREN_FUNCTION_PARSERS.pop("ANY")
374
375        RANGE_PARSERS = {
376            **parser.Parser.RANGE_PARSERS,
377            TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN)
378            and self._parse_in(this, is_global=True),
379        }
380
381        # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to
382        # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler.
383        COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy()
384        COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
385
386        JOIN_KINDS = {
387            *parser.Parser.JOIN_KINDS,
388            TokenType.ANY,
389            TokenType.ASOF,
390            TokenType.ARRAY,
391        }
392
393        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
394            TokenType.ANY,
395            TokenType.ARRAY,
396            TokenType.FINAL,
397            TokenType.FORMAT,
398            TokenType.SETTINGS,
399        }
400
401        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
402            TokenType.FORMAT,
403        }
404
405        LOG_DEFAULTS_TO_LN = True
406
407        QUERY_MODIFIER_PARSERS = {
408            **parser.Parser.QUERY_MODIFIER_PARSERS,
409            TokenType.SETTINGS: lambda self: (
410                "settings",
411                self._advance() or self._parse_csv(self._parse_assignment),
412            ),
413            TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
414        }
415
416        CONSTRAINT_PARSERS = {
417            **parser.Parser.CONSTRAINT_PARSERS,
418            "INDEX": lambda self: self._parse_index_constraint(),
419            "CODEC": lambda self: self._parse_compress(),
420        }
421
422        ALTER_PARSERS = {
423            **parser.Parser.ALTER_PARSERS,
424            "REPLACE": lambda self: self._parse_alter_table_replace(),
425        }
426
427        SCHEMA_UNNAMED_CONSTRAINTS = {
428            *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
429            "INDEX",
430        }
431
432        def _parse_create(self) -> exp.Create | exp.Command:
433            create = super()._parse_create()
434
435            # DATABASE in ClickHouse is the same as SCHEMA in other dialects
436            if isinstance(create, exp.Create) and create.kind == "DATABASE":
437                create.set("kind", "SCHEMA")
438
439            return create
440
441        def _parse_extract(self) -> exp.Extract | exp.Anonymous:
442            index = self._index
443            this = self._parse_bitwise()
444            if self._match(TokenType.FROM):
445                self._retreat(index)
446                return super()._parse_extract()
447
448            # We return Anonymous here because extract and regexpExtract have different semantics,
449            # so parsing extract(foo, bar) into RegexpExtract can potentially break queries. E.g.,
450            # `extract('foobar', 'b')` works, but ClickHouse crashes for `regexpExtract('foobar', 'b')`.
451            #
452            # TODO: can we somehow convert the former into an equivalent `regexpExtract` call?
453            self._match(TokenType.COMMA)
454            return self.expression(
455                exp.Anonymous, this="extract", expressions=[this, self._parse_bitwise()]
456            )
457
458        def _parse_assignment(self) -> t.Optional[exp.Expression]:
459            this = super()._parse_assignment()
460
461            if self._match(TokenType.PLACEHOLDER):
462                return self.expression(
463                    exp.If,
464                    this=this,
465                    true=self._parse_assignment(),
466                    false=self._match(TokenType.COLON) and self._parse_assignment(),
467                )
468
469            return this
470
471        def _parse_placeholder(self) -> t.Optional[exp.Expression]:
472            """
473            Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
474            https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
475            """
476            if not self._match(TokenType.L_BRACE):
477                return None
478
479            this = self._parse_id_var()
480            self._match(TokenType.COLON)
481            kind = self._parse_types(check_func=False, allow_identifiers=False) or (
482                self._match_text_seq("IDENTIFIER") and "Identifier"
483            )
484
485            if not kind:
486                self.raise_error("Expecting a placeholder type or 'Identifier' for tables")
487            elif not self._match(TokenType.R_BRACE):
488                self.raise_error("Expecting }")
489
490            return self.expression(exp.Placeholder, this=this, kind=kind)
491
492        def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In:
493            this = super()._parse_in(this)
494            this.set("is_global", is_global)
495            return this
496
497        def _parse_table(
498            self,
499            schema: bool = False,
500            joins: bool = False,
501            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
502            parse_bracket: bool = False,
503            is_db_reference: bool = False,
504            parse_partition: bool = False,
505        ) -> t.Optional[exp.Expression]:
506            this = super()._parse_table(
507                schema=schema,
508                joins=joins,
509                alias_tokens=alias_tokens,
510                parse_bracket=parse_bracket,
511                is_db_reference=is_db_reference,
512            )
513
514            if self._match(TokenType.FINAL):
515                this = self.expression(exp.Final, this=this)
516
517            return this
518
519        def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
520            return super()._parse_position(haystack_first=True)
521
522        # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
523        def _parse_cte(self) -> exp.CTE:
524            # WITH <identifier> AS <subquery expression>
525            cte: t.Optional[exp.CTE] = self._try_parse(super()._parse_cte)
526
527            if not cte:
528                # WITH <expression> AS <identifier>
529                cte = self.expression(
530                    exp.CTE,
531                    this=self._parse_assignment(),
532                    alias=self._parse_table_alias(),
533                    scalar=True,
534                )
535
536            return cte
537
538        def _parse_join_parts(
539            self,
540        ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
541            is_global = self._match(TokenType.GLOBAL) and self._prev
542            kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev
543
544            if kind_pre:
545                kind = self._match_set(self.JOIN_KINDS) and self._prev
546                side = self._match_set(self.JOIN_SIDES) and self._prev
547                return is_global, side, kind
548
549            return (
550                is_global,
551                self._match_set(self.JOIN_SIDES) and self._prev,
552                self._match_set(self.JOIN_KINDS) and self._prev,
553            )
554
555        def _parse_join(
556            self, skip_join_token: bool = False, parse_bracket: bool = False
557        ) -> t.Optional[exp.Join]:
558            join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True)
559            if join:
560                join.set("global", join.args.pop("method", None))
561
562            return join
563
564        def _parse_function(
565            self,
566            functions: t.Optional[t.Dict[str, t.Callable]] = None,
567            anonymous: bool = False,
568            optional_parens: bool = True,
569            any_token: bool = False,
570        ) -> t.Optional[exp.Expression]:
571            expr = super()._parse_function(
572                functions=functions,
573                anonymous=anonymous,
574                optional_parens=optional_parens,
575                any_token=any_token,
576            )
577
578            func = expr.this if isinstance(expr, exp.Window) else expr
579
580            # Aggregate functions can be split in 2 parts: <func_name><suffix>
581            parts = (
582                self.AGG_FUNC_MAPPING.get(func.this) if isinstance(func, exp.Anonymous) else None
583            )
584
585            if parts:
586                params = self._parse_func_params(func)
587
588                kwargs = {
589                    "this": func.this,
590                    "expressions": func.expressions,
591                }
592                if parts[1]:
593                    kwargs["parts"] = parts
594                    exp_class = exp.CombinedParameterizedAgg if params else exp.CombinedAggFunc
595                else:
596                    exp_class = exp.ParameterizedAgg if params else exp.AnonymousAggFunc
597
598                kwargs["exp_class"] = exp_class
599                if params:
600                    kwargs["params"] = params
601
602                func = self.expression(**kwargs)
603
604                if isinstance(expr, exp.Window):
605                    # The window's func was parsed as Anonymous in base parser, fix its
606                    # type to be ClickHouse style CombinedAnonymousAggFunc / AnonymousAggFunc
607                    expr.set("this", func)
608                elif params:
609                    # Params have blocked super()._parse_function() from parsing the following window
610                    # (if that exists) as they're standing between the function call and the window spec
611                    expr = self._parse_window(func)
612                else:
613                    expr = func
614
615            return expr
616
617        def _parse_func_params(
618            self, this: t.Optional[exp.Func] = None
619        ) -> t.Optional[t.List[exp.Expression]]:
620            if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
621                return self._parse_csv(self._parse_lambda)
622
623            if self._match(TokenType.L_PAREN):
624                params = self._parse_csv(self._parse_lambda)
625                self._match_r_paren(this)
626                return params
627
628            return None
629
630        def _parse_quantile(self) -> exp.Quantile:
631            this = self._parse_lambda()
632            params = self._parse_func_params()
633            if params:
634                return self.expression(exp.Quantile, this=params[0], quantile=this)
635            return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5))
636
637        def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
638            return super()._parse_wrapped_id_vars(optional=True)
639
640        def _parse_primary_key(
641            self, wrapped_optional: bool = False, in_props: bool = False
642        ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
643            return super()._parse_primary_key(
644                wrapped_optional=wrapped_optional or in_props, in_props=in_props
645            )
646
647        def _parse_on_property(self) -> t.Optional[exp.Expression]:
648            index = self._index
649            if self._match_text_seq("CLUSTER"):
650                this = self._parse_id_var()
651                if this:
652                    return self.expression(exp.OnCluster, this=this)
653                else:
654                    self._retreat(index)
655            return None
656
657        def _parse_index_constraint(
658            self, kind: t.Optional[str] = None
659        ) -> exp.IndexColumnConstraint:
660            # INDEX name1 expr TYPE type1(args) GRANULARITY value
661            this = self._parse_id_var()
662            expression = self._parse_assignment()
663
664            index_type = self._match_text_seq("TYPE") and (
665                self._parse_function() or self._parse_var()
666            )
667
668            granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
669
670            return self.expression(
671                exp.IndexColumnConstraint,
672                this=this,
673                expression=expression,
674                index_type=index_type,
675                granularity=granularity,
676            )
677
678        def _parse_partition(self) -> t.Optional[exp.Partition]:
679            # https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#how-to-set-partition-expression
680            if not self._match(TokenType.PARTITION):
681                return None
682
683            if self._match_text_seq("ID"):
684                # Corresponds to the PARTITION ID <string_value> syntax
685                expressions: t.List[exp.Expression] = [
686                    self.expression(exp.PartitionId, this=self._parse_string())
687                ]
688            else:
689                expressions = self._parse_expressions()
690
691            return self.expression(exp.Partition, expressions=expressions)
692
693        def _parse_alter_table_replace(self) -> t.Optional[exp.Expression]:
694            partition = self._parse_partition()
695
696            if not partition or not self._match(TokenType.FROM):
697                return None
698
699            return self.expression(
700                exp.ReplacePartition, expression=partition, source=self._parse_table_parts()
701            )
702
703        def _parse_projection_def(self) -> t.Optional[exp.ProjectionDef]:
704            if not self._match_text_seq("PROJECTION"):
705                return None
706
707            return self.expression(
708                exp.ProjectionDef,
709                this=self._parse_id_var(),
710                expression=self._parse_wrapped(self._parse_statement),
711            )
712
713        def _parse_constraint(self) -> t.Optional[exp.Expression]:
714            return super()._parse_constraint() or self._parse_projection_def()

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
MODIFIERS_ATTACHED_TO_SET_OP = False
INTERVAL_SPANS = False
FUNCTIONS = {'ABS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Abs'>>, 'ADD_MONTHS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AddMonths'>>, 'ANONYMOUS_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnonymousAggFunc'>>, 'ANY_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnyValue'>>, 'APPROX_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_COUNT_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxQuantile'>>, 'APPROX_TOP_K': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxTopK'>>, 'ARG_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARGMAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'MAX_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARG_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARGMIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'MIN_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARRAY': <function Parser.<lambda>>, 'ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAgg'>>, 'ARRAY_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAll'>>, 'ARRAY_ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAny'>>, 'ARRAY_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CONSTRUCT_COMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConstructCompact'>>, 'ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContains'>>, 'ARRAY_HAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContains'>>, 'ARRAY_CONTAINS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContainsAll'>>, 'ARRAY_HAS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContainsAll'>>, 'FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_OVERLAPS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayOverlaps'>>, 'ARRAY_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_SORT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySort'>>, 'ARRAY_SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySum'>>, 'ARRAY_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayToString'>>, 'ARRAY_JOIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayToString'>>, 'ARRAY_UNION_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUnionAgg'>>, 'ARRAY_UNIQUE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUniqueAgg'>>, 'AVG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Avg'>>, 'CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Case'>>, 'CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cast'>>, 'CAST_TO_STR_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CastToStrType'>>, 'CBRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cbrt'>>, 'CEIL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CEILING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CHR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Chr'>>, 'CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Chr'>>, 'COALESCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'IFNULL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'NVL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'COLLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Collate'>>, 'COMBINED_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedAggFunc'>>, 'COMBINED_PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedParameterizedAgg'>>, 'CONCAT': <function Parser.<lambda>>, 'CONCAT_WS': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ConnectByRoot'>>, 'CONVERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Convert'>>, 'CONVERT_TIMEZONE': <function build_convert_timezone>, 'CORR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Corr'>>, 'COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Count'>>, 'COUNT_IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CountIf'>>, 'COUNTIF': <function _build_count_if>, 'COVAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CovarPop'>>, 'COVAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CovarSamp'>>, 'CURRENT_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDate'>>, 'CURRENT_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDatetime'>>, 'CURRENT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTime'>>, 'CURRENT_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTimestamp'>>, 'CURRENT_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentUser'>>, 'DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Date'>>, 'DATE_ADD': <function build_date_delta.<locals>._builder>, '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.DateFromParts'>>, 'DATEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATE_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.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.DateToDi'>>, 'DATE_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateTrunc'>>, 'DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Datetime'>>, 'DATETIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeAdd'>>, 'DATETIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeDiff'>>, 'DATETIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeSub'>>, 'DATETIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeTrunc'>>, 'DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Day'>>, 'DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAYOFMONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAY_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAYOFWEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAY_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DAYOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DECODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Decode'>>, 'DI_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DiToDate'>>, 'ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Encode'>>, 'EXP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Exp'>>, 'EXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Explode'>>, 'EXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ExplodeOuter'>>, 'EXPLODING_GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ExplodingGenerateSeries'>>, 'EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Extract'>>, 'FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.First'>>, 'FIRST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FirstValue'>>, 'FLATTEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Flatten'>>, 'FLOOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Floor'>>, 'FROM_BASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase'>>, 'FROM_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase64'>>, 'GAP_FILL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GapFill'>>, 'GENERATE_DATE_ARRAY': <function Parser.<lambda>>, 'GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateSeries'>>, 'GENERATE_TIMESTAMP_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateTimestampArray'>>, 'GREATEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Greatest'>>, 'GROUP_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GroupConcat'>>, 'HEX': <function build_hex>, 'HLL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Hll'>>, 'IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'IIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'INITCAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Initcap'>>, 'IS_INF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'ISINF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'IS_NAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'ISNAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'J_S_O_N_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArray'>>, 'J_S_O_N_ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayAgg'>>, 'JSON_ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayContains'>>, 'JSONB_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBContains'>>, 'JSONB_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtract'>>, 'JSONB_EXTRACT_SCALAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtractScalar'>>, 'JSON_EXTRACT': <function build_extract_json_with_path.<locals>._builder>, 'JSON_EXTRACT_SCALAR': <function build_extract_json_with_path.<locals>._builder>, 'JSON_FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONFormat'>>, 'J_S_O_N_OBJECT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObject'>>, 'J_S_O_N_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObjectAgg'>>, 'J_S_O_N_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONTable'>>, 'LAG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lag'>>, 'LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Last'>>, 'LAST_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastValue'>>, 'LEAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lead'>>, 'LEAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Least'>>, 'LEFT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Left'>>, 'LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEVENSHTEIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Levenshtein'>>, 'LIST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.List'>>, 'LN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ln'>>, 'LOG': <function build_logarithm>, 'LOGICAL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOLAND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'LOGICAL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOLOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'LOWER': <function build_lower>, 'LCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lower'>>, 'LOWER_HEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LowerHex'>>, 'MD5': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5Digest'>>, 'MD5_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5Digest'>>, 'MAP': <function build_var_map>, 'MAP_FROM_ENTRIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MapFromEntries'>>, 'MATCH_AGAINST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MatchAgainst'>>, 'MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Max'>>, 'MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Min'>>, 'MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Month'>>, 'MONTHS_BETWEEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MonthsBetween'>>, 'NEXT_VALUE_FOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NextValueFor'>>, 'NTH_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NthValue'>>, 'NULLIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nullif'>>, 'NUMBER_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NumberToStr'>>, 'NVL2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nvl2'>>, 'OBJECT_INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ObjectInsert'>>, 'OPEN_J_S_O_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.OpenJSON'>>, 'PAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pad'>>, 'PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParameterizedAgg'>>, 'PARSE_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'JSON_PARSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'PERCENTILE_CONT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileCont'>>, 'PERCENTILE_DISC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileDisc'>>, 'POSEXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Posexplode'>>, 'POSEXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PosexplodeOuter'>>, 'POWER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'POW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'PREDICT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Predict'>>, 'QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quantile'>>, 'QUARTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quarter'>>, 'RAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDOM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Randn'>>, 'RANGE_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RangeN'>>, 'READ_CSV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ReadCSV'>>, 'REDUCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Reduce'>>, 'REGEXP_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpExtract'>>, 'REGEXP_I_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpILike'>>, 'REGEXP_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpLike'>>, 'REGEXP_REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpReplace'>>, 'REGEXP_SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpSplit'>>, 'REPEAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Repeat'>>, 'RIGHT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Right'>>, 'ROUND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Round'>>, 'ROW_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RowNumber'>>, 'SHA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA2'>>, 'SAFE_DIVIDE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SafeDivide'>>, 'SIGN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sign'>>, 'SIGNUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sign'>>, 'SORT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SortArray'>>, 'SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Split'>>, 'SQRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sqrt'>>, 'STANDARD_HASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StandardHash'>>, 'STAR_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StarMap'>>, 'STARTS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STARTSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STDDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stddev'>>, 'STDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stddev'>>, 'STDDEV_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevPop'>>, 'STDDEV_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevSamp'>>, 'STR_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrPosition'>>, 'STR_TO_DATE': <function _build_str_to_date>, 'STR_TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToMap'>>, 'STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToTime'>>, 'STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToUnix'>>, 'STRING_TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StringToArray'>>, 'SPLIT_BY_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StringToArray'>>, 'STRUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Struct'>>, 'STRUCT_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StructExtract'>>, 'STUFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'SUBSTRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Substring'>>, 'SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sum'>>, 'TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Time'>>, 'TIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeAdd'>>, 'TIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeDiff'>>, 'TIME_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIMEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIME_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToDate'>>, 'TIME_STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToTime'>>, 'TIME_STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToUnix'>>, 'TIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeSub'>>, 'TIME_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToStr'>>, 'TIME_TO_TIME_STR': <function Parser.<lambda>>, 'TIME_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToUnix'>>, 'TIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeTrunc'>>, 'TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Timestamp'>>, 'TIMESTAMP_ADD': <function build_date_delta.<locals>._builder>, 'TIMESTAMPDIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampDiff'>>, 'TIMESTAMP_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampDiff'>>, 'TIMESTAMP_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMPFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMP_SUB': <function build_date_delta.<locals>._builder>, 'TIMESTAMP_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampTrunc'>>, 'TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToArray'>>, 'TO_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToBase64'>>, 'TO_CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToChar'>>, 'TO_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToDays'>>, 'TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToMap'>>, 'TO_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToNumber'>>, 'TRANSFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Transform'>>, 'TRIM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Trim'>>, 'TRY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Try'>>, 'TRY_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TryCast'>>, 'TS_OR_DI_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDiToDi'>>, 'TS_OR_DS_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsAdd'>>, 'TS_OR_DS_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsDiff'>>, 'TS_OR_DS_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToDate'>>, 'TS_OR_DS_TO_DATE_STR': <function Parser.<lambda>>, 'TS_OR_DS_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTime'>>, 'TS_OR_DS_TO_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTimestamp'>>, 'UNHEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Unhex'>>, 'UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixDate'>>, 'UNIX_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToStr'>>, 'UNIX_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTime'>>, 'UNIX_TO_TIME_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTimeStr'>>, 'UNNEST': <function Parser.<lambda>>, 'UPPER': <function build_upper>, 'UCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Upper'>>, 'VAR_MAP': <function build_var_map>, 'VARIANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'VAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Week'>>, 'WEEK_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'WEEKOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'WHEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.When'>>, 'X_M_L_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.XMLTable'>>, 'XOR': <function ClickHouse.Parser.<lambda>>, 'YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Year'>>, 'GLOB': <function Parser.<lambda>>, 'JSON_EXTRACT_PATH_TEXT': <function build_extract_json_with_path.<locals>._builder>, 'LIKE': <function build_like>, 'LOG2': <function Parser.<lambda>>, 'LOG10': <function Parser.<lambda>>, 'LPAD': <function Parser.<lambda>>, 'LEFTPAD': <function Parser.<lambda>>, 'MOD': <function build_mod>, 'RPAD': <function Parser.<lambda>>, 'RIGHTPAD': <function Parser.<lambda>>, 'SCOPE_RESOLUTION': <function Parser.<lambda>>, 'TO_HEX': <function build_hex>, 'ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnyValue'>>, 'ARRAYSUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySum'>>, 'DATEADD': <function build_date_delta.<locals>._builder>, 'DATE_FORMAT': <function _build_date_format>, 'DATESUB': <function build_date_delta.<locals>._builder>, 'FORMATDATETIME': <function _build_date_format>, 'JSONEXTRACTSTRING': <function build_json_extract_path.<locals>._builder>, 'MATCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpLike'>>, 'RANDCANONICAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'TUPLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Struct'>>, 'TIMESTAMPSUB': <function build_date_delta.<locals>._builder>, 'TIMESTAMPADD': <function build_date_delta.<locals>._builder>, 'UNIQ': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'SHA256': <function ClickHouse.Parser.<lambda>>, 'SHA512': <function ClickHouse.Parser.<lambda>>}
AGG_FUNCTIONS = {'quantilesGK', 'skewSamp', 'quantilesExact', 'kolmogorovSmirnovTest', 'uniq', 'studentTTest', 'groupUniqArray', 'uniqUpTo', 'groupArrayMovingSum', 'uniqExact', 'min', 'skewPop', 'quantileExact', 'deltaSum', 'maxIntersectionsPosition', 'simpleLinearRegression', 'stddevSamp', 'uniqTheta', 'uniqCombined', 'quantileExactWeighted', 'rankCorr', 'sequenceCount', 'sequenceMatch', 'histogram', 'groupBitOr', 'max', 'quantileTiming', 'contingency', 'maxIntersections', 'groupBitmapOr', 'quantilesTDigest', 'avgWeighted', 'entropy', 'kurtPop', 'quantiles', 'avg', 'groupArrayLast', 'groupBitmapAnd', 'sumWithOverflow', 'quantilesBFloat16', 'sumKahan', 'quantileGK', 'covarPop', 'quantilesBFloat16Weighted', 'sumMap', 'groupArraySample', 'groupBitXor', 'argMax', 'quantilesTimingWeighted', 'quantileExactHigh', 'quantileDeterministic', 'meanZTest', 'sumCount', 'exponentialMovingAverage', 'anyHeavy', 'stddevPop', 'exponentialTimeDecayedAvg', 'any', 'quantileTDigestWeighted', 'minMap', 'corr', 'stochasticLogisticRegression', 'varSamp', 'welchTTest', 'covarSamp', 'sparkBar', 'maxMap', 'groupArray', 'largestTriangleThreeBuckets', 'deltaSumTimestamp', 'uniqHLL12', 'groupBitAnd', 'quantileBFloat16Weighted', 'kurtSamp', 'topK', 'quantileBFloat16', 'cramersV', 'anyLast', 'quantilesExactLow', 'sum', 'quantileExactLow', 'quantilesTDigestWeighted', 'argMin', 'quantile', 'quantileInterpolatedWeighted', 'quantilesTiming', 'theilsU', 'last_value', 'groupBitmap', 'uniqCombined64', 'mannWhitneyUTest', 'categoricalInformationValue', 'count', 'quantilesDeterministic', 'quantilesExactHigh', 'first_value', 'median', 'quantileTDigest', 'intervalLengthSum', 'sequenceNextNode', 'boundingRatio', 'varPop', 'stochasticLinearRegression', 'quantileTimingWeighted', 'quantilesExactWeighted', 'groupBitmapXor', 'retention', 'cramersVBiasCorrected', 'groupArrayMovingAvg', 'quantilesInterpolatedWeighted', 'topKWeighted', 'groupArrayInsertAt', 'windowFunnel'}
AGG_FUNCTIONS_SUFFIXES = ['If', 'Array', 'ArrayIf', 'Map', 'SimpleState', 'State', 'Merge', 'MergeState', 'ForEach', 'Distinct', 'OrDefault', 'OrNull', 'Resample', 'ArgMin', 'ArgMax']
FUNC_TOKENS = {<TokenType.REPLACE: 'REPLACE'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ALL: 'ALL'>, <TokenType.TIME: 'TIME'>, <TokenType.UUID: 'UUID'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.NAME: 'NAME'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.UINT: 'UINT'>, <TokenType.ENUM: 'ENUM'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.INDEX: 'INDEX'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TEXT: 'TEXT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.JSON: 'JSON'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.LIKE: 'LIKE'>, <TokenType.FIRST: 'FIRST'>, <TokenType.ILIKE: 'ILIKE'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, <TokenType.INET: 'INET'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.XML: 'XML'>, <TokenType.UINT256: 'UINT256'>, <TokenType.MAP: 'MAP'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.INT128: 'INT128'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.LIST: 'LIST'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.ROW: 'ROW'>, <TokenType.NULL: 'NULL'>, <TokenType.CHAR: 'CHAR'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.SUPER: 'SUPER'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.TABLE: 'TABLE'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.INT256: 'INT256'>, <TokenType.DATE32: 'DATE32'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.NESTED: 'NESTED'>, <TokenType.DATE: 'DATE'>, <TokenType.YEAR: 'YEAR'>, <TokenType.IPV6: 'IPV6'>, <TokenType.BIT: 'BIT'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.MONEY: 'MONEY'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.LEFT: 'LEFT'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.GLOB: 'GLOB'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.SOME: 'SOME'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.UINT128: 'UINT128'>, <TokenType.XOR: 'XOR'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.INSERT: 'INSERT'>, <TokenType.ANY: 'ANY'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.JSONB: 'JSONB'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.INT: 'INT'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.RLIKE: 'RLIKE'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.RANGE: 'RANGE'>, <TokenType.IPV4: 'IPV4'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.VAR: 'VAR'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.SET: 'SET'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.BINARY: 'BINARY'>}
RESERVED_TOKENS = {<TokenType.L_PAREN: 'L_PAREN'>, <TokenType.GT: 'GT'>, <TokenType.R_PAREN: 'R_PAREN'>, <TokenType.L_BRACE: 'L_BRACE'>, <TokenType.MOD: 'MOD'>, <TokenType.STAR: 'STAR'>, <TokenType.R_BRACKET: 'R_BRACKET'>, <TokenType.SEMICOLON: 'SEMICOLON'>, <TokenType.BACKSLASH: 'BACKSLASH'>, <TokenType.LT: 'LT'>, <TokenType.COLON: 'COLON'>, <TokenType.PLACEHOLDER: 'PLACEHOLDER'>, <TokenType.HASH: 'HASH'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.SLASH: 'SLASH'>, <TokenType.L_BRACKET: 'L_BRACKET'>, <TokenType.DOT: 'DOT'>, <TokenType.PARAMETER: 'PARAMETER'>, <TokenType.PLUS: 'PLUS'>, <TokenType.CARET: 'CARET'>, <TokenType.COMMA: 'COMMA'>, <TokenType.PIPE: 'PIPE'>, <TokenType.DASH: 'DASH'>, <TokenType.TILDA: 'TILDA'>, <TokenType.R_BRACE: 'R_BRACE'>, <TokenType.NOT: 'NOT'>, <TokenType.AMP: 'AMP'>, <TokenType.EQ: 'EQ'>}
ID_VAR_TOKENS = {<TokenType.REPLACE: 'REPLACE'>, <TokenType.ALL: 'ALL'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.CACHE: 'CACHE'>, <TokenType.TIME: 'TIME'>, <TokenType.UUID: 'UUID'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.NAME: 'NAME'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.UINT: 'UINT'>, <TokenType.ENUM: 'ENUM'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, <TokenType.INDEX: 'INDEX'>, <TokenType.FULL: 'FULL'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TEXT: 'TEXT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.JSON: 'JSON'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.LIKE: 'LIKE'>, <TokenType.ASOF: 'ASOF'>, <TokenType.MODEL: 'MODEL'>, <TokenType.FIRST: 'FIRST'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.RENAME: 'RENAME'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.INET: 'INET'>, <TokenType.KEEP: 'KEEP'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.XML: 'XML'>, <TokenType.UINT256: 'UINT256'>, <TokenType.MAP: 'MAP'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.TRUE: 'TRUE'>, <TokenType.INT128: 'INT128'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.CUBE: 'CUBE'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.SEMI: 'SEMI'>, <TokenType.LIST: 'LIST'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.VIEW: 'VIEW'>, <TokenType.SHOW: 'SHOW'>, <TokenType.COPY: 'COPY'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.CASE: 'CASE'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.FINAL: 'FINAL'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.ROW: 'ROW'>, <TokenType.NULL: 'NULL'>, <TokenType.CHAR: 'CHAR'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.SUPER: 'SUPER'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.TABLE: 'TABLE'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.INT256: 'INT256'>, <TokenType.DATE32: 'DATE32'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.NESTED: 'NESTED'>, <TokenType.DATE: 'DATE'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.YEAR: 'YEAR'>, <TokenType.IPV6: 'IPV6'>, <TokenType.BIT: 'BIT'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.MONEY: 'MONEY'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.KILL: 'KILL'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.LEFT: 'LEFT'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.ASC: 'ASC'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.USE: 'USE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.ROWS: 'ROWS'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.FALSE: 'FALSE'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.DIV: 'DIV'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.SOME: 'SOME'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.UINT128: 'UINT128'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.APPLY: 'APPLY'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.ANY: 'ANY'>, <TokenType.END: 'END'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.JSONB: 'JSONB'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.DELETE: 'DELETE'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.INT: 'INT'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.MERGE: 'MERGE'>, <TokenType.ANTI: 'ANTI'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.DESC: 'DESC'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.TAG: 'TAG'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.RANGE: 'RANGE'>, <TokenType.IPV4: 'IPV4'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.VAR: 'VAR'>, <TokenType.IS: 'IS'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.LOAD: 'LOAD'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.TOP: 'TOP'>, <TokenType.SET: 'SET'>, <TokenType.NEXT: 'NEXT'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.BINARY: 'BINARY'>}
AGG_FUNC_MAPPING = {'quantilesGKIf': ('quantilesGK', 'If'), 'skewSampIf': ('skewSamp', 'If'), 'quantilesExactIf': ('quantilesExact', 'If'), 'kolmogorovSmirnovTestIf': ('kolmogorovSmirnovTest', 'If'), 'uniqIf': ('uniq', 'If'), 'studentTTestIf': ('studentTTest', 'If'), 'groupUniqArrayIf': ('groupUniqArray', 'If'), 'uniqUpToIf': ('uniqUpTo', 'If'), 'groupArrayMovingSumIf': ('groupArrayMovingSum', 'If'), 'uniqExactIf': ('uniqExact', 'If'), 'minIf': ('min', 'If'), 'skewPopIf': ('skewPop', 'If'), 'quantileExactIf': ('quantileExact', 'If'), 'deltaSumIf': ('deltaSum', 'If'), 'maxIntersectionsPositionIf': ('maxIntersectionsPosition', 'If'), 'simpleLinearRegressionIf': ('simpleLinearRegression', 'If'), 'stddevSampIf': ('stddevSamp', 'If'), 'uniqThetaIf': ('uniqTheta', 'If'), 'uniqCombinedIf': ('uniqCombined', 'If'), 'quantileExactWeightedIf': ('quantileExactWeighted', 'If'), 'rankCorrIf': ('rankCorr', 'If'), 'sequenceCountIf': ('sequenceCount', 'If'), 'sequenceMatchIf': ('sequenceMatch', 'If'), 'histogramIf': ('histogram', 'If'), 'groupBitOrIf': ('groupBitOr', 'If'), 'maxIf': ('max', 'If'), 'quantileTimingIf': ('quantileTiming', 'If'), 'contingencyIf': ('contingency', 'If'), 'maxIntersectionsIf': ('maxIntersections', 'If'), 'groupBitmapOrIf': ('groupBitmapOr', 'If'), 'quantilesTDigestIf': ('quantilesTDigest', 'If'), 'avgWeightedIf': ('avgWeighted', 'If'), 'entropyIf': ('entropy', 'If'), 'kurtPopIf': ('kurtPop', 'If'), 'quantilesIf': ('quantiles', 'If'), 'avgIf': ('avg', 'If'), 'groupArrayLastIf': ('groupArrayLast', 'If'), 'groupBitmapAndIf': ('groupBitmapAnd', 'If'), 'sumWithOverflowIf': ('sumWithOverflow', 'If'), 'quantilesBFloat16If': ('quantilesBFloat16', 'If'), 'sumKahanIf': ('sumKahan', 'If'), 'quantileGKIf': ('quantileGK', 'If'), 'covarPopIf': ('covarPop', 'If'), 'quantilesBFloat16WeightedIf': ('quantilesBFloat16Weighted', 'If'), 'sumMapIf': ('sumMap', 'If'), 'groupArraySampleIf': ('groupArraySample', 'If'), 'groupBitXorIf': ('groupBitXor', 'If'), 'argMaxIf': ('argMax', 'If'), 'quantilesTimingWeightedIf': ('quantilesTimingWeighted', 'If'), 'quantileExactHighIf': ('quantileExactHigh', 'If'), 'quantileDeterministicIf': ('quantileDeterministic', 'If'), 'meanZTestIf': ('meanZTest', 'If'), 'sumCountIf': ('sumCount', 'If'), 'exponentialMovingAverageIf': ('exponentialMovingAverage', 'If'), 'anyHeavyIf': ('anyHeavy', 'If'), 'stddevPopIf': ('stddevPop', 'If'), 'exponentialTimeDecayedAvgIf': ('exponentialTimeDecayedAvg', 'If'), 'anyIf': ('any', 'If'), 'quantileTDigestWeightedIf': ('quantileTDigestWeighted', 'If'), 'minMapIf': ('minMap', 'If'), 'corrIf': ('corr', 'If'), 'stochasticLogisticRegressionIf': ('stochasticLogisticRegression', 'If'), 'varSampIf': ('varSamp', 'If'), 'welchTTestIf': ('welchTTest', 'If'), 'covarSampIf': ('covarSamp', 'If'), 'sparkBarIf': ('sparkBar', 'If'), 'maxMapIf': ('maxMap', 'If'), 'groupArrayIf': ('groupArray', 'If'), 'largestTriangleThreeBucketsIf': ('largestTriangleThreeBuckets', 'If'), 'deltaSumTimestampIf': ('deltaSumTimestamp', 'If'), 'uniqHLL12If': ('uniqHLL12', 'If'), 'groupBitAndIf': ('groupBitAnd', 'If'), 'quantileBFloat16WeightedIf': ('quantileBFloat16Weighted', 'If'), 'kurtSampIf': ('kurtSamp', 'If'), 'topKIf': ('topK', 'If'), 'quantileBFloat16If': ('quantileBFloat16', 'If'), 'cramersVIf': ('cramersV', 'If'), 'anyLastIf': ('anyLast', 'If'), 'quantilesExactLowIf': ('quantilesExactLow', 'If'), 'sumIf': ('sum', 'If'), 'quantileExactLowIf': ('quantileExactLow', 'If'), 'quantilesTDigestWeightedIf': ('quantilesTDigestWeighted', 'If'), 'argMinIf': ('argMin', 'If'), 'quantileIf': ('quantile', 'If'), 'quantileInterpolatedWeightedIf': ('quantileInterpolatedWeighted', 'If'), 'quantilesTimingIf': ('quantilesTiming', 'If'), 'theilsUIf': ('theilsU', 'If'), 'last_valueIf': ('last_value', 'If'), 'groupBitmapIf': ('groupBitmap', 'If'), 'uniqCombined64If': ('uniqCombined64', 'If'), 'mannWhitneyUTestIf': ('mannWhitneyUTest', 'If'), 'categoricalInformationValueIf': ('categoricalInformationValue', 'If'), 'countIf': ('count', 'If'), 'quantilesDeterministicIf': ('quantilesDeterministic', 'If'), 'quantilesExactHighIf': ('quantilesExactHigh', 'If'), 'first_valueIf': ('first_value', 'If'), 'medianIf': ('median', 'If'), 'quantileTDigestIf': ('quantileTDigest', 'If'), 'intervalLengthSumIf': ('intervalLengthSum', 'If'), 'sequenceNextNodeIf': ('sequenceNextNode', 'If'), 'boundingRatioIf': ('boundingRatio', 'If'), 'varPopIf': ('varPop', 'If'), 'stochasticLinearRegressionIf': ('stochasticLinearRegression', 'If'), 'quantileTimingWeightedIf': ('quantileTimingWeighted', 'If'), 'quantilesExactWeightedIf': ('quantilesExactWeighted', 'If'), 'groupBitmapXorIf': ('groupBitmapXor', 'If'), 'retentionIf': ('retention', 'If'), 'cramersVBiasCorrectedIf': ('cramersVBiasCorrected', 'If'), 'groupArrayMovingAvgIf': ('groupArrayMovingAvg', 'If'), 'quantilesInterpolatedWeightedIf': ('quantilesInterpolatedWeighted', 'If'), 'topKWeightedIf': ('topKWeighted', 'If'), 'groupArrayInsertAtIf': ('groupArrayInsertAt', 'If'), 'windowFunnelIf': ('windowFunnel', 'If'), 'quantilesGKArray': ('quantilesGK', 'Array'), 'skewSampArray': ('skewSamp', 'Array'), 'quantilesExactArray': ('quantilesExact', 'Array'), 'kolmogorovSmirnovTestArray': ('kolmogorovSmirnovTest', 'Array'), 'uniqArray': ('uniq', 'Array'), 'studentTTestArray': ('studentTTest', 'Array'), 'groupUniqArrayArray': ('groupUniqArray', 'Array'), 'uniqUpToArray': ('uniqUpTo', 'Array'), 'groupArrayMovingSumArray': ('groupArrayMovingSum', 'Array'), 'uniqExactArray': ('uniqExact', 'Array'), 'minArray': ('min', 'Array'), 'skewPopArray': ('skewPop', 'Array'), 'quantileExactArray': ('quantileExact', 'Array'), 'deltaSumArray': ('deltaSum', 'Array'), 'maxIntersectionsPositionArray': ('maxIntersectionsPosition', 'Array'), 'simpleLinearRegressionArray': ('simpleLinearRegression', 'Array'), 'stddevSampArray': ('stddevSamp', 'Array'), 'uniqThetaArray': ('uniqTheta', 'Array'), 'uniqCombinedArray': ('uniqCombined', 'Array'), 'quantileExactWeightedArray': ('quantileExactWeighted', 'Array'), 'rankCorrArray': ('rankCorr', 'Array'), 'sequenceCountArray': ('sequenceCount', 'Array'), 'sequenceMatchArray': ('sequenceMatch', 'Array'), 'histogramArray': ('histogram', 'Array'), 'groupBitOrArray': ('groupBitOr', 'Array'), 'maxArray': ('max', 'Array'), 'quantileTimingArray': ('quantileTiming', 'Array'), 'contingencyArray': ('contingency', 'Array'), 'maxIntersectionsArray': ('maxIntersections', 'Array'), 'groupBitmapOrArray': ('groupBitmapOr', 'Array'), 'quantilesTDigestArray': ('quantilesTDigest', 'Array'), 'avgWeightedArray': ('avgWeighted', 'Array'), 'entropyArray': ('entropy', 'Array'), 'kurtPopArray': ('kurtPop', 'Array'), 'quantilesArray': ('quantiles', 'Array'), 'avgArray': ('avg', 'Array'), 'groupArrayLastArray': ('groupArrayLast', 'Array'), 'groupBitmapAndArray': ('groupBitmapAnd', 'Array'), 'sumWithOverflowArray': ('sumWithOverflow', 'Array'), 'quantilesBFloat16Array': ('quantilesBFloat16', 'Array'), 'sumKahanArray': ('sumKahan', 'Array'), 'quantileGKArray': ('quantileGK', 'Array'), 'covarPopArray': ('covarPop', 'Array'), 'quantilesBFloat16WeightedArray': ('quantilesBFloat16Weighted', 'Array'), 'sumMapArray': ('sumMap', 'Array'), 'groupArraySampleArray': ('groupArraySample', 'Array'), 'groupBitXorArray': ('groupBitXor', 'Array'), 'argMaxArray': ('argMax', 'Array'), 'quantilesTimingWeightedArray': ('quantilesTimingWeighted', 'Array'), 'quantileExactHighArray': ('quantileExactHigh', 'Array'), 'quantileDeterministicArray': ('quantileDeterministic', 'Array'), 'meanZTestArray': ('meanZTest', 'Array'), 'sumCountArray': ('sumCount', 'Array'), 'exponentialMovingAverageArray': ('exponentialMovingAverage', 'Array'), 'anyHeavyArray': ('anyHeavy', 'Array'), 'stddevPopArray': ('stddevPop', 'Array'), 'exponentialTimeDecayedAvgArray': ('exponentialTimeDecayedAvg', 'Array'), 'anyArray': ('any', 'Array'), 'quantileTDigestWeightedArray': ('quantileTDigestWeighted', 'Array'), 'minMapArray': ('minMap', 'Array'), 'corrArray': ('corr', 'Array'), 'stochasticLogisticRegressionArray': ('stochasticLogisticRegression', 'Array'), 'varSampArray': ('varSamp', 'Array'), 'welchTTestArray': ('welchTTest', 'Array'), 'covarSampArray': ('covarSamp', 'Array'), 'sparkBarArray': ('sparkBar', 'Array'), 'maxMapArray': ('maxMap', 'Array'), 'groupArrayArray': ('groupArray', 'Array'), 'largestTriangleThreeBucketsArray': ('largestTriangleThreeBuckets', 'Array'), 'deltaSumTimestampArray': ('deltaSumTimestamp', 'Array'), 'uniqHLL12Array': ('uniqHLL12', 'Array'), 'groupBitAndArray': ('groupBitAnd', 'Array'), 'quantileBFloat16WeightedArray': ('quantileBFloat16Weighted', 'Array'), 'kurtSampArray': ('kurtSamp', 'Array'), 'topKArray': ('topK', 'Array'), 'quantileBFloat16Array': ('quantileBFloat16', 'Array'), 'cramersVArray': ('cramersV', 'Array'), 'anyLastArray': ('anyLast', 'Array'), 'quantilesExactLowArray': ('quantilesExactLow', 'Array'), 'sumArray': ('sum', 'Array'), 'quantileExactLowArray': ('quantileExactLow', 'Array'), 'quantilesTDigestWeightedArray': ('quantilesTDigestWeighted', 'Array'), 'argMinArray': ('argMin', 'Array'), 'quantileArray': ('quantile', 'Array'), 'quantileInterpolatedWeightedArray': ('quantileInterpolatedWeighted', 'Array'), 'quantilesTimingArray': ('quantilesTiming', 'Array'), 'theilsUArray': ('theilsU', 'Array'), 'last_valueArray': ('last_value', 'Array'), 'groupBitmapArray': ('groupBitmap', 'Array'), 'uniqCombined64Array': ('uniqCombined64', 'Array'), 'mannWhitneyUTestArray': ('mannWhitneyUTest', 'Array'), 'categoricalInformationValueArray': ('categoricalInformationValue', 'Array'), 'countArray': ('count', 'Array'), 'quantilesDeterministicArray': ('quantilesDeterministic', 'Array'), 'quantilesExactHighArray': ('quantilesExactHigh', 'Array'), 'first_valueArray': ('first_value', 'Array'), 'medianArray': ('median', 'Array'), 'quantileTDigestArray': ('quantileTDigest', 'Array'), 'intervalLengthSumArray': ('intervalLengthSum', 'Array'), 'sequenceNextNodeArray': ('sequenceNextNode', 'Array'), 'boundingRatioArray': ('boundingRatio', 'Array'), 'varPopArray': ('varPop', 'Array'), 'stochasticLinearRegressionArray': ('stochasticLinearRegression', 'Array'), 'quantileTimingWeightedArray': ('quantileTimingWeighted', 'Array'), 'quantilesExactWeightedArray': ('quantilesExactWeighted', 'Array'), 'groupBitmapXorArray': ('groupBitmapXor', 'Array'), 'retentionArray': ('retention', 'Array'), 'cramersVBiasCorrectedArray': ('cramersVBiasCorrected', 'Array'), 'groupArrayMovingAvgArray': ('groupArrayMovingAvg', 'Array'), 'quantilesInterpolatedWeightedArray': ('quantilesInterpolatedWeighted', 'Array'), 'topKWeightedArray': ('topKWeighted', 'Array'), 'groupArrayInsertAtArray': ('groupArrayInsertAt', 'Array'), 'windowFunnelArray': ('windowFunnel', 'Array'), 'quantilesGKArrayIf': ('quantilesGK', 'ArrayIf'), 'skewSampArrayIf': ('skewSamp', 'ArrayIf'), 'quantilesExactArrayIf': ('quantilesExact', 'ArrayIf'), 'kolmogorovSmirnovTestArrayIf': ('kolmogorovSmirnovTest', 'ArrayIf'), 'uniqArrayIf': ('uniq', 'ArrayIf'), 'studentTTestArrayIf': ('studentTTest', 'ArrayIf'), 'groupUniqArrayArrayIf': ('groupUniqArray', 'ArrayIf'), 'uniqUpToArrayIf': ('uniqUpTo', 'ArrayIf'), 'groupArrayMovingSumArrayIf': ('groupArrayMovingSum', 'ArrayIf'), 'uniqExactArrayIf': ('uniqExact', 'ArrayIf'), 'minArrayIf': ('min', 'ArrayIf'), 'skewPopArrayIf': ('skewPop', 'ArrayIf'), 'quantileExactArrayIf': ('quantileExact', 'ArrayIf'), 'deltaSumArrayIf': ('deltaSum', 'ArrayIf'), 'maxIntersectionsPositionArrayIf': ('maxIntersectionsPosition', 'ArrayIf'), 'simpleLinearRegressionArrayIf': ('simpleLinearRegression', 'ArrayIf'), 'stddevSampArrayIf': ('stddevSamp', 'ArrayIf'), 'uniqThetaArrayIf': ('uniqTheta', 'ArrayIf'), 'uniqCombinedArrayIf': ('uniqCombined', 'ArrayIf'), 'quantileExactWeightedArrayIf': ('quantileExactWeighted', 'ArrayIf'), 'rankCorrArrayIf': ('rankCorr', 'ArrayIf'), 'sequenceCountArrayIf': ('sequenceCount', 'ArrayIf'), 'sequenceMatchArrayIf': ('sequenceMatch', 'ArrayIf'), 'histogramArrayIf': ('histogram', 'ArrayIf'), 'groupBitOrArrayIf': ('groupBitOr', 'ArrayIf'), 'maxArrayIf': ('max', 'ArrayIf'), 'quantileTimingArrayIf': ('quantileTiming', 'ArrayIf'), 'contingencyArrayIf': ('contingency', 'ArrayIf'), 'maxIntersectionsArrayIf': ('maxIntersections', 'ArrayIf'), 'groupBitmapOrArrayIf': ('groupBitmapOr', 'ArrayIf'), 'quantilesTDigestArrayIf': ('quantilesTDigest', 'ArrayIf'), 'avgWeightedArrayIf': ('avgWeighted', 'ArrayIf'), 'entropyArrayIf': ('entropy', 'ArrayIf'), 'kurtPopArrayIf': ('kurtPop', 'ArrayIf'), 'quantilesArrayIf': ('quantiles', 'ArrayIf'), 'avgArrayIf': ('avg', 'ArrayIf'), 'groupArrayLastArrayIf': ('groupArrayLast', 'ArrayIf'), 'groupBitmapAndArrayIf': ('groupBitmapAnd', 'ArrayIf'), 'sumWithOverflowArrayIf': ('sumWithOverflow', 'ArrayIf'), 'quantilesBFloat16ArrayIf': ('quantilesBFloat16', 'ArrayIf'), 'sumKahanArrayIf': ('sumKahan', 'ArrayIf'), 'quantileGKArrayIf': ('quantileGK', 'ArrayIf'), 'covarPopArrayIf': ('covarPop', 'ArrayIf'), 'quantilesBFloat16WeightedArrayIf': ('quantilesBFloat16Weighted', 'ArrayIf'), 'sumMapArrayIf': ('sumMap', 'ArrayIf'), 'groupArraySampleArrayIf': ('groupArraySample', 'ArrayIf'), 'groupBitXorArrayIf': ('groupBitXor', 'ArrayIf'), 'argMaxArrayIf': ('argMax', 'ArrayIf'), 'quantilesTimingWeightedArrayIf': ('quantilesTimingWeighted', 'ArrayIf'), 'quantileExactHighArrayIf': ('quantileExactHigh', 'ArrayIf'), 'quantileDeterministicArrayIf': ('quantileDeterministic', 'ArrayIf'), 'meanZTestArrayIf': ('meanZTest', 'ArrayIf'), 'sumCountArrayIf': ('sumCount', 'ArrayIf'), 'exponentialMovingAverageArrayIf': ('exponentialMovingAverage', 'ArrayIf'), 'anyHeavyArrayIf': ('anyHeavy', 'ArrayIf'), 'stddevPopArrayIf': ('stddevPop', 'ArrayIf'), 'exponentialTimeDecayedAvgArrayIf': ('exponentialTimeDecayedAvg', 'ArrayIf'), 'anyArrayIf': ('any', 'ArrayIf'), 'quantileTDigestWeightedArrayIf': ('quantileTDigestWeighted', 'ArrayIf'), 'minMapArrayIf': ('minMap', 'ArrayIf'), 'corrArrayIf': ('corr', 'ArrayIf'), 'stochasticLogisticRegressionArrayIf': ('stochasticLogisticRegression', 'ArrayIf'), 'varSampArrayIf': ('varSamp', 'ArrayIf'), 'welchTTestArrayIf': ('welchTTest', 'ArrayIf'), 'covarSampArrayIf': ('covarSamp', 'ArrayIf'), 'sparkBarArrayIf': ('sparkBar', 'ArrayIf'), 'maxMapArrayIf': ('maxMap', 'ArrayIf'), 'groupArrayArrayIf': ('groupArray', 'ArrayIf'), 'largestTriangleThreeBucketsArrayIf': ('largestTriangleThreeBuckets', 'ArrayIf'), 'deltaSumTimestampArrayIf': ('deltaSumTimestamp', 'ArrayIf'), 'uniqHLL12ArrayIf': ('uniqHLL12', 'ArrayIf'), 'groupBitAndArrayIf': ('groupBitAnd', 'ArrayIf'), 'quantileBFloat16WeightedArrayIf': ('quantileBFloat16Weighted', 'ArrayIf'), 'kurtSampArrayIf': ('kurtSamp', 'ArrayIf'), 'topKArrayIf': ('topK', 'ArrayIf'), 'quantileBFloat16ArrayIf': ('quantileBFloat16', 'ArrayIf'), 'cramersVArrayIf': ('cramersV', 'ArrayIf'), 'anyLastArrayIf': ('anyLast', 'ArrayIf'), 'quantilesExactLowArrayIf': ('quantilesExactLow', 'ArrayIf'), 'sumArrayIf': ('sum', 'ArrayIf'), 'quantileExactLowArrayIf': ('quantileExactLow', 'ArrayIf'), 'quantilesTDigestWeightedArrayIf': ('quantilesTDigestWeighted', 'ArrayIf'), 'argMinArrayIf': ('argMin', 'ArrayIf'), 'quantileArrayIf': ('quantile', 'ArrayIf'), 'quantileInterpolatedWeightedArrayIf': ('quantileInterpolatedWeighted', 'ArrayIf'), 'quantilesTimingArrayIf': ('quantilesTiming', 'ArrayIf'), 'theilsUArrayIf': ('theilsU', 'ArrayIf'), 'last_valueArrayIf': ('last_value', 'ArrayIf'), 'groupBitmapArrayIf': ('groupBitmap', 'ArrayIf'), 'uniqCombined64ArrayIf': ('uniqCombined64', 'ArrayIf'), 'mannWhitneyUTestArrayIf': ('mannWhitneyUTest', 'ArrayIf'), 'categoricalInformationValueArrayIf': ('categoricalInformationValue', 'ArrayIf'), 'countArrayIf': ('count', 'ArrayIf'), 'quantilesDeterministicArrayIf': ('quantilesDeterministic', 'ArrayIf'), 'quantilesExactHighArrayIf': ('quantilesExactHigh', 'ArrayIf'), 'first_valueArrayIf': ('first_value', 'ArrayIf'), 'medianArrayIf': ('median', 'ArrayIf'), 'quantileTDigestArrayIf': ('quantileTDigest', 'ArrayIf'), 'intervalLengthSumArrayIf': ('intervalLengthSum', 'ArrayIf'), 'sequenceNextNodeArrayIf': ('sequenceNextNode', 'ArrayIf'), 'boundingRatioArrayIf': ('boundingRatio', 'ArrayIf'), 'varPopArrayIf': ('varPop', 'ArrayIf'), 'stochasticLinearRegressionArrayIf': ('stochasticLinearRegression', 'ArrayIf'), 'quantileTimingWeightedArrayIf': ('quantileTimingWeighted', 'ArrayIf'), 'quantilesExactWeightedArrayIf': ('quantilesExactWeighted', 'ArrayIf'), 'groupBitmapXorArrayIf': ('groupBitmapXor', 'ArrayIf'), 'retentionArrayIf': ('retention', 'ArrayIf'), 'cramersVBiasCorrectedArrayIf': ('cramersVBiasCorrected', 'ArrayIf'), 'groupArrayMovingAvgArrayIf': ('groupArrayMovingAvg', 'ArrayIf'), 'quantilesInterpolatedWeightedArrayIf': ('quantilesInterpolatedWeighted', 'ArrayIf'), 'topKWeightedArrayIf': ('topKWeighted', 'ArrayIf'), 'groupArrayInsertAtArrayIf': ('groupArrayInsertAt', 'ArrayIf'), 'windowFunnelArrayIf': ('windowFunnel', 'ArrayIf'), 'quantilesGKMap': ('quantilesGK', 'Map'), 'skewSampMap': ('skewSamp', 'Map'), 'quantilesExactMap': ('quantilesExact', 'Map'), 'kolmogorovSmirnovTestMap': ('kolmogorovSmirnovTest', 'Map'), 'uniqMap': ('uniq', 'Map'), 'studentTTestMap': ('studentTTest', 'Map'), 'groupUniqArrayMap': ('groupUniqArray', 'Map'), 'uniqUpToMap': ('uniqUpTo', 'Map'), 'groupArrayMovingSumMap': ('groupArrayMovingSum', 'Map'), 'uniqExactMap': ('uniqExact', 'Map'), 'minMap': ('minMap', ''), 'skewPopMap': ('skewPop', 'Map'), 'quantileExactMap': ('quantileExact', 'Map'), 'deltaSumMap': ('deltaSum', 'Map'), 'maxIntersectionsPositionMap': ('maxIntersectionsPosition', 'Map'), 'simpleLinearRegressionMap': ('simpleLinearRegression', 'Map'), 'stddevSampMap': ('stddevSamp', 'Map'), 'uniqThetaMap': ('uniqTheta', 'Map'), 'uniqCombinedMap': ('uniqCombined', 'Map'), 'quantileExactWeightedMap': ('quantileExactWeighted', 'Map'), 'rankCorrMap': ('rankCorr', 'Map'), 'sequenceCountMap': ('sequenceCount', 'Map'), 'sequenceMatchMap': ('sequenceMatch', 'Map'), 'histogramMap': ('histogram', 'Map'), 'groupBitOrMap': ('groupBitOr', 'Map'), 'maxMap': ('maxMap', ''), 'quantileTimingMap': ('quantileTiming', 'Map'), 'contingencyMap': ('contingency', 'Map'), 'maxIntersectionsMap': ('maxIntersections', 'Map'), 'groupBitmapOrMap': ('groupBitmapOr', 'Map'), 'quantilesTDigestMap': ('quantilesTDigest', 'Map'), 'avgWeightedMap': ('avgWeighted', 'Map'), 'entropyMap': ('entropy', 'Map'), 'kurtPopMap': ('kurtPop', 'Map'), 'quantilesMap': ('quantiles', 'Map'), 'avgMap': ('avg', 'Map'), 'groupArrayLastMap': ('groupArrayLast', 'Map'), 'groupBitmapAndMap': ('groupBitmapAnd', 'Map'), 'sumWithOverflowMap': ('sumWithOverflow', 'Map'), 'quantilesBFloat16Map': ('quantilesBFloat16', 'Map'), 'sumKahanMap': ('sumKahan', 'Map'), 'quantileGKMap': ('quantileGK', 'Map'), 'covarPopMap': ('covarPop', 'Map'), 'quantilesBFloat16WeightedMap': ('quantilesBFloat16Weighted', 'Map'), 'sumMapMap': ('sumMap', 'Map'), 'groupArraySampleMap': ('groupArraySample', 'Map'), 'groupBitXorMap': ('groupBitXor', 'Map'), 'argMaxMap': ('argMax', 'Map'), 'quantilesTimingWeightedMap': ('quantilesTimingWeighted', 'Map'), 'quantileExactHighMap': ('quantileExactHigh', 'Map'), 'quantileDeterministicMap': ('quantileDeterministic', 'Map'), 'meanZTestMap': ('meanZTest', 'Map'), 'sumCountMap': ('sumCount', 'Map'), 'exponentialMovingAverageMap': ('exponentialMovingAverage', 'Map'), 'anyHeavyMap': ('anyHeavy', 'Map'), 'stddevPopMap': ('stddevPop', 'Map'), 'exponentialTimeDecayedAvgMap': ('exponentialTimeDecayedAvg', 'Map'), 'anyMap': ('any', 'Map'), 'quantileTDigestWeightedMap': ('quantileTDigestWeighted', 'Map'), 'minMapMap': ('minMap', 'Map'), 'corrMap': ('corr', 'Map'), 'stochasticLogisticRegressionMap': ('stochasticLogisticRegression', 'Map'), 'varSampMap': ('varSamp', 'Map'), 'welchTTestMap': ('welchTTest', 'Map'), 'covarSampMap': ('covarSamp', 'Map'), 'sparkBarMap': ('sparkBar', 'Map'), 'maxMapMap': ('maxMap', 'Map'), 'groupArrayMap': ('groupArray', 'Map'), 'largestTriangleThreeBucketsMap': ('largestTriangleThreeBuckets', 'Map'), 'deltaSumTimestampMap': ('deltaSumTimestamp', 'Map'), 'uniqHLL12Map': ('uniqHLL12', 'Map'), 'groupBitAndMap': ('groupBitAnd', 'Map'), 'quantileBFloat16WeightedMap': ('quantileBFloat16Weighted', 'Map'), 'kurtSampMap': ('kurtSamp', 'Map'), 'topKMap': ('topK', 'Map'), 'quantileBFloat16Map': ('quantileBFloat16', 'Map'), 'cramersVMap': ('cramersV', 'Map'), 'anyLastMap': ('anyLast', 'Map'), 'quantilesExactLowMap': ('quantilesExactLow', 'Map'), 'sumMap': ('sumMap', ''), 'quantileExactLowMap': ('quantileExactLow', 'Map'), 'quantilesTDigestWeightedMap': ('quantilesTDigestWeighted', 'Map'), 'argMinMap': ('argMin', 'Map'), 'quantileMap': ('quantile', 'Map'), 'quantileInterpolatedWeightedMap': ('quantileInterpolatedWeighted', 'Map'), 'quantilesTimingMap': ('quantilesTiming', 'Map'), 'theilsUMap': ('theilsU', 'Map'), 'last_valueMap': ('last_value', 'Map'), 'groupBitmapMap': ('groupBitmap', 'Map'), 'uniqCombined64Map': ('uniqCombined64', 'Map'), 'mannWhitneyUTestMap': ('mannWhitneyUTest', 'Map'), 'categoricalInformationValueMap': ('categoricalInformationValue', 'Map'), 'countMap': ('count', 'Map'), 'quantilesDeterministicMap': ('quantilesDeterministic', 'Map'), 'quantilesExactHighMap': ('quantilesExactHigh', 'Map'), 'first_valueMap': ('first_value', 'Map'), 'medianMap': ('median', 'Map'), 'quantileTDigestMap': ('quantileTDigest', 'Map'), 'intervalLengthSumMap': ('intervalLengthSum', 'Map'), 'sequenceNextNodeMap': ('sequenceNextNode', 'Map'), 'boundingRatioMap': ('boundingRatio', 'Map'), 'varPopMap': ('varPop', 'Map'), 'stochasticLinearRegressionMap': ('stochasticLinearRegression', 'Map'), 'quantileTimingWeightedMap': ('quantileTimingWeighted', 'Map'), 'quantilesExactWeightedMap': ('quantilesExactWeighted', 'Map'), 'groupBitmapXorMap': ('groupBitmapXor', 'Map'), 'retentionMap': ('retention', 'Map'), 'cramersVBiasCorrectedMap': ('cramersVBiasCorrected', 'Map'), 'groupArrayMovingAvgMap': ('groupArrayMovingAvg', 'Map'), 'quantilesInterpolatedWeightedMap': ('quantilesInterpolatedWeighted', 'Map'), 'topKWeightedMap': ('topKWeighted', 'Map'), 'groupArrayInsertAtMap': ('groupArrayInsertAt', 'Map'), 'windowFunnelMap': ('windowFunnel', 'Map'), 'quantilesGKSimpleState': ('quantilesGK', 'SimpleState'), 'skewSampSimpleState': ('skewSamp', 'SimpleState'), 'quantilesExactSimpleState': ('quantilesExact', 'SimpleState'), 'kolmogorovSmirnovTestSimpleState': ('kolmogorovSmirnovTest', 'SimpleState'), 'uniqSimpleState': ('uniq', 'SimpleState'), 'studentTTestSimpleState': ('studentTTest', 'SimpleState'), 'groupUniqArraySimpleState': ('groupUniqArray', 'SimpleState'), 'uniqUpToSimpleState': ('uniqUpTo', 'SimpleState'), 'groupArrayMovingSumSimpleState': ('groupArrayMovingSum', 'SimpleState'), 'uniqExactSimpleState': ('uniqExact', 'SimpleState'), 'minSimpleState': ('min', 'SimpleState'), 'skewPopSimpleState': ('skewPop', 'SimpleState'), 'quantileExactSimpleState': ('quantileExact', 'SimpleState'), 'deltaSumSimpleState': ('deltaSum', 'SimpleState'), 'maxIntersectionsPositionSimpleState': ('maxIntersectionsPosition', 'SimpleState'), 'simpleLinearRegressionSimpleState': ('simpleLinearRegression', 'SimpleState'), 'stddevSampSimpleState': ('stddevSamp', 'SimpleState'), 'uniqThetaSimpleState': ('uniqTheta', 'SimpleState'), 'uniqCombinedSimpleState': ('uniqCombined', 'SimpleState'), 'quantileExactWeightedSimpleState': ('quantileExactWeighted', 'SimpleState'), 'rankCorrSimpleState': ('rankCorr', 'SimpleState'), 'sequenceCountSimpleState': ('sequenceCount', 'SimpleState'), 'sequenceMatchSimpleState': ('sequenceMatch', 'SimpleState'), 'histogramSimpleState': ('histogram', 'SimpleState'), 'groupBitOrSimpleState': ('groupBitOr', 'SimpleState'), 'maxSimpleState': ('max', 'SimpleState'), 'quantileTimingSimpleState': ('quantileTiming', 'SimpleState'), 'contingencySimpleState': ('contingency', 'SimpleState'), 'maxIntersectionsSimpleState': ('maxIntersections', 'SimpleState'), 'groupBitmapOrSimpleState': ('groupBitmapOr', 'SimpleState'), 'quantilesTDigestSimpleState': ('quantilesTDigest', 'SimpleState'), 'avgWeightedSimpleState': ('avgWeighted', 'SimpleState'), 'entropySimpleState': ('entropy', 'SimpleState'), 'kurtPopSimpleState': ('kurtPop', 'SimpleState'), 'quantilesSimpleState': ('quantiles', 'SimpleState'), 'avgSimpleState': ('avg', 'SimpleState'), 'groupArrayLastSimpleState': ('groupArrayLast', 'SimpleState'), 'groupBitmapAndSimpleState': ('groupBitmapAnd', 'SimpleState'), 'sumWithOverflowSimpleState': ('sumWithOverflow', 'SimpleState'), 'quantilesBFloat16SimpleState': ('quantilesBFloat16', 'SimpleState'), 'sumKahanSimpleState': ('sumKahan', 'SimpleState'), 'quantileGKSimpleState': ('quantileGK', 'SimpleState'), 'covarPopSimpleState': ('covarPop', 'SimpleState'), 'quantilesBFloat16WeightedSimpleState': ('quantilesBFloat16Weighted', 'SimpleState'), 'sumMapSimpleState': ('sumMap', 'SimpleState'), 'groupArraySampleSimpleState': ('groupArraySample', 'SimpleState'), 'groupBitXorSimpleState': ('groupBitXor', 'SimpleState'), 'argMaxSimpleState': ('argMax', 'SimpleState'), 'quantilesTimingWeightedSimpleState': ('quantilesTimingWeighted', 'SimpleState'), 'quantileExactHighSimpleState': ('quantileExactHigh', 'SimpleState'), 'quantileDeterministicSimpleState': ('quantileDeterministic', 'SimpleState'), 'meanZTestSimpleState': ('meanZTest', 'SimpleState'), 'sumCountSimpleState': ('sumCount', 'SimpleState'), 'exponentialMovingAverageSimpleState': ('exponentialMovingAverage', 'SimpleState'), 'anyHeavySimpleState': ('anyHeavy', 'SimpleState'), 'stddevPopSimpleState': ('stddevPop', 'SimpleState'), 'exponentialTimeDecayedAvgSimpleState': ('exponentialTimeDecayedAvg', 'SimpleState'), 'anySimpleState': ('any', 'SimpleState'), 'quantileTDigestWeightedSimpleState': ('quantileTDigestWeighted', 'SimpleState'), 'minMapSimpleState': ('minMap', 'SimpleState'), 'corrSimpleState': ('corr', 'SimpleState'), 'stochasticLogisticRegressionSimpleState': ('stochasticLogisticRegression', 'SimpleState'), 'varSampSimpleState': ('varSamp', 'SimpleState'), 'welchTTestSimpleState': ('welchTTest', 'SimpleState'), 'covarSampSimpleState': ('covarSamp', 'SimpleState'), 'sparkBarSimpleState': ('sparkBar', 'SimpleState'), 'maxMapSimpleState': ('maxMap', 'SimpleState'), 'groupArraySimpleState': ('groupArray', 'SimpleState'), 'largestTriangleThreeBucketsSimpleState': ('largestTriangleThreeBuckets', 'SimpleState'), 'deltaSumTimestampSimpleState': ('deltaSumTimestamp', 'SimpleState'), 'uniqHLL12SimpleState': ('uniqHLL12', 'SimpleState'), 'groupBitAndSimpleState': ('groupBitAnd', 'SimpleState'), 'quantileBFloat16WeightedSimpleState': ('quantileBFloat16Weighted', 'SimpleState'), 'kurtSampSimpleState': ('kurtSamp', 'SimpleState'), 'topKSimpleState': ('topK', 'SimpleState'), 'quantileBFloat16SimpleState': ('quantileBFloat16', 'SimpleState'), 'cramersVSimpleState': ('cramersV', 'SimpleState'), 'anyLastSimpleState': ('anyLast', 'SimpleState'), 'quantilesExactLowSimpleState': ('quantilesExactLow', 'SimpleState'), 'sumSimpleState': ('sum', 'SimpleState'), 'quantileExactLowSimpleState': ('quantileExactLow', 'SimpleState'), 'quantilesTDigestWeightedSimpleState': ('quantilesTDigestWeighted', 'SimpleState'), 'argMinSimpleState': ('argMin', 'SimpleState'), 'quantileSimpleState': ('quantile', 'SimpleState'), 'quantileInterpolatedWeightedSimpleState': ('quantileInterpolatedWeighted', 'SimpleState'), 'quantilesTimingSimpleState': ('quantilesTiming', 'SimpleState'), 'theilsUSimpleState': ('theilsU', 'SimpleState'), 'last_valueSimpleState': ('last_value', 'SimpleState'), 'groupBitmapSimpleState': ('groupBitmap', 'SimpleState'), 'uniqCombined64SimpleState': ('uniqCombined64', 'SimpleState'), 'mannWhitneyUTestSimpleState': ('mannWhitneyUTest', 'SimpleState'), 'categoricalInformationValueSimpleState': ('categoricalInformationValue', 'SimpleState'), 'countSimpleState': ('count', 'SimpleState'), 'quantilesDeterministicSimpleState': ('quantilesDeterministic', 'SimpleState'), 'quantilesExactHighSimpleState': ('quantilesExactHigh', 'SimpleState'), 'first_valueSimpleState': ('first_value', 'SimpleState'), 'medianSimpleState': ('median', 'SimpleState'), 'quantileTDigestSimpleState': ('quantileTDigest', 'SimpleState'), 'intervalLengthSumSimpleState': ('intervalLengthSum', 'SimpleState'), 'sequenceNextNodeSimpleState': ('sequenceNextNode', 'SimpleState'), 'boundingRatioSimpleState': ('boundingRatio', 'SimpleState'), 'varPopSimpleState': ('varPop', 'SimpleState'), 'stochasticLinearRegressionSimpleState': ('stochasticLinearRegression', 'SimpleState'), 'quantileTimingWeightedSimpleState': ('quantileTimingWeighted', 'SimpleState'), 'quantilesExactWeightedSimpleState': ('quantilesExactWeighted', 'SimpleState'), 'groupBitmapXorSimpleState': ('groupBitmapXor', 'SimpleState'), 'retentionSimpleState': ('retention', 'SimpleState'), 'cramersVBiasCorrectedSimpleState': ('cramersVBiasCorrected', 'SimpleState'), 'groupArrayMovingAvgSimpleState': ('groupArrayMovingAvg', 'SimpleState'), 'quantilesInterpolatedWeightedSimpleState': ('quantilesInterpolatedWeighted', 'SimpleState'), 'topKWeightedSimpleState': ('topKWeighted', 'SimpleState'), 'groupArrayInsertAtSimpleState': ('groupArrayInsertAt', 'SimpleState'), 'windowFunnelSimpleState': ('windowFunnel', 'SimpleState'), 'quantilesGKState': ('quantilesGK', 'State'), 'skewSampState': ('skewSamp', 'State'), 'quantilesExactState': ('quantilesExact', 'State'), 'kolmogorovSmirnovTestState': ('kolmogorovSmirnovTest', 'State'), 'uniqState': ('uniq', 'State'), 'studentTTestState': ('studentTTest', 'State'), 'groupUniqArrayState': ('groupUniqArray', 'State'), 'uniqUpToState': ('uniqUpTo', 'State'), 'groupArrayMovingSumState': ('groupArrayMovingSum', 'State'), 'uniqExactState': ('uniqExact', 'State'), 'minState': ('min', 'State'), 'skewPopState': ('skewPop', 'State'), 'quantileExactState': ('quantileExact', 'State'), 'deltaSumState': ('deltaSum', 'State'), 'maxIntersectionsPositionState': ('maxIntersectionsPosition', 'State'), 'simpleLinearRegressionState': ('simpleLinearRegression', 'State'), 'stddevSampState': ('stddevSamp', 'State'), 'uniqThetaState': ('uniqTheta', 'State'), 'uniqCombinedState': ('uniqCombined', 'State'), 'quantileExactWeightedState': ('quantileExactWeighted', 'State'), 'rankCorrState': ('rankCorr', 'State'), 'sequenceCountState': ('sequenceCount', 'State'), 'sequenceMatchState': ('sequenceMatch', 'State'), 'histogramState': ('histogram', 'State'), 'groupBitOrState': ('groupBitOr', 'State'), 'maxState': ('max', 'State'), 'quantileTimingState': ('quantileTiming', 'State'), 'contingencyState': ('contingency', 'State'), 'maxIntersectionsState': ('maxIntersections', 'State'), 'groupBitmapOrState': ('groupBitmapOr', 'State'), 'quantilesTDigestState': ('quantilesTDigest', 'State'), 'avgWeightedState': ('avgWeighted', 'State'), 'entropyState': ('entropy', 'State'), 'kurtPopState': ('kurtPop', 'State'), 'quantilesState': ('quantiles', 'State'), 'avgState': ('avg', 'State'), 'groupArrayLastState': ('groupArrayLast', 'State'), 'groupBitmapAndState': ('groupBitmapAnd', 'State'), 'sumWithOverflowState': ('sumWithOverflow', 'State'), 'quantilesBFloat16State': ('quantilesBFloat16', 'State'), 'sumKahanState': ('sumKahan', 'State'), 'quantileGKState': ('quantileGK', 'State'), 'covarPopState': ('covarPop', 'State'), 'quantilesBFloat16WeightedState': ('quantilesBFloat16Weighted', 'State'), 'sumMapState': ('sumMap', 'State'), 'groupArraySampleState': ('groupArraySample', 'State'), 'groupBitXorState': ('groupBitXor', 'State'), 'argMaxState': ('argMax', 'State'), 'quantilesTimingWeightedState': ('quantilesTimingWeighted', 'State'), 'quantileExactHighState': ('quantileExactHigh', 'State'), 'quantileDeterministicState': ('quantileDeterministic', 'State'), 'meanZTestState': ('meanZTest', 'State'), 'sumCountState': ('sumCount', 'State'), 'exponentialMovingAverageState': ('exponentialMovingAverage', 'State'), 'anyHeavyState': ('anyHeavy', 'State'), 'stddevPopState': ('stddevPop', 'State'), 'exponentialTimeDecayedAvgState': ('exponentialTimeDecayedAvg', 'State'), 'anyState': ('any', 'State'), 'quantileTDigestWeightedState': ('quantileTDigestWeighted', 'State'), 'minMapState': ('minMap', 'State'), 'corrState': ('corr', 'State'), 'stochasticLogisticRegressionState': ('stochasticLogisticRegression', 'State'), 'varSampState': ('varSamp', 'State'), 'welchTTestState': ('welchTTest', 'State'), 'covarSampState': ('covarSamp', 'State'), 'sparkBarState': ('sparkBar', 'State'), 'maxMapState': ('maxMap', 'State'), 'groupArrayState': ('groupArray', 'State'), 'largestTriangleThreeBucketsState': ('largestTriangleThreeBuckets', 'State'), 'deltaSumTimestampState': ('deltaSumTimestamp', 'State'), 'uniqHLL12State': ('uniqHLL12', 'State'), 'groupBitAndState': ('groupBitAnd', 'State'), 'quantileBFloat16WeightedState': ('quantileBFloat16Weighted', 'State'), 'kurtSampState': ('kurtSamp', 'State'), 'topKState': ('topK', 'State'), 'quantileBFloat16State': ('quantileBFloat16', 'State'), 'cramersVState': ('cramersV', 'State'), 'anyLastState': ('anyLast', 'State'), 'quantilesExactLowState': ('quantilesExactLow', 'State'), 'sumState': ('sum', 'State'), 'quantileExactLowState': ('quantileExactLow', 'State'), 'quantilesTDigestWeightedState': ('quantilesTDigestWeighted', 'State'), 'argMinState': ('argMin', 'State'), 'quantileState': ('quantile', 'State'), 'quantileInterpolatedWeightedState': ('quantileInterpolatedWeighted', 'State'), 'quantilesTimingState': ('quantilesTiming', 'State'), 'theilsUState': ('theilsU', 'State'), 'last_valueState': ('last_value', 'State'), 'groupBitmapState': ('groupBitmap', 'State'), 'uniqCombined64State': ('uniqCombined64', 'State'), 'mannWhitneyUTestState': ('mannWhitneyUTest', 'State'), 'categoricalInformationValueState': ('categoricalInformationValue', 'State'), 'countState': ('count', 'State'), 'quantilesDeterministicState': ('quantilesDeterministic', 'State'), 'quantilesExactHighState': ('quantilesExactHigh', 'State'), 'first_valueState': ('first_value', 'State'), 'medianState': ('median', 'State'), 'quantileTDigestState': ('quantileTDigest', 'State'), 'intervalLengthSumState': ('intervalLengthSum', 'State'), 'sequenceNextNodeState': ('sequenceNextNode', 'State'), 'boundingRatioState': ('boundingRatio', 'State'), 'varPopState': ('varPop', 'State'), 'stochasticLinearRegressionState': ('stochasticLinearRegression', 'State'), 'quantileTimingWeightedState': ('quantileTimingWeighted', 'State'), 'quantilesExactWeightedState': ('quantilesExactWeighted', 'State'), 'groupBitmapXorState': ('groupBitmapXor', 'State'), 'retentionState': ('retention', 'State'), 'cramersVBiasCorrectedState': ('cramersVBiasCorrected', 'State'), 'groupArrayMovingAvgState': ('groupArrayMovingAvg', 'State'), 'quantilesInterpolatedWeightedState': ('quantilesInterpolatedWeighted', 'State'), 'topKWeightedState': ('topKWeighted', 'State'), 'groupArrayInsertAtState': ('groupArrayInsertAt', 'State'), 'windowFunnelState': ('windowFunnel', 'State'), 'quantilesGKMerge': ('quantilesGK', 'Merge'), 'skewSampMerge': ('skewSamp', 'Merge'), 'quantilesExactMerge': ('quantilesExact', 'Merge'), 'kolmogorovSmirnovTestMerge': ('kolmogorovSmirnovTest', 'Merge'), 'uniqMerge': ('uniq', 'Merge'), 'studentTTestMerge': ('studentTTest', 'Merge'), 'groupUniqArrayMerge': ('groupUniqArray', 'Merge'), 'uniqUpToMerge': ('uniqUpTo', 'Merge'), 'groupArrayMovingSumMerge': ('groupArrayMovingSum', 'Merge'), 'uniqExactMerge': ('uniqExact', 'Merge'), 'minMerge': ('min', 'Merge'), 'skewPopMerge': ('skewPop', 'Merge'), 'quantileExactMerge': ('quantileExact', 'Merge'), 'deltaSumMerge': ('deltaSum', 'Merge'), 'maxIntersectionsPositionMerge': ('maxIntersectionsPosition', 'Merge'), 'simpleLinearRegressionMerge': ('simpleLinearRegression', 'Merge'), 'stddevSampMerge': ('stddevSamp', 'Merge'), 'uniqThetaMerge': ('uniqTheta', 'Merge'), 'uniqCombinedMerge': ('uniqCombined', 'Merge'), 'quantileExactWeightedMerge': ('quantileExactWeighted', 'Merge'), 'rankCorrMerge': ('rankCorr', 'Merge'), 'sequenceCountMerge': ('sequenceCount', 'Merge'), 'sequenceMatchMerge': ('sequenceMatch', 'Merge'), 'histogramMerge': ('histogram', 'Merge'), 'groupBitOrMerge': ('groupBitOr', 'Merge'), 'maxMerge': ('max', 'Merge'), 'quantileTimingMerge': ('quantileTiming', 'Merge'), 'contingencyMerge': ('contingency', 'Merge'), 'maxIntersectionsMerge': ('maxIntersections', 'Merge'), 'groupBitmapOrMerge': ('groupBitmapOr', 'Merge'), 'quantilesTDigestMerge': ('quantilesTDigest', 'Merge'), 'avgWeightedMerge': ('avgWeighted', 'Merge'), 'entropyMerge': ('entropy', 'Merge'), 'kurtPopMerge': ('kurtPop', 'Merge'), 'quantilesMerge': ('quantiles', 'Merge'), 'avgMerge': ('avg', 'Merge'), 'groupArrayLastMerge': ('groupArrayLast', 'Merge'), 'groupBitmapAndMerge': ('groupBitmapAnd', 'Merge'), 'sumWithOverflowMerge': ('sumWithOverflow', 'Merge'), 'quantilesBFloat16Merge': ('quantilesBFloat16', 'Merge'), 'sumKahanMerge': ('sumKahan', 'Merge'), 'quantileGKMerge': ('quantileGK', 'Merge'), 'covarPopMerge': ('covarPop', 'Merge'), 'quantilesBFloat16WeightedMerge': ('quantilesBFloat16Weighted', 'Merge'), 'sumMapMerge': ('sumMap', 'Merge'), 'groupArraySampleMerge': ('groupArraySample', 'Merge'), 'groupBitXorMerge': ('groupBitXor', 'Merge'), 'argMaxMerge': ('argMax', 'Merge'), 'quantilesTimingWeightedMerge': ('quantilesTimingWeighted', 'Merge'), 'quantileExactHighMerge': ('quantileExactHigh', 'Merge'), 'quantileDeterministicMerge': ('quantileDeterministic', 'Merge'), 'meanZTestMerge': ('meanZTest', 'Merge'), 'sumCountMerge': ('sumCount', 'Merge'), 'exponentialMovingAverageMerge': ('exponentialMovingAverage', 'Merge'), 'anyHeavyMerge': ('anyHeavy', 'Merge'), 'stddevPopMerge': ('stddevPop', 'Merge'), 'exponentialTimeDecayedAvgMerge': ('exponentialTimeDecayedAvg', 'Merge'), 'anyMerge': ('any', 'Merge'), 'quantileTDigestWeightedMerge': ('quantileTDigestWeighted', 'Merge'), 'minMapMerge': ('minMap', 'Merge'), 'corrMerge': ('corr', 'Merge'), 'stochasticLogisticRegressionMerge': ('stochasticLogisticRegression', 'Merge'), 'varSampMerge': ('varSamp', 'Merge'), 'welchTTestMerge': ('welchTTest', 'Merge'), 'covarSampMerge': ('covarSamp', 'Merge'), 'sparkBarMerge': ('sparkBar', 'Merge'), 'maxMapMerge': ('maxMap', 'Merge'), 'groupArrayMerge': ('groupArray', 'Merge'), 'largestTriangleThreeBucketsMerge': ('largestTriangleThreeBuckets', 'Merge'), 'deltaSumTimestampMerge': ('deltaSumTimestamp', 'Merge'), 'uniqHLL12Merge': ('uniqHLL12', 'Merge'), 'groupBitAndMerge': ('groupBitAnd', 'Merge'), 'quantileBFloat16WeightedMerge': ('quantileBFloat16Weighted', 'Merge'), 'kurtSampMerge': ('kurtSamp', 'Merge'), 'topKMerge': ('topK', 'Merge'), 'quantileBFloat16Merge': ('quantileBFloat16', 'Merge'), 'cramersVMerge': ('cramersV', 'Merge'), 'anyLastMerge': ('anyLast', 'Merge'), 'quantilesExactLowMerge': ('quantilesExactLow', 'Merge'), 'sumMerge': ('sum', 'Merge'), 'quantileExactLowMerge': ('quantileExactLow', 'Merge'), 'quantilesTDigestWeightedMerge': ('quantilesTDigestWeighted', 'Merge'), 'argMinMerge': ('argMin', 'Merge'), 'quantileMerge': ('quantile', 'Merge'), 'quantileInterpolatedWeightedMerge': ('quantileInterpolatedWeighted', 'Merge'), 'quantilesTimingMerge': ('quantilesTiming', 'Merge'), 'theilsUMerge': ('theilsU', 'Merge'), 'last_valueMerge': ('last_value', 'Merge'), 'groupBitmapMerge': ('groupBitmap', 'Merge'), 'uniqCombined64Merge': ('uniqCombined64', 'Merge'), 'mannWhitneyUTestMerge': ('mannWhitneyUTest', 'Merge'), 'categoricalInformationValueMerge': ('categoricalInformationValue', 'Merge'), 'countMerge': ('count', 'Merge'), 'quantilesDeterministicMerge': ('quantilesDeterministic', 'Merge'), 'quantilesExactHighMerge': ('quantilesExactHigh', 'Merge'), 'first_valueMerge': ('first_value', 'Merge'), 'medianMerge': ('median', 'Merge'), 'quantileTDigestMerge': ('quantileTDigest', 'Merge'), 'intervalLengthSumMerge': ('intervalLengthSum', 'Merge'), 'sequenceNextNodeMerge': ('sequenceNextNode', 'Merge'), 'boundingRatioMerge': ('boundingRatio', 'Merge'), 'varPopMerge': ('varPop', 'Merge'), 'stochasticLinearRegressionMerge': ('stochasticLinearRegression', 'Merge'), 'quantileTimingWeightedMerge': ('quantileTimingWeighted', 'Merge'), 'quantilesExactWeightedMerge': ('quantilesExactWeighted', 'Merge'), 'groupBitmapXorMerge': ('groupBitmapXor', 'Merge'), 'retentionMerge': ('retention', 'Merge'), 'cramersVBiasCorrectedMerge': ('cramersVBiasCorrected', 'Merge'), 'groupArrayMovingAvgMerge': ('groupArrayMovingAvg', 'Merge'), 'quantilesInterpolatedWeightedMerge': ('quantilesInterpolatedWeighted', 'Merge'), 'topKWeightedMerge': ('topKWeighted', 'Merge'), 'groupArrayInsertAtMerge': ('groupArrayInsertAt', 'Merge'), 'windowFunnelMerge': ('windowFunnel', 'Merge'), 'quantilesGKMergeState': ('quantilesGK', 'MergeState'), 'skewSampMergeState': ('skewSamp', 'MergeState'), 'quantilesExactMergeState': ('quantilesExact', 'MergeState'), 'kolmogorovSmirnovTestMergeState': ('kolmogorovSmirnovTest', 'MergeState'), 'uniqMergeState': ('uniq', 'MergeState'), 'studentTTestMergeState': ('studentTTest', 'MergeState'), 'groupUniqArrayMergeState': ('groupUniqArray', 'MergeState'), 'uniqUpToMergeState': ('uniqUpTo', 'MergeState'), 'groupArrayMovingSumMergeState': ('groupArrayMovingSum', 'MergeState'), 'uniqExactMergeState': ('uniqExact', 'MergeState'), 'minMergeState': ('min', 'MergeState'), 'skewPopMergeState': ('skewPop', 'MergeState'), 'quantileExactMergeState': ('quantileExact', 'MergeState'), 'deltaSumMergeState': ('deltaSum', 'MergeState'), 'maxIntersectionsPositionMergeState': ('maxIntersectionsPosition', 'MergeState'), 'simpleLinearRegressionMergeState': ('simpleLinearRegression', 'MergeState'), 'stddevSampMergeState': ('stddevSamp', 'MergeState'), 'uniqThetaMergeState': ('uniqTheta', 'MergeState'), 'uniqCombinedMergeState': ('uniqCombined', 'MergeState'), 'quantileExactWeightedMergeState': ('quantileExactWeighted', 'MergeState'), 'rankCorrMergeState': ('rankCorr', 'MergeState'), 'sequenceCountMergeState': ('sequenceCount', 'MergeState'), 'sequenceMatchMergeState': ('sequenceMatch', 'MergeState'), 'histogramMergeState': ('histogram', 'MergeState'), 'groupBitOrMergeState': ('groupBitOr', 'MergeState'), 'maxMergeState': ('max', 'MergeState'), 'quantileTimingMergeState': ('quantileTiming', 'MergeState'), 'contingencyMergeState': ('contingency', 'MergeState'), 'maxIntersectionsMergeState': ('maxIntersections', 'MergeState'), 'groupBitmapOrMergeState': ('groupBitmapOr', 'MergeState'), 'quantilesTDigestMergeState': ('quantilesTDigest', 'MergeState'), 'avgWeightedMergeState': ('avgWeighted', 'MergeState'), 'entropyMergeState': ('entropy', 'MergeState'), 'kurtPopMergeState': ('kurtPop', 'MergeState'), 'quantilesMergeState': ('quantiles', 'MergeState'), 'avgMergeState': ('avg', 'MergeState'), 'groupArrayLastMergeState': ('groupArrayLast', 'MergeState'), 'groupBitmapAndMergeState': ('groupBitmapAnd', 'MergeState'), 'sumWithOverflowMergeState': ('sumWithOverflow', 'MergeState'), 'quantilesBFloat16MergeState': ('quantilesBFloat16', 'MergeState'), 'sumKahanMergeState': ('sumKahan', 'MergeState'), 'quantileGKMergeState': ('quantileGK', 'MergeState'), 'covarPopMergeState': ('covarPop', 'MergeState'), 'quantilesBFloat16WeightedMergeState': ('quantilesBFloat16Weighted', 'MergeState'), 'sumMapMergeState': ('sumMap', 'MergeState'), 'groupArraySampleMergeState': ('groupArraySample', 'MergeState'), 'groupBitXorMergeState': ('groupBitXor', 'MergeState'), 'argMaxMergeState': ('argMax', 'MergeState'), 'quantilesTimingWeightedMergeState': ('quantilesTimingWeighted', 'MergeState'), 'quantileExactHighMergeState': ('quantileExactHigh', 'MergeState'), 'quantileDeterministicMergeState': ('quantileDeterministic', 'MergeState'), 'meanZTestMergeState': ('meanZTest', 'MergeState'), 'sumCountMergeState': ('sumCount', 'MergeState'), 'exponentialMovingAverageMergeState': ('exponentialMovingAverage', 'MergeState'), 'anyHeavyMergeState': ('anyHeavy', 'MergeState'), 'stddevPopMergeState': ('stddevPop', 'MergeState'), 'exponentialTimeDecayedAvgMergeState': ('exponentialTimeDecayedAvg', 'MergeState'), 'anyMergeState': ('any', 'MergeState'), 'quantileTDigestWeightedMergeState': ('quantileTDigestWeighted', 'MergeState'), 'minMapMergeState': ('minMap', 'MergeState'), 'corrMergeState': ('corr', 'MergeState'), 'stochasticLogisticRegressionMergeState': ('stochasticLogisticRegression', 'MergeState'), 'varSampMergeState': ('varSamp', 'MergeState'), 'welchTTestMergeState': ('welchTTest', 'MergeState'), 'covarSampMergeState': ('covarSamp', 'MergeState'), 'sparkBarMergeState': ('sparkBar', 'MergeState'), 'maxMapMergeState': ('maxMap', 'MergeState'), 'groupArrayMergeState': ('groupArray', 'MergeState'), 'largestTriangleThreeBucketsMergeState': ('largestTriangleThreeBuckets', 'MergeState'), 'deltaSumTimestampMergeState': ('deltaSumTimestamp', 'MergeState'), 'uniqHLL12MergeState': ('uniqHLL12', 'MergeState'), 'groupBitAndMergeState': ('groupBitAnd', 'MergeState'), 'quantileBFloat16WeightedMergeState': ('quantileBFloat16Weighted', 'MergeState'), 'kurtSampMergeState': ('kurtSamp', 'MergeState'), 'topKMergeState': ('topK', 'MergeState'), 'quantileBFloat16MergeState': ('quantileBFloat16', 'MergeState'), 'cramersVMergeState': ('cramersV', 'MergeState'), 'anyLastMergeState': ('anyLast', 'MergeState'), 'quantilesExactLowMergeState': ('quantilesExactLow', 'MergeState'), 'sumMergeState': ('sum', 'MergeState'), 'quantileExactLowMergeState': ('quantileExactLow', 'MergeState'), 'quantilesTDigestWeightedMergeState': ('quantilesTDigestWeighted', 'MergeState'), 'argMinMergeState': ('argMin', 'MergeState'), 'quantileMergeState': ('quantile', 'MergeState'), 'quantileInterpolatedWeightedMergeState': ('quantileInterpolatedWeighted', 'MergeState'), 'quantilesTimingMergeState': ('quantilesTiming', 'MergeState'), 'theilsUMergeState': ('theilsU', 'MergeState'), 'last_valueMergeState': ('last_value', 'MergeState'), 'groupBitmapMergeState': ('groupBitmap', 'MergeState'), 'uniqCombined64MergeState': ('uniqCombined64', 'MergeState'), 'mannWhitneyUTestMergeState': ('mannWhitneyUTest', 'MergeState'), 'categoricalInformationValueMergeState': ('categoricalInformationValue', 'MergeState'), 'countMergeState': ('count', 'MergeState'), 'quantilesDeterministicMergeState': ('quantilesDeterministic', 'MergeState'), 'quantilesExactHighMergeState': ('quantilesExactHigh', 'MergeState'), 'first_valueMergeState': ('first_value', 'MergeState'), 'medianMergeState': ('median', 'MergeState'), 'quantileTDigestMergeState': ('quantileTDigest', 'MergeState'), 'intervalLengthSumMergeState': ('intervalLengthSum', 'MergeState'), 'sequenceNextNodeMergeState': ('sequenceNextNode', 'MergeState'), 'boundingRatioMergeState': ('boundingRatio', 'MergeState'), 'varPopMergeState': ('varPop', 'MergeState'), 'stochasticLinearRegressionMergeState': ('stochasticLinearRegression', 'MergeState'), 'quantileTimingWeightedMergeState': ('quantileTimingWeighted', 'MergeState'), 'quantilesExactWeightedMergeState': ('quantilesExactWeighted', 'MergeState'), 'groupBitmapXorMergeState': ('groupBitmapXor', 'MergeState'), 'retentionMergeState': ('retention', 'MergeState'), 'cramersVBiasCorrectedMergeState': ('cramersVBiasCorrected', 'MergeState'), 'groupArrayMovingAvgMergeState': ('groupArrayMovingAvg', 'MergeState'), 'quantilesInterpolatedWeightedMergeState': ('quantilesInterpolatedWeighted', 'MergeState'), 'topKWeightedMergeState': ('topKWeighted', 'MergeState'), 'groupArrayInsertAtMergeState': ('groupArrayInsertAt', 'MergeState'), 'windowFunnelMergeState': ('windowFunnel', 'MergeState'), 'quantilesGKForEach': ('quantilesGK', 'ForEach'), 'skewSampForEach': ('skewSamp', 'ForEach'), 'quantilesExactForEach': ('quantilesExact', 'ForEach'), 'kolmogorovSmirnovTestForEach': ('kolmogorovSmirnovTest', 'ForEach'), 'uniqForEach': ('uniq', 'ForEach'), 'studentTTestForEach': ('studentTTest', 'ForEach'), 'groupUniqArrayForEach': ('groupUniqArray', 'ForEach'), 'uniqUpToForEach': ('uniqUpTo', 'ForEach'), 'groupArrayMovingSumForEach': ('groupArrayMovingSum', 'ForEach'), 'uniqExactForEach': ('uniqExact', 'ForEach'), 'minForEach': ('min', 'ForEach'), 'skewPopForEach': ('skewPop', 'ForEach'), 'quantileExactForEach': ('quantileExact', 'ForEach'), 'deltaSumForEach': ('deltaSum', 'ForEach'), 'maxIntersectionsPositionForEach': ('maxIntersectionsPosition', 'ForEach'), 'simpleLinearRegressionForEach': ('simpleLinearRegression', 'ForEach'), 'stddevSampForEach': ('stddevSamp', 'ForEach'), 'uniqThetaForEach': ('uniqTheta', 'ForEach'), 'uniqCombinedForEach': ('uniqCombined', 'ForEach'), 'quantileExactWeightedForEach': ('quantileExactWeighted', 'ForEach'), 'rankCorrForEach': ('rankCorr', 'ForEach'), 'sequenceCountForEach': ('sequenceCount', 'ForEach'), 'sequenceMatchForEach': ('sequenceMatch', 'ForEach'), 'histogramForEach': ('histogram', 'ForEach'), 'groupBitOrForEach': ('groupBitOr', 'ForEach'), 'maxForEach': ('max', 'ForEach'), 'quantileTimingForEach': ('quantileTiming', 'ForEach'), 'contingencyForEach': ('contingency', 'ForEach'), 'maxIntersectionsForEach': ('maxIntersections', 'ForEach'), 'groupBitmapOrForEach': ('groupBitmapOr', 'ForEach'), 'quantilesTDigestForEach': ('quantilesTDigest', 'ForEach'), 'avgWeightedForEach': ('avgWeighted', 'ForEach'), 'entropyForEach': ('entropy', 'ForEach'), 'kurtPopForEach': ('kurtPop', 'ForEach'), 'quantilesForEach': ('quantiles', 'ForEach'), 'avgForEach': ('avg', 'ForEach'), 'groupArrayLastForEach': ('groupArrayLast', 'ForEach'), 'groupBitmapAndForEach': ('groupBitmapAnd', 'ForEach'), 'sumWithOverflowForEach': ('sumWithOverflow', 'ForEach'), 'quantilesBFloat16ForEach': ('quantilesBFloat16', 'ForEach'), 'sumKahanForEach': ('sumKahan', 'ForEach'), 'quantileGKForEach': ('quantileGK', 'ForEach'), 'covarPopForEach': ('covarPop', 'ForEach'), 'quantilesBFloat16WeightedForEach': ('quantilesBFloat16Weighted', 'ForEach'), 'sumMapForEach': ('sumMap', 'ForEach'), 'groupArraySampleForEach': ('groupArraySample', 'ForEach'), 'groupBitXorForEach': ('groupBitXor', 'ForEach'), 'argMaxForEach': ('argMax', 'ForEach'), 'quantilesTimingWeightedForEach': ('quantilesTimingWeighted', 'ForEach'), 'quantileExactHighForEach': ('quantileExactHigh', 'ForEach'), 'quantileDeterministicForEach': ('quantileDeterministic', 'ForEach'), 'meanZTestForEach': ('meanZTest', 'ForEach'), 'sumCountForEach': ('sumCount', 'ForEach'), 'exponentialMovingAverageForEach': ('exponentialMovingAverage', 'ForEach'), 'anyHeavyForEach': ('anyHeavy', 'ForEach'), 'stddevPopForEach': ('stddevPop', 'ForEach'), 'exponentialTimeDecayedAvgForEach': ('exponentialTimeDecayedAvg', 'ForEach'), 'anyForEach': ('any', 'ForEach'), 'quantileTDigestWeightedForEach': ('quantileTDigestWeighted', 'ForEach'), 'minMapForEach': ('minMap', 'ForEach'), 'corrForEach': ('corr', 'ForEach'), 'stochasticLogisticRegressionForEach': ('stochasticLogisticRegression', 'ForEach'), 'varSampForEach': ('varSamp', 'ForEach'), 'welchTTestForEach': ('welchTTest', 'ForEach'), 'covarSampForEach': ('covarSamp', 'ForEach'), 'sparkBarForEach': ('sparkBar', 'ForEach'), 'maxMapForEach': ('maxMap', 'ForEach'), 'groupArrayForEach': ('groupArray', 'ForEach'), 'largestTriangleThreeBucketsForEach': ('largestTriangleThreeBuckets', 'ForEach'), 'deltaSumTimestampForEach': ('deltaSumTimestamp', 'ForEach'), 'uniqHLL12ForEach': ('uniqHLL12', 'ForEach'), 'groupBitAndForEach': ('groupBitAnd', 'ForEach'), 'quantileBFloat16WeightedForEach': ('quantileBFloat16Weighted', 'ForEach'), 'kurtSampForEach': ('kurtSamp', 'ForEach'), 'topKForEach': ('topK', 'ForEach'), 'quantileBFloat16ForEach': ('quantileBFloat16', 'ForEach'), 'cramersVForEach': ('cramersV', 'ForEach'), 'anyLastForEach': ('anyLast', 'ForEach'), 'quantilesExactLowForEach': ('quantilesExactLow', 'ForEach'), 'sumForEach': ('sum', 'ForEach'), 'quantileExactLowForEach': ('quantileExactLow', 'ForEach'), 'quantilesTDigestWeightedForEach': ('quantilesTDigestWeighted', 'ForEach'), 'argMinForEach': ('argMin', 'ForEach'), 'quantileForEach': ('quantile', 'ForEach'), 'quantileInterpolatedWeightedForEach': ('quantileInterpolatedWeighted', 'ForEach'), 'quantilesTimingForEach': ('quantilesTiming', 'ForEach'), 'theilsUForEach': ('theilsU', 'ForEach'), 'last_valueForEach': ('last_value', 'ForEach'), 'groupBitmapForEach': ('groupBitmap', 'ForEach'), 'uniqCombined64ForEach': ('uniqCombined64', 'ForEach'), 'mannWhitneyUTestForEach': ('mannWhitneyUTest', 'ForEach'), 'categoricalInformationValueForEach': ('categoricalInformationValue', 'ForEach'), 'countForEach': ('count', 'ForEach'), 'quantilesDeterministicForEach': ('quantilesDeterministic', 'ForEach'), 'quantilesExactHighForEach': ('quantilesExactHigh', 'ForEach'), 'first_valueForEach': ('first_value', 'ForEach'), 'medianForEach': ('median', 'ForEach'), 'quantileTDigestForEach': ('quantileTDigest', 'ForEach'), 'intervalLengthSumForEach': ('intervalLengthSum', 'ForEach'), 'sequenceNextNodeForEach': ('sequenceNextNode', 'ForEach'), 'boundingRatioForEach': ('boundingRatio', 'ForEach'), 'varPopForEach': ('varPop', 'ForEach'), 'stochasticLinearRegressionForEach': ('stochasticLinearRegression', 'ForEach'), 'quantileTimingWeightedForEach': ('quantileTimingWeighted', 'ForEach'), 'quantilesExactWeightedForEach': ('quantilesExactWeighted', 'ForEach'), 'groupBitmapXorForEach': ('groupBitmapXor', 'ForEach'), 'retentionForEach': ('retention', 'ForEach'), 'cramersVBiasCorrectedForEach': ('cramersVBiasCorrected', 'ForEach'), 'groupArrayMovingAvgForEach': ('groupArrayMovingAvg', 'ForEach'), 'quantilesInterpolatedWeightedForEach': ('quantilesInterpolatedWeighted', 'ForEach'), 'topKWeightedForEach': ('topKWeighted', 'ForEach'), 'groupArrayInsertAtForEach': ('groupArrayInsertAt', 'ForEach'), 'windowFunnelForEach': ('windowFunnel', 'ForEach'), 'quantilesGKDistinct': ('quantilesGK', 'Distinct'), 'skewSampDistinct': ('skewSamp', 'Distinct'), 'quantilesExactDistinct': ('quantilesExact', 'Distinct'), 'kolmogorovSmirnovTestDistinct': ('kolmogorovSmirnovTest', 'Distinct'), 'uniqDistinct': ('uniq', 'Distinct'), 'studentTTestDistinct': ('studentTTest', 'Distinct'), 'groupUniqArrayDistinct': ('groupUniqArray', 'Distinct'), 'uniqUpToDistinct': ('uniqUpTo', 'Distinct'), 'groupArrayMovingSumDistinct': ('groupArrayMovingSum', 'Distinct'), 'uniqExactDistinct': ('uniqExact', 'Distinct'), 'minDistinct': ('min', 'Distinct'), 'skewPopDistinct': ('skewPop', 'Distinct'), 'quantileExactDistinct': ('quantileExact', 'Distinct'), 'deltaSumDistinct': ('deltaSum', 'Distinct'), 'maxIntersectionsPositionDistinct': ('maxIntersectionsPosition', 'Distinct'), 'simpleLinearRegressionDistinct': ('simpleLinearRegression', 'Distinct'), 'stddevSampDistinct': ('stddevSamp', 'Distinct'), 'uniqThetaDistinct': ('uniqTheta', 'Distinct'), 'uniqCombinedDistinct': ('uniqCombined', 'Distinct'), 'quantileExactWeightedDistinct': ('quantileExactWeighted', 'Distinct'), 'rankCorrDistinct': ('rankCorr', 'Distinct'), 'sequenceCountDistinct': ('sequenceCount', 'Distinct'), 'sequenceMatchDistinct': ('sequenceMatch', 'Distinct'), 'histogramDistinct': ('histogram', 'Distinct'), 'groupBitOrDistinct': ('groupBitOr', 'Distinct'), 'maxDistinct': ('max', 'Distinct'), 'quantileTimingDistinct': ('quantileTiming', 'Distinct'), 'contingencyDistinct': ('contingency', 'Distinct'), 'maxIntersectionsDistinct': ('maxIntersections', 'Distinct'), 'groupBitmapOrDistinct': ('groupBitmapOr', 'Distinct'), 'quantilesTDigestDistinct': ('quantilesTDigest', 'Distinct'), 'avgWeightedDistinct': ('avgWeighted', 'Distinct'), 'entropyDistinct': ('entropy', 'Distinct'), 'kurtPopDistinct': ('kurtPop', 'Distinct'), 'quantilesDistinct': ('quantiles', 'Distinct'), 'avgDistinct': ('avg', 'Distinct'), 'groupArrayLastDistinct': ('groupArrayLast', 'Distinct'), 'groupBitmapAndDistinct': ('groupBitmapAnd', 'Distinct'), 'sumWithOverflowDistinct': ('sumWithOverflow', 'Distinct'), 'quantilesBFloat16Distinct': ('quantilesBFloat16', 'Distinct'), 'sumKahanDistinct': ('sumKahan', 'Distinct'), 'quantileGKDistinct': ('quantileGK', 'Distinct'), 'covarPopDistinct': ('covarPop', 'Distinct'), 'quantilesBFloat16WeightedDistinct': ('quantilesBFloat16Weighted', 'Distinct'), 'sumMapDistinct': ('sumMap', 'Distinct'), 'groupArraySampleDistinct': ('groupArraySample', 'Distinct'), 'groupBitXorDistinct': ('groupBitXor', 'Distinct'), 'argMaxDistinct': ('argMax', 'Distinct'), 'quantilesTimingWeightedDistinct': ('quantilesTimingWeighted', 'Distinct'), 'quantileExactHighDistinct': ('quantileExactHigh', 'Distinct'), 'quantileDeterministicDistinct': ('quantileDeterministic', 'Distinct'), 'meanZTestDistinct': ('meanZTest', 'Distinct'), 'sumCountDistinct': ('sumCount', 'Distinct'), 'exponentialMovingAverageDistinct': ('exponentialMovingAverage', 'Distinct'), 'anyHeavyDistinct': ('anyHeavy', 'Distinct'), 'stddevPopDistinct': ('stddevPop', 'Distinct'), 'exponentialTimeDecayedAvgDistinct': ('exponentialTimeDecayedAvg', 'Distinct'), 'anyDistinct': ('any', 'Distinct'), 'quantileTDigestWeightedDistinct': ('quantileTDigestWeighted', 'Distinct'), 'minMapDistinct': ('minMap', 'Distinct'), 'corrDistinct': ('corr', 'Distinct'), 'stochasticLogisticRegressionDistinct': ('stochasticLogisticRegression', 'Distinct'), 'varSampDistinct': ('varSamp', 'Distinct'), 'welchTTestDistinct': ('welchTTest', 'Distinct'), 'covarSampDistinct': ('covarSamp', 'Distinct'), 'sparkBarDistinct': ('sparkBar', 'Distinct'), 'maxMapDistinct': ('maxMap', 'Distinct'), 'groupArrayDistinct': ('groupArray', 'Distinct'), 'largestTriangleThreeBucketsDistinct': ('largestTriangleThreeBuckets', 'Distinct'), 'deltaSumTimestampDistinct': ('deltaSumTimestamp', 'Distinct'), 'uniqHLL12Distinct': ('uniqHLL12', 'Distinct'), 'groupBitAndDistinct': ('groupBitAnd', 'Distinct'), 'quantileBFloat16WeightedDistinct': ('quantileBFloat16Weighted', 'Distinct'), 'kurtSampDistinct': ('kurtSamp', 'Distinct'), 'topKDistinct': ('topK', 'Distinct'), 'quantileBFloat16Distinct': ('quantileBFloat16', 'Distinct'), 'cramersVDistinct': ('cramersV', 'Distinct'), 'anyLastDistinct': ('anyLast', 'Distinct'), 'quantilesExactLowDistinct': ('quantilesExactLow', 'Distinct'), 'sumDistinct': ('sum', 'Distinct'), 'quantileExactLowDistinct': ('quantileExactLow', 'Distinct'), 'quantilesTDigestWeightedDistinct': ('quantilesTDigestWeighted', 'Distinct'), 'argMinDistinct': ('argMin', 'Distinct'), 'quantileDistinct': ('quantile', 'Distinct'), 'quantileInterpolatedWeightedDistinct': ('quantileInterpolatedWeighted', 'Distinct'), 'quantilesTimingDistinct': ('quantilesTiming', 'Distinct'), 'theilsUDistinct': ('theilsU', 'Distinct'), 'last_valueDistinct': ('last_value', 'Distinct'), 'groupBitmapDistinct': ('groupBitmap', 'Distinct'), 'uniqCombined64Distinct': ('uniqCombined64', 'Distinct'), 'mannWhitneyUTestDistinct': ('mannWhitneyUTest', 'Distinct'), 'categoricalInformationValueDistinct': ('categoricalInformationValue', 'Distinct'), 'countDistinct': ('count', 'Distinct'), 'quantilesDeterministicDistinct': ('quantilesDeterministic', 'Distinct'), 'quantilesExactHighDistinct': ('quantilesExactHigh', 'Distinct'), 'first_valueDistinct': ('first_value', 'Distinct'), 'medianDistinct': ('median', 'Distinct'), 'quantileTDigestDistinct': ('quantileTDigest', 'Distinct'), 'intervalLengthSumDistinct': ('intervalLengthSum', 'Distinct'), 'sequenceNextNodeDistinct': ('sequenceNextNode', 'Distinct'), 'boundingRatioDistinct': ('boundingRatio', 'Distinct'), 'varPopDistinct': ('varPop', 'Distinct'), 'stochasticLinearRegressionDistinct': ('stochasticLinearRegression', 'Distinct'), 'quantileTimingWeightedDistinct': ('quantileTimingWeighted', 'Distinct'), 'quantilesExactWeightedDistinct': ('quantilesExactWeighted', 'Distinct'), 'groupBitmapXorDistinct': ('groupBitmapXor', 'Distinct'), 'retentionDistinct': ('retention', 'Distinct'), 'cramersVBiasCorrectedDistinct': ('cramersVBiasCorrected', 'Distinct'), 'groupArrayMovingAvgDistinct': ('groupArrayMovingAvg', 'Distinct'), 'quantilesInterpolatedWeightedDistinct': ('quantilesInterpolatedWeighted', 'Distinct'), 'topKWeightedDistinct': ('topKWeighted', 'Distinct'), 'groupArrayInsertAtDistinct': ('groupArrayInsertAt', 'Distinct'), 'windowFunnelDistinct': ('windowFunnel', 'Distinct'), 'quantilesGKOrDefault': ('quantilesGK', 'OrDefault'), 'skewSampOrDefault': ('skewSamp', 'OrDefault'), 'quantilesExactOrDefault': ('quantilesExact', 'OrDefault'), 'kolmogorovSmirnovTestOrDefault': ('kolmogorovSmirnovTest', 'OrDefault'), 'uniqOrDefault': ('uniq', 'OrDefault'), 'studentTTestOrDefault': ('studentTTest', 'OrDefault'), 'groupUniqArrayOrDefault': ('groupUniqArray', 'OrDefault'), 'uniqUpToOrDefault': ('uniqUpTo', 'OrDefault'), 'groupArrayMovingSumOrDefault': ('groupArrayMovingSum', 'OrDefault'), 'uniqExactOrDefault': ('uniqExact', 'OrDefault'), 'minOrDefault': ('min', 'OrDefault'), 'skewPopOrDefault': ('skewPop', 'OrDefault'), 'quantileExactOrDefault': ('quantileExact', 'OrDefault'), 'deltaSumOrDefault': ('deltaSum', 'OrDefault'), 'maxIntersectionsPositionOrDefault': ('maxIntersectionsPosition', 'OrDefault'), 'simpleLinearRegressionOrDefault': ('simpleLinearRegression', 'OrDefault'), 'stddevSampOrDefault': ('stddevSamp', 'OrDefault'), 'uniqThetaOrDefault': ('uniqTheta', 'OrDefault'), 'uniqCombinedOrDefault': ('uniqCombined', 'OrDefault'), 'quantileExactWeightedOrDefault': ('quantileExactWeighted', 'OrDefault'), 'rankCorrOrDefault': ('rankCorr', 'OrDefault'), 'sequenceCountOrDefault': ('sequenceCount', 'OrDefault'), 'sequenceMatchOrDefault': ('sequenceMatch', 'OrDefault'), 'histogramOrDefault': ('histogram', 'OrDefault'), 'groupBitOrOrDefault': ('groupBitOr', 'OrDefault'), 'maxOrDefault': ('max', 'OrDefault'), 'quantileTimingOrDefault': ('quantileTiming', 'OrDefault'), 'contingencyOrDefault': ('contingency', 'OrDefault'), 'maxIntersectionsOrDefault': ('maxIntersections', 'OrDefault'), 'groupBitmapOrOrDefault': ('groupBitmapOr', 'OrDefault'), 'quantilesTDigestOrDefault': ('quantilesTDigest', 'OrDefault'), 'avgWeightedOrDefault': ('avgWeighted', 'OrDefault'), 'entropyOrDefault': ('entropy', 'OrDefault'), 'kurtPopOrDefault': ('kurtPop', 'OrDefault'), 'quantilesOrDefault': ('quantiles', 'OrDefault'), 'avgOrDefault': ('avg', 'OrDefault'), 'groupArrayLastOrDefault': ('groupArrayLast', 'OrDefault'), 'groupBitmapAndOrDefault': ('groupBitmapAnd', 'OrDefault'), 'sumWithOverflowOrDefault': ('sumWithOverflow', 'OrDefault'), 'quantilesBFloat16OrDefault': ('quantilesBFloat16', 'OrDefault'), 'sumKahanOrDefault': ('sumKahan', 'OrDefault'), 'quantileGKOrDefault': ('quantileGK', 'OrDefault'), 'covarPopOrDefault': ('covarPop', 'OrDefault'), 'quantilesBFloat16WeightedOrDefault': ('quantilesBFloat16Weighted', 'OrDefault'), 'sumMapOrDefault': ('sumMap', 'OrDefault'), 'groupArraySampleOrDefault': ('groupArraySample', 'OrDefault'), 'groupBitXorOrDefault': ('groupBitXor', 'OrDefault'), 'argMaxOrDefault': ('argMax', 'OrDefault'), 'quantilesTimingWeightedOrDefault': ('quantilesTimingWeighted', 'OrDefault'), 'quantileExactHighOrDefault': ('quantileExactHigh', 'OrDefault'), 'quantileDeterministicOrDefault': ('quantileDeterministic', 'OrDefault'), 'meanZTestOrDefault': ('meanZTest', 'OrDefault'), 'sumCountOrDefault': ('sumCount', 'OrDefault'), 'exponentialMovingAverageOrDefault': ('exponentialMovingAverage', 'OrDefault'), 'anyHeavyOrDefault': ('anyHeavy', 'OrDefault'), 'stddevPopOrDefault': ('stddevPop', 'OrDefault'), 'exponentialTimeDecayedAvgOrDefault': ('exponentialTimeDecayedAvg', 'OrDefault'), 'anyOrDefault': ('any', 'OrDefault'), 'quantileTDigestWeightedOrDefault': ('quantileTDigestWeighted', 'OrDefault'), 'minMapOrDefault': ('minMap', 'OrDefault'), 'corrOrDefault': ('corr', 'OrDefault'), 'stochasticLogisticRegressionOrDefault': ('stochasticLogisticRegression', 'OrDefault'), 'varSampOrDefault': ('varSamp', 'OrDefault'), 'welchTTestOrDefault': ('welchTTest', 'OrDefault'), 'covarSampOrDefault': ('covarSamp', 'OrDefault'), 'sparkBarOrDefault': ('sparkBar', 'OrDefault'), 'maxMapOrDefault': ('maxMap', 'OrDefault'), 'groupArrayOrDefault': ('groupArray', 'OrDefault'), 'largestTriangleThreeBucketsOrDefault': ('largestTriangleThreeBuckets', 'OrDefault'), 'deltaSumTimestampOrDefault': ('deltaSumTimestamp', 'OrDefault'), 'uniqHLL12OrDefault': ('uniqHLL12', 'OrDefault'), 'groupBitAndOrDefault': ('groupBitAnd', 'OrDefault'), 'quantileBFloat16WeightedOrDefault': ('quantileBFloat16Weighted', 'OrDefault'), 'kurtSampOrDefault': ('kurtSamp', 'OrDefault'), 'topKOrDefault': ('topK', 'OrDefault'), 'quantileBFloat16OrDefault': ('quantileBFloat16', 'OrDefault'), 'cramersVOrDefault': ('cramersV', 'OrDefault'), 'anyLastOrDefault': ('anyLast', 'OrDefault'), 'quantilesExactLowOrDefault': ('quantilesExactLow', 'OrDefault'), 'sumOrDefault': ('sum', 'OrDefault'), 'quantileExactLowOrDefault': ('quantileExactLow', 'OrDefault'), 'quantilesTDigestWeightedOrDefault': ('quantilesTDigestWeighted', 'OrDefault'), 'argMinOrDefault': ('argMin', 'OrDefault'), 'quantileOrDefault': ('quantile', 'OrDefault'), 'quantileInterpolatedWeightedOrDefault': ('quantileInterpolatedWeighted', 'OrDefault'), 'quantilesTimingOrDefault': ('quantilesTiming', 'OrDefault'), 'theilsUOrDefault': ('theilsU', 'OrDefault'), 'last_valueOrDefault': ('last_value', 'OrDefault'), 'groupBitmapOrDefault': ('groupBitmap', 'OrDefault'), 'uniqCombined64OrDefault': ('uniqCombined64', 'OrDefault'), 'mannWhitneyUTestOrDefault': ('mannWhitneyUTest', 'OrDefault'), 'categoricalInformationValueOrDefault': ('categoricalInformationValue', 'OrDefault'), 'countOrDefault': ('count', 'OrDefault'), 'quantilesDeterministicOrDefault': ('quantilesDeterministic', 'OrDefault'), 'quantilesExactHighOrDefault': ('quantilesExactHigh', 'OrDefault'), 'first_valueOrDefault': ('first_value', 'OrDefault'), 'medianOrDefault': ('median', 'OrDefault'), 'quantileTDigestOrDefault': ('quantileTDigest', 'OrDefault'), 'intervalLengthSumOrDefault': ('intervalLengthSum', 'OrDefault'), 'sequenceNextNodeOrDefault': ('sequenceNextNode', 'OrDefault'), 'boundingRatioOrDefault': ('boundingRatio', 'OrDefault'), 'varPopOrDefault': ('varPop', 'OrDefault'), 'stochasticLinearRegressionOrDefault': ('stochasticLinearRegression', 'OrDefault'), 'quantileTimingWeightedOrDefault': ('quantileTimingWeighted', 'OrDefault'), 'quantilesExactWeightedOrDefault': ('quantilesExactWeighted', 'OrDefault'), 'groupBitmapXorOrDefault': ('groupBitmapXor', 'OrDefault'), 'retentionOrDefault': ('retention', 'OrDefault'), 'cramersVBiasCorrectedOrDefault': ('cramersVBiasCorrected', 'OrDefault'), 'groupArrayMovingAvgOrDefault': ('groupArrayMovingAvg', 'OrDefault'), 'quantilesInterpolatedWeightedOrDefault': ('quantilesInterpolatedWeighted', 'OrDefault'), 'topKWeightedOrDefault': ('topKWeighted', 'OrDefault'), 'groupArrayInsertAtOrDefault': ('groupArrayInsertAt', 'OrDefault'), 'windowFunnelOrDefault': ('windowFunnel', 'OrDefault'), 'quantilesGKOrNull': ('quantilesGK', 'OrNull'), 'skewSampOrNull': ('skewSamp', 'OrNull'), 'quantilesExactOrNull': ('quantilesExact', 'OrNull'), 'kolmogorovSmirnovTestOrNull': ('kolmogorovSmirnovTest', 'OrNull'), 'uniqOrNull': ('uniq', 'OrNull'), 'studentTTestOrNull': ('studentTTest', 'OrNull'), 'groupUniqArrayOrNull': ('groupUniqArray', 'OrNull'), 'uniqUpToOrNull': ('uniqUpTo', 'OrNull'), 'groupArrayMovingSumOrNull': ('groupArrayMovingSum', 'OrNull'), 'uniqExactOrNull': ('uniqExact', 'OrNull'), 'minOrNull': ('min', 'OrNull'), 'skewPopOrNull': ('skewPop', 'OrNull'), 'quantileExactOrNull': ('quantileExact', 'OrNull'), 'deltaSumOrNull': ('deltaSum', 'OrNull'), 'maxIntersectionsPositionOrNull': ('maxIntersectionsPosition', 'OrNull'), 'simpleLinearRegressionOrNull': ('simpleLinearRegression', 'OrNull'), 'stddevSampOrNull': ('stddevSamp', 'OrNull'), 'uniqThetaOrNull': ('uniqTheta', 'OrNull'), 'uniqCombinedOrNull': ('uniqCombined', 'OrNull'), 'quantileExactWeightedOrNull': ('quantileExactWeighted', 'OrNull'), 'rankCorrOrNull': ('rankCorr', 'OrNull'), 'sequenceCountOrNull': ('sequenceCount', 'OrNull'), 'sequenceMatchOrNull': ('sequenceMatch', 'OrNull'), 'histogramOrNull': ('histogram', 'OrNull'), 'groupBitOrOrNull': ('groupBitOr', 'OrNull'), 'maxOrNull': ('max', 'OrNull'), 'quantileTimingOrNull': ('quantileTiming', 'OrNull'), 'contingencyOrNull': ('contingency', 'OrNull'), 'maxIntersectionsOrNull': ('maxIntersections', 'OrNull'), 'groupBitmapOrOrNull': ('groupBitmapOr', 'OrNull'), 'quantilesTDigestOrNull': ('quantilesTDigest', 'OrNull'), 'avgWeightedOrNull': ('avgWeighted', 'OrNull'), 'entropyOrNull': ('entropy', 'OrNull'), 'kurtPopOrNull': ('kurtPop', 'OrNull'), 'quantilesOrNull': ('quantiles', 'OrNull'), 'avgOrNull': ('avg', 'OrNull'), 'groupArrayLastOrNull': ('groupArrayLast', 'OrNull'), 'groupBitmapAndOrNull': ('groupBitmapAnd', 'OrNull'), 'sumWithOverflowOrNull': ('sumWithOverflow', 'OrNull'), 'quantilesBFloat16OrNull': ('quantilesBFloat16', 'OrNull'), 'sumKahanOrNull': ('sumKahan', 'OrNull'), 'quantileGKOrNull': ('quantileGK', 'OrNull'), 'covarPopOrNull': ('covarPop', 'OrNull'), 'quantilesBFloat16WeightedOrNull': ('quantilesBFloat16Weighted', 'OrNull'), 'sumMapOrNull': ('sumMap', 'OrNull'), 'groupArraySampleOrNull': ('groupArraySample', 'OrNull'), 'groupBitXorOrNull': ('groupBitXor', 'OrNull'), 'argMaxOrNull': ('argMax', 'OrNull'), 'quantilesTimingWeightedOrNull': ('quantilesTimingWeighted', 'OrNull'), 'quantileExactHighOrNull': ('quantileExactHigh', 'OrNull'), 'quantileDeterministicOrNull': ('quantileDeterministic', 'OrNull'), 'meanZTestOrNull': ('meanZTest', 'OrNull'), 'sumCountOrNull': ('sumCount', 'OrNull'), 'exponentialMovingAverageOrNull': ('exponentialMovingAverage', 'OrNull'), 'anyHeavyOrNull': ('anyHeavy', 'OrNull'), 'stddevPopOrNull': ('stddevPop', 'OrNull'), 'exponentialTimeDecayedAvgOrNull': ('exponentialTimeDecayedAvg', 'OrNull'), 'anyOrNull': ('any', 'OrNull'), 'quantileTDigestWeightedOrNull': ('quantileTDigestWeighted', 'OrNull'), 'minMapOrNull': ('minMap', 'OrNull'), 'corrOrNull': ('corr', 'OrNull'), 'stochasticLogisticRegressionOrNull': ('stochasticLogisticRegression', 'OrNull'), 'varSampOrNull': ('varSamp', 'OrNull'), 'welchTTestOrNull': ('welchTTest', 'OrNull'), 'covarSampOrNull': ('covarSamp', 'OrNull'), 'sparkBarOrNull': ('sparkBar', 'OrNull'), 'maxMapOrNull': ('maxMap', 'OrNull'), 'groupArrayOrNull': ('groupArray', 'OrNull'), 'largestTriangleThreeBucketsOrNull': ('largestTriangleThreeBuckets', 'OrNull'), 'deltaSumTimestampOrNull': ('deltaSumTimestamp', 'OrNull'), 'uniqHLL12OrNull': ('uniqHLL12', 'OrNull'), 'groupBitAndOrNull': ('groupBitAnd', 'OrNull'), 'quantileBFloat16WeightedOrNull': ('quantileBFloat16Weighted', 'OrNull'), 'kurtSampOrNull': ('kurtSamp', 'OrNull'), 'topKOrNull': ('topK', 'OrNull'), 'quantileBFloat16OrNull': ('quantileBFloat16', 'OrNull'), 'cramersVOrNull': ('cramersV', 'OrNull'), 'anyLastOrNull': ('anyLast', 'OrNull'), 'quantilesExactLowOrNull': ('quantilesExactLow', 'OrNull'), 'sumOrNull': ('sum', 'OrNull'), 'quantileExactLowOrNull': ('quantileExactLow', 'OrNull'), 'quantilesTDigestWeightedOrNull': ('quantilesTDigestWeighted', 'OrNull'), 'argMinOrNull': ('argMin', 'OrNull'), 'quantileOrNull': ('quantile', 'OrNull'), 'quantileInterpolatedWeightedOrNull': ('quantileInterpolatedWeighted', 'OrNull'), 'quantilesTimingOrNull': ('quantilesTiming', 'OrNull'), 'theilsUOrNull': ('theilsU', 'OrNull'), 'last_valueOrNull': ('last_value', 'OrNull'), 'groupBitmapOrNull': ('groupBitmap', 'OrNull'), 'uniqCombined64OrNull': ('uniqCombined64', 'OrNull'), 'mannWhitneyUTestOrNull': ('mannWhitneyUTest', 'OrNull'), 'categoricalInformationValueOrNull': ('categoricalInformationValue', 'OrNull'), 'countOrNull': ('count', 'OrNull'), 'quantilesDeterministicOrNull': ('quantilesDeterministic', 'OrNull'), 'quantilesExactHighOrNull': ('quantilesExactHigh', 'OrNull'), 'first_valueOrNull': ('first_value', 'OrNull'), 'medianOrNull': ('median', 'OrNull'), 'quantileTDigestOrNull': ('quantileTDigest', 'OrNull'), 'intervalLengthSumOrNull': ('intervalLengthSum', 'OrNull'), 'sequenceNextNodeOrNull': ('sequenceNextNode', 'OrNull'), 'boundingRatioOrNull': ('boundingRatio', 'OrNull'), 'varPopOrNull': ('varPop', 'OrNull'), 'stochasticLinearRegressionOrNull': ('stochasticLinearRegression', 'OrNull'), 'quantileTimingWeightedOrNull': ('quantileTimingWeighted', 'OrNull'), 'quantilesExactWeightedOrNull': ('quantilesExactWeighted', 'OrNull'), 'groupBitmapXorOrNull': ('groupBitmapXor', 'OrNull'), 'retentionOrNull': ('retention', 'OrNull'), 'cramersVBiasCorrectedOrNull': ('cramersVBiasCorrected', 'OrNull'), 'groupArrayMovingAvgOrNull': ('groupArrayMovingAvg', 'OrNull'), 'quantilesInterpolatedWeightedOrNull': ('quantilesInterpolatedWeighted', 'OrNull'), 'topKWeightedOrNull': ('topKWeighted', 'OrNull'), 'groupArrayInsertAtOrNull': ('groupArrayInsertAt', 'OrNull'), 'windowFunnelOrNull': ('windowFunnel', 'OrNull'), 'quantilesGKResample': ('quantilesGK', 'Resample'), 'skewSampResample': ('skewSamp', 'Resample'), 'quantilesExactResample': ('quantilesExact', 'Resample'), 'kolmogorovSmirnovTestResample': ('kolmogorovSmirnovTest', 'Resample'), 'uniqResample': ('uniq', 'Resample'), 'studentTTestResample': ('studentTTest', 'Resample'), 'groupUniqArrayResample': ('groupUniqArray', 'Resample'), 'uniqUpToResample': ('uniqUpTo', 'Resample'), 'groupArrayMovingSumResample': ('groupArrayMovingSum', 'Resample'), 'uniqExactResample': ('uniqExact', 'Resample'), 'minResample': ('min', 'Resample'), 'skewPopResample': ('skewPop', 'Resample'), 'quantileExactResample': ('quantileExact', 'Resample'), 'deltaSumResample': ('deltaSum', 'Resample'), 'maxIntersectionsPositionResample': ('maxIntersectionsPosition', 'Resample'), 'simpleLinearRegressionResample': ('simpleLinearRegression', 'Resample'), 'stddevSampResample': ('stddevSamp', 'Resample'), 'uniqThetaResample': ('uniqTheta', 'Resample'), 'uniqCombinedResample': ('uniqCombined', 'Resample'), 'quantileExactWeightedResample': ('quantileExactWeighted', 'Resample'), 'rankCorrResample': ('rankCorr', 'Resample'), 'sequenceCountResample': ('sequenceCount', 'Resample'), 'sequenceMatchResample': ('sequenceMatch', 'Resample'), 'histogramResample': ('histogram', 'Resample'), 'groupBitOrResample': ('groupBitOr', 'Resample'), 'maxResample': ('max', 'Resample'), 'quantileTimingResample': ('quantileTiming', 'Resample'), 'contingencyResample': ('contingency', 'Resample'), 'maxIntersectionsResample': ('maxIntersections', 'Resample'), 'groupBitmapOrResample': ('groupBitmapOr', 'Resample'), 'quantilesTDigestResample': ('quantilesTDigest', 'Resample'), 'avgWeightedResample': ('avgWeighted', 'Resample'), 'entropyResample': ('entropy', 'Resample'), 'kurtPopResample': ('kurtPop', 'Resample'), 'quantilesResample': ('quantiles', 'Resample'), 'avgResample': ('avg', 'Resample'), 'groupArrayLastResample': ('groupArrayLast', 'Resample'), 'groupBitmapAndResample': ('groupBitmapAnd', 'Resample'), 'sumWithOverflowResample': ('sumWithOverflow', 'Resample'), 'quantilesBFloat16Resample': ('quantilesBFloat16', 'Resample'), 'sumKahanResample': ('sumKahan', 'Resample'), 'quantileGKResample': ('quantileGK', 'Resample'), 'covarPopResample': ('covarPop', 'Resample'), 'quantilesBFloat16WeightedResample': ('quantilesBFloat16Weighted', 'Resample'), 'sumMapResample': ('sumMap', 'Resample'), 'groupArraySampleResample': ('groupArraySample', 'Resample'), 'groupBitXorResample': ('groupBitXor', 'Resample'), 'argMaxResample': ('argMax', 'Resample'), 'quantilesTimingWeightedResample': ('quantilesTimingWeighted', 'Resample'), 'quantileExactHighResample': ('quantileExactHigh', 'Resample'), 'quantileDeterministicResample': ('quantileDeterministic', 'Resample'), 'meanZTestResample': ('meanZTest', 'Resample'), 'sumCountResample': ('sumCount', 'Resample'), 'exponentialMovingAverageResample': ('exponentialMovingAverage', 'Resample'), 'anyHeavyResample': ('anyHeavy', 'Resample'), 'stddevPopResample': ('stddevPop', 'Resample'), 'exponentialTimeDecayedAvgResample': ('exponentialTimeDecayedAvg', 'Resample'), 'anyResample': ('any', 'Resample'), 'quantileTDigestWeightedResample': ('quantileTDigestWeighted', 'Resample'), 'minMapResample': ('minMap', 'Resample'), 'corrResample': ('corr', 'Resample'), 'stochasticLogisticRegressionResample': ('stochasticLogisticRegression', 'Resample'), 'varSampResample': ('varSamp', 'Resample'), 'welchTTestResample': ('welchTTest', 'Resample'), 'covarSampResample': ('covarSamp', 'Resample'), 'sparkBarResample': ('sparkBar', 'Resample'), 'maxMapResample': ('maxMap', 'Resample'), 'groupArrayResample': ('groupArray', 'Resample'), 'largestTriangleThreeBucketsResample': ('largestTriangleThreeBuckets', 'Resample'), 'deltaSumTimestampResample': ('deltaSumTimestamp', 'Resample'), 'uniqHLL12Resample': ('uniqHLL12', 'Resample'), 'groupBitAndResample': ('groupBitAnd', 'Resample'), 'quantileBFloat16WeightedResample': ('quantileBFloat16Weighted', 'Resample'), 'kurtSampResample': ('kurtSamp', 'Resample'), 'topKResample': ('topK', 'Resample'), 'quantileBFloat16Resample': ('quantileBFloat16', 'Resample'), 'cramersVResample': ('cramersV', 'Resample'), 'anyLastResample': ('anyLast', 'Resample'), 'quantilesExactLowResample': ('quantilesExactLow', 'Resample'), 'sumResample': ('sum', 'Resample'), 'quantileExactLowResample': ('quantileExactLow', 'Resample'), 'quantilesTDigestWeightedResample': ('quantilesTDigestWeighted', 'Resample'), 'argMinResample': ('argMin', 'Resample'), 'quantileResample': ('quantile', 'Resample'), 'quantileInterpolatedWeightedResample': ('quantileInterpolatedWeighted', 'Resample'), 'quantilesTimingResample': ('quantilesTiming', 'Resample'), 'theilsUResample': ('theilsU', 'Resample'), 'last_valueResample': ('last_value', 'Resample'), 'groupBitmapResample': ('groupBitmap', 'Resample'), 'uniqCombined64Resample': ('uniqCombined64', 'Resample'), 'mannWhitneyUTestResample': ('mannWhitneyUTest', 'Resample'), 'categoricalInformationValueResample': ('categoricalInformationValue', 'Resample'), 'countResample': ('count', 'Resample'), 'quantilesDeterministicResample': ('quantilesDeterministic', 'Resample'), 'quantilesExactHighResample': ('quantilesExactHigh', 'Resample'), 'first_valueResample': ('first_value', 'Resample'), 'medianResample': ('median', 'Resample'), 'quantileTDigestResample': ('quantileTDigest', 'Resample'), 'intervalLengthSumResample': ('intervalLengthSum', 'Resample'), 'sequenceNextNodeResample': ('sequenceNextNode', 'Resample'), 'boundingRatioResample': ('boundingRatio', 'Resample'), 'varPopResample': ('varPop', 'Resample'), 'stochasticLinearRegressionResample': ('stochasticLinearRegression', 'Resample'), 'quantileTimingWeightedResample': ('quantileTimingWeighted', 'Resample'), 'quantilesExactWeightedResample': ('quantilesExactWeighted', 'Resample'), 'groupBitmapXorResample': ('groupBitmapXor', 'Resample'), 'retentionResample': ('retention', 'Resample'), 'cramersVBiasCorrectedResample': ('cramersVBiasCorrected', 'Resample'), 'groupArrayMovingAvgResample': ('groupArrayMovingAvg', 'Resample'), 'quantilesInterpolatedWeightedResample': ('quantilesInterpolatedWeighted', 'Resample'), 'topKWeightedResample': ('topKWeighted', 'Resample'), 'groupArrayInsertAtResample': ('groupArrayInsertAt', 'Resample'), 'windowFunnelResample': ('windowFunnel', 'Resample'), 'quantilesGKArgMin': ('quantilesGK', 'ArgMin'), 'skewSampArgMin': ('skewSamp', 'ArgMin'), 'quantilesExactArgMin': ('quantilesExact', 'ArgMin'), 'kolmogorovSmirnovTestArgMin': ('kolmogorovSmirnovTest', 'ArgMin'), 'uniqArgMin': ('uniq', 'ArgMin'), 'studentTTestArgMin': ('studentTTest', 'ArgMin'), 'groupUniqArrayArgMin': ('groupUniqArray', 'ArgMin'), 'uniqUpToArgMin': ('uniqUpTo', 'ArgMin'), 'groupArrayMovingSumArgMin': ('groupArrayMovingSum', 'ArgMin'), 'uniqExactArgMin': ('uniqExact', 'ArgMin'), 'minArgMin': ('min', 'ArgMin'), 'skewPopArgMin': ('skewPop', 'ArgMin'), 'quantileExactArgMin': ('quantileExact', 'ArgMin'), 'deltaSumArgMin': ('deltaSum', 'ArgMin'), 'maxIntersectionsPositionArgMin': ('maxIntersectionsPosition', 'ArgMin'), 'simpleLinearRegressionArgMin': ('simpleLinearRegression', 'ArgMin'), 'stddevSampArgMin': ('stddevSamp', 'ArgMin'), 'uniqThetaArgMin': ('uniqTheta', 'ArgMin'), 'uniqCombinedArgMin': ('uniqCombined', 'ArgMin'), 'quantileExactWeightedArgMin': ('quantileExactWeighted', 'ArgMin'), 'rankCorrArgMin': ('rankCorr', 'ArgMin'), 'sequenceCountArgMin': ('sequenceCount', 'ArgMin'), 'sequenceMatchArgMin': ('sequenceMatch', 'ArgMin'), 'histogramArgMin': ('histogram', 'ArgMin'), 'groupBitOrArgMin': ('groupBitOr', 'ArgMin'), 'maxArgMin': ('max', 'ArgMin'), 'quantileTimingArgMin': ('quantileTiming', 'ArgMin'), 'contingencyArgMin': ('contingency', 'ArgMin'), 'maxIntersectionsArgMin': ('maxIntersections', 'ArgMin'), 'groupBitmapOrArgMin': ('groupBitmapOr', 'ArgMin'), 'quantilesTDigestArgMin': ('quantilesTDigest', 'ArgMin'), 'avgWeightedArgMin': ('avgWeighted', 'ArgMin'), 'entropyArgMin': ('entropy', 'ArgMin'), 'kurtPopArgMin': ('kurtPop', 'ArgMin'), 'quantilesArgMin': ('quantiles', 'ArgMin'), 'avgArgMin': ('avg', 'ArgMin'), 'groupArrayLastArgMin': ('groupArrayLast', 'ArgMin'), 'groupBitmapAndArgMin': ('groupBitmapAnd', 'ArgMin'), 'sumWithOverflowArgMin': ('sumWithOverflow', 'ArgMin'), 'quantilesBFloat16ArgMin': ('quantilesBFloat16', 'ArgMin'), 'sumKahanArgMin': ('sumKahan', 'ArgMin'), 'quantileGKArgMin': ('quantileGK', 'ArgMin'), 'covarPopArgMin': ('covarPop', 'ArgMin'), 'quantilesBFloat16WeightedArgMin': ('quantilesBFloat16Weighted', 'ArgMin'), 'sumMapArgMin': ('sumMap', 'ArgMin'), 'groupArraySampleArgMin': ('groupArraySample', 'ArgMin'), 'groupBitXorArgMin': ('groupBitXor', 'ArgMin'), 'argMaxArgMin': ('argMax', 'ArgMin'), 'quantilesTimingWeightedArgMin': ('quantilesTimingWeighted', 'ArgMin'), 'quantileExactHighArgMin': ('quantileExactHigh', 'ArgMin'), 'quantileDeterministicArgMin': ('quantileDeterministic', 'ArgMin'), 'meanZTestArgMin': ('meanZTest', 'ArgMin'), 'sumCountArgMin': ('sumCount', 'ArgMin'), 'exponentialMovingAverageArgMin': ('exponentialMovingAverage', 'ArgMin'), 'anyHeavyArgMin': ('anyHeavy', 'ArgMin'), 'stddevPopArgMin': ('stddevPop', 'ArgMin'), 'exponentialTimeDecayedAvgArgMin': ('exponentialTimeDecayedAvg', 'ArgMin'), 'anyArgMin': ('any', 'ArgMin'), 'quantileTDigestWeightedArgMin': ('quantileTDigestWeighted', 'ArgMin'), 'minMapArgMin': ('minMap', 'ArgMin'), 'corrArgMin': ('corr', 'ArgMin'), 'stochasticLogisticRegressionArgMin': ('stochasticLogisticRegression', 'ArgMin'), 'varSampArgMin': ('varSamp', 'ArgMin'), 'welchTTestArgMin': ('welchTTest', 'ArgMin'), 'covarSampArgMin': ('covarSamp', 'ArgMin'), 'sparkBarArgMin': ('sparkBar', 'ArgMin'), 'maxMapArgMin': ('maxMap', 'ArgMin'), 'groupArrayArgMin': ('groupArray', 'ArgMin'), 'largestTriangleThreeBucketsArgMin': ('largestTriangleThreeBuckets', 'ArgMin'), 'deltaSumTimestampArgMin': ('deltaSumTimestamp', 'ArgMin'), 'uniqHLL12ArgMin': ('uniqHLL12', 'ArgMin'), 'groupBitAndArgMin': ('groupBitAnd', 'ArgMin'), 'quantileBFloat16WeightedArgMin': ('quantileBFloat16Weighted', 'ArgMin'), 'kurtSampArgMin': ('kurtSamp', 'ArgMin'), 'topKArgMin': ('topK', 'ArgMin'), 'quantileBFloat16ArgMin': ('quantileBFloat16', 'ArgMin'), 'cramersVArgMin': ('cramersV', 'ArgMin'), 'anyLastArgMin': ('anyLast', 'ArgMin'), 'quantilesExactLowArgMin': ('quantilesExactLow', 'ArgMin'), 'sumArgMin': ('sum', 'ArgMin'), 'quantileExactLowArgMin': ('quantileExactLow', 'ArgMin'), 'quantilesTDigestWeightedArgMin': ('quantilesTDigestWeighted', 'ArgMin'), 'argMinArgMin': ('argMin', 'ArgMin'), 'quantileArgMin': ('quantile', 'ArgMin'), 'quantileInterpolatedWeightedArgMin': ('quantileInterpolatedWeighted', 'ArgMin'), 'quantilesTimingArgMin': ('quantilesTiming', 'ArgMin'), 'theilsUArgMin': ('theilsU', 'ArgMin'), 'last_valueArgMin': ('last_value', 'ArgMin'), 'groupBitmapArgMin': ('groupBitmap', 'ArgMin'), 'uniqCombined64ArgMin': ('uniqCombined64', 'ArgMin'), 'mannWhitneyUTestArgMin': ('mannWhitneyUTest', 'ArgMin'), 'categoricalInformationValueArgMin': ('categoricalInformationValue', 'ArgMin'), 'countArgMin': ('count', 'ArgMin'), 'quantilesDeterministicArgMin': ('quantilesDeterministic', 'ArgMin'), 'quantilesExactHighArgMin': ('quantilesExactHigh', 'ArgMin'), 'first_valueArgMin': ('first_value', 'ArgMin'), 'medianArgMin': ('median', 'ArgMin'), 'quantileTDigestArgMin': ('quantileTDigest', 'ArgMin'), 'intervalLengthSumArgMin': ('intervalLengthSum', 'ArgMin'), 'sequenceNextNodeArgMin': ('sequenceNextNode', 'ArgMin'), 'boundingRatioArgMin': ('boundingRatio', 'ArgMin'), 'varPopArgMin': ('varPop', 'ArgMin'), 'stochasticLinearRegressionArgMin': ('stochasticLinearRegression', 'ArgMin'), 'quantileTimingWeightedArgMin': ('quantileTimingWeighted', 'ArgMin'), 'quantilesExactWeightedArgMin': ('quantilesExactWeighted', 'ArgMin'), 'groupBitmapXorArgMin': ('groupBitmapXor', 'ArgMin'), 'retentionArgMin': ('retention', 'ArgMin'), 'cramersVBiasCorrectedArgMin': ('cramersVBiasCorrected', 'ArgMin'), 'groupArrayMovingAvgArgMin': ('groupArrayMovingAvg', 'ArgMin'), 'quantilesInterpolatedWeightedArgMin': ('quantilesInterpolatedWeighted', 'ArgMin'), 'topKWeightedArgMin': ('topKWeighted', 'ArgMin'), 'groupArrayInsertAtArgMin': ('groupArrayInsertAt', 'ArgMin'), 'windowFunnelArgMin': ('windowFunnel', 'ArgMin'), 'quantilesGKArgMax': ('quantilesGK', 'ArgMax'), 'skewSampArgMax': ('skewSamp', 'ArgMax'), 'quantilesExactArgMax': ('quantilesExact', 'ArgMax'), 'kolmogorovSmirnovTestArgMax': ('kolmogorovSmirnovTest', 'ArgMax'), 'uniqArgMax': ('uniq', 'ArgMax'), 'studentTTestArgMax': ('studentTTest', 'ArgMax'), 'groupUniqArrayArgMax': ('groupUniqArray', 'ArgMax'), 'uniqUpToArgMax': ('uniqUpTo', 'ArgMax'), 'groupArrayMovingSumArgMax': ('groupArrayMovingSum', 'ArgMax'), 'uniqExactArgMax': ('uniqExact', 'ArgMax'), 'minArgMax': ('min', 'ArgMax'), 'skewPopArgMax': ('skewPop', 'ArgMax'), 'quantileExactArgMax': ('quantileExact', 'ArgMax'), 'deltaSumArgMax': ('deltaSum', 'ArgMax'), 'maxIntersectionsPositionArgMax': ('maxIntersectionsPosition', 'ArgMax'), 'simpleLinearRegressionArgMax': ('simpleLinearRegression', 'ArgMax'), 'stddevSampArgMax': ('stddevSamp', 'ArgMax'), 'uniqThetaArgMax': ('uniqTheta', 'ArgMax'), 'uniqCombinedArgMax': ('uniqCombined', 'ArgMax'), 'quantileExactWeightedArgMax': ('quantileExactWeighted', 'ArgMax'), 'rankCorrArgMax': ('rankCorr', 'ArgMax'), 'sequenceCountArgMax': ('sequenceCount', 'ArgMax'), 'sequenceMatchArgMax': ('sequenceMatch', 'ArgMax'), 'histogramArgMax': ('histogram', 'ArgMax'), 'groupBitOrArgMax': ('groupBitOr', 'ArgMax'), 'maxArgMax': ('max', 'ArgMax'), 'quantileTimingArgMax': ('quantileTiming', 'ArgMax'), 'contingencyArgMax': ('contingency', 'ArgMax'), 'maxIntersectionsArgMax': ('maxIntersections', 'ArgMax'), 'groupBitmapOrArgMax': ('groupBitmapOr', 'ArgMax'), 'quantilesTDigestArgMax': ('quantilesTDigest', 'ArgMax'), 'avgWeightedArgMax': ('avgWeighted', 'ArgMax'), 'entropyArgMax': ('entropy', 'ArgMax'), 'kurtPopArgMax': ('kurtPop', 'ArgMax'), 'quantilesArgMax': ('quantiles', 'ArgMax'), 'avgArgMax': ('avg', 'ArgMax'), 'groupArrayLastArgMax': ('groupArrayLast', 'ArgMax'), 'groupBitmapAndArgMax': ('groupBitmapAnd', 'ArgMax'), 'sumWithOverflowArgMax': ('sumWithOverflow', 'ArgMax'), 'quantilesBFloat16ArgMax': ('quantilesBFloat16', 'ArgMax'), 'sumKahanArgMax': ('sumKahan', 'ArgMax'), 'quantileGKArgMax': ('quantileGK', 'ArgMax'), 'covarPopArgMax': ('covarPop', 'ArgMax'), 'quantilesBFloat16WeightedArgMax': ('quantilesBFloat16Weighted', 'ArgMax'), 'sumMapArgMax': ('sumMap', 'ArgMax'), 'groupArraySampleArgMax': ('groupArraySample', 'ArgMax'), 'groupBitXorArgMax': ('groupBitXor', 'ArgMax'), 'argMaxArgMax': ('argMax', 'ArgMax'), 'quantilesTimingWeightedArgMax': ('quantilesTimingWeighted', 'ArgMax'), 'quantileExactHighArgMax': ('quantileExactHigh', 'ArgMax'), 'quantileDeterministicArgMax': ('quantileDeterministic', 'ArgMax'), 'meanZTestArgMax': ('meanZTest', 'ArgMax'), 'sumCountArgMax': ('sumCount', 'ArgMax'), 'exponentialMovingAverageArgMax': ('exponentialMovingAverage', 'ArgMax'), 'anyHeavyArgMax': ('anyHeavy', 'ArgMax'), 'stddevPopArgMax': ('stddevPop', 'ArgMax'), 'exponentialTimeDecayedAvgArgMax': ('exponentialTimeDecayedAvg', 'ArgMax'), 'anyArgMax': ('any', 'ArgMax'), 'quantileTDigestWeightedArgMax': ('quantileTDigestWeighted', 'ArgMax'), 'minMapArgMax': ('minMap', 'ArgMax'), 'corrArgMax': ('corr', 'ArgMax'), 'stochasticLogisticRegressionArgMax': ('stochasticLogisticRegression', 'ArgMax'), 'varSampArgMax': ('varSamp', 'ArgMax'), 'welchTTestArgMax': ('welchTTest', 'ArgMax'), 'covarSampArgMax': ('covarSamp', 'ArgMax'), 'sparkBarArgMax': ('sparkBar', 'ArgMax'), 'maxMapArgMax': ('maxMap', 'ArgMax'), 'groupArrayArgMax': ('groupArray', 'ArgMax'), 'largestTriangleThreeBucketsArgMax': ('largestTriangleThreeBuckets', 'ArgMax'), 'deltaSumTimestampArgMax': ('deltaSumTimestamp', 'ArgMax'), 'uniqHLL12ArgMax': ('uniqHLL12', 'ArgMax'), 'groupBitAndArgMax': ('groupBitAnd', 'ArgMax'), 'quantileBFloat16WeightedArgMax': ('quantileBFloat16Weighted', 'ArgMax'), 'kurtSampArgMax': ('kurtSamp', 'ArgMax'), 'topKArgMax': ('topK', 'ArgMax'), 'quantileBFloat16ArgMax': ('quantileBFloat16', 'ArgMax'), 'cramersVArgMax': ('cramersV', 'ArgMax'), 'anyLastArgMax': ('anyLast', 'ArgMax'), 'quantilesExactLowArgMax': ('quantilesExactLow', 'ArgMax'), 'sumArgMax': ('sum', 'ArgMax'), 'quantileExactLowArgMax': ('quantileExactLow', 'ArgMax'), 'quantilesTDigestWeightedArgMax': ('quantilesTDigestWeighted', 'ArgMax'), 'argMinArgMax': ('argMin', 'ArgMax'), 'quantileArgMax': ('quantile', 'ArgMax'), 'quantileInterpolatedWeightedArgMax': ('quantileInterpolatedWeighted', 'ArgMax'), 'quantilesTimingArgMax': ('quantilesTiming', 'ArgMax'), 'theilsUArgMax': ('theilsU', 'ArgMax'), 'last_valueArgMax': ('last_value', 'ArgMax'), 'groupBitmapArgMax': ('groupBitmap', 'ArgMax'), 'uniqCombined64ArgMax': ('uniqCombined64', 'ArgMax'), 'mannWhitneyUTestArgMax': ('mannWhitneyUTest', 'ArgMax'), 'categoricalInformationValueArgMax': ('categoricalInformationValue', 'ArgMax'), 'countArgMax': ('count', 'ArgMax'), 'quantilesDeterministicArgMax': ('quantilesDeterministic', 'ArgMax'), 'quantilesExactHighArgMax': ('quantilesExactHigh', 'ArgMax'), 'first_valueArgMax': ('first_value', 'ArgMax'), 'medianArgMax': ('median', 'ArgMax'), 'quantileTDigestArgMax': ('quantileTDigest', 'ArgMax'), 'intervalLengthSumArgMax': ('intervalLengthSum', 'ArgMax'), 'sequenceNextNodeArgMax': ('sequenceNextNode', 'ArgMax'), 'boundingRatioArgMax': ('boundingRatio', 'ArgMax'), 'varPopArgMax': ('varPop', 'ArgMax'), 'stochasticLinearRegressionArgMax': ('stochasticLinearRegression', 'ArgMax'), 'quantileTimingWeightedArgMax': ('quantileTimingWeighted', 'ArgMax'), 'quantilesExactWeightedArgMax': ('quantilesExactWeighted', 'ArgMax'), 'groupBitmapXorArgMax': ('groupBitmapXor', 'ArgMax'), 'retentionArgMax': ('retention', 'ArgMax'), 'cramersVBiasCorrectedArgMax': ('cramersVBiasCorrected', 'ArgMax'), 'groupArrayMovingAvgArgMax': ('groupArrayMovingAvg', 'ArgMax'), 'quantilesInterpolatedWeightedArgMax': ('quantilesInterpolatedWeighted', 'ArgMax'), 'topKWeightedArgMax': ('topKWeighted', 'ArgMax'), 'groupArrayInsertAtArgMax': ('groupArrayInsertAt', 'ArgMax'), 'windowFunnelArgMax': ('windowFunnel', 'ArgMax'), 'quantilesGK': ('quantilesGK', ''), 'skewSamp': ('skewSamp', ''), 'quantilesExact': ('quantilesExact', ''), 'kolmogorovSmirnovTest': ('kolmogorovSmirnovTest', ''), 'uniq': ('uniq', ''), 'studentTTest': ('studentTTest', ''), 'groupUniqArray': ('groupUniqArray', ''), 'uniqUpTo': ('uniqUpTo', ''), 'groupArrayMovingSum': ('groupArrayMovingSum', ''), 'uniqExact': ('uniqExact', ''), 'min': ('min', ''), 'skewPop': ('skewPop', ''), 'quantileExact': ('quantileExact', ''), 'deltaSum': ('deltaSum', ''), 'maxIntersectionsPosition': ('maxIntersectionsPosition', ''), 'simpleLinearRegression': ('simpleLinearRegression', ''), 'stddevSamp': ('stddevSamp', ''), 'uniqTheta': ('uniqTheta', ''), 'uniqCombined': ('uniqCombined', ''), 'quantileExactWeighted': ('quantileExactWeighted', ''), 'rankCorr': ('rankCorr', ''), 'sequenceCount': ('sequenceCount', ''), 'sequenceMatch': ('sequenceMatch', ''), 'histogram': ('histogram', ''), 'groupBitOr': ('groupBitOr', ''), 'max': ('max', ''), 'quantileTiming': ('quantileTiming', ''), 'contingency': ('contingency', ''), 'maxIntersections': ('maxIntersections', ''), 'groupBitmapOr': ('groupBitmapOr', ''), 'quantilesTDigest': ('quantilesTDigest', ''), 'avgWeighted': ('avgWeighted', ''), 'entropy': ('entropy', ''), 'kurtPop': ('kurtPop', ''), 'quantiles': ('quantiles', ''), 'avg': ('avg', ''), 'groupArrayLast': ('groupArrayLast', ''), 'groupBitmapAnd': ('groupBitmapAnd', ''), 'sumWithOverflow': ('sumWithOverflow', ''), 'quantilesBFloat16': ('quantilesBFloat16', ''), 'sumKahan': ('sumKahan', ''), 'quantileGK': ('quantileGK', ''), 'covarPop': ('covarPop', ''), 'quantilesBFloat16Weighted': ('quantilesBFloat16Weighted', ''), 'groupArraySample': ('groupArraySample', ''), 'groupBitXor': ('groupBitXor', ''), 'argMax': ('argMax', ''), 'quantilesTimingWeighted': ('quantilesTimingWeighted', ''), 'quantileExactHigh': ('quantileExactHigh', ''), 'quantileDeterministic': ('quantileDeterministic', ''), 'meanZTest': ('meanZTest', ''), 'sumCount': ('sumCount', ''), 'exponentialMovingAverage': ('exponentialMovingAverage', ''), 'anyHeavy': ('anyHeavy', ''), 'stddevPop': ('stddevPop', ''), 'exponentialTimeDecayedAvg': ('exponentialTimeDecayedAvg', ''), 'any': ('any', ''), 'quantileTDigestWeighted': ('quantileTDigestWeighted', ''), 'corr': ('corr', ''), 'stochasticLogisticRegression': ('stochasticLogisticRegression', ''), 'varSamp': ('varSamp', ''), 'welchTTest': ('welchTTest', ''), 'covarSamp': ('covarSamp', ''), 'sparkBar': ('sparkBar', ''), 'groupArray': ('groupArray', ''), 'largestTriangleThreeBuckets': ('largestTriangleThreeBuckets', ''), 'deltaSumTimestamp': ('deltaSumTimestamp', ''), 'uniqHLL12': ('uniqHLL12', ''), 'groupBitAnd': ('groupBitAnd', ''), 'quantileBFloat16Weighted': ('quantileBFloat16Weighted', ''), 'kurtSamp': ('kurtSamp', ''), 'topK': ('topK', ''), 'quantileBFloat16': ('quantileBFloat16', ''), 'cramersV': ('cramersV', ''), 'anyLast': ('anyLast', ''), 'quantilesExactLow': ('quantilesExactLow', ''), 'sum': ('sum', ''), 'quantileExactLow': ('quantileExactLow', ''), 'quantilesTDigestWeighted': ('quantilesTDigestWeighted', ''), 'argMin': ('argMin', ''), 'quantile': ('quantile', ''), 'quantileInterpolatedWeighted': ('quantileInterpolatedWeighted', ''), 'quantilesTiming': ('quantilesTiming', ''), 'theilsU': ('theilsU', ''), 'last_value': ('last_value', ''), 'groupBitmap': ('groupBitmap', ''), 'uniqCombined64': ('uniqCombined64', ''), 'mannWhitneyUTest': ('mannWhitneyUTest', ''), 'categoricalInformationValue': ('categoricalInformationValue', ''), 'count': ('count', ''), 'quantilesDeterministic': ('quantilesDeterministic', ''), 'quantilesExactHigh': ('quantilesExactHigh', ''), 'first_value': ('first_value', ''), 'median': ('median', ''), 'quantileTDigest': ('quantileTDigest', ''), 'intervalLengthSum': ('intervalLengthSum', ''), 'sequenceNextNode': ('sequenceNextNode', ''), 'boundingRatio': ('boundingRatio', ''), 'varPop': ('varPop', ''), 'stochasticLinearRegression': ('stochasticLinearRegression', ''), 'quantileTimingWeighted': ('quantileTimingWeighted', ''), 'quantilesExactWeighted': ('quantilesExactWeighted', ''), 'groupBitmapXor': ('groupBitmapXor', ''), 'retention': ('retention', ''), 'cramersVBiasCorrected': ('cramersVBiasCorrected', ''), 'groupArrayMovingAvg': ('groupArrayMovingAvg', ''), 'quantilesInterpolatedWeighted': ('quantilesInterpolatedWeighted', ''), 'topKWeighted': ('topKWeighted', ''), 'groupArrayInsertAt': ('groupArrayInsertAt', ''), 'windowFunnel': ('windowFunnel', '')}
FUNCTIONS_WITH_ALIASED_ARGS = {'TUPLE', 'STRUCT'}
FUNCTION_PARSERS = {'CAST': <function Parser.<lambda>>, 'CONVERT': <function Parser.<lambda>>, 'DECODE': <function Parser.<lambda>>, 'EXTRACT': <function Parser.<lambda>>, 'GAP_FILL': <function Parser.<lambda>>, 'JSON_OBJECT': <function Parser.<lambda>>, 'JSON_OBJECTAGG': <function Parser.<lambda>>, 'JSON_TABLE': <function Parser.<lambda>>, 'OPENJSON': <function Parser.<lambda>>, 'POSITION': <function Parser.<lambda>>, 'PREDICT': <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>>, 'ARRAYJOIN': <function ClickHouse.Parser.<lambda>>, 'QUANTILE': <function ClickHouse.Parser.<lambda>>}
NO_PAREN_FUNCTION_PARSERS = {'CASE': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <function Parser.<lambda>>, 'IF': <function Parser.<lambda>>, 'NEXT': <function Parser.<lambda>>}
RANGE_PARSERS = {<TokenType.BETWEEN: 'BETWEEN'>: <function Parser.<lambda>>, <TokenType.GLOB: 'GLOB'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.ILIKE: 'ILIKE'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IN: 'IN'>: <function Parser.<lambda>>, <TokenType.IRLIKE: 'IRLIKE'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IS: 'IS'>: <function Parser.<lambda>>, <TokenType.LIKE: 'LIKE'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.OVERLAPS: 'OVERLAPS'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.RLIKE: 'RLIKE'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.SIMILAR_TO: 'SIMILAR_TO'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.FOR: 'FOR'>: <function Parser.<lambda>>, <TokenType.GLOBAL: 'GLOBAL'>: <function ClickHouse.Parser.<lambda>>}
COLUMN_OPERATORS = {<TokenType.DOT: 'DOT'>: None, <TokenType.DCOLON: 'DCOLON'>: <function Parser.<lambda>>, <TokenType.ARROW: 'ARROW'>: <function Parser.<lambda>>, <TokenType.DARROW: 'DARROW'>: <function Parser.<lambda>>, <TokenType.HASH_ARROW: 'HASH_ARROW'>: <function Parser.<lambda>>, <TokenType.DHASH_ARROW: 'DHASH_ARROW'>: <function Parser.<lambda>>}
JOIN_KINDS = {<TokenType.ASOF: 'ASOF'>, <TokenType.CROSS: 'CROSS'>, <TokenType.OUTER: 'OUTER'>, <TokenType.ANTI: 'ANTI'>, <TokenType.SEMI: 'SEMI'>, <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, <TokenType.ANY: 'ANY'>, <TokenType.INNER: 'INNER'>, <TokenType.ARRAY: 'ARRAY'>}
TABLE_ALIAS_TOKENS = {<TokenType.REPLACE: 'REPLACE'>, <TokenType.ALL: 'ALL'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.CACHE: 'CACHE'>, <TokenType.TIME: 'TIME'>, <TokenType.UUID: 'UUID'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.NAME: 'NAME'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.UINT: 'UINT'>, <TokenType.ENUM: 'ENUM'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, <TokenType.INDEX: 'INDEX'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TEXT: 'TEXT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.JSON: 'JSON'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.MODEL: 'MODEL'>, <TokenType.FIRST: 'FIRST'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.RENAME: 'RENAME'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.INET: 'INET'>, <TokenType.KEEP: 'KEEP'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.XML: 'XML'>, <TokenType.UINT256: 'UINT256'>, <TokenType.MAP: 'MAP'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.TRUE: 'TRUE'>, <TokenType.INT128: 'INT128'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.CUBE: 'CUBE'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.LIST: 'LIST'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.VIEW: 'VIEW'>, <TokenType.SHOW: 'SHOW'>, <TokenType.COPY: 'COPY'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.CASE: 'CASE'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.ROW: 'ROW'>, <TokenType.NULL: 'NULL'>, <TokenType.CHAR: 'CHAR'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.SUPER: 'SUPER'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.TABLE: 'TABLE'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.INT256: 'INT256'>, <TokenType.DATE32: 'DATE32'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.NESTED: 'NESTED'>, <TokenType.DATE: 'DATE'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.YEAR: 'YEAR'>, <TokenType.IPV6: 'IPV6'>, <TokenType.BIT: 'BIT'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.MONEY: 'MONEY'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.KILL: 'KILL'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.ASC: 'ASC'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.USE: 'USE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.ROWS: 'ROWS'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.FALSE: 'FALSE'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.DIV: 'DIV'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.SOME: 'SOME'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.UINT128: 'UINT128'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.END: 'END'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.JSONB: 'JSONB'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.DELETE: 'DELETE'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.INT: 'INT'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.DESC: 'DESC'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.TAG: 'TAG'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.RANGE: 'RANGE'>, <TokenType.IPV4: 'IPV4'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.VAR: 'VAR'>, <TokenType.IS: 'IS'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.LOAD: 'LOAD'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.TOP: 'TOP'>, <TokenType.SET: 'SET'>, <TokenType.NEXT: 'NEXT'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.BINARY: 'BINARY'>}
ALIAS_TOKENS = {<TokenType.REPLACE: 'REPLACE'>, <TokenType.ALL: 'ALL'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.CACHE: 'CACHE'>, <TokenType.TIME: 'TIME'>, <TokenType.UUID: 'UUID'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.NAME: 'NAME'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.UINT: 'UINT'>, <TokenType.ENUM: 'ENUM'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.INDEX: 'INDEX'>, <TokenType.FULL: 'FULL'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TEXT: 'TEXT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.JSON: 'JSON'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.ASOF: 'ASOF'>, <TokenType.MODEL: 'MODEL'>, <TokenType.FIRST: 'FIRST'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.RENAME: 'RENAME'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.INET: 'INET'>, <TokenType.KEEP: 'KEEP'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.XML: 'XML'>, <TokenType.UINT256: 'UINT256'>, <TokenType.MAP: 'MAP'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.TRUE: 'TRUE'>, <TokenType.INT128: 'INT128'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.CUBE: 'CUBE'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.SEMI: 'SEMI'>, <TokenType.LIST: 'LIST'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.VIEW: 'VIEW'>, <TokenType.SHOW: 'SHOW'>, <TokenType.COPY: 'COPY'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.CASE: 'CASE'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.FINAL: 'FINAL'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.ROW: 'ROW'>, <TokenType.NULL: 'NULL'>, <TokenType.CHAR: 'CHAR'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.SUPER: 'SUPER'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.TABLE: 'TABLE'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.INT256: 'INT256'>, <TokenType.DATE32: 'DATE32'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.NESTED: 'NESTED'>, <TokenType.DATE: 'DATE'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.YEAR: 'YEAR'>, <TokenType.IPV6: 'IPV6'>, <TokenType.BIT: 'BIT'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.MONEY: 'MONEY'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.KILL: 'KILL'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.LEFT: 'LEFT'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.ASC: 'ASC'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.USE: 'USE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.ROWS: 'ROWS'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.FALSE: 'FALSE'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.DIV: 'DIV'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.SOME: 'SOME'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.UINT128: 'UINT128'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.APPLY: 'APPLY'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.ANY: 'ANY'>, <TokenType.END: 'END'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.JSONB: 'JSONB'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.DELETE: 'DELETE'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.INT: 'INT'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.MERGE: 'MERGE'>, <TokenType.ANTI: 'ANTI'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.DESC: 'DESC'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.TAG: 'TAG'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.RANGE: 'RANGE'>, <TokenType.IPV4: 'IPV4'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.VAR: 'VAR'>, <TokenType.IS: 'IS'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.LOAD: 'LOAD'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.TOP: 'TOP'>, <TokenType.SET: 'SET'>, <TokenType.NEXT: 'NEXT'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.BINARY: 'BINARY'>}
LOG_DEFAULTS_TO_LN = True
QUERY_MODIFIER_PARSERS = {<TokenType.MATCH_RECOGNIZE: 'MATCH_RECOGNIZE'>: <function Parser.<lambda>>, <TokenType.PREWHERE: 'PREWHERE'>: <function Parser.<lambda>>, <TokenType.WHERE: 'WHERE'>: <function Parser.<lambda>>, <TokenType.GROUP_BY: 'GROUP_BY'>: <function Parser.<lambda>>, <TokenType.HAVING: 'HAVING'>: <function Parser.<lambda>>, <TokenType.QUALIFY: 'QUALIFY'>: <function Parser.<lambda>>, <TokenType.WINDOW: 'WINDOW'>: <function Parser.<lambda>>, <TokenType.ORDER_BY: 'ORDER_BY'>: <function Parser.<lambda>>, <TokenType.LIMIT: 'LIMIT'>: <function Parser.<lambda>>, <TokenType.FETCH: 'FETCH'>: <function Parser.<lambda>>, <TokenType.OFFSET: 'OFFSET'>: <function Parser.<lambda>>, <TokenType.FOR: 'FOR'>: <function Parser.<lambda>>, <TokenType.LOCK: 'LOCK'>: <function Parser.<lambda>>, <TokenType.TABLE_SAMPLE: 'TABLE_SAMPLE'>: <function Parser.<lambda>>, <TokenType.USING: 'USING'>: <function Parser.<lambda>>, <TokenType.CLUSTER_BY: 'CLUSTER_BY'>: <function Parser.<lambda>>, <TokenType.DISTRIBUTE_BY: 'DISTRIBUTE_BY'>: <function Parser.<lambda>>, <TokenType.SORT_BY: 'SORT_BY'>: <function Parser.<lambda>>, <TokenType.CONNECT_BY: 'CONNECT_BY'>: <function Parser.<lambda>>, <TokenType.START_WITH: 'START_WITH'>: <function Parser.<lambda>>, <TokenType.SETTINGS: 'SETTINGS'>: <function ClickHouse.Parser.<lambda>>, <TokenType.FORMAT: 'FORMAT'>: <function ClickHouse.Parser.<lambda>>}
CONSTRAINT_PARSERS = {'AUTOINCREMENT': <function Parser.<lambda>>, 'AUTO_INCREMENT': <function Parser.<lambda>>, 'CASESPECIFIC': <function Parser.<lambda>>, 'CHARACTER SET': <function Parser.<lambda>>, 'CHECK': <function Parser.<lambda>>, 'COLLATE': <function Parser.<lambda>>, 'COMMENT': <function Parser.<lambda>>, 'COMPRESS': <function Parser.<lambda>>, 'CLUSTERED': <function Parser.<lambda>>, 'NONCLUSTERED': <function Parser.<lambda>>, 'DEFAULT': <function Parser.<lambda>>, 'ENCODE': <function Parser.<lambda>>, 'EPHEMERAL': <function Parser.<lambda>>, 'EXCLUDE': <function Parser.<lambda>>, 'FOREIGN KEY': <function Parser.<lambda>>, 'FORMAT': <function Parser.<lambda>>, 'GENERATED': <function Parser.<lambda>>, 'IDENTITY': <function Parser.<lambda>>, 'INLINE': <function Parser.<lambda>>, 'LIKE': <function Parser.<lambda>>, 'NOT': <function Parser.<lambda>>, 'NULL': <function Parser.<lambda>>, 'ON': <function Parser.<lambda>>, 'PATH': <function Parser.<lambda>>, 'PERIOD': <function Parser.<lambda>>, 'PRIMARY KEY': <function Parser.<lambda>>, 'REFERENCES': <function Parser.<lambda>>, 'TITLE': <function Parser.<lambda>>, 'TTL': <function Parser.<lambda>>, 'UNIQUE': <function Parser.<lambda>>, 'UPPERCASE': <function Parser.<lambda>>, 'WITH': <function Parser.<lambda>>, 'INDEX': <function ClickHouse.Parser.<lambda>>, 'CODEC': <function ClickHouse.Parser.<lambda>>}
ALTER_PARSERS = {'ADD': <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>>, 'AS': <function Parser.<lambda>>, 'REPLACE': <function ClickHouse.Parser.<lambda>>}
SCHEMA_UNNAMED_CONSTRAINTS = {'EXCLUDE', 'CHECK', 'LIKE', 'PRIMARY KEY', 'PERIOD', 'INDEX', 'FOREIGN KEY', 'UNIQUE'}
SHOW_TRIE: Dict = {}
SET_TRIE: Dict = {'GLOBAL': {0: True}, 'LOCAL': {0: True}, 'SESSION': {0: True}, 'TRANSACTION': {0: True}}
Inherited Members
sqlglot.parser.Parser
Parser
NO_PAREN_FUNCTIONS
STRUCT_TYPE_TOKENS
NESTED_TYPE_TOKENS
ENUM_TYPE_TOKENS
AGGREGATE_TYPE_TOKENS
TYPE_TOKENS
SIGNED_TO_UNSIGNED_TYPE_TOKEN
SUBQUERY_PREDICATES
DB_CREATABLES
CREATABLES
ALTERABLES
INTERVAL_VARS
ARRAY_CONSTRUCTORS
COMMENT_TABLE_ALIAS_TOKENS
UPDATE_ALIAS_TOKENS
TRIM_TYPES
CONJUNCTION
ASSIGNMENT
DISJUNCTION
EQUALITY
COMPARISON
BITWISE
TERM
FACTOR
EXPONENT
TIMES
TIMESTAMPS
SET_OPERATIONS
JOIN_METHODS
JOIN_SIDES
JOIN_HINTS
LAMBDAS
EXPRESSION_PARSERS
STATEMENT_PARSERS
UNARY_PARSERS
STRING_PARSERS
NUMERIC_PARSERS
PRIMARY_PARSERS
PLACEHOLDER_PARSERS
PROPERTY_PARSERS
ALTER_ALTER_PARSERS
INVALID_FUNC_NAME_TOKENS
KEY_VALUE_DEFINITIONS
SET_PARSERS
SHOW_PARSERS
TYPE_LITERAL_PARSERS
TYPE_CONVERTERS
DDL_SELECT_TOKENS
PRE_VOLATILE_TOKENS
TRANSACTION_KIND
TRANSACTION_CHARACTERISTICS
CONFLICT_ACTIONS
CREATE_SEQUENCE
ISOLATED_LOADING_OPTIONS
USABLES
CAST_ACTIONS
SCHEMA_BINDING_OPTIONS
KEY_CONSTRAINT_OPTIONS
INSERT_ALTERNATIVES
CLONE_KEYWORDS
HISTORICAL_DATA_PREFIX
HISTORICAL_DATA_KIND
OPCLASS_FOLLOW_KEYWORDS
OPTYPE_FOLLOW_TOKENS
TABLE_INDEX_HINT_TOKENS
VIEW_ATTRIBUTES
WINDOW_ALIAS_TOKENS
WINDOW_BEFORE_PAREN_TOKENS
WINDOW_SIDES
JSON_KEY_VALUE_SEPARATOR_TOKENS
FETCH_TOKENS
ADD_CONSTRAINT_TOKENS
DISTINCT_TOKENS
NULL_TOKENS
UNNEST_OFFSET_ALIAS_TOKENS
SELECT_START_TOKENS
COPY_INTO_VARLEN_OPTIONS
STRICT_CAST
PREFIXED_PIVOT_COLUMNS
IDENTIFY_PIVOT_STRINGS
ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN
TABLESAMPLE_CSV
DEFAULT_SAMPLING_METHOD
SET_REQUIRES_ASSIGNMENT_DELIMITER
TRIM_PATTERN_FIRST
STRING_ALIASES
SET_OP_MODIFIERS
NO_PAREN_IF_COMMANDS
JSON_ARROWS_REQUIRE_JSON_TYPE
COLON_IS_VARIANT_EXTRACT
VALUES_FOLLOWED_BY_PAREN
SUPPORTS_IMPLICIT_UNNEST
SUPPORTS_PARTITION_SELECTION
error_level
error_message_context
max_errors
dialect
reset
parse
parse_into
check_errors
raise_error
expression
validate_expression
errors
sql
class ClickHouse.Generator(sqlglot.generator.Generator):
 716    class Generator(generator.Generator):
 717        QUERY_HINTS = False
 718        STRUCT_DELIMITER = ("(", ")")
 719        NVL2_SUPPORTED = False
 720        TABLESAMPLE_REQUIRES_PARENS = False
 721        TABLESAMPLE_SIZE_IS_ROWS = False
 722        TABLESAMPLE_KEYWORDS = "SAMPLE"
 723        LAST_DAY_SUPPORTS_DATE_PART = False
 724        CAN_IMPLEMENT_ARRAY_ANY = True
 725        SUPPORTS_TO_NUMBER = False
 726        JOIN_HINTS = False
 727        TABLE_HINTS = False
 728        EXPLICIT_SET_OP = True
 729        GROUPINGS_SEP = ""
 730        SET_OP_MODIFIERS = False
 731        SUPPORTS_TABLE_ALIAS_COLUMNS = False
 732        VALUES_AS_TABLE = False
 733
 734        STRING_TYPE_MAPPING = {
 735            exp.DataType.Type.CHAR: "String",
 736            exp.DataType.Type.LONGBLOB: "String",
 737            exp.DataType.Type.LONGTEXT: "String",
 738            exp.DataType.Type.MEDIUMBLOB: "String",
 739            exp.DataType.Type.MEDIUMTEXT: "String",
 740            exp.DataType.Type.TINYBLOB: "String",
 741            exp.DataType.Type.TINYTEXT: "String",
 742            exp.DataType.Type.TEXT: "String",
 743            exp.DataType.Type.VARBINARY: "String",
 744            exp.DataType.Type.VARCHAR: "String",
 745        }
 746
 747        SUPPORTED_JSON_PATH_PARTS = {
 748            exp.JSONPathKey,
 749            exp.JSONPathRoot,
 750            exp.JSONPathSubscript,
 751        }
 752
 753        TYPE_MAPPING = {
 754            **generator.Generator.TYPE_MAPPING,
 755            **STRING_TYPE_MAPPING,
 756            exp.DataType.Type.ARRAY: "Array",
 757            exp.DataType.Type.BIGINT: "Int64",
 758            exp.DataType.Type.DATE32: "Date32",
 759            exp.DataType.Type.DATETIME64: "DateTime64",
 760            exp.DataType.Type.DOUBLE: "Float64",
 761            exp.DataType.Type.ENUM: "Enum",
 762            exp.DataType.Type.ENUM8: "Enum8",
 763            exp.DataType.Type.ENUM16: "Enum16",
 764            exp.DataType.Type.FIXEDSTRING: "FixedString",
 765            exp.DataType.Type.FLOAT: "Float32",
 766            exp.DataType.Type.INT: "Int32",
 767            exp.DataType.Type.MEDIUMINT: "Int32",
 768            exp.DataType.Type.INT128: "Int128",
 769            exp.DataType.Type.INT256: "Int256",
 770            exp.DataType.Type.LOWCARDINALITY: "LowCardinality",
 771            exp.DataType.Type.MAP: "Map",
 772            exp.DataType.Type.NESTED: "Nested",
 773            exp.DataType.Type.NULLABLE: "Nullable",
 774            exp.DataType.Type.SMALLINT: "Int16",
 775            exp.DataType.Type.STRUCT: "Tuple",
 776            exp.DataType.Type.TINYINT: "Int8",
 777            exp.DataType.Type.UBIGINT: "UInt64",
 778            exp.DataType.Type.UINT: "UInt32",
 779            exp.DataType.Type.UINT128: "UInt128",
 780            exp.DataType.Type.UINT256: "UInt256",
 781            exp.DataType.Type.USMALLINT: "UInt16",
 782            exp.DataType.Type.UTINYINT: "UInt8",
 783            exp.DataType.Type.IPV4: "IPv4",
 784            exp.DataType.Type.IPV6: "IPv6",
 785            exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction",
 786            exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction",
 787        }
 788
 789        TRANSFORMS = {
 790            **generator.Generator.TRANSFORMS,
 791            exp.AnyValue: rename_func("any"),
 792            exp.ApproxDistinct: rename_func("uniq"),
 793            exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this),
 794            exp.ArraySize: rename_func("LENGTH"),
 795            exp.ArraySum: rename_func("arraySum"),
 796            exp.ArgMax: arg_max_or_min_no_count("argMax"),
 797            exp.ArgMin: arg_max_or_min_no_count("argMin"),
 798            exp.Array: inline_array_sql,
 799            exp.CastToStrType: rename_func("CAST"),
 800            exp.CountIf: rename_func("countIf"),
 801            exp.CompressColumnConstraint: lambda self,
 802            e: f"CODEC({self.expressions(e, key='this', flat=True)})",
 803            exp.ComputedColumnConstraint: lambda self,
 804            e: f"{'MATERIALIZED' if e.args.get('persisted') else 'ALIAS'} {self.sql(e, 'this')}",
 805            exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"),
 806            exp.DateAdd: _datetime_delta_sql("DATE_ADD"),
 807            exp.DateDiff: _datetime_delta_sql("DATE_DIFF"),
 808            exp.DateStrToDate: rename_func("toDate"),
 809            exp.DateSub: _datetime_delta_sql("DATE_SUB"),
 810            exp.Explode: rename_func("arrayJoin"),
 811            exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL",
 812            exp.IsNan: rename_func("isNaN"),
 813            exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False),
 814            exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False),
 815            exp.JSONPathKey: json_path_key_only_name,
 816            exp.JSONPathRoot: lambda *_: "",
 817            exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)),
 818            exp.Nullif: rename_func("nullIf"),
 819            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
 820            exp.Pivot: no_pivot_sql,
 821            exp.Quantile: _quantile_sql,
 822            exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression),
 823            exp.Rand: rename_func("randCanonical"),
 824            exp.StartsWith: rename_func("startsWith"),
 825            exp.StrPosition: lambda self, e: self.func(
 826                "position", e.this, e.args.get("substr"), e.args.get("position")
 827            ),
 828            exp.TimeToStr: lambda self, e: self.func(
 829                "DATE_FORMAT", e.this, self.format_time(e), e.args.get("timezone")
 830            ),
 831            exp.TimestampAdd: _datetime_delta_sql("TIMESTAMP_ADD"),
 832            exp.TimestampSub: _datetime_delta_sql("TIMESTAMP_SUB"),
 833            exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)),
 834            exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions),
 835            exp.MD5Digest: rename_func("MD5"),
 836            exp.MD5: lambda self, e: self.func("LOWER", self.func("HEX", self.func("MD5", e.this))),
 837            exp.SHA: rename_func("SHA1"),
 838            exp.SHA2: sha256_sql,
 839            exp.UnixToTime: _unix_to_time_sql,
 840            exp.TimestampTrunc: timestamptrunc_sql(zone=True),
 841            exp.Variance: rename_func("varSamp"),
 842            exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
 843            exp.Stddev: rename_func("stddevSamp"),
 844        }
 845
 846        PROPERTIES_LOCATION = {
 847            **generator.Generator.PROPERTIES_LOCATION,
 848            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
 849            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
 850            exp.OnCluster: exp.Properties.Location.POST_NAME,
 851        }
 852
 853        # there's no list in docs, but it can be found in Clickhouse code
 854        # see `ClickHouse/src/Parsers/ParserCreate*.cpp`
 855        ON_CLUSTER_TARGETS = {
 856            "DATABASE",
 857            "TABLE",
 858            "VIEW",
 859            "DICTIONARY",
 860            "INDEX",
 861            "FUNCTION",
 862            "NAMED COLLECTION",
 863        }
 864
 865        # https://github.com/ClickHouse/ClickHouse/blob/275de04b8f6bb8c9334bf8070001afe2dab0b17d/src/Functions/FunctionsConversion.cpp#L2939-L2989
 866        TRY_CAST_TYPES = {
 867            "DATE",
 868            "DATE32",
 869            "DATETIME",
 870            "DATETIME64",
 871            "DECIMAL32",
 872            "DECIMAL64",
 873            "DECIMAL128",
 874            "DECIMAL256",
 875            "FLOAT32",
 876            "FLOAT64",
 877            "INT8",
 878            "INT16",
 879            "INT32",
 880            "INT64",
 881            "INT128",
 882            "INT256",
 883            "IPV4",
 884            "IPV6",
 885            "UINT8",
 886            "UINT16",
 887            "UINT32",
 888            "UINT64",
 889            "UINT128",
 890            "UINT256",
 891            "UUID",
 892        }
 893
 894        def strtodate_sql(self, expression: exp.StrToDate) -> str:
 895            strtodate_sql = self.function_fallback_sql(expression)
 896
 897            if not isinstance(expression.parent, exp.Cast):
 898                # StrToDate returns DATEs in other dialects (eg. postgres), so
 899                # this branch aims to improve the transpilation to clickhouse
 900                return f"CAST({strtodate_sql} AS DATE)"
 901
 902            return strtodate_sql
 903
 904        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
 905            this = expression.this
 906
 907            if isinstance(this, exp.StrToDate) and expression.to == exp.DataType.build("datetime"):
 908                return self.sql(this)
 909
 910            return super().cast_sql(expression, safe_prefix=safe_prefix)
 911
 912        def trycast_sql(self, expression: exp.TryCast) -> str:
 913            target_type = self.sql(expression.to)
 914            if target_type.upper() in self.TRY_CAST_TYPES:
 915                return self.func(f"to{target_type}OrNull", expression.this)
 916
 917            self.unsupported(f"There is no `to<Type>OrNull` for type {target_type}.")
 918            return super().cast_sql(expression)
 919
 920        def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str:
 921            this = self.json_path_part(expression.this)
 922            return str(int(this) + 1) if is_int(this) else this
 923
 924        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
 925            return f"AS {self.sql(expression, 'this')}"
 926
 927        def _any_to_has(
 928            self,
 929            expression: exp.EQ | exp.NEQ,
 930            default: t.Callable[[t.Any], str],
 931            prefix: str = "",
 932        ) -> str:
 933            if isinstance(expression.left, exp.Any):
 934                arr = expression.left
 935                this = expression.right
 936            elif isinstance(expression.right, exp.Any):
 937                arr = expression.right
 938                this = expression.left
 939            else:
 940                return default(expression)
 941
 942            return prefix + self.func("has", arr.this.unnest(), this)
 943
 944        def eq_sql(self, expression: exp.EQ) -> str:
 945            return self._any_to_has(expression, super().eq_sql)
 946
 947        def neq_sql(self, expression: exp.NEQ) -> str:
 948            return self._any_to_has(expression, super().neq_sql, "NOT ")
 949
 950        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
 951            # Manually add a flag to make the search case-insensitive
 952            regex = self.func("CONCAT", "'(?i)'", expression.expression)
 953            return self.func("match", expression.this, regex)
 954
 955        def datatype_sql(self, expression: exp.DataType) -> str:
 956            # String is the standard ClickHouse type, every other variant is just an alias.
 957            # Additionally, any supplied length parameter will be ignored.
 958            #
 959            # https://clickhouse.com/docs/en/sql-reference/data-types/string
 960            if expression.this in self.STRING_TYPE_MAPPING:
 961                return "String"
 962
 963            return super().datatype_sql(expression)
 964
 965        def cte_sql(self, expression: exp.CTE) -> str:
 966            if expression.args.get("scalar"):
 967                this = self.sql(expression, "this")
 968                alias = self.sql(expression, "alias")
 969                return f"{this} AS {alias}"
 970
 971            return super().cte_sql(expression)
 972
 973        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
 974            return super().after_limit_modifiers(expression) + [
 975                (
 976                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
 977                    if expression.args.get("settings")
 978                    else ""
 979                ),
 980                (
 981                    self.seg("FORMAT ") + self.sql(expression, "format")
 982                    if expression.args.get("format")
 983                    else ""
 984                ),
 985            ]
 986
 987        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
 988            params = self.expressions(expression, key="params", flat=True)
 989            return self.func(expression.name, *expression.expressions) + f"({params})"
 990
 991        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
 992            return self.func(expression.name, *expression.expressions)
 993
 994        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
 995            return self.anonymousaggfunc_sql(expression)
 996
 997        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
 998            return self.parameterizedagg_sql(expression)
 999
1000        def placeholder_sql(self, expression: exp.Placeholder) -> str:
1001            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
1002
1003        def oncluster_sql(self, expression: exp.OnCluster) -> str:
1004            return f"ON CLUSTER {self.sql(expression, 'this')}"
1005
1006        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
1007            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
1008                exp.Properties.Location.POST_NAME
1009            ):
1010                this_name = self.sql(
1011                    expression.this if isinstance(expression.this, exp.Schema) else expression,
1012                    "this",
1013                )
1014                this_properties = " ".join(
1015                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
1016                )
1017                this_schema = self.schema_columns_sql(expression.this)
1018                return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}"
1019
1020            return super().createable_sql(expression, locations)
1021
1022        def create_sql(self, expression: exp.Create) -> str:
1023            # The comment property comes last in CTAS statements, i.e. after the query
1024            query = expression.expression
1025            if isinstance(query, exp.Query):
1026                comment_prop = expression.find(exp.SchemaCommentProperty)
1027                if comment_prop:
1028                    comment_prop.pop()
1029                    query.replace(exp.paren(query))
1030            else:
1031                comment_prop = None
1032
1033            # ClickHouse only has DATABASEs and objects under them, eg. TABLEs, VIEWs, etc
1034            if expression.kind == "SCHEMA":
1035                expression.set("kind", "DATABASE")
1036
1037            create_sql = super().create_sql(expression)
1038
1039            comment_sql = self.sql(comment_prop)
1040            comment_sql = f" {comment_sql}" if comment_sql else ""
1041
1042            return f"{create_sql}{comment_sql}"
1043
1044        def prewhere_sql(self, expression: exp.PreWhere) -> str:
1045            this = self.indent(self.sql(expression, "this"))
1046            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
1047
1048        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
1049            this = self.sql(expression, "this")
1050            this = f" {this}" if this else ""
1051            expr = self.sql(expression, "expression")
1052            expr = f" {expr}" if expr else ""
1053            index_type = self.sql(expression, "index_type")
1054            index_type = f" TYPE {index_type}" if index_type else ""
1055            granularity = self.sql(expression, "granularity")
1056            granularity = f" GRANULARITY {granularity}" if granularity else ""
1057
1058            return f"INDEX{this}{expr}{index_type}{granularity}"
1059
1060        def partition_sql(self, expression: exp.Partition) -> str:
1061            return f"PARTITION {self.expressions(expression, flat=True)}"
1062
1063        def partitionid_sql(self, expression: exp.PartitionId) -> str:
1064            return f"ID {self.sql(expression.this)}"
1065
1066        def replacepartition_sql(self, expression: exp.ReplacePartition) -> str:
1067            return (
1068                f"REPLACE {self.sql(expression.expression)} FROM {self.sql(expression, 'source')}"
1069            )
1070
1071        def projectiondef_sql(self, expression: exp.ProjectionDef) -> str:
1072            return f"PROJECTION {self.sql(expression.this)} {self.wrap(expression.expression)}"

Generator converts a given syntax tree to the corresponding SQL string.

Arguments:
  • pretty: Whether to format the produced SQL string. Default: False.
  • identify: Determines when an identifier should be quoted. Possible values are: False (default): Never quote, except in cases where it's mandatory by the dialect. True or 'always': Always quote. 'safe': Only quote identifiers that are case insensitive.
  • normalize: Whether to normalize identifiers to lowercase. Default: False.
  • pad: The pad size in a formatted string. For example, this affects the indentation of a projection in a query, relative to its nesting level. Default: 2.
  • indent: The indentation size in a formatted string. For example, this affects the indentation of subqueries and filters under a WHERE clause. Default: 2.
  • normalize_functions: How to normalize function names. Possible values are: "upper" or True (default): Convert names to uppercase. "lower": Convert names to lowercase. False: Disables function name normalization.
  • unsupported_level: Determines the generator's behavior when it encounters unsupported expressions. Default ErrorLevel.WARN.
  • max_unsupported: Maximum number of unsupported messages to include in a raised UnsupportedError. This is only relevant if unsupported_level is ErrorLevel.RAISE. Default: 3
  • leading_comma: Whether the comma is leading or trailing in select expressions. This is only relevant when generating in pretty mode. Default: False
  • max_text_width: The max number of characters in a segment before creating new lines in pretty mode. The default is on the smaller end because the length only represents a segment and not the true line length. Default: 80
  • comments: Whether to preserve comments in the output SQL code. Default: True
QUERY_HINTS = False
STRUCT_DELIMITER = ('(', ')')
NVL2_SUPPORTED = False
TABLESAMPLE_REQUIRES_PARENS = False
TABLESAMPLE_SIZE_IS_ROWS = False
TABLESAMPLE_KEYWORDS = 'SAMPLE'
LAST_DAY_SUPPORTS_DATE_PART = False
CAN_IMPLEMENT_ARRAY_ANY = True
SUPPORTS_TO_NUMBER = False
JOIN_HINTS = False
TABLE_HINTS = False
EXPLICIT_SET_OP = True
GROUPINGS_SEP = ''
SET_OP_MODIFIERS = False
SUPPORTS_TABLE_ALIAS_COLUMNS = False
VALUES_AS_TABLE = False
STRING_TYPE_MAPPING = {<Type.CHAR: 'CHAR'>: 'String', <Type.LONGBLOB: 'LONGBLOB'>: 'String', <Type.LONGTEXT: 'LONGTEXT'>: 'String', <Type.MEDIUMBLOB: 'MEDIUMBLOB'>: 'String', <Type.MEDIUMTEXT: 'MEDIUMTEXT'>: 'String', <Type.TINYBLOB: 'TINYBLOB'>: 'String', <Type.TINYTEXT: 'TINYTEXT'>: 'String', <Type.TEXT: 'TEXT'>: 'String', <Type.VARBINARY: 'VARBINARY'>: 'String', <Type.VARCHAR: 'VARCHAR'>: 'String'}
TYPE_MAPPING = {<Type.NCHAR: 'NCHAR'>: 'CHAR', <Type.NVARCHAR: 'NVARCHAR'>: 'VARCHAR', <Type.MEDIUMTEXT: 'MEDIUMTEXT'>: 'String', <Type.LONGTEXT: 'LONGTEXT'>: 'String', <Type.TINYTEXT: 'TINYTEXT'>: 'String', <Type.MEDIUMBLOB: 'MEDIUMBLOB'>: 'String', <Type.LONGBLOB: 'LONGBLOB'>: 'String', <Type.TINYBLOB: 'TINYBLOB'>: 'String', <Type.INET: 'INET'>: 'INET', <Type.ROWVERSION: 'ROWVERSION'>: 'VARBINARY', <Type.CHAR: 'CHAR'>: 'String', <Type.TEXT: 'TEXT'>: 'String', <Type.VARBINARY: 'VARBINARY'>: 'String', <Type.VARCHAR: 'VARCHAR'>: 'String', <Type.ARRAY: 'ARRAY'>: 'Array', <Type.BIGINT: 'BIGINT'>: 'Int64', <Type.DATE32: 'DATE32'>: 'Date32', <Type.DATETIME64: 'DATETIME64'>: 'DateTime64', <Type.DOUBLE: 'DOUBLE'>: 'Float64', <Type.ENUM: 'ENUM'>: 'Enum', <Type.ENUM8: 'ENUM8'>: 'Enum8', <Type.ENUM16: 'ENUM16'>: 'Enum16', <Type.FIXEDSTRING: 'FIXEDSTRING'>: 'FixedString', <Type.FLOAT: 'FLOAT'>: 'Float32', <Type.INT: 'INT'>: 'Int32', <Type.MEDIUMINT: 'MEDIUMINT'>: 'Int32', <Type.INT128: 'INT128'>: 'Int128', <Type.INT256: 'INT256'>: 'Int256', <Type.LOWCARDINALITY: 'LOWCARDINALITY'>: 'LowCardinality', <Type.MAP: 'MAP'>: 'Map', <Type.NESTED: 'NESTED'>: 'Nested', <Type.NULLABLE: 'NULLABLE'>: 'Nullable', <Type.SMALLINT: 'SMALLINT'>: 'Int16', <Type.STRUCT: 'STRUCT'>: 'Tuple', <Type.TINYINT: 'TINYINT'>: 'Int8', <Type.UBIGINT: 'UBIGINT'>: 'UInt64', <Type.UINT: 'UINT'>: 'UInt32', <Type.UINT128: 'UINT128'>: 'UInt128', <Type.UINT256: 'UINT256'>: 'UInt256', <Type.USMALLINT: 'USMALLINT'>: 'UInt16', <Type.UTINYINT: 'UTINYINT'>: 'UInt8', <Type.IPV4: 'IPV4'>: 'IPv4', <Type.IPV6: 'IPV6'>: 'IPv6', <Type.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>: 'AggregateFunction', <Type.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>: 'SimpleAggregateFunction'}
TRANSFORMS = {<class 'sqlglot.expressions.JSONPathKey'>: <function json_path_key_only_name>, <class 'sqlglot.expressions.JSONPathRoot'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.JSONPathSubscript'>: <function <lambda>>, <class 'sqlglot.expressions.AllowedValuesProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.AutoRefreshProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.BackupProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CaseSpecificColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ClusteredColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CollateColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CommentColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ConnectByRoot'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CopyGrantsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DateFormatColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DefaultColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DynamicProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EmptyProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EncodeColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EphemeralColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExcludeColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExecuteAsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExternalProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.GlobalProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.HeapProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.IcebergProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InheritsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InlineLengthColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.IntervalSpan'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LanguageProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LocationProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LogProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.MaterializedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NonClusteredColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NoPrimaryIndexProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NotForReplicationColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnCommitProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnUpdateColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OutputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.PathColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.PivotAny'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ProjectionPolicyColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.RemoteWithConnectionModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ReturnsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SampleProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SecureProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SetConfigProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SetProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SettingsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SharingProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SqlReadWriteProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SqlSecurityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StabilityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Stream'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StreamingTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StrictProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TemporaryProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TagColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TitleColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ToMap'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ToTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransformModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransientProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UppercaseColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UnloggedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VarMap'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.ViewAttributeProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VolatileProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithJournalTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithSchemaBindingProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithOperator'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.AnyValue'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ApproxDistinct'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ArrayFilter'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.ArraySize'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ArraySum'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ArgMax'>: <function arg_max_or_min_no_count.<locals>._arg_max_or_min_sql>, <class 'sqlglot.expressions.ArgMin'>: <function arg_max_or_min_no_count.<locals>._arg_max_or_min_sql>, <class 'sqlglot.expressions.Array'>: <function inline_array_sql>, <class 'sqlglot.expressions.CastToStrType'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.CountIf'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.CompressColumnConstraint'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.ComputedColumnConstraint'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.CurrentDate'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.DateAdd'>: <function _datetime_delta_sql.<locals>._delta_sql>, <class 'sqlglot.expressions.DateDiff'>: <function _datetime_delta_sql.<locals>._delta_sql>, <class 'sqlglot.expressions.DateStrToDate'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.DateSub'>: <function _datetime_delta_sql.<locals>._delta_sql>, <class 'sqlglot.expressions.Explode'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Final'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.IsNan'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.JSONExtract'>: <function json_extract_segments.<locals>._json_extract_segments>, <class 'sqlglot.expressions.JSONExtractScalar'>: <function json_extract_segments.<locals>._json_extract_segments>, <class 'sqlglot.expressions.Map'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.Nullif'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.PartitionedByProperty'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.Pivot'>: <function no_pivot_sql>, <class 'sqlglot.expressions.Quantile'>: <function _quantile_sql>, <class 'sqlglot.expressions.RegexpLike'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.Rand'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.StartsWith'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.StrPosition'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.TimeToStr'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.TimestampAdd'>: <function _datetime_delta_sql.<locals>._delta_sql>, <class 'sqlglot.expressions.TimestampSub'>: <function _datetime_delta_sql.<locals>._delta_sql>, <class 'sqlglot.expressions.Xor'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.MD5Digest'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.MD5'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.SHA'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.SHA2'>: <function sha256_sql>, <class 'sqlglot.expressions.UnixToTime'>: <function _unix_to_time_sql>, <class 'sqlglot.expressions.TimestampTrunc'>: <function timestamptrunc_sql.<locals>._timestamptrunc_sql>, <class 'sqlglot.expressions.Variance'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.SchemaCommentProperty'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.Stddev'>: <function rename_func.<locals>.<lambda>>}
PROPERTIES_LOCATION = {<class 'sqlglot.expressions.AllowedValuesProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.AlgorithmProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.AutoIncrementProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.AutoRefreshProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.BackupProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.BlockCompressionProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.CharacterSetProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ChecksumProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.CollateProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.CopyGrantsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Cluster'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ClusteredByProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DataBlocksizeProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.DataDeletionProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DefinerProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.DictRange'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DictProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DynamicProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.DistKeyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DistStyleProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.EmptyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.EngineProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ExecuteAsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ExternalProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.FallbackProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.FileFormatProperty'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.FreespaceProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.GlobalProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.HeapProperty'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.InheritsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.IcebergProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.InputModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.IsolatedLoadingProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.JournalProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.LanguageProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LikeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LocationProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LockProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LockingProperty'>: <Location.POST_ALIAS: 'POST_ALIAS'>, <class 'sqlglot.expressions.LogProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.MaterializedProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.MergeBlockRatioProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.NoPrimaryIndexProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.OnProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.OnCommitProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.Order'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.OutputModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PartitionedByProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PartitionedOfProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PrimaryKey'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Property'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.RemoteWithConnectionModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ReturnsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatDelimitedProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatSerdeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SampleProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SchemaCommentProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SecureProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.SerdeProperties'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Set'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SettingsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SetProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.SetConfigProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SharingProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.SequenceProperties'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.SortKeyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SqlReadWriteProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SqlSecurityProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.StabilityProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.StreamingTableProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.StrictProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.TemporaryProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.ToTableProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.TransientProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.TransformModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.MergeTreeTTL'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.UnloggedProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.ViewAttributeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.VolatileProperty'>: <Location.UNSUPPORTED: 'UNSUPPORTED'>, <class 'sqlglot.expressions.WithDataProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.WithJournalTableProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.WithSchemaBindingProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.WithSystemVersioningProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.OnCluster'>: <Location.POST_NAME: 'POST_NAME'>}
ON_CLUSTER_TARGETS = {'INDEX', 'TABLE', 'DATABASE', 'DICTIONARY', 'VIEW', 'NAMED COLLECTION', 'FUNCTION'}
TRY_CAST_TYPES = {'IPV4', 'INT16', 'UINT8', 'FLOAT32', 'DECIMAL32', 'UINT64', 'UUID', 'INT128', 'DECIMAL256', 'UINT32', 'INT64', 'INT256', 'DATETIME64', 'DATE32', 'UINT128', 'DATE', 'DECIMAL64', 'FLOAT64', 'DATETIME', 'IPV6', 'UINT16', 'INT32', 'DECIMAL128', 'UINT256', 'INT8'}
def strtodate_sql(self, expression: sqlglot.expressions.StrToDate) -> str:
894        def strtodate_sql(self, expression: exp.StrToDate) -> str:
895            strtodate_sql = self.function_fallback_sql(expression)
896
897            if not isinstance(expression.parent, exp.Cast):
898                # StrToDate returns DATEs in other dialects (eg. postgres), so
899                # this branch aims to improve the transpilation to clickhouse
900                return f"CAST({strtodate_sql} AS DATE)"
901
902            return strtodate_sql
def cast_sql( self, expression: sqlglot.expressions.Cast, safe_prefix: Optional[str] = None) -> str:
904        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
905            this = expression.this
906
907            if isinstance(this, exp.StrToDate) and expression.to == exp.DataType.build("datetime"):
908                return self.sql(this)
909
910            return super().cast_sql(expression, safe_prefix=safe_prefix)
def trycast_sql(self, expression: sqlglot.expressions.TryCast) -> str:
912        def trycast_sql(self, expression: exp.TryCast) -> str:
913            target_type = self.sql(expression.to)
914            if target_type.upper() in self.TRY_CAST_TYPES:
915                return self.func(f"to{target_type}OrNull", expression.this)
916
917            self.unsupported(f"There is no `to<Type>OrNull` for type {target_type}.")
918            return super().cast_sql(expression)
def likeproperty_sql(self, expression: sqlglot.expressions.LikeProperty) -> str:
924        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
925            return f"AS {self.sql(expression, 'this')}"
def eq_sql(self, expression: sqlglot.expressions.EQ) -> str:
944        def eq_sql(self, expression: exp.EQ) -> str:
945            return self._any_to_has(expression, super().eq_sql)
def neq_sql(self, expression: sqlglot.expressions.NEQ) -> str:
947        def neq_sql(self, expression: exp.NEQ) -> str:
948            return self._any_to_has(expression, super().neq_sql, "NOT ")
def regexpilike_sql(self, expression: sqlglot.expressions.RegexpILike) -> str:
950        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
951            # Manually add a flag to make the search case-insensitive
952            regex = self.func("CONCAT", "'(?i)'", expression.expression)
953            return self.func("match", expression.this, regex)
def datatype_sql(self, expression: sqlglot.expressions.DataType) -> str:
955        def datatype_sql(self, expression: exp.DataType) -> str:
956            # String is the standard ClickHouse type, every other variant is just an alias.
957            # Additionally, any supplied length parameter will be ignored.
958            #
959            # https://clickhouse.com/docs/en/sql-reference/data-types/string
960            if expression.this in self.STRING_TYPE_MAPPING:
961                return "String"
962
963            return super().datatype_sql(expression)
def cte_sql(self, expression: sqlglot.expressions.CTE) -> str:
965        def cte_sql(self, expression: exp.CTE) -> str:
966            if expression.args.get("scalar"):
967                this = self.sql(expression, "this")
968                alias = self.sql(expression, "alias")
969                return f"{this} AS {alias}"
970
971            return super().cte_sql(expression)
def after_limit_modifiers(self, expression: sqlglot.expressions.Expression) -> List[str]:
973        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
974            return super().after_limit_modifiers(expression) + [
975                (
976                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
977                    if expression.args.get("settings")
978                    else ""
979                ),
980                (
981                    self.seg("FORMAT ") + self.sql(expression, "format")
982                    if expression.args.get("format")
983                    else ""
984                ),
985            ]
def parameterizedagg_sql(self, expression: sqlglot.expressions.ParameterizedAgg) -> str:
987        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
988            params = self.expressions(expression, key="params", flat=True)
989            return self.func(expression.name, *expression.expressions) + f"({params})"
def anonymousaggfunc_sql(self, expression: sqlglot.expressions.AnonymousAggFunc) -> str:
991        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
992            return self.func(expression.name, *expression.expressions)
def combinedaggfunc_sql(self, expression: sqlglot.expressions.CombinedAggFunc) -> str:
994        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
995            return self.anonymousaggfunc_sql(expression)
def combinedparameterizedagg_sql(self, expression: sqlglot.expressions.CombinedParameterizedAgg) -> str:
997        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
998            return self.parameterizedagg_sql(expression)
def placeholder_sql(self, expression: sqlglot.expressions.Placeholder) -> str:
1000        def placeholder_sql(self, expression: exp.Placeholder) -> str:
1001            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
def oncluster_sql(self, expression: sqlglot.expressions.OnCluster) -> str:
1003        def oncluster_sql(self, expression: exp.OnCluster) -> str:
1004            return f"ON CLUSTER {self.sql(expression, 'this')}"
def createable_sql( self, expression: sqlglot.expressions.Create, locations: DefaultDict) -> str:
1006        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
1007            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
1008                exp.Properties.Location.POST_NAME
1009            ):
1010                this_name = self.sql(
1011                    expression.this if isinstance(expression.this, exp.Schema) else expression,
1012                    "this",
1013                )
1014                this_properties = " ".join(
1015                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
1016                )
1017                this_schema = self.schema_columns_sql(expression.this)
1018                return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}"
1019
1020            return super().createable_sql(expression, locations)
def create_sql(self, expression: sqlglot.expressions.Create) -> str:
1022        def create_sql(self, expression: exp.Create) -> str:
1023            # The comment property comes last in CTAS statements, i.e. after the query
1024            query = expression.expression
1025            if isinstance(query, exp.Query):
1026                comment_prop = expression.find(exp.SchemaCommentProperty)
1027                if comment_prop:
1028                    comment_prop.pop()
1029                    query.replace(exp.paren(query))
1030            else:
1031                comment_prop = None
1032
1033            # ClickHouse only has DATABASEs and objects under them, eg. TABLEs, VIEWs, etc
1034            if expression.kind == "SCHEMA":
1035                expression.set("kind", "DATABASE")
1036
1037            create_sql = super().create_sql(expression)
1038
1039            comment_sql = self.sql(comment_prop)
1040            comment_sql = f" {comment_sql}" if comment_sql else ""
1041
1042            return f"{create_sql}{comment_sql}"
def prewhere_sql(self, expression: sqlglot.expressions.PreWhere) -> str:
1044        def prewhere_sql(self, expression: exp.PreWhere) -> str:
1045            this = self.indent(self.sql(expression, "this"))
1046            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
def indexcolumnconstraint_sql(self, expression: sqlglot.expressions.IndexColumnConstraint) -> str:
1048        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
1049            this = self.sql(expression, "this")
1050            this = f" {this}" if this else ""
1051            expr = self.sql(expression, "expression")
1052            expr = f" {expr}" if expr else ""
1053            index_type = self.sql(expression, "index_type")
1054            index_type = f" TYPE {index_type}" if index_type else ""
1055            granularity = self.sql(expression, "granularity")
1056            granularity = f" GRANULARITY {granularity}" if granularity else ""
1057
1058            return f"INDEX{this}{expr}{index_type}{granularity}"
def partition_sql(self, expression: sqlglot.expressions.Partition) -> str:
1060        def partition_sql(self, expression: exp.Partition) -> str:
1061            return f"PARTITION {self.expressions(expression, flat=True)}"
def partitionid_sql(self, expression: sqlglot.expressions.PartitionId) -> str:
1063        def partitionid_sql(self, expression: exp.PartitionId) -> str:
1064            return f"ID {self.sql(expression.this)}"
def replacepartition_sql(self, expression: sqlglot.expressions.ReplacePartition) -> str:
1066        def replacepartition_sql(self, expression: exp.ReplacePartition) -> str:
1067            return (
1068                f"REPLACE {self.sql(expression.expression)} FROM {self.sql(expression, 'source')}"
1069            )
def projectiondef_sql(self, expression: sqlglot.expressions.ProjectionDef) -> str:
1071        def projectiondef_sql(self, expression: exp.ProjectionDef) -> str:
1072            return f"PROJECTION {self.sql(expression.this)} {self.wrap(expression.expression)}"
SELECT_KINDS: Tuple[str, ...] = ()
TRY_SUPPORTED = False
SUPPORTS_UESCAPE = False
AFTER_HAVING_MODIFIER_TRANSFORMS = {'windows': <function Generator.<lambda>>, 'qualify': <function Generator.<lambda>>}
Inherited Members
sqlglot.generator.Generator
Generator
NULL_ORDERING_SUPPORTED
IGNORE_NULLS_IN_FUNC
LOCKING_READS_SUPPORTED
WRAP_DERIVED_VALUES
CREATE_FUNCTION_RETURN_AS
MATCHED_BY_SOURCE
SINGLE_STRING_INTERVAL
INTERVAL_ALLOWS_PLURAL_FORM
LIMIT_FETCH
LIMIT_ONLY_LITERALS
RENAME_TABLE_WITH_DB
INDEX_ON
QUERY_HINT_SEP
IS_BOOL_ALLOWED
DUPLICATE_KEY_UPDATE_WITH_SET
LIMIT_IS_TOP
RETURNING_END
EXTRACT_ALLOWS_QUOTES
TZ_TO_WITH_TIME_ZONE
ALTER_TABLE_INCLUDE_COLUMN_KEYWORD
UNNEST_WITH_ORDINALITY
AGGREGATE_FILTER_SUPPORTED
SEMI_ANTI_JOIN_WITH_SIDE
COMPUTED_COLUMN_WITH_TYPE
SUPPORTS_TABLE_COPY
TABLESAMPLE_WITH_METHOD
TABLESAMPLE_SEED_KEYWORD
COLLATE_IS_FUNC
DATA_TYPE_SPECIFIERS_ALLOWED
ENSURE_BOOLS
CTE_RECURSIVE_KEYWORD_REQUIRED
SUPPORTS_SINGLE_ARG_CONCAT
UNPIVOT_ALIASES_ARE_IDENTIFIERS
JSON_KEY_VALUE_PAIR_SEP
INSERT_OVERWRITE
SUPPORTS_SELECT_INTO
SUPPORTS_UNLOGGED_TABLES
SUPPORTS_CREATE_TABLE_LIKE
LIKE_PROPERTY_INSIDE_SCHEMA
MULTI_ARG_DISTINCT
JSON_TYPE_REQUIRED_FOR_EXTRACTION
JSON_PATH_BRACKETED_KEY_SUPPORTED
JSON_PATH_SINGLE_QUOTE_ESCAPE
COPY_PARAMS_ARE_WRAPPED
COPY_PARAMS_EQ_REQUIRED
COPY_HAS_INTO_KEYWORD
STAR_EXCEPT
HEX_FUNC
WITH_PROPERTIES_PREFIX
QUOTE_JSON_PATH
PAD_FILL_PATTERN_IS_REQUIRED
SUPPORTS_EXPLODING_PROJECTIONS
ARRAY_CONCAT_IS_VAR_LEN
SUPPORTS_CONVERT_TIMEZONE
PARSE_JSON_NAME
TIME_PART_SINGULARS
TOKEN_MAPPING
PARAMETER_TOKEN
NAMED_PLACEHOLDER_TOKEN
RESERVED_KEYWORDS
WITH_SEPARATED_COMMENTS
EXCLUDE_COMMENTS
UNWRAPPED_INTERVAL_VALUES
PARAMETERIZABLE_TEXT_TYPES
EXPRESSIONS_WITHOUT_NESTED_CTES
SENTINEL_LINE_BREAK
pretty
identify
normalize
pad
unsupported_level
max_unsupported
leading_comma
max_text_width
comments
dialect
normalize_functions
unsupported_messages
generate
preprocess
unsupported
sep
seg
pad_comment
maybe_comment
wrap
no_identify
normalize_func
indent
sql
uncache_sql
cache_sql
characterset_sql
column_parts
column_sql
columnposition_sql
columndef_sql
columnconstraint_sql
computedcolumnconstraint_sql
autoincrementcolumnconstraint_sql
compresscolumnconstraint_sql
generatedasidentitycolumnconstraint_sql
generatedasrowcolumnconstraint_sql
periodforsystemtimeconstraint_sql
notnullcolumnconstraint_sql
transformcolumnconstraint_sql
primarykeycolumnconstraint_sql
uniquecolumnconstraint_sql
sequenceproperties_sql
clone_sql
describe_sql
heredoc_sql
prepend_ctes
with_sql
tablealias_sql
bitstring_sql
hexstring_sql
bytestring_sql
unicodestring_sql
rawstring_sql
datatypeparam_sql
directory_sql
delete_sql
drop_sql
except_sql
except_op
fetch_sql
filter_sql
hint_sql
indexparameters_sql
index_sql
identifier_sql
hex_sql
lowerhex_sql
inputoutputformat_sql
national_sql
properties_sql
root_properties
properties
with_properties
locate_properties
property_name
property_sql
fallbackproperty_sql
journalproperty_sql
freespaceproperty_sql
checksumproperty_sql
mergeblockratioproperty_sql
datablocksizeproperty_sql
blockcompressionproperty_sql
isolatedloadingproperty_sql
partitionboundspec_sql
partitionedofproperty_sql
lockingproperty_sql
withdataproperty_sql
withsystemversioningproperty_sql
insert_sql
intersect_sql
intersect_op
introducer_sql
kill_sql
pseudotype_sql
objectidentifier_sql
onconflict_sql
returning_sql
rowformatdelimitedproperty_sql
withtablehint_sql
indextablehint_sql
historicaldata_sql
table_parts
table_sql
tablesample_sql
pivot_sql
version_sql
tuple_sql
update_sql
values_sql
var_sql
into_sql
from_sql
group_sql
having_sql
connect_sql
prior_sql
join_sql
lambda_sql
lateral_op
lateral_sql
limit_sql
offset_sql
setitem_sql
set_sql
pragma_sql
lock_sql
literal_sql
escape_str
loaddata_sql
null_sql
boolean_sql
order_sql
withfill_sql
cluster_sql
distribute_sql
sort_sql
ordered_sql
matchrecognizemeasure_sql
matchrecognize_sql
query_modifiers
options_modifier
queryoption_sql
offset_limit_modifiers
select_sql
schema_sql
schema_columns_sql
star_sql
parameter_sql
sessionparameter_sql
subquery_sql
qualify_sql
set_operations
union_sql
union_op
unnest_sql
where_sql
window_sql
partition_by_sql
windowspec_sql
withingroup_sql
between_sql
bracket_offset_expressions
bracket_sql
all_sql
any_sql
exists_sql
case_sql
constraint_sql
nextvaluefor_sql
extract_sql
trim_sql
convert_concat_args
concat_sql
concatws_sql
check_sql
foreignkey_sql
primarykey_sql
if_sql
matchagainst_sql
jsonkeyvalue_sql
jsonpath_sql
json_path_part
formatjson_sql
jsonobject_sql
jsonobjectagg_sql
jsonarray_sql
jsonarrayagg_sql
jsoncolumndef_sql
jsonschema_sql
jsontable_sql
openjsoncolumndef_sql
openjson_sql
in_sql
in_unnest_op
interval_sql
return_sql
reference_sql
anonymous_sql
paren_sql
neg_sql
not_sql
alias_sql
pivotalias_sql
aliases_sql
atindex_sql
attimezone_sql
fromtimezone_sql
add_sql
and_sql
or_sql
xor_sql
connector_sql
bitwiseand_sql
bitwiseleftshift_sql
bitwisenot_sql
bitwiseor_sql
bitwiserightshift_sql
bitwisexor_sql
currentdate_sql
collate_sql
command_sql
comment_sql
mergetreettlaction_sql
mergetreettl_sql
transaction_sql
commit_sql
rollback_sql
altercolumn_sql
alterdiststyle_sql
altersortkey_sql
renametable_sql
renamecolumn_sql
alterset_sql
alter_sql
add_column_sql
droppartition_sql
addconstraint_sql
distinct_sql
ignorenulls_sql
respectnulls_sql
havingmax_sql
intdiv_sql
dpipe_sql
div_sql
overlaps_sql
distance_sql
dot_sql
propertyeq_sql
escape_sql
glob_sql
gt_sql
gte_sql
ilike_sql
ilikeany_sql
is_sql
like_sql
likeany_sql
similarto_sql
lt_sql
lte_sql
mod_sql
mul_sql
nullsafeeq_sql
nullsafeneq_sql
slice_sql
sub_sql
try_sql
log_sql
use_sql
binary
function_fallback_sql
func
format_args
too_wide
format_time
expressions
op_expressions
naked_property
tag_sql
token_sql
userdefinedfunction_sql
joinhint_sql
kwarg_sql
when_sql
merge_sql
tochar_sql
tonumber_sql
dictproperty_sql
dictrange_sql
dictsubproperty_sql
clusteredbyproperty_sql
anyvalue_sql
querytransform_sql
indexconstraintoption_sql
checkcolumnconstraint_sql
nvl2_sql
comprehension_sql
columnprefix_sql
opclass_sql
predict_sql
forin_sql
refresh_sql
operator_sql
toarray_sql
tsordstotime_sql
tsordstotimestamp_sql
tsordstodate_sql
unixdate_sql
lastday_sql
dateadd_sql
arrayany_sql
struct_sql
partitionrange_sql
truncatetable_sql
convert_sql
copyparameter_sql
credentials_sql
copy_sql
semicolon_sql
datadeletionproperty_sql
maskingpolicycolumnconstraint_sql
gapfill_sql
scope_resolution
scoperesolution_sql
parsejson_sql
rand_sql
changes_sql
pad_sql
summarize_sql
explodinggenerateseries_sql
arrayconcat_sql
converttimezone_sql