Edit on GitHub

sqlglot.dialects.clickhouse

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

CREATABLE_KIND_MAPPING = {'DATABASE': 'SCHEMA'}

Helper for dialects that use a different name for the same creatable kind. For example, the Clickhouse equivalent of CREATE SCHEMA is CREATE DATABASE.

SET_OP_DISTINCT_BY_DEFAULT: Dict[Type[sqlglot.expressions.Expression], Optional[bool]] = {<class 'sqlglot.expressions.Except'>: False, <class 'sqlglot.expressions.Intersect'>: False, <class 'sqlglot.expressions.Union'>: None}

Whether a set operation uses DISTINCT by default. This is None when either DISTINCT or ALL must be explicitly specified.

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 = {}
INVERSE_CREATABLE_KIND_MAPPING: dict[str, str] = {'SCHEMA': 'DATABASE'}
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):
156    class Tokenizer(tokens.Tokenizer):
157        COMMENTS = ["--", "#", "#!", ("/*", "*/")]
158        IDENTIFIERS = ['"', "`"]
159        STRING_ESCAPES = ["'", "\\"]
160        BIT_STRINGS = [("0b", "")]
161        HEX_STRINGS = [("0x", ""), ("0X", "")]
162        HEREDOC_STRINGS = ["$"]
163
164        KEYWORDS = {
165            **tokens.Tokenizer.KEYWORDS,
166            "ATTACH": TokenType.COMMAND,
167            "DATE32": TokenType.DATE32,
168            "DATETIME64": TokenType.DATETIME64,
169            "DICTIONARY": TokenType.DICTIONARY,
170            "ENUM8": TokenType.ENUM8,
171            "ENUM16": TokenType.ENUM16,
172            "FINAL": TokenType.FINAL,
173            "FIXEDSTRING": TokenType.FIXEDSTRING,
174            "FLOAT32": TokenType.FLOAT,
175            "FLOAT64": TokenType.DOUBLE,
176            "GLOBAL": TokenType.GLOBAL,
177            "INT256": TokenType.INT256,
178            "LOWCARDINALITY": TokenType.LOWCARDINALITY,
179            "MAP": TokenType.MAP,
180            "NESTED": TokenType.NESTED,
181            "SAMPLE": TokenType.TABLE_SAMPLE,
182            "TUPLE": TokenType.STRUCT,
183            "UINT128": TokenType.UINT128,
184            "UINT16": TokenType.USMALLINT,
185            "UINT256": TokenType.UINT256,
186            "UINT32": TokenType.UINT,
187            "UINT64": TokenType.UBIGINT,
188            "UINT8": TokenType.UTINYINT,
189            "IPV4": TokenType.IPV4,
190            "IPV6": TokenType.IPV6,
191            "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION,
192            "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION,
193            "SYSTEM": TokenType.COMMAND,
194            "PREWHERE": TokenType.PREWHERE,
195        }
196        KEYWORDS.pop("/*+")
197
198        SINGLE_TOKENS = {
199            **tokens.Tokenizer.SINGLE_TOKENS,
200            "$": TokenType.HEREDOC_STRING,
201        }
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'>, '~~~': <TokenType.GLOB: 'GLOB'>, '~~': <TokenType.LIKE: 'LIKE'>, '~~*': <TokenType.ILIKE: 'ILIKE'>, '~*': <TokenType.IRLIKE: 'IRLIKE'>, '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'>, 'UHUGEINT': <TokenType.UINT128: 'UINT128'>, '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'>, 'DECIMAL32': <TokenType.DECIMAL32: 'DECIMAL32'>, 'DECIMAL64': <TokenType.DECIMAL64: 'DECIMAL64'>, 'DECIMAL128': <TokenType.DECIMAL128: 'DECIMAL128'>, '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.GRANT: 'GRANT'>, '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):
203    class Parser(parser.Parser):
204        # Tested in ClickHouse's playground, it seems that the following two queries do the same thing
205        # * select x from t1 union all select x from t2 limit 1;
206        # * select x from t1 union all (select x from t2 limit 1);
207        MODIFIERS_ATTACHED_TO_SET_OP = False
208        INTERVAL_SPANS = False
209
210        FUNCTIONS = {
211            **parser.Parser.FUNCTIONS,
212            "ANY": exp.AnyValue.from_arg_list,
213            "ARRAYSUM": exp.ArraySum.from_arg_list,
214            "COUNTIF": _build_count_if,
215            "DATE_ADD": build_date_delta(exp.DateAdd, default_unit=None),
216            "DATEADD": build_date_delta(exp.DateAdd, default_unit=None),
217            "DATE_DIFF": build_date_delta(exp.DateDiff, default_unit=None),
218            "DATEDIFF": build_date_delta(exp.DateDiff, default_unit=None),
219            "DATE_FORMAT": _build_date_format,
220            "DATE_SUB": build_date_delta(exp.DateSub, default_unit=None),
221            "DATESUB": build_date_delta(exp.DateSub, default_unit=None),
222            "FORMATDATETIME": _build_date_format,
223            "JSONEXTRACTSTRING": build_json_extract_path(
224                exp.JSONExtractScalar, zero_based_indexing=False
225            ),
226            "MAP": parser.build_var_map,
227            "MATCH": exp.RegexpLike.from_arg_list,
228            "RANDCANONICAL": exp.Rand.from_arg_list,
229            "STR_TO_DATE": _build_str_to_date,
230            "TUPLE": exp.Struct.from_arg_list,
231            "TIMESTAMP_SUB": build_date_delta(exp.TimestampSub, default_unit=None),
232            "TIMESTAMPSUB": build_date_delta(exp.TimestampSub, default_unit=None),
233            "TIMESTAMP_ADD": build_date_delta(exp.TimestampAdd, default_unit=None),
234            "TIMESTAMPADD": build_date_delta(exp.TimestampAdd, default_unit=None),
235            "UNIQ": exp.ApproxDistinct.from_arg_list,
236            "XOR": lambda args: exp.Xor(expressions=args),
237            "MD5": exp.MD5Digest.from_arg_list,
238            "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
239            "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
240        }
241
242        AGG_FUNCTIONS = {
243            "count",
244            "min",
245            "max",
246            "sum",
247            "avg",
248            "any",
249            "stddevPop",
250            "stddevSamp",
251            "varPop",
252            "varSamp",
253            "corr",
254            "covarPop",
255            "covarSamp",
256            "entropy",
257            "exponentialMovingAverage",
258            "intervalLengthSum",
259            "kolmogorovSmirnovTest",
260            "mannWhitneyUTest",
261            "median",
262            "rankCorr",
263            "sumKahan",
264            "studentTTest",
265            "welchTTest",
266            "anyHeavy",
267            "anyLast",
268            "boundingRatio",
269            "first_value",
270            "last_value",
271            "argMin",
272            "argMax",
273            "avgWeighted",
274            "topK",
275            "topKWeighted",
276            "deltaSum",
277            "deltaSumTimestamp",
278            "groupArray",
279            "groupArrayLast",
280            "groupUniqArray",
281            "groupArrayInsertAt",
282            "groupArrayMovingAvg",
283            "groupArrayMovingSum",
284            "groupArraySample",
285            "groupBitAnd",
286            "groupBitOr",
287            "groupBitXor",
288            "groupBitmap",
289            "groupBitmapAnd",
290            "groupBitmapOr",
291            "groupBitmapXor",
292            "sumWithOverflow",
293            "sumMap",
294            "minMap",
295            "maxMap",
296            "skewSamp",
297            "skewPop",
298            "kurtSamp",
299            "kurtPop",
300            "uniq",
301            "uniqExact",
302            "uniqCombined",
303            "uniqCombined64",
304            "uniqHLL12",
305            "uniqTheta",
306            "quantile",
307            "quantiles",
308            "quantileExact",
309            "quantilesExact",
310            "quantileExactLow",
311            "quantilesExactLow",
312            "quantileExactHigh",
313            "quantilesExactHigh",
314            "quantileExactWeighted",
315            "quantilesExactWeighted",
316            "quantileTiming",
317            "quantilesTiming",
318            "quantileTimingWeighted",
319            "quantilesTimingWeighted",
320            "quantileDeterministic",
321            "quantilesDeterministic",
322            "quantileTDigest",
323            "quantilesTDigest",
324            "quantileTDigestWeighted",
325            "quantilesTDigestWeighted",
326            "quantileBFloat16",
327            "quantilesBFloat16",
328            "quantileBFloat16Weighted",
329            "quantilesBFloat16Weighted",
330            "simpleLinearRegression",
331            "stochasticLinearRegression",
332            "stochasticLogisticRegression",
333            "categoricalInformationValue",
334            "contingency",
335            "cramersV",
336            "cramersVBiasCorrected",
337            "theilsU",
338            "maxIntersections",
339            "maxIntersectionsPosition",
340            "meanZTest",
341            "quantileInterpolatedWeighted",
342            "quantilesInterpolatedWeighted",
343            "quantileGK",
344            "quantilesGK",
345            "sparkBar",
346            "sumCount",
347            "largestTriangleThreeBuckets",
348            "histogram",
349            "sequenceMatch",
350            "sequenceCount",
351            "windowFunnel",
352            "retention",
353            "uniqUpTo",
354            "sequenceNextNode",
355            "exponentialTimeDecayedAvg",
356        }
357
358        AGG_FUNCTIONS_SUFFIXES = [
359            "If",
360            "Array",
361            "ArrayIf",
362            "Map",
363            "SimpleState",
364            "State",
365            "Merge",
366            "MergeState",
367            "ForEach",
368            "Distinct",
369            "OrDefault",
370            "OrNull",
371            "Resample",
372            "ArgMin",
373            "ArgMax",
374        ]
375
376        FUNC_TOKENS = {
377            *parser.Parser.FUNC_TOKENS,
378            TokenType.SET,
379        }
380
381        RESERVED_TOKENS = parser.Parser.RESERVED_TOKENS - {TokenType.SELECT}
382
383        ID_VAR_TOKENS = {
384            *parser.Parser.ID_VAR_TOKENS,
385            TokenType.LIKE,
386        }
387
388        AGG_FUNC_MAPPING = (
389            lambda functions, suffixes: {
390                f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions
391            }
392        )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES)
393
394        FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"}
395
396        FUNCTION_PARSERS = {
397            **parser.Parser.FUNCTION_PARSERS,
398            "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()),
399            "QUANTILE": lambda self: self._parse_quantile(),
400            "COLUMNS": lambda self: self._parse_columns(),
401        }
402
403        FUNCTION_PARSERS.pop("MATCH")
404
405        NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy()
406        NO_PAREN_FUNCTION_PARSERS.pop("ANY")
407
408        NO_PAREN_FUNCTIONS = parser.Parser.NO_PAREN_FUNCTIONS.copy()
409        NO_PAREN_FUNCTIONS.pop(TokenType.CURRENT_TIMESTAMP)
410
411        RANGE_PARSERS = {
412            **parser.Parser.RANGE_PARSERS,
413            TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN)
414            and self._parse_in(this, is_global=True),
415        }
416
417        # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to
418        # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler.
419        COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy()
420        COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
421
422        JOIN_KINDS = {
423            *parser.Parser.JOIN_KINDS,
424            TokenType.ANY,
425            TokenType.ASOF,
426            TokenType.ARRAY,
427        }
428
429        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
430            TokenType.ANY,
431            TokenType.ARRAY,
432            TokenType.FINAL,
433            TokenType.FORMAT,
434            TokenType.SETTINGS,
435        }
436
437        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
438            TokenType.FORMAT,
439        }
440
441        LOG_DEFAULTS_TO_LN = True
442
443        QUERY_MODIFIER_PARSERS = {
444            **parser.Parser.QUERY_MODIFIER_PARSERS,
445            TokenType.SETTINGS: lambda self: (
446                "settings",
447                self._advance() or self._parse_csv(self._parse_assignment),
448            ),
449            TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
450        }
451
452        CONSTRAINT_PARSERS = {
453            **parser.Parser.CONSTRAINT_PARSERS,
454            "INDEX": lambda self: self._parse_index_constraint(),
455            "CODEC": lambda self: self._parse_compress(),
456        }
457
458        ALTER_PARSERS = {
459            **parser.Parser.ALTER_PARSERS,
460            "REPLACE": lambda self: self._parse_alter_table_replace(),
461        }
462
463        SCHEMA_UNNAMED_CONSTRAINTS = {
464            *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
465            "INDEX",
466        }
467
468        PLACEHOLDER_PARSERS = {
469            **parser.Parser.PLACEHOLDER_PARSERS,
470            TokenType.L_BRACE: lambda self: self._parse_query_parameter(),
471        }
472
473        def _parse_types(
474            self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
475        ) -> t.Optional[exp.Expression]:
476            dtype = super()._parse_types(
477                check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
478            )
479            if isinstance(dtype, exp.DataType) and dtype.args.get("nullable") is not True:
480                # Mark every type as non-nullable which is ClickHouse's default, unless it's
481                # already marked as nullable. This marker helps us transpile types from other
482                # dialects to ClickHouse, so that we can e.g. produce `CAST(x AS Nullable(String))`
483                # from `CAST(x AS TEXT)`. If there is a `NULL` value in `x`, the former would
484                # fail in ClickHouse without the `Nullable` type constructor.
485                dtype.set("nullable", False)
486
487            return dtype
488
489        def _parse_extract(self) -> exp.Extract | exp.Anonymous:
490            index = self._index
491            this = self._parse_bitwise()
492            if self._match(TokenType.FROM):
493                self._retreat(index)
494                return super()._parse_extract()
495
496            # We return Anonymous here because extract and regexpExtract have different semantics,
497            # so parsing extract(foo, bar) into RegexpExtract can potentially break queries. E.g.,
498            # `extract('foobar', 'b')` works, but ClickHouse crashes for `regexpExtract('foobar', 'b')`.
499            #
500            # TODO: can we somehow convert the former into an equivalent `regexpExtract` call?
501            self._match(TokenType.COMMA)
502            return self.expression(
503                exp.Anonymous, this="extract", expressions=[this, self._parse_bitwise()]
504            )
505
506        def _parse_assignment(self) -> t.Optional[exp.Expression]:
507            this = super()._parse_assignment()
508
509            if self._match(TokenType.PLACEHOLDER):
510                return self.expression(
511                    exp.If,
512                    this=this,
513                    true=self._parse_assignment(),
514                    false=self._match(TokenType.COLON) and self._parse_assignment(),
515                )
516
517            return this
518
519        def _parse_query_parameter(self) -> t.Optional[exp.Expression]:
520            """
521            Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
522            https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
523            """
524            this = self._parse_id_var()
525            self._match(TokenType.COLON)
526            kind = self._parse_types(check_func=False, allow_identifiers=False) or (
527                self._match_text_seq("IDENTIFIER") and "Identifier"
528            )
529
530            if not kind:
531                self.raise_error("Expecting a placeholder type or 'Identifier' for tables")
532            elif not self._match(TokenType.R_BRACE):
533                self.raise_error("Expecting }")
534
535            return self.expression(exp.Placeholder, this=this, kind=kind)
536
537        def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In:
538            this = super()._parse_in(this)
539            this.set("is_global", is_global)
540            return this
541
542        def _parse_table(
543            self,
544            schema: bool = False,
545            joins: bool = False,
546            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
547            parse_bracket: bool = False,
548            is_db_reference: bool = False,
549            parse_partition: bool = False,
550        ) -> t.Optional[exp.Expression]:
551            this = super()._parse_table(
552                schema=schema,
553                joins=joins,
554                alias_tokens=alias_tokens,
555                parse_bracket=parse_bracket,
556                is_db_reference=is_db_reference,
557            )
558
559            if self._match(TokenType.FINAL):
560                this = self.expression(exp.Final, this=this)
561
562            return this
563
564        def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
565            return super()._parse_position(haystack_first=True)
566
567        # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
568        def _parse_cte(self) -> exp.CTE:
569            # WITH <identifier> AS <subquery expression>
570            cte: t.Optional[exp.CTE] = self._try_parse(super()._parse_cte)
571
572            if not cte:
573                # WITH <expression> AS <identifier>
574                cte = self.expression(
575                    exp.CTE,
576                    this=self._parse_assignment(),
577                    alias=self._parse_table_alias(),
578                    scalar=True,
579                )
580
581            return cte
582
583        def _parse_join_parts(
584            self,
585        ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
586            is_global = self._match(TokenType.GLOBAL) and self._prev
587            kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev
588
589            if kind_pre:
590                kind = self._match_set(self.JOIN_KINDS) and self._prev
591                side = self._match_set(self.JOIN_SIDES) and self._prev
592                return is_global, side, kind
593
594            return (
595                is_global,
596                self._match_set(self.JOIN_SIDES) and self._prev,
597                self._match_set(self.JOIN_KINDS) and self._prev,
598            )
599
600        def _parse_join(
601            self, skip_join_token: bool = False, parse_bracket: bool = False
602        ) -> t.Optional[exp.Join]:
603            join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True)
604            if join:
605                join.set("global", join.args.pop("method", None))
606
607                # tbl ARRAY JOIN arr <-- this should be a `Column` reference, not a `Table`
608                # https://clickhouse.com/docs/en/sql-reference/statements/select/array-join
609                if join.kind == "ARRAY":
610                    for table in join.find_all(exp.Table):
611                        table.replace(table.to_column())
612
613            return join
614
615        def _parse_function(
616            self,
617            functions: t.Optional[t.Dict[str, t.Callable]] = None,
618            anonymous: bool = False,
619            optional_parens: bool = True,
620            any_token: bool = False,
621        ) -> t.Optional[exp.Expression]:
622            expr = super()._parse_function(
623                functions=functions,
624                anonymous=anonymous,
625                optional_parens=optional_parens,
626                any_token=any_token,
627            )
628
629            func = expr.this if isinstance(expr, exp.Window) else expr
630
631            # Aggregate functions can be split in 2 parts: <func_name><suffix>
632            parts = (
633                self.AGG_FUNC_MAPPING.get(func.this) if isinstance(func, exp.Anonymous) else None
634            )
635
636            if parts:
637                anon_func: exp.Anonymous = t.cast(exp.Anonymous, func)
638                params = self._parse_func_params(anon_func)
639
640                kwargs = {
641                    "this": anon_func.this,
642                    "expressions": anon_func.expressions,
643                }
644                if parts[1]:
645                    kwargs["parts"] = parts
646                    exp_class: t.Type[exp.Expression] = (
647                        exp.CombinedParameterizedAgg if params else exp.CombinedAggFunc
648                    )
649                else:
650                    exp_class = exp.ParameterizedAgg if params else exp.AnonymousAggFunc
651
652                kwargs["exp_class"] = exp_class
653                if params:
654                    kwargs["params"] = params
655
656                func = self.expression(**kwargs)
657
658                if isinstance(expr, exp.Window):
659                    # The window's func was parsed as Anonymous in base parser, fix its
660                    # type to be ClickHouse style CombinedAnonymousAggFunc / AnonymousAggFunc
661                    expr.set("this", func)
662                elif params:
663                    # Params have blocked super()._parse_function() from parsing the following window
664                    # (if that exists) as they're standing between the function call and the window spec
665                    expr = self._parse_window(func)
666                else:
667                    expr = func
668
669            return expr
670
671        def _parse_func_params(
672            self, this: t.Optional[exp.Func] = None
673        ) -> t.Optional[t.List[exp.Expression]]:
674            if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
675                return self._parse_csv(self._parse_lambda)
676
677            if self._match(TokenType.L_PAREN):
678                params = self._parse_csv(self._parse_lambda)
679                self._match_r_paren(this)
680                return params
681
682            return None
683
684        def _parse_quantile(self) -> exp.Quantile:
685            this = self._parse_lambda()
686            params = self._parse_func_params()
687            if params:
688                return self.expression(exp.Quantile, this=params[0], quantile=this)
689            return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5))
690
691        def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
692            return super()._parse_wrapped_id_vars(optional=True)
693
694        def _parse_primary_key(
695            self, wrapped_optional: bool = False, in_props: bool = False
696        ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
697            return super()._parse_primary_key(
698                wrapped_optional=wrapped_optional or in_props, in_props=in_props
699            )
700
701        def _parse_on_property(self) -> t.Optional[exp.Expression]:
702            index = self._index
703            if self._match_text_seq("CLUSTER"):
704                this = self._parse_id_var()
705                if this:
706                    return self.expression(exp.OnCluster, this=this)
707                else:
708                    self._retreat(index)
709            return None
710
711        def _parse_index_constraint(
712            self, kind: t.Optional[str] = None
713        ) -> exp.IndexColumnConstraint:
714            # INDEX name1 expr TYPE type1(args) GRANULARITY value
715            this = self._parse_id_var()
716            expression = self._parse_assignment()
717
718            index_type = self._match_text_seq("TYPE") and (
719                self._parse_function() or self._parse_var()
720            )
721
722            granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
723
724            return self.expression(
725                exp.IndexColumnConstraint,
726                this=this,
727                expression=expression,
728                index_type=index_type,
729                granularity=granularity,
730            )
731
732        def _parse_partition(self) -> t.Optional[exp.Partition]:
733            # https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#how-to-set-partition-expression
734            if not self._match(TokenType.PARTITION):
735                return None
736
737            if self._match_text_seq("ID"):
738                # Corresponds to the PARTITION ID <string_value> syntax
739                expressions: t.List[exp.Expression] = [
740                    self.expression(exp.PartitionId, this=self._parse_string())
741                ]
742            else:
743                expressions = self._parse_expressions()
744
745            return self.expression(exp.Partition, expressions=expressions)
746
747        def _parse_alter_table_replace(self) -> t.Optional[exp.Expression]:
748            partition = self._parse_partition()
749
750            if not partition or not self._match(TokenType.FROM):
751                return None
752
753            return self.expression(
754                exp.ReplacePartition, expression=partition, source=self._parse_table_parts()
755            )
756
757        def _parse_projection_def(self) -> t.Optional[exp.ProjectionDef]:
758            if not self._match_text_seq("PROJECTION"):
759                return None
760
761            return self.expression(
762                exp.ProjectionDef,
763                this=self._parse_id_var(),
764                expression=self._parse_wrapped(self._parse_statement),
765            )
766
767        def _parse_constraint(self) -> t.Optional[exp.Expression]:
768            return super()._parse_constraint() or self._parse_projection_def()
769
770        def _parse_alias(
771            self, this: t.Optional[exp.Expression], explicit: bool = False
772        ) -> t.Optional[exp.Expression]:
773            # In clickhouse "SELECT <expr> APPLY(...)" is a query modifier,
774            # so "APPLY" shouldn't be parsed as <expr>'s alias. However, "SELECT <expr> apply" is a valid alias
775            if self._match_pair(TokenType.APPLY, TokenType.L_PAREN, advance=False):
776                return this
777
778            return super()._parse_alias(this=this, explicit=explicit)
779
780        def _parse_expression(self) -> t.Optional[exp.Expression]:
781            this = super()._parse_expression()
782
783            # Clickhouse allows "SELECT <expr> [APPLY(func)] [...]]" modifier
784            while self._match_pair(TokenType.APPLY, TokenType.L_PAREN):
785                this = exp.Apply(this=this, expression=self._parse_var(any_token=True))
786                self._match(TokenType.R_PAREN)
787
788            return this
789
790        def _parse_columns(self) -> exp.Expression:
791            this: exp.Expression = self.expression(exp.Columns, this=self._parse_lambda())
792
793            while self._next and self._match_text_seq(")", "APPLY", "("):
794                self._match(TokenType.R_PAREN)
795                this = exp.Apply(this=this, expression=self._parse_var(any_token=True))
796            return this

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'>>, 'APPLY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Apply'>>, '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': <function Parser.<lambda>>, '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': <function Parser.<lambda>>, 'CHAR': <function Parser.<lambda>>, 'COALESCE': <function build_coalesce>, 'IFNULL': <function build_coalesce>, 'NVL': <function build_coalesce>, 'COLLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Collate'>>, 'COLUMNS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Columns'>>, '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': <function Parser.<lambda>>, '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'>>, 'DAYOFWEEK_ISO': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeekIso'>>, 'ISODOW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeekIso'>>, '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'>>, 'FROM_ISO8601_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromISO8601Timestamp'>>, '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'>>, 'INLINE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Inline'>>, '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'>>, 'J_S_O_N_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONExists'>>, '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'>>, 'NORMALIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Normalize'>>, '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'>>, 'OVERLAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Overlay'>>, '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'>>, 'SPLIT_PART': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SplitPart'>>, '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'>>, 'SUBSTR': <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_DOUBLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToDouble'>>, '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'>>, 'UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, 'GEN_RANDOM_UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, 'GENERATE_UUID': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, 'UUID_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Uuid'>>, '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'>>, 'ARRAYAGG': <function Parser.<lambda>>, 'GLOB': <function Parser.<lambda>>, 'INSTR': <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>>, 'LTRIM': <function Parser.<lambda>>, 'MOD': <function build_mod>, 'RIGHTPAD': <function Parser.<lambda>>, 'RPAD': <function Parser.<lambda>>, 'RTRIM': <function Parser.<lambda>>, 'SCOPE_RESOLUTION': <function Parser.<lambda>>, '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 = {'kurtPop', 'quantilesExactWeighted', 'quantilesExact', 'groupArrayLast', 'min', 'intervalLengthSum', 'exponentialTimeDecayedAvg', 'windowFunnel', 'quantilesBFloat16Weighted', 'last_value', 'histogram', 'maxIntersections', 'uniqCombined64', 'minMap', 'sequenceMatch', 'quantilesTiming', 'median', 'sumWithOverflow', 'uniqHLL12', 'contingency', 'quantileTimingWeighted', 'topK', 'cramersV', 'deltaSum', 'varPop', 'boundingRatio', 'welchTTest', 'quantileBFloat16Weighted', 'quantileInterpolatedWeighted', 'entropy', 'studentTTest', 'stochasticLogisticRegression', 'uniq', 'uniqUpTo', 'groupBitOr', 'groupArrayMovingSum', 'skewSamp', 'groupBitmapOr', 'avg', 'sequenceCount', 'skewPop', 'groupArrayInsertAt', 'anyLast', 'deltaSumTimestamp', 'groupArrayMovingAvg', 'categoricalInformationValue', 'mannWhitneyUTest', 'quantileExactWeighted', 'sum', 'groupArray', 'theilsU', 'varSamp', 'quantile', 'any', 'quantileExact', 'uniqCombined', 'quantilesTDigestWeighted', 'quantileExactLow', 'uniqTheta', 'simpleLinearRegression', 'avgWeighted', 'stddevSamp', 'sequenceNextNode', 'sumCount', 'quantileTiming', 'first_value', 'maxMap', 'groupBitmapXor', 'quantilesExactLow', 'stddevPop', 'argMax', 'corr', 'groupBitmap', 'sparkBar', 'covarPop', 'quantileTDigestWeighted', 'quantiles', 'quantilesDeterministic', 'cramersVBiasCorrected', 'anyHeavy', 'count', 'quantileTDigest', 'rankCorr', 'uniqExact', 'quantilesTDigest', 'quantilesInterpolatedWeighted', 'groupBitmapAnd', 'stochasticLinearRegression', 'quantileDeterministic', 'covarSamp', 'kurtSamp', 'sumKahan', 'quantileExactHigh', 'groupUniqArray', 'meanZTest', 'quantilesExactHigh', 'exponentialMovingAverage', 'groupArraySample', 'groupBitAnd', 'quantileBFloat16', 'topKWeighted', 'quantilesBFloat16', 'quantilesTimingWeighted', 'quantilesGK', 'quantileGK', 'groupBitXor', 'kolmogorovSmirnovTest', 'largestTriangleThreeBuckets', 'max', 'maxIntersectionsPosition', 'retention', 'sumMap', 'argMin'}
AGG_FUNCTIONS_SUFFIXES = ['If', 'Array', 'ArrayIf', 'Map', 'SimpleState', 'State', 'Merge', 'MergeState', 'ForEach', 'Distinct', 'OrDefault', 'OrNull', 'Resample', 'ArgMin', 'ArgMax']
FUNC_TOKENS = {<TokenType.DECIMAL32: 'DECIMAL32'>, <TokenType.GLOB: 'GLOB'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.DATE32: 'DATE32'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.ALL: 'ALL'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.NESTED: 'NESTED'>, <TokenType.LEFT: 'LEFT'>, <TokenType.JSON: 'JSON'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.SUPER: 'SUPER'>, <TokenType.INT256: 'INT256'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.XOR: 'XOR'>, <TokenType.TEXT: 'TEXT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, <TokenType.RANGE: 'RANGE'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.INET: 'INET'>, <TokenType.MONEY: 'MONEY'>, <TokenType.SET: 'SET'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.INDEX: 'INDEX'>, <TokenType.JSONB: 'JSONB'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.FIRST: 'FIRST'>, <TokenType.INT: 'INT'>, <TokenType.CHAR: 'CHAR'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.ENUM: 'ENUM'>, <TokenType.BIT: 'BIT'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.UINT256: 'UINT256'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.SOME: 'SOME'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TIME: 'TIME'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.MAP: 'MAP'>, <TokenType.UNION: 'UNION'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.IPV6: 'IPV6'>, <TokenType.TABLE: 'TABLE'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.ILIKE: 'ILIKE'>, <TokenType.UINT128: 'UINT128'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.RLIKE: 'RLIKE'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.BINARY: 'BINARY'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ROW: 'ROW'>, <TokenType.INT128: 'INT128'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DECIMAL64: 'DECIMAL64'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.DECIMAL128: 'DECIMAL128'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.YEAR: 'YEAR'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.UINT: 'UINT'>, <TokenType.INSERT: 'INSERT'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.LIKE: 'LIKE'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.ANY: 'ANY'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.NAME: 'NAME'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.FILTER: 'FILTER'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.DATE: 'DATE'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.VAR: 'VAR'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.XML: 'XML'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.LIST: 'LIST'>, <TokenType.MERGE: 'MERGE'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.NULL: 'NULL'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.UBIGINT: 'UBIGINT'>}
RESERVED_TOKENS = {<TokenType.L_BRACE: 'L_BRACE'>, <TokenType.SEMICOLON: 'SEMICOLON'>, <TokenType.MOD: 'MOD'>, <TokenType.L_PAREN: 'L_PAREN'>, <TokenType.COLON: 'COLON'>, <TokenType.PARAMETER: 'PARAMETER'>, <TokenType.EQ: 'EQ'>, <TokenType.HASH: 'HASH'>, <TokenType.GT: 'GT'>, <TokenType.L_BRACKET: 'L_BRACKET'>, <TokenType.BACKSLASH: 'BACKSLASH'>, <TokenType.PIPE: 'PIPE'>, <TokenType.TILDA: 'TILDA'>, <TokenType.CARET: 'CARET'>, <TokenType.LT: 'LT'>, <TokenType.PLACEHOLDER: 'PLACEHOLDER'>, <TokenType.DASH: 'DASH'>, <TokenType.PLUS: 'PLUS'>, <TokenType.NOT: 'NOT'>, <TokenType.R_BRACE: 'R_BRACE'>, <TokenType.R_PAREN: 'R_PAREN'>, <TokenType.DOT: 'DOT'>, <TokenType.COMMA: 'COMMA'>, <TokenType.SLASH: 'SLASH'>, <TokenType.R_BRACKET: 'R_BRACKET'>, <TokenType.STAR: 'STAR'>, <TokenType.AMP: 'AMP'>, <TokenType.UNKNOWN: 'UNKNOWN'>}
ID_VAR_TOKENS = {<TokenType.DECIMAL32: 'DECIMAL32'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.DATE32: 'DATE32'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.ALL: 'ALL'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TAG: 'TAG'>, <TokenType.CASE: 'CASE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.IS: 'IS'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.NESTED: 'NESTED'>, <TokenType.LEFT: 'LEFT'>, <TokenType.DELETE: 'DELETE'>, <TokenType.JSON: 'JSON'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.MODEL: 'MODEL'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.SUPER: 'SUPER'>, <TokenType.INT256: 'INT256'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.TEXT: 'TEXT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.COPY: 'COPY'>, <TokenType.RANGE: 'RANGE'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.INET: 'INET'>, <TokenType.KILL: 'KILL'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.SET: 'SET'>, <TokenType.ROWS: 'ROWS'>, <TokenType.MONEY: 'MONEY'>, <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.INDEX: 'INDEX'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.JSONB: 'JSONB'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.FIRST: 'FIRST'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.INT: 'INT'>, <TokenType.CHAR: 'CHAR'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.ENUM: 'ENUM'>, <TokenType.BIT: 'BIT'>, <TokenType.RENAME: 'RENAME'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.CACHE: 'CACHE'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.UINT256: 'UINT256'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.ANTI: 'ANTI'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.TOP: 'TOP'>, <TokenType.SOME: 'SOME'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TIME: 'TIME'>, <TokenType.SEMI: 'SEMI'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.MAP: 'MAP'>, <TokenType.APPLY: 'APPLY'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.IPV6: 'IPV6'>, <TokenType.SHOW: 'SHOW'>, <TokenType.DIV: 'DIV'>, <TokenType.TABLE: 'TABLE'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.END: 'END'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.VIEW: 'VIEW'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.UINT128: 'UINT128'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.FALSE: 'FALSE'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.BINARY: 'BINARY'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ROW: 'ROW'>, <TokenType.INT128: 'INT128'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DECIMAL64: 'DECIMAL64'>, <TokenType.KEEP: 'KEEP'>, <TokenType.NEXT: 'NEXT'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.FINAL: 'FINAL'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.DECIMAL128: 'DECIMAL128'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.TRUE: 'TRUE'>, <TokenType.YEAR: 'YEAR'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.UINT: 'UINT'>, <TokenType.ASOF: 'ASOF'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.LIKE: 'LIKE'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.ANY: 'ANY'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.NAME: 'NAME'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.ASC: 'ASC'>, <TokenType.FILTER: 'FILTER'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.CUBE: 'CUBE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.DATE: 'DATE'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.FULL: 'FULL'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.USE: 'USE'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.LOAD: 'LOAD'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.VAR: 'VAR'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.XML: 'XML'>, <TokenType.DESC: 'DESC'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.LIST: 'LIST'>, <TokenType.MERGE: 'MERGE'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.NULL: 'NULL'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.UBIGINT: 'UBIGINT'>}
AGG_FUNC_MAPPING = {'kurtPopIf': ('kurtPop', 'If'), 'quantilesExactWeightedIf': ('quantilesExactWeighted', 'If'), 'quantilesExactIf': ('quantilesExact', 'If'), 'groupArrayLastIf': ('groupArrayLast', 'If'), 'minIf': ('min', 'If'), 'intervalLengthSumIf': ('intervalLengthSum', 'If'), 'exponentialTimeDecayedAvgIf': ('exponentialTimeDecayedAvg', 'If'), 'windowFunnelIf': ('windowFunnel', 'If'), 'quantilesBFloat16WeightedIf': ('quantilesBFloat16Weighted', 'If'), 'last_valueIf': ('last_value', 'If'), 'histogramIf': ('histogram', 'If'), 'maxIntersectionsIf': ('maxIntersections', 'If'), 'uniqCombined64If': ('uniqCombined64', 'If'), 'minMapIf': ('minMap', 'If'), 'sequenceMatchIf': ('sequenceMatch', 'If'), 'quantilesTimingIf': ('quantilesTiming', 'If'), 'medianIf': ('median', 'If'), 'sumWithOverflowIf': ('sumWithOverflow', 'If'), 'uniqHLL12If': ('uniqHLL12', 'If'), 'contingencyIf': ('contingency', 'If'), 'quantileTimingWeightedIf': ('quantileTimingWeighted', 'If'), 'topKIf': ('topK', 'If'), 'cramersVIf': ('cramersV', 'If'), 'deltaSumIf': ('deltaSum', 'If'), 'varPopIf': ('varPop', 'If'), 'boundingRatioIf': ('boundingRatio', 'If'), 'welchTTestIf': ('welchTTest', 'If'), 'quantileBFloat16WeightedIf': ('quantileBFloat16Weighted', 'If'), 'quantileInterpolatedWeightedIf': ('quantileInterpolatedWeighted', 'If'), 'entropyIf': ('entropy', 'If'), 'studentTTestIf': ('studentTTest', 'If'), 'stochasticLogisticRegressionIf': ('stochasticLogisticRegression', 'If'), 'uniqIf': ('uniq', 'If'), 'uniqUpToIf': ('uniqUpTo', 'If'), 'groupBitOrIf': ('groupBitOr', 'If'), 'groupArrayMovingSumIf': ('groupArrayMovingSum', 'If'), 'skewSampIf': ('skewSamp', 'If'), 'groupBitmapOrIf': ('groupBitmapOr', 'If'), 'avgIf': ('avg', 'If'), 'sequenceCountIf': ('sequenceCount', 'If'), 'skewPopIf': ('skewPop', 'If'), 'groupArrayInsertAtIf': ('groupArrayInsertAt', 'If'), 'anyLastIf': ('anyLast', 'If'), 'deltaSumTimestampIf': ('deltaSumTimestamp', 'If'), 'groupArrayMovingAvgIf': ('groupArrayMovingAvg', 'If'), 'categoricalInformationValueIf': ('categoricalInformationValue', 'If'), 'mannWhitneyUTestIf': ('mannWhitneyUTest', 'If'), 'quantileExactWeightedIf': ('quantileExactWeighted', 'If'), 'sumIf': ('sum', 'If'), 'groupArrayIf': ('groupArray', 'If'), 'theilsUIf': ('theilsU', 'If'), 'varSampIf': ('varSamp', 'If'), 'quantileIf': ('quantile', 'If'), 'anyIf': ('any', 'If'), 'quantileExactIf': ('quantileExact', 'If'), 'uniqCombinedIf': ('uniqCombined', 'If'), 'quantilesTDigestWeightedIf': ('quantilesTDigestWeighted', 'If'), 'quantileExactLowIf': ('quantileExactLow', 'If'), 'uniqThetaIf': ('uniqTheta', 'If'), 'simpleLinearRegressionIf': ('simpleLinearRegression', 'If'), 'avgWeightedIf': ('avgWeighted', 'If'), 'stddevSampIf': ('stddevSamp', 'If'), 'sequenceNextNodeIf': ('sequenceNextNode', 'If'), 'sumCountIf': ('sumCount', 'If'), 'quantileTimingIf': ('quantileTiming', 'If'), 'first_valueIf': ('first_value', 'If'), 'maxMapIf': ('maxMap', 'If'), 'groupBitmapXorIf': ('groupBitmapXor', 'If'), 'quantilesExactLowIf': ('quantilesExactLow', 'If'), 'stddevPopIf': ('stddevPop', 'If'), 'argMaxIf': ('argMax', 'If'), 'corrIf': ('corr', 'If'), 'groupBitmapIf': ('groupBitmap', 'If'), 'sparkBarIf': ('sparkBar', 'If'), 'covarPopIf': ('covarPop', 'If'), 'quantileTDigestWeightedIf': ('quantileTDigestWeighted', 'If'), 'quantilesIf': ('quantiles', 'If'), 'quantilesDeterministicIf': ('quantilesDeterministic', 'If'), 'cramersVBiasCorrectedIf': ('cramersVBiasCorrected', 'If'), 'anyHeavyIf': ('anyHeavy', 'If'), 'countIf': ('count', 'If'), 'quantileTDigestIf': ('quantileTDigest', 'If'), 'rankCorrIf': ('rankCorr', 'If'), 'uniqExactIf': ('uniqExact', 'If'), 'quantilesTDigestIf': ('quantilesTDigest', 'If'), 'quantilesInterpolatedWeightedIf': ('quantilesInterpolatedWeighted', 'If'), 'groupBitmapAndIf': ('groupBitmapAnd', 'If'), 'stochasticLinearRegressionIf': ('stochasticLinearRegression', 'If'), 'quantileDeterministicIf': ('quantileDeterministic', 'If'), 'covarSampIf': ('covarSamp', 'If'), 'kurtSampIf': ('kurtSamp', 'If'), 'sumKahanIf': ('sumKahan', 'If'), 'quantileExactHighIf': ('quantileExactHigh', 'If'), 'groupUniqArrayIf': ('groupUniqArray', 'If'), 'meanZTestIf': ('meanZTest', 'If'), 'quantilesExactHighIf': ('quantilesExactHigh', 'If'), 'exponentialMovingAverageIf': ('exponentialMovingAverage', 'If'), 'groupArraySampleIf': ('groupArraySample', 'If'), 'groupBitAndIf': ('groupBitAnd', 'If'), 'quantileBFloat16If': ('quantileBFloat16', 'If'), 'topKWeightedIf': ('topKWeighted', 'If'), 'quantilesBFloat16If': ('quantilesBFloat16', 'If'), 'quantilesTimingWeightedIf': ('quantilesTimingWeighted', 'If'), 'quantilesGKIf': ('quantilesGK', 'If'), 'quantileGKIf': ('quantileGK', 'If'), 'groupBitXorIf': ('groupBitXor', 'If'), 'kolmogorovSmirnovTestIf': ('kolmogorovSmirnovTest', 'If'), 'largestTriangleThreeBucketsIf': ('largestTriangleThreeBuckets', 'If'), 'maxIf': ('max', 'If'), 'maxIntersectionsPositionIf': ('maxIntersectionsPosition', 'If'), 'retentionIf': ('retention', 'If'), 'sumMapIf': ('sumMap', 'If'), 'argMinIf': ('argMin', 'If'), 'kurtPopArray': ('kurtPop', 'Array'), 'quantilesExactWeightedArray': ('quantilesExactWeighted', 'Array'), 'quantilesExactArray': ('quantilesExact', 'Array'), 'groupArrayLastArray': ('groupArrayLast', 'Array'), 'minArray': ('min', 'Array'), 'intervalLengthSumArray': ('intervalLengthSum', 'Array'), 'exponentialTimeDecayedAvgArray': ('exponentialTimeDecayedAvg', 'Array'), 'windowFunnelArray': ('windowFunnel', 'Array'), 'quantilesBFloat16WeightedArray': ('quantilesBFloat16Weighted', 'Array'), 'last_valueArray': ('last_value', 'Array'), 'histogramArray': ('histogram', 'Array'), 'maxIntersectionsArray': ('maxIntersections', 'Array'), 'uniqCombined64Array': ('uniqCombined64', 'Array'), 'minMapArray': ('minMap', 'Array'), 'sequenceMatchArray': ('sequenceMatch', 'Array'), 'quantilesTimingArray': ('quantilesTiming', 'Array'), 'medianArray': ('median', 'Array'), 'sumWithOverflowArray': ('sumWithOverflow', 'Array'), 'uniqHLL12Array': ('uniqHLL12', 'Array'), 'contingencyArray': ('contingency', 'Array'), 'quantileTimingWeightedArray': ('quantileTimingWeighted', 'Array'), 'topKArray': ('topK', 'Array'), 'cramersVArray': ('cramersV', 'Array'), 'deltaSumArray': ('deltaSum', 'Array'), 'varPopArray': ('varPop', 'Array'), 'boundingRatioArray': ('boundingRatio', 'Array'), 'welchTTestArray': ('welchTTest', 'Array'), 'quantileBFloat16WeightedArray': ('quantileBFloat16Weighted', 'Array'), 'quantileInterpolatedWeightedArray': ('quantileInterpolatedWeighted', 'Array'), 'entropyArray': ('entropy', 'Array'), 'studentTTestArray': ('studentTTest', 'Array'), 'stochasticLogisticRegressionArray': ('stochasticLogisticRegression', 'Array'), 'uniqArray': ('uniq', 'Array'), 'uniqUpToArray': ('uniqUpTo', 'Array'), 'groupBitOrArray': ('groupBitOr', 'Array'), 'groupArrayMovingSumArray': ('groupArrayMovingSum', 'Array'), 'skewSampArray': ('skewSamp', 'Array'), 'groupBitmapOrArray': ('groupBitmapOr', 'Array'), 'avgArray': ('avg', 'Array'), 'sequenceCountArray': ('sequenceCount', 'Array'), 'skewPopArray': ('skewPop', 'Array'), 'groupArrayInsertAtArray': ('groupArrayInsertAt', 'Array'), 'anyLastArray': ('anyLast', 'Array'), 'deltaSumTimestampArray': ('deltaSumTimestamp', 'Array'), 'groupArrayMovingAvgArray': ('groupArrayMovingAvg', 'Array'), 'categoricalInformationValueArray': ('categoricalInformationValue', 'Array'), 'mannWhitneyUTestArray': ('mannWhitneyUTest', 'Array'), 'quantileExactWeightedArray': ('quantileExactWeighted', 'Array'), 'sumArray': ('sum', 'Array'), 'groupArrayArray': ('groupArray', 'Array'), 'theilsUArray': ('theilsU', 'Array'), 'varSampArray': ('varSamp', 'Array'), 'quantileArray': ('quantile', 'Array'), 'anyArray': ('any', 'Array'), 'quantileExactArray': ('quantileExact', 'Array'), 'uniqCombinedArray': ('uniqCombined', 'Array'), 'quantilesTDigestWeightedArray': ('quantilesTDigestWeighted', 'Array'), 'quantileExactLowArray': ('quantileExactLow', 'Array'), 'uniqThetaArray': ('uniqTheta', 'Array'), 'simpleLinearRegressionArray': ('simpleLinearRegression', 'Array'), 'avgWeightedArray': ('avgWeighted', 'Array'), 'stddevSampArray': ('stddevSamp', 'Array'), 'sequenceNextNodeArray': ('sequenceNextNode', 'Array'), 'sumCountArray': ('sumCount', 'Array'), 'quantileTimingArray': ('quantileTiming', 'Array'), 'first_valueArray': ('first_value', 'Array'), 'maxMapArray': ('maxMap', 'Array'), 'groupBitmapXorArray': ('groupBitmapXor', 'Array'), 'quantilesExactLowArray': ('quantilesExactLow', 'Array'), 'stddevPopArray': ('stddevPop', 'Array'), 'argMaxArray': ('argMax', 'Array'), 'corrArray': ('corr', 'Array'), 'groupBitmapArray': ('groupBitmap', 'Array'), 'sparkBarArray': ('sparkBar', 'Array'), 'covarPopArray': ('covarPop', 'Array'), 'quantileTDigestWeightedArray': ('quantileTDigestWeighted', 'Array'), 'quantilesArray': ('quantiles', 'Array'), 'quantilesDeterministicArray': ('quantilesDeterministic', 'Array'), 'cramersVBiasCorrectedArray': ('cramersVBiasCorrected', 'Array'), 'anyHeavyArray': ('anyHeavy', 'Array'), 'countArray': ('count', 'Array'), 'quantileTDigestArray': ('quantileTDigest', 'Array'), 'rankCorrArray': ('rankCorr', 'Array'), 'uniqExactArray': ('uniqExact', 'Array'), 'quantilesTDigestArray': ('quantilesTDigest', 'Array'), 'quantilesInterpolatedWeightedArray': ('quantilesInterpolatedWeighted', 'Array'), 'groupBitmapAndArray': ('groupBitmapAnd', 'Array'), 'stochasticLinearRegressionArray': ('stochasticLinearRegression', 'Array'), 'quantileDeterministicArray': ('quantileDeterministic', 'Array'), 'covarSampArray': ('covarSamp', 'Array'), 'kurtSampArray': ('kurtSamp', 'Array'), 'sumKahanArray': ('sumKahan', 'Array'), 'quantileExactHighArray': ('quantileExactHigh', 'Array'), 'groupUniqArrayArray': ('groupUniqArray', 'Array'), 'meanZTestArray': ('meanZTest', 'Array'), 'quantilesExactHighArray': ('quantilesExactHigh', 'Array'), 'exponentialMovingAverageArray': ('exponentialMovingAverage', 'Array'), 'groupArraySampleArray': ('groupArraySample', 'Array'), 'groupBitAndArray': ('groupBitAnd', 'Array'), 'quantileBFloat16Array': ('quantileBFloat16', 'Array'), 'topKWeightedArray': ('topKWeighted', 'Array'), 'quantilesBFloat16Array': ('quantilesBFloat16', 'Array'), 'quantilesTimingWeightedArray': ('quantilesTimingWeighted', 'Array'), 'quantilesGKArray': ('quantilesGK', 'Array'), 'quantileGKArray': ('quantileGK', 'Array'), 'groupBitXorArray': ('groupBitXor', 'Array'), 'kolmogorovSmirnovTestArray': ('kolmogorovSmirnovTest', 'Array'), 'largestTriangleThreeBucketsArray': ('largestTriangleThreeBuckets', 'Array'), 'maxArray': ('max', 'Array'), 'maxIntersectionsPositionArray': ('maxIntersectionsPosition', 'Array'), 'retentionArray': ('retention', 'Array'), 'sumMapArray': ('sumMap', 'Array'), 'argMinArray': ('argMin', 'Array'), 'kurtPopArrayIf': ('kurtPop', 'ArrayIf'), 'quantilesExactWeightedArrayIf': ('quantilesExactWeighted', 'ArrayIf'), 'quantilesExactArrayIf': ('quantilesExact', 'ArrayIf'), 'groupArrayLastArrayIf': ('groupArrayLast', 'ArrayIf'), 'minArrayIf': ('min', 'ArrayIf'), 'intervalLengthSumArrayIf': ('intervalLengthSum', 'ArrayIf'), 'exponentialTimeDecayedAvgArrayIf': ('exponentialTimeDecayedAvg', 'ArrayIf'), 'windowFunnelArrayIf': ('windowFunnel', 'ArrayIf'), 'quantilesBFloat16WeightedArrayIf': ('quantilesBFloat16Weighted', 'ArrayIf'), 'last_valueArrayIf': ('last_value', 'ArrayIf'), 'histogramArrayIf': ('histogram', 'ArrayIf'), 'maxIntersectionsArrayIf': ('maxIntersections', 'ArrayIf'), 'uniqCombined64ArrayIf': ('uniqCombined64', 'ArrayIf'), 'minMapArrayIf': ('minMap', 'ArrayIf'), 'sequenceMatchArrayIf': ('sequenceMatch', 'ArrayIf'), 'quantilesTimingArrayIf': ('quantilesTiming', 'ArrayIf'), 'medianArrayIf': ('median', 'ArrayIf'), 'sumWithOverflowArrayIf': ('sumWithOverflow', 'ArrayIf'), 'uniqHLL12ArrayIf': ('uniqHLL12', 'ArrayIf'), 'contingencyArrayIf': ('contingency', 'ArrayIf'), 'quantileTimingWeightedArrayIf': ('quantileTimingWeighted', 'ArrayIf'), 'topKArrayIf': ('topK', 'ArrayIf'), 'cramersVArrayIf': ('cramersV', 'ArrayIf'), 'deltaSumArrayIf': ('deltaSum', 'ArrayIf'), 'varPopArrayIf': ('varPop', 'ArrayIf'), 'boundingRatioArrayIf': ('boundingRatio', 'ArrayIf'), 'welchTTestArrayIf': ('welchTTest', 'ArrayIf'), 'quantileBFloat16WeightedArrayIf': ('quantileBFloat16Weighted', 'ArrayIf'), 'quantileInterpolatedWeightedArrayIf': ('quantileInterpolatedWeighted', 'ArrayIf'), 'entropyArrayIf': ('entropy', 'ArrayIf'), 'studentTTestArrayIf': ('studentTTest', 'ArrayIf'), 'stochasticLogisticRegressionArrayIf': ('stochasticLogisticRegression', 'ArrayIf'), 'uniqArrayIf': ('uniq', 'ArrayIf'), 'uniqUpToArrayIf': ('uniqUpTo', 'ArrayIf'), 'groupBitOrArrayIf': ('groupBitOr', 'ArrayIf'), 'groupArrayMovingSumArrayIf': ('groupArrayMovingSum', 'ArrayIf'), 'skewSampArrayIf': ('skewSamp', 'ArrayIf'), 'groupBitmapOrArrayIf': ('groupBitmapOr', 'ArrayIf'), 'avgArrayIf': ('avg', 'ArrayIf'), 'sequenceCountArrayIf': ('sequenceCount', 'ArrayIf'), 'skewPopArrayIf': ('skewPop', 'ArrayIf'), 'groupArrayInsertAtArrayIf': ('groupArrayInsertAt', 'ArrayIf'), 'anyLastArrayIf': ('anyLast', 'ArrayIf'), 'deltaSumTimestampArrayIf': ('deltaSumTimestamp', 'ArrayIf'), 'groupArrayMovingAvgArrayIf': ('groupArrayMovingAvg', 'ArrayIf'), 'categoricalInformationValueArrayIf': ('categoricalInformationValue', 'ArrayIf'), 'mannWhitneyUTestArrayIf': ('mannWhitneyUTest', 'ArrayIf'), 'quantileExactWeightedArrayIf': ('quantileExactWeighted', 'ArrayIf'), 'sumArrayIf': ('sum', 'ArrayIf'), 'groupArrayArrayIf': ('groupArray', 'ArrayIf'), 'theilsUArrayIf': ('theilsU', 'ArrayIf'), 'varSampArrayIf': ('varSamp', 'ArrayIf'), 'quantileArrayIf': ('quantile', 'ArrayIf'), 'anyArrayIf': ('any', 'ArrayIf'), 'quantileExactArrayIf': ('quantileExact', 'ArrayIf'), 'uniqCombinedArrayIf': ('uniqCombined', 'ArrayIf'), 'quantilesTDigestWeightedArrayIf': ('quantilesTDigestWeighted', 'ArrayIf'), 'quantileExactLowArrayIf': ('quantileExactLow', 'ArrayIf'), 'uniqThetaArrayIf': ('uniqTheta', 'ArrayIf'), 'simpleLinearRegressionArrayIf': ('simpleLinearRegression', 'ArrayIf'), 'avgWeightedArrayIf': ('avgWeighted', 'ArrayIf'), 'stddevSampArrayIf': ('stddevSamp', 'ArrayIf'), 'sequenceNextNodeArrayIf': ('sequenceNextNode', 'ArrayIf'), 'sumCountArrayIf': ('sumCount', 'ArrayIf'), 'quantileTimingArrayIf': ('quantileTiming', 'ArrayIf'), 'first_valueArrayIf': ('first_value', 'ArrayIf'), 'maxMapArrayIf': ('maxMap', 'ArrayIf'), 'groupBitmapXorArrayIf': ('groupBitmapXor', 'ArrayIf'), 'quantilesExactLowArrayIf': ('quantilesExactLow', 'ArrayIf'), 'stddevPopArrayIf': ('stddevPop', 'ArrayIf'), 'argMaxArrayIf': ('argMax', 'ArrayIf'), 'corrArrayIf': ('corr', 'ArrayIf'), 'groupBitmapArrayIf': ('groupBitmap', 'ArrayIf'), 'sparkBarArrayIf': ('sparkBar', 'ArrayIf'), 'covarPopArrayIf': ('covarPop', 'ArrayIf'), 'quantileTDigestWeightedArrayIf': ('quantileTDigestWeighted', 'ArrayIf'), 'quantilesArrayIf': ('quantiles', 'ArrayIf'), 'quantilesDeterministicArrayIf': ('quantilesDeterministic', 'ArrayIf'), 'cramersVBiasCorrectedArrayIf': ('cramersVBiasCorrected', 'ArrayIf'), 'anyHeavyArrayIf': ('anyHeavy', 'ArrayIf'), 'countArrayIf': ('count', 'ArrayIf'), 'quantileTDigestArrayIf': ('quantileTDigest', 'ArrayIf'), 'rankCorrArrayIf': ('rankCorr', 'ArrayIf'), 'uniqExactArrayIf': ('uniqExact', 'ArrayIf'), 'quantilesTDigestArrayIf': ('quantilesTDigest', 'ArrayIf'), 'quantilesInterpolatedWeightedArrayIf': ('quantilesInterpolatedWeighted', 'ArrayIf'), 'groupBitmapAndArrayIf': ('groupBitmapAnd', 'ArrayIf'), 'stochasticLinearRegressionArrayIf': ('stochasticLinearRegression', 'ArrayIf'), 'quantileDeterministicArrayIf': ('quantileDeterministic', 'ArrayIf'), 'covarSampArrayIf': ('covarSamp', 'ArrayIf'), 'kurtSampArrayIf': ('kurtSamp', 'ArrayIf'), 'sumKahanArrayIf': ('sumKahan', 'ArrayIf'), 'quantileExactHighArrayIf': ('quantileExactHigh', 'ArrayIf'), 'groupUniqArrayArrayIf': ('groupUniqArray', 'ArrayIf'), 'meanZTestArrayIf': ('meanZTest', 'ArrayIf'), 'quantilesExactHighArrayIf': ('quantilesExactHigh', 'ArrayIf'), 'exponentialMovingAverageArrayIf': ('exponentialMovingAverage', 'ArrayIf'), 'groupArraySampleArrayIf': ('groupArraySample', 'ArrayIf'), 'groupBitAndArrayIf': ('groupBitAnd', 'ArrayIf'), 'quantileBFloat16ArrayIf': ('quantileBFloat16', 'ArrayIf'), 'topKWeightedArrayIf': ('topKWeighted', 'ArrayIf'), 'quantilesBFloat16ArrayIf': ('quantilesBFloat16', 'ArrayIf'), 'quantilesTimingWeightedArrayIf': ('quantilesTimingWeighted', 'ArrayIf'), 'quantilesGKArrayIf': ('quantilesGK', 'ArrayIf'), 'quantileGKArrayIf': ('quantileGK', 'ArrayIf'), 'groupBitXorArrayIf': ('groupBitXor', 'ArrayIf'), 'kolmogorovSmirnovTestArrayIf': ('kolmogorovSmirnovTest', 'ArrayIf'), 'largestTriangleThreeBucketsArrayIf': ('largestTriangleThreeBuckets', 'ArrayIf'), 'maxArrayIf': ('max', 'ArrayIf'), 'maxIntersectionsPositionArrayIf': ('maxIntersectionsPosition', 'ArrayIf'), 'retentionArrayIf': ('retention', 'ArrayIf'), 'sumMapArrayIf': ('sumMap', 'ArrayIf'), 'argMinArrayIf': ('argMin', 'ArrayIf'), 'kurtPopMap': ('kurtPop', 'Map'), 'quantilesExactWeightedMap': ('quantilesExactWeighted', 'Map'), 'quantilesExactMap': ('quantilesExact', 'Map'), 'groupArrayLastMap': ('groupArrayLast', 'Map'), 'minMap': ('minMap', ''), 'intervalLengthSumMap': ('intervalLengthSum', 'Map'), 'exponentialTimeDecayedAvgMap': ('exponentialTimeDecayedAvg', 'Map'), 'windowFunnelMap': ('windowFunnel', 'Map'), 'quantilesBFloat16WeightedMap': ('quantilesBFloat16Weighted', 'Map'), 'last_valueMap': ('last_value', 'Map'), 'histogramMap': ('histogram', 'Map'), 'maxIntersectionsMap': ('maxIntersections', 'Map'), 'uniqCombined64Map': ('uniqCombined64', 'Map'), 'minMapMap': ('minMap', 'Map'), 'sequenceMatchMap': ('sequenceMatch', 'Map'), 'quantilesTimingMap': ('quantilesTiming', 'Map'), 'medianMap': ('median', 'Map'), 'sumWithOverflowMap': ('sumWithOverflow', 'Map'), 'uniqHLL12Map': ('uniqHLL12', 'Map'), 'contingencyMap': ('contingency', 'Map'), 'quantileTimingWeightedMap': ('quantileTimingWeighted', 'Map'), 'topKMap': ('topK', 'Map'), 'cramersVMap': ('cramersV', 'Map'), 'deltaSumMap': ('deltaSum', 'Map'), 'varPopMap': ('varPop', 'Map'), 'boundingRatioMap': ('boundingRatio', 'Map'), 'welchTTestMap': ('welchTTest', 'Map'), 'quantileBFloat16WeightedMap': ('quantileBFloat16Weighted', 'Map'), 'quantileInterpolatedWeightedMap': ('quantileInterpolatedWeighted', 'Map'), 'entropyMap': ('entropy', 'Map'), 'studentTTestMap': ('studentTTest', 'Map'), 'stochasticLogisticRegressionMap': ('stochasticLogisticRegression', 'Map'), 'uniqMap': ('uniq', 'Map'), 'uniqUpToMap': ('uniqUpTo', 'Map'), 'groupBitOrMap': ('groupBitOr', 'Map'), 'groupArrayMovingSumMap': ('groupArrayMovingSum', 'Map'), 'skewSampMap': ('skewSamp', 'Map'), 'groupBitmapOrMap': ('groupBitmapOr', 'Map'), 'avgMap': ('avg', 'Map'), 'sequenceCountMap': ('sequenceCount', 'Map'), 'skewPopMap': ('skewPop', 'Map'), 'groupArrayInsertAtMap': ('groupArrayInsertAt', 'Map'), 'anyLastMap': ('anyLast', 'Map'), 'deltaSumTimestampMap': ('deltaSumTimestamp', 'Map'), 'groupArrayMovingAvgMap': ('groupArrayMovingAvg', 'Map'), 'categoricalInformationValueMap': ('categoricalInformationValue', 'Map'), 'mannWhitneyUTestMap': ('mannWhitneyUTest', 'Map'), 'quantileExactWeightedMap': ('quantileExactWeighted', 'Map'), 'sumMap': ('sumMap', ''), 'groupArrayMap': ('groupArray', 'Map'), 'theilsUMap': ('theilsU', 'Map'), 'varSampMap': ('varSamp', 'Map'), 'quantileMap': ('quantile', 'Map'), 'anyMap': ('any', 'Map'), 'quantileExactMap': ('quantileExact', 'Map'), 'uniqCombinedMap': ('uniqCombined', 'Map'), 'quantilesTDigestWeightedMap': ('quantilesTDigestWeighted', 'Map'), 'quantileExactLowMap': ('quantileExactLow', 'Map'), 'uniqThetaMap': ('uniqTheta', 'Map'), 'simpleLinearRegressionMap': ('simpleLinearRegression', 'Map'), 'avgWeightedMap': ('avgWeighted', 'Map'), 'stddevSampMap': ('stddevSamp', 'Map'), 'sequenceNextNodeMap': ('sequenceNextNode', 'Map'), 'sumCountMap': ('sumCount', 'Map'), 'quantileTimingMap': ('quantileTiming', 'Map'), 'first_valueMap': ('first_value', 'Map'), 'maxMapMap': ('maxMap', 'Map'), 'groupBitmapXorMap': ('groupBitmapXor', 'Map'), 'quantilesExactLowMap': ('quantilesExactLow', 'Map'), 'stddevPopMap': ('stddevPop', 'Map'), 'argMaxMap': ('argMax', 'Map'), 'corrMap': ('corr', 'Map'), 'groupBitmapMap': ('groupBitmap', 'Map'), 'sparkBarMap': ('sparkBar', 'Map'), 'covarPopMap': ('covarPop', 'Map'), 'quantileTDigestWeightedMap': ('quantileTDigestWeighted', 'Map'), 'quantilesMap': ('quantiles', 'Map'), 'quantilesDeterministicMap': ('quantilesDeterministic', 'Map'), 'cramersVBiasCorrectedMap': ('cramersVBiasCorrected', 'Map'), 'anyHeavyMap': ('anyHeavy', 'Map'), 'countMap': ('count', 'Map'), 'quantileTDigestMap': ('quantileTDigest', 'Map'), 'rankCorrMap': ('rankCorr', 'Map'), 'uniqExactMap': ('uniqExact', 'Map'), 'quantilesTDigestMap': ('quantilesTDigest', 'Map'), 'quantilesInterpolatedWeightedMap': ('quantilesInterpolatedWeighted', 'Map'), 'groupBitmapAndMap': ('groupBitmapAnd', 'Map'), 'stochasticLinearRegressionMap': ('stochasticLinearRegression', 'Map'), 'quantileDeterministicMap': ('quantileDeterministic', 'Map'), 'covarSampMap': ('covarSamp', 'Map'), 'kurtSampMap': ('kurtSamp', 'Map'), 'sumKahanMap': ('sumKahan', 'Map'), 'quantileExactHighMap': ('quantileExactHigh', 'Map'), 'groupUniqArrayMap': ('groupUniqArray', 'Map'), 'meanZTestMap': ('meanZTest', 'Map'), 'quantilesExactHighMap': ('quantilesExactHigh', 'Map'), 'exponentialMovingAverageMap': ('exponentialMovingAverage', 'Map'), 'groupArraySampleMap': ('groupArraySample', 'Map'), 'groupBitAndMap': ('groupBitAnd', 'Map'), 'quantileBFloat16Map': ('quantileBFloat16', 'Map'), 'topKWeightedMap': ('topKWeighted', 'Map'), 'quantilesBFloat16Map': ('quantilesBFloat16', 'Map'), 'quantilesTimingWeightedMap': ('quantilesTimingWeighted', 'Map'), 'quantilesGKMap': ('quantilesGK', 'Map'), 'quantileGKMap': ('quantileGK', 'Map'), 'groupBitXorMap': ('groupBitXor', 'Map'), 'kolmogorovSmirnovTestMap': ('kolmogorovSmirnovTest', 'Map'), 'largestTriangleThreeBucketsMap': ('largestTriangleThreeBuckets', 'Map'), 'maxMap': ('maxMap', ''), 'maxIntersectionsPositionMap': ('maxIntersectionsPosition', 'Map'), 'retentionMap': ('retention', 'Map'), 'sumMapMap': ('sumMap', 'Map'), 'argMinMap': ('argMin', 'Map'), 'kurtPopSimpleState': ('kurtPop', 'SimpleState'), 'quantilesExactWeightedSimpleState': ('quantilesExactWeighted', 'SimpleState'), 'quantilesExactSimpleState': ('quantilesExact', 'SimpleState'), 'groupArrayLastSimpleState': ('groupArrayLast', 'SimpleState'), 'minSimpleState': ('min', 'SimpleState'), 'intervalLengthSumSimpleState': ('intervalLengthSum', 'SimpleState'), 'exponentialTimeDecayedAvgSimpleState': ('exponentialTimeDecayedAvg', 'SimpleState'), 'windowFunnelSimpleState': ('windowFunnel', 'SimpleState'), 'quantilesBFloat16WeightedSimpleState': ('quantilesBFloat16Weighted', 'SimpleState'), 'last_valueSimpleState': ('last_value', 'SimpleState'), 'histogramSimpleState': ('histogram', 'SimpleState'), 'maxIntersectionsSimpleState': ('maxIntersections', 'SimpleState'), 'uniqCombined64SimpleState': ('uniqCombined64', 'SimpleState'), 'minMapSimpleState': ('minMap', 'SimpleState'), 'sequenceMatchSimpleState': ('sequenceMatch', 'SimpleState'), 'quantilesTimingSimpleState': ('quantilesTiming', 'SimpleState'), 'medianSimpleState': ('median', 'SimpleState'), 'sumWithOverflowSimpleState': ('sumWithOverflow', 'SimpleState'), 'uniqHLL12SimpleState': ('uniqHLL12', 'SimpleState'), 'contingencySimpleState': ('contingency', 'SimpleState'), 'quantileTimingWeightedSimpleState': ('quantileTimingWeighted', 'SimpleState'), 'topKSimpleState': ('topK', 'SimpleState'), 'cramersVSimpleState': ('cramersV', 'SimpleState'), 'deltaSumSimpleState': ('deltaSum', 'SimpleState'), 'varPopSimpleState': ('varPop', 'SimpleState'), 'boundingRatioSimpleState': ('boundingRatio', 'SimpleState'), 'welchTTestSimpleState': ('welchTTest', 'SimpleState'), 'quantileBFloat16WeightedSimpleState': ('quantileBFloat16Weighted', 'SimpleState'), 'quantileInterpolatedWeightedSimpleState': ('quantileInterpolatedWeighted', 'SimpleState'), 'entropySimpleState': ('entropy', 'SimpleState'), 'studentTTestSimpleState': ('studentTTest', 'SimpleState'), 'stochasticLogisticRegressionSimpleState': ('stochasticLogisticRegression', 'SimpleState'), 'uniqSimpleState': ('uniq', 'SimpleState'), 'uniqUpToSimpleState': ('uniqUpTo', 'SimpleState'), 'groupBitOrSimpleState': ('groupBitOr', 'SimpleState'), 'groupArrayMovingSumSimpleState': ('groupArrayMovingSum', 'SimpleState'), 'skewSampSimpleState': ('skewSamp', 'SimpleState'), 'groupBitmapOrSimpleState': ('groupBitmapOr', 'SimpleState'), 'avgSimpleState': ('avg', 'SimpleState'), 'sequenceCountSimpleState': ('sequenceCount', 'SimpleState'), 'skewPopSimpleState': ('skewPop', 'SimpleState'), 'groupArrayInsertAtSimpleState': ('groupArrayInsertAt', 'SimpleState'), 'anyLastSimpleState': ('anyLast', 'SimpleState'), 'deltaSumTimestampSimpleState': ('deltaSumTimestamp', 'SimpleState'), 'groupArrayMovingAvgSimpleState': ('groupArrayMovingAvg', 'SimpleState'), 'categoricalInformationValueSimpleState': ('categoricalInformationValue', 'SimpleState'), 'mannWhitneyUTestSimpleState': ('mannWhitneyUTest', 'SimpleState'), 'quantileExactWeightedSimpleState': ('quantileExactWeighted', 'SimpleState'), 'sumSimpleState': ('sum', 'SimpleState'), 'groupArraySimpleState': ('groupArray', 'SimpleState'), 'theilsUSimpleState': ('theilsU', 'SimpleState'), 'varSampSimpleState': ('varSamp', 'SimpleState'), 'quantileSimpleState': ('quantile', 'SimpleState'), 'anySimpleState': ('any', 'SimpleState'), 'quantileExactSimpleState': ('quantileExact', 'SimpleState'), 'uniqCombinedSimpleState': ('uniqCombined', 'SimpleState'), 'quantilesTDigestWeightedSimpleState': ('quantilesTDigestWeighted', 'SimpleState'), 'quantileExactLowSimpleState': ('quantileExactLow', 'SimpleState'), 'uniqThetaSimpleState': ('uniqTheta', 'SimpleState'), 'simpleLinearRegressionSimpleState': ('simpleLinearRegression', 'SimpleState'), 'avgWeightedSimpleState': ('avgWeighted', 'SimpleState'), 'stddevSampSimpleState': ('stddevSamp', 'SimpleState'), 'sequenceNextNodeSimpleState': ('sequenceNextNode', 'SimpleState'), 'sumCountSimpleState': ('sumCount', 'SimpleState'), 'quantileTimingSimpleState': ('quantileTiming', 'SimpleState'), 'first_valueSimpleState': ('first_value', 'SimpleState'), 'maxMapSimpleState': ('maxMap', 'SimpleState'), 'groupBitmapXorSimpleState': ('groupBitmapXor', 'SimpleState'), 'quantilesExactLowSimpleState': ('quantilesExactLow', 'SimpleState'), 'stddevPopSimpleState': ('stddevPop', 'SimpleState'), 'argMaxSimpleState': ('argMax', 'SimpleState'), 'corrSimpleState': ('corr', 'SimpleState'), 'groupBitmapSimpleState': ('groupBitmap', 'SimpleState'), 'sparkBarSimpleState': ('sparkBar', 'SimpleState'), 'covarPopSimpleState': ('covarPop', 'SimpleState'), 'quantileTDigestWeightedSimpleState': ('quantileTDigestWeighted', 'SimpleState'), 'quantilesSimpleState': ('quantiles', 'SimpleState'), 'quantilesDeterministicSimpleState': ('quantilesDeterministic', 'SimpleState'), 'cramersVBiasCorrectedSimpleState': ('cramersVBiasCorrected', 'SimpleState'), 'anyHeavySimpleState': ('anyHeavy', 'SimpleState'), 'countSimpleState': ('count', 'SimpleState'), 'quantileTDigestSimpleState': ('quantileTDigest', 'SimpleState'), 'rankCorrSimpleState': ('rankCorr', 'SimpleState'), 'uniqExactSimpleState': ('uniqExact', 'SimpleState'), 'quantilesTDigestSimpleState': ('quantilesTDigest', 'SimpleState'), 'quantilesInterpolatedWeightedSimpleState': ('quantilesInterpolatedWeighted', 'SimpleState'), 'groupBitmapAndSimpleState': ('groupBitmapAnd', 'SimpleState'), 'stochasticLinearRegressionSimpleState': ('stochasticLinearRegression', 'SimpleState'), 'quantileDeterministicSimpleState': ('quantileDeterministic', 'SimpleState'), 'covarSampSimpleState': ('covarSamp', 'SimpleState'), 'kurtSampSimpleState': ('kurtSamp', 'SimpleState'), 'sumKahanSimpleState': ('sumKahan', 'SimpleState'), 'quantileExactHighSimpleState': ('quantileExactHigh', 'SimpleState'), 'groupUniqArraySimpleState': ('groupUniqArray', 'SimpleState'), 'meanZTestSimpleState': ('meanZTest', 'SimpleState'), 'quantilesExactHighSimpleState': ('quantilesExactHigh', 'SimpleState'), 'exponentialMovingAverageSimpleState': ('exponentialMovingAverage', 'SimpleState'), 'groupArraySampleSimpleState': ('groupArraySample', 'SimpleState'), 'groupBitAndSimpleState': ('groupBitAnd', 'SimpleState'), 'quantileBFloat16SimpleState': ('quantileBFloat16', 'SimpleState'), 'topKWeightedSimpleState': ('topKWeighted', 'SimpleState'), 'quantilesBFloat16SimpleState': ('quantilesBFloat16', 'SimpleState'), 'quantilesTimingWeightedSimpleState': ('quantilesTimingWeighted', 'SimpleState'), 'quantilesGKSimpleState': ('quantilesGK', 'SimpleState'), 'quantileGKSimpleState': ('quantileGK', 'SimpleState'), 'groupBitXorSimpleState': ('groupBitXor', 'SimpleState'), 'kolmogorovSmirnovTestSimpleState': ('kolmogorovSmirnovTest', 'SimpleState'), 'largestTriangleThreeBucketsSimpleState': ('largestTriangleThreeBuckets', 'SimpleState'), 'maxSimpleState': ('max', 'SimpleState'), 'maxIntersectionsPositionSimpleState': ('maxIntersectionsPosition', 'SimpleState'), 'retentionSimpleState': ('retention', 'SimpleState'), 'sumMapSimpleState': ('sumMap', 'SimpleState'), 'argMinSimpleState': ('argMin', 'SimpleState'), 'kurtPopState': ('kurtPop', 'State'), 'quantilesExactWeightedState': ('quantilesExactWeighted', 'State'), 'quantilesExactState': ('quantilesExact', 'State'), 'groupArrayLastState': ('groupArrayLast', 'State'), 'minState': ('min', 'State'), 'intervalLengthSumState': ('intervalLengthSum', 'State'), 'exponentialTimeDecayedAvgState': ('exponentialTimeDecayedAvg', 'State'), 'windowFunnelState': ('windowFunnel', 'State'), 'quantilesBFloat16WeightedState': ('quantilesBFloat16Weighted', 'State'), 'last_valueState': ('last_value', 'State'), 'histogramState': ('histogram', 'State'), 'maxIntersectionsState': ('maxIntersections', 'State'), 'uniqCombined64State': ('uniqCombined64', 'State'), 'minMapState': ('minMap', 'State'), 'sequenceMatchState': ('sequenceMatch', 'State'), 'quantilesTimingState': ('quantilesTiming', 'State'), 'medianState': ('median', 'State'), 'sumWithOverflowState': ('sumWithOverflow', 'State'), 'uniqHLL12State': ('uniqHLL12', 'State'), 'contingencyState': ('contingency', 'State'), 'quantileTimingWeightedState': ('quantileTimingWeighted', 'State'), 'topKState': ('topK', 'State'), 'cramersVState': ('cramersV', 'State'), 'deltaSumState': ('deltaSum', 'State'), 'varPopState': ('varPop', 'State'), 'boundingRatioState': ('boundingRatio', 'State'), 'welchTTestState': ('welchTTest', 'State'), 'quantileBFloat16WeightedState': ('quantileBFloat16Weighted', 'State'), 'quantileInterpolatedWeightedState': ('quantileInterpolatedWeighted', 'State'), 'entropyState': ('entropy', 'State'), 'studentTTestState': ('studentTTest', 'State'), 'stochasticLogisticRegressionState': ('stochasticLogisticRegression', 'State'), 'uniqState': ('uniq', 'State'), 'uniqUpToState': ('uniqUpTo', 'State'), 'groupBitOrState': ('groupBitOr', 'State'), 'groupArrayMovingSumState': ('groupArrayMovingSum', 'State'), 'skewSampState': ('skewSamp', 'State'), 'groupBitmapOrState': ('groupBitmapOr', 'State'), 'avgState': ('avg', 'State'), 'sequenceCountState': ('sequenceCount', 'State'), 'skewPopState': ('skewPop', 'State'), 'groupArrayInsertAtState': ('groupArrayInsertAt', 'State'), 'anyLastState': ('anyLast', 'State'), 'deltaSumTimestampState': ('deltaSumTimestamp', 'State'), 'groupArrayMovingAvgState': ('groupArrayMovingAvg', 'State'), 'categoricalInformationValueState': ('categoricalInformationValue', 'State'), 'mannWhitneyUTestState': ('mannWhitneyUTest', 'State'), 'quantileExactWeightedState': ('quantileExactWeighted', 'State'), 'sumState': ('sum', 'State'), 'groupArrayState': ('groupArray', 'State'), 'theilsUState': ('theilsU', 'State'), 'varSampState': ('varSamp', 'State'), 'quantileState': ('quantile', 'State'), 'anyState': ('any', 'State'), 'quantileExactState': ('quantileExact', 'State'), 'uniqCombinedState': ('uniqCombined', 'State'), 'quantilesTDigestWeightedState': ('quantilesTDigestWeighted', 'State'), 'quantileExactLowState': ('quantileExactLow', 'State'), 'uniqThetaState': ('uniqTheta', 'State'), 'simpleLinearRegressionState': ('simpleLinearRegression', 'State'), 'avgWeightedState': ('avgWeighted', 'State'), 'stddevSampState': ('stddevSamp', 'State'), 'sequenceNextNodeState': ('sequenceNextNode', 'State'), 'sumCountState': ('sumCount', 'State'), 'quantileTimingState': ('quantileTiming', 'State'), 'first_valueState': ('first_value', 'State'), 'maxMapState': ('maxMap', 'State'), 'groupBitmapXorState': ('groupBitmapXor', 'State'), 'quantilesExactLowState': ('quantilesExactLow', 'State'), 'stddevPopState': ('stddevPop', 'State'), 'argMaxState': ('argMax', 'State'), 'corrState': ('corr', 'State'), 'groupBitmapState': ('groupBitmap', 'State'), 'sparkBarState': ('sparkBar', 'State'), 'covarPopState': ('covarPop', 'State'), 'quantileTDigestWeightedState': ('quantileTDigestWeighted', 'State'), 'quantilesState': ('quantiles', 'State'), 'quantilesDeterministicState': ('quantilesDeterministic', 'State'), 'cramersVBiasCorrectedState': ('cramersVBiasCorrected', 'State'), 'anyHeavyState': ('anyHeavy', 'State'), 'countState': ('count', 'State'), 'quantileTDigestState': ('quantileTDigest', 'State'), 'rankCorrState': ('rankCorr', 'State'), 'uniqExactState': ('uniqExact', 'State'), 'quantilesTDigestState': ('quantilesTDigest', 'State'), 'quantilesInterpolatedWeightedState': ('quantilesInterpolatedWeighted', 'State'), 'groupBitmapAndState': ('groupBitmapAnd', 'State'), 'stochasticLinearRegressionState': ('stochasticLinearRegression', 'State'), 'quantileDeterministicState': ('quantileDeterministic', 'State'), 'covarSampState': ('covarSamp', 'State'), 'kurtSampState': ('kurtSamp', 'State'), 'sumKahanState': ('sumKahan', 'State'), 'quantileExactHighState': ('quantileExactHigh', 'State'), 'groupUniqArrayState': ('groupUniqArray', 'State'), 'meanZTestState': ('meanZTest', 'State'), 'quantilesExactHighState': ('quantilesExactHigh', 'State'), 'exponentialMovingAverageState': ('exponentialMovingAverage', 'State'), 'groupArraySampleState': ('groupArraySample', 'State'), 'groupBitAndState': ('groupBitAnd', 'State'), 'quantileBFloat16State': ('quantileBFloat16', 'State'), 'topKWeightedState': ('topKWeighted', 'State'), 'quantilesBFloat16State': ('quantilesBFloat16', 'State'), 'quantilesTimingWeightedState': ('quantilesTimingWeighted', 'State'), 'quantilesGKState': ('quantilesGK', 'State'), 'quantileGKState': ('quantileGK', 'State'), 'groupBitXorState': ('groupBitXor', 'State'), 'kolmogorovSmirnovTestState': ('kolmogorovSmirnovTest', 'State'), 'largestTriangleThreeBucketsState': ('largestTriangleThreeBuckets', 'State'), 'maxState': ('max', 'State'), 'maxIntersectionsPositionState': ('maxIntersectionsPosition', 'State'), 'retentionState': ('retention', 'State'), 'sumMapState': ('sumMap', 'State'), 'argMinState': ('argMin', 'State'), 'kurtPopMerge': ('kurtPop', 'Merge'), 'quantilesExactWeightedMerge': ('quantilesExactWeighted', 'Merge'), 'quantilesExactMerge': ('quantilesExact', 'Merge'), 'groupArrayLastMerge': ('groupArrayLast', 'Merge'), 'minMerge': ('min', 'Merge'), 'intervalLengthSumMerge': ('intervalLengthSum', 'Merge'), 'exponentialTimeDecayedAvgMerge': ('exponentialTimeDecayedAvg', 'Merge'), 'windowFunnelMerge': ('windowFunnel', 'Merge'), 'quantilesBFloat16WeightedMerge': ('quantilesBFloat16Weighted', 'Merge'), 'last_valueMerge': ('last_value', 'Merge'), 'histogramMerge': ('histogram', 'Merge'), 'maxIntersectionsMerge': ('maxIntersections', 'Merge'), 'uniqCombined64Merge': ('uniqCombined64', 'Merge'), 'minMapMerge': ('minMap', 'Merge'), 'sequenceMatchMerge': ('sequenceMatch', 'Merge'), 'quantilesTimingMerge': ('quantilesTiming', 'Merge'), 'medianMerge': ('median', 'Merge'), 'sumWithOverflowMerge': ('sumWithOverflow', 'Merge'), 'uniqHLL12Merge': ('uniqHLL12', 'Merge'), 'contingencyMerge': ('contingency', 'Merge'), 'quantileTimingWeightedMerge': ('quantileTimingWeighted', 'Merge'), 'topKMerge': ('topK', 'Merge'), 'cramersVMerge': ('cramersV', 'Merge'), 'deltaSumMerge': ('deltaSum', 'Merge'), 'varPopMerge': ('varPop', 'Merge'), 'boundingRatioMerge': ('boundingRatio', 'Merge'), 'welchTTestMerge': ('welchTTest', 'Merge'), 'quantileBFloat16WeightedMerge': ('quantileBFloat16Weighted', 'Merge'), 'quantileInterpolatedWeightedMerge': ('quantileInterpolatedWeighted', 'Merge'), 'entropyMerge': ('entropy', 'Merge'), 'studentTTestMerge': ('studentTTest', 'Merge'), 'stochasticLogisticRegressionMerge': ('stochasticLogisticRegression', 'Merge'), 'uniqMerge': ('uniq', 'Merge'), 'uniqUpToMerge': ('uniqUpTo', 'Merge'), 'groupBitOrMerge': ('groupBitOr', 'Merge'), 'groupArrayMovingSumMerge': ('groupArrayMovingSum', 'Merge'), 'skewSampMerge': ('skewSamp', 'Merge'), 'groupBitmapOrMerge': ('groupBitmapOr', 'Merge'), 'avgMerge': ('avg', 'Merge'), 'sequenceCountMerge': ('sequenceCount', 'Merge'), 'skewPopMerge': ('skewPop', 'Merge'), 'groupArrayInsertAtMerge': ('groupArrayInsertAt', 'Merge'), 'anyLastMerge': ('anyLast', 'Merge'), 'deltaSumTimestampMerge': ('deltaSumTimestamp', 'Merge'), 'groupArrayMovingAvgMerge': ('groupArrayMovingAvg', 'Merge'), 'categoricalInformationValueMerge': ('categoricalInformationValue', 'Merge'), 'mannWhitneyUTestMerge': ('mannWhitneyUTest', 'Merge'), 'quantileExactWeightedMerge': ('quantileExactWeighted', 'Merge'), 'sumMerge': ('sum', 'Merge'), 'groupArrayMerge': ('groupArray', 'Merge'), 'theilsUMerge': ('theilsU', 'Merge'), 'varSampMerge': ('varSamp', 'Merge'), 'quantileMerge': ('quantile', 'Merge'), 'anyMerge': ('any', 'Merge'), 'quantileExactMerge': ('quantileExact', 'Merge'), 'uniqCombinedMerge': ('uniqCombined', 'Merge'), 'quantilesTDigestWeightedMerge': ('quantilesTDigestWeighted', 'Merge'), 'quantileExactLowMerge': ('quantileExactLow', 'Merge'), 'uniqThetaMerge': ('uniqTheta', 'Merge'), 'simpleLinearRegressionMerge': ('simpleLinearRegression', 'Merge'), 'avgWeightedMerge': ('avgWeighted', 'Merge'), 'stddevSampMerge': ('stddevSamp', 'Merge'), 'sequenceNextNodeMerge': ('sequenceNextNode', 'Merge'), 'sumCountMerge': ('sumCount', 'Merge'), 'quantileTimingMerge': ('quantileTiming', 'Merge'), 'first_valueMerge': ('first_value', 'Merge'), 'maxMapMerge': ('maxMap', 'Merge'), 'groupBitmapXorMerge': ('groupBitmapXor', 'Merge'), 'quantilesExactLowMerge': ('quantilesExactLow', 'Merge'), 'stddevPopMerge': ('stddevPop', 'Merge'), 'argMaxMerge': ('argMax', 'Merge'), 'corrMerge': ('corr', 'Merge'), 'groupBitmapMerge': ('groupBitmap', 'Merge'), 'sparkBarMerge': ('sparkBar', 'Merge'), 'covarPopMerge': ('covarPop', 'Merge'), 'quantileTDigestWeightedMerge': ('quantileTDigestWeighted', 'Merge'), 'quantilesMerge': ('quantiles', 'Merge'), 'quantilesDeterministicMerge': ('quantilesDeterministic', 'Merge'), 'cramersVBiasCorrectedMerge': ('cramersVBiasCorrected', 'Merge'), 'anyHeavyMerge': ('anyHeavy', 'Merge'), 'countMerge': ('count', 'Merge'), 'quantileTDigestMerge': ('quantileTDigest', 'Merge'), 'rankCorrMerge': ('rankCorr', 'Merge'), 'uniqExactMerge': ('uniqExact', 'Merge'), 'quantilesTDigestMerge': ('quantilesTDigest', 'Merge'), 'quantilesInterpolatedWeightedMerge': ('quantilesInterpolatedWeighted', 'Merge'), 'groupBitmapAndMerge': ('groupBitmapAnd', 'Merge'), 'stochasticLinearRegressionMerge': ('stochasticLinearRegression', 'Merge'), 'quantileDeterministicMerge': ('quantileDeterministic', 'Merge'), 'covarSampMerge': ('covarSamp', 'Merge'), 'kurtSampMerge': ('kurtSamp', 'Merge'), 'sumKahanMerge': ('sumKahan', 'Merge'), 'quantileExactHighMerge': ('quantileExactHigh', 'Merge'), 'groupUniqArrayMerge': ('groupUniqArray', 'Merge'), 'meanZTestMerge': ('meanZTest', 'Merge'), 'quantilesExactHighMerge': ('quantilesExactHigh', 'Merge'), 'exponentialMovingAverageMerge': ('exponentialMovingAverage', 'Merge'), 'groupArraySampleMerge': ('groupArraySample', 'Merge'), 'groupBitAndMerge': ('groupBitAnd', 'Merge'), 'quantileBFloat16Merge': ('quantileBFloat16', 'Merge'), 'topKWeightedMerge': ('topKWeighted', 'Merge'), 'quantilesBFloat16Merge': ('quantilesBFloat16', 'Merge'), 'quantilesTimingWeightedMerge': ('quantilesTimingWeighted', 'Merge'), 'quantilesGKMerge': ('quantilesGK', 'Merge'), 'quantileGKMerge': ('quantileGK', 'Merge'), 'groupBitXorMerge': ('groupBitXor', 'Merge'), 'kolmogorovSmirnovTestMerge': ('kolmogorovSmirnovTest', 'Merge'), 'largestTriangleThreeBucketsMerge': ('largestTriangleThreeBuckets', 'Merge'), 'maxMerge': ('max', 'Merge'), 'maxIntersectionsPositionMerge': ('maxIntersectionsPosition', 'Merge'), 'retentionMerge': ('retention', 'Merge'), 'sumMapMerge': ('sumMap', 'Merge'), 'argMinMerge': ('argMin', 'Merge'), 'kurtPopMergeState': ('kurtPop', 'MergeState'), 'quantilesExactWeightedMergeState': ('quantilesExactWeighted', 'MergeState'), 'quantilesExactMergeState': ('quantilesExact', 'MergeState'), 'groupArrayLastMergeState': ('groupArrayLast', 'MergeState'), 'minMergeState': ('min', 'MergeState'), 'intervalLengthSumMergeState': ('intervalLengthSum', 'MergeState'), 'exponentialTimeDecayedAvgMergeState': ('exponentialTimeDecayedAvg', 'MergeState'), 'windowFunnelMergeState': ('windowFunnel', 'MergeState'), 'quantilesBFloat16WeightedMergeState': ('quantilesBFloat16Weighted', 'MergeState'), 'last_valueMergeState': ('last_value', 'MergeState'), 'histogramMergeState': ('histogram', 'MergeState'), 'maxIntersectionsMergeState': ('maxIntersections', 'MergeState'), 'uniqCombined64MergeState': ('uniqCombined64', 'MergeState'), 'minMapMergeState': ('minMap', 'MergeState'), 'sequenceMatchMergeState': ('sequenceMatch', 'MergeState'), 'quantilesTimingMergeState': ('quantilesTiming', 'MergeState'), 'medianMergeState': ('median', 'MergeState'), 'sumWithOverflowMergeState': ('sumWithOverflow', 'MergeState'), 'uniqHLL12MergeState': ('uniqHLL12', 'MergeState'), 'contingencyMergeState': ('contingency', 'MergeState'), 'quantileTimingWeightedMergeState': ('quantileTimingWeighted', 'MergeState'), 'topKMergeState': ('topK', 'MergeState'), 'cramersVMergeState': ('cramersV', 'MergeState'), 'deltaSumMergeState': ('deltaSum', 'MergeState'), 'varPopMergeState': ('varPop', 'MergeState'), 'boundingRatioMergeState': ('boundingRatio', 'MergeState'), 'welchTTestMergeState': ('welchTTest', 'MergeState'), 'quantileBFloat16WeightedMergeState': ('quantileBFloat16Weighted', 'MergeState'), 'quantileInterpolatedWeightedMergeState': ('quantileInterpolatedWeighted', 'MergeState'), 'entropyMergeState': ('entropy', 'MergeState'), 'studentTTestMergeState': ('studentTTest', 'MergeState'), 'stochasticLogisticRegressionMergeState': ('stochasticLogisticRegression', 'MergeState'), 'uniqMergeState': ('uniq', 'MergeState'), 'uniqUpToMergeState': ('uniqUpTo', 'MergeState'), 'groupBitOrMergeState': ('groupBitOr', 'MergeState'), 'groupArrayMovingSumMergeState': ('groupArrayMovingSum', 'MergeState'), 'skewSampMergeState': ('skewSamp', 'MergeState'), 'groupBitmapOrMergeState': ('groupBitmapOr', 'MergeState'), 'avgMergeState': ('avg', 'MergeState'), 'sequenceCountMergeState': ('sequenceCount', 'MergeState'), 'skewPopMergeState': ('skewPop', 'MergeState'), 'groupArrayInsertAtMergeState': ('groupArrayInsertAt', 'MergeState'), 'anyLastMergeState': ('anyLast', 'MergeState'), 'deltaSumTimestampMergeState': ('deltaSumTimestamp', 'MergeState'), 'groupArrayMovingAvgMergeState': ('groupArrayMovingAvg', 'MergeState'), 'categoricalInformationValueMergeState': ('categoricalInformationValue', 'MergeState'), 'mannWhitneyUTestMergeState': ('mannWhitneyUTest', 'MergeState'), 'quantileExactWeightedMergeState': ('quantileExactWeighted', 'MergeState'), 'sumMergeState': ('sum', 'MergeState'), 'groupArrayMergeState': ('groupArray', 'MergeState'), 'theilsUMergeState': ('theilsU', 'MergeState'), 'varSampMergeState': ('varSamp', 'MergeState'), 'quantileMergeState': ('quantile', 'MergeState'), 'anyMergeState': ('any', 'MergeState'), 'quantileExactMergeState': ('quantileExact', 'MergeState'), 'uniqCombinedMergeState': ('uniqCombined', 'MergeState'), 'quantilesTDigestWeightedMergeState': ('quantilesTDigestWeighted', 'MergeState'), 'quantileExactLowMergeState': ('quantileExactLow', 'MergeState'), 'uniqThetaMergeState': ('uniqTheta', 'MergeState'), 'simpleLinearRegressionMergeState': ('simpleLinearRegression', 'MergeState'), 'avgWeightedMergeState': ('avgWeighted', 'MergeState'), 'stddevSampMergeState': ('stddevSamp', 'MergeState'), 'sequenceNextNodeMergeState': ('sequenceNextNode', 'MergeState'), 'sumCountMergeState': ('sumCount', 'MergeState'), 'quantileTimingMergeState': ('quantileTiming', 'MergeState'), 'first_valueMergeState': ('first_value', 'MergeState'), 'maxMapMergeState': ('maxMap', 'MergeState'), 'groupBitmapXorMergeState': ('groupBitmapXor', 'MergeState'), 'quantilesExactLowMergeState': ('quantilesExactLow', 'MergeState'), 'stddevPopMergeState': ('stddevPop', 'MergeState'), 'argMaxMergeState': ('argMax', 'MergeState'), 'corrMergeState': ('corr', 'MergeState'), 'groupBitmapMergeState': ('groupBitmap', 'MergeState'), 'sparkBarMergeState': ('sparkBar', 'MergeState'), 'covarPopMergeState': ('covarPop', 'MergeState'), 'quantileTDigestWeightedMergeState': ('quantileTDigestWeighted', 'MergeState'), 'quantilesMergeState': ('quantiles', 'MergeState'), 'quantilesDeterministicMergeState': ('quantilesDeterministic', 'MergeState'), 'cramersVBiasCorrectedMergeState': ('cramersVBiasCorrected', 'MergeState'), 'anyHeavyMergeState': ('anyHeavy', 'MergeState'), 'countMergeState': ('count', 'MergeState'), 'quantileTDigestMergeState': ('quantileTDigest', 'MergeState'), 'rankCorrMergeState': ('rankCorr', 'MergeState'), 'uniqExactMergeState': ('uniqExact', 'MergeState'), 'quantilesTDigestMergeState': ('quantilesTDigest', 'MergeState'), 'quantilesInterpolatedWeightedMergeState': ('quantilesInterpolatedWeighted', 'MergeState'), 'groupBitmapAndMergeState': ('groupBitmapAnd', 'MergeState'), 'stochasticLinearRegressionMergeState': ('stochasticLinearRegression', 'MergeState'), 'quantileDeterministicMergeState': ('quantileDeterministic', 'MergeState'), 'covarSampMergeState': ('covarSamp', 'MergeState'), 'kurtSampMergeState': ('kurtSamp', 'MergeState'), 'sumKahanMergeState': ('sumKahan', 'MergeState'), 'quantileExactHighMergeState': ('quantileExactHigh', 'MergeState'), 'groupUniqArrayMergeState': ('groupUniqArray', 'MergeState'), 'meanZTestMergeState': ('meanZTest', 'MergeState'), 'quantilesExactHighMergeState': ('quantilesExactHigh', 'MergeState'), 'exponentialMovingAverageMergeState': ('exponentialMovingAverage', 'MergeState'), 'groupArraySampleMergeState': ('groupArraySample', 'MergeState'), 'groupBitAndMergeState': ('groupBitAnd', 'MergeState'), 'quantileBFloat16MergeState': ('quantileBFloat16', 'MergeState'), 'topKWeightedMergeState': ('topKWeighted', 'MergeState'), 'quantilesBFloat16MergeState': ('quantilesBFloat16', 'MergeState'), 'quantilesTimingWeightedMergeState': ('quantilesTimingWeighted', 'MergeState'), 'quantilesGKMergeState': ('quantilesGK', 'MergeState'), 'quantileGKMergeState': ('quantileGK', 'MergeState'), 'groupBitXorMergeState': ('groupBitXor', 'MergeState'), 'kolmogorovSmirnovTestMergeState': ('kolmogorovSmirnovTest', 'MergeState'), 'largestTriangleThreeBucketsMergeState': ('largestTriangleThreeBuckets', 'MergeState'), 'maxMergeState': ('max', 'MergeState'), 'maxIntersectionsPositionMergeState': ('maxIntersectionsPosition', 'MergeState'), 'retentionMergeState': ('retention', 'MergeState'), 'sumMapMergeState': ('sumMap', 'MergeState'), 'argMinMergeState': ('argMin', 'MergeState'), 'kurtPopForEach': ('kurtPop', 'ForEach'), 'quantilesExactWeightedForEach': ('quantilesExactWeighted', 'ForEach'), 'quantilesExactForEach': ('quantilesExact', 'ForEach'), 'groupArrayLastForEach': ('groupArrayLast', 'ForEach'), 'minForEach': ('min', 'ForEach'), 'intervalLengthSumForEach': ('intervalLengthSum', 'ForEach'), 'exponentialTimeDecayedAvgForEach': ('exponentialTimeDecayedAvg', 'ForEach'), 'windowFunnelForEach': ('windowFunnel', 'ForEach'), 'quantilesBFloat16WeightedForEach': ('quantilesBFloat16Weighted', 'ForEach'), 'last_valueForEach': ('last_value', 'ForEach'), 'histogramForEach': ('histogram', 'ForEach'), 'maxIntersectionsForEach': ('maxIntersections', 'ForEach'), 'uniqCombined64ForEach': ('uniqCombined64', 'ForEach'), 'minMapForEach': ('minMap', 'ForEach'), 'sequenceMatchForEach': ('sequenceMatch', 'ForEach'), 'quantilesTimingForEach': ('quantilesTiming', 'ForEach'), 'medianForEach': ('median', 'ForEach'), 'sumWithOverflowForEach': ('sumWithOverflow', 'ForEach'), 'uniqHLL12ForEach': ('uniqHLL12', 'ForEach'), 'contingencyForEach': ('contingency', 'ForEach'), 'quantileTimingWeightedForEach': ('quantileTimingWeighted', 'ForEach'), 'topKForEach': ('topK', 'ForEach'), 'cramersVForEach': ('cramersV', 'ForEach'), 'deltaSumForEach': ('deltaSum', 'ForEach'), 'varPopForEach': ('varPop', 'ForEach'), 'boundingRatioForEach': ('boundingRatio', 'ForEach'), 'welchTTestForEach': ('welchTTest', 'ForEach'), 'quantileBFloat16WeightedForEach': ('quantileBFloat16Weighted', 'ForEach'), 'quantileInterpolatedWeightedForEach': ('quantileInterpolatedWeighted', 'ForEach'), 'entropyForEach': ('entropy', 'ForEach'), 'studentTTestForEach': ('studentTTest', 'ForEach'), 'stochasticLogisticRegressionForEach': ('stochasticLogisticRegression', 'ForEach'), 'uniqForEach': ('uniq', 'ForEach'), 'uniqUpToForEach': ('uniqUpTo', 'ForEach'), 'groupBitOrForEach': ('groupBitOr', 'ForEach'), 'groupArrayMovingSumForEach': ('groupArrayMovingSum', 'ForEach'), 'skewSampForEach': ('skewSamp', 'ForEach'), 'groupBitmapOrForEach': ('groupBitmapOr', 'ForEach'), 'avgForEach': ('avg', 'ForEach'), 'sequenceCountForEach': ('sequenceCount', 'ForEach'), 'skewPopForEach': ('skewPop', 'ForEach'), 'groupArrayInsertAtForEach': ('groupArrayInsertAt', 'ForEach'), 'anyLastForEach': ('anyLast', 'ForEach'), 'deltaSumTimestampForEach': ('deltaSumTimestamp', 'ForEach'), 'groupArrayMovingAvgForEach': ('groupArrayMovingAvg', 'ForEach'), 'categoricalInformationValueForEach': ('categoricalInformationValue', 'ForEach'), 'mannWhitneyUTestForEach': ('mannWhitneyUTest', 'ForEach'), 'quantileExactWeightedForEach': ('quantileExactWeighted', 'ForEach'), 'sumForEach': ('sum', 'ForEach'), 'groupArrayForEach': ('groupArray', 'ForEach'), 'theilsUForEach': ('theilsU', 'ForEach'), 'varSampForEach': ('varSamp', 'ForEach'), 'quantileForEach': ('quantile', 'ForEach'), 'anyForEach': ('any', 'ForEach'), 'quantileExactForEach': ('quantileExact', 'ForEach'), 'uniqCombinedForEach': ('uniqCombined', 'ForEach'), 'quantilesTDigestWeightedForEach': ('quantilesTDigestWeighted', 'ForEach'), 'quantileExactLowForEach': ('quantileExactLow', 'ForEach'), 'uniqThetaForEach': ('uniqTheta', 'ForEach'), 'simpleLinearRegressionForEach': ('simpleLinearRegression', 'ForEach'), 'avgWeightedForEach': ('avgWeighted', 'ForEach'), 'stddevSampForEach': ('stddevSamp', 'ForEach'), 'sequenceNextNodeForEach': ('sequenceNextNode', 'ForEach'), 'sumCountForEach': ('sumCount', 'ForEach'), 'quantileTimingForEach': ('quantileTiming', 'ForEach'), 'first_valueForEach': ('first_value', 'ForEach'), 'maxMapForEach': ('maxMap', 'ForEach'), 'groupBitmapXorForEach': ('groupBitmapXor', 'ForEach'), 'quantilesExactLowForEach': ('quantilesExactLow', 'ForEach'), 'stddevPopForEach': ('stddevPop', 'ForEach'), 'argMaxForEach': ('argMax', 'ForEach'), 'corrForEach': ('corr', 'ForEach'), 'groupBitmapForEach': ('groupBitmap', 'ForEach'), 'sparkBarForEach': ('sparkBar', 'ForEach'), 'covarPopForEach': ('covarPop', 'ForEach'), 'quantileTDigestWeightedForEach': ('quantileTDigestWeighted', 'ForEach'), 'quantilesForEach': ('quantiles', 'ForEach'), 'quantilesDeterministicForEach': ('quantilesDeterministic', 'ForEach'), 'cramersVBiasCorrectedForEach': ('cramersVBiasCorrected', 'ForEach'), 'anyHeavyForEach': ('anyHeavy', 'ForEach'), 'countForEach': ('count', 'ForEach'), 'quantileTDigestForEach': ('quantileTDigest', 'ForEach'), 'rankCorrForEach': ('rankCorr', 'ForEach'), 'uniqExactForEach': ('uniqExact', 'ForEach'), 'quantilesTDigestForEach': ('quantilesTDigest', 'ForEach'), 'quantilesInterpolatedWeightedForEach': ('quantilesInterpolatedWeighted', 'ForEach'), 'groupBitmapAndForEach': ('groupBitmapAnd', 'ForEach'), 'stochasticLinearRegressionForEach': ('stochasticLinearRegression', 'ForEach'), 'quantileDeterministicForEach': ('quantileDeterministic', 'ForEach'), 'covarSampForEach': ('covarSamp', 'ForEach'), 'kurtSampForEach': ('kurtSamp', 'ForEach'), 'sumKahanForEach': ('sumKahan', 'ForEach'), 'quantileExactHighForEach': ('quantileExactHigh', 'ForEach'), 'groupUniqArrayForEach': ('groupUniqArray', 'ForEach'), 'meanZTestForEach': ('meanZTest', 'ForEach'), 'quantilesExactHighForEach': ('quantilesExactHigh', 'ForEach'), 'exponentialMovingAverageForEach': ('exponentialMovingAverage', 'ForEach'), 'groupArraySampleForEach': ('groupArraySample', 'ForEach'), 'groupBitAndForEach': ('groupBitAnd', 'ForEach'), 'quantileBFloat16ForEach': ('quantileBFloat16', 'ForEach'), 'topKWeightedForEach': ('topKWeighted', 'ForEach'), 'quantilesBFloat16ForEach': ('quantilesBFloat16', 'ForEach'), 'quantilesTimingWeightedForEach': ('quantilesTimingWeighted', 'ForEach'), 'quantilesGKForEach': ('quantilesGK', 'ForEach'), 'quantileGKForEach': ('quantileGK', 'ForEach'), 'groupBitXorForEach': ('groupBitXor', 'ForEach'), 'kolmogorovSmirnovTestForEach': ('kolmogorovSmirnovTest', 'ForEach'), 'largestTriangleThreeBucketsForEach': ('largestTriangleThreeBuckets', 'ForEach'), 'maxForEach': ('max', 'ForEach'), 'maxIntersectionsPositionForEach': ('maxIntersectionsPosition', 'ForEach'), 'retentionForEach': ('retention', 'ForEach'), 'sumMapForEach': ('sumMap', 'ForEach'), 'argMinForEach': ('argMin', 'ForEach'), 'kurtPopDistinct': ('kurtPop', 'Distinct'), 'quantilesExactWeightedDistinct': ('quantilesExactWeighted', 'Distinct'), 'quantilesExactDistinct': ('quantilesExact', 'Distinct'), 'groupArrayLastDistinct': ('groupArrayLast', 'Distinct'), 'minDistinct': ('min', 'Distinct'), 'intervalLengthSumDistinct': ('intervalLengthSum', 'Distinct'), 'exponentialTimeDecayedAvgDistinct': ('exponentialTimeDecayedAvg', 'Distinct'), 'windowFunnelDistinct': ('windowFunnel', 'Distinct'), 'quantilesBFloat16WeightedDistinct': ('quantilesBFloat16Weighted', 'Distinct'), 'last_valueDistinct': ('last_value', 'Distinct'), 'histogramDistinct': ('histogram', 'Distinct'), 'maxIntersectionsDistinct': ('maxIntersections', 'Distinct'), 'uniqCombined64Distinct': ('uniqCombined64', 'Distinct'), 'minMapDistinct': ('minMap', 'Distinct'), 'sequenceMatchDistinct': ('sequenceMatch', 'Distinct'), 'quantilesTimingDistinct': ('quantilesTiming', 'Distinct'), 'medianDistinct': ('median', 'Distinct'), 'sumWithOverflowDistinct': ('sumWithOverflow', 'Distinct'), 'uniqHLL12Distinct': ('uniqHLL12', 'Distinct'), 'contingencyDistinct': ('contingency', 'Distinct'), 'quantileTimingWeightedDistinct': ('quantileTimingWeighted', 'Distinct'), 'topKDistinct': ('topK', 'Distinct'), 'cramersVDistinct': ('cramersV', 'Distinct'), 'deltaSumDistinct': ('deltaSum', 'Distinct'), 'varPopDistinct': ('varPop', 'Distinct'), 'boundingRatioDistinct': ('boundingRatio', 'Distinct'), 'welchTTestDistinct': ('welchTTest', 'Distinct'), 'quantileBFloat16WeightedDistinct': ('quantileBFloat16Weighted', 'Distinct'), 'quantileInterpolatedWeightedDistinct': ('quantileInterpolatedWeighted', 'Distinct'), 'entropyDistinct': ('entropy', 'Distinct'), 'studentTTestDistinct': ('studentTTest', 'Distinct'), 'stochasticLogisticRegressionDistinct': ('stochasticLogisticRegression', 'Distinct'), 'uniqDistinct': ('uniq', 'Distinct'), 'uniqUpToDistinct': ('uniqUpTo', 'Distinct'), 'groupBitOrDistinct': ('groupBitOr', 'Distinct'), 'groupArrayMovingSumDistinct': ('groupArrayMovingSum', 'Distinct'), 'skewSampDistinct': ('skewSamp', 'Distinct'), 'groupBitmapOrDistinct': ('groupBitmapOr', 'Distinct'), 'avgDistinct': ('avg', 'Distinct'), 'sequenceCountDistinct': ('sequenceCount', 'Distinct'), 'skewPopDistinct': ('skewPop', 'Distinct'), 'groupArrayInsertAtDistinct': ('groupArrayInsertAt', 'Distinct'), 'anyLastDistinct': ('anyLast', 'Distinct'), 'deltaSumTimestampDistinct': ('deltaSumTimestamp', 'Distinct'), 'groupArrayMovingAvgDistinct': ('groupArrayMovingAvg', 'Distinct'), 'categoricalInformationValueDistinct': ('categoricalInformationValue', 'Distinct'), 'mannWhitneyUTestDistinct': ('mannWhitneyUTest', 'Distinct'), 'quantileExactWeightedDistinct': ('quantileExactWeighted', 'Distinct'), 'sumDistinct': ('sum', 'Distinct'), 'groupArrayDistinct': ('groupArray', 'Distinct'), 'theilsUDistinct': ('theilsU', 'Distinct'), 'varSampDistinct': ('varSamp', 'Distinct'), 'quantileDistinct': ('quantile', 'Distinct'), 'anyDistinct': ('any', 'Distinct'), 'quantileExactDistinct': ('quantileExact', 'Distinct'), 'uniqCombinedDistinct': ('uniqCombined', 'Distinct'), 'quantilesTDigestWeightedDistinct': ('quantilesTDigestWeighted', 'Distinct'), 'quantileExactLowDistinct': ('quantileExactLow', 'Distinct'), 'uniqThetaDistinct': ('uniqTheta', 'Distinct'), 'simpleLinearRegressionDistinct': ('simpleLinearRegression', 'Distinct'), 'avgWeightedDistinct': ('avgWeighted', 'Distinct'), 'stddevSampDistinct': ('stddevSamp', 'Distinct'), 'sequenceNextNodeDistinct': ('sequenceNextNode', 'Distinct'), 'sumCountDistinct': ('sumCount', 'Distinct'), 'quantileTimingDistinct': ('quantileTiming', 'Distinct'), 'first_valueDistinct': ('first_value', 'Distinct'), 'maxMapDistinct': ('maxMap', 'Distinct'), 'groupBitmapXorDistinct': ('groupBitmapXor', 'Distinct'), 'quantilesExactLowDistinct': ('quantilesExactLow', 'Distinct'), 'stddevPopDistinct': ('stddevPop', 'Distinct'), 'argMaxDistinct': ('argMax', 'Distinct'), 'corrDistinct': ('corr', 'Distinct'), 'groupBitmapDistinct': ('groupBitmap', 'Distinct'), 'sparkBarDistinct': ('sparkBar', 'Distinct'), 'covarPopDistinct': ('covarPop', 'Distinct'), 'quantileTDigestWeightedDistinct': ('quantileTDigestWeighted', 'Distinct'), 'quantilesDistinct': ('quantiles', 'Distinct'), 'quantilesDeterministicDistinct': ('quantilesDeterministic', 'Distinct'), 'cramersVBiasCorrectedDistinct': ('cramersVBiasCorrected', 'Distinct'), 'anyHeavyDistinct': ('anyHeavy', 'Distinct'), 'countDistinct': ('count', 'Distinct'), 'quantileTDigestDistinct': ('quantileTDigest', 'Distinct'), 'rankCorrDistinct': ('rankCorr', 'Distinct'), 'uniqExactDistinct': ('uniqExact', 'Distinct'), 'quantilesTDigestDistinct': ('quantilesTDigest', 'Distinct'), 'quantilesInterpolatedWeightedDistinct': ('quantilesInterpolatedWeighted', 'Distinct'), 'groupBitmapAndDistinct': ('groupBitmapAnd', 'Distinct'), 'stochasticLinearRegressionDistinct': ('stochasticLinearRegression', 'Distinct'), 'quantileDeterministicDistinct': ('quantileDeterministic', 'Distinct'), 'covarSampDistinct': ('covarSamp', 'Distinct'), 'kurtSampDistinct': ('kurtSamp', 'Distinct'), 'sumKahanDistinct': ('sumKahan', 'Distinct'), 'quantileExactHighDistinct': ('quantileExactHigh', 'Distinct'), 'groupUniqArrayDistinct': ('groupUniqArray', 'Distinct'), 'meanZTestDistinct': ('meanZTest', 'Distinct'), 'quantilesExactHighDistinct': ('quantilesExactHigh', 'Distinct'), 'exponentialMovingAverageDistinct': ('exponentialMovingAverage', 'Distinct'), 'groupArraySampleDistinct': ('groupArraySample', 'Distinct'), 'groupBitAndDistinct': ('groupBitAnd', 'Distinct'), 'quantileBFloat16Distinct': ('quantileBFloat16', 'Distinct'), 'topKWeightedDistinct': ('topKWeighted', 'Distinct'), 'quantilesBFloat16Distinct': ('quantilesBFloat16', 'Distinct'), 'quantilesTimingWeightedDistinct': ('quantilesTimingWeighted', 'Distinct'), 'quantilesGKDistinct': ('quantilesGK', 'Distinct'), 'quantileGKDistinct': ('quantileGK', 'Distinct'), 'groupBitXorDistinct': ('groupBitXor', 'Distinct'), 'kolmogorovSmirnovTestDistinct': ('kolmogorovSmirnovTest', 'Distinct'), 'largestTriangleThreeBucketsDistinct': ('largestTriangleThreeBuckets', 'Distinct'), 'maxDistinct': ('max', 'Distinct'), 'maxIntersectionsPositionDistinct': ('maxIntersectionsPosition', 'Distinct'), 'retentionDistinct': ('retention', 'Distinct'), 'sumMapDistinct': ('sumMap', 'Distinct'), 'argMinDistinct': ('argMin', 'Distinct'), 'kurtPopOrDefault': ('kurtPop', 'OrDefault'), 'quantilesExactWeightedOrDefault': ('quantilesExactWeighted', 'OrDefault'), 'quantilesExactOrDefault': ('quantilesExact', 'OrDefault'), 'groupArrayLastOrDefault': ('groupArrayLast', 'OrDefault'), 'minOrDefault': ('min', 'OrDefault'), 'intervalLengthSumOrDefault': ('intervalLengthSum', 'OrDefault'), 'exponentialTimeDecayedAvgOrDefault': ('exponentialTimeDecayedAvg', 'OrDefault'), 'windowFunnelOrDefault': ('windowFunnel', 'OrDefault'), 'quantilesBFloat16WeightedOrDefault': ('quantilesBFloat16Weighted', 'OrDefault'), 'last_valueOrDefault': ('last_value', 'OrDefault'), 'histogramOrDefault': ('histogram', 'OrDefault'), 'maxIntersectionsOrDefault': ('maxIntersections', 'OrDefault'), 'uniqCombined64OrDefault': ('uniqCombined64', 'OrDefault'), 'minMapOrDefault': ('minMap', 'OrDefault'), 'sequenceMatchOrDefault': ('sequenceMatch', 'OrDefault'), 'quantilesTimingOrDefault': ('quantilesTiming', 'OrDefault'), 'medianOrDefault': ('median', 'OrDefault'), 'sumWithOverflowOrDefault': ('sumWithOverflow', 'OrDefault'), 'uniqHLL12OrDefault': ('uniqHLL12', 'OrDefault'), 'contingencyOrDefault': ('contingency', 'OrDefault'), 'quantileTimingWeightedOrDefault': ('quantileTimingWeighted', 'OrDefault'), 'topKOrDefault': ('topK', 'OrDefault'), 'cramersVOrDefault': ('cramersV', 'OrDefault'), 'deltaSumOrDefault': ('deltaSum', 'OrDefault'), 'varPopOrDefault': ('varPop', 'OrDefault'), 'boundingRatioOrDefault': ('boundingRatio', 'OrDefault'), 'welchTTestOrDefault': ('welchTTest', 'OrDefault'), 'quantileBFloat16WeightedOrDefault': ('quantileBFloat16Weighted', 'OrDefault'), 'quantileInterpolatedWeightedOrDefault': ('quantileInterpolatedWeighted', 'OrDefault'), 'entropyOrDefault': ('entropy', 'OrDefault'), 'studentTTestOrDefault': ('studentTTest', 'OrDefault'), 'stochasticLogisticRegressionOrDefault': ('stochasticLogisticRegression', 'OrDefault'), 'uniqOrDefault': ('uniq', 'OrDefault'), 'uniqUpToOrDefault': ('uniqUpTo', 'OrDefault'), 'groupBitOrOrDefault': ('groupBitOr', 'OrDefault'), 'groupArrayMovingSumOrDefault': ('groupArrayMovingSum', 'OrDefault'), 'skewSampOrDefault': ('skewSamp', 'OrDefault'), 'groupBitmapOrOrDefault': ('groupBitmapOr', 'OrDefault'), 'avgOrDefault': ('avg', 'OrDefault'), 'sequenceCountOrDefault': ('sequenceCount', 'OrDefault'), 'skewPopOrDefault': ('skewPop', 'OrDefault'), 'groupArrayInsertAtOrDefault': ('groupArrayInsertAt', 'OrDefault'), 'anyLastOrDefault': ('anyLast', 'OrDefault'), 'deltaSumTimestampOrDefault': ('deltaSumTimestamp', 'OrDefault'), 'groupArrayMovingAvgOrDefault': ('groupArrayMovingAvg', 'OrDefault'), 'categoricalInformationValueOrDefault': ('categoricalInformationValue', 'OrDefault'), 'mannWhitneyUTestOrDefault': ('mannWhitneyUTest', 'OrDefault'), 'quantileExactWeightedOrDefault': ('quantileExactWeighted', 'OrDefault'), 'sumOrDefault': ('sum', 'OrDefault'), 'groupArrayOrDefault': ('groupArray', 'OrDefault'), 'theilsUOrDefault': ('theilsU', 'OrDefault'), 'varSampOrDefault': ('varSamp', 'OrDefault'), 'quantileOrDefault': ('quantile', 'OrDefault'), 'anyOrDefault': ('any', 'OrDefault'), 'quantileExactOrDefault': ('quantileExact', 'OrDefault'), 'uniqCombinedOrDefault': ('uniqCombined', 'OrDefault'), 'quantilesTDigestWeightedOrDefault': ('quantilesTDigestWeighted', 'OrDefault'), 'quantileExactLowOrDefault': ('quantileExactLow', 'OrDefault'), 'uniqThetaOrDefault': ('uniqTheta', 'OrDefault'), 'simpleLinearRegressionOrDefault': ('simpleLinearRegression', 'OrDefault'), 'avgWeightedOrDefault': ('avgWeighted', 'OrDefault'), 'stddevSampOrDefault': ('stddevSamp', 'OrDefault'), 'sequenceNextNodeOrDefault': ('sequenceNextNode', 'OrDefault'), 'sumCountOrDefault': ('sumCount', 'OrDefault'), 'quantileTimingOrDefault': ('quantileTiming', 'OrDefault'), 'first_valueOrDefault': ('first_value', 'OrDefault'), 'maxMapOrDefault': ('maxMap', 'OrDefault'), 'groupBitmapXorOrDefault': ('groupBitmapXor', 'OrDefault'), 'quantilesExactLowOrDefault': ('quantilesExactLow', 'OrDefault'), 'stddevPopOrDefault': ('stddevPop', 'OrDefault'), 'argMaxOrDefault': ('argMax', 'OrDefault'), 'corrOrDefault': ('corr', 'OrDefault'), 'groupBitmapOrDefault': ('groupBitmap', 'OrDefault'), 'sparkBarOrDefault': ('sparkBar', 'OrDefault'), 'covarPopOrDefault': ('covarPop', 'OrDefault'), 'quantileTDigestWeightedOrDefault': ('quantileTDigestWeighted', 'OrDefault'), 'quantilesOrDefault': ('quantiles', 'OrDefault'), 'quantilesDeterministicOrDefault': ('quantilesDeterministic', 'OrDefault'), 'cramersVBiasCorrectedOrDefault': ('cramersVBiasCorrected', 'OrDefault'), 'anyHeavyOrDefault': ('anyHeavy', 'OrDefault'), 'countOrDefault': ('count', 'OrDefault'), 'quantileTDigestOrDefault': ('quantileTDigest', 'OrDefault'), 'rankCorrOrDefault': ('rankCorr', 'OrDefault'), 'uniqExactOrDefault': ('uniqExact', 'OrDefault'), 'quantilesTDigestOrDefault': ('quantilesTDigest', 'OrDefault'), 'quantilesInterpolatedWeightedOrDefault': ('quantilesInterpolatedWeighted', 'OrDefault'), 'groupBitmapAndOrDefault': ('groupBitmapAnd', 'OrDefault'), 'stochasticLinearRegressionOrDefault': ('stochasticLinearRegression', 'OrDefault'), 'quantileDeterministicOrDefault': ('quantileDeterministic', 'OrDefault'), 'covarSampOrDefault': ('covarSamp', 'OrDefault'), 'kurtSampOrDefault': ('kurtSamp', 'OrDefault'), 'sumKahanOrDefault': ('sumKahan', 'OrDefault'), 'quantileExactHighOrDefault': ('quantileExactHigh', 'OrDefault'), 'groupUniqArrayOrDefault': ('groupUniqArray', 'OrDefault'), 'meanZTestOrDefault': ('meanZTest', 'OrDefault'), 'quantilesExactHighOrDefault': ('quantilesExactHigh', 'OrDefault'), 'exponentialMovingAverageOrDefault': ('exponentialMovingAverage', 'OrDefault'), 'groupArraySampleOrDefault': ('groupArraySample', 'OrDefault'), 'groupBitAndOrDefault': ('groupBitAnd', 'OrDefault'), 'quantileBFloat16OrDefault': ('quantileBFloat16', 'OrDefault'), 'topKWeightedOrDefault': ('topKWeighted', 'OrDefault'), 'quantilesBFloat16OrDefault': ('quantilesBFloat16', 'OrDefault'), 'quantilesTimingWeightedOrDefault': ('quantilesTimingWeighted', 'OrDefault'), 'quantilesGKOrDefault': ('quantilesGK', 'OrDefault'), 'quantileGKOrDefault': ('quantileGK', 'OrDefault'), 'groupBitXorOrDefault': ('groupBitXor', 'OrDefault'), 'kolmogorovSmirnovTestOrDefault': ('kolmogorovSmirnovTest', 'OrDefault'), 'largestTriangleThreeBucketsOrDefault': ('largestTriangleThreeBuckets', 'OrDefault'), 'maxOrDefault': ('max', 'OrDefault'), 'maxIntersectionsPositionOrDefault': ('maxIntersectionsPosition', 'OrDefault'), 'retentionOrDefault': ('retention', 'OrDefault'), 'sumMapOrDefault': ('sumMap', 'OrDefault'), 'argMinOrDefault': ('argMin', 'OrDefault'), 'kurtPopOrNull': ('kurtPop', 'OrNull'), 'quantilesExactWeightedOrNull': ('quantilesExactWeighted', 'OrNull'), 'quantilesExactOrNull': ('quantilesExact', 'OrNull'), 'groupArrayLastOrNull': ('groupArrayLast', 'OrNull'), 'minOrNull': ('min', 'OrNull'), 'intervalLengthSumOrNull': ('intervalLengthSum', 'OrNull'), 'exponentialTimeDecayedAvgOrNull': ('exponentialTimeDecayedAvg', 'OrNull'), 'windowFunnelOrNull': ('windowFunnel', 'OrNull'), 'quantilesBFloat16WeightedOrNull': ('quantilesBFloat16Weighted', 'OrNull'), 'last_valueOrNull': ('last_value', 'OrNull'), 'histogramOrNull': ('histogram', 'OrNull'), 'maxIntersectionsOrNull': ('maxIntersections', 'OrNull'), 'uniqCombined64OrNull': ('uniqCombined64', 'OrNull'), 'minMapOrNull': ('minMap', 'OrNull'), 'sequenceMatchOrNull': ('sequenceMatch', 'OrNull'), 'quantilesTimingOrNull': ('quantilesTiming', 'OrNull'), 'medianOrNull': ('median', 'OrNull'), 'sumWithOverflowOrNull': ('sumWithOverflow', 'OrNull'), 'uniqHLL12OrNull': ('uniqHLL12', 'OrNull'), 'contingencyOrNull': ('contingency', 'OrNull'), 'quantileTimingWeightedOrNull': ('quantileTimingWeighted', 'OrNull'), 'topKOrNull': ('topK', 'OrNull'), 'cramersVOrNull': ('cramersV', 'OrNull'), 'deltaSumOrNull': ('deltaSum', 'OrNull'), 'varPopOrNull': ('varPop', 'OrNull'), 'boundingRatioOrNull': ('boundingRatio', 'OrNull'), 'welchTTestOrNull': ('welchTTest', 'OrNull'), 'quantileBFloat16WeightedOrNull': ('quantileBFloat16Weighted', 'OrNull'), 'quantileInterpolatedWeightedOrNull': ('quantileInterpolatedWeighted', 'OrNull'), 'entropyOrNull': ('entropy', 'OrNull'), 'studentTTestOrNull': ('studentTTest', 'OrNull'), 'stochasticLogisticRegressionOrNull': ('stochasticLogisticRegression', 'OrNull'), 'uniqOrNull': ('uniq', 'OrNull'), 'uniqUpToOrNull': ('uniqUpTo', 'OrNull'), 'groupBitOrOrNull': ('groupBitOr', 'OrNull'), 'groupArrayMovingSumOrNull': ('groupArrayMovingSum', 'OrNull'), 'skewSampOrNull': ('skewSamp', 'OrNull'), 'groupBitmapOrOrNull': ('groupBitmapOr', 'OrNull'), 'avgOrNull': ('avg', 'OrNull'), 'sequenceCountOrNull': ('sequenceCount', 'OrNull'), 'skewPopOrNull': ('skewPop', 'OrNull'), 'groupArrayInsertAtOrNull': ('groupArrayInsertAt', 'OrNull'), 'anyLastOrNull': ('anyLast', 'OrNull'), 'deltaSumTimestampOrNull': ('deltaSumTimestamp', 'OrNull'), 'groupArrayMovingAvgOrNull': ('groupArrayMovingAvg', 'OrNull'), 'categoricalInformationValueOrNull': ('categoricalInformationValue', 'OrNull'), 'mannWhitneyUTestOrNull': ('mannWhitneyUTest', 'OrNull'), 'quantileExactWeightedOrNull': ('quantileExactWeighted', 'OrNull'), 'sumOrNull': ('sum', 'OrNull'), 'groupArrayOrNull': ('groupArray', 'OrNull'), 'theilsUOrNull': ('theilsU', 'OrNull'), 'varSampOrNull': ('varSamp', 'OrNull'), 'quantileOrNull': ('quantile', 'OrNull'), 'anyOrNull': ('any', 'OrNull'), 'quantileExactOrNull': ('quantileExact', 'OrNull'), 'uniqCombinedOrNull': ('uniqCombined', 'OrNull'), 'quantilesTDigestWeightedOrNull': ('quantilesTDigestWeighted', 'OrNull'), 'quantileExactLowOrNull': ('quantileExactLow', 'OrNull'), 'uniqThetaOrNull': ('uniqTheta', 'OrNull'), 'simpleLinearRegressionOrNull': ('simpleLinearRegression', 'OrNull'), 'avgWeightedOrNull': ('avgWeighted', 'OrNull'), 'stddevSampOrNull': ('stddevSamp', 'OrNull'), 'sequenceNextNodeOrNull': ('sequenceNextNode', 'OrNull'), 'sumCountOrNull': ('sumCount', 'OrNull'), 'quantileTimingOrNull': ('quantileTiming', 'OrNull'), 'first_valueOrNull': ('first_value', 'OrNull'), 'maxMapOrNull': ('maxMap', 'OrNull'), 'groupBitmapXorOrNull': ('groupBitmapXor', 'OrNull'), 'quantilesExactLowOrNull': ('quantilesExactLow', 'OrNull'), 'stddevPopOrNull': ('stddevPop', 'OrNull'), 'argMaxOrNull': ('argMax', 'OrNull'), 'corrOrNull': ('corr', 'OrNull'), 'groupBitmapOrNull': ('groupBitmap', 'OrNull'), 'sparkBarOrNull': ('sparkBar', 'OrNull'), 'covarPopOrNull': ('covarPop', 'OrNull'), 'quantileTDigestWeightedOrNull': ('quantileTDigestWeighted', 'OrNull'), 'quantilesOrNull': ('quantiles', 'OrNull'), 'quantilesDeterministicOrNull': ('quantilesDeterministic', 'OrNull'), 'cramersVBiasCorrectedOrNull': ('cramersVBiasCorrected', 'OrNull'), 'anyHeavyOrNull': ('anyHeavy', 'OrNull'), 'countOrNull': ('count', 'OrNull'), 'quantileTDigestOrNull': ('quantileTDigest', 'OrNull'), 'rankCorrOrNull': ('rankCorr', 'OrNull'), 'uniqExactOrNull': ('uniqExact', 'OrNull'), 'quantilesTDigestOrNull': ('quantilesTDigest', 'OrNull'), 'quantilesInterpolatedWeightedOrNull': ('quantilesInterpolatedWeighted', 'OrNull'), 'groupBitmapAndOrNull': ('groupBitmapAnd', 'OrNull'), 'stochasticLinearRegressionOrNull': ('stochasticLinearRegression', 'OrNull'), 'quantileDeterministicOrNull': ('quantileDeterministic', 'OrNull'), 'covarSampOrNull': ('covarSamp', 'OrNull'), 'kurtSampOrNull': ('kurtSamp', 'OrNull'), 'sumKahanOrNull': ('sumKahan', 'OrNull'), 'quantileExactHighOrNull': ('quantileExactHigh', 'OrNull'), 'groupUniqArrayOrNull': ('groupUniqArray', 'OrNull'), 'meanZTestOrNull': ('meanZTest', 'OrNull'), 'quantilesExactHighOrNull': ('quantilesExactHigh', 'OrNull'), 'exponentialMovingAverageOrNull': ('exponentialMovingAverage', 'OrNull'), 'groupArraySampleOrNull': ('groupArraySample', 'OrNull'), 'groupBitAndOrNull': ('groupBitAnd', 'OrNull'), 'quantileBFloat16OrNull': ('quantileBFloat16', 'OrNull'), 'topKWeightedOrNull': ('topKWeighted', 'OrNull'), 'quantilesBFloat16OrNull': ('quantilesBFloat16', 'OrNull'), 'quantilesTimingWeightedOrNull': ('quantilesTimingWeighted', 'OrNull'), 'quantilesGKOrNull': ('quantilesGK', 'OrNull'), 'quantileGKOrNull': ('quantileGK', 'OrNull'), 'groupBitXorOrNull': ('groupBitXor', 'OrNull'), 'kolmogorovSmirnovTestOrNull': ('kolmogorovSmirnovTest', 'OrNull'), 'largestTriangleThreeBucketsOrNull': ('largestTriangleThreeBuckets', 'OrNull'), 'maxOrNull': ('max', 'OrNull'), 'maxIntersectionsPositionOrNull': ('maxIntersectionsPosition', 'OrNull'), 'retentionOrNull': ('retention', 'OrNull'), 'sumMapOrNull': ('sumMap', 'OrNull'), 'argMinOrNull': ('argMin', 'OrNull'), 'kurtPopResample': ('kurtPop', 'Resample'), 'quantilesExactWeightedResample': ('quantilesExactWeighted', 'Resample'), 'quantilesExactResample': ('quantilesExact', 'Resample'), 'groupArrayLastResample': ('groupArrayLast', 'Resample'), 'minResample': ('min', 'Resample'), 'intervalLengthSumResample': ('intervalLengthSum', 'Resample'), 'exponentialTimeDecayedAvgResample': ('exponentialTimeDecayedAvg', 'Resample'), 'windowFunnelResample': ('windowFunnel', 'Resample'), 'quantilesBFloat16WeightedResample': ('quantilesBFloat16Weighted', 'Resample'), 'last_valueResample': ('last_value', 'Resample'), 'histogramResample': ('histogram', 'Resample'), 'maxIntersectionsResample': ('maxIntersections', 'Resample'), 'uniqCombined64Resample': ('uniqCombined64', 'Resample'), 'minMapResample': ('minMap', 'Resample'), 'sequenceMatchResample': ('sequenceMatch', 'Resample'), 'quantilesTimingResample': ('quantilesTiming', 'Resample'), 'medianResample': ('median', 'Resample'), 'sumWithOverflowResample': ('sumWithOverflow', 'Resample'), 'uniqHLL12Resample': ('uniqHLL12', 'Resample'), 'contingencyResample': ('contingency', 'Resample'), 'quantileTimingWeightedResample': ('quantileTimingWeighted', 'Resample'), 'topKResample': ('topK', 'Resample'), 'cramersVResample': ('cramersV', 'Resample'), 'deltaSumResample': ('deltaSum', 'Resample'), 'varPopResample': ('varPop', 'Resample'), 'boundingRatioResample': ('boundingRatio', 'Resample'), 'welchTTestResample': ('welchTTest', 'Resample'), 'quantileBFloat16WeightedResample': ('quantileBFloat16Weighted', 'Resample'), 'quantileInterpolatedWeightedResample': ('quantileInterpolatedWeighted', 'Resample'), 'entropyResample': ('entropy', 'Resample'), 'studentTTestResample': ('studentTTest', 'Resample'), 'stochasticLogisticRegressionResample': ('stochasticLogisticRegression', 'Resample'), 'uniqResample': ('uniq', 'Resample'), 'uniqUpToResample': ('uniqUpTo', 'Resample'), 'groupBitOrResample': ('groupBitOr', 'Resample'), 'groupArrayMovingSumResample': ('groupArrayMovingSum', 'Resample'), 'skewSampResample': ('skewSamp', 'Resample'), 'groupBitmapOrResample': ('groupBitmapOr', 'Resample'), 'avgResample': ('avg', 'Resample'), 'sequenceCountResample': ('sequenceCount', 'Resample'), 'skewPopResample': ('skewPop', 'Resample'), 'groupArrayInsertAtResample': ('groupArrayInsertAt', 'Resample'), 'anyLastResample': ('anyLast', 'Resample'), 'deltaSumTimestampResample': ('deltaSumTimestamp', 'Resample'), 'groupArrayMovingAvgResample': ('groupArrayMovingAvg', 'Resample'), 'categoricalInformationValueResample': ('categoricalInformationValue', 'Resample'), 'mannWhitneyUTestResample': ('mannWhitneyUTest', 'Resample'), 'quantileExactWeightedResample': ('quantileExactWeighted', 'Resample'), 'sumResample': ('sum', 'Resample'), 'groupArrayResample': ('groupArray', 'Resample'), 'theilsUResample': ('theilsU', 'Resample'), 'varSampResample': ('varSamp', 'Resample'), 'quantileResample': ('quantile', 'Resample'), 'anyResample': ('any', 'Resample'), 'quantileExactResample': ('quantileExact', 'Resample'), 'uniqCombinedResample': ('uniqCombined', 'Resample'), 'quantilesTDigestWeightedResample': ('quantilesTDigestWeighted', 'Resample'), 'quantileExactLowResample': ('quantileExactLow', 'Resample'), 'uniqThetaResample': ('uniqTheta', 'Resample'), 'simpleLinearRegressionResample': ('simpleLinearRegression', 'Resample'), 'avgWeightedResample': ('avgWeighted', 'Resample'), 'stddevSampResample': ('stddevSamp', 'Resample'), 'sequenceNextNodeResample': ('sequenceNextNode', 'Resample'), 'sumCountResample': ('sumCount', 'Resample'), 'quantileTimingResample': ('quantileTiming', 'Resample'), 'first_valueResample': ('first_value', 'Resample'), 'maxMapResample': ('maxMap', 'Resample'), 'groupBitmapXorResample': ('groupBitmapXor', 'Resample'), 'quantilesExactLowResample': ('quantilesExactLow', 'Resample'), 'stddevPopResample': ('stddevPop', 'Resample'), 'argMaxResample': ('argMax', 'Resample'), 'corrResample': ('corr', 'Resample'), 'groupBitmapResample': ('groupBitmap', 'Resample'), 'sparkBarResample': ('sparkBar', 'Resample'), 'covarPopResample': ('covarPop', 'Resample'), 'quantileTDigestWeightedResample': ('quantileTDigestWeighted', 'Resample'), 'quantilesResample': ('quantiles', 'Resample'), 'quantilesDeterministicResample': ('quantilesDeterministic', 'Resample'), 'cramersVBiasCorrectedResample': ('cramersVBiasCorrected', 'Resample'), 'anyHeavyResample': ('anyHeavy', 'Resample'), 'countResample': ('count', 'Resample'), 'quantileTDigestResample': ('quantileTDigest', 'Resample'), 'rankCorrResample': ('rankCorr', 'Resample'), 'uniqExactResample': ('uniqExact', 'Resample'), 'quantilesTDigestResample': ('quantilesTDigest', 'Resample'), 'quantilesInterpolatedWeightedResample': ('quantilesInterpolatedWeighted', 'Resample'), 'groupBitmapAndResample': ('groupBitmapAnd', 'Resample'), 'stochasticLinearRegressionResample': ('stochasticLinearRegression', 'Resample'), 'quantileDeterministicResample': ('quantileDeterministic', 'Resample'), 'covarSampResample': ('covarSamp', 'Resample'), 'kurtSampResample': ('kurtSamp', 'Resample'), 'sumKahanResample': ('sumKahan', 'Resample'), 'quantileExactHighResample': ('quantileExactHigh', 'Resample'), 'groupUniqArrayResample': ('groupUniqArray', 'Resample'), 'meanZTestResample': ('meanZTest', 'Resample'), 'quantilesExactHighResample': ('quantilesExactHigh', 'Resample'), 'exponentialMovingAverageResample': ('exponentialMovingAverage', 'Resample'), 'groupArraySampleResample': ('groupArraySample', 'Resample'), 'groupBitAndResample': ('groupBitAnd', 'Resample'), 'quantileBFloat16Resample': ('quantileBFloat16', 'Resample'), 'topKWeightedResample': ('topKWeighted', 'Resample'), 'quantilesBFloat16Resample': ('quantilesBFloat16', 'Resample'), 'quantilesTimingWeightedResample': ('quantilesTimingWeighted', 'Resample'), 'quantilesGKResample': ('quantilesGK', 'Resample'), 'quantileGKResample': ('quantileGK', 'Resample'), 'groupBitXorResample': ('groupBitXor', 'Resample'), 'kolmogorovSmirnovTestResample': ('kolmogorovSmirnovTest', 'Resample'), 'largestTriangleThreeBucketsResample': ('largestTriangleThreeBuckets', 'Resample'), 'maxResample': ('max', 'Resample'), 'maxIntersectionsPositionResample': ('maxIntersectionsPosition', 'Resample'), 'retentionResample': ('retention', 'Resample'), 'sumMapResample': ('sumMap', 'Resample'), 'argMinResample': ('argMin', 'Resample'), 'kurtPopArgMin': ('kurtPop', 'ArgMin'), 'quantilesExactWeightedArgMin': ('quantilesExactWeighted', 'ArgMin'), 'quantilesExactArgMin': ('quantilesExact', 'ArgMin'), 'groupArrayLastArgMin': ('groupArrayLast', 'ArgMin'), 'minArgMin': ('min', 'ArgMin'), 'intervalLengthSumArgMin': ('intervalLengthSum', 'ArgMin'), 'exponentialTimeDecayedAvgArgMin': ('exponentialTimeDecayedAvg', 'ArgMin'), 'windowFunnelArgMin': ('windowFunnel', 'ArgMin'), 'quantilesBFloat16WeightedArgMin': ('quantilesBFloat16Weighted', 'ArgMin'), 'last_valueArgMin': ('last_value', 'ArgMin'), 'histogramArgMin': ('histogram', 'ArgMin'), 'maxIntersectionsArgMin': ('maxIntersections', 'ArgMin'), 'uniqCombined64ArgMin': ('uniqCombined64', 'ArgMin'), 'minMapArgMin': ('minMap', 'ArgMin'), 'sequenceMatchArgMin': ('sequenceMatch', 'ArgMin'), 'quantilesTimingArgMin': ('quantilesTiming', 'ArgMin'), 'medianArgMin': ('median', 'ArgMin'), 'sumWithOverflowArgMin': ('sumWithOverflow', 'ArgMin'), 'uniqHLL12ArgMin': ('uniqHLL12', 'ArgMin'), 'contingencyArgMin': ('contingency', 'ArgMin'), 'quantileTimingWeightedArgMin': ('quantileTimingWeighted', 'ArgMin'), 'topKArgMin': ('topK', 'ArgMin'), 'cramersVArgMin': ('cramersV', 'ArgMin'), 'deltaSumArgMin': ('deltaSum', 'ArgMin'), 'varPopArgMin': ('varPop', 'ArgMin'), 'boundingRatioArgMin': ('boundingRatio', 'ArgMin'), 'welchTTestArgMin': ('welchTTest', 'ArgMin'), 'quantileBFloat16WeightedArgMin': ('quantileBFloat16Weighted', 'ArgMin'), 'quantileInterpolatedWeightedArgMin': ('quantileInterpolatedWeighted', 'ArgMin'), 'entropyArgMin': ('entropy', 'ArgMin'), 'studentTTestArgMin': ('studentTTest', 'ArgMin'), 'stochasticLogisticRegressionArgMin': ('stochasticLogisticRegression', 'ArgMin'), 'uniqArgMin': ('uniq', 'ArgMin'), 'uniqUpToArgMin': ('uniqUpTo', 'ArgMin'), 'groupBitOrArgMin': ('groupBitOr', 'ArgMin'), 'groupArrayMovingSumArgMin': ('groupArrayMovingSum', 'ArgMin'), 'skewSampArgMin': ('skewSamp', 'ArgMin'), 'groupBitmapOrArgMin': ('groupBitmapOr', 'ArgMin'), 'avgArgMin': ('avg', 'ArgMin'), 'sequenceCountArgMin': ('sequenceCount', 'ArgMin'), 'skewPopArgMin': ('skewPop', 'ArgMin'), 'groupArrayInsertAtArgMin': ('groupArrayInsertAt', 'ArgMin'), 'anyLastArgMin': ('anyLast', 'ArgMin'), 'deltaSumTimestampArgMin': ('deltaSumTimestamp', 'ArgMin'), 'groupArrayMovingAvgArgMin': ('groupArrayMovingAvg', 'ArgMin'), 'categoricalInformationValueArgMin': ('categoricalInformationValue', 'ArgMin'), 'mannWhitneyUTestArgMin': ('mannWhitneyUTest', 'ArgMin'), 'quantileExactWeightedArgMin': ('quantileExactWeighted', 'ArgMin'), 'sumArgMin': ('sum', 'ArgMin'), 'groupArrayArgMin': ('groupArray', 'ArgMin'), 'theilsUArgMin': ('theilsU', 'ArgMin'), 'varSampArgMin': ('varSamp', 'ArgMin'), 'quantileArgMin': ('quantile', 'ArgMin'), 'anyArgMin': ('any', 'ArgMin'), 'quantileExactArgMin': ('quantileExact', 'ArgMin'), 'uniqCombinedArgMin': ('uniqCombined', 'ArgMin'), 'quantilesTDigestWeightedArgMin': ('quantilesTDigestWeighted', 'ArgMin'), 'quantileExactLowArgMin': ('quantileExactLow', 'ArgMin'), 'uniqThetaArgMin': ('uniqTheta', 'ArgMin'), 'simpleLinearRegressionArgMin': ('simpleLinearRegression', 'ArgMin'), 'avgWeightedArgMin': ('avgWeighted', 'ArgMin'), 'stddevSampArgMin': ('stddevSamp', 'ArgMin'), 'sequenceNextNodeArgMin': ('sequenceNextNode', 'ArgMin'), 'sumCountArgMin': ('sumCount', 'ArgMin'), 'quantileTimingArgMin': ('quantileTiming', 'ArgMin'), 'first_valueArgMin': ('first_value', 'ArgMin'), 'maxMapArgMin': ('maxMap', 'ArgMin'), 'groupBitmapXorArgMin': ('groupBitmapXor', 'ArgMin'), 'quantilesExactLowArgMin': ('quantilesExactLow', 'ArgMin'), 'stddevPopArgMin': ('stddevPop', 'ArgMin'), 'argMaxArgMin': ('argMax', 'ArgMin'), 'corrArgMin': ('corr', 'ArgMin'), 'groupBitmapArgMin': ('groupBitmap', 'ArgMin'), 'sparkBarArgMin': ('sparkBar', 'ArgMin'), 'covarPopArgMin': ('covarPop', 'ArgMin'), 'quantileTDigestWeightedArgMin': ('quantileTDigestWeighted', 'ArgMin'), 'quantilesArgMin': ('quantiles', 'ArgMin'), 'quantilesDeterministicArgMin': ('quantilesDeterministic', 'ArgMin'), 'cramersVBiasCorrectedArgMin': ('cramersVBiasCorrected', 'ArgMin'), 'anyHeavyArgMin': ('anyHeavy', 'ArgMin'), 'countArgMin': ('count', 'ArgMin'), 'quantileTDigestArgMin': ('quantileTDigest', 'ArgMin'), 'rankCorrArgMin': ('rankCorr', 'ArgMin'), 'uniqExactArgMin': ('uniqExact', 'ArgMin'), 'quantilesTDigestArgMin': ('quantilesTDigest', 'ArgMin'), 'quantilesInterpolatedWeightedArgMin': ('quantilesInterpolatedWeighted', 'ArgMin'), 'groupBitmapAndArgMin': ('groupBitmapAnd', 'ArgMin'), 'stochasticLinearRegressionArgMin': ('stochasticLinearRegression', 'ArgMin'), 'quantileDeterministicArgMin': ('quantileDeterministic', 'ArgMin'), 'covarSampArgMin': ('covarSamp', 'ArgMin'), 'kurtSampArgMin': ('kurtSamp', 'ArgMin'), 'sumKahanArgMin': ('sumKahan', 'ArgMin'), 'quantileExactHighArgMin': ('quantileExactHigh', 'ArgMin'), 'groupUniqArrayArgMin': ('groupUniqArray', 'ArgMin'), 'meanZTestArgMin': ('meanZTest', 'ArgMin'), 'quantilesExactHighArgMin': ('quantilesExactHigh', 'ArgMin'), 'exponentialMovingAverageArgMin': ('exponentialMovingAverage', 'ArgMin'), 'groupArraySampleArgMin': ('groupArraySample', 'ArgMin'), 'groupBitAndArgMin': ('groupBitAnd', 'ArgMin'), 'quantileBFloat16ArgMin': ('quantileBFloat16', 'ArgMin'), 'topKWeightedArgMin': ('topKWeighted', 'ArgMin'), 'quantilesBFloat16ArgMin': ('quantilesBFloat16', 'ArgMin'), 'quantilesTimingWeightedArgMin': ('quantilesTimingWeighted', 'ArgMin'), 'quantilesGKArgMin': ('quantilesGK', 'ArgMin'), 'quantileGKArgMin': ('quantileGK', 'ArgMin'), 'groupBitXorArgMin': ('groupBitXor', 'ArgMin'), 'kolmogorovSmirnovTestArgMin': ('kolmogorovSmirnovTest', 'ArgMin'), 'largestTriangleThreeBucketsArgMin': ('largestTriangleThreeBuckets', 'ArgMin'), 'maxArgMin': ('max', 'ArgMin'), 'maxIntersectionsPositionArgMin': ('maxIntersectionsPosition', 'ArgMin'), 'retentionArgMin': ('retention', 'ArgMin'), 'sumMapArgMin': ('sumMap', 'ArgMin'), 'argMinArgMin': ('argMin', 'ArgMin'), 'kurtPopArgMax': ('kurtPop', 'ArgMax'), 'quantilesExactWeightedArgMax': ('quantilesExactWeighted', 'ArgMax'), 'quantilesExactArgMax': ('quantilesExact', 'ArgMax'), 'groupArrayLastArgMax': ('groupArrayLast', 'ArgMax'), 'minArgMax': ('min', 'ArgMax'), 'intervalLengthSumArgMax': ('intervalLengthSum', 'ArgMax'), 'exponentialTimeDecayedAvgArgMax': ('exponentialTimeDecayedAvg', 'ArgMax'), 'windowFunnelArgMax': ('windowFunnel', 'ArgMax'), 'quantilesBFloat16WeightedArgMax': ('quantilesBFloat16Weighted', 'ArgMax'), 'last_valueArgMax': ('last_value', 'ArgMax'), 'histogramArgMax': ('histogram', 'ArgMax'), 'maxIntersectionsArgMax': ('maxIntersections', 'ArgMax'), 'uniqCombined64ArgMax': ('uniqCombined64', 'ArgMax'), 'minMapArgMax': ('minMap', 'ArgMax'), 'sequenceMatchArgMax': ('sequenceMatch', 'ArgMax'), 'quantilesTimingArgMax': ('quantilesTiming', 'ArgMax'), 'medianArgMax': ('median', 'ArgMax'), 'sumWithOverflowArgMax': ('sumWithOverflow', 'ArgMax'), 'uniqHLL12ArgMax': ('uniqHLL12', 'ArgMax'), 'contingencyArgMax': ('contingency', 'ArgMax'), 'quantileTimingWeightedArgMax': ('quantileTimingWeighted', 'ArgMax'), 'topKArgMax': ('topK', 'ArgMax'), 'cramersVArgMax': ('cramersV', 'ArgMax'), 'deltaSumArgMax': ('deltaSum', 'ArgMax'), 'varPopArgMax': ('varPop', 'ArgMax'), 'boundingRatioArgMax': ('boundingRatio', 'ArgMax'), 'welchTTestArgMax': ('welchTTest', 'ArgMax'), 'quantileBFloat16WeightedArgMax': ('quantileBFloat16Weighted', 'ArgMax'), 'quantileInterpolatedWeightedArgMax': ('quantileInterpolatedWeighted', 'ArgMax'), 'entropyArgMax': ('entropy', 'ArgMax'), 'studentTTestArgMax': ('studentTTest', 'ArgMax'), 'stochasticLogisticRegressionArgMax': ('stochasticLogisticRegression', 'ArgMax'), 'uniqArgMax': ('uniq', 'ArgMax'), 'uniqUpToArgMax': ('uniqUpTo', 'ArgMax'), 'groupBitOrArgMax': ('groupBitOr', 'ArgMax'), 'groupArrayMovingSumArgMax': ('groupArrayMovingSum', 'ArgMax'), 'skewSampArgMax': ('skewSamp', 'ArgMax'), 'groupBitmapOrArgMax': ('groupBitmapOr', 'ArgMax'), 'avgArgMax': ('avg', 'ArgMax'), 'sequenceCountArgMax': ('sequenceCount', 'ArgMax'), 'skewPopArgMax': ('skewPop', 'ArgMax'), 'groupArrayInsertAtArgMax': ('groupArrayInsertAt', 'ArgMax'), 'anyLastArgMax': ('anyLast', 'ArgMax'), 'deltaSumTimestampArgMax': ('deltaSumTimestamp', 'ArgMax'), 'groupArrayMovingAvgArgMax': ('groupArrayMovingAvg', 'ArgMax'), 'categoricalInformationValueArgMax': ('categoricalInformationValue', 'ArgMax'), 'mannWhitneyUTestArgMax': ('mannWhitneyUTest', 'ArgMax'), 'quantileExactWeightedArgMax': ('quantileExactWeighted', 'ArgMax'), 'sumArgMax': ('sum', 'ArgMax'), 'groupArrayArgMax': ('groupArray', 'ArgMax'), 'theilsUArgMax': ('theilsU', 'ArgMax'), 'varSampArgMax': ('varSamp', 'ArgMax'), 'quantileArgMax': ('quantile', 'ArgMax'), 'anyArgMax': ('any', 'ArgMax'), 'quantileExactArgMax': ('quantileExact', 'ArgMax'), 'uniqCombinedArgMax': ('uniqCombined', 'ArgMax'), 'quantilesTDigestWeightedArgMax': ('quantilesTDigestWeighted', 'ArgMax'), 'quantileExactLowArgMax': ('quantileExactLow', 'ArgMax'), 'uniqThetaArgMax': ('uniqTheta', 'ArgMax'), 'simpleLinearRegressionArgMax': ('simpleLinearRegression', 'ArgMax'), 'avgWeightedArgMax': ('avgWeighted', 'ArgMax'), 'stddevSampArgMax': ('stddevSamp', 'ArgMax'), 'sequenceNextNodeArgMax': ('sequenceNextNode', 'ArgMax'), 'sumCountArgMax': ('sumCount', 'ArgMax'), 'quantileTimingArgMax': ('quantileTiming', 'ArgMax'), 'first_valueArgMax': ('first_value', 'ArgMax'), 'maxMapArgMax': ('maxMap', 'ArgMax'), 'groupBitmapXorArgMax': ('groupBitmapXor', 'ArgMax'), 'quantilesExactLowArgMax': ('quantilesExactLow', 'ArgMax'), 'stddevPopArgMax': ('stddevPop', 'ArgMax'), 'argMaxArgMax': ('argMax', 'ArgMax'), 'corrArgMax': ('corr', 'ArgMax'), 'groupBitmapArgMax': ('groupBitmap', 'ArgMax'), 'sparkBarArgMax': ('sparkBar', 'ArgMax'), 'covarPopArgMax': ('covarPop', 'ArgMax'), 'quantileTDigestWeightedArgMax': ('quantileTDigestWeighted', 'ArgMax'), 'quantilesArgMax': ('quantiles', 'ArgMax'), 'quantilesDeterministicArgMax': ('quantilesDeterministic', 'ArgMax'), 'cramersVBiasCorrectedArgMax': ('cramersVBiasCorrected', 'ArgMax'), 'anyHeavyArgMax': ('anyHeavy', 'ArgMax'), 'countArgMax': ('count', 'ArgMax'), 'quantileTDigestArgMax': ('quantileTDigest', 'ArgMax'), 'rankCorrArgMax': ('rankCorr', 'ArgMax'), 'uniqExactArgMax': ('uniqExact', 'ArgMax'), 'quantilesTDigestArgMax': ('quantilesTDigest', 'ArgMax'), 'quantilesInterpolatedWeightedArgMax': ('quantilesInterpolatedWeighted', 'ArgMax'), 'groupBitmapAndArgMax': ('groupBitmapAnd', 'ArgMax'), 'stochasticLinearRegressionArgMax': ('stochasticLinearRegression', 'ArgMax'), 'quantileDeterministicArgMax': ('quantileDeterministic', 'ArgMax'), 'covarSampArgMax': ('covarSamp', 'ArgMax'), 'kurtSampArgMax': ('kurtSamp', 'ArgMax'), 'sumKahanArgMax': ('sumKahan', 'ArgMax'), 'quantileExactHighArgMax': ('quantileExactHigh', 'ArgMax'), 'groupUniqArrayArgMax': ('groupUniqArray', 'ArgMax'), 'meanZTestArgMax': ('meanZTest', 'ArgMax'), 'quantilesExactHighArgMax': ('quantilesExactHigh', 'ArgMax'), 'exponentialMovingAverageArgMax': ('exponentialMovingAverage', 'ArgMax'), 'groupArraySampleArgMax': ('groupArraySample', 'ArgMax'), 'groupBitAndArgMax': ('groupBitAnd', 'ArgMax'), 'quantileBFloat16ArgMax': ('quantileBFloat16', 'ArgMax'), 'topKWeightedArgMax': ('topKWeighted', 'ArgMax'), 'quantilesBFloat16ArgMax': ('quantilesBFloat16', 'ArgMax'), 'quantilesTimingWeightedArgMax': ('quantilesTimingWeighted', 'ArgMax'), 'quantilesGKArgMax': ('quantilesGK', 'ArgMax'), 'quantileGKArgMax': ('quantileGK', 'ArgMax'), 'groupBitXorArgMax': ('groupBitXor', 'ArgMax'), 'kolmogorovSmirnovTestArgMax': ('kolmogorovSmirnovTest', 'ArgMax'), 'largestTriangleThreeBucketsArgMax': ('largestTriangleThreeBuckets', 'ArgMax'), 'maxArgMax': ('max', 'ArgMax'), 'maxIntersectionsPositionArgMax': ('maxIntersectionsPosition', 'ArgMax'), 'retentionArgMax': ('retention', 'ArgMax'), 'sumMapArgMax': ('sumMap', 'ArgMax'), 'argMinArgMax': ('argMin', 'ArgMax'), 'kurtPop': ('kurtPop', ''), 'quantilesExactWeighted': ('quantilesExactWeighted', ''), 'quantilesExact': ('quantilesExact', ''), 'groupArrayLast': ('groupArrayLast', ''), 'min': ('min', ''), 'intervalLengthSum': ('intervalLengthSum', ''), 'exponentialTimeDecayedAvg': ('exponentialTimeDecayedAvg', ''), 'windowFunnel': ('windowFunnel', ''), 'quantilesBFloat16Weighted': ('quantilesBFloat16Weighted', ''), 'last_value': ('last_value', ''), 'histogram': ('histogram', ''), 'maxIntersections': ('maxIntersections', ''), 'uniqCombined64': ('uniqCombined64', ''), 'sequenceMatch': ('sequenceMatch', ''), 'quantilesTiming': ('quantilesTiming', ''), 'median': ('median', ''), 'sumWithOverflow': ('sumWithOverflow', ''), 'uniqHLL12': ('uniqHLL12', ''), 'contingency': ('contingency', ''), 'quantileTimingWeighted': ('quantileTimingWeighted', ''), 'topK': ('topK', ''), 'cramersV': ('cramersV', ''), 'deltaSum': ('deltaSum', ''), 'varPop': ('varPop', ''), 'boundingRatio': ('boundingRatio', ''), 'welchTTest': ('welchTTest', ''), 'quantileBFloat16Weighted': ('quantileBFloat16Weighted', ''), 'quantileInterpolatedWeighted': ('quantileInterpolatedWeighted', ''), 'entropy': ('entropy', ''), 'studentTTest': ('studentTTest', ''), 'stochasticLogisticRegression': ('stochasticLogisticRegression', ''), 'uniq': ('uniq', ''), 'uniqUpTo': ('uniqUpTo', ''), 'groupBitOr': ('groupBitOr', ''), 'groupArrayMovingSum': ('groupArrayMovingSum', ''), 'skewSamp': ('skewSamp', ''), 'groupBitmapOr': ('groupBitmapOr', ''), 'avg': ('avg', ''), 'sequenceCount': ('sequenceCount', ''), 'skewPop': ('skewPop', ''), 'groupArrayInsertAt': ('groupArrayInsertAt', ''), 'anyLast': ('anyLast', ''), 'deltaSumTimestamp': ('deltaSumTimestamp', ''), 'groupArrayMovingAvg': ('groupArrayMovingAvg', ''), 'categoricalInformationValue': ('categoricalInformationValue', ''), 'mannWhitneyUTest': ('mannWhitneyUTest', ''), 'quantileExactWeighted': ('quantileExactWeighted', ''), 'sum': ('sum', ''), 'groupArray': ('groupArray', ''), 'theilsU': ('theilsU', ''), 'varSamp': ('varSamp', ''), 'quantile': ('quantile', ''), 'any': ('any', ''), 'quantileExact': ('quantileExact', ''), 'uniqCombined': ('uniqCombined', ''), 'quantilesTDigestWeighted': ('quantilesTDigestWeighted', ''), 'quantileExactLow': ('quantileExactLow', ''), 'uniqTheta': ('uniqTheta', ''), 'simpleLinearRegression': ('simpleLinearRegression', ''), 'avgWeighted': ('avgWeighted', ''), 'stddevSamp': ('stddevSamp', ''), 'sequenceNextNode': ('sequenceNextNode', ''), 'sumCount': ('sumCount', ''), 'quantileTiming': ('quantileTiming', ''), 'first_value': ('first_value', ''), 'groupBitmapXor': ('groupBitmapXor', ''), 'quantilesExactLow': ('quantilesExactLow', ''), 'stddevPop': ('stddevPop', ''), 'argMax': ('argMax', ''), 'corr': ('corr', ''), 'groupBitmap': ('groupBitmap', ''), 'sparkBar': ('sparkBar', ''), 'covarPop': ('covarPop', ''), 'quantileTDigestWeighted': ('quantileTDigestWeighted', ''), 'quantiles': ('quantiles', ''), 'quantilesDeterministic': ('quantilesDeterministic', ''), 'cramersVBiasCorrected': ('cramersVBiasCorrected', ''), 'anyHeavy': ('anyHeavy', ''), 'count': ('count', ''), 'quantileTDigest': ('quantileTDigest', ''), 'rankCorr': ('rankCorr', ''), 'uniqExact': ('uniqExact', ''), 'quantilesTDigest': ('quantilesTDigest', ''), 'quantilesInterpolatedWeighted': ('quantilesInterpolatedWeighted', ''), 'groupBitmapAnd': ('groupBitmapAnd', ''), 'stochasticLinearRegression': ('stochasticLinearRegression', ''), 'quantileDeterministic': ('quantileDeterministic', ''), 'covarSamp': ('covarSamp', ''), 'kurtSamp': ('kurtSamp', ''), 'sumKahan': ('sumKahan', ''), 'quantileExactHigh': ('quantileExactHigh', ''), 'groupUniqArray': ('groupUniqArray', ''), 'meanZTest': ('meanZTest', ''), 'quantilesExactHigh': ('quantilesExactHigh', ''), 'exponentialMovingAverage': ('exponentialMovingAverage', ''), 'groupArraySample': ('groupArraySample', ''), 'groupBitAnd': ('groupBitAnd', ''), 'quantileBFloat16': ('quantileBFloat16', ''), 'topKWeighted': ('topKWeighted', ''), 'quantilesBFloat16': ('quantilesBFloat16', ''), 'quantilesTimingWeighted': ('quantilesTimingWeighted', ''), 'quantilesGK': ('quantilesGK', ''), 'quantileGK': ('quantileGK', ''), 'groupBitXor': ('groupBitXor', ''), 'kolmogorovSmirnovTest': ('kolmogorovSmirnovTest', ''), 'largestTriangleThreeBuckets': ('largestTriangleThreeBuckets', ''), 'max': ('max', ''), 'maxIntersectionsPosition': ('maxIntersectionsPosition', ''), 'retention': ('retention', ''), 'argMin': ('argMin', '')}
FUNCTIONS_WITH_ALIASED_ARGS = {'STRUCT', 'TUPLE'}
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>>, 'NORMALIZE': <function Parser.<lambda>>, 'OPENJSON': <function Parser.<lambda>>, 'OVERLAY': <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>>, 'COLUMNS': <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>>}
NO_PAREN_FUNCTIONS = {<TokenType.CURRENT_DATE: 'CURRENT_DATE'>: <class 'sqlglot.expressions.CurrentDate'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>: <class 'sqlglot.expressions.CurrentDate'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>: <class 'sqlglot.expressions.CurrentTime'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>: <class 'sqlglot.expressions.CurrentUser'>}
RANGE_PARSERS = {<TokenType.AT_GT: 'AT_GT'>: <function binary_range_parser.<locals>._parse_binary_range>, <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.LT_AT: 'LT_AT'>: <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.OUTER: 'OUTER'>, <TokenType.ANY: 'ANY'>, <TokenType.CROSS: 'CROSS'>, <TokenType.INNER: 'INNER'>, <TokenType.ANTI: 'ANTI'>, <TokenType.SEMI: 'SEMI'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.ASOF: 'ASOF'>, <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>}
TABLE_ALIAS_TOKENS = {<TokenType.DECIMAL32: 'DECIMAL32'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.DATE32: 'DATE32'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.ALL: 'ALL'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TAG: 'TAG'>, <TokenType.CASE: 'CASE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.IS: 'IS'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.NESTED: 'NESTED'>, <TokenType.JSON: 'JSON'>, <TokenType.DELETE: 'DELETE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.MODEL: 'MODEL'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.SUPER: 'SUPER'>, <TokenType.INT256: 'INT256'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.TEXT: 'TEXT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.COPY: 'COPY'>, <TokenType.RANGE: 'RANGE'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.INET: 'INET'>, <TokenType.KILL: 'KILL'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.SET: 'SET'>, <TokenType.ROWS: 'ROWS'>, <TokenType.MONEY: 'MONEY'>, <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, <TokenType.INDEX: 'INDEX'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.JSONB: 'JSONB'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.FIRST: 'FIRST'>, <TokenType.INT: 'INT'>, <TokenType.CHAR: 'CHAR'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.ENUM: 'ENUM'>, <TokenType.BIT: 'BIT'>, <TokenType.RENAME: 'RENAME'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.CACHE: 'CACHE'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.UINT256: 'UINT256'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.TOP: 'TOP'>, <TokenType.SOME: 'SOME'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TIME: 'TIME'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.MAP: 'MAP'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.IPV6: 'IPV6'>, <TokenType.SHOW: 'SHOW'>, <TokenType.DIV: 'DIV'>, <TokenType.TABLE: 'TABLE'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.END: 'END'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.VIEW: 'VIEW'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.UINT128: 'UINT128'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.FALSE: 'FALSE'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.BINARY: 'BINARY'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ROW: 'ROW'>, <TokenType.INT128: 'INT128'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DECIMAL64: 'DECIMAL64'>, <TokenType.KEEP: 'KEEP'>, <TokenType.NEXT: 'NEXT'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.DECIMAL128: 'DECIMAL128'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.TRUE: 'TRUE'>, <TokenType.YEAR: 'YEAR'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.UINT: 'UINT'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.NAME: 'NAME'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.ASC: 'ASC'>, <TokenType.FILTER: 'FILTER'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.CUBE: 'CUBE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.DATE: 'DATE'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.USE: 'USE'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.LOAD: 'LOAD'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.VAR: 'VAR'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.XML: 'XML'>, <TokenType.DESC: 'DESC'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.LIST: 'LIST'>, <TokenType.MERGE: 'MERGE'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.NULL: 'NULL'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.UBIGINT: 'UBIGINT'>}
ALIAS_TOKENS = {<TokenType.DECIMAL32: 'DECIMAL32'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.DATE32: 'DATE32'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.ALL: 'ALL'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TAG: 'TAG'>, <TokenType.CASE: 'CASE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.IS: 'IS'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.NESTED: 'NESTED'>, <TokenType.LEFT: 'LEFT'>, <TokenType.DELETE: 'DELETE'>, <TokenType.JSON: 'JSON'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.MODEL: 'MODEL'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.SUPER: 'SUPER'>, <TokenType.INT256: 'INT256'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.TEXT: 'TEXT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.COPY: 'COPY'>, <TokenType.RANGE: 'RANGE'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.INET: 'INET'>, <TokenType.KILL: 'KILL'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.SET: 'SET'>, <TokenType.ROWS: 'ROWS'>, <TokenType.MONEY: 'MONEY'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.INDEX: 'INDEX'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.JSONB: 'JSONB'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.FIRST: 'FIRST'>, <TokenType.INT: 'INT'>, <TokenType.CHAR: 'CHAR'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.ENUM: 'ENUM'>, <TokenType.BIT: 'BIT'>, <TokenType.RENAME: 'RENAME'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.CACHE: 'CACHE'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.UINT256: 'UINT256'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.ANTI: 'ANTI'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.TOP: 'TOP'>, <TokenType.SOME: 'SOME'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TIME: 'TIME'>, <TokenType.SEMI: 'SEMI'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.MAP: 'MAP'>, <TokenType.APPLY: 'APPLY'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.IPV6: 'IPV6'>, <TokenType.SHOW: 'SHOW'>, <TokenType.DIV: 'DIV'>, <TokenType.TABLE: 'TABLE'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.END: 'END'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.VIEW: 'VIEW'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.UINT128: 'UINT128'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.FALSE: 'FALSE'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.BINARY: 'BINARY'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ROW: 'ROW'>, <TokenType.INT128: 'INT128'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DECIMAL64: 'DECIMAL64'>, <TokenType.KEEP: 'KEEP'>, <TokenType.NEXT: 'NEXT'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.FINAL: 'FINAL'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.DECIMAL128: 'DECIMAL128'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.TRUE: 'TRUE'>, <TokenType.YEAR: 'YEAR'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.UINT: 'UINT'>, <TokenType.ASOF: 'ASOF'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.ANY: 'ANY'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.NAME: 'NAME'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.ASC: 'ASC'>, <TokenType.FILTER: 'FILTER'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.CUBE: 'CUBE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.DATE: 'DATE'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.FULL: 'FULL'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.USE: 'USE'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.LOAD: 'LOAD'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.VAR: 'VAR'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.XML: 'XML'>, <TokenType.DESC: 'DESC'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.LIST: 'LIST'>, <TokenType.MERGE: 'MERGE'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.NULL: 'NULL'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.UBIGINT: 'UBIGINT'>}
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>>, 'AS': <function Parser.<lambda>>, 'ALTER': <function Parser.<lambda>>, 'CLUSTER BY': <function Parser.<lambda>>, 'DELETE': <function Parser.<lambda>>, 'DROP': <function Parser.<lambda>>, 'RENAME': <function Parser.<lambda>>, 'SET': <function Parser.<lambda>>, 'SWAP': <function Parser.<lambda>>, 'REPLACE': <function ClickHouse.Parser.<lambda>>}
SCHEMA_UNNAMED_CONSTRAINTS = {'LIKE', 'FOREIGN KEY', 'CHECK', 'EXCLUDE', 'INDEX', 'PERIOD', 'PRIMARY KEY', 'UNIQUE'}
PLACEHOLDER_PARSERS = {<TokenType.PLACEHOLDER: 'PLACEHOLDER'>: <function Parser.<lambda>>, <TokenType.PARAMETER: 'PARAMETER'>: <function Parser.<lambda>>, <TokenType.COLON: 'COLON'>: <function Parser.<lambda>>, <TokenType.L_BRACE: 'L_BRACE'>: <function ClickHouse.Parser.<lambda>>}
SHOW_TRIE: Dict = {}
SET_TRIE: Dict = {'GLOBAL': {0: True}, 'LOCAL': {0: True}, 'SESSION': {0: True}, 'TRANSACTION': {0: True}}
Inherited Members
sqlglot.parser.Parser
Parser
STRUCT_TYPE_TOKENS
NESTED_TYPE_TOKENS
ENUM_TYPE_TOKENS
AGGREGATE_TYPE_TOKENS
TYPE_TOKENS
SIGNED_TO_UNSIGNED_TYPE_TOKEN
SUBQUERY_PREDICATES
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
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
PROCEDURE_OPTIONS
EXECUTE_AS_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
IS_JSON_PREDICATE_KIND
ODBC_DATETIME_LITERALS
ON_CONDITION_TOKENS
PRIVILEGE_FOLLOW_TOKENS
DESCRIBE_STYLES
OPERATION_MODIFIERS
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):
 798    class Generator(generator.Generator):
 799        QUERY_HINTS = False
 800        STRUCT_DELIMITER = ("(", ")")
 801        NVL2_SUPPORTED = False
 802        TABLESAMPLE_REQUIRES_PARENS = False
 803        TABLESAMPLE_SIZE_IS_ROWS = False
 804        TABLESAMPLE_KEYWORDS = "SAMPLE"
 805        LAST_DAY_SUPPORTS_DATE_PART = False
 806        CAN_IMPLEMENT_ARRAY_ANY = True
 807        SUPPORTS_TO_NUMBER = False
 808        JOIN_HINTS = False
 809        TABLE_HINTS = False
 810        GROUPINGS_SEP = ""
 811        SET_OP_MODIFIERS = False
 812        SUPPORTS_TABLE_ALIAS_COLUMNS = False
 813        VALUES_AS_TABLE = False
 814
 815        STRING_TYPE_MAPPING = {
 816            exp.DataType.Type.CHAR: "String",
 817            exp.DataType.Type.LONGBLOB: "String",
 818            exp.DataType.Type.LONGTEXT: "String",
 819            exp.DataType.Type.MEDIUMBLOB: "String",
 820            exp.DataType.Type.MEDIUMTEXT: "String",
 821            exp.DataType.Type.TINYBLOB: "String",
 822            exp.DataType.Type.TINYTEXT: "String",
 823            exp.DataType.Type.TEXT: "String",
 824            exp.DataType.Type.VARBINARY: "String",
 825            exp.DataType.Type.VARCHAR: "String",
 826        }
 827
 828        SUPPORTED_JSON_PATH_PARTS = {
 829            exp.JSONPathKey,
 830            exp.JSONPathRoot,
 831            exp.JSONPathSubscript,
 832        }
 833
 834        TYPE_MAPPING = {
 835            **generator.Generator.TYPE_MAPPING,
 836            **STRING_TYPE_MAPPING,
 837            exp.DataType.Type.ARRAY: "Array",
 838            exp.DataType.Type.BOOLEAN: "Bool",
 839            exp.DataType.Type.BIGINT: "Int64",
 840            exp.DataType.Type.DATE32: "Date32",
 841            exp.DataType.Type.DATETIME: "DateTime",
 842            exp.DataType.Type.DATETIME64: "DateTime64",
 843            exp.DataType.Type.TIMESTAMP: "DateTime",
 844            exp.DataType.Type.TIMESTAMPTZ: "DateTime",
 845            exp.DataType.Type.DOUBLE: "Float64",
 846            exp.DataType.Type.ENUM: "Enum",
 847            exp.DataType.Type.ENUM8: "Enum8",
 848            exp.DataType.Type.ENUM16: "Enum16",
 849            exp.DataType.Type.FIXEDSTRING: "FixedString",
 850            exp.DataType.Type.FLOAT: "Float32",
 851            exp.DataType.Type.INT: "Int32",
 852            exp.DataType.Type.MEDIUMINT: "Int32",
 853            exp.DataType.Type.INT128: "Int128",
 854            exp.DataType.Type.INT256: "Int256",
 855            exp.DataType.Type.LOWCARDINALITY: "LowCardinality",
 856            exp.DataType.Type.MAP: "Map",
 857            exp.DataType.Type.NESTED: "Nested",
 858            exp.DataType.Type.SMALLINT: "Int16",
 859            exp.DataType.Type.STRUCT: "Tuple",
 860            exp.DataType.Type.TINYINT: "Int8",
 861            exp.DataType.Type.UBIGINT: "UInt64",
 862            exp.DataType.Type.UINT: "UInt32",
 863            exp.DataType.Type.UINT128: "UInt128",
 864            exp.DataType.Type.UINT256: "UInt256",
 865            exp.DataType.Type.USMALLINT: "UInt16",
 866            exp.DataType.Type.UTINYINT: "UInt8",
 867            exp.DataType.Type.IPV4: "IPv4",
 868            exp.DataType.Type.IPV6: "IPv6",
 869            exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction",
 870            exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction",
 871        }
 872
 873        TRANSFORMS = {
 874            **generator.Generator.TRANSFORMS,
 875            exp.AnyValue: rename_func("any"),
 876            exp.ApproxDistinct: rename_func("uniq"),
 877            exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this),
 878            exp.ArraySize: rename_func("LENGTH"),
 879            exp.ArraySum: rename_func("arraySum"),
 880            exp.ArgMax: arg_max_or_min_no_count("argMax"),
 881            exp.ArgMin: arg_max_or_min_no_count("argMin"),
 882            exp.Array: inline_array_sql,
 883            exp.CastToStrType: rename_func("CAST"),
 884            exp.CountIf: rename_func("countIf"),
 885            exp.CompressColumnConstraint: lambda self,
 886            e: f"CODEC({self.expressions(e, key='this', flat=True)})",
 887            exp.ComputedColumnConstraint: lambda self,
 888            e: f"{'MATERIALIZED' if e.args.get('persisted') else 'ALIAS'} {self.sql(e, 'this')}",
 889            exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"),
 890            exp.DateAdd: _datetime_delta_sql("DATE_ADD"),
 891            exp.DateDiff: _datetime_delta_sql("DATE_DIFF"),
 892            exp.DateStrToDate: rename_func("toDate"),
 893            exp.DateSub: _datetime_delta_sql("DATE_SUB"),
 894            exp.Explode: rename_func("arrayJoin"),
 895            exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL",
 896            exp.IsNan: rename_func("isNaN"),
 897            exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False),
 898            exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False),
 899            exp.JSONPathKey: json_path_key_only_name,
 900            exp.JSONPathRoot: lambda *_: "",
 901            exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)),
 902            exp.Nullif: rename_func("nullIf"),
 903            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
 904            exp.Pivot: no_pivot_sql,
 905            exp.Quantile: _quantile_sql,
 906            exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression),
 907            exp.Rand: rename_func("randCanonical"),
 908            exp.StartsWith: rename_func("startsWith"),
 909            exp.StrPosition: lambda self, e: self.func(
 910                "position", e.this, e.args.get("substr"), e.args.get("position")
 911            ),
 912            exp.TimeToStr: lambda self, e: self.func(
 913                "formatDateTime", e.this, self.format_time(e), e.args.get("zone")
 914            ),
 915            exp.TimeStrToTime: _timestrtotime_sql,
 916            exp.TimestampAdd: _datetime_delta_sql("TIMESTAMP_ADD"),
 917            exp.TimestampSub: _datetime_delta_sql("TIMESTAMP_SUB"),
 918            exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)),
 919            exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions),
 920            exp.MD5Digest: rename_func("MD5"),
 921            exp.MD5: lambda self, e: self.func("LOWER", self.func("HEX", self.func("MD5", e.this))),
 922            exp.SHA: rename_func("SHA1"),
 923            exp.SHA2: sha256_sql,
 924            exp.UnixToTime: _unix_to_time_sql,
 925            exp.TimestampTrunc: timestamptrunc_sql(zone=True),
 926            exp.Trim: trim_sql,
 927            exp.Variance: rename_func("varSamp"),
 928            exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
 929            exp.Stddev: rename_func("stddevSamp"),
 930            exp.Chr: rename_func("CHAR"),
 931            exp.Lag: lambda self, e: self.func(
 932                "lagInFrame", e.this, e.args.get("offset"), e.args.get("default")
 933            ),
 934            exp.Lead: lambda self, e: self.func(
 935                "leadInFrame", e.this, e.args.get("offset"), e.args.get("default")
 936            ),
 937        }
 938
 939        PROPERTIES_LOCATION = {
 940            **generator.Generator.PROPERTIES_LOCATION,
 941            exp.OnCluster: exp.Properties.Location.POST_NAME,
 942            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
 943            exp.ToTableProperty: exp.Properties.Location.POST_NAME,
 944            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
 945        }
 946
 947        # There's no list in docs, but it can be found in Clickhouse code
 948        # see `ClickHouse/src/Parsers/ParserCreate*.cpp`
 949        ON_CLUSTER_TARGETS = {
 950            "SCHEMA",  # Transpiled CREATE SCHEMA may have OnCluster property set
 951            "DATABASE",
 952            "TABLE",
 953            "VIEW",
 954            "DICTIONARY",
 955            "INDEX",
 956            "FUNCTION",
 957            "NAMED COLLECTION",
 958        }
 959
 960        # https://clickhouse.com/docs/en/sql-reference/data-types/nullable
 961        NON_NULLABLE_TYPES = {
 962            exp.DataType.Type.ARRAY,
 963            exp.DataType.Type.MAP,
 964            exp.DataType.Type.STRUCT,
 965        }
 966
 967        def strtodate_sql(self, expression: exp.StrToDate) -> str:
 968            strtodate_sql = self.function_fallback_sql(expression)
 969
 970            if not isinstance(expression.parent, exp.Cast):
 971                # StrToDate returns DATEs in other dialects (eg. postgres), so
 972                # this branch aims to improve the transpilation to clickhouse
 973                return f"CAST({strtodate_sql} AS DATE)"
 974
 975            return strtodate_sql
 976
 977        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
 978            this = expression.this
 979
 980            if isinstance(this, exp.StrToDate) and expression.to == exp.DataType.build("datetime"):
 981                return self.sql(this)
 982
 983            return super().cast_sql(expression, safe_prefix=safe_prefix)
 984
 985        def trycast_sql(self, expression: exp.TryCast) -> str:
 986            dtype = expression.to
 987            if not dtype.is_type(*self.NON_NULLABLE_TYPES, check_nullable=True):
 988                # Casting x into Nullable(T) appears to behave similarly to TRY_CAST(x AS T)
 989                dtype.set("nullable", True)
 990
 991            return super().cast_sql(expression)
 992
 993        def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str:
 994            this = self.json_path_part(expression.this)
 995            return str(int(this) + 1) if is_int(this) else this
 996
 997        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
 998            return f"AS {self.sql(expression, 'this')}"
 999
1000        def _any_to_has(
1001            self,
1002            expression: exp.EQ | exp.NEQ,
1003            default: t.Callable[[t.Any], str],
1004            prefix: str = "",
1005        ) -> str:
1006            if isinstance(expression.left, exp.Any):
1007                arr = expression.left
1008                this = expression.right
1009            elif isinstance(expression.right, exp.Any):
1010                arr = expression.right
1011                this = expression.left
1012            else:
1013                return default(expression)
1014
1015            return prefix + self.func("has", arr.this.unnest(), this)
1016
1017        def eq_sql(self, expression: exp.EQ) -> str:
1018            return self._any_to_has(expression, super().eq_sql)
1019
1020        def neq_sql(self, expression: exp.NEQ) -> str:
1021            return self._any_to_has(expression, super().neq_sql, "NOT ")
1022
1023        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
1024            # Manually add a flag to make the search case-insensitive
1025            regex = self.func("CONCAT", "'(?i)'", expression.expression)
1026            return self.func("match", expression.this, regex)
1027
1028        def datatype_sql(self, expression: exp.DataType) -> str:
1029            # String is the standard ClickHouse type, every other variant is just an alias.
1030            # Additionally, any supplied length parameter will be ignored.
1031            #
1032            # https://clickhouse.com/docs/en/sql-reference/data-types/string
1033            if expression.this in self.STRING_TYPE_MAPPING:
1034                dtype = "String"
1035            else:
1036                dtype = super().datatype_sql(expression)
1037
1038            # This section changes the type to `Nullable(...)` if the following conditions hold:
1039            # - It's marked as nullable - this ensures we won't wrap ClickHouse types with `Nullable`
1040            #   and change their semantics
1041            # - It's not the key type of a `Map`. This is because ClickHouse enforces the following
1042            #   constraint: "Type of Map key must be a type, that can be represented by integer or
1043            #   String or FixedString (possibly LowCardinality) or UUID or IPv6"
1044            # - It's not a composite type, e.g. `Nullable(Array(...))` is not a valid type
1045            parent = expression.parent
1046            nullable = expression.args.get("nullable")
1047            if nullable is True or (
1048                nullable is None
1049                and not (
1050                    isinstance(parent, exp.DataType)
1051                    and parent.is_type(exp.DataType.Type.MAP, check_nullable=True)
1052                    and expression.index in (None, 0)
1053                )
1054                and not expression.is_type(*self.NON_NULLABLE_TYPES, check_nullable=True)
1055            ):
1056                dtype = f"Nullable({dtype})"
1057
1058            return dtype
1059
1060        def cte_sql(self, expression: exp.CTE) -> str:
1061            if expression.args.get("scalar"):
1062                this = self.sql(expression, "this")
1063                alias = self.sql(expression, "alias")
1064                return f"{this} AS {alias}"
1065
1066            return super().cte_sql(expression)
1067
1068        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
1069            return super().after_limit_modifiers(expression) + [
1070                (
1071                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
1072                    if expression.args.get("settings")
1073                    else ""
1074                ),
1075                (
1076                    self.seg("FORMAT ") + self.sql(expression, "format")
1077                    if expression.args.get("format")
1078                    else ""
1079                ),
1080            ]
1081
1082        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
1083            params = self.expressions(expression, key="params", flat=True)
1084            return self.func(expression.name, *expression.expressions) + f"({params})"
1085
1086        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
1087            return self.func(expression.name, *expression.expressions)
1088
1089        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
1090            return self.anonymousaggfunc_sql(expression)
1091
1092        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
1093            return self.parameterizedagg_sql(expression)
1094
1095        def placeholder_sql(self, expression: exp.Placeholder) -> str:
1096            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
1097
1098        def oncluster_sql(self, expression: exp.OnCluster) -> str:
1099            return f"ON CLUSTER {self.sql(expression, 'this')}"
1100
1101        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
1102            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
1103                exp.Properties.Location.POST_NAME
1104            ):
1105                this_name = self.sql(
1106                    expression.this if isinstance(expression.this, exp.Schema) else expression,
1107                    "this",
1108                )
1109                this_properties = " ".join(
1110                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
1111                )
1112                this_schema = self.schema_columns_sql(expression.this)
1113                this_schema = f"{self.sep()}{this_schema}" if this_schema else ""
1114
1115                return f"{this_name}{self.sep()}{this_properties}{this_schema}"
1116
1117            return super().createable_sql(expression, locations)
1118
1119        def create_sql(self, expression: exp.Create) -> str:
1120            # The comment property comes last in CTAS statements, i.e. after the query
1121            query = expression.expression
1122            if isinstance(query, exp.Query):
1123                comment_prop = expression.find(exp.SchemaCommentProperty)
1124                if comment_prop:
1125                    comment_prop.pop()
1126                    query.replace(exp.paren(query))
1127            else:
1128                comment_prop = None
1129
1130            create_sql = super().create_sql(expression)
1131
1132            comment_sql = self.sql(comment_prop)
1133            comment_sql = f" {comment_sql}" if comment_sql else ""
1134
1135            return f"{create_sql}{comment_sql}"
1136
1137        def prewhere_sql(self, expression: exp.PreWhere) -> str:
1138            this = self.indent(self.sql(expression, "this"))
1139            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
1140
1141        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
1142            this = self.sql(expression, "this")
1143            this = f" {this}" if this else ""
1144            expr = self.sql(expression, "expression")
1145            expr = f" {expr}" if expr else ""
1146            index_type = self.sql(expression, "index_type")
1147            index_type = f" TYPE {index_type}" if index_type else ""
1148            granularity = self.sql(expression, "granularity")
1149            granularity = f" GRANULARITY {granularity}" if granularity else ""
1150
1151            return f"INDEX{this}{expr}{index_type}{granularity}"
1152
1153        def partition_sql(self, expression: exp.Partition) -> str:
1154            return f"PARTITION {self.expressions(expression, flat=True)}"
1155
1156        def partitionid_sql(self, expression: exp.PartitionId) -> str:
1157            return f"ID {self.sql(expression.this)}"
1158
1159        def replacepartition_sql(self, expression: exp.ReplacePartition) -> str:
1160            return (
1161                f"REPLACE {self.sql(expression.expression)} FROM {self.sql(expression, 'source')}"
1162            )
1163
1164        def projectiondef_sql(self, expression: exp.ProjectionDef) -> str:
1165            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
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.BOOLEAN: 'BOOLEAN'>: 'Bool', <Type.BIGINT: 'BIGINT'>: 'Int64', <Type.DATE32: 'DATE32'>: 'Date32', <Type.DATETIME: 'DATETIME'>: 'DateTime', <Type.DATETIME64: 'DATETIME64'>: 'DateTime64', <Type.TIMESTAMP: 'TIMESTAMP'>: 'DateTime', <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>: 'DateTime', <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.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.ArrayContainsAll'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ArrayOverlaps'>: <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.Except'>: <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.Intersect'>: <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.Operator'>: <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.SecurityProperty'>: <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.SwapTable'>: <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.Union'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UnloggedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Uuid'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UppercaseColumnConstraint'>: <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.WithProcedureOptions'>: <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.TimeStrToTime'>: <function _timestrtotime_sql>, <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.Trim'>: <function trim_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>>, <class 'sqlglot.expressions.Chr'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Lag'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.Lead'>: <function ClickHouse.Generator.<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.DistributedByProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DuplicateKeyProperty'>: <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.SecurityProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <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_NAME: 'POST_NAME'>, <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.WithProcedureOptions'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <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 = {'TABLE', 'NAMED COLLECTION', 'SCHEMA', 'VIEW', 'FUNCTION', 'DATABASE', 'INDEX', 'DICTIONARY'}
NON_NULLABLE_TYPES = {<Type.ARRAY: 'ARRAY'>, <Type.MAP: 'MAP'>, <Type.STRUCT: 'STRUCT'>}
def strtodate_sql(self, expression: sqlglot.expressions.StrToDate) -> str:
967        def strtodate_sql(self, expression: exp.StrToDate) -> str:
968            strtodate_sql = self.function_fallback_sql(expression)
969
970            if not isinstance(expression.parent, exp.Cast):
971                # StrToDate returns DATEs in other dialects (eg. postgres), so
972                # this branch aims to improve the transpilation to clickhouse
973                return f"CAST({strtodate_sql} AS DATE)"
974
975            return strtodate_sql
def cast_sql( self, expression: sqlglot.expressions.Cast, safe_prefix: Optional[str] = None) -> str:
977        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
978            this = expression.this
979
980            if isinstance(this, exp.StrToDate) and expression.to == exp.DataType.build("datetime"):
981                return self.sql(this)
982
983            return super().cast_sql(expression, safe_prefix=safe_prefix)
def trycast_sql(self, expression: sqlglot.expressions.TryCast) -> str:
985        def trycast_sql(self, expression: exp.TryCast) -> str:
986            dtype = expression.to
987            if not dtype.is_type(*self.NON_NULLABLE_TYPES, check_nullable=True):
988                # Casting x into Nullable(T) appears to behave similarly to TRY_CAST(x AS T)
989                dtype.set("nullable", True)
990
991            return super().cast_sql(expression)
def likeproperty_sql(self, expression: sqlglot.expressions.LikeProperty) -> str:
997        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
998            return f"AS {self.sql(expression, 'this')}"
def eq_sql(self, expression: sqlglot.expressions.EQ) -> str:
1017        def eq_sql(self, expression: exp.EQ) -> str:
1018            return self._any_to_has(expression, super().eq_sql)
def neq_sql(self, expression: sqlglot.expressions.NEQ) -> str:
1020        def neq_sql(self, expression: exp.NEQ) -> str:
1021            return self._any_to_has(expression, super().neq_sql, "NOT ")
def regexpilike_sql(self, expression: sqlglot.expressions.RegexpILike) -> str:
1023        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
1024            # Manually add a flag to make the search case-insensitive
1025            regex = self.func("CONCAT", "'(?i)'", expression.expression)
1026            return self.func("match", expression.this, regex)
def datatype_sql(self, expression: sqlglot.expressions.DataType) -> str:
1028        def datatype_sql(self, expression: exp.DataType) -> str:
1029            # String is the standard ClickHouse type, every other variant is just an alias.
1030            # Additionally, any supplied length parameter will be ignored.
1031            #
1032            # https://clickhouse.com/docs/en/sql-reference/data-types/string
1033            if expression.this in self.STRING_TYPE_MAPPING:
1034                dtype = "String"
1035            else:
1036                dtype = super().datatype_sql(expression)
1037
1038            # This section changes the type to `Nullable(...)` if the following conditions hold:
1039            # - It's marked as nullable - this ensures we won't wrap ClickHouse types with `Nullable`
1040            #   and change their semantics
1041            # - It's not the key type of a `Map`. This is because ClickHouse enforces the following
1042            #   constraint: "Type of Map key must be a type, that can be represented by integer or
1043            #   String or FixedString (possibly LowCardinality) or UUID or IPv6"
1044            # - It's not a composite type, e.g. `Nullable(Array(...))` is not a valid type
1045            parent = expression.parent
1046            nullable = expression.args.get("nullable")
1047            if nullable is True or (
1048                nullable is None
1049                and not (
1050                    isinstance(parent, exp.DataType)
1051                    and parent.is_type(exp.DataType.Type.MAP, check_nullable=True)
1052                    and expression.index in (None, 0)
1053                )
1054                and not expression.is_type(*self.NON_NULLABLE_TYPES, check_nullable=True)
1055            ):
1056                dtype = f"Nullable({dtype})"
1057
1058            return dtype
def cte_sql(self, expression: sqlglot.expressions.CTE) -> str:
1060        def cte_sql(self, expression: exp.CTE) -> str:
1061            if expression.args.get("scalar"):
1062                this = self.sql(expression, "this")
1063                alias = self.sql(expression, "alias")
1064                return f"{this} AS {alias}"
1065
1066            return super().cte_sql(expression)
def after_limit_modifiers(self, expression: sqlglot.expressions.Expression) -> List[str]:
1068        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
1069            return super().after_limit_modifiers(expression) + [
1070                (
1071                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
1072                    if expression.args.get("settings")
1073                    else ""
1074                ),
1075                (
1076                    self.seg("FORMAT ") + self.sql(expression, "format")
1077                    if expression.args.get("format")
1078                    else ""
1079                ),
1080            ]
def parameterizedagg_sql(self, expression: sqlglot.expressions.ParameterizedAgg) -> str:
1082        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
1083            params = self.expressions(expression, key="params", flat=True)
1084            return self.func(expression.name, *expression.expressions) + f"({params})"
def anonymousaggfunc_sql(self, expression: sqlglot.expressions.AnonymousAggFunc) -> str:
1086        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
1087            return self.func(expression.name, *expression.expressions)
def combinedaggfunc_sql(self, expression: sqlglot.expressions.CombinedAggFunc) -> str:
1089        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
1090            return self.anonymousaggfunc_sql(expression)
def combinedparameterizedagg_sql(self, expression: sqlglot.expressions.CombinedParameterizedAgg) -> str:
1092        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
1093            return self.parameterizedagg_sql(expression)
def placeholder_sql(self, expression: sqlglot.expressions.Placeholder) -> str:
1095        def placeholder_sql(self, expression: exp.Placeholder) -> str:
1096            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
def oncluster_sql(self, expression: sqlglot.expressions.OnCluster) -> str:
1098        def oncluster_sql(self, expression: exp.OnCluster) -> str:
1099            return f"ON CLUSTER {self.sql(expression, 'this')}"
def createable_sql( self, expression: sqlglot.expressions.Create, locations: DefaultDict) -> str:
1101        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
1102            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
1103                exp.Properties.Location.POST_NAME
1104            ):
1105                this_name = self.sql(
1106                    expression.this if isinstance(expression.this, exp.Schema) else expression,
1107                    "this",
1108                )
1109                this_properties = " ".join(
1110                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
1111                )
1112                this_schema = self.schema_columns_sql(expression.this)
1113                this_schema = f"{self.sep()}{this_schema}" if this_schema else ""
1114
1115                return f"{this_name}{self.sep()}{this_properties}{this_schema}"
1116
1117            return super().createable_sql(expression, locations)
def create_sql(self, expression: sqlglot.expressions.Create) -> str:
1119        def create_sql(self, expression: exp.Create) -> str:
1120            # The comment property comes last in CTAS statements, i.e. after the query
1121            query = expression.expression
1122            if isinstance(query, exp.Query):
1123                comment_prop = expression.find(exp.SchemaCommentProperty)
1124                if comment_prop:
1125                    comment_prop.pop()
1126                    query.replace(exp.paren(query))
1127            else:
1128                comment_prop = None
1129
1130            create_sql = super().create_sql(expression)
1131
1132            comment_sql = self.sql(comment_prop)
1133            comment_sql = f" {comment_sql}" if comment_sql else ""
1134
1135            return f"{create_sql}{comment_sql}"
def prewhere_sql(self, expression: sqlglot.expressions.PreWhere) -> str:
1137        def prewhere_sql(self, expression: exp.PreWhere) -> str:
1138            this = self.indent(self.sql(expression, "this"))
1139            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
def indexcolumnconstraint_sql(self, expression: sqlglot.expressions.IndexColumnConstraint) -> str:
1141        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
1142            this = self.sql(expression, "this")
1143            this = f" {this}" if this else ""
1144            expr = self.sql(expression, "expression")
1145            expr = f" {expr}" if expr else ""
1146            index_type = self.sql(expression, "index_type")
1147            index_type = f" TYPE {index_type}" if index_type else ""
1148            granularity = self.sql(expression, "granularity")
1149            granularity = f" GRANULARITY {granularity}" if granularity else ""
1150
1151            return f"INDEX{this}{expr}{index_type}{granularity}"
def partition_sql(self, expression: sqlglot.expressions.Partition) -> str:
1153        def partition_sql(self, expression: exp.Partition) -> str:
1154            return f"PARTITION {self.expressions(expression, flat=True)}"
def partitionid_sql(self, expression: sqlglot.expressions.PartitionId) -> str:
1156        def partitionid_sql(self, expression: exp.PartitionId) -> str:
1157            return f"ID {self.sql(expression.this)}"
def replacepartition_sql(self, expression: sqlglot.expressions.ReplacePartition) -> str:
1159        def replacepartition_sql(self, expression: exp.ReplacePartition) -> str:
1160            return (
1161                f"REPLACE {self.sql(expression.expression)} FROM {self.sql(expression, 'source')}"
1162            )
def projectiondef_sql(self, expression: sqlglot.expressions.ProjectionDef) -> str:
1164        def projectiondef_sql(self, expression: exp.ProjectionDef) -> str:
1165            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
EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE
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
set_operation
set_operations
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
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
groupingsets_sql
rollup_sql
cube_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
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
alterrename_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
duplicatekeyproperty_sql
distributedbyproperty_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
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
json_sql
jsonvalue_sql
conditionalinsert_sql
multitableinserts_sql
oncondition_sql
jsonexists_sql
arrayagg_sql
apply_sql
grant_sql
grantprivilege_sql
grantprincipal_sql
columns_sql
overlay_sql
todouble_sql