Edit on GitHub

sqlglot.dialects.clickhouse

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

PRESERVE_ORIGINAL_NAMES = True

Whether the name of the function should be preserved inside the node's metadata, can be useful for roundtripping deprecated vs new functions that share an AST node e.g JSON_VALUE vs JSON_EXTRACT_SCALAR in BigQuery

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):
186    class Tokenizer(tokens.Tokenizer):
187        COMMENTS = ["--", "#", "#!", ("/*", "*/")]
188        IDENTIFIERS = ['"', "`"]
189        IDENTIFIER_ESCAPES = ["\\"]
190        STRING_ESCAPES = ["'", "\\"]
191        BIT_STRINGS = [("0b", "")]
192        HEX_STRINGS = [("0x", ""), ("0X", "")]
193        HEREDOC_STRINGS = ["$"]
194
195        KEYWORDS = {
196            **tokens.Tokenizer.KEYWORDS,
197            "ATTACH": TokenType.COMMAND,
198            "DATE32": TokenType.DATE32,
199            "DATETIME64": TokenType.DATETIME64,
200            "DICTIONARY": TokenType.DICTIONARY,
201            "ENUM8": TokenType.ENUM8,
202            "ENUM16": TokenType.ENUM16,
203            "FINAL": TokenType.FINAL,
204            "FIXEDSTRING": TokenType.FIXEDSTRING,
205            "FLOAT32": TokenType.FLOAT,
206            "FLOAT64": TokenType.DOUBLE,
207            "GLOBAL": TokenType.GLOBAL,
208            "INT256": TokenType.INT256,
209            "LOWCARDINALITY": TokenType.LOWCARDINALITY,
210            "MAP": TokenType.MAP,
211            "NESTED": TokenType.NESTED,
212            "SAMPLE": TokenType.TABLE_SAMPLE,
213            "TUPLE": TokenType.STRUCT,
214            "UINT128": TokenType.UINT128,
215            "UINT16": TokenType.USMALLINT,
216            "UINT256": TokenType.UINT256,
217            "UINT32": TokenType.UINT,
218            "UINT64": TokenType.UBIGINT,
219            "UINT8": TokenType.UTINYINT,
220            "IPV4": TokenType.IPV4,
221            "IPV6": TokenType.IPV6,
222            "POINT": TokenType.POINT,
223            "RING": TokenType.RING,
224            "LINESTRING": TokenType.LINESTRING,
225            "MULTILINESTRING": TokenType.MULTILINESTRING,
226            "POLYGON": TokenType.POLYGON,
227            "MULTIPOLYGON": TokenType.MULTIPOLYGON,
228            "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION,
229            "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION,
230            "SYSTEM": TokenType.COMMAND,
231            "PREWHERE": TokenType.PREWHERE,
232        }
233        KEYWORDS.pop("/*+")
234
235        SINGLE_TOKENS = {
236            **tokens.Tokenizer.SINGLE_TOKENS,
237            "$": TokenType.HEREDOC_STRING,
238        }
COMMENTS = ['--', '#', '#!', ('/*', '*/')]
IDENTIFIERS = ['"', '`']
IDENTIFIER_ESCAPES = ['\\']
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'>, 'DECIMAL256': <TokenType.DECIMAL256: 'DECIMAL256'>, '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'>, 'POINT': <TokenType.POINT: 'POINT'>, 'RING': <TokenType.RING: 'RING'>, 'LINESTRING': <TokenType.LINESTRING: 'LINESTRING'>, 'MULTILINESTRING': <TokenType.MULTILINESTRING: 'MULTILINESTRING'>, 'POLYGON': <TokenType.POLYGON: 'POLYGON'>, 'MULTIPOLYGON': <TokenType.MULTIPOLYGON: 'MULTIPOLYGON'>, '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):
240    class Parser(parser.Parser):
241        # Tested in ClickHouse's playground, it seems that the following two queries do the same thing
242        # * select x from t1 union all select x from t2 limit 1;
243        # * select x from t1 union all (select x from t2 limit 1);
244        MODIFIERS_ATTACHED_TO_SET_OP = False
245        INTERVAL_SPANS = False
246
247        FUNCTIONS = {
248            **parser.Parser.FUNCTIONS,
249            "ANY": exp.AnyValue.from_arg_list,
250            "ARRAYSUM": exp.ArraySum.from_arg_list,
251            "COUNTIF": _build_count_if,
252            "DATE_ADD": build_date_delta(exp.DateAdd, default_unit=None),
253            "DATEADD": build_date_delta(exp.DateAdd, default_unit=None),
254            "DATE_DIFF": build_date_delta(exp.DateDiff, default_unit=None),
255            "DATEDIFF": build_date_delta(exp.DateDiff, default_unit=None),
256            "DATE_FORMAT": _build_date_format,
257            "DATE_SUB": build_date_delta(exp.DateSub, default_unit=None),
258            "DATESUB": build_date_delta(exp.DateSub, default_unit=None),
259            "FORMATDATETIME": _build_date_format,
260            "JSONEXTRACTSTRING": build_json_extract_path(
261                exp.JSONExtractScalar, zero_based_indexing=False
262            ),
263            "MAP": parser.build_var_map,
264            "MATCH": exp.RegexpLike.from_arg_list,
265            "RANDCANONICAL": exp.Rand.from_arg_list,
266            "STR_TO_DATE": _build_str_to_date,
267            "TUPLE": exp.Struct.from_arg_list,
268            "TIMESTAMP_SUB": build_date_delta(exp.TimestampSub, default_unit=None),
269            "TIMESTAMPSUB": build_date_delta(exp.TimestampSub, default_unit=None),
270            "TIMESTAMP_ADD": build_date_delta(exp.TimestampAdd, default_unit=None),
271            "TIMESTAMPADD": build_date_delta(exp.TimestampAdd, default_unit=None),
272            "UNIQ": exp.ApproxDistinct.from_arg_list,
273            "XOR": lambda args: exp.Xor(expressions=args),
274            "MD5": exp.MD5Digest.from_arg_list,
275            "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
276            "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
277            "EDITDISTANCE": exp.Levenshtein.from_arg_list,
278            "LEVENSHTEINDISTANCE": exp.Levenshtein.from_arg_list,
279        }
280        FUNCTIONS.pop("TRANSFORM")
281
282        AGG_FUNCTIONS = {
283            "count",
284            "min",
285            "max",
286            "sum",
287            "avg",
288            "any",
289            "stddevPop",
290            "stddevSamp",
291            "varPop",
292            "varSamp",
293            "corr",
294            "covarPop",
295            "covarSamp",
296            "entropy",
297            "exponentialMovingAverage",
298            "intervalLengthSum",
299            "kolmogorovSmirnovTest",
300            "mannWhitneyUTest",
301            "median",
302            "rankCorr",
303            "sumKahan",
304            "studentTTest",
305            "welchTTest",
306            "anyHeavy",
307            "anyLast",
308            "boundingRatio",
309            "first_value",
310            "last_value",
311            "argMin",
312            "argMax",
313            "avgWeighted",
314            "topK",
315            "topKWeighted",
316            "deltaSum",
317            "deltaSumTimestamp",
318            "groupArray",
319            "groupArrayLast",
320            "groupUniqArray",
321            "groupArrayInsertAt",
322            "groupArrayMovingAvg",
323            "groupArrayMovingSum",
324            "groupArraySample",
325            "groupBitAnd",
326            "groupBitOr",
327            "groupBitXor",
328            "groupBitmap",
329            "groupBitmapAnd",
330            "groupBitmapOr",
331            "groupBitmapXor",
332            "sumWithOverflow",
333            "sumMap",
334            "minMap",
335            "maxMap",
336            "skewSamp",
337            "skewPop",
338            "kurtSamp",
339            "kurtPop",
340            "uniq",
341            "uniqExact",
342            "uniqCombined",
343            "uniqCombined64",
344            "uniqHLL12",
345            "uniqTheta",
346            "quantile",
347            "quantiles",
348            "quantileExact",
349            "quantilesExact",
350            "quantileExactLow",
351            "quantilesExactLow",
352            "quantileExactHigh",
353            "quantilesExactHigh",
354            "quantileExactWeighted",
355            "quantilesExactWeighted",
356            "quantileTiming",
357            "quantilesTiming",
358            "quantileTimingWeighted",
359            "quantilesTimingWeighted",
360            "quantileDeterministic",
361            "quantilesDeterministic",
362            "quantileTDigest",
363            "quantilesTDigest",
364            "quantileTDigestWeighted",
365            "quantilesTDigestWeighted",
366            "quantileBFloat16",
367            "quantilesBFloat16",
368            "quantileBFloat16Weighted",
369            "quantilesBFloat16Weighted",
370            "simpleLinearRegression",
371            "stochasticLinearRegression",
372            "stochasticLogisticRegression",
373            "categoricalInformationValue",
374            "contingency",
375            "cramersV",
376            "cramersVBiasCorrected",
377            "theilsU",
378            "maxIntersections",
379            "maxIntersectionsPosition",
380            "meanZTest",
381            "quantileInterpolatedWeighted",
382            "quantilesInterpolatedWeighted",
383            "quantileGK",
384            "quantilesGK",
385            "sparkBar",
386            "sumCount",
387            "largestTriangleThreeBuckets",
388            "histogram",
389            "sequenceMatch",
390            "sequenceCount",
391            "windowFunnel",
392            "retention",
393            "uniqUpTo",
394            "sequenceNextNode",
395            "exponentialTimeDecayedAvg",
396        }
397
398        AGG_FUNCTIONS_SUFFIXES = [
399            "If",
400            "Array",
401            "ArrayIf",
402            "Map",
403            "SimpleState",
404            "State",
405            "Merge",
406            "MergeState",
407            "ForEach",
408            "Distinct",
409            "OrDefault",
410            "OrNull",
411            "Resample",
412            "ArgMin",
413            "ArgMax",
414        ]
415
416        FUNC_TOKENS = {
417            *parser.Parser.FUNC_TOKENS,
418            TokenType.SET,
419        }
420
421        RESERVED_TOKENS = parser.Parser.RESERVED_TOKENS - {TokenType.SELECT}
422
423        ID_VAR_TOKENS = {
424            *parser.Parser.ID_VAR_TOKENS,
425            TokenType.LIKE,
426        }
427
428        AGG_FUNC_MAPPING = (
429            lambda functions, suffixes: {
430                f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions
431            }
432        )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES)
433
434        FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"}
435
436        FUNCTION_PARSERS = {
437            **parser.Parser.FUNCTION_PARSERS,
438            "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()),
439            "QUANTILE": lambda self: self._parse_quantile(),
440            "MEDIAN": lambda self: self._parse_quantile(),
441            "COLUMNS": lambda self: self._parse_columns(),
442        }
443
444        FUNCTION_PARSERS.pop("MATCH")
445
446        NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy()
447        NO_PAREN_FUNCTION_PARSERS.pop("ANY")
448
449        NO_PAREN_FUNCTIONS = parser.Parser.NO_PAREN_FUNCTIONS.copy()
450        NO_PAREN_FUNCTIONS.pop(TokenType.CURRENT_TIMESTAMP)
451
452        RANGE_PARSERS = {
453            **parser.Parser.RANGE_PARSERS,
454            TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN)
455            and self._parse_in(this, is_global=True),
456        }
457
458        # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to
459        # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler.
460        COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy()
461        COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
462
463        JOIN_KINDS = {
464            *parser.Parser.JOIN_KINDS,
465            TokenType.ANY,
466            TokenType.ASOF,
467            TokenType.ARRAY,
468        }
469
470        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
471            TokenType.ANY,
472            TokenType.ARRAY,
473            TokenType.FINAL,
474            TokenType.FORMAT,
475            TokenType.SETTINGS,
476        }
477
478        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
479            TokenType.FORMAT,
480        }
481
482        LOG_DEFAULTS_TO_LN = True
483
484        QUERY_MODIFIER_PARSERS = {
485            **parser.Parser.QUERY_MODIFIER_PARSERS,
486            TokenType.SETTINGS: lambda self: (
487                "settings",
488                self._advance() or self._parse_csv(self._parse_assignment),
489            ),
490            TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
491        }
492
493        CONSTRAINT_PARSERS = {
494            **parser.Parser.CONSTRAINT_PARSERS,
495            "INDEX": lambda self: self._parse_index_constraint(),
496            "CODEC": lambda self: self._parse_compress(),
497        }
498
499        ALTER_PARSERS = {
500            **parser.Parser.ALTER_PARSERS,
501            "REPLACE": lambda self: self._parse_alter_table_replace(),
502        }
503
504        SCHEMA_UNNAMED_CONSTRAINTS = {
505            *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
506            "INDEX",
507        }
508
509        PLACEHOLDER_PARSERS = {
510            **parser.Parser.PLACEHOLDER_PARSERS,
511            TokenType.L_BRACE: lambda self: self._parse_query_parameter(),
512        }
513
514        # https://clickhouse.com/docs/en/sql-reference/statements/create/function
515        def _parse_user_defined_function_expression(self) -> t.Optional[exp.Expression]:
516            return self._parse_lambda()
517
518        def _parse_types(
519            self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
520        ) -> t.Optional[exp.Expression]:
521            dtype = super()._parse_types(
522                check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
523            )
524            if isinstance(dtype, exp.DataType) and dtype.args.get("nullable") is not True:
525                # Mark every type as non-nullable which is ClickHouse's default, unless it's
526                # already marked as nullable. This marker helps us transpile types from other
527                # dialects to ClickHouse, so that we can e.g. produce `CAST(x AS Nullable(String))`
528                # from `CAST(x AS TEXT)`. If there is a `NULL` value in `x`, the former would
529                # fail in ClickHouse without the `Nullable` type constructor.
530                dtype.set("nullable", False)
531
532            return dtype
533
534        def _parse_extract(self) -> exp.Extract | exp.Anonymous:
535            index = self._index
536            this = self._parse_bitwise()
537            if self._match(TokenType.FROM):
538                self._retreat(index)
539                return super()._parse_extract()
540
541            # We return Anonymous here because extract and regexpExtract have different semantics,
542            # so parsing extract(foo, bar) into RegexpExtract can potentially break queries. E.g.,
543            # `extract('foobar', 'b')` works, but ClickHouse crashes for `regexpExtract('foobar', 'b')`.
544            #
545            # TODO: can we somehow convert the former into an equivalent `regexpExtract` call?
546            self._match(TokenType.COMMA)
547            return self.expression(
548                exp.Anonymous, this="extract", expressions=[this, self._parse_bitwise()]
549            )
550
551        def _parse_assignment(self) -> t.Optional[exp.Expression]:
552            this = super()._parse_assignment()
553
554            if self._match(TokenType.PLACEHOLDER):
555                return self.expression(
556                    exp.If,
557                    this=this,
558                    true=self._parse_assignment(),
559                    false=self._match(TokenType.COLON) and self._parse_assignment(),
560                )
561
562            return this
563
564        def _parse_query_parameter(self) -> t.Optional[exp.Expression]:
565            """
566            Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
567            https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
568            """
569            index = self._index
570
571            this = self._parse_id_var()
572            self._match(TokenType.COLON)
573            kind = self._parse_types(check_func=False, allow_identifiers=False) or (
574                self._match_text_seq("IDENTIFIER") and "Identifier"
575            )
576
577            if not kind:
578                self._retreat(index)
579                return None
580            elif not self._match(TokenType.R_BRACE):
581                self.raise_error("Expecting }")
582
583            return self.expression(exp.Placeholder, this=this, kind=kind)
584
585        def _parse_bracket(
586            self, this: t.Optional[exp.Expression] = None
587        ) -> t.Optional[exp.Expression]:
588            l_brace = self._match(TokenType.L_BRACE, advance=False)
589            bracket = super()._parse_bracket(this)
590
591            if l_brace and isinstance(bracket, exp.Struct):
592                varmap = exp.VarMap(keys=exp.Array(), values=exp.Array())
593                for expression in bracket.expressions:
594                    if not isinstance(expression, exp.PropertyEQ):
595                        break
596
597                    varmap.args["keys"].append("expressions", exp.Literal.string(expression.name))
598                    varmap.args["values"].append("expressions", expression.expression)
599
600                return varmap
601
602            return bracket
603
604        def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In:
605            this = super()._parse_in(this)
606            this.set("is_global", is_global)
607            return this
608
609        def _parse_table(
610            self,
611            schema: bool = False,
612            joins: bool = False,
613            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
614            parse_bracket: bool = False,
615            is_db_reference: bool = False,
616            parse_partition: bool = False,
617        ) -> t.Optional[exp.Expression]:
618            this = super()._parse_table(
619                schema=schema,
620                joins=joins,
621                alias_tokens=alias_tokens,
622                parse_bracket=parse_bracket,
623                is_db_reference=is_db_reference,
624            )
625
626            if self._match(TokenType.FINAL):
627                this = self.expression(exp.Final, this=this)
628
629            return this
630
631        def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
632            return super()._parse_position(haystack_first=True)
633
634        # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
635        def _parse_cte(self) -> exp.CTE:
636            # WITH <identifier> AS <subquery expression>
637            cte: t.Optional[exp.CTE] = self._try_parse(super()._parse_cte)
638
639            if not cte:
640                # WITH <expression> AS <identifier>
641                cte = self.expression(
642                    exp.CTE,
643                    this=self._parse_assignment(),
644                    alias=self._parse_table_alias(),
645                    scalar=True,
646                )
647
648            return cte
649
650        def _parse_join_parts(
651            self,
652        ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
653            is_global = self._match(TokenType.GLOBAL) and self._prev
654            kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev
655
656            if kind_pre:
657                kind = self._match_set(self.JOIN_KINDS) and self._prev
658                side = self._match_set(self.JOIN_SIDES) and self._prev
659                return is_global, side, kind
660
661            return (
662                is_global,
663                self._match_set(self.JOIN_SIDES) and self._prev,
664                self._match_set(self.JOIN_KINDS) and self._prev,
665            )
666
667        def _parse_join(
668            self, skip_join_token: bool = False, parse_bracket: bool = False
669        ) -> t.Optional[exp.Join]:
670            join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True)
671            if join:
672                join.set("global", join.args.pop("method", None))
673
674                # tbl ARRAY JOIN arr <-- this should be a `Column` reference, not a `Table`
675                # https://clickhouse.com/docs/en/sql-reference/statements/select/array-join
676                if join.kind == "ARRAY":
677                    for table in join.find_all(exp.Table):
678                        table.replace(table.to_column())
679
680            return join
681
682        def _parse_function(
683            self,
684            functions: t.Optional[t.Dict[str, t.Callable]] = None,
685            anonymous: bool = False,
686            optional_parens: bool = True,
687            any_token: bool = False,
688        ) -> t.Optional[exp.Expression]:
689            expr = super()._parse_function(
690                functions=functions,
691                anonymous=anonymous,
692                optional_parens=optional_parens,
693                any_token=any_token,
694            )
695
696            func = expr.this if isinstance(expr, exp.Window) else expr
697
698            # Aggregate functions can be split in 2 parts: <func_name><suffix>
699            parts = (
700                self.AGG_FUNC_MAPPING.get(func.this) if isinstance(func, exp.Anonymous) else None
701            )
702
703            if parts:
704                anon_func: exp.Anonymous = t.cast(exp.Anonymous, func)
705                params = self._parse_func_params(anon_func)
706
707                kwargs = {
708                    "this": anon_func.this,
709                    "expressions": anon_func.expressions,
710                }
711                if parts[1]:
712                    kwargs["parts"] = parts
713                    exp_class: t.Type[exp.Expression] = (
714                        exp.CombinedParameterizedAgg if params else exp.CombinedAggFunc
715                    )
716                else:
717                    exp_class = exp.ParameterizedAgg if params else exp.AnonymousAggFunc
718
719                kwargs["exp_class"] = exp_class
720                if params:
721                    kwargs["params"] = params
722
723                func = self.expression(**kwargs)
724
725                if isinstance(expr, exp.Window):
726                    # The window's func was parsed as Anonymous in base parser, fix its
727                    # type to be ClickHouse style CombinedAnonymousAggFunc / AnonymousAggFunc
728                    expr.set("this", func)
729                elif params:
730                    # Params have blocked super()._parse_function() from parsing the following window
731                    # (if that exists) as they're standing between the function call and the window spec
732                    expr = self._parse_window(func)
733                else:
734                    expr = func
735
736            return expr
737
738        def _parse_func_params(
739            self, this: t.Optional[exp.Func] = None
740        ) -> t.Optional[t.List[exp.Expression]]:
741            if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
742                return self._parse_csv(self._parse_lambda)
743
744            if self._match(TokenType.L_PAREN):
745                params = self._parse_csv(self._parse_lambda)
746                self._match_r_paren(this)
747                return params
748
749            return None
750
751        def _parse_quantile(self) -> exp.Quantile:
752            this = self._parse_lambda()
753            params = self._parse_func_params()
754            if params:
755                return self.expression(exp.Quantile, this=params[0], quantile=this)
756            return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5))
757
758        def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
759            return super()._parse_wrapped_id_vars(optional=True)
760
761        def _parse_primary_key(
762            self, wrapped_optional: bool = False, in_props: bool = False
763        ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
764            return super()._parse_primary_key(
765                wrapped_optional=wrapped_optional or in_props, in_props=in_props
766            )
767
768        def _parse_on_property(self) -> t.Optional[exp.Expression]:
769            index = self._index
770            if self._match_text_seq("CLUSTER"):
771                this = self._parse_id_var()
772                if this:
773                    return self.expression(exp.OnCluster, this=this)
774                else:
775                    self._retreat(index)
776            return None
777
778        def _parse_index_constraint(
779            self, kind: t.Optional[str] = None
780        ) -> exp.IndexColumnConstraint:
781            # INDEX name1 expr TYPE type1(args) GRANULARITY value
782            this = self._parse_id_var()
783            expression = self._parse_assignment()
784
785            index_type = self._match_text_seq("TYPE") and (
786                self._parse_function() or self._parse_var()
787            )
788
789            granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
790
791            return self.expression(
792                exp.IndexColumnConstraint,
793                this=this,
794                expression=expression,
795                index_type=index_type,
796                granularity=granularity,
797            )
798
799        def _parse_partition(self) -> t.Optional[exp.Partition]:
800            # https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#how-to-set-partition-expression
801            if not self._match(TokenType.PARTITION):
802                return None
803
804            if self._match_text_seq("ID"):
805                # Corresponds to the PARTITION ID <string_value> syntax
806                expressions: t.List[exp.Expression] = [
807                    self.expression(exp.PartitionId, this=self._parse_string())
808                ]
809            else:
810                expressions = self._parse_expressions()
811
812            return self.expression(exp.Partition, expressions=expressions)
813
814        def _parse_alter_table_replace(self) -> t.Optional[exp.Expression]:
815            partition = self._parse_partition()
816
817            if not partition or not self._match(TokenType.FROM):
818                return None
819
820            return self.expression(
821                exp.ReplacePartition, expression=partition, source=self._parse_table_parts()
822            )
823
824        def _parse_projection_def(self) -> t.Optional[exp.ProjectionDef]:
825            if not self._match_text_seq("PROJECTION"):
826                return None
827
828            return self.expression(
829                exp.ProjectionDef,
830                this=self._parse_id_var(),
831                expression=self._parse_wrapped(self._parse_statement),
832            )
833
834        def _parse_constraint(self) -> t.Optional[exp.Expression]:
835            return super()._parse_constraint() or self._parse_projection_def()
836
837        def _parse_alias(
838            self, this: t.Optional[exp.Expression], explicit: bool = False
839        ) -> t.Optional[exp.Expression]:
840            # In clickhouse "SELECT <expr> APPLY(...)" is a query modifier,
841            # so "APPLY" shouldn't be parsed as <expr>'s alias. However, "SELECT <expr> apply" is a valid alias
842            if self._match_pair(TokenType.APPLY, TokenType.L_PAREN, advance=False):
843                return this
844
845            return super()._parse_alias(this=this, explicit=explicit)
846
847        def _parse_expression(self) -> t.Optional[exp.Expression]:
848            this = super()._parse_expression()
849
850            # Clickhouse allows "SELECT <expr> [APPLY(func)] [...]]" modifier
851            while self._match_pair(TokenType.APPLY, TokenType.L_PAREN):
852                this = exp.Apply(this=this, expression=self._parse_var(any_token=True))
853                self._match(TokenType.R_PAREN)
854
855            return this
856
857        def _parse_columns(self) -> exp.Expression:
858            this: exp.Expression = self.expression(exp.Columns, this=self._parse_lambda())
859
860            while self._next and self._match_text_seq(")", "APPLY", "("):
861                self._match(TokenType.R_PAREN)
862                this = exp.Apply(this=this, expression=self._parse_var(any_token=True))
863            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'>>, 'CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Contains'>>, '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'>>, 'EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Exists'>>, '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'>>, 'FEATURES_AT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FeaturesAtTime'>>, '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'>>, 'INT64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Int64'>>, '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_EXISTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExists'>>, '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_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONExtractArray'>>, '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'>>, 'J_S_O_N_VALUE_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONValueArray'>>, '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'>>, 'MAKE_INTERVAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MakeInterval'>>, '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'>>, 'MEDIAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Median'>>, '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_EXTRACT_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpExtractAll'>>, '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': <bound method Func.from_arg_list of <class 'sqlglot.expressions.String'>>, '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'>>, '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_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToDatetime'>>, '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_SECONDS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixSeconds'>>, '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'>>, 'XMLELEMENT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.XMLElement'>>, '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>>, 'EDITDISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Levenshtein'>>, 'LEVENSHTEINDISTANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Levenshtein'>>}
AGG_FUNCTIONS = {'retention', 'quantilesExact', 'windowFunnel', 'sumWithOverflow', 'min', 'kurtSamp', 'quantileDeterministic', 'quantileExactHigh', 'quantileExactLow', 'argMax', 'groupBitXor', 'quantilesTDigest', 'topKWeighted', 'quantilesBFloat16', 'cramersVBiasCorrected', 'exponentialMovingAverage', 'anyHeavy', 'topK', 'sumCount', 'sumKahan', 'sumMap', 'theilsU', 'maxMap', 'entropy', 'welchTTest', 'varPop', 'corr', 'quantileTDigest', 'skewPop', 'groupBitmapOr', 'exponentialTimeDecayedAvg', 'minMap', 'boundingRatio', 'uniqCombined', 'groupArrayMovingSum', 'sum', 'stddevPop', 'groupBitAnd', 'quantileInterpolatedWeighted', 'uniqTheta', 'sequenceNextNode', 'groupUniqArray', 'max', 'skewSamp', 'quantilesBFloat16Weighted', 'quantilesExactLow', 'quantilesDeterministic', 'groupBitmap', 'cramersV', 'categoricalInformationValue', 'meanZTest', 'stochasticLogisticRegression', 'quantilesInterpolatedWeighted', 'quantiles', 'uniqCombined64', 'kurtPop', 'intervalLengthSum', 'quantileExactWeighted', 'histogram', 'avg', 'uniq', 'uniqUpTo', 'stddevSamp', 'largestTriangleThreeBuckets', 'median', 'deltaSum', 'groupBitmapXor', 'quantileBFloat16', 'simpleLinearRegression', 'quantile', 'stochasticLinearRegression', 'quantilesTiming', 'contingency', 'covarSamp', 'deltaSumTimestamp', 'uniqHLL12', 'maxIntersections', 'quantileTDigestWeighted', 'groupArrayInsertAt', 'uniqExact', 'last_value', 'quantilesTimingWeighted', 'groupArraySample', 'quantileBFloat16Weighted', 'quantilesTDigestWeighted', 'quantilesExactWeighted', 'rankCorr', 'groupBitOr', 'groupArray', 'sequenceMatch', 'quantileTiming', 'anyLast', 'avgWeighted', 'groupArrayMovingAvg', 'first_value', 'quantilesGK', 'argMin', 'quantilesExactHigh', 'count', 'varSamp', 'quantileExact', 'kolmogorovSmirnovTest', 'groupBitmapAnd', 'sparkBar', 'covarPop', 'groupArrayLast', 'mannWhitneyUTest', 'studentTTest', 'quantileTimingWeighted', 'any', 'sequenceCount', 'quantileGK', 'maxIntersectionsPosition'}
AGG_FUNCTIONS_SUFFIXES = ['If', 'Array', 'ArrayIf', 'Map', 'SimpleState', 'State', 'Merge', 'MergeState', 'ForEach', 'Distinct', 'OrDefault', 'OrNull', 'Resample', 'ArgMin', 'ArgMax']
FUNC_TOKENS = {<TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.TABLE: 'TABLE'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.NESTED: 'NESTED'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.RLIKE: 'RLIKE'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.FIRST: 'FIRST'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.YEAR: 'YEAR'>, <TokenType.SET: 'SET'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.LIKE: 'LIKE'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.POLYGON: 'POLYGON'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DECIMAL256: 'DECIMAL256'>, <TokenType.DATETIME2: 'DATETIME2'>, <TokenType.LEFT: 'LEFT'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.INT128: 'INT128'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.DECIMAL64: 'DECIMAL64'>, <TokenType.POINT: 'POINT'>, <TokenType.TIME: 'TIME'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.UINT: 'UINT'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.IPV6: 'IPV6'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.JSONB: 'JSONB'>, <TokenType.IPV4: 'IPV4'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.JSON: 'JSON'>, <TokenType.RING: 'RING'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.VAR: 'VAR'>, <TokenType.DATE32: 'DATE32'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.INET: 'INET'>, <TokenType.XML: 'XML'>, <TokenType.GLOB: 'GLOB'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.BINARY: 'BINARY'>, <TokenType.LINESTRING: 'LINESTRING'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.FILTER: 'FILTER'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.ILIKE: 'ILIKE'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.UINT256: 'UINT256'>, <TokenType.UINT128: 'UINT128'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.ROW: 'ROW'>, <TokenType.INT256: 'INT256'>, <TokenType.INT: 'INT'>, <TokenType.NULL: 'NULL'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.SUPER: 'SUPER'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.NAME: 'NAME'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.SOME: 'SOME'>, <TokenType.MAP: 'MAP'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.XOR: 'XOR'>, <TokenType.BIT: 'BIT'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.UNION: 'UNION'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.CHAR: 'CHAR'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.MONEY: 'MONEY'>, <TokenType.ALL: 'ALL'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.INDEX: 'INDEX'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.MULTILINESTRING: 'MULTILINESTRING'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.UUID: 'UUID'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.ENUM: 'ENUM'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.MULTIPOLYGON: 'MULTIPOLYGON'>, <TokenType.TEXT: 'TEXT'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.DECIMAL32: 'DECIMAL32'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.DATE: 'DATE'>, <TokenType.DECIMAL128: 'DECIMAL128'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.INSERT: 'INSERT'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.RANGE: 'RANGE'>, <TokenType.SMALLDATETIME: 'SMALLDATETIME'>, <TokenType.ANY: 'ANY'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.MERGE: 'MERGE'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.NEXT: 'NEXT'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.LIST: 'LIST'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.TIMETZ: 'TIMETZ'>}
RESERVED_TOKENS = {<TokenType.EQ: 'EQ'>, <TokenType.L_PAREN: 'L_PAREN'>, <TokenType.SEMICOLON: 'SEMICOLON'>, <TokenType.CARET: 'CARET'>, <TokenType.HASH: 'HASH'>, <TokenType.TILDA: 'TILDA'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.LT: 'LT'>, <TokenType.BACKSLASH: 'BACKSLASH'>, <TokenType.L_BRACKET: 'L_BRACKET'>, <TokenType.PARAMETER: 'PARAMETER'>, <TokenType.STAR: 'STAR'>, <TokenType.PLACEHOLDER: 'PLACEHOLDER'>, <TokenType.MOD: 'MOD'>, <TokenType.PLUS: 'PLUS'>, <TokenType.NOT: 'NOT'>, <TokenType.L_BRACE: 'L_BRACE'>, <TokenType.DOT: 'DOT'>, <TokenType.R_BRACKET: 'R_BRACKET'>, <TokenType.R_PAREN: 'R_PAREN'>, <TokenType.COMMA: 'COMMA'>, <TokenType.R_BRACE: 'R_BRACE'>, <TokenType.AMP: 'AMP'>, <TokenType.GT: 'GT'>, <TokenType.PIPE: 'PIPE'>, <TokenType.DASH: 'DASH'>, <TokenType.SLASH: 'SLASH'>, <TokenType.COLON: 'COLON'>}
ID_VAR_TOKENS = {<TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.TABLE: 'TABLE'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.NESTED: 'NESTED'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.FIRST: 'FIRST'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.YEAR: 'YEAR'>, <TokenType.SET: 'SET'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.LIKE: 'LIKE'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.POLYGON: 'POLYGON'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DECIMAL256: 'DECIMAL256'>, <TokenType.DATETIME2: 'DATETIME2'>, <TokenType.LEFT: 'LEFT'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.INT128: 'INT128'>, <TokenType.CASE: 'CASE'>, <TokenType.END: 'END'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.DECIMAL64: 'DECIMAL64'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.POINT: 'POINT'>, <TokenType.TIME: 'TIME'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.UINT: 'UINT'>, <TokenType.ASC: 'ASC'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.FULL: 'FULL'>, <TokenType.IPV6: 'IPV6'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.ATTACH: 'ATTACH'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.FINAL: 'FINAL'>, <TokenType.CACHE: 'CACHE'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.JSONB: 'JSONB'>, <TokenType.DETACH: 'DETACH'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.IPV4: 'IPV4'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.JSON: 'JSON'>, <TokenType.SINK: 'SINK'>, <TokenType.RING: 'RING'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.VAR: 'VAR'>, <TokenType.DATE32: 'DATE32'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.ANTI: 'ANTI'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.SEMI: 'SEMI'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.ROWS: 'ROWS'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.INET: 'INET'>, <TokenType.CUBE: 'CUBE'>, <TokenType.XML: 'XML'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.SOURCE: 'SOURCE'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.COPY: 'COPY'>, <TokenType.BINARY: 'BINARY'>, <TokenType.LINESTRING: 'LINESTRING'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.FILTER: 'FILTER'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.USE: 'USE'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.UINT256: 'UINT256'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.UINT128: 'UINT128'>, <TokenType.INT256: 'INT256'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.ROW: 'ROW'>, <TokenType.INT: 'INT'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.NULL: 'NULL'>, <TokenType.RENAME: 'RENAME'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.SUPER: 'SUPER'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.NAME: 'NAME'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.KILL: 'KILL'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.APPLY: 'APPLY'>, <TokenType.SOME: 'SOME'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.MAP: 'MAP'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.LOAD: 'LOAD'>, <TokenType.TAG: 'TAG'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.BIT: 'BIT'>, <TokenType.DIV: 'DIV'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.IS: 'IS'>, <TokenType.ASOF: 'ASOF'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.MODEL: 'MODEL'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.ALL: 'ALL'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.CHAR: 'CHAR'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.MONEY: 'MONEY'>, <TokenType.FALSE: 'FALSE'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.INDEX: 'INDEX'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.MULTILINESTRING: 'MULTILINESTRING'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.UUID: 'UUID'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.KEEP: 'KEEP'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.DESC: 'DESC'>, <TokenType.ENUM: 'ENUM'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.TOP: 'TOP'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.MULTIPOLYGON: 'MULTIPOLYGON'>, <TokenType.TEXT: 'TEXT'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.DECIMAL32: 'DECIMAL32'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.DATE: 'DATE'>, <TokenType.DECIMAL128: 'DECIMAL128'>, <TokenType.SHOW: 'SHOW'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.VIEW: 'VIEW'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.RANGE: 'RANGE'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.SMALLDATETIME: 'SMALLDATETIME'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.TRUE: 'TRUE'>, <TokenType.ANY: 'ANY'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.MERGE: 'MERGE'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, <TokenType.DELETE: 'DELETE'>, <TokenType.NEXT: 'NEXT'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.LIST: 'LIST'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.TIMETZ: 'TIMETZ'>}
AGG_FUNC_MAPPING = {'retentionIf': ('retention', 'If'), 'quantilesExactIf': ('quantilesExact', 'If'), 'windowFunnelIf': ('windowFunnel', 'If'), 'sumWithOverflowIf': ('sumWithOverflow', 'If'), 'minIf': ('min', 'If'), 'kurtSampIf': ('kurtSamp', 'If'), 'quantileDeterministicIf': ('quantileDeterministic', 'If'), 'quantileExactHighIf': ('quantileExactHigh', 'If'), 'quantileExactLowIf': ('quantileExactLow', 'If'), 'argMaxIf': ('argMax', 'If'), 'groupBitXorIf': ('groupBitXor', 'If'), 'quantilesTDigestIf': ('quantilesTDigest', 'If'), 'topKWeightedIf': ('topKWeighted', 'If'), 'quantilesBFloat16If': ('quantilesBFloat16', 'If'), 'cramersVBiasCorrectedIf': ('cramersVBiasCorrected', 'If'), 'exponentialMovingAverageIf': ('exponentialMovingAverage', 'If'), 'anyHeavyIf': ('anyHeavy', 'If'), 'topKIf': ('topK', 'If'), 'sumCountIf': ('sumCount', 'If'), 'sumKahanIf': ('sumKahan', 'If'), 'sumMapIf': ('sumMap', 'If'), 'theilsUIf': ('theilsU', 'If'), 'maxMapIf': ('maxMap', 'If'), 'entropyIf': ('entropy', 'If'), 'welchTTestIf': ('welchTTest', 'If'), 'varPopIf': ('varPop', 'If'), 'corrIf': ('corr', 'If'), 'quantileTDigestIf': ('quantileTDigest', 'If'), 'skewPopIf': ('skewPop', 'If'), 'groupBitmapOrIf': ('groupBitmapOr', 'If'), 'exponentialTimeDecayedAvgIf': ('exponentialTimeDecayedAvg', 'If'), 'minMapIf': ('minMap', 'If'), 'boundingRatioIf': ('boundingRatio', 'If'), 'uniqCombinedIf': ('uniqCombined', 'If'), 'groupArrayMovingSumIf': ('groupArrayMovingSum', 'If'), 'sumIf': ('sum', 'If'), 'stddevPopIf': ('stddevPop', 'If'), 'groupBitAndIf': ('groupBitAnd', 'If'), 'quantileInterpolatedWeightedIf': ('quantileInterpolatedWeighted', 'If'), 'uniqThetaIf': ('uniqTheta', 'If'), 'sequenceNextNodeIf': ('sequenceNextNode', 'If'), 'groupUniqArrayIf': ('groupUniqArray', 'If'), 'maxIf': ('max', 'If'), 'skewSampIf': ('skewSamp', 'If'), 'quantilesBFloat16WeightedIf': ('quantilesBFloat16Weighted', 'If'), 'quantilesExactLowIf': ('quantilesExactLow', 'If'), 'quantilesDeterministicIf': ('quantilesDeterministic', 'If'), 'groupBitmapIf': ('groupBitmap', 'If'), 'cramersVIf': ('cramersV', 'If'), 'categoricalInformationValueIf': ('categoricalInformationValue', 'If'), 'meanZTestIf': ('meanZTest', 'If'), 'stochasticLogisticRegressionIf': ('stochasticLogisticRegression', 'If'), 'quantilesInterpolatedWeightedIf': ('quantilesInterpolatedWeighted', 'If'), 'quantilesIf': ('quantiles', 'If'), 'uniqCombined64If': ('uniqCombined64', 'If'), 'kurtPopIf': ('kurtPop', 'If'), 'intervalLengthSumIf': ('intervalLengthSum', 'If'), 'quantileExactWeightedIf': ('quantileExactWeighted', 'If'), 'histogramIf': ('histogram', 'If'), 'avgIf': ('avg', 'If'), 'uniqIf': ('uniq', 'If'), 'uniqUpToIf': ('uniqUpTo', 'If'), 'stddevSampIf': ('stddevSamp', 'If'), 'largestTriangleThreeBucketsIf': ('largestTriangleThreeBuckets', 'If'), 'medianIf': ('median', 'If'), 'deltaSumIf': ('deltaSum', 'If'), 'groupBitmapXorIf': ('groupBitmapXor', 'If'), 'quantileBFloat16If': ('quantileBFloat16', 'If'), 'simpleLinearRegressionIf': ('simpleLinearRegression', 'If'), 'quantileIf': ('quantile', 'If'), 'stochasticLinearRegressionIf': ('stochasticLinearRegression', 'If'), 'quantilesTimingIf': ('quantilesTiming', 'If'), 'contingencyIf': ('contingency', 'If'), 'covarSampIf': ('covarSamp', 'If'), 'deltaSumTimestampIf': ('deltaSumTimestamp', 'If'), 'uniqHLL12If': ('uniqHLL12', 'If'), 'maxIntersectionsIf': ('maxIntersections', 'If'), 'quantileTDigestWeightedIf': ('quantileTDigestWeighted', 'If'), 'groupArrayInsertAtIf': ('groupArrayInsertAt', 'If'), 'uniqExactIf': ('uniqExact', 'If'), 'last_valueIf': ('last_value', 'If'), 'quantilesTimingWeightedIf': ('quantilesTimingWeighted', 'If'), 'groupArraySampleIf': ('groupArraySample', 'If'), 'quantileBFloat16WeightedIf': ('quantileBFloat16Weighted', 'If'), 'quantilesTDigestWeightedIf': ('quantilesTDigestWeighted', 'If'), 'quantilesExactWeightedIf': ('quantilesExactWeighted', 'If'), 'rankCorrIf': ('rankCorr', 'If'), 'groupBitOrIf': ('groupBitOr', 'If'), 'groupArrayIf': ('groupArray', 'If'), 'sequenceMatchIf': ('sequenceMatch', 'If'), 'quantileTimingIf': ('quantileTiming', 'If'), 'anyLastIf': ('anyLast', 'If'), 'avgWeightedIf': ('avgWeighted', 'If'), 'groupArrayMovingAvgIf': ('groupArrayMovingAvg', 'If'), 'first_valueIf': ('first_value', 'If'), 'quantilesGKIf': ('quantilesGK', 'If'), 'argMinIf': ('argMin', 'If'), 'quantilesExactHighIf': ('quantilesExactHigh', 'If'), 'countIf': ('count', 'If'), 'varSampIf': ('varSamp', 'If'), 'quantileExactIf': ('quantileExact', 'If'), 'kolmogorovSmirnovTestIf': ('kolmogorovSmirnovTest', 'If'), 'groupBitmapAndIf': ('groupBitmapAnd', 'If'), 'sparkBarIf': ('sparkBar', 'If'), 'covarPopIf': ('covarPop', 'If'), 'groupArrayLastIf': ('groupArrayLast', 'If'), 'mannWhitneyUTestIf': ('mannWhitneyUTest', 'If'), 'studentTTestIf': ('studentTTest', 'If'), 'quantileTimingWeightedIf': ('quantileTimingWeighted', 'If'), 'anyIf': ('any', 'If'), 'sequenceCountIf': ('sequenceCount', 'If'), 'quantileGKIf': ('quantileGK', 'If'), 'maxIntersectionsPositionIf': ('maxIntersectionsPosition', 'If'), 'retentionArray': ('retention', 'Array'), 'quantilesExactArray': ('quantilesExact', 'Array'), 'windowFunnelArray': ('windowFunnel', 'Array'), 'sumWithOverflowArray': ('sumWithOverflow', 'Array'), 'minArray': ('min', 'Array'), 'kurtSampArray': ('kurtSamp', 'Array'), 'quantileDeterministicArray': ('quantileDeterministic', 'Array'), 'quantileExactHighArray': ('quantileExactHigh', 'Array'), 'quantileExactLowArray': ('quantileExactLow', 'Array'), 'argMaxArray': ('argMax', 'Array'), 'groupBitXorArray': ('groupBitXor', 'Array'), 'quantilesTDigestArray': ('quantilesTDigest', 'Array'), 'topKWeightedArray': ('topKWeighted', 'Array'), 'quantilesBFloat16Array': ('quantilesBFloat16', 'Array'), 'cramersVBiasCorrectedArray': ('cramersVBiasCorrected', 'Array'), 'exponentialMovingAverageArray': ('exponentialMovingAverage', 'Array'), 'anyHeavyArray': ('anyHeavy', 'Array'), 'topKArray': ('topK', 'Array'), 'sumCountArray': ('sumCount', 'Array'), 'sumKahanArray': ('sumKahan', 'Array'), 'sumMapArray': ('sumMap', 'Array'), 'theilsUArray': ('theilsU', 'Array'), 'maxMapArray': ('maxMap', 'Array'), 'entropyArray': ('entropy', 'Array'), 'welchTTestArray': ('welchTTest', 'Array'), 'varPopArray': ('varPop', 'Array'), 'corrArray': ('corr', 'Array'), 'quantileTDigestArray': ('quantileTDigest', 'Array'), 'skewPopArray': ('skewPop', 'Array'), 'groupBitmapOrArray': ('groupBitmapOr', 'Array'), 'exponentialTimeDecayedAvgArray': ('exponentialTimeDecayedAvg', 'Array'), 'minMapArray': ('minMap', 'Array'), 'boundingRatioArray': ('boundingRatio', 'Array'), 'uniqCombinedArray': ('uniqCombined', 'Array'), 'groupArrayMovingSumArray': ('groupArrayMovingSum', 'Array'), 'sumArray': ('sum', 'Array'), 'stddevPopArray': ('stddevPop', 'Array'), 'groupBitAndArray': ('groupBitAnd', 'Array'), 'quantileInterpolatedWeightedArray': ('quantileInterpolatedWeighted', 'Array'), 'uniqThetaArray': ('uniqTheta', 'Array'), 'sequenceNextNodeArray': ('sequenceNextNode', 'Array'), 'groupUniqArrayArray': ('groupUniqArray', 'Array'), 'maxArray': ('max', 'Array'), 'skewSampArray': ('skewSamp', 'Array'), 'quantilesBFloat16WeightedArray': ('quantilesBFloat16Weighted', 'Array'), 'quantilesExactLowArray': ('quantilesExactLow', 'Array'), 'quantilesDeterministicArray': ('quantilesDeterministic', 'Array'), 'groupBitmapArray': ('groupBitmap', 'Array'), 'cramersVArray': ('cramersV', 'Array'), 'categoricalInformationValueArray': ('categoricalInformationValue', 'Array'), 'meanZTestArray': ('meanZTest', 'Array'), 'stochasticLogisticRegressionArray': ('stochasticLogisticRegression', 'Array'), 'quantilesInterpolatedWeightedArray': ('quantilesInterpolatedWeighted', 'Array'), 'quantilesArray': ('quantiles', 'Array'), 'uniqCombined64Array': ('uniqCombined64', 'Array'), 'kurtPopArray': ('kurtPop', 'Array'), 'intervalLengthSumArray': ('intervalLengthSum', 'Array'), 'quantileExactWeightedArray': ('quantileExactWeighted', 'Array'), 'histogramArray': ('histogram', 'Array'), 'avgArray': ('avg', 'Array'), 'uniqArray': ('uniq', 'Array'), 'uniqUpToArray': ('uniqUpTo', 'Array'), 'stddevSampArray': ('stddevSamp', 'Array'), 'largestTriangleThreeBucketsArray': ('largestTriangleThreeBuckets', 'Array'), 'medianArray': ('median', 'Array'), 'deltaSumArray': ('deltaSum', 'Array'), 'groupBitmapXorArray': ('groupBitmapXor', 'Array'), 'quantileBFloat16Array': ('quantileBFloat16', 'Array'), 'simpleLinearRegressionArray': ('simpleLinearRegression', 'Array'), 'quantileArray': ('quantile', 'Array'), 'stochasticLinearRegressionArray': ('stochasticLinearRegression', 'Array'), 'quantilesTimingArray': ('quantilesTiming', 'Array'), 'contingencyArray': ('contingency', 'Array'), 'covarSampArray': ('covarSamp', 'Array'), 'deltaSumTimestampArray': ('deltaSumTimestamp', 'Array'), 'uniqHLL12Array': ('uniqHLL12', 'Array'), 'maxIntersectionsArray': ('maxIntersections', 'Array'), 'quantileTDigestWeightedArray': ('quantileTDigestWeighted', 'Array'), 'groupArrayInsertAtArray': ('groupArrayInsertAt', 'Array'), 'uniqExactArray': ('uniqExact', 'Array'), 'last_valueArray': ('last_value', 'Array'), 'quantilesTimingWeightedArray': ('quantilesTimingWeighted', 'Array'), 'groupArraySampleArray': ('groupArraySample', 'Array'), 'quantileBFloat16WeightedArray': ('quantileBFloat16Weighted', 'Array'), 'quantilesTDigestWeightedArray': ('quantilesTDigestWeighted', 'Array'), 'quantilesExactWeightedArray': ('quantilesExactWeighted', 'Array'), 'rankCorrArray': ('rankCorr', 'Array'), 'groupBitOrArray': ('groupBitOr', 'Array'), 'groupArrayArray': ('groupArray', 'Array'), 'sequenceMatchArray': ('sequenceMatch', 'Array'), 'quantileTimingArray': ('quantileTiming', 'Array'), 'anyLastArray': ('anyLast', 'Array'), 'avgWeightedArray': ('avgWeighted', 'Array'), 'groupArrayMovingAvgArray': ('groupArrayMovingAvg', 'Array'), 'first_valueArray': ('first_value', 'Array'), 'quantilesGKArray': ('quantilesGK', 'Array'), 'argMinArray': ('argMin', 'Array'), 'quantilesExactHighArray': ('quantilesExactHigh', 'Array'), 'countArray': ('count', 'Array'), 'varSampArray': ('varSamp', 'Array'), 'quantileExactArray': ('quantileExact', 'Array'), 'kolmogorovSmirnovTestArray': ('kolmogorovSmirnovTest', 'Array'), 'groupBitmapAndArray': ('groupBitmapAnd', 'Array'), 'sparkBarArray': ('sparkBar', 'Array'), 'covarPopArray': ('covarPop', 'Array'), 'groupArrayLastArray': ('groupArrayLast', 'Array'), 'mannWhitneyUTestArray': ('mannWhitneyUTest', 'Array'), 'studentTTestArray': ('studentTTest', 'Array'), 'quantileTimingWeightedArray': ('quantileTimingWeighted', 'Array'), 'anyArray': ('any', 'Array'), 'sequenceCountArray': ('sequenceCount', 'Array'), 'quantileGKArray': ('quantileGK', 'Array'), 'maxIntersectionsPositionArray': ('maxIntersectionsPosition', 'Array'), 'retentionArrayIf': ('retention', 'ArrayIf'), 'quantilesExactArrayIf': ('quantilesExact', 'ArrayIf'), 'windowFunnelArrayIf': ('windowFunnel', 'ArrayIf'), 'sumWithOverflowArrayIf': ('sumWithOverflow', 'ArrayIf'), 'minArrayIf': ('min', 'ArrayIf'), 'kurtSampArrayIf': ('kurtSamp', 'ArrayIf'), 'quantileDeterministicArrayIf': ('quantileDeterministic', 'ArrayIf'), 'quantileExactHighArrayIf': ('quantileExactHigh', 'ArrayIf'), 'quantileExactLowArrayIf': ('quantileExactLow', 'ArrayIf'), 'argMaxArrayIf': ('argMax', 'ArrayIf'), 'groupBitXorArrayIf': ('groupBitXor', 'ArrayIf'), 'quantilesTDigestArrayIf': ('quantilesTDigest', 'ArrayIf'), 'topKWeightedArrayIf': ('topKWeighted', 'ArrayIf'), 'quantilesBFloat16ArrayIf': ('quantilesBFloat16', 'ArrayIf'), 'cramersVBiasCorrectedArrayIf': ('cramersVBiasCorrected', 'ArrayIf'), 'exponentialMovingAverageArrayIf': ('exponentialMovingAverage', 'ArrayIf'), 'anyHeavyArrayIf': ('anyHeavy', 'ArrayIf'), 'topKArrayIf': ('topK', 'ArrayIf'), 'sumCountArrayIf': ('sumCount', 'ArrayIf'), 'sumKahanArrayIf': ('sumKahan', 'ArrayIf'), 'sumMapArrayIf': ('sumMap', 'ArrayIf'), 'theilsUArrayIf': ('theilsU', 'ArrayIf'), 'maxMapArrayIf': ('maxMap', 'ArrayIf'), 'entropyArrayIf': ('entropy', 'ArrayIf'), 'welchTTestArrayIf': ('welchTTest', 'ArrayIf'), 'varPopArrayIf': ('varPop', 'ArrayIf'), 'corrArrayIf': ('corr', 'ArrayIf'), 'quantileTDigestArrayIf': ('quantileTDigest', 'ArrayIf'), 'skewPopArrayIf': ('skewPop', 'ArrayIf'), 'groupBitmapOrArrayIf': ('groupBitmapOr', 'ArrayIf'), 'exponentialTimeDecayedAvgArrayIf': ('exponentialTimeDecayedAvg', 'ArrayIf'), 'minMapArrayIf': ('minMap', 'ArrayIf'), 'boundingRatioArrayIf': ('boundingRatio', 'ArrayIf'), 'uniqCombinedArrayIf': ('uniqCombined', 'ArrayIf'), 'groupArrayMovingSumArrayIf': ('groupArrayMovingSum', 'ArrayIf'), 'sumArrayIf': ('sum', 'ArrayIf'), 'stddevPopArrayIf': ('stddevPop', 'ArrayIf'), 'groupBitAndArrayIf': ('groupBitAnd', 'ArrayIf'), 'quantileInterpolatedWeightedArrayIf': ('quantileInterpolatedWeighted', 'ArrayIf'), 'uniqThetaArrayIf': ('uniqTheta', 'ArrayIf'), 'sequenceNextNodeArrayIf': ('sequenceNextNode', 'ArrayIf'), 'groupUniqArrayArrayIf': ('groupUniqArray', 'ArrayIf'), 'maxArrayIf': ('max', 'ArrayIf'), 'skewSampArrayIf': ('skewSamp', 'ArrayIf'), 'quantilesBFloat16WeightedArrayIf': ('quantilesBFloat16Weighted', 'ArrayIf'), 'quantilesExactLowArrayIf': ('quantilesExactLow', 'ArrayIf'), 'quantilesDeterministicArrayIf': ('quantilesDeterministic', 'ArrayIf'), 'groupBitmapArrayIf': ('groupBitmap', 'ArrayIf'), 'cramersVArrayIf': ('cramersV', 'ArrayIf'), 'categoricalInformationValueArrayIf': ('categoricalInformationValue', 'ArrayIf'), 'meanZTestArrayIf': ('meanZTest', 'ArrayIf'), 'stochasticLogisticRegressionArrayIf': ('stochasticLogisticRegression', 'ArrayIf'), 'quantilesInterpolatedWeightedArrayIf': ('quantilesInterpolatedWeighted', 'ArrayIf'), 'quantilesArrayIf': ('quantiles', 'ArrayIf'), 'uniqCombined64ArrayIf': ('uniqCombined64', 'ArrayIf'), 'kurtPopArrayIf': ('kurtPop', 'ArrayIf'), 'intervalLengthSumArrayIf': ('intervalLengthSum', 'ArrayIf'), 'quantileExactWeightedArrayIf': ('quantileExactWeighted', 'ArrayIf'), 'histogramArrayIf': ('histogram', 'ArrayIf'), 'avgArrayIf': ('avg', 'ArrayIf'), 'uniqArrayIf': ('uniq', 'ArrayIf'), 'uniqUpToArrayIf': ('uniqUpTo', 'ArrayIf'), 'stddevSampArrayIf': ('stddevSamp', 'ArrayIf'), 'largestTriangleThreeBucketsArrayIf': ('largestTriangleThreeBuckets', 'ArrayIf'), 'medianArrayIf': ('median', 'ArrayIf'), 'deltaSumArrayIf': ('deltaSum', 'ArrayIf'), 'groupBitmapXorArrayIf': ('groupBitmapXor', 'ArrayIf'), 'quantileBFloat16ArrayIf': ('quantileBFloat16', 'ArrayIf'), 'simpleLinearRegressionArrayIf': ('simpleLinearRegression', 'ArrayIf'), 'quantileArrayIf': ('quantile', 'ArrayIf'), 'stochasticLinearRegressionArrayIf': ('stochasticLinearRegression', 'ArrayIf'), 'quantilesTimingArrayIf': ('quantilesTiming', 'ArrayIf'), 'contingencyArrayIf': ('contingency', 'ArrayIf'), 'covarSampArrayIf': ('covarSamp', 'ArrayIf'), 'deltaSumTimestampArrayIf': ('deltaSumTimestamp', 'ArrayIf'), 'uniqHLL12ArrayIf': ('uniqHLL12', 'ArrayIf'), 'maxIntersectionsArrayIf': ('maxIntersections', 'ArrayIf'), 'quantileTDigestWeightedArrayIf': ('quantileTDigestWeighted', 'ArrayIf'), 'groupArrayInsertAtArrayIf': ('groupArrayInsertAt', 'ArrayIf'), 'uniqExactArrayIf': ('uniqExact', 'ArrayIf'), 'last_valueArrayIf': ('last_value', 'ArrayIf'), 'quantilesTimingWeightedArrayIf': ('quantilesTimingWeighted', 'ArrayIf'), 'groupArraySampleArrayIf': ('groupArraySample', 'ArrayIf'), 'quantileBFloat16WeightedArrayIf': ('quantileBFloat16Weighted', 'ArrayIf'), 'quantilesTDigestWeightedArrayIf': ('quantilesTDigestWeighted', 'ArrayIf'), 'quantilesExactWeightedArrayIf': ('quantilesExactWeighted', 'ArrayIf'), 'rankCorrArrayIf': ('rankCorr', 'ArrayIf'), 'groupBitOrArrayIf': ('groupBitOr', 'ArrayIf'), 'groupArrayArrayIf': ('groupArray', 'ArrayIf'), 'sequenceMatchArrayIf': ('sequenceMatch', 'ArrayIf'), 'quantileTimingArrayIf': ('quantileTiming', 'ArrayIf'), 'anyLastArrayIf': ('anyLast', 'ArrayIf'), 'avgWeightedArrayIf': ('avgWeighted', 'ArrayIf'), 'groupArrayMovingAvgArrayIf': ('groupArrayMovingAvg', 'ArrayIf'), 'first_valueArrayIf': ('first_value', 'ArrayIf'), 'quantilesGKArrayIf': ('quantilesGK', 'ArrayIf'), 'argMinArrayIf': ('argMin', 'ArrayIf'), 'quantilesExactHighArrayIf': ('quantilesExactHigh', 'ArrayIf'), 'countArrayIf': ('count', 'ArrayIf'), 'varSampArrayIf': ('varSamp', 'ArrayIf'), 'quantileExactArrayIf': ('quantileExact', 'ArrayIf'), 'kolmogorovSmirnovTestArrayIf': ('kolmogorovSmirnovTest', 'ArrayIf'), 'groupBitmapAndArrayIf': ('groupBitmapAnd', 'ArrayIf'), 'sparkBarArrayIf': ('sparkBar', 'ArrayIf'), 'covarPopArrayIf': ('covarPop', 'ArrayIf'), 'groupArrayLastArrayIf': ('groupArrayLast', 'ArrayIf'), 'mannWhitneyUTestArrayIf': ('mannWhitneyUTest', 'ArrayIf'), 'studentTTestArrayIf': ('studentTTest', 'ArrayIf'), 'quantileTimingWeightedArrayIf': ('quantileTimingWeighted', 'ArrayIf'), 'anyArrayIf': ('any', 'ArrayIf'), 'sequenceCountArrayIf': ('sequenceCount', 'ArrayIf'), 'quantileGKArrayIf': ('quantileGK', 'ArrayIf'), 'maxIntersectionsPositionArrayIf': ('maxIntersectionsPosition', 'ArrayIf'), 'retentionMap': ('retention', 'Map'), 'quantilesExactMap': ('quantilesExact', 'Map'), 'windowFunnelMap': ('windowFunnel', 'Map'), 'sumWithOverflowMap': ('sumWithOverflow', 'Map'), 'minMap': ('minMap', ''), 'kurtSampMap': ('kurtSamp', 'Map'), 'quantileDeterministicMap': ('quantileDeterministic', 'Map'), 'quantileExactHighMap': ('quantileExactHigh', 'Map'), 'quantileExactLowMap': ('quantileExactLow', 'Map'), 'argMaxMap': ('argMax', 'Map'), 'groupBitXorMap': ('groupBitXor', 'Map'), 'quantilesTDigestMap': ('quantilesTDigest', 'Map'), 'topKWeightedMap': ('topKWeighted', 'Map'), 'quantilesBFloat16Map': ('quantilesBFloat16', 'Map'), 'cramersVBiasCorrectedMap': ('cramersVBiasCorrected', 'Map'), 'exponentialMovingAverageMap': ('exponentialMovingAverage', 'Map'), 'anyHeavyMap': ('anyHeavy', 'Map'), 'topKMap': ('topK', 'Map'), 'sumCountMap': ('sumCount', 'Map'), 'sumKahanMap': ('sumKahan', 'Map'), 'sumMapMap': ('sumMap', 'Map'), 'theilsUMap': ('theilsU', 'Map'), 'maxMapMap': ('maxMap', 'Map'), 'entropyMap': ('entropy', 'Map'), 'welchTTestMap': ('welchTTest', 'Map'), 'varPopMap': ('varPop', 'Map'), 'corrMap': ('corr', 'Map'), 'quantileTDigestMap': ('quantileTDigest', 'Map'), 'skewPopMap': ('skewPop', 'Map'), 'groupBitmapOrMap': ('groupBitmapOr', 'Map'), 'exponentialTimeDecayedAvgMap': ('exponentialTimeDecayedAvg', 'Map'), 'minMapMap': ('minMap', 'Map'), 'boundingRatioMap': ('boundingRatio', 'Map'), 'uniqCombinedMap': ('uniqCombined', 'Map'), 'groupArrayMovingSumMap': ('groupArrayMovingSum', 'Map'), 'sumMap': ('sumMap', ''), 'stddevPopMap': ('stddevPop', 'Map'), 'groupBitAndMap': ('groupBitAnd', 'Map'), 'quantileInterpolatedWeightedMap': ('quantileInterpolatedWeighted', 'Map'), 'uniqThetaMap': ('uniqTheta', 'Map'), 'sequenceNextNodeMap': ('sequenceNextNode', 'Map'), 'groupUniqArrayMap': ('groupUniqArray', 'Map'), 'maxMap': ('maxMap', ''), 'skewSampMap': ('skewSamp', 'Map'), 'quantilesBFloat16WeightedMap': ('quantilesBFloat16Weighted', 'Map'), 'quantilesExactLowMap': ('quantilesExactLow', 'Map'), 'quantilesDeterministicMap': ('quantilesDeterministic', 'Map'), 'groupBitmapMap': ('groupBitmap', 'Map'), 'cramersVMap': ('cramersV', 'Map'), 'categoricalInformationValueMap': ('categoricalInformationValue', 'Map'), 'meanZTestMap': ('meanZTest', 'Map'), 'stochasticLogisticRegressionMap': ('stochasticLogisticRegression', 'Map'), 'quantilesInterpolatedWeightedMap': ('quantilesInterpolatedWeighted', 'Map'), 'quantilesMap': ('quantiles', 'Map'), 'uniqCombined64Map': ('uniqCombined64', 'Map'), 'kurtPopMap': ('kurtPop', 'Map'), 'intervalLengthSumMap': ('intervalLengthSum', 'Map'), 'quantileExactWeightedMap': ('quantileExactWeighted', 'Map'), 'histogramMap': ('histogram', 'Map'), 'avgMap': ('avg', 'Map'), 'uniqMap': ('uniq', 'Map'), 'uniqUpToMap': ('uniqUpTo', 'Map'), 'stddevSampMap': ('stddevSamp', 'Map'), 'largestTriangleThreeBucketsMap': ('largestTriangleThreeBuckets', 'Map'), 'medianMap': ('median', 'Map'), 'deltaSumMap': ('deltaSum', 'Map'), 'groupBitmapXorMap': ('groupBitmapXor', 'Map'), 'quantileBFloat16Map': ('quantileBFloat16', 'Map'), 'simpleLinearRegressionMap': ('simpleLinearRegression', 'Map'), 'quantileMap': ('quantile', 'Map'), 'stochasticLinearRegressionMap': ('stochasticLinearRegression', 'Map'), 'quantilesTimingMap': ('quantilesTiming', 'Map'), 'contingencyMap': ('contingency', 'Map'), 'covarSampMap': ('covarSamp', 'Map'), 'deltaSumTimestampMap': ('deltaSumTimestamp', 'Map'), 'uniqHLL12Map': ('uniqHLL12', 'Map'), 'maxIntersectionsMap': ('maxIntersections', 'Map'), 'quantileTDigestWeightedMap': ('quantileTDigestWeighted', 'Map'), 'groupArrayInsertAtMap': ('groupArrayInsertAt', 'Map'), 'uniqExactMap': ('uniqExact', 'Map'), 'last_valueMap': ('last_value', 'Map'), 'quantilesTimingWeightedMap': ('quantilesTimingWeighted', 'Map'), 'groupArraySampleMap': ('groupArraySample', 'Map'), 'quantileBFloat16WeightedMap': ('quantileBFloat16Weighted', 'Map'), 'quantilesTDigestWeightedMap': ('quantilesTDigestWeighted', 'Map'), 'quantilesExactWeightedMap': ('quantilesExactWeighted', 'Map'), 'rankCorrMap': ('rankCorr', 'Map'), 'groupBitOrMap': ('groupBitOr', 'Map'), 'groupArrayMap': ('groupArray', 'Map'), 'sequenceMatchMap': ('sequenceMatch', 'Map'), 'quantileTimingMap': ('quantileTiming', 'Map'), 'anyLastMap': ('anyLast', 'Map'), 'avgWeightedMap': ('avgWeighted', 'Map'), 'groupArrayMovingAvgMap': ('groupArrayMovingAvg', 'Map'), 'first_valueMap': ('first_value', 'Map'), 'quantilesGKMap': ('quantilesGK', 'Map'), 'argMinMap': ('argMin', 'Map'), 'quantilesExactHighMap': ('quantilesExactHigh', 'Map'), 'countMap': ('count', 'Map'), 'varSampMap': ('varSamp', 'Map'), 'quantileExactMap': ('quantileExact', 'Map'), 'kolmogorovSmirnovTestMap': ('kolmogorovSmirnovTest', 'Map'), 'groupBitmapAndMap': ('groupBitmapAnd', 'Map'), 'sparkBarMap': ('sparkBar', 'Map'), 'covarPopMap': ('covarPop', 'Map'), 'groupArrayLastMap': ('groupArrayLast', 'Map'), 'mannWhitneyUTestMap': ('mannWhitneyUTest', 'Map'), 'studentTTestMap': ('studentTTest', 'Map'), 'quantileTimingWeightedMap': ('quantileTimingWeighted', 'Map'), 'anyMap': ('any', 'Map'), 'sequenceCountMap': ('sequenceCount', 'Map'), 'quantileGKMap': ('quantileGK', 'Map'), 'maxIntersectionsPositionMap': ('maxIntersectionsPosition', 'Map'), 'retentionSimpleState': ('retention', 'SimpleState'), 'quantilesExactSimpleState': ('quantilesExact', 'SimpleState'), 'windowFunnelSimpleState': ('windowFunnel', 'SimpleState'), 'sumWithOverflowSimpleState': ('sumWithOverflow', 'SimpleState'), 'minSimpleState': ('min', 'SimpleState'), 'kurtSampSimpleState': ('kurtSamp', 'SimpleState'), 'quantileDeterministicSimpleState': ('quantileDeterministic', 'SimpleState'), 'quantileExactHighSimpleState': ('quantileExactHigh', 'SimpleState'), 'quantileExactLowSimpleState': ('quantileExactLow', 'SimpleState'), 'argMaxSimpleState': ('argMax', 'SimpleState'), 'groupBitXorSimpleState': ('groupBitXor', 'SimpleState'), 'quantilesTDigestSimpleState': ('quantilesTDigest', 'SimpleState'), 'topKWeightedSimpleState': ('topKWeighted', 'SimpleState'), 'quantilesBFloat16SimpleState': ('quantilesBFloat16', 'SimpleState'), 'cramersVBiasCorrectedSimpleState': ('cramersVBiasCorrected', 'SimpleState'), 'exponentialMovingAverageSimpleState': ('exponentialMovingAverage', 'SimpleState'), 'anyHeavySimpleState': ('anyHeavy', 'SimpleState'), 'topKSimpleState': ('topK', 'SimpleState'), 'sumCountSimpleState': ('sumCount', 'SimpleState'), 'sumKahanSimpleState': ('sumKahan', 'SimpleState'), 'sumMapSimpleState': ('sumMap', 'SimpleState'), 'theilsUSimpleState': ('theilsU', 'SimpleState'), 'maxMapSimpleState': ('maxMap', 'SimpleState'), 'entropySimpleState': ('entropy', 'SimpleState'), 'welchTTestSimpleState': ('welchTTest', 'SimpleState'), 'varPopSimpleState': ('varPop', 'SimpleState'), 'corrSimpleState': ('corr', 'SimpleState'), 'quantileTDigestSimpleState': ('quantileTDigest', 'SimpleState'), 'skewPopSimpleState': ('skewPop', 'SimpleState'), 'groupBitmapOrSimpleState': ('groupBitmapOr', 'SimpleState'), 'exponentialTimeDecayedAvgSimpleState': ('exponentialTimeDecayedAvg', 'SimpleState'), 'minMapSimpleState': ('minMap', 'SimpleState'), 'boundingRatioSimpleState': ('boundingRatio', 'SimpleState'), 'uniqCombinedSimpleState': ('uniqCombined', 'SimpleState'), 'groupArrayMovingSumSimpleState': ('groupArrayMovingSum', 'SimpleState'), 'sumSimpleState': ('sum', 'SimpleState'), 'stddevPopSimpleState': ('stddevPop', 'SimpleState'), 'groupBitAndSimpleState': ('groupBitAnd', 'SimpleState'), 'quantileInterpolatedWeightedSimpleState': ('quantileInterpolatedWeighted', 'SimpleState'), 'uniqThetaSimpleState': ('uniqTheta', 'SimpleState'), 'sequenceNextNodeSimpleState': ('sequenceNextNode', 'SimpleState'), 'groupUniqArraySimpleState': ('groupUniqArray', 'SimpleState'), 'maxSimpleState': ('max', 'SimpleState'), 'skewSampSimpleState': ('skewSamp', 'SimpleState'), 'quantilesBFloat16WeightedSimpleState': ('quantilesBFloat16Weighted', 'SimpleState'), 'quantilesExactLowSimpleState': ('quantilesExactLow', 'SimpleState'), 'quantilesDeterministicSimpleState': ('quantilesDeterministic', 'SimpleState'), 'groupBitmapSimpleState': ('groupBitmap', 'SimpleState'), 'cramersVSimpleState': ('cramersV', 'SimpleState'), 'categoricalInformationValueSimpleState': ('categoricalInformationValue', 'SimpleState'), 'meanZTestSimpleState': ('meanZTest', 'SimpleState'), 'stochasticLogisticRegressionSimpleState': ('stochasticLogisticRegression', 'SimpleState'), 'quantilesInterpolatedWeightedSimpleState': ('quantilesInterpolatedWeighted', 'SimpleState'), 'quantilesSimpleState': ('quantiles', 'SimpleState'), 'uniqCombined64SimpleState': ('uniqCombined64', 'SimpleState'), 'kurtPopSimpleState': ('kurtPop', 'SimpleState'), 'intervalLengthSumSimpleState': ('intervalLengthSum', 'SimpleState'), 'quantileExactWeightedSimpleState': ('quantileExactWeighted', 'SimpleState'), 'histogramSimpleState': ('histogram', 'SimpleState'), 'avgSimpleState': ('avg', 'SimpleState'), 'uniqSimpleState': ('uniq', 'SimpleState'), 'uniqUpToSimpleState': ('uniqUpTo', 'SimpleState'), 'stddevSampSimpleState': ('stddevSamp', 'SimpleState'), 'largestTriangleThreeBucketsSimpleState': ('largestTriangleThreeBuckets', 'SimpleState'), 'medianSimpleState': ('median', 'SimpleState'), 'deltaSumSimpleState': ('deltaSum', 'SimpleState'), 'groupBitmapXorSimpleState': ('groupBitmapXor', 'SimpleState'), 'quantileBFloat16SimpleState': ('quantileBFloat16', 'SimpleState'), 'simpleLinearRegressionSimpleState': ('simpleLinearRegression', 'SimpleState'), 'quantileSimpleState': ('quantile', 'SimpleState'), 'stochasticLinearRegressionSimpleState': ('stochasticLinearRegression', 'SimpleState'), 'quantilesTimingSimpleState': ('quantilesTiming', 'SimpleState'), 'contingencySimpleState': ('contingency', 'SimpleState'), 'covarSampSimpleState': ('covarSamp', 'SimpleState'), 'deltaSumTimestampSimpleState': ('deltaSumTimestamp', 'SimpleState'), 'uniqHLL12SimpleState': ('uniqHLL12', 'SimpleState'), 'maxIntersectionsSimpleState': ('maxIntersections', 'SimpleState'), 'quantileTDigestWeightedSimpleState': ('quantileTDigestWeighted', 'SimpleState'), 'groupArrayInsertAtSimpleState': ('groupArrayInsertAt', 'SimpleState'), 'uniqExactSimpleState': ('uniqExact', 'SimpleState'), 'last_valueSimpleState': ('last_value', 'SimpleState'), 'quantilesTimingWeightedSimpleState': ('quantilesTimingWeighted', 'SimpleState'), 'groupArraySampleSimpleState': ('groupArraySample', 'SimpleState'), 'quantileBFloat16WeightedSimpleState': ('quantileBFloat16Weighted', 'SimpleState'), 'quantilesTDigestWeightedSimpleState': ('quantilesTDigestWeighted', 'SimpleState'), 'quantilesExactWeightedSimpleState': ('quantilesExactWeighted', 'SimpleState'), 'rankCorrSimpleState': ('rankCorr', 'SimpleState'), 'groupBitOrSimpleState': ('groupBitOr', 'SimpleState'), 'groupArraySimpleState': ('groupArray', 'SimpleState'), 'sequenceMatchSimpleState': ('sequenceMatch', 'SimpleState'), 'quantileTimingSimpleState': ('quantileTiming', 'SimpleState'), 'anyLastSimpleState': ('anyLast', 'SimpleState'), 'avgWeightedSimpleState': ('avgWeighted', 'SimpleState'), 'groupArrayMovingAvgSimpleState': ('groupArrayMovingAvg', 'SimpleState'), 'first_valueSimpleState': ('first_value', 'SimpleState'), 'quantilesGKSimpleState': ('quantilesGK', 'SimpleState'), 'argMinSimpleState': ('argMin', 'SimpleState'), 'quantilesExactHighSimpleState': ('quantilesExactHigh', 'SimpleState'), 'countSimpleState': ('count', 'SimpleState'), 'varSampSimpleState': ('varSamp', 'SimpleState'), 'quantileExactSimpleState': ('quantileExact', 'SimpleState'), 'kolmogorovSmirnovTestSimpleState': ('kolmogorovSmirnovTest', 'SimpleState'), 'groupBitmapAndSimpleState': ('groupBitmapAnd', 'SimpleState'), 'sparkBarSimpleState': ('sparkBar', 'SimpleState'), 'covarPopSimpleState': ('covarPop', 'SimpleState'), 'groupArrayLastSimpleState': ('groupArrayLast', 'SimpleState'), 'mannWhitneyUTestSimpleState': ('mannWhitneyUTest', 'SimpleState'), 'studentTTestSimpleState': ('studentTTest', 'SimpleState'), 'quantileTimingWeightedSimpleState': ('quantileTimingWeighted', 'SimpleState'), 'anySimpleState': ('any', 'SimpleState'), 'sequenceCountSimpleState': ('sequenceCount', 'SimpleState'), 'quantileGKSimpleState': ('quantileGK', 'SimpleState'), 'maxIntersectionsPositionSimpleState': ('maxIntersectionsPosition', 'SimpleState'), 'retentionState': ('retention', 'State'), 'quantilesExactState': ('quantilesExact', 'State'), 'windowFunnelState': ('windowFunnel', 'State'), 'sumWithOverflowState': ('sumWithOverflow', 'State'), 'minState': ('min', 'State'), 'kurtSampState': ('kurtSamp', 'State'), 'quantileDeterministicState': ('quantileDeterministic', 'State'), 'quantileExactHighState': ('quantileExactHigh', 'State'), 'quantileExactLowState': ('quantileExactLow', 'State'), 'argMaxState': ('argMax', 'State'), 'groupBitXorState': ('groupBitXor', 'State'), 'quantilesTDigestState': ('quantilesTDigest', 'State'), 'topKWeightedState': ('topKWeighted', 'State'), 'quantilesBFloat16State': ('quantilesBFloat16', 'State'), 'cramersVBiasCorrectedState': ('cramersVBiasCorrected', 'State'), 'exponentialMovingAverageState': ('exponentialMovingAverage', 'State'), 'anyHeavyState': ('anyHeavy', 'State'), 'topKState': ('topK', 'State'), 'sumCountState': ('sumCount', 'State'), 'sumKahanState': ('sumKahan', 'State'), 'sumMapState': ('sumMap', 'State'), 'theilsUState': ('theilsU', 'State'), 'maxMapState': ('maxMap', 'State'), 'entropyState': ('entropy', 'State'), 'welchTTestState': ('welchTTest', 'State'), 'varPopState': ('varPop', 'State'), 'corrState': ('corr', 'State'), 'quantileTDigestState': ('quantileTDigest', 'State'), 'skewPopState': ('skewPop', 'State'), 'groupBitmapOrState': ('groupBitmapOr', 'State'), 'exponentialTimeDecayedAvgState': ('exponentialTimeDecayedAvg', 'State'), 'minMapState': ('minMap', 'State'), 'boundingRatioState': ('boundingRatio', 'State'), 'uniqCombinedState': ('uniqCombined', 'State'), 'groupArrayMovingSumState': ('groupArrayMovingSum', 'State'), 'sumState': ('sum', 'State'), 'stddevPopState': ('stddevPop', 'State'), 'groupBitAndState': ('groupBitAnd', 'State'), 'quantileInterpolatedWeightedState': ('quantileInterpolatedWeighted', 'State'), 'uniqThetaState': ('uniqTheta', 'State'), 'sequenceNextNodeState': ('sequenceNextNode', 'State'), 'groupUniqArrayState': ('groupUniqArray', 'State'), 'maxState': ('max', 'State'), 'skewSampState': ('skewSamp', 'State'), 'quantilesBFloat16WeightedState': ('quantilesBFloat16Weighted', 'State'), 'quantilesExactLowState': ('quantilesExactLow', 'State'), 'quantilesDeterministicState': ('quantilesDeterministic', 'State'), 'groupBitmapState': ('groupBitmap', 'State'), 'cramersVState': ('cramersV', 'State'), 'categoricalInformationValueState': ('categoricalInformationValue', 'State'), 'meanZTestState': ('meanZTest', 'State'), 'stochasticLogisticRegressionState': ('stochasticLogisticRegression', 'State'), 'quantilesInterpolatedWeightedState': ('quantilesInterpolatedWeighted', 'State'), 'quantilesState': ('quantiles', 'State'), 'uniqCombined64State': ('uniqCombined64', 'State'), 'kurtPopState': ('kurtPop', 'State'), 'intervalLengthSumState': ('intervalLengthSum', 'State'), 'quantileExactWeightedState': ('quantileExactWeighted', 'State'), 'histogramState': ('histogram', 'State'), 'avgState': ('avg', 'State'), 'uniqState': ('uniq', 'State'), 'uniqUpToState': ('uniqUpTo', 'State'), 'stddevSampState': ('stddevSamp', 'State'), 'largestTriangleThreeBucketsState': ('largestTriangleThreeBuckets', 'State'), 'medianState': ('median', 'State'), 'deltaSumState': ('deltaSum', 'State'), 'groupBitmapXorState': ('groupBitmapXor', 'State'), 'quantileBFloat16State': ('quantileBFloat16', 'State'), 'simpleLinearRegressionState': ('simpleLinearRegression', 'State'), 'quantileState': ('quantile', 'State'), 'stochasticLinearRegressionState': ('stochasticLinearRegression', 'State'), 'quantilesTimingState': ('quantilesTiming', 'State'), 'contingencyState': ('contingency', 'State'), 'covarSampState': ('covarSamp', 'State'), 'deltaSumTimestampState': ('deltaSumTimestamp', 'State'), 'uniqHLL12State': ('uniqHLL12', 'State'), 'maxIntersectionsState': ('maxIntersections', 'State'), 'quantileTDigestWeightedState': ('quantileTDigestWeighted', 'State'), 'groupArrayInsertAtState': ('groupArrayInsertAt', 'State'), 'uniqExactState': ('uniqExact', 'State'), 'last_valueState': ('last_value', 'State'), 'quantilesTimingWeightedState': ('quantilesTimingWeighted', 'State'), 'groupArraySampleState': ('groupArraySample', 'State'), 'quantileBFloat16WeightedState': ('quantileBFloat16Weighted', 'State'), 'quantilesTDigestWeightedState': ('quantilesTDigestWeighted', 'State'), 'quantilesExactWeightedState': ('quantilesExactWeighted', 'State'), 'rankCorrState': ('rankCorr', 'State'), 'groupBitOrState': ('groupBitOr', 'State'), 'groupArrayState': ('groupArray', 'State'), 'sequenceMatchState': ('sequenceMatch', 'State'), 'quantileTimingState': ('quantileTiming', 'State'), 'anyLastState': ('anyLast', 'State'), 'avgWeightedState': ('avgWeighted', 'State'), 'groupArrayMovingAvgState': ('groupArrayMovingAvg', 'State'), 'first_valueState': ('first_value', 'State'), 'quantilesGKState': ('quantilesGK', 'State'), 'argMinState': ('argMin', 'State'), 'quantilesExactHighState': ('quantilesExactHigh', 'State'), 'countState': ('count', 'State'), 'varSampState': ('varSamp', 'State'), 'quantileExactState': ('quantileExact', 'State'), 'kolmogorovSmirnovTestState': ('kolmogorovSmirnovTest', 'State'), 'groupBitmapAndState': ('groupBitmapAnd', 'State'), 'sparkBarState': ('sparkBar', 'State'), 'covarPopState': ('covarPop', 'State'), 'groupArrayLastState': ('groupArrayLast', 'State'), 'mannWhitneyUTestState': ('mannWhitneyUTest', 'State'), 'studentTTestState': ('studentTTest', 'State'), 'quantileTimingWeightedState': ('quantileTimingWeighted', 'State'), 'anyState': ('any', 'State'), 'sequenceCountState': ('sequenceCount', 'State'), 'quantileGKState': ('quantileGK', 'State'), 'maxIntersectionsPositionState': ('maxIntersectionsPosition', 'State'), 'retentionMerge': ('retention', 'Merge'), 'quantilesExactMerge': ('quantilesExact', 'Merge'), 'windowFunnelMerge': ('windowFunnel', 'Merge'), 'sumWithOverflowMerge': ('sumWithOverflow', 'Merge'), 'minMerge': ('min', 'Merge'), 'kurtSampMerge': ('kurtSamp', 'Merge'), 'quantileDeterministicMerge': ('quantileDeterministic', 'Merge'), 'quantileExactHighMerge': ('quantileExactHigh', 'Merge'), 'quantileExactLowMerge': ('quantileExactLow', 'Merge'), 'argMaxMerge': ('argMax', 'Merge'), 'groupBitXorMerge': ('groupBitXor', 'Merge'), 'quantilesTDigestMerge': ('quantilesTDigest', 'Merge'), 'topKWeightedMerge': ('topKWeighted', 'Merge'), 'quantilesBFloat16Merge': ('quantilesBFloat16', 'Merge'), 'cramersVBiasCorrectedMerge': ('cramersVBiasCorrected', 'Merge'), 'exponentialMovingAverageMerge': ('exponentialMovingAverage', 'Merge'), 'anyHeavyMerge': ('anyHeavy', 'Merge'), 'topKMerge': ('topK', 'Merge'), 'sumCountMerge': ('sumCount', 'Merge'), 'sumKahanMerge': ('sumKahan', 'Merge'), 'sumMapMerge': ('sumMap', 'Merge'), 'theilsUMerge': ('theilsU', 'Merge'), 'maxMapMerge': ('maxMap', 'Merge'), 'entropyMerge': ('entropy', 'Merge'), 'welchTTestMerge': ('welchTTest', 'Merge'), 'varPopMerge': ('varPop', 'Merge'), 'corrMerge': ('corr', 'Merge'), 'quantileTDigestMerge': ('quantileTDigest', 'Merge'), 'skewPopMerge': ('skewPop', 'Merge'), 'groupBitmapOrMerge': ('groupBitmapOr', 'Merge'), 'exponentialTimeDecayedAvgMerge': ('exponentialTimeDecayedAvg', 'Merge'), 'minMapMerge': ('minMap', 'Merge'), 'boundingRatioMerge': ('boundingRatio', 'Merge'), 'uniqCombinedMerge': ('uniqCombined', 'Merge'), 'groupArrayMovingSumMerge': ('groupArrayMovingSum', 'Merge'), 'sumMerge': ('sum', 'Merge'), 'stddevPopMerge': ('stddevPop', 'Merge'), 'groupBitAndMerge': ('groupBitAnd', 'Merge'), 'quantileInterpolatedWeightedMerge': ('quantileInterpolatedWeighted', 'Merge'), 'uniqThetaMerge': ('uniqTheta', 'Merge'), 'sequenceNextNodeMerge': ('sequenceNextNode', 'Merge'), 'groupUniqArrayMerge': ('groupUniqArray', 'Merge'), 'maxMerge': ('max', 'Merge'), 'skewSampMerge': ('skewSamp', 'Merge'), 'quantilesBFloat16WeightedMerge': ('quantilesBFloat16Weighted', 'Merge'), 'quantilesExactLowMerge': ('quantilesExactLow', 'Merge'), 'quantilesDeterministicMerge': ('quantilesDeterministic', 'Merge'), 'groupBitmapMerge': ('groupBitmap', 'Merge'), 'cramersVMerge': ('cramersV', 'Merge'), 'categoricalInformationValueMerge': ('categoricalInformationValue', 'Merge'), 'meanZTestMerge': ('meanZTest', 'Merge'), 'stochasticLogisticRegressionMerge': ('stochasticLogisticRegression', 'Merge'), 'quantilesInterpolatedWeightedMerge': ('quantilesInterpolatedWeighted', 'Merge'), 'quantilesMerge': ('quantiles', 'Merge'), 'uniqCombined64Merge': ('uniqCombined64', 'Merge'), 'kurtPopMerge': ('kurtPop', 'Merge'), 'intervalLengthSumMerge': ('intervalLengthSum', 'Merge'), 'quantileExactWeightedMerge': ('quantileExactWeighted', 'Merge'), 'histogramMerge': ('histogram', 'Merge'), 'avgMerge': ('avg', 'Merge'), 'uniqMerge': ('uniq', 'Merge'), 'uniqUpToMerge': ('uniqUpTo', 'Merge'), 'stddevSampMerge': ('stddevSamp', 'Merge'), 'largestTriangleThreeBucketsMerge': ('largestTriangleThreeBuckets', 'Merge'), 'medianMerge': ('median', 'Merge'), 'deltaSumMerge': ('deltaSum', 'Merge'), 'groupBitmapXorMerge': ('groupBitmapXor', 'Merge'), 'quantileBFloat16Merge': ('quantileBFloat16', 'Merge'), 'simpleLinearRegressionMerge': ('simpleLinearRegression', 'Merge'), 'quantileMerge': ('quantile', 'Merge'), 'stochasticLinearRegressionMerge': ('stochasticLinearRegression', 'Merge'), 'quantilesTimingMerge': ('quantilesTiming', 'Merge'), 'contingencyMerge': ('contingency', 'Merge'), 'covarSampMerge': ('covarSamp', 'Merge'), 'deltaSumTimestampMerge': ('deltaSumTimestamp', 'Merge'), 'uniqHLL12Merge': ('uniqHLL12', 'Merge'), 'maxIntersectionsMerge': ('maxIntersections', 'Merge'), 'quantileTDigestWeightedMerge': ('quantileTDigestWeighted', 'Merge'), 'groupArrayInsertAtMerge': ('groupArrayInsertAt', 'Merge'), 'uniqExactMerge': ('uniqExact', 'Merge'), 'last_valueMerge': ('last_value', 'Merge'), 'quantilesTimingWeightedMerge': ('quantilesTimingWeighted', 'Merge'), 'groupArraySampleMerge': ('groupArraySample', 'Merge'), 'quantileBFloat16WeightedMerge': ('quantileBFloat16Weighted', 'Merge'), 'quantilesTDigestWeightedMerge': ('quantilesTDigestWeighted', 'Merge'), 'quantilesExactWeightedMerge': ('quantilesExactWeighted', 'Merge'), 'rankCorrMerge': ('rankCorr', 'Merge'), 'groupBitOrMerge': ('groupBitOr', 'Merge'), 'groupArrayMerge': ('groupArray', 'Merge'), 'sequenceMatchMerge': ('sequenceMatch', 'Merge'), 'quantileTimingMerge': ('quantileTiming', 'Merge'), 'anyLastMerge': ('anyLast', 'Merge'), 'avgWeightedMerge': ('avgWeighted', 'Merge'), 'groupArrayMovingAvgMerge': ('groupArrayMovingAvg', 'Merge'), 'first_valueMerge': ('first_value', 'Merge'), 'quantilesGKMerge': ('quantilesGK', 'Merge'), 'argMinMerge': ('argMin', 'Merge'), 'quantilesExactHighMerge': ('quantilesExactHigh', 'Merge'), 'countMerge': ('count', 'Merge'), 'varSampMerge': ('varSamp', 'Merge'), 'quantileExactMerge': ('quantileExact', 'Merge'), 'kolmogorovSmirnovTestMerge': ('kolmogorovSmirnovTest', 'Merge'), 'groupBitmapAndMerge': ('groupBitmapAnd', 'Merge'), 'sparkBarMerge': ('sparkBar', 'Merge'), 'covarPopMerge': ('covarPop', 'Merge'), 'groupArrayLastMerge': ('groupArrayLast', 'Merge'), 'mannWhitneyUTestMerge': ('mannWhitneyUTest', 'Merge'), 'studentTTestMerge': ('studentTTest', 'Merge'), 'quantileTimingWeightedMerge': ('quantileTimingWeighted', 'Merge'), 'anyMerge': ('any', 'Merge'), 'sequenceCountMerge': ('sequenceCount', 'Merge'), 'quantileGKMerge': ('quantileGK', 'Merge'), 'maxIntersectionsPositionMerge': ('maxIntersectionsPosition', 'Merge'), 'retentionMergeState': ('retention', 'MergeState'), 'quantilesExactMergeState': ('quantilesExact', 'MergeState'), 'windowFunnelMergeState': ('windowFunnel', 'MergeState'), 'sumWithOverflowMergeState': ('sumWithOverflow', 'MergeState'), 'minMergeState': ('min', 'MergeState'), 'kurtSampMergeState': ('kurtSamp', 'MergeState'), 'quantileDeterministicMergeState': ('quantileDeterministic', 'MergeState'), 'quantileExactHighMergeState': ('quantileExactHigh', 'MergeState'), 'quantileExactLowMergeState': ('quantileExactLow', 'MergeState'), 'argMaxMergeState': ('argMax', 'MergeState'), 'groupBitXorMergeState': ('groupBitXor', 'MergeState'), 'quantilesTDigestMergeState': ('quantilesTDigest', 'MergeState'), 'topKWeightedMergeState': ('topKWeighted', 'MergeState'), 'quantilesBFloat16MergeState': ('quantilesBFloat16', 'MergeState'), 'cramersVBiasCorrectedMergeState': ('cramersVBiasCorrected', 'MergeState'), 'exponentialMovingAverageMergeState': ('exponentialMovingAverage', 'MergeState'), 'anyHeavyMergeState': ('anyHeavy', 'MergeState'), 'topKMergeState': ('topK', 'MergeState'), 'sumCountMergeState': ('sumCount', 'MergeState'), 'sumKahanMergeState': ('sumKahan', 'MergeState'), 'sumMapMergeState': ('sumMap', 'MergeState'), 'theilsUMergeState': ('theilsU', 'MergeState'), 'maxMapMergeState': ('maxMap', 'MergeState'), 'entropyMergeState': ('entropy', 'MergeState'), 'welchTTestMergeState': ('welchTTest', 'MergeState'), 'varPopMergeState': ('varPop', 'MergeState'), 'corrMergeState': ('corr', 'MergeState'), 'quantileTDigestMergeState': ('quantileTDigest', 'MergeState'), 'skewPopMergeState': ('skewPop', 'MergeState'), 'groupBitmapOrMergeState': ('groupBitmapOr', 'MergeState'), 'exponentialTimeDecayedAvgMergeState': ('exponentialTimeDecayedAvg', 'MergeState'), 'minMapMergeState': ('minMap', 'MergeState'), 'boundingRatioMergeState': ('boundingRatio', 'MergeState'), 'uniqCombinedMergeState': ('uniqCombined', 'MergeState'), 'groupArrayMovingSumMergeState': ('groupArrayMovingSum', 'MergeState'), 'sumMergeState': ('sum', 'MergeState'), 'stddevPopMergeState': ('stddevPop', 'MergeState'), 'groupBitAndMergeState': ('groupBitAnd', 'MergeState'), 'quantileInterpolatedWeightedMergeState': ('quantileInterpolatedWeighted', 'MergeState'), 'uniqThetaMergeState': ('uniqTheta', 'MergeState'), 'sequenceNextNodeMergeState': ('sequenceNextNode', 'MergeState'), 'groupUniqArrayMergeState': ('groupUniqArray', 'MergeState'), 'maxMergeState': ('max', 'MergeState'), 'skewSampMergeState': ('skewSamp', 'MergeState'), 'quantilesBFloat16WeightedMergeState': ('quantilesBFloat16Weighted', 'MergeState'), 'quantilesExactLowMergeState': ('quantilesExactLow', 'MergeState'), 'quantilesDeterministicMergeState': ('quantilesDeterministic', 'MergeState'), 'groupBitmapMergeState': ('groupBitmap', 'MergeState'), 'cramersVMergeState': ('cramersV', 'MergeState'), 'categoricalInformationValueMergeState': ('categoricalInformationValue', 'MergeState'), 'meanZTestMergeState': ('meanZTest', 'MergeState'), 'stochasticLogisticRegressionMergeState': ('stochasticLogisticRegression', 'MergeState'), 'quantilesInterpolatedWeightedMergeState': ('quantilesInterpolatedWeighted', 'MergeState'), 'quantilesMergeState': ('quantiles', 'MergeState'), 'uniqCombined64MergeState': ('uniqCombined64', 'MergeState'), 'kurtPopMergeState': ('kurtPop', 'MergeState'), 'intervalLengthSumMergeState': ('intervalLengthSum', 'MergeState'), 'quantileExactWeightedMergeState': ('quantileExactWeighted', 'MergeState'), 'histogramMergeState': ('histogram', 'MergeState'), 'avgMergeState': ('avg', 'MergeState'), 'uniqMergeState': ('uniq', 'MergeState'), 'uniqUpToMergeState': ('uniqUpTo', 'MergeState'), 'stddevSampMergeState': ('stddevSamp', 'MergeState'), 'largestTriangleThreeBucketsMergeState': ('largestTriangleThreeBuckets', 'MergeState'), 'medianMergeState': ('median', 'MergeState'), 'deltaSumMergeState': ('deltaSum', 'MergeState'), 'groupBitmapXorMergeState': ('groupBitmapXor', 'MergeState'), 'quantileBFloat16MergeState': ('quantileBFloat16', 'MergeState'), 'simpleLinearRegressionMergeState': ('simpleLinearRegression', 'MergeState'), 'quantileMergeState': ('quantile', 'MergeState'), 'stochasticLinearRegressionMergeState': ('stochasticLinearRegression', 'MergeState'), 'quantilesTimingMergeState': ('quantilesTiming', 'MergeState'), 'contingencyMergeState': ('contingency', 'MergeState'), 'covarSampMergeState': ('covarSamp', 'MergeState'), 'deltaSumTimestampMergeState': ('deltaSumTimestamp', 'MergeState'), 'uniqHLL12MergeState': ('uniqHLL12', 'MergeState'), 'maxIntersectionsMergeState': ('maxIntersections', 'MergeState'), 'quantileTDigestWeightedMergeState': ('quantileTDigestWeighted', 'MergeState'), 'groupArrayInsertAtMergeState': ('groupArrayInsertAt', 'MergeState'), 'uniqExactMergeState': ('uniqExact', 'MergeState'), 'last_valueMergeState': ('last_value', 'MergeState'), 'quantilesTimingWeightedMergeState': ('quantilesTimingWeighted', 'MergeState'), 'groupArraySampleMergeState': ('groupArraySample', 'MergeState'), 'quantileBFloat16WeightedMergeState': ('quantileBFloat16Weighted', 'MergeState'), 'quantilesTDigestWeightedMergeState': ('quantilesTDigestWeighted', 'MergeState'), 'quantilesExactWeightedMergeState': ('quantilesExactWeighted', 'MergeState'), 'rankCorrMergeState': ('rankCorr', 'MergeState'), 'groupBitOrMergeState': ('groupBitOr', 'MergeState'), 'groupArrayMergeState': ('groupArray', 'MergeState'), 'sequenceMatchMergeState': ('sequenceMatch', 'MergeState'), 'quantileTimingMergeState': ('quantileTiming', 'MergeState'), 'anyLastMergeState': ('anyLast', 'MergeState'), 'avgWeightedMergeState': ('avgWeighted', 'MergeState'), 'groupArrayMovingAvgMergeState': ('groupArrayMovingAvg', 'MergeState'), 'first_valueMergeState': ('first_value', 'MergeState'), 'quantilesGKMergeState': ('quantilesGK', 'MergeState'), 'argMinMergeState': ('argMin', 'MergeState'), 'quantilesExactHighMergeState': ('quantilesExactHigh', 'MergeState'), 'countMergeState': ('count', 'MergeState'), 'varSampMergeState': ('varSamp', 'MergeState'), 'quantileExactMergeState': ('quantileExact', 'MergeState'), 'kolmogorovSmirnovTestMergeState': ('kolmogorovSmirnovTest', 'MergeState'), 'groupBitmapAndMergeState': ('groupBitmapAnd', 'MergeState'), 'sparkBarMergeState': ('sparkBar', 'MergeState'), 'covarPopMergeState': ('covarPop', 'MergeState'), 'groupArrayLastMergeState': ('groupArrayLast', 'MergeState'), 'mannWhitneyUTestMergeState': ('mannWhitneyUTest', 'MergeState'), 'studentTTestMergeState': ('studentTTest', 'MergeState'), 'quantileTimingWeightedMergeState': ('quantileTimingWeighted', 'MergeState'), 'anyMergeState': ('any', 'MergeState'), 'sequenceCountMergeState': ('sequenceCount', 'MergeState'), 'quantileGKMergeState': ('quantileGK', 'MergeState'), 'maxIntersectionsPositionMergeState': ('maxIntersectionsPosition', 'MergeState'), 'retentionForEach': ('retention', 'ForEach'), 'quantilesExactForEach': ('quantilesExact', 'ForEach'), 'windowFunnelForEach': ('windowFunnel', 'ForEach'), 'sumWithOverflowForEach': ('sumWithOverflow', 'ForEach'), 'minForEach': ('min', 'ForEach'), 'kurtSampForEach': ('kurtSamp', 'ForEach'), 'quantileDeterministicForEach': ('quantileDeterministic', 'ForEach'), 'quantileExactHighForEach': ('quantileExactHigh', 'ForEach'), 'quantileExactLowForEach': ('quantileExactLow', 'ForEach'), 'argMaxForEach': ('argMax', 'ForEach'), 'groupBitXorForEach': ('groupBitXor', 'ForEach'), 'quantilesTDigestForEach': ('quantilesTDigest', 'ForEach'), 'topKWeightedForEach': ('topKWeighted', 'ForEach'), 'quantilesBFloat16ForEach': ('quantilesBFloat16', 'ForEach'), 'cramersVBiasCorrectedForEach': ('cramersVBiasCorrected', 'ForEach'), 'exponentialMovingAverageForEach': ('exponentialMovingAverage', 'ForEach'), 'anyHeavyForEach': ('anyHeavy', 'ForEach'), 'topKForEach': ('topK', 'ForEach'), 'sumCountForEach': ('sumCount', 'ForEach'), 'sumKahanForEach': ('sumKahan', 'ForEach'), 'sumMapForEach': ('sumMap', 'ForEach'), 'theilsUForEach': ('theilsU', 'ForEach'), 'maxMapForEach': ('maxMap', 'ForEach'), 'entropyForEach': ('entropy', 'ForEach'), 'welchTTestForEach': ('welchTTest', 'ForEach'), 'varPopForEach': ('varPop', 'ForEach'), 'corrForEach': ('corr', 'ForEach'), 'quantileTDigestForEach': ('quantileTDigest', 'ForEach'), 'skewPopForEach': ('skewPop', 'ForEach'), 'groupBitmapOrForEach': ('groupBitmapOr', 'ForEach'), 'exponentialTimeDecayedAvgForEach': ('exponentialTimeDecayedAvg', 'ForEach'), 'minMapForEach': ('minMap', 'ForEach'), 'boundingRatioForEach': ('boundingRatio', 'ForEach'), 'uniqCombinedForEach': ('uniqCombined', 'ForEach'), 'groupArrayMovingSumForEach': ('groupArrayMovingSum', 'ForEach'), 'sumForEach': ('sum', 'ForEach'), 'stddevPopForEach': ('stddevPop', 'ForEach'), 'groupBitAndForEach': ('groupBitAnd', 'ForEach'), 'quantileInterpolatedWeightedForEach': ('quantileInterpolatedWeighted', 'ForEach'), 'uniqThetaForEach': ('uniqTheta', 'ForEach'), 'sequenceNextNodeForEach': ('sequenceNextNode', 'ForEach'), 'groupUniqArrayForEach': ('groupUniqArray', 'ForEach'), 'maxForEach': ('max', 'ForEach'), 'skewSampForEach': ('skewSamp', 'ForEach'), 'quantilesBFloat16WeightedForEach': ('quantilesBFloat16Weighted', 'ForEach'), 'quantilesExactLowForEach': ('quantilesExactLow', 'ForEach'), 'quantilesDeterministicForEach': ('quantilesDeterministic', 'ForEach'), 'groupBitmapForEach': ('groupBitmap', 'ForEach'), 'cramersVForEach': ('cramersV', 'ForEach'), 'categoricalInformationValueForEach': ('categoricalInformationValue', 'ForEach'), 'meanZTestForEach': ('meanZTest', 'ForEach'), 'stochasticLogisticRegressionForEach': ('stochasticLogisticRegression', 'ForEach'), 'quantilesInterpolatedWeightedForEach': ('quantilesInterpolatedWeighted', 'ForEach'), 'quantilesForEach': ('quantiles', 'ForEach'), 'uniqCombined64ForEach': ('uniqCombined64', 'ForEach'), 'kurtPopForEach': ('kurtPop', 'ForEach'), 'intervalLengthSumForEach': ('intervalLengthSum', 'ForEach'), 'quantileExactWeightedForEach': ('quantileExactWeighted', 'ForEach'), 'histogramForEach': ('histogram', 'ForEach'), 'avgForEach': ('avg', 'ForEach'), 'uniqForEach': ('uniq', 'ForEach'), 'uniqUpToForEach': ('uniqUpTo', 'ForEach'), 'stddevSampForEach': ('stddevSamp', 'ForEach'), 'largestTriangleThreeBucketsForEach': ('largestTriangleThreeBuckets', 'ForEach'), 'medianForEach': ('median', 'ForEach'), 'deltaSumForEach': ('deltaSum', 'ForEach'), 'groupBitmapXorForEach': ('groupBitmapXor', 'ForEach'), 'quantileBFloat16ForEach': ('quantileBFloat16', 'ForEach'), 'simpleLinearRegressionForEach': ('simpleLinearRegression', 'ForEach'), 'quantileForEach': ('quantile', 'ForEach'), 'stochasticLinearRegressionForEach': ('stochasticLinearRegression', 'ForEach'), 'quantilesTimingForEach': ('quantilesTiming', 'ForEach'), 'contingencyForEach': ('contingency', 'ForEach'), 'covarSampForEach': ('covarSamp', 'ForEach'), 'deltaSumTimestampForEach': ('deltaSumTimestamp', 'ForEach'), 'uniqHLL12ForEach': ('uniqHLL12', 'ForEach'), 'maxIntersectionsForEach': ('maxIntersections', 'ForEach'), 'quantileTDigestWeightedForEach': ('quantileTDigestWeighted', 'ForEach'), 'groupArrayInsertAtForEach': ('groupArrayInsertAt', 'ForEach'), 'uniqExactForEach': ('uniqExact', 'ForEach'), 'last_valueForEach': ('last_value', 'ForEach'), 'quantilesTimingWeightedForEach': ('quantilesTimingWeighted', 'ForEach'), 'groupArraySampleForEach': ('groupArraySample', 'ForEach'), 'quantileBFloat16WeightedForEach': ('quantileBFloat16Weighted', 'ForEach'), 'quantilesTDigestWeightedForEach': ('quantilesTDigestWeighted', 'ForEach'), 'quantilesExactWeightedForEach': ('quantilesExactWeighted', 'ForEach'), 'rankCorrForEach': ('rankCorr', 'ForEach'), 'groupBitOrForEach': ('groupBitOr', 'ForEach'), 'groupArrayForEach': ('groupArray', 'ForEach'), 'sequenceMatchForEach': ('sequenceMatch', 'ForEach'), 'quantileTimingForEach': ('quantileTiming', 'ForEach'), 'anyLastForEach': ('anyLast', 'ForEach'), 'avgWeightedForEach': ('avgWeighted', 'ForEach'), 'groupArrayMovingAvgForEach': ('groupArrayMovingAvg', 'ForEach'), 'first_valueForEach': ('first_value', 'ForEach'), 'quantilesGKForEach': ('quantilesGK', 'ForEach'), 'argMinForEach': ('argMin', 'ForEach'), 'quantilesExactHighForEach': ('quantilesExactHigh', 'ForEach'), 'countForEach': ('count', 'ForEach'), 'varSampForEach': ('varSamp', 'ForEach'), 'quantileExactForEach': ('quantileExact', 'ForEach'), 'kolmogorovSmirnovTestForEach': ('kolmogorovSmirnovTest', 'ForEach'), 'groupBitmapAndForEach': ('groupBitmapAnd', 'ForEach'), 'sparkBarForEach': ('sparkBar', 'ForEach'), 'covarPopForEach': ('covarPop', 'ForEach'), 'groupArrayLastForEach': ('groupArrayLast', 'ForEach'), 'mannWhitneyUTestForEach': ('mannWhitneyUTest', 'ForEach'), 'studentTTestForEach': ('studentTTest', 'ForEach'), 'quantileTimingWeightedForEach': ('quantileTimingWeighted', 'ForEach'), 'anyForEach': ('any', 'ForEach'), 'sequenceCountForEach': ('sequenceCount', 'ForEach'), 'quantileGKForEach': ('quantileGK', 'ForEach'), 'maxIntersectionsPositionForEach': ('maxIntersectionsPosition', 'ForEach'), 'retentionDistinct': ('retention', 'Distinct'), 'quantilesExactDistinct': ('quantilesExact', 'Distinct'), 'windowFunnelDistinct': ('windowFunnel', 'Distinct'), 'sumWithOverflowDistinct': ('sumWithOverflow', 'Distinct'), 'minDistinct': ('min', 'Distinct'), 'kurtSampDistinct': ('kurtSamp', 'Distinct'), 'quantileDeterministicDistinct': ('quantileDeterministic', 'Distinct'), 'quantileExactHighDistinct': ('quantileExactHigh', 'Distinct'), 'quantileExactLowDistinct': ('quantileExactLow', 'Distinct'), 'argMaxDistinct': ('argMax', 'Distinct'), 'groupBitXorDistinct': ('groupBitXor', 'Distinct'), 'quantilesTDigestDistinct': ('quantilesTDigest', 'Distinct'), 'topKWeightedDistinct': ('topKWeighted', 'Distinct'), 'quantilesBFloat16Distinct': ('quantilesBFloat16', 'Distinct'), 'cramersVBiasCorrectedDistinct': ('cramersVBiasCorrected', 'Distinct'), 'exponentialMovingAverageDistinct': ('exponentialMovingAverage', 'Distinct'), 'anyHeavyDistinct': ('anyHeavy', 'Distinct'), 'topKDistinct': ('topK', 'Distinct'), 'sumCountDistinct': ('sumCount', 'Distinct'), 'sumKahanDistinct': ('sumKahan', 'Distinct'), 'sumMapDistinct': ('sumMap', 'Distinct'), 'theilsUDistinct': ('theilsU', 'Distinct'), 'maxMapDistinct': ('maxMap', 'Distinct'), 'entropyDistinct': ('entropy', 'Distinct'), 'welchTTestDistinct': ('welchTTest', 'Distinct'), 'varPopDistinct': ('varPop', 'Distinct'), 'corrDistinct': ('corr', 'Distinct'), 'quantileTDigestDistinct': ('quantileTDigest', 'Distinct'), 'skewPopDistinct': ('skewPop', 'Distinct'), 'groupBitmapOrDistinct': ('groupBitmapOr', 'Distinct'), 'exponentialTimeDecayedAvgDistinct': ('exponentialTimeDecayedAvg', 'Distinct'), 'minMapDistinct': ('minMap', 'Distinct'), 'boundingRatioDistinct': ('boundingRatio', 'Distinct'), 'uniqCombinedDistinct': ('uniqCombined', 'Distinct'), 'groupArrayMovingSumDistinct': ('groupArrayMovingSum', 'Distinct'), 'sumDistinct': ('sum', 'Distinct'), 'stddevPopDistinct': ('stddevPop', 'Distinct'), 'groupBitAndDistinct': ('groupBitAnd', 'Distinct'), 'quantileInterpolatedWeightedDistinct': ('quantileInterpolatedWeighted', 'Distinct'), 'uniqThetaDistinct': ('uniqTheta', 'Distinct'), 'sequenceNextNodeDistinct': ('sequenceNextNode', 'Distinct'), 'groupUniqArrayDistinct': ('groupUniqArray', 'Distinct'), 'maxDistinct': ('max', 'Distinct'), 'skewSampDistinct': ('skewSamp', 'Distinct'), 'quantilesBFloat16WeightedDistinct': ('quantilesBFloat16Weighted', 'Distinct'), 'quantilesExactLowDistinct': ('quantilesExactLow', 'Distinct'), 'quantilesDeterministicDistinct': ('quantilesDeterministic', 'Distinct'), 'groupBitmapDistinct': ('groupBitmap', 'Distinct'), 'cramersVDistinct': ('cramersV', 'Distinct'), 'categoricalInformationValueDistinct': ('categoricalInformationValue', 'Distinct'), 'meanZTestDistinct': ('meanZTest', 'Distinct'), 'stochasticLogisticRegressionDistinct': ('stochasticLogisticRegression', 'Distinct'), 'quantilesInterpolatedWeightedDistinct': ('quantilesInterpolatedWeighted', 'Distinct'), 'quantilesDistinct': ('quantiles', 'Distinct'), 'uniqCombined64Distinct': ('uniqCombined64', 'Distinct'), 'kurtPopDistinct': ('kurtPop', 'Distinct'), 'intervalLengthSumDistinct': ('intervalLengthSum', 'Distinct'), 'quantileExactWeightedDistinct': ('quantileExactWeighted', 'Distinct'), 'histogramDistinct': ('histogram', 'Distinct'), 'avgDistinct': ('avg', 'Distinct'), 'uniqDistinct': ('uniq', 'Distinct'), 'uniqUpToDistinct': ('uniqUpTo', 'Distinct'), 'stddevSampDistinct': ('stddevSamp', 'Distinct'), 'largestTriangleThreeBucketsDistinct': ('largestTriangleThreeBuckets', 'Distinct'), 'medianDistinct': ('median', 'Distinct'), 'deltaSumDistinct': ('deltaSum', 'Distinct'), 'groupBitmapXorDistinct': ('groupBitmapXor', 'Distinct'), 'quantileBFloat16Distinct': ('quantileBFloat16', 'Distinct'), 'simpleLinearRegressionDistinct': ('simpleLinearRegression', 'Distinct'), 'quantileDistinct': ('quantile', 'Distinct'), 'stochasticLinearRegressionDistinct': ('stochasticLinearRegression', 'Distinct'), 'quantilesTimingDistinct': ('quantilesTiming', 'Distinct'), 'contingencyDistinct': ('contingency', 'Distinct'), 'covarSampDistinct': ('covarSamp', 'Distinct'), 'deltaSumTimestampDistinct': ('deltaSumTimestamp', 'Distinct'), 'uniqHLL12Distinct': ('uniqHLL12', 'Distinct'), 'maxIntersectionsDistinct': ('maxIntersections', 'Distinct'), 'quantileTDigestWeightedDistinct': ('quantileTDigestWeighted', 'Distinct'), 'groupArrayInsertAtDistinct': ('groupArrayInsertAt', 'Distinct'), 'uniqExactDistinct': ('uniqExact', 'Distinct'), 'last_valueDistinct': ('last_value', 'Distinct'), 'quantilesTimingWeightedDistinct': ('quantilesTimingWeighted', 'Distinct'), 'groupArraySampleDistinct': ('groupArraySample', 'Distinct'), 'quantileBFloat16WeightedDistinct': ('quantileBFloat16Weighted', 'Distinct'), 'quantilesTDigestWeightedDistinct': ('quantilesTDigestWeighted', 'Distinct'), 'quantilesExactWeightedDistinct': ('quantilesExactWeighted', 'Distinct'), 'rankCorrDistinct': ('rankCorr', 'Distinct'), 'groupBitOrDistinct': ('groupBitOr', 'Distinct'), 'groupArrayDistinct': ('groupArray', 'Distinct'), 'sequenceMatchDistinct': ('sequenceMatch', 'Distinct'), 'quantileTimingDistinct': ('quantileTiming', 'Distinct'), 'anyLastDistinct': ('anyLast', 'Distinct'), 'avgWeightedDistinct': ('avgWeighted', 'Distinct'), 'groupArrayMovingAvgDistinct': ('groupArrayMovingAvg', 'Distinct'), 'first_valueDistinct': ('first_value', 'Distinct'), 'quantilesGKDistinct': ('quantilesGK', 'Distinct'), 'argMinDistinct': ('argMin', 'Distinct'), 'quantilesExactHighDistinct': ('quantilesExactHigh', 'Distinct'), 'countDistinct': ('count', 'Distinct'), 'varSampDistinct': ('varSamp', 'Distinct'), 'quantileExactDistinct': ('quantileExact', 'Distinct'), 'kolmogorovSmirnovTestDistinct': ('kolmogorovSmirnovTest', 'Distinct'), 'groupBitmapAndDistinct': ('groupBitmapAnd', 'Distinct'), 'sparkBarDistinct': ('sparkBar', 'Distinct'), 'covarPopDistinct': ('covarPop', 'Distinct'), 'groupArrayLastDistinct': ('groupArrayLast', 'Distinct'), 'mannWhitneyUTestDistinct': ('mannWhitneyUTest', 'Distinct'), 'studentTTestDistinct': ('studentTTest', 'Distinct'), 'quantileTimingWeightedDistinct': ('quantileTimingWeighted', 'Distinct'), 'anyDistinct': ('any', 'Distinct'), 'sequenceCountDistinct': ('sequenceCount', 'Distinct'), 'quantileGKDistinct': ('quantileGK', 'Distinct'), 'maxIntersectionsPositionDistinct': ('maxIntersectionsPosition', 'Distinct'), 'retentionOrDefault': ('retention', 'OrDefault'), 'quantilesExactOrDefault': ('quantilesExact', 'OrDefault'), 'windowFunnelOrDefault': ('windowFunnel', 'OrDefault'), 'sumWithOverflowOrDefault': ('sumWithOverflow', 'OrDefault'), 'minOrDefault': ('min', 'OrDefault'), 'kurtSampOrDefault': ('kurtSamp', 'OrDefault'), 'quantileDeterministicOrDefault': ('quantileDeterministic', 'OrDefault'), 'quantileExactHighOrDefault': ('quantileExactHigh', 'OrDefault'), 'quantileExactLowOrDefault': ('quantileExactLow', 'OrDefault'), 'argMaxOrDefault': ('argMax', 'OrDefault'), 'groupBitXorOrDefault': ('groupBitXor', 'OrDefault'), 'quantilesTDigestOrDefault': ('quantilesTDigest', 'OrDefault'), 'topKWeightedOrDefault': ('topKWeighted', 'OrDefault'), 'quantilesBFloat16OrDefault': ('quantilesBFloat16', 'OrDefault'), 'cramersVBiasCorrectedOrDefault': ('cramersVBiasCorrected', 'OrDefault'), 'exponentialMovingAverageOrDefault': ('exponentialMovingAverage', 'OrDefault'), 'anyHeavyOrDefault': ('anyHeavy', 'OrDefault'), 'topKOrDefault': ('topK', 'OrDefault'), 'sumCountOrDefault': ('sumCount', 'OrDefault'), 'sumKahanOrDefault': ('sumKahan', 'OrDefault'), 'sumMapOrDefault': ('sumMap', 'OrDefault'), 'theilsUOrDefault': ('theilsU', 'OrDefault'), 'maxMapOrDefault': ('maxMap', 'OrDefault'), 'entropyOrDefault': ('entropy', 'OrDefault'), 'welchTTestOrDefault': ('welchTTest', 'OrDefault'), 'varPopOrDefault': ('varPop', 'OrDefault'), 'corrOrDefault': ('corr', 'OrDefault'), 'quantileTDigestOrDefault': ('quantileTDigest', 'OrDefault'), 'skewPopOrDefault': ('skewPop', 'OrDefault'), 'groupBitmapOrOrDefault': ('groupBitmapOr', 'OrDefault'), 'exponentialTimeDecayedAvgOrDefault': ('exponentialTimeDecayedAvg', 'OrDefault'), 'minMapOrDefault': ('minMap', 'OrDefault'), 'boundingRatioOrDefault': ('boundingRatio', 'OrDefault'), 'uniqCombinedOrDefault': ('uniqCombined', 'OrDefault'), 'groupArrayMovingSumOrDefault': ('groupArrayMovingSum', 'OrDefault'), 'sumOrDefault': ('sum', 'OrDefault'), 'stddevPopOrDefault': ('stddevPop', 'OrDefault'), 'groupBitAndOrDefault': ('groupBitAnd', 'OrDefault'), 'quantileInterpolatedWeightedOrDefault': ('quantileInterpolatedWeighted', 'OrDefault'), 'uniqThetaOrDefault': ('uniqTheta', 'OrDefault'), 'sequenceNextNodeOrDefault': ('sequenceNextNode', 'OrDefault'), 'groupUniqArrayOrDefault': ('groupUniqArray', 'OrDefault'), 'maxOrDefault': ('max', 'OrDefault'), 'skewSampOrDefault': ('skewSamp', 'OrDefault'), 'quantilesBFloat16WeightedOrDefault': ('quantilesBFloat16Weighted', 'OrDefault'), 'quantilesExactLowOrDefault': ('quantilesExactLow', 'OrDefault'), 'quantilesDeterministicOrDefault': ('quantilesDeterministic', 'OrDefault'), 'groupBitmapOrDefault': ('groupBitmap', 'OrDefault'), 'cramersVOrDefault': ('cramersV', 'OrDefault'), 'categoricalInformationValueOrDefault': ('categoricalInformationValue', 'OrDefault'), 'meanZTestOrDefault': ('meanZTest', 'OrDefault'), 'stochasticLogisticRegressionOrDefault': ('stochasticLogisticRegression', 'OrDefault'), 'quantilesInterpolatedWeightedOrDefault': ('quantilesInterpolatedWeighted', 'OrDefault'), 'quantilesOrDefault': ('quantiles', 'OrDefault'), 'uniqCombined64OrDefault': ('uniqCombined64', 'OrDefault'), 'kurtPopOrDefault': ('kurtPop', 'OrDefault'), 'intervalLengthSumOrDefault': ('intervalLengthSum', 'OrDefault'), 'quantileExactWeightedOrDefault': ('quantileExactWeighted', 'OrDefault'), 'histogramOrDefault': ('histogram', 'OrDefault'), 'avgOrDefault': ('avg', 'OrDefault'), 'uniqOrDefault': ('uniq', 'OrDefault'), 'uniqUpToOrDefault': ('uniqUpTo', 'OrDefault'), 'stddevSampOrDefault': ('stddevSamp', 'OrDefault'), 'largestTriangleThreeBucketsOrDefault': ('largestTriangleThreeBuckets', 'OrDefault'), 'medianOrDefault': ('median', 'OrDefault'), 'deltaSumOrDefault': ('deltaSum', 'OrDefault'), 'groupBitmapXorOrDefault': ('groupBitmapXor', 'OrDefault'), 'quantileBFloat16OrDefault': ('quantileBFloat16', 'OrDefault'), 'simpleLinearRegressionOrDefault': ('simpleLinearRegression', 'OrDefault'), 'quantileOrDefault': ('quantile', 'OrDefault'), 'stochasticLinearRegressionOrDefault': ('stochasticLinearRegression', 'OrDefault'), 'quantilesTimingOrDefault': ('quantilesTiming', 'OrDefault'), 'contingencyOrDefault': ('contingency', 'OrDefault'), 'covarSampOrDefault': ('covarSamp', 'OrDefault'), 'deltaSumTimestampOrDefault': ('deltaSumTimestamp', 'OrDefault'), 'uniqHLL12OrDefault': ('uniqHLL12', 'OrDefault'), 'maxIntersectionsOrDefault': ('maxIntersections', 'OrDefault'), 'quantileTDigestWeightedOrDefault': ('quantileTDigestWeighted', 'OrDefault'), 'groupArrayInsertAtOrDefault': ('groupArrayInsertAt', 'OrDefault'), 'uniqExactOrDefault': ('uniqExact', 'OrDefault'), 'last_valueOrDefault': ('last_value', 'OrDefault'), 'quantilesTimingWeightedOrDefault': ('quantilesTimingWeighted', 'OrDefault'), 'groupArraySampleOrDefault': ('groupArraySample', 'OrDefault'), 'quantileBFloat16WeightedOrDefault': ('quantileBFloat16Weighted', 'OrDefault'), 'quantilesTDigestWeightedOrDefault': ('quantilesTDigestWeighted', 'OrDefault'), 'quantilesExactWeightedOrDefault': ('quantilesExactWeighted', 'OrDefault'), 'rankCorrOrDefault': ('rankCorr', 'OrDefault'), 'groupBitOrOrDefault': ('groupBitOr', 'OrDefault'), 'groupArrayOrDefault': ('groupArray', 'OrDefault'), 'sequenceMatchOrDefault': ('sequenceMatch', 'OrDefault'), 'quantileTimingOrDefault': ('quantileTiming', 'OrDefault'), 'anyLastOrDefault': ('anyLast', 'OrDefault'), 'avgWeightedOrDefault': ('avgWeighted', 'OrDefault'), 'groupArrayMovingAvgOrDefault': ('groupArrayMovingAvg', 'OrDefault'), 'first_valueOrDefault': ('first_value', 'OrDefault'), 'quantilesGKOrDefault': ('quantilesGK', 'OrDefault'), 'argMinOrDefault': ('argMin', 'OrDefault'), 'quantilesExactHighOrDefault': ('quantilesExactHigh', 'OrDefault'), 'countOrDefault': ('count', 'OrDefault'), 'varSampOrDefault': ('varSamp', 'OrDefault'), 'quantileExactOrDefault': ('quantileExact', 'OrDefault'), 'kolmogorovSmirnovTestOrDefault': ('kolmogorovSmirnovTest', 'OrDefault'), 'groupBitmapAndOrDefault': ('groupBitmapAnd', 'OrDefault'), 'sparkBarOrDefault': ('sparkBar', 'OrDefault'), 'covarPopOrDefault': ('covarPop', 'OrDefault'), 'groupArrayLastOrDefault': ('groupArrayLast', 'OrDefault'), 'mannWhitneyUTestOrDefault': ('mannWhitneyUTest', 'OrDefault'), 'studentTTestOrDefault': ('studentTTest', 'OrDefault'), 'quantileTimingWeightedOrDefault': ('quantileTimingWeighted', 'OrDefault'), 'anyOrDefault': ('any', 'OrDefault'), 'sequenceCountOrDefault': ('sequenceCount', 'OrDefault'), 'quantileGKOrDefault': ('quantileGK', 'OrDefault'), 'maxIntersectionsPositionOrDefault': ('maxIntersectionsPosition', 'OrDefault'), 'retentionOrNull': ('retention', 'OrNull'), 'quantilesExactOrNull': ('quantilesExact', 'OrNull'), 'windowFunnelOrNull': ('windowFunnel', 'OrNull'), 'sumWithOverflowOrNull': ('sumWithOverflow', 'OrNull'), 'minOrNull': ('min', 'OrNull'), 'kurtSampOrNull': ('kurtSamp', 'OrNull'), 'quantileDeterministicOrNull': ('quantileDeterministic', 'OrNull'), 'quantileExactHighOrNull': ('quantileExactHigh', 'OrNull'), 'quantileExactLowOrNull': ('quantileExactLow', 'OrNull'), 'argMaxOrNull': ('argMax', 'OrNull'), 'groupBitXorOrNull': ('groupBitXor', 'OrNull'), 'quantilesTDigestOrNull': ('quantilesTDigest', 'OrNull'), 'topKWeightedOrNull': ('topKWeighted', 'OrNull'), 'quantilesBFloat16OrNull': ('quantilesBFloat16', 'OrNull'), 'cramersVBiasCorrectedOrNull': ('cramersVBiasCorrected', 'OrNull'), 'exponentialMovingAverageOrNull': ('exponentialMovingAverage', 'OrNull'), 'anyHeavyOrNull': ('anyHeavy', 'OrNull'), 'topKOrNull': ('topK', 'OrNull'), 'sumCountOrNull': ('sumCount', 'OrNull'), 'sumKahanOrNull': ('sumKahan', 'OrNull'), 'sumMapOrNull': ('sumMap', 'OrNull'), 'theilsUOrNull': ('theilsU', 'OrNull'), 'maxMapOrNull': ('maxMap', 'OrNull'), 'entropyOrNull': ('entropy', 'OrNull'), 'welchTTestOrNull': ('welchTTest', 'OrNull'), 'varPopOrNull': ('varPop', 'OrNull'), 'corrOrNull': ('corr', 'OrNull'), 'quantileTDigestOrNull': ('quantileTDigest', 'OrNull'), 'skewPopOrNull': ('skewPop', 'OrNull'), 'groupBitmapOrOrNull': ('groupBitmapOr', 'OrNull'), 'exponentialTimeDecayedAvgOrNull': ('exponentialTimeDecayedAvg', 'OrNull'), 'minMapOrNull': ('minMap', 'OrNull'), 'boundingRatioOrNull': ('boundingRatio', 'OrNull'), 'uniqCombinedOrNull': ('uniqCombined', 'OrNull'), 'groupArrayMovingSumOrNull': ('groupArrayMovingSum', 'OrNull'), 'sumOrNull': ('sum', 'OrNull'), 'stddevPopOrNull': ('stddevPop', 'OrNull'), 'groupBitAndOrNull': ('groupBitAnd', 'OrNull'), 'quantileInterpolatedWeightedOrNull': ('quantileInterpolatedWeighted', 'OrNull'), 'uniqThetaOrNull': ('uniqTheta', 'OrNull'), 'sequenceNextNodeOrNull': ('sequenceNextNode', 'OrNull'), 'groupUniqArrayOrNull': ('groupUniqArray', 'OrNull'), 'maxOrNull': ('max', 'OrNull'), 'skewSampOrNull': ('skewSamp', 'OrNull'), 'quantilesBFloat16WeightedOrNull': ('quantilesBFloat16Weighted', 'OrNull'), 'quantilesExactLowOrNull': ('quantilesExactLow', 'OrNull'), 'quantilesDeterministicOrNull': ('quantilesDeterministic', 'OrNull'), 'groupBitmapOrNull': ('groupBitmap', 'OrNull'), 'cramersVOrNull': ('cramersV', 'OrNull'), 'categoricalInformationValueOrNull': ('categoricalInformationValue', 'OrNull'), 'meanZTestOrNull': ('meanZTest', 'OrNull'), 'stochasticLogisticRegressionOrNull': ('stochasticLogisticRegression', 'OrNull'), 'quantilesInterpolatedWeightedOrNull': ('quantilesInterpolatedWeighted', 'OrNull'), 'quantilesOrNull': ('quantiles', 'OrNull'), 'uniqCombined64OrNull': ('uniqCombined64', 'OrNull'), 'kurtPopOrNull': ('kurtPop', 'OrNull'), 'intervalLengthSumOrNull': ('intervalLengthSum', 'OrNull'), 'quantileExactWeightedOrNull': ('quantileExactWeighted', 'OrNull'), 'histogramOrNull': ('histogram', 'OrNull'), 'avgOrNull': ('avg', 'OrNull'), 'uniqOrNull': ('uniq', 'OrNull'), 'uniqUpToOrNull': ('uniqUpTo', 'OrNull'), 'stddevSampOrNull': ('stddevSamp', 'OrNull'), 'largestTriangleThreeBucketsOrNull': ('largestTriangleThreeBuckets', 'OrNull'), 'medianOrNull': ('median', 'OrNull'), 'deltaSumOrNull': ('deltaSum', 'OrNull'), 'groupBitmapXorOrNull': ('groupBitmapXor', 'OrNull'), 'quantileBFloat16OrNull': ('quantileBFloat16', 'OrNull'), 'simpleLinearRegressionOrNull': ('simpleLinearRegression', 'OrNull'), 'quantileOrNull': ('quantile', 'OrNull'), 'stochasticLinearRegressionOrNull': ('stochasticLinearRegression', 'OrNull'), 'quantilesTimingOrNull': ('quantilesTiming', 'OrNull'), 'contingencyOrNull': ('contingency', 'OrNull'), 'covarSampOrNull': ('covarSamp', 'OrNull'), 'deltaSumTimestampOrNull': ('deltaSumTimestamp', 'OrNull'), 'uniqHLL12OrNull': ('uniqHLL12', 'OrNull'), 'maxIntersectionsOrNull': ('maxIntersections', 'OrNull'), 'quantileTDigestWeightedOrNull': ('quantileTDigestWeighted', 'OrNull'), 'groupArrayInsertAtOrNull': ('groupArrayInsertAt', 'OrNull'), 'uniqExactOrNull': ('uniqExact', 'OrNull'), 'last_valueOrNull': ('last_value', 'OrNull'), 'quantilesTimingWeightedOrNull': ('quantilesTimingWeighted', 'OrNull'), 'groupArraySampleOrNull': ('groupArraySample', 'OrNull'), 'quantileBFloat16WeightedOrNull': ('quantileBFloat16Weighted', 'OrNull'), 'quantilesTDigestWeightedOrNull': ('quantilesTDigestWeighted', 'OrNull'), 'quantilesExactWeightedOrNull': ('quantilesExactWeighted', 'OrNull'), 'rankCorrOrNull': ('rankCorr', 'OrNull'), 'groupBitOrOrNull': ('groupBitOr', 'OrNull'), 'groupArrayOrNull': ('groupArray', 'OrNull'), 'sequenceMatchOrNull': ('sequenceMatch', 'OrNull'), 'quantileTimingOrNull': ('quantileTiming', 'OrNull'), 'anyLastOrNull': ('anyLast', 'OrNull'), 'avgWeightedOrNull': ('avgWeighted', 'OrNull'), 'groupArrayMovingAvgOrNull': ('groupArrayMovingAvg', 'OrNull'), 'first_valueOrNull': ('first_value', 'OrNull'), 'quantilesGKOrNull': ('quantilesGK', 'OrNull'), 'argMinOrNull': ('argMin', 'OrNull'), 'quantilesExactHighOrNull': ('quantilesExactHigh', 'OrNull'), 'countOrNull': ('count', 'OrNull'), 'varSampOrNull': ('varSamp', 'OrNull'), 'quantileExactOrNull': ('quantileExact', 'OrNull'), 'kolmogorovSmirnovTestOrNull': ('kolmogorovSmirnovTest', 'OrNull'), 'groupBitmapAndOrNull': ('groupBitmapAnd', 'OrNull'), 'sparkBarOrNull': ('sparkBar', 'OrNull'), 'covarPopOrNull': ('covarPop', 'OrNull'), 'groupArrayLastOrNull': ('groupArrayLast', 'OrNull'), 'mannWhitneyUTestOrNull': ('mannWhitneyUTest', 'OrNull'), 'studentTTestOrNull': ('studentTTest', 'OrNull'), 'quantileTimingWeightedOrNull': ('quantileTimingWeighted', 'OrNull'), 'anyOrNull': ('any', 'OrNull'), 'sequenceCountOrNull': ('sequenceCount', 'OrNull'), 'quantileGKOrNull': ('quantileGK', 'OrNull'), 'maxIntersectionsPositionOrNull': ('maxIntersectionsPosition', 'OrNull'), 'retentionResample': ('retention', 'Resample'), 'quantilesExactResample': ('quantilesExact', 'Resample'), 'windowFunnelResample': ('windowFunnel', 'Resample'), 'sumWithOverflowResample': ('sumWithOverflow', 'Resample'), 'minResample': ('min', 'Resample'), 'kurtSampResample': ('kurtSamp', 'Resample'), 'quantileDeterministicResample': ('quantileDeterministic', 'Resample'), 'quantileExactHighResample': ('quantileExactHigh', 'Resample'), 'quantileExactLowResample': ('quantileExactLow', 'Resample'), 'argMaxResample': ('argMax', 'Resample'), 'groupBitXorResample': ('groupBitXor', 'Resample'), 'quantilesTDigestResample': ('quantilesTDigest', 'Resample'), 'topKWeightedResample': ('topKWeighted', 'Resample'), 'quantilesBFloat16Resample': ('quantilesBFloat16', 'Resample'), 'cramersVBiasCorrectedResample': ('cramersVBiasCorrected', 'Resample'), 'exponentialMovingAverageResample': ('exponentialMovingAverage', 'Resample'), 'anyHeavyResample': ('anyHeavy', 'Resample'), 'topKResample': ('topK', 'Resample'), 'sumCountResample': ('sumCount', 'Resample'), 'sumKahanResample': ('sumKahan', 'Resample'), 'sumMapResample': ('sumMap', 'Resample'), 'theilsUResample': ('theilsU', 'Resample'), 'maxMapResample': ('maxMap', 'Resample'), 'entropyResample': ('entropy', 'Resample'), 'welchTTestResample': ('welchTTest', 'Resample'), 'varPopResample': ('varPop', 'Resample'), 'corrResample': ('corr', 'Resample'), 'quantileTDigestResample': ('quantileTDigest', 'Resample'), 'skewPopResample': ('skewPop', 'Resample'), 'groupBitmapOrResample': ('groupBitmapOr', 'Resample'), 'exponentialTimeDecayedAvgResample': ('exponentialTimeDecayedAvg', 'Resample'), 'minMapResample': ('minMap', 'Resample'), 'boundingRatioResample': ('boundingRatio', 'Resample'), 'uniqCombinedResample': ('uniqCombined', 'Resample'), 'groupArrayMovingSumResample': ('groupArrayMovingSum', 'Resample'), 'sumResample': ('sum', 'Resample'), 'stddevPopResample': ('stddevPop', 'Resample'), 'groupBitAndResample': ('groupBitAnd', 'Resample'), 'quantileInterpolatedWeightedResample': ('quantileInterpolatedWeighted', 'Resample'), 'uniqThetaResample': ('uniqTheta', 'Resample'), 'sequenceNextNodeResample': ('sequenceNextNode', 'Resample'), 'groupUniqArrayResample': ('groupUniqArray', 'Resample'), 'maxResample': ('max', 'Resample'), 'skewSampResample': ('skewSamp', 'Resample'), 'quantilesBFloat16WeightedResample': ('quantilesBFloat16Weighted', 'Resample'), 'quantilesExactLowResample': ('quantilesExactLow', 'Resample'), 'quantilesDeterministicResample': ('quantilesDeterministic', 'Resample'), 'groupBitmapResample': ('groupBitmap', 'Resample'), 'cramersVResample': ('cramersV', 'Resample'), 'categoricalInformationValueResample': ('categoricalInformationValue', 'Resample'), 'meanZTestResample': ('meanZTest', 'Resample'), 'stochasticLogisticRegressionResample': ('stochasticLogisticRegression', 'Resample'), 'quantilesInterpolatedWeightedResample': ('quantilesInterpolatedWeighted', 'Resample'), 'quantilesResample': ('quantiles', 'Resample'), 'uniqCombined64Resample': ('uniqCombined64', 'Resample'), 'kurtPopResample': ('kurtPop', 'Resample'), 'intervalLengthSumResample': ('intervalLengthSum', 'Resample'), 'quantileExactWeightedResample': ('quantileExactWeighted', 'Resample'), 'histogramResample': ('histogram', 'Resample'), 'avgResample': ('avg', 'Resample'), 'uniqResample': ('uniq', 'Resample'), 'uniqUpToResample': ('uniqUpTo', 'Resample'), 'stddevSampResample': ('stddevSamp', 'Resample'), 'largestTriangleThreeBucketsResample': ('largestTriangleThreeBuckets', 'Resample'), 'medianResample': ('median', 'Resample'), 'deltaSumResample': ('deltaSum', 'Resample'), 'groupBitmapXorResample': ('groupBitmapXor', 'Resample'), 'quantileBFloat16Resample': ('quantileBFloat16', 'Resample'), 'simpleLinearRegressionResample': ('simpleLinearRegression', 'Resample'), 'quantileResample': ('quantile', 'Resample'), 'stochasticLinearRegressionResample': ('stochasticLinearRegression', 'Resample'), 'quantilesTimingResample': ('quantilesTiming', 'Resample'), 'contingencyResample': ('contingency', 'Resample'), 'covarSampResample': ('covarSamp', 'Resample'), 'deltaSumTimestampResample': ('deltaSumTimestamp', 'Resample'), 'uniqHLL12Resample': ('uniqHLL12', 'Resample'), 'maxIntersectionsResample': ('maxIntersections', 'Resample'), 'quantileTDigestWeightedResample': ('quantileTDigestWeighted', 'Resample'), 'groupArrayInsertAtResample': ('groupArrayInsertAt', 'Resample'), 'uniqExactResample': ('uniqExact', 'Resample'), 'last_valueResample': ('last_value', 'Resample'), 'quantilesTimingWeightedResample': ('quantilesTimingWeighted', 'Resample'), 'groupArraySampleResample': ('groupArraySample', 'Resample'), 'quantileBFloat16WeightedResample': ('quantileBFloat16Weighted', 'Resample'), 'quantilesTDigestWeightedResample': ('quantilesTDigestWeighted', 'Resample'), 'quantilesExactWeightedResample': ('quantilesExactWeighted', 'Resample'), 'rankCorrResample': ('rankCorr', 'Resample'), 'groupBitOrResample': ('groupBitOr', 'Resample'), 'groupArrayResample': ('groupArray', 'Resample'), 'sequenceMatchResample': ('sequenceMatch', 'Resample'), 'quantileTimingResample': ('quantileTiming', 'Resample'), 'anyLastResample': ('anyLast', 'Resample'), 'avgWeightedResample': ('avgWeighted', 'Resample'), 'groupArrayMovingAvgResample': ('groupArrayMovingAvg', 'Resample'), 'first_valueResample': ('first_value', 'Resample'), 'quantilesGKResample': ('quantilesGK', 'Resample'), 'argMinResample': ('argMin', 'Resample'), 'quantilesExactHighResample': ('quantilesExactHigh', 'Resample'), 'countResample': ('count', 'Resample'), 'varSampResample': ('varSamp', 'Resample'), 'quantileExactResample': ('quantileExact', 'Resample'), 'kolmogorovSmirnovTestResample': ('kolmogorovSmirnovTest', 'Resample'), 'groupBitmapAndResample': ('groupBitmapAnd', 'Resample'), 'sparkBarResample': ('sparkBar', 'Resample'), 'covarPopResample': ('covarPop', 'Resample'), 'groupArrayLastResample': ('groupArrayLast', 'Resample'), 'mannWhitneyUTestResample': ('mannWhitneyUTest', 'Resample'), 'studentTTestResample': ('studentTTest', 'Resample'), 'quantileTimingWeightedResample': ('quantileTimingWeighted', 'Resample'), 'anyResample': ('any', 'Resample'), 'sequenceCountResample': ('sequenceCount', 'Resample'), 'quantileGKResample': ('quantileGK', 'Resample'), 'maxIntersectionsPositionResample': ('maxIntersectionsPosition', 'Resample'), 'retentionArgMin': ('retention', 'ArgMin'), 'quantilesExactArgMin': ('quantilesExact', 'ArgMin'), 'windowFunnelArgMin': ('windowFunnel', 'ArgMin'), 'sumWithOverflowArgMin': ('sumWithOverflow', 'ArgMin'), 'minArgMin': ('min', 'ArgMin'), 'kurtSampArgMin': ('kurtSamp', 'ArgMin'), 'quantileDeterministicArgMin': ('quantileDeterministic', 'ArgMin'), 'quantileExactHighArgMin': ('quantileExactHigh', 'ArgMin'), 'quantileExactLowArgMin': ('quantileExactLow', 'ArgMin'), 'argMaxArgMin': ('argMax', 'ArgMin'), 'groupBitXorArgMin': ('groupBitXor', 'ArgMin'), 'quantilesTDigestArgMin': ('quantilesTDigest', 'ArgMin'), 'topKWeightedArgMin': ('topKWeighted', 'ArgMin'), 'quantilesBFloat16ArgMin': ('quantilesBFloat16', 'ArgMin'), 'cramersVBiasCorrectedArgMin': ('cramersVBiasCorrected', 'ArgMin'), 'exponentialMovingAverageArgMin': ('exponentialMovingAverage', 'ArgMin'), 'anyHeavyArgMin': ('anyHeavy', 'ArgMin'), 'topKArgMin': ('topK', 'ArgMin'), 'sumCountArgMin': ('sumCount', 'ArgMin'), 'sumKahanArgMin': ('sumKahan', 'ArgMin'), 'sumMapArgMin': ('sumMap', 'ArgMin'), 'theilsUArgMin': ('theilsU', 'ArgMin'), 'maxMapArgMin': ('maxMap', 'ArgMin'), 'entropyArgMin': ('entropy', 'ArgMin'), 'welchTTestArgMin': ('welchTTest', 'ArgMin'), 'varPopArgMin': ('varPop', 'ArgMin'), 'corrArgMin': ('corr', 'ArgMin'), 'quantileTDigestArgMin': ('quantileTDigest', 'ArgMin'), 'skewPopArgMin': ('skewPop', 'ArgMin'), 'groupBitmapOrArgMin': ('groupBitmapOr', 'ArgMin'), 'exponentialTimeDecayedAvgArgMin': ('exponentialTimeDecayedAvg', 'ArgMin'), 'minMapArgMin': ('minMap', 'ArgMin'), 'boundingRatioArgMin': ('boundingRatio', 'ArgMin'), 'uniqCombinedArgMin': ('uniqCombined', 'ArgMin'), 'groupArrayMovingSumArgMin': ('groupArrayMovingSum', 'ArgMin'), 'sumArgMin': ('sum', 'ArgMin'), 'stddevPopArgMin': ('stddevPop', 'ArgMin'), 'groupBitAndArgMin': ('groupBitAnd', 'ArgMin'), 'quantileInterpolatedWeightedArgMin': ('quantileInterpolatedWeighted', 'ArgMin'), 'uniqThetaArgMin': ('uniqTheta', 'ArgMin'), 'sequenceNextNodeArgMin': ('sequenceNextNode', 'ArgMin'), 'groupUniqArrayArgMin': ('groupUniqArray', 'ArgMin'), 'maxArgMin': ('max', 'ArgMin'), 'skewSampArgMin': ('skewSamp', 'ArgMin'), 'quantilesBFloat16WeightedArgMin': ('quantilesBFloat16Weighted', 'ArgMin'), 'quantilesExactLowArgMin': ('quantilesExactLow', 'ArgMin'), 'quantilesDeterministicArgMin': ('quantilesDeterministic', 'ArgMin'), 'groupBitmapArgMin': ('groupBitmap', 'ArgMin'), 'cramersVArgMin': ('cramersV', 'ArgMin'), 'categoricalInformationValueArgMin': ('categoricalInformationValue', 'ArgMin'), 'meanZTestArgMin': ('meanZTest', 'ArgMin'), 'stochasticLogisticRegressionArgMin': ('stochasticLogisticRegression', 'ArgMin'), 'quantilesInterpolatedWeightedArgMin': ('quantilesInterpolatedWeighted', 'ArgMin'), 'quantilesArgMin': ('quantiles', 'ArgMin'), 'uniqCombined64ArgMin': ('uniqCombined64', 'ArgMin'), 'kurtPopArgMin': ('kurtPop', 'ArgMin'), 'intervalLengthSumArgMin': ('intervalLengthSum', 'ArgMin'), 'quantileExactWeightedArgMin': ('quantileExactWeighted', 'ArgMin'), 'histogramArgMin': ('histogram', 'ArgMin'), 'avgArgMin': ('avg', 'ArgMin'), 'uniqArgMin': ('uniq', 'ArgMin'), 'uniqUpToArgMin': ('uniqUpTo', 'ArgMin'), 'stddevSampArgMin': ('stddevSamp', 'ArgMin'), 'largestTriangleThreeBucketsArgMin': ('largestTriangleThreeBuckets', 'ArgMin'), 'medianArgMin': ('median', 'ArgMin'), 'deltaSumArgMin': ('deltaSum', 'ArgMin'), 'groupBitmapXorArgMin': ('groupBitmapXor', 'ArgMin'), 'quantileBFloat16ArgMin': ('quantileBFloat16', 'ArgMin'), 'simpleLinearRegressionArgMin': ('simpleLinearRegression', 'ArgMin'), 'quantileArgMin': ('quantile', 'ArgMin'), 'stochasticLinearRegressionArgMin': ('stochasticLinearRegression', 'ArgMin'), 'quantilesTimingArgMin': ('quantilesTiming', 'ArgMin'), 'contingencyArgMin': ('contingency', 'ArgMin'), 'covarSampArgMin': ('covarSamp', 'ArgMin'), 'deltaSumTimestampArgMin': ('deltaSumTimestamp', 'ArgMin'), 'uniqHLL12ArgMin': ('uniqHLL12', 'ArgMin'), 'maxIntersectionsArgMin': ('maxIntersections', 'ArgMin'), 'quantileTDigestWeightedArgMin': ('quantileTDigestWeighted', 'ArgMin'), 'groupArrayInsertAtArgMin': ('groupArrayInsertAt', 'ArgMin'), 'uniqExactArgMin': ('uniqExact', 'ArgMin'), 'last_valueArgMin': ('last_value', 'ArgMin'), 'quantilesTimingWeightedArgMin': ('quantilesTimingWeighted', 'ArgMin'), 'groupArraySampleArgMin': ('groupArraySample', 'ArgMin'), 'quantileBFloat16WeightedArgMin': ('quantileBFloat16Weighted', 'ArgMin'), 'quantilesTDigestWeightedArgMin': ('quantilesTDigestWeighted', 'ArgMin'), 'quantilesExactWeightedArgMin': ('quantilesExactWeighted', 'ArgMin'), 'rankCorrArgMin': ('rankCorr', 'ArgMin'), 'groupBitOrArgMin': ('groupBitOr', 'ArgMin'), 'groupArrayArgMin': ('groupArray', 'ArgMin'), 'sequenceMatchArgMin': ('sequenceMatch', 'ArgMin'), 'quantileTimingArgMin': ('quantileTiming', 'ArgMin'), 'anyLastArgMin': ('anyLast', 'ArgMin'), 'avgWeightedArgMin': ('avgWeighted', 'ArgMin'), 'groupArrayMovingAvgArgMin': ('groupArrayMovingAvg', 'ArgMin'), 'first_valueArgMin': ('first_value', 'ArgMin'), 'quantilesGKArgMin': ('quantilesGK', 'ArgMin'), 'argMinArgMin': ('argMin', 'ArgMin'), 'quantilesExactHighArgMin': ('quantilesExactHigh', 'ArgMin'), 'countArgMin': ('count', 'ArgMin'), 'varSampArgMin': ('varSamp', 'ArgMin'), 'quantileExactArgMin': ('quantileExact', 'ArgMin'), 'kolmogorovSmirnovTestArgMin': ('kolmogorovSmirnovTest', 'ArgMin'), 'groupBitmapAndArgMin': ('groupBitmapAnd', 'ArgMin'), 'sparkBarArgMin': ('sparkBar', 'ArgMin'), 'covarPopArgMin': ('covarPop', 'ArgMin'), 'groupArrayLastArgMin': ('groupArrayLast', 'ArgMin'), 'mannWhitneyUTestArgMin': ('mannWhitneyUTest', 'ArgMin'), 'studentTTestArgMin': ('studentTTest', 'ArgMin'), 'quantileTimingWeightedArgMin': ('quantileTimingWeighted', 'ArgMin'), 'anyArgMin': ('any', 'ArgMin'), 'sequenceCountArgMin': ('sequenceCount', 'ArgMin'), 'quantileGKArgMin': ('quantileGK', 'ArgMin'), 'maxIntersectionsPositionArgMin': ('maxIntersectionsPosition', 'ArgMin'), 'retentionArgMax': ('retention', 'ArgMax'), 'quantilesExactArgMax': ('quantilesExact', 'ArgMax'), 'windowFunnelArgMax': ('windowFunnel', 'ArgMax'), 'sumWithOverflowArgMax': ('sumWithOverflow', 'ArgMax'), 'minArgMax': ('min', 'ArgMax'), 'kurtSampArgMax': ('kurtSamp', 'ArgMax'), 'quantileDeterministicArgMax': ('quantileDeterministic', 'ArgMax'), 'quantileExactHighArgMax': ('quantileExactHigh', 'ArgMax'), 'quantileExactLowArgMax': ('quantileExactLow', 'ArgMax'), 'argMaxArgMax': ('argMax', 'ArgMax'), 'groupBitXorArgMax': ('groupBitXor', 'ArgMax'), 'quantilesTDigestArgMax': ('quantilesTDigest', 'ArgMax'), 'topKWeightedArgMax': ('topKWeighted', 'ArgMax'), 'quantilesBFloat16ArgMax': ('quantilesBFloat16', 'ArgMax'), 'cramersVBiasCorrectedArgMax': ('cramersVBiasCorrected', 'ArgMax'), 'exponentialMovingAverageArgMax': ('exponentialMovingAverage', 'ArgMax'), 'anyHeavyArgMax': ('anyHeavy', 'ArgMax'), 'topKArgMax': ('topK', 'ArgMax'), 'sumCountArgMax': ('sumCount', 'ArgMax'), 'sumKahanArgMax': ('sumKahan', 'ArgMax'), 'sumMapArgMax': ('sumMap', 'ArgMax'), 'theilsUArgMax': ('theilsU', 'ArgMax'), 'maxMapArgMax': ('maxMap', 'ArgMax'), 'entropyArgMax': ('entropy', 'ArgMax'), 'welchTTestArgMax': ('welchTTest', 'ArgMax'), 'varPopArgMax': ('varPop', 'ArgMax'), 'corrArgMax': ('corr', 'ArgMax'), 'quantileTDigestArgMax': ('quantileTDigest', 'ArgMax'), 'skewPopArgMax': ('skewPop', 'ArgMax'), 'groupBitmapOrArgMax': ('groupBitmapOr', 'ArgMax'), 'exponentialTimeDecayedAvgArgMax': ('exponentialTimeDecayedAvg', 'ArgMax'), 'minMapArgMax': ('minMap', 'ArgMax'), 'boundingRatioArgMax': ('boundingRatio', 'ArgMax'), 'uniqCombinedArgMax': ('uniqCombined', 'ArgMax'), 'groupArrayMovingSumArgMax': ('groupArrayMovingSum', 'ArgMax'), 'sumArgMax': ('sum', 'ArgMax'), 'stddevPopArgMax': ('stddevPop', 'ArgMax'), 'groupBitAndArgMax': ('groupBitAnd', 'ArgMax'), 'quantileInterpolatedWeightedArgMax': ('quantileInterpolatedWeighted', 'ArgMax'), 'uniqThetaArgMax': ('uniqTheta', 'ArgMax'), 'sequenceNextNodeArgMax': ('sequenceNextNode', 'ArgMax'), 'groupUniqArrayArgMax': ('groupUniqArray', 'ArgMax'), 'maxArgMax': ('max', 'ArgMax'), 'skewSampArgMax': ('skewSamp', 'ArgMax'), 'quantilesBFloat16WeightedArgMax': ('quantilesBFloat16Weighted', 'ArgMax'), 'quantilesExactLowArgMax': ('quantilesExactLow', 'ArgMax'), 'quantilesDeterministicArgMax': ('quantilesDeterministic', 'ArgMax'), 'groupBitmapArgMax': ('groupBitmap', 'ArgMax'), 'cramersVArgMax': ('cramersV', 'ArgMax'), 'categoricalInformationValueArgMax': ('categoricalInformationValue', 'ArgMax'), 'meanZTestArgMax': ('meanZTest', 'ArgMax'), 'stochasticLogisticRegressionArgMax': ('stochasticLogisticRegression', 'ArgMax'), 'quantilesInterpolatedWeightedArgMax': ('quantilesInterpolatedWeighted', 'ArgMax'), 'quantilesArgMax': ('quantiles', 'ArgMax'), 'uniqCombined64ArgMax': ('uniqCombined64', 'ArgMax'), 'kurtPopArgMax': ('kurtPop', 'ArgMax'), 'intervalLengthSumArgMax': ('intervalLengthSum', 'ArgMax'), 'quantileExactWeightedArgMax': ('quantileExactWeighted', 'ArgMax'), 'histogramArgMax': ('histogram', 'ArgMax'), 'avgArgMax': ('avg', 'ArgMax'), 'uniqArgMax': ('uniq', 'ArgMax'), 'uniqUpToArgMax': ('uniqUpTo', 'ArgMax'), 'stddevSampArgMax': ('stddevSamp', 'ArgMax'), 'largestTriangleThreeBucketsArgMax': ('largestTriangleThreeBuckets', 'ArgMax'), 'medianArgMax': ('median', 'ArgMax'), 'deltaSumArgMax': ('deltaSum', 'ArgMax'), 'groupBitmapXorArgMax': ('groupBitmapXor', 'ArgMax'), 'quantileBFloat16ArgMax': ('quantileBFloat16', 'ArgMax'), 'simpleLinearRegressionArgMax': ('simpleLinearRegression', 'ArgMax'), 'quantileArgMax': ('quantile', 'ArgMax'), 'stochasticLinearRegressionArgMax': ('stochasticLinearRegression', 'ArgMax'), 'quantilesTimingArgMax': ('quantilesTiming', 'ArgMax'), 'contingencyArgMax': ('contingency', 'ArgMax'), 'covarSampArgMax': ('covarSamp', 'ArgMax'), 'deltaSumTimestampArgMax': ('deltaSumTimestamp', 'ArgMax'), 'uniqHLL12ArgMax': ('uniqHLL12', 'ArgMax'), 'maxIntersectionsArgMax': ('maxIntersections', 'ArgMax'), 'quantileTDigestWeightedArgMax': ('quantileTDigestWeighted', 'ArgMax'), 'groupArrayInsertAtArgMax': ('groupArrayInsertAt', 'ArgMax'), 'uniqExactArgMax': ('uniqExact', 'ArgMax'), 'last_valueArgMax': ('last_value', 'ArgMax'), 'quantilesTimingWeightedArgMax': ('quantilesTimingWeighted', 'ArgMax'), 'groupArraySampleArgMax': ('groupArraySample', 'ArgMax'), 'quantileBFloat16WeightedArgMax': ('quantileBFloat16Weighted', 'ArgMax'), 'quantilesTDigestWeightedArgMax': ('quantilesTDigestWeighted', 'ArgMax'), 'quantilesExactWeightedArgMax': ('quantilesExactWeighted', 'ArgMax'), 'rankCorrArgMax': ('rankCorr', 'ArgMax'), 'groupBitOrArgMax': ('groupBitOr', 'ArgMax'), 'groupArrayArgMax': ('groupArray', 'ArgMax'), 'sequenceMatchArgMax': ('sequenceMatch', 'ArgMax'), 'quantileTimingArgMax': ('quantileTiming', 'ArgMax'), 'anyLastArgMax': ('anyLast', 'ArgMax'), 'avgWeightedArgMax': ('avgWeighted', 'ArgMax'), 'groupArrayMovingAvgArgMax': ('groupArrayMovingAvg', 'ArgMax'), 'first_valueArgMax': ('first_value', 'ArgMax'), 'quantilesGKArgMax': ('quantilesGK', 'ArgMax'), 'argMinArgMax': ('argMin', 'ArgMax'), 'quantilesExactHighArgMax': ('quantilesExactHigh', 'ArgMax'), 'countArgMax': ('count', 'ArgMax'), 'varSampArgMax': ('varSamp', 'ArgMax'), 'quantileExactArgMax': ('quantileExact', 'ArgMax'), 'kolmogorovSmirnovTestArgMax': ('kolmogorovSmirnovTest', 'ArgMax'), 'groupBitmapAndArgMax': ('groupBitmapAnd', 'ArgMax'), 'sparkBarArgMax': ('sparkBar', 'ArgMax'), 'covarPopArgMax': ('covarPop', 'ArgMax'), 'groupArrayLastArgMax': ('groupArrayLast', 'ArgMax'), 'mannWhitneyUTestArgMax': ('mannWhitneyUTest', 'ArgMax'), 'studentTTestArgMax': ('studentTTest', 'ArgMax'), 'quantileTimingWeightedArgMax': ('quantileTimingWeighted', 'ArgMax'), 'anyArgMax': ('any', 'ArgMax'), 'sequenceCountArgMax': ('sequenceCount', 'ArgMax'), 'quantileGKArgMax': ('quantileGK', 'ArgMax'), 'maxIntersectionsPositionArgMax': ('maxIntersectionsPosition', 'ArgMax'), 'retention': ('retention', ''), 'quantilesExact': ('quantilesExact', ''), 'windowFunnel': ('windowFunnel', ''), 'sumWithOverflow': ('sumWithOverflow', ''), 'min': ('min', ''), 'kurtSamp': ('kurtSamp', ''), 'quantileDeterministic': ('quantileDeterministic', ''), 'quantileExactHigh': ('quantileExactHigh', ''), 'quantileExactLow': ('quantileExactLow', ''), 'argMax': ('argMax', ''), 'groupBitXor': ('groupBitXor', ''), 'quantilesTDigest': ('quantilesTDigest', ''), 'topKWeighted': ('topKWeighted', ''), 'quantilesBFloat16': ('quantilesBFloat16', ''), 'cramersVBiasCorrected': ('cramersVBiasCorrected', ''), 'exponentialMovingAverage': ('exponentialMovingAverage', ''), 'anyHeavy': ('anyHeavy', ''), 'topK': ('topK', ''), 'sumCount': ('sumCount', ''), 'sumKahan': ('sumKahan', ''), 'theilsU': ('theilsU', ''), 'entropy': ('entropy', ''), 'welchTTest': ('welchTTest', ''), 'varPop': ('varPop', ''), 'corr': ('corr', ''), 'quantileTDigest': ('quantileTDigest', ''), 'skewPop': ('skewPop', ''), 'groupBitmapOr': ('groupBitmapOr', ''), 'exponentialTimeDecayedAvg': ('exponentialTimeDecayedAvg', ''), 'boundingRatio': ('boundingRatio', ''), 'uniqCombined': ('uniqCombined', ''), 'groupArrayMovingSum': ('groupArrayMovingSum', ''), 'sum': ('sum', ''), 'stddevPop': ('stddevPop', ''), 'groupBitAnd': ('groupBitAnd', ''), 'quantileInterpolatedWeighted': ('quantileInterpolatedWeighted', ''), 'uniqTheta': ('uniqTheta', ''), 'sequenceNextNode': ('sequenceNextNode', ''), 'groupUniqArray': ('groupUniqArray', ''), 'max': ('max', ''), 'skewSamp': ('skewSamp', ''), 'quantilesBFloat16Weighted': ('quantilesBFloat16Weighted', ''), 'quantilesExactLow': ('quantilesExactLow', ''), 'quantilesDeterministic': ('quantilesDeterministic', ''), 'groupBitmap': ('groupBitmap', ''), 'cramersV': ('cramersV', ''), 'categoricalInformationValue': ('categoricalInformationValue', ''), 'meanZTest': ('meanZTest', ''), 'stochasticLogisticRegression': ('stochasticLogisticRegression', ''), 'quantilesInterpolatedWeighted': ('quantilesInterpolatedWeighted', ''), 'quantiles': ('quantiles', ''), 'uniqCombined64': ('uniqCombined64', ''), 'kurtPop': ('kurtPop', ''), 'intervalLengthSum': ('intervalLengthSum', ''), 'quantileExactWeighted': ('quantileExactWeighted', ''), 'histogram': ('histogram', ''), 'avg': ('avg', ''), 'uniq': ('uniq', ''), 'uniqUpTo': ('uniqUpTo', ''), 'stddevSamp': ('stddevSamp', ''), 'largestTriangleThreeBuckets': ('largestTriangleThreeBuckets', ''), 'median': ('median', ''), 'deltaSum': ('deltaSum', ''), 'groupBitmapXor': ('groupBitmapXor', ''), 'quantileBFloat16': ('quantileBFloat16', ''), 'simpleLinearRegression': ('simpleLinearRegression', ''), 'quantile': ('quantile', ''), 'stochasticLinearRegression': ('stochasticLinearRegression', ''), 'quantilesTiming': ('quantilesTiming', ''), 'contingency': ('contingency', ''), 'covarSamp': ('covarSamp', ''), 'deltaSumTimestamp': ('deltaSumTimestamp', ''), 'uniqHLL12': ('uniqHLL12', ''), 'maxIntersections': ('maxIntersections', ''), 'quantileTDigestWeighted': ('quantileTDigestWeighted', ''), 'groupArrayInsertAt': ('groupArrayInsertAt', ''), 'uniqExact': ('uniqExact', ''), 'last_value': ('last_value', ''), 'quantilesTimingWeighted': ('quantilesTimingWeighted', ''), 'groupArraySample': ('groupArraySample', ''), 'quantileBFloat16Weighted': ('quantileBFloat16Weighted', ''), 'quantilesTDigestWeighted': ('quantilesTDigestWeighted', ''), 'quantilesExactWeighted': ('quantilesExactWeighted', ''), 'rankCorr': ('rankCorr', ''), 'groupBitOr': ('groupBitOr', ''), 'groupArray': ('groupArray', ''), 'sequenceMatch': ('sequenceMatch', ''), 'quantileTiming': ('quantileTiming', ''), 'anyLast': ('anyLast', ''), 'avgWeighted': ('avgWeighted', ''), 'groupArrayMovingAvg': ('groupArrayMovingAvg', ''), 'first_value': ('first_value', ''), 'quantilesGK': ('quantilesGK', ''), 'argMin': ('argMin', ''), 'quantilesExactHigh': ('quantilesExactHigh', ''), 'count': ('count', ''), 'varSamp': ('varSamp', ''), 'quantileExact': ('quantileExact', ''), 'kolmogorovSmirnovTest': ('kolmogorovSmirnovTest', ''), 'groupBitmapAnd': ('groupBitmapAnd', ''), 'sparkBar': ('sparkBar', ''), 'covarPop': ('covarPop', ''), 'groupArrayLast': ('groupArrayLast', ''), 'mannWhitneyUTest': ('mannWhitneyUTest', ''), 'studentTTest': ('studentTTest', ''), 'quantileTimingWeighted': ('quantileTimingWeighted', ''), 'any': ('any', ''), 'sequenceCount': ('sequenceCount', ''), 'quantileGK': ('quantileGK', ''), 'maxIntersectionsPosition': ('maxIntersectionsPosition', '')}
FUNCTIONS_WITH_ALIASED_ARGS = {'TUPLE', 'STRUCT'}
FUNCTION_PARSERS = {'CAST': <function Parser.<lambda>>, 'CONVERT': <function Parser.<lambda>>, 'DECODE': <function Parser.<lambda>>, 'EXTRACT': <function Parser.<lambda>>, 'GAP_FILL': <function Parser.<lambda>>, 'JSON_OBJECT': <function Parser.<lambda>>, 'JSON_OBJECTAGG': <function Parser.<lambda>>, 'JSON_TABLE': <function Parser.<lambda>>, '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>>, 'XMLELEMENT': <function Parser.<lambda>>, 'ARRAYJOIN': <function ClickHouse.Parser.<lambda>>, 'QUANTILE': <function ClickHouse.Parser.<lambda>>, 'MEDIAN': <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>>}
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.ARRAY: 'ARRAY'>, <TokenType.ANY: 'ANY'>, <TokenType.INNER: 'INNER'>, <TokenType.OUTER: 'OUTER'>, <TokenType.ASOF: 'ASOF'>, <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, <TokenType.CROSS: 'CROSS'>, <TokenType.ANTI: 'ANTI'>, <TokenType.SEMI: 'SEMI'>}
TABLE_ALIAS_TOKENS = {<TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.TABLE: 'TABLE'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.NESTED: 'NESTED'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.FIRST: 'FIRST'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.YEAR: 'YEAR'>, <TokenType.SET: 'SET'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.POLYGON: 'POLYGON'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DECIMAL256: 'DECIMAL256'>, <TokenType.DATETIME2: 'DATETIME2'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.INT128: 'INT128'>, <TokenType.CASE: 'CASE'>, <TokenType.END: 'END'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.DECIMAL64: 'DECIMAL64'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.POINT: 'POINT'>, <TokenType.TIME: 'TIME'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.UINT: 'UINT'>, <TokenType.ASC: 'ASC'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.IPV6: 'IPV6'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.ATTACH: 'ATTACH'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.CACHE: 'CACHE'>, <TokenType.JSONB: 'JSONB'>, <TokenType.DETACH: 'DETACH'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.IPV4: 'IPV4'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.JSON: 'JSON'>, <TokenType.SINK: 'SINK'>, <TokenType.RING: 'RING'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.VAR: 'VAR'>, <TokenType.DATE32: 'DATE32'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.ROWS: 'ROWS'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.INET: 'INET'>, <TokenType.CUBE: 'CUBE'>, <TokenType.XML: 'XML'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.SOURCE: 'SOURCE'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.COPY: 'COPY'>, <TokenType.BINARY: 'BINARY'>, <TokenType.LINESTRING: 'LINESTRING'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.FILTER: 'FILTER'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.USE: 'USE'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.UINT256: 'UINT256'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.UINT128: 'UINT128'>, <TokenType.INT256: 'INT256'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.ROW: 'ROW'>, <TokenType.INT: 'INT'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.NULL: 'NULL'>, <TokenType.RENAME: 'RENAME'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.SUPER: 'SUPER'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.NAME: 'NAME'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.KILL: 'KILL'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.SOME: 'SOME'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.MAP: 'MAP'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.LOAD: 'LOAD'>, <TokenType.TAG: 'TAG'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.BIT: 'BIT'>, <TokenType.DIV: 'DIV'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.IS: 'IS'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.MODEL: 'MODEL'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.ALL: 'ALL'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.CHAR: 'CHAR'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.MONEY: 'MONEY'>, <TokenType.FALSE: 'FALSE'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.INDEX: 'INDEX'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.MULTILINESTRING: 'MULTILINESTRING'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.UUID: 'UUID'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.KEEP: 'KEEP'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.DESC: 'DESC'>, <TokenType.ENUM: 'ENUM'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.TOP: 'TOP'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.MULTIPOLYGON: 'MULTIPOLYGON'>, <TokenType.TEXT: 'TEXT'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.DECIMAL32: 'DECIMAL32'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.DATE: 'DATE'>, <TokenType.DECIMAL128: 'DECIMAL128'>, <TokenType.SHOW: 'SHOW'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.VIEW: 'VIEW'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.RANGE: 'RANGE'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.SMALLDATETIME: 'SMALLDATETIME'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.TRUE: 'TRUE'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.MERGE: 'MERGE'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, <TokenType.DELETE: 'DELETE'>, <TokenType.NEXT: 'NEXT'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.LIST: 'LIST'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.TIMETZ: 'TIMETZ'>}
ALIAS_TOKENS = {<TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.TABLE: 'TABLE'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.NESTED: 'NESTED'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.FIRST: 'FIRST'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.YEAR: 'YEAR'>, <TokenType.SET: 'SET'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.POLYGON: 'POLYGON'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DECIMAL256: 'DECIMAL256'>, <TokenType.DATETIME2: 'DATETIME2'>, <TokenType.LEFT: 'LEFT'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.INT128: 'INT128'>, <TokenType.CASE: 'CASE'>, <TokenType.END: 'END'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.DECIMAL64: 'DECIMAL64'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.POINT: 'POINT'>, <TokenType.TIME: 'TIME'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.UINT: 'UINT'>, <TokenType.ASC: 'ASC'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.FULL: 'FULL'>, <TokenType.IPV6: 'IPV6'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.ATTACH: 'ATTACH'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.FINAL: 'FINAL'>, <TokenType.CACHE: 'CACHE'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.JSONB: 'JSONB'>, <TokenType.DETACH: 'DETACH'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.IPV4: 'IPV4'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.JSON: 'JSON'>, <TokenType.SINK: 'SINK'>, <TokenType.RING: 'RING'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.VAR: 'VAR'>, <TokenType.DATE32: 'DATE32'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.ANTI: 'ANTI'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.SEMI: 'SEMI'>, <TokenType.VECTOR: 'VECTOR'>, <TokenType.ROWS: 'ROWS'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.INET: 'INET'>, <TokenType.CUBE: 'CUBE'>, <TokenType.XML: 'XML'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.SOURCE: 'SOURCE'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.COPY: 'COPY'>, <TokenType.BINARY: 'BINARY'>, <TokenType.LINESTRING: 'LINESTRING'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.FILTER: 'FILTER'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.USE: 'USE'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.UINT256: 'UINT256'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.UINT128: 'UINT128'>, <TokenType.INT256: 'INT256'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.ROW: 'ROW'>, <TokenType.INT: 'INT'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.NULL: 'NULL'>, <TokenType.RENAME: 'RENAME'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.SUPER: 'SUPER'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.NAME: 'NAME'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.KILL: 'KILL'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.APPLY: 'APPLY'>, <TokenType.SOME: 'SOME'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.MAP: 'MAP'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.LOAD: 'LOAD'>, <TokenType.TAG: 'TAG'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.BIT: 'BIT'>, <TokenType.DIV: 'DIV'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.IS: 'IS'>, <TokenType.ASOF: 'ASOF'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.MODEL: 'MODEL'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.ALL: 'ALL'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.CHAR: 'CHAR'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.MONEY: 'MONEY'>, <TokenType.FALSE: 'FALSE'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.INDEX: 'INDEX'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.MULTILINESTRING: 'MULTILINESTRING'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.UUID: 'UUID'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.KEEP: 'KEEP'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.DESC: 'DESC'>, <TokenType.ENUM: 'ENUM'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.TOP: 'TOP'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.MULTIPOLYGON: 'MULTIPOLYGON'>, <TokenType.TEXT: 'TEXT'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.DECIMAL32: 'DECIMAL32'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.DATE: 'DATE'>, <TokenType.DECIMAL128: 'DECIMAL128'>, <TokenType.SHOW: 'SHOW'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.VIEW: 'VIEW'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.RANGE: 'RANGE'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.SMALLDATETIME: 'SMALLDATETIME'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.TRUE: 'TRUE'>, <TokenType.ANY: 'ANY'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.MERGE: 'MERGE'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.DELETE: 'DELETE'>, <TokenType.NEXT: 'NEXT'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.LIST: 'LIST'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.TIMETZ: 'TIMETZ'>}
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>>, 'WATERMARK': <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 = {'PRIMARY KEY', 'LIKE', 'CHECK', 'EXCLUDE', 'UNIQUE', 'FOREIGN KEY', 'WATERMARK', 'PERIOD', 'INDEX'}
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
WRAPPED_TRANSFORM_COLUMN_CONSTRAINT
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):
 865    class Generator(generator.Generator):
 866        QUERY_HINTS = False
 867        STRUCT_DELIMITER = ("(", ")")
 868        NVL2_SUPPORTED = False
 869        TABLESAMPLE_REQUIRES_PARENS = False
 870        TABLESAMPLE_SIZE_IS_ROWS = False
 871        TABLESAMPLE_KEYWORDS = "SAMPLE"
 872        LAST_DAY_SUPPORTS_DATE_PART = False
 873        CAN_IMPLEMENT_ARRAY_ANY = True
 874        SUPPORTS_TO_NUMBER = False
 875        JOIN_HINTS = False
 876        TABLE_HINTS = False
 877        GROUPINGS_SEP = ""
 878        SET_OP_MODIFIERS = False
 879        SUPPORTS_TABLE_ALIAS_COLUMNS = False
 880        VALUES_AS_TABLE = False
 881        ARRAY_SIZE_NAME = "LENGTH"
 882
 883        STRING_TYPE_MAPPING = {
 884            exp.DataType.Type.CHAR: "String",
 885            exp.DataType.Type.LONGBLOB: "String",
 886            exp.DataType.Type.LONGTEXT: "String",
 887            exp.DataType.Type.MEDIUMBLOB: "String",
 888            exp.DataType.Type.MEDIUMTEXT: "String",
 889            exp.DataType.Type.TINYBLOB: "String",
 890            exp.DataType.Type.TINYTEXT: "String",
 891            exp.DataType.Type.TEXT: "String",
 892            exp.DataType.Type.VARBINARY: "String",
 893            exp.DataType.Type.VARCHAR: "String",
 894        }
 895
 896        SUPPORTED_JSON_PATH_PARTS = {
 897            exp.JSONPathKey,
 898            exp.JSONPathRoot,
 899            exp.JSONPathSubscript,
 900        }
 901
 902        TYPE_MAPPING = {
 903            **generator.Generator.TYPE_MAPPING,
 904            **STRING_TYPE_MAPPING,
 905            exp.DataType.Type.ARRAY: "Array",
 906            exp.DataType.Type.BOOLEAN: "Bool",
 907            exp.DataType.Type.BIGINT: "Int64",
 908            exp.DataType.Type.DATE32: "Date32",
 909            exp.DataType.Type.DATETIME: "DateTime",
 910            exp.DataType.Type.DATETIME2: "DateTime",
 911            exp.DataType.Type.SMALLDATETIME: "DateTime",
 912            exp.DataType.Type.DATETIME64: "DateTime64",
 913            exp.DataType.Type.DECIMAL: "Decimal",
 914            exp.DataType.Type.DECIMAL32: "Decimal32",
 915            exp.DataType.Type.DECIMAL64: "Decimal64",
 916            exp.DataType.Type.DECIMAL128: "Decimal128",
 917            exp.DataType.Type.DECIMAL256: "Decimal256",
 918            exp.DataType.Type.TIMESTAMP: "DateTime",
 919            exp.DataType.Type.TIMESTAMPTZ: "DateTime",
 920            exp.DataType.Type.DOUBLE: "Float64",
 921            exp.DataType.Type.ENUM: "Enum",
 922            exp.DataType.Type.ENUM8: "Enum8",
 923            exp.DataType.Type.ENUM16: "Enum16",
 924            exp.DataType.Type.FIXEDSTRING: "FixedString",
 925            exp.DataType.Type.FLOAT: "Float32",
 926            exp.DataType.Type.INT: "Int32",
 927            exp.DataType.Type.MEDIUMINT: "Int32",
 928            exp.DataType.Type.INT128: "Int128",
 929            exp.DataType.Type.INT256: "Int256",
 930            exp.DataType.Type.LOWCARDINALITY: "LowCardinality",
 931            exp.DataType.Type.MAP: "Map",
 932            exp.DataType.Type.NESTED: "Nested",
 933            exp.DataType.Type.SMALLINT: "Int16",
 934            exp.DataType.Type.STRUCT: "Tuple",
 935            exp.DataType.Type.TINYINT: "Int8",
 936            exp.DataType.Type.UBIGINT: "UInt64",
 937            exp.DataType.Type.UINT: "UInt32",
 938            exp.DataType.Type.UINT128: "UInt128",
 939            exp.DataType.Type.UINT256: "UInt256",
 940            exp.DataType.Type.USMALLINT: "UInt16",
 941            exp.DataType.Type.UTINYINT: "UInt8",
 942            exp.DataType.Type.IPV4: "IPv4",
 943            exp.DataType.Type.IPV6: "IPv6",
 944            exp.DataType.Type.POINT: "Point",
 945            exp.DataType.Type.RING: "Ring",
 946            exp.DataType.Type.LINESTRING: "LineString",
 947            exp.DataType.Type.MULTILINESTRING: "MultiLineString",
 948            exp.DataType.Type.POLYGON: "Polygon",
 949            exp.DataType.Type.MULTIPOLYGON: "MultiPolygon",
 950            exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction",
 951            exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction",
 952        }
 953
 954        TRANSFORMS = {
 955            **generator.Generator.TRANSFORMS,
 956            exp.AnyValue: rename_func("any"),
 957            exp.ApproxDistinct: rename_func("uniq"),
 958            exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this),
 959            exp.ArraySum: rename_func("arraySum"),
 960            exp.ArgMax: arg_max_or_min_no_count("argMax"),
 961            exp.ArgMin: arg_max_or_min_no_count("argMin"),
 962            exp.Array: inline_array_sql,
 963            exp.CastToStrType: rename_func("CAST"),
 964            exp.CountIf: rename_func("countIf"),
 965            exp.CompressColumnConstraint: lambda self,
 966            e: f"CODEC({self.expressions(e, key='this', flat=True)})",
 967            exp.ComputedColumnConstraint: lambda self,
 968            e: f"{'MATERIALIZED' if e.args.get('persisted') else 'ALIAS'} {self.sql(e, 'this')}",
 969            exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"),
 970            exp.DateAdd: _datetime_delta_sql("DATE_ADD"),
 971            exp.DateDiff: _datetime_delta_sql("DATE_DIFF"),
 972            exp.DateStrToDate: rename_func("toDate"),
 973            exp.DateSub: _datetime_delta_sql("DATE_SUB"),
 974            exp.Explode: rename_func("arrayJoin"),
 975            exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL",
 976            exp.IsNan: rename_func("isNaN"),
 977            exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False),
 978            exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False),
 979            exp.JSONPathKey: json_path_key_only_name,
 980            exp.JSONPathRoot: lambda *_: "",
 981            exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)),
 982            exp.Median: rename_func("median"),
 983            exp.Nullif: rename_func("nullIf"),
 984            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
 985            exp.Pivot: no_pivot_sql,
 986            exp.Quantile: _quantile_sql,
 987            exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression),
 988            exp.Rand: rename_func("randCanonical"),
 989            exp.StartsWith: rename_func("startsWith"),
 990            exp.StrPosition: lambda self, e: self.func(
 991                "position", e.this, e.args.get("substr"), e.args.get("position")
 992            ),
 993            exp.TimeToStr: lambda self, e: self.func(
 994                "formatDateTime", e.this, self.format_time(e), e.args.get("zone")
 995            ),
 996            exp.TimeStrToTime: _timestrtotime_sql,
 997            exp.TimestampAdd: _datetime_delta_sql("TIMESTAMP_ADD"),
 998            exp.TimestampSub: _datetime_delta_sql("TIMESTAMP_SUB"),
 999            exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)),
1000            exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions),
1001            exp.MD5Digest: rename_func("MD5"),
1002            exp.MD5: lambda self, e: self.func("LOWER", self.func("HEX", self.func("MD5", e.this))),
1003            exp.SHA: rename_func("SHA1"),
1004            exp.SHA2: sha256_sql,
1005            exp.UnixToTime: _unix_to_time_sql,
1006            exp.TimestampTrunc: timestamptrunc_sql(zone=True),
1007            exp.Trim: trim_sql,
1008            exp.Variance: rename_func("varSamp"),
1009            exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
1010            exp.Stddev: rename_func("stddevSamp"),
1011            exp.Chr: rename_func("CHAR"),
1012            exp.Lag: lambda self, e: self.func(
1013                "lagInFrame", e.this, e.args.get("offset"), e.args.get("default")
1014            ),
1015            exp.Lead: lambda self, e: self.func(
1016                "leadInFrame", e.this, e.args.get("offset"), e.args.get("default")
1017            ),
1018            exp.Levenshtein: unsupported_args("ins_cost", "del_cost", "sub_cost", "max_dist")(
1019                rename_func("editDistance")
1020            ),
1021        }
1022
1023        PROPERTIES_LOCATION = {
1024            **generator.Generator.PROPERTIES_LOCATION,
1025            exp.OnCluster: exp.Properties.Location.POST_NAME,
1026            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
1027            exp.ToTableProperty: exp.Properties.Location.POST_NAME,
1028            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
1029        }
1030
1031        # There's no list in docs, but it can be found in Clickhouse code
1032        # see `ClickHouse/src/Parsers/ParserCreate*.cpp`
1033        ON_CLUSTER_TARGETS = {
1034            "SCHEMA",  # Transpiled CREATE SCHEMA may have OnCluster property set
1035            "DATABASE",
1036            "TABLE",
1037            "VIEW",
1038            "DICTIONARY",
1039            "INDEX",
1040            "FUNCTION",
1041            "NAMED COLLECTION",
1042        }
1043
1044        # https://clickhouse.com/docs/en/sql-reference/data-types/nullable
1045        NON_NULLABLE_TYPES = {
1046            exp.DataType.Type.ARRAY,
1047            exp.DataType.Type.MAP,
1048            exp.DataType.Type.STRUCT,
1049            exp.DataType.Type.POINT,
1050            exp.DataType.Type.RING,
1051            exp.DataType.Type.LINESTRING,
1052            exp.DataType.Type.MULTILINESTRING,
1053            exp.DataType.Type.POLYGON,
1054            exp.DataType.Type.MULTIPOLYGON,
1055        }
1056
1057        def strtodate_sql(self, expression: exp.StrToDate) -> str:
1058            strtodate_sql = self.function_fallback_sql(expression)
1059
1060            if not isinstance(expression.parent, exp.Cast):
1061                # StrToDate returns DATEs in other dialects (eg. postgres), so
1062                # this branch aims to improve the transpilation to clickhouse
1063                return f"CAST({strtodate_sql} AS DATE)"
1064
1065            return strtodate_sql
1066
1067        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
1068            this = expression.this
1069
1070            if isinstance(this, exp.StrToDate) and expression.to == exp.DataType.build("datetime"):
1071                return self.sql(this)
1072
1073            return super().cast_sql(expression, safe_prefix=safe_prefix)
1074
1075        def trycast_sql(self, expression: exp.TryCast) -> str:
1076            dtype = expression.to
1077            if not dtype.is_type(*self.NON_NULLABLE_TYPES, check_nullable=True):
1078                # Casting x into Nullable(T) appears to behave similarly to TRY_CAST(x AS T)
1079                dtype.set("nullable", True)
1080
1081            return super().cast_sql(expression)
1082
1083        def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str:
1084            this = self.json_path_part(expression.this)
1085            return str(int(this) + 1) if is_int(this) else this
1086
1087        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
1088            return f"AS {self.sql(expression, 'this')}"
1089
1090        def _any_to_has(
1091            self,
1092            expression: exp.EQ | exp.NEQ,
1093            default: t.Callable[[t.Any], str],
1094            prefix: str = "",
1095        ) -> str:
1096            if isinstance(expression.left, exp.Any):
1097                arr = expression.left
1098                this = expression.right
1099            elif isinstance(expression.right, exp.Any):
1100                arr = expression.right
1101                this = expression.left
1102            else:
1103                return default(expression)
1104
1105            return prefix + self.func("has", arr.this.unnest(), this)
1106
1107        def eq_sql(self, expression: exp.EQ) -> str:
1108            return self._any_to_has(expression, super().eq_sql)
1109
1110        def neq_sql(self, expression: exp.NEQ) -> str:
1111            return self._any_to_has(expression, super().neq_sql, "NOT ")
1112
1113        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
1114            # Manually add a flag to make the search case-insensitive
1115            regex = self.func("CONCAT", "'(?i)'", expression.expression)
1116            return self.func("match", expression.this, regex)
1117
1118        def datatype_sql(self, expression: exp.DataType) -> str:
1119            # String is the standard ClickHouse type, every other variant is just an alias.
1120            # Additionally, any supplied length parameter will be ignored.
1121            #
1122            # https://clickhouse.com/docs/en/sql-reference/data-types/string
1123            if expression.this in self.STRING_TYPE_MAPPING:
1124                dtype = "String"
1125            else:
1126                dtype = super().datatype_sql(expression)
1127
1128            # This section changes the type to `Nullable(...)` if the following conditions hold:
1129            # - It's marked as nullable - this ensures we won't wrap ClickHouse types with `Nullable`
1130            #   and change their semantics
1131            # - It's not the key type of a `Map`. This is because ClickHouse enforces the following
1132            #   constraint: "Type of Map key must be a type, that can be represented by integer or
1133            #   String or FixedString (possibly LowCardinality) or UUID or IPv6"
1134            # - It's not a composite type, e.g. `Nullable(Array(...))` is not a valid type
1135            parent = expression.parent
1136            nullable = expression.args.get("nullable")
1137            if nullable is True or (
1138                nullable is None
1139                and not (
1140                    isinstance(parent, exp.DataType)
1141                    and parent.is_type(exp.DataType.Type.MAP, check_nullable=True)
1142                    and expression.index in (None, 0)
1143                )
1144                and not expression.is_type(*self.NON_NULLABLE_TYPES, check_nullable=True)
1145            ):
1146                dtype = f"Nullable({dtype})"
1147
1148            return dtype
1149
1150        def cte_sql(self, expression: exp.CTE) -> str:
1151            if expression.args.get("scalar"):
1152                this = self.sql(expression, "this")
1153                alias = self.sql(expression, "alias")
1154                return f"{this} AS {alias}"
1155
1156            return super().cte_sql(expression)
1157
1158        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
1159            return super().after_limit_modifiers(expression) + [
1160                (
1161                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
1162                    if expression.args.get("settings")
1163                    else ""
1164                ),
1165                (
1166                    self.seg("FORMAT ") + self.sql(expression, "format")
1167                    if expression.args.get("format")
1168                    else ""
1169                ),
1170            ]
1171
1172        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
1173            params = self.expressions(expression, key="params", flat=True)
1174            return self.func(expression.name, *expression.expressions) + f"({params})"
1175
1176        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
1177            return self.func(expression.name, *expression.expressions)
1178
1179        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
1180            return self.anonymousaggfunc_sql(expression)
1181
1182        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
1183            return self.parameterizedagg_sql(expression)
1184
1185        def placeholder_sql(self, expression: exp.Placeholder) -> str:
1186            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
1187
1188        def oncluster_sql(self, expression: exp.OnCluster) -> str:
1189            return f"ON CLUSTER {self.sql(expression, 'this')}"
1190
1191        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
1192            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
1193                exp.Properties.Location.POST_NAME
1194            ):
1195                this_name = self.sql(
1196                    expression.this if isinstance(expression.this, exp.Schema) else expression,
1197                    "this",
1198                )
1199                this_properties = " ".join(
1200                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
1201                )
1202                this_schema = self.schema_columns_sql(expression.this)
1203                this_schema = f"{self.sep()}{this_schema}" if this_schema else ""
1204
1205                return f"{this_name}{self.sep()}{this_properties}{this_schema}"
1206
1207            return super().createable_sql(expression, locations)
1208
1209        def create_sql(self, expression: exp.Create) -> str:
1210            # The comment property comes last in CTAS statements, i.e. after the query
1211            query = expression.expression
1212            if isinstance(query, exp.Query):
1213                comment_prop = expression.find(exp.SchemaCommentProperty)
1214                if comment_prop:
1215                    comment_prop.pop()
1216                    query.replace(exp.paren(query))
1217            else:
1218                comment_prop = None
1219
1220            create_sql = super().create_sql(expression)
1221
1222            comment_sql = self.sql(comment_prop)
1223            comment_sql = f" {comment_sql}" if comment_sql else ""
1224
1225            return f"{create_sql}{comment_sql}"
1226
1227        def prewhere_sql(self, expression: exp.PreWhere) -> str:
1228            this = self.indent(self.sql(expression, "this"))
1229            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
1230
1231        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
1232            this = self.sql(expression, "this")
1233            this = f" {this}" if this else ""
1234            expr = self.sql(expression, "expression")
1235            expr = f" {expr}" if expr else ""
1236            index_type = self.sql(expression, "index_type")
1237            index_type = f" TYPE {index_type}" if index_type else ""
1238            granularity = self.sql(expression, "granularity")
1239            granularity = f" GRANULARITY {granularity}" if granularity else ""
1240
1241            return f"INDEX{this}{expr}{index_type}{granularity}"
1242
1243        def partition_sql(self, expression: exp.Partition) -> str:
1244            return f"PARTITION {self.expressions(expression, flat=True)}"
1245
1246        def partitionid_sql(self, expression: exp.PartitionId) -> str:
1247            return f"ID {self.sql(expression.this)}"
1248
1249        def replacepartition_sql(self, expression: exp.ReplacePartition) -> str:
1250            return (
1251                f"REPLACE {self.sql(expression.expression)} FROM {self.sql(expression, 'source')}"
1252            )
1253
1254        def projectiondef_sql(self, expression: exp.ProjectionDef) -> str:
1255            return f"PROJECTION {self.sql(expression.this)} {self.wrap(expression.expression)}"
1256
1257        def is_sql(self, expression: exp.Is) -> str:
1258            is_sql = super().is_sql(expression)
1259
1260            if isinstance(expression.parent, exp.Not):
1261                # value IS NOT NULL -> NOT (value IS NULL)
1262                is_sql = self.wrap(is_sql)
1263
1264            return is_sql

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
ARRAY_SIZE_NAME = 'LENGTH'
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.DATETIME2: 'DATETIME2'>: 'DateTime', <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.SMALLDATETIME: 'SMALLDATETIME'>: 'DateTime', <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.DECIMAL: 'DECIMAL'>: 'Decimal', <Type.DECIMAL32: 'DECIMAL32'>: 'Decimal32', <Type.DECIMAL64: 'DECIMAL64'>: 'Decimal64', <Type.DECIMAL128: 'DECIMAL128'>: 'Decimal128', <Type.DECIMAL256: 'DECIMAL256'>: 'Decimal256', <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.POINT: 'POINT'>: 'Point', <Type.RING: 'RING'>: 'Ring', <Type.LINESTRING: 'LINESTRING'>: 'LineString', <Type.MULTILINESTRING: 'MULTILINESTRING'>: 'MultiLineString', <Type.POLYGON: 'POLYGON'>: 'Polygon', <Type.MULTIPOLYGON: 'MULTIPOLYGON'>: 'MultiPolygon', <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.Int64'>: <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.Tags'>: <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.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.Median'>: <function rename_func.<locals>.<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>>, <class 'sqlglot.expressions.Levenshtein'>: <function rename_func.<locals>.<lambda>>}
PROPERTIES_LOCATION = {<class 'sqlglot.expressions.AllowedValuesProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.AlgorithmProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.AutoIncrementProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.AutoRefreshProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.BackupProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.BlockCompressionProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.CharacterSetProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ChecksumProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.CollateProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.CopyGrantsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Cluster'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ClusteredByProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.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.EncodeProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <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.IncludeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <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.Tags'>: <Location.POST_WITH: 'POST_WITH'>, <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', 'FUNCTION', 'DICTIONARY', 'DATABASE', 'SCHEMA', 'VIEW', 'NAMED COLLECTION', 'INDEX'}
NON_NULLABLE_TYPES = {<Type.MULTILINESTRING: 'MULTILINESTRING'>, <Type.ARRAY: 'ARRAY'>, <Type.LINESTRING: 'LINESTRING'>, <Type.MAP: 'MAP'>, <Type.STRUCT: 'STRUCT'>, <Type.MULTIPOLYGON: 'MULTIPOLYGON'>, <Type.POINT: 'POINT'>, <Type.POLYGON: 'POLYGON'>, <Type.RING: 'RING'>}
def strtodate_sql(self, expression: sqlglot.expressions.StrToDate) -> str:
1057        def strtodate_sql(self, expression: exp.StrToDate) -> str:
1058            strtodate_sql = self.function_fallback_sql(expression)
1059
1060            if not isinstance(expression.parent, exp.Cast):
1061                # StrToDate returns DATEs in other dialects (eg. postgres), so
1062                # this branch aims to improve the transpilation to clickhouse
1063                return f"CAST({strtodate_sql} AS DATE)"
1064
1065            return strtodate_sql
def cast_sql( self, expression: sqlglot.expressions.Cast, safe_prefix: Optional[str] = None) -> str:
1067        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
1068            this = expression.this
1069
1070            if isinstance(this, exp.StrToDate) and expression.to == exp.DataType.build("datetime"):
1071                return self.sql(this)
1072
1073            return super().cast_sql(expression, safe_prefix=safe_prefix)
def trycast_sql(self, expression: sqlglot.expressions.TryCast) -> str:
1075        def trycast_sql(self, expression: exp.TryCast) -> str:
1076            dtype = expression.to
1077            if not dtype.is_type(*self.NON_NULLABLE_TYPES, check_nullable=True):
1078                # Casting x into Nullable(T) appears to behave similarly to TRY_CAST(x AS T)
1079                dtype.set("nullable", True)
1080
1081            return super().cast_sql(expression)
def likeproperty_sql(self, expression: sqlglot.expressions.LikeProperty) -> str:
1087        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
1088            return f"AS {self.sql(expression, 'this')}"
def eq_sql(self, expression: sqlglot.expressions.EQ) -> str:
1107        def eq_sql(self, expression: exp.EQ) -> str:
1108            return self._any_to_has(expression, super().eq_sql)
def neq_sql(self, expression: sqlglot.expressions.NEQ) -> str:
1110        def neq_sql(self, expression: exp.NEQ) -> str:
1111            return self._any_to_has(expression, super().neq_sql, "NOT ")
def regexpilike_sql(self, expression: sqlglot.expressions.RegexpILike) -> str:
1113        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
1114            # Manually add a flag to make the search case-insensitive
1115            regex = self.func("CONCAT", "'(?i)'", expression.expression)
1116            return self.func("match", expression.this, regex)
def datatype_sql(self, expression: sqlglot.expressions.DataType) -> str:
1118        def datatype_sql(self, expression: exp.DataType) -> str:
1119            # String is the standard ClickHouse type, every other variant is just an alias.
1120            # Additionally, any supplied length parameter will be ignored.
1121            #
1122            # https://clickhouse.com/docs/en/sql-reference/data-types/string
1123            if expression.this in self.STRING_TYPE_MAPPING:
1124                dtype = "String"
1125            else:
1126                dtype = super().datatype_sql(expression)
1127
1128            # This section changes the type to `Nullable(...)` if the following conditions hold:
1129            # - It's marked as nullable - this ensures we won't wrap ClickHouse types with `Nullable`
1130            #   and change their semantics
1131            # - It's not the key type of a `Map`. This is because ClickHouse enforces the following
1132            #   constraint: "Type of Map key must be a type, that can be represented by integer or
1133            #   String or FixedString (possibly LowCardinality) or UUID or IPv6"
1134            # - It's not a composite type, e.g. `Nullable(Array(...))` is not a valid type
1135            parent = expression.parent
1136            nullable = expression.args.get("nullable")
1137            if nullable is True or (
1138                nullable is None
1139                and not (
1140                    isinstance(parent, exp.DataType)
1141                    and parent.is_type(exp.DataType.Type.MAP, check_nullable=True)
1142                    and expression.index in (None, 0)
1143                )
1144                and not expression.is_type(*self.NON_NULLABLE_TYPES, check_nullable=True)
1145            ):
1146                dtype = f"Nullable({dtype})"
1147
1148            return dtype
def cte_sql(self, expression: sqlglot.expressions.CTE) -> str:
1150        def cte_sql(self, expression: exp.CTE) -> str:
1151            if expression.args.get("scalar"):
1152                this = self.sql(expression, "this")
1153                alias = self.sql(expression, "alias")
1154                return f"{this} AS {alias}"
1155
1156            return super().cte_sql(expression)
def after_limit_modifiers(self, expression: sqlglot.expressions.Expression) -> List[str]:
1158        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
1159            return super().after_limit_modifiers(expression) + [
1160                (
1161                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
1162                    if expression.args.get("settings")
1163                    else ""
1164                ),
1165                (
1166                    self.seg("FORMAT ") + self.sql(expression, "format")
1167                    if expression.args.get("format")
1168                    else ""
1169                ),
1170            ]
def parameterizedagg_sql(self, expression: sqlglot.expressions.ParameterizedAgg) -> str:
1172        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
1173            params = self.expressions(expression, key="params", flat=True)
1174            return self.func(expression.name, *expression.expressions) + f"({params})"
def anonymousaggfunc_sql(self, expression: sqlglot.expressions.AnonymousAggFunc) -> str:
1176        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
1177            return self.func(expression.name, *expression.expressions)
def combinedaggfunc_sql(self, expression: sqlglot.expressions.CombinedAggFunc) -> str:
1179        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
1180            return self.anonymousaggfunc_sql(expression)
def combinedparameterizedagg_sql(self, expression: sqlglot.expressions.CombinedParameterizedAgg) -> str:
1182        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
1183            return self.parameterizedagg_sql(expression)
def placeholder_sql(self, expression: sqlglot.expressions.Placeholder) -> str:
1185        def placeholder_sql(self, expression: exp.Placeholder) -> str:
1186            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
def oncluster_sql(self, expression: sqlglot.expressions.OnCluster) -> str:
1188        def oncluster_sql(self, expression: exp.OnCluster) -> str:
1189            return f"ON CLUSTER {self.sql(expression, 'this')}"
def createable_sql( self, expression: sqlglot.expressions.Create, locations: DefaultDict) -> str:
1191        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
1192            if expression.kind in self.ON_CLUSTER_TARGETS and locations.get(
1193                exp.Properties.Location.POST_NAME
1194            ):
1195                this_name = self.sql(
1196                    expression.this if isinstance(expression.this, exp.Schema) else expression,
1197                    "this",
1198                )
1199                this_properties = " ".join(
1200                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
1201                )
1202                this_schema = self.schema_columns_sql(expression.this)
1203                this_schema = f"{self.sep()}{this_schema}" if this_schema else ""
1204
1205                return f"{this_name}{self.sep()}{this_properties}{this_schema}"
1206
1207            return super().createable_sql(expression, locations)
def create_sql(self, expression: sqlglot.expressions.Create) -> str:
1209        def create_sql(self, expression: exp.Create) -> str:
1210            # The comment property comes last in CTAS statements, i.e. after the query
1211            query = expression.expression
1212            if isinstance(query, exp.Query):
1213                comment_prop = expression.find(exp.SchemaCommentProperty)
1214                if comment_prop:
1215                    comment_prop.pop()
1216                    query.replace(exp.paren(query))
1217            else:
1218                comment_prop = None
1219
1220            create_sql = super().create_sql(expression)
1221
1222            comment_sql = self.sql(comment_prop)
1223            comment_sql = f" {comment_sql}" if comment_sql else ""
1224
1225            return f"{create_sql}{comment_sql}"
def prewhere_sql(self, expression: sqlglot.expressions.PreWhere) -> str:
1227        def prewhere_sql(self, expression: exp.PreWhere) -> str:
1228            this = self.indent(self.sql(expression, "this"))
1229            return f"{self.seg('PREWHERE')}{self.sep()}{this}"
def indexcolumnconstraint_sql(self, expression: sqlglot.expressions.IndexColumnConstraint) -> str:
1231        def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
1232            this = self.sql(expression, "this")
1233            this = f" {this}" if this else ""
1234            expr = self.sql(expression, "expression")
1235            expr = f" {expr}" if expr else ""
1236            index_type = self.sql(expression, "index_type")
1237            index_type = f" TYPE {index_type}" if index_type else ""
1238            granularity = self.sql(expression, "granularity")
1239            granularity = f" GRANULARITY {granularity}" if granularity else ""
1240
1241            return f"INDEX{this}{expr}{index_type}{granularity}"
def partition_sql(self, expression: sqlglot.expressions.Partition) -> str:
1243        def partition_sql(self, expression: exp.Partition) -> str:
1244            return f"PARTITION {self.expressions(expression, flat=True)}"
def partitionid_sql(self, expression: sqlglot.expressions.PartitionId) -> str:
1246        def partitionid_sql(self, expression: exp.PartitionId) -> str:
1247            return f"ID {self.sql(expression.this)}"
def replacepartition_sql(self, expression: sqlglot.expressions.ReplacePartition) -> str:
1249        def replacepartition_sql(self, expression: exp.ReplacePartition) -> str:
1250            return (
1251                f"REPLACE {self.sql(expression.expression)} FROM {self.sql(expression, 'source')}"
1252            )
def projectiondef_sql(self, expression: sqlglot.expressions.ProjectionDef) -> str:
1254        def projectiondef_sql(self, expression: exp.ProjectionDef) -> str:
1255            return f"PROJECTION {self.sql(expression.this)} {self.wrap(expression.expression)}"
def is_sql(self, expression: sqlglot.expressions.Is) -> str:
1257        def is_sql(self, expression: exp.Is) -> str:
1258            is_sql = super().is_sql(expression)
1259
1260            if isinstance(expression.parent, exp.Not):
1261                # value IS NOT NULL -> NOT (value IS NULL)
1262                is_sql = self.wrap(is_sql)
1263
1264            return is_sql
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
SUPPORTS_MEDIAN
SUPPORTS_UNIX_SECONDS
PARSE_JSON_NAME
ARRAY_SIZE_DIM_REQUIRED
TIME_PART_SINGULARS
TOKEN_MAPPING
PARAMETER_TOKEN
NAMED_PLACEHOLDER_TOKEN
EXPRESSION_PRECEDES_PROPERTIES_CREATABLES
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
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
whens_sql
merge_sql
tochar_sql
tonumber_sql
dictproperty_sql
dictrange_sql
dictsubproperty_sql
duplicatekeyproperty_sql
uniquekeyproperty_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
tsordstodatetime_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
string_sql
median_sql
overflowtruncatebehavior_sql
unixseconds_sql
arraysize_sql
attach_sql
detach_sql
attachoption_sql
featuresattime_sql
watermarkcolumnconstraint_sql
encodeproperty_sql
includeproperty_sql
xmlelement_sql
partitionbyrangeproperty_sql
partitionbyrangepropertydynamic_sql