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

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):
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        }
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):
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
280        AGG_FUNCTIONS = {
281            "count",
282            "min",
283            "max",
284            "sum",
285            "avg",
286            "any",
287            "stddevPop",
288            "stddevSamp",
289            "varPop",
290            "varSamp",
291            "corr",
292            "covarPop",
293            "covarSamp",
294            "entropy",
295            "exponentialMovingAverage",
296            "intervalLengthSum",
297            "kolmogorovSmirnovTest",
298            "mannWhitneyUTest",
299            "median",
300            "rankCorr",
301            "sumKahan",
302            "studentTTest",
303            "welchTTest",
304            "anyHeavy",
305            "anyLast",
306            "boundingRatio",
307            "first_value",
308            "last_value",
309            "argMin",
310            "argMax",
311            "avgWeighted",
312            "topK",
313            "topKWeighted",
314            "deltaSum",
315            "deltaSumTimestamp",
316            "groupArray",
317            "groupArrayLast",
318            "groupUniqArray",
319            "groupArrayInsertAt",
320            "groupArrayMovingAvg",
321            "groupArrayMovingSum",
322            "groupArraySample",
323            "groupBitAnd",
324            "groupBitOr",
325            "groupBitXor",
326            "groupBitmap",
327            "groupBitmapAnd",
328            "groupBitmapOr",
329            "groupBitmapXor",
330            "sumWithOverflow",
331            "sumMap",
332            "minMap",
333            "maxMap",
334            "skewSamp",
335            "skewPop",
336            "kurtSamp",
337            "kurtPop",
338            "uniq",
339            "uniqExact",
340            "uniqCombined",
341            "uniqCombined64",
342            "uniqHLL12",
343            "uniqTheta",
344            "quantile",
345            "quantiles",
346            "quantileExact",
347            "quantilesExact",
348            "quantileExactLow",
349            "quantilesExactLow",
350            "quantileExactHigh",
351            "quantilesExactHigh",
352            "quantileExactWeighted",
353            "quantilesExactWeighted",
354            "quantileTiming",
355            "quantilesTiming",
356            "quantileTimingWeighted",
357            "quantilesTimingWeighted",
358            "quantileDeterministic",
359            "quantilesDeterministic",
360            "quantileTDigest",
361            "quantilesTDigest",
362            "quantileTDigestWeighted",
363            "quantilesTDigestWeighted",
364            "quantileBFloat16",
365            "quantilesBFloat16",
366            "quantileBFloat16Weighted",
367            "quantilesBFloat16Weighted",
368            "simpleLinearRegression",
369            "stochasticLinearRegression",
370            "stochasticLogisticRegression",
371            "categoricalInformationValue",
372            "contingency",
373            "cramersV",
374            "cramersVBiasCorrected",
375            "theilsU",
376            "maxIntersections",
377            "maxIntersectionsPosition",
378            "meanZTest",
379            "quantileInterpolatedWeighted",
380            "quantilesInterpolatedWeighted",
381            "quantileGK",
382            "quantilesGK",
383            "sparkBar",
384            "sumCount",
385            "largestTriangleThreeBuckets",
386            "histogram",
387            "sequenceMatch",
388            "sequenceCount",
389            "windowFunnel",
390            "retention",
391            "uniqUpTo",
392            "sequenceNextNode",
393            "exponentialTimeDecayedAvg",
394        }
395
396        AGG_FUNCTIONS_SUFFIXES = [
397            "If",
398            "Array",
399            "ArrayIf",
400            "Map",
401            "SimpleState",
402            "State",
403            "Merge",
404            "MergeState",
405            "ForEach",
406            "Distinct",
407            "OrDefault",
408            "OrNull",
409            "Resample",
410            "ArgMin",
411            "ArgMax",
412        ]
413
414        FUNC_TOKENS = {
415            *parser.Parser.FUNC_TOKENS,
416            TokenType.SET,
417        }
418
419        RESERVED_TOKENS = parser.Parser.RESERVED_TOKENS - {TokenType.SELECT}
420
421        ID_VAR_TOKENS = {
422            *parser.Parser.ID_VAR_TOKENS,
423            TokenType.LIKE,
424        }
425
426        AGG_FUNC_MAPPING = (
427            lambda functions, suffixes: {
428                f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions
429            }
430        )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES)
431
432        FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"}
433
434        FUNCTION_PARSERS = {
435            **parser.Parser.FUNCTION_PARSERS,
436            "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()),
437            "QUANTILE": lambda self: self._parse_quantile(),
438            "MEDIAN": lambda self: self._parse_quantile(),
439            "COLUMNS": lambda self: self._parse_columns(),
440        }
441
442        FUNCTION_PARSERS.pop("MATCH")
443
444        NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy()
445        NO_PAREN_FUNCTION_PARSERS.pop("ANY")
446
447        NO_PAREN_FUNCTIONS = parser.Parser.NO_PAREN_FUNCTIONS.copy()
448        NO_PAREN_FUNCTIONS.pop(TokenType.CURRENT_TIMESTAMP)
449
450        RANGE_PARSERS = {
451            **parser.Parser.RANGE_PARSERS,
452            TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN)
453            and self._parse_in(this, is_global=True),
454        }
455
456        # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to
457        # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler.
458        COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy()
459        COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
460
461        JOIN_KINDS = {
462            *parser.Parser.JOIN_KINDS,
463            TokenType.ANY,
464            TokenType.ASOF,
465            TokenType.ARRAY,
466        }
467
468        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
469            TokenType.ANY,
470            TokenType.ARRAY,
471            TokenType.FINAL,
472            TokenType.FORMAT,
473            TokenType.SETTINGS,
474        }
475
476        ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - {
477            TokenType.FORMAT,
478        }
479
480        LOG_DEFAULTS_TO_LN = True
481
482        QUERY_MODIFIER_PARSERS = {
483            **parser.Parser.QUERY_MODIFIER_PARSERS,
484            TokenType.SETTINGS: lambda self: (
485                "settings",
486                self._advance() or self._parse_csv(self._parse_assignment),
487            ),
488            TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
489        }
490
491        CONSTRAINT_PARSERS = {
492            **parser.Parser.CONSTRAINT_PARSERS,
493            "INDEX": lambda self: self._parse_index_constraint(),
494            "CODEC": lambda self: self._parse_compress(),
495        }
496
497        ALTER_PARSERS = {
498            **parser.Parser.ALTER_PARSERS,
499            "REPLACE": lambda self: self._parse_alter_table_replace(),
500        }
501
502        SCHEMA_UNNAMED_CONSTRAINTS = {
503            *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
504            "INDEX",
505        }
506
507        PLACEHOLDER_PARSERS = {
508            **parser.Parser.PLACEHOLDER_PARSERS,
509            TokenType.L_BRACE: lambda self: self._parse_query_parameter(),
510        }
511
512        # https://clickhouse.com/docs/en/sql-reference/statements/create/function
513        def _parse_user_defined_function_expression(self) -> t.Optional[exp.Expression]:
514            return self._parse_lambda()
515
516        def _parse_types(
517            self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
518        ) -> t.Optional[exp.Expression]:
519            dtype = super()._parse_types(
520                check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
521            )
522            if isinstance(dtype, exp.DataType) and dtype.args.get("nullable") is not True:
523                # Mark every type as non-nullable which is ClickHouse's default, unless it's
524                # already marked as nullable. This marker helps us transpile types from other
525                # dialects to ClickHouse, so that we can e.g. produce `CAST(x AS Nullable(String))`
526                # from `CAST(x AS TEXT)`. If there is a `NULL` value in `x`, the former would
527                # fail in ClickHouse without the `Nullable` type constructor.
528                dtype.set("nullable", False)
529
530            return dtype
531
532        def _parse_extract(self) -> exp.Extract | exp.Anonymous:
533            index = self._index
534            this = self._parse_bitwise()
535            if self._match(TokenType.FROM):
536                self._retreat(index)
537                return super()._parse_extract()
538
539            # We return Anonymous here because extract and regexpExtract have different semantics,
540            # so parsing extract(foo, bar) into RegexpExtract can potentially break queries. E.g.,
541            # `extract('foobar', 'b')` works, but ClickHouse crashes for `regexpExtract('foobar', 'b')`.
542            #
543            # TODO: can we somehow convert the former into an equivalent `regexpExtract` call?
544            self._match(TokenType.COMMA)
545            return self.expression(
546                exp.Anonymous, this="extract", expressions=[this, self._parse_bitwise()]
547            )
548
549        def _parse_assignment(self) -> t.Optional[exp.Expression]:
550            this = super()._parse_assignment()
551
552            if self._match(TokenType.PLACEHOLDER):
553                return self.expression(
554                    exp.If,
555                    this=this,
556                    true=self._parse_assignment(),
557                    false=self._match(TokenType.COLON) and self._parse_assignment(),
558                )
559
560            return this
561
562        def _parse_query_parameter(self) -> t.Optional[exp.Expression]:
563            """
564            Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
565            https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
566            """
567            this = self._parse_id_var()
568            self._match(TokenType.COLON)
569            kind = self._parse_types(check_func=False, allow_identifiers=False) or (
570                self._match_text_seq("IDENTIFIER") and "Identifier"
571            )
572
573            if not kind:
574                self.raise_error("Expecting a placeholder type or 'Identifier' for tables")
575            elif not self._match(TokenType.R_BRACE):
576                self.raise_error("Expecting }")
577
578            return self.expression(exp.Placeholder, this=this, kind=kind)
579
580        def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In:
581            this = super()._parse_in(this)
582            this.set("is_global", is_global)
583            return this
584
585        def _parse_table(
586            self,
587            schema: bool = False,
588            joins: bool = False,
589            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
590            parse_bracket: bool = False,
591            is_db_reference: bool = False,
592            parse_partition: bool = False,
593        ) -> t.Optional[exp.Expression]:
594            this = super()._parse_table(
595                schema=schema,
596                joins=joins,
597                alias_tokens=alias_tokens,
598                parse_bracket=parse_bracket,
599                is_db_reference=is_db_reference,
600            )
601
602            if self._match(TokenType.FINAL):
603                this = self.expression(exp.Final, this=this)
604
605            return this
606
607        def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
608            return super()._parse_position(haystack_first=True)
609
610        # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
611        def _parse_cte(self) -> exp.CTE:
612            # WITH <identifier> AS <subquery expression>
613            cte: t.Optional[exp.CTE] = self._try_parse(super()._parse_cte)
614
615            if not cte:
616                # WITH <expression> AS <identifier>
617                cte = self.expression(
618                    exp.CTE,
619                    this=self._parse_assignment(),
620                    alias=self._parse_table_alias(),
621                    scalar=True,
622                )
623
624            return cte
625
626        def _parse_join_parts(
627            self,
628        ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
629            is_global = self._match(TokenType.GLOBAL) and self._prev
630            kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev
631
632            if kind_pre:
633                kind = self._match_set(self.JOIN_KINDS) and self._prev
634                side = self._match_set(self.JOIN_SIDES) and self._prev
635                return is_global, side, kind
636
637            return (
638                is_global,
639                self._match_set(self.JOIN_SIDES) and self._prev,
640                self._match_set(self.JOIN_KINDS) and self._prev,
641            )
642
643        def _parse_join(
644            self, skip_join_token: bool = False, parse_bracket: bool = False
645        ) -> t.Optional[exp.Join]:
646            join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True)
647            if join:
648                join.set("global", join.args.pop("method", None))
649
650                # tbl ARRAY JOIN arr <-- this should be a `Column` reference, not a `Table`
651                # https://clickhouse.com/docs/en/sql-reference/statements/select/array-join
652                if join.kind == "ARRAY":
653                    for table in join.find_all(exp.Table):
654                        table.replace(table.to_column())
655
656            return join
657
658        def _parse_function(
659            self,
660            functions: t.Optional[t.Dict[str, t.Callable]] = None,
661            anonymous: bool = False,
662            optional_parens: bool = True,
663            any_token: bool = False,
664        ) -> t.Optional[exp.Expression]:
665            expr = super()._parse_function(
666                functions=functions,
667                anonymous=anonymous,
668                optional_parens=optional_parens,
669                any_token=any_token,
670            )
671
672            func = expr.this if isinstance(expr, exp.Window) else expr
673
674            # Aggregate functions can be split in 2 parts: <func_name><suffix>
675            parts = (
676                self.AGG_FUNC_MAPPING.get(func.this) if isinstance(func, exp.Anonymous) else None
677            )
678
679            if parts:
680                anon_func: exp.Anonymous = t.cast(exp.Anonymous, func)
681                params = self._parse_func_params(anon_func)
682
683                kwargs = {
684                    "this": anon_func.this,
685                    "expressions": anon_func.expressions,
686                }
687                if parts[1]:
688                    kwargs["parts"] = parts
689                    exp_class: t.Type[exp.Expression] = (
690                        exp.CombinedParameterizedAgg if params else exp.CombinedAggFunc
691                    )
692                else:
693                    exp_class = exp.ParameterizedAgg if params else exp.AnonymousAggFunc
694
695                kwargs["exp_class"] = exp_class
696                if params:
697                    kwargs["params"] = params
698
699                func = self.expression(**kwargs)
700
701                if isinstance(expr, exp.Window):
702                    # The window's func was parsed as Anonymous in base parser, fix its
703                    # type to be ClickHouse style CombinedAnonymousAggFunc / AnonymousAggFunc
704                    expr.set("this", func)
705                elif params:
706                    # Params have blocked super()._parse_function() from parsing the following window
707                    # (if that exists) as they're standing between the function call and the window spec
708                    expr = self._parse_window(func)
709                else:
710                    expr = func
711
712            return expr
713
714        def _parse_func_params(
715            self, this: t.Optional[exp.Func] = None
716        ) -> t.Optional[t.List[exp.Expression]]:
717            if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
718                return self._parse_csv(self._parse_lambda)
719
720            if self._match(TokenType.L_PAREN):
721                params = self._parse_csv(self._parse_lambda)
722                self._match_r_paren(this)
723                return params
724
725            return None
726
727        def _parse_quantile(self) -> exp.Quantile:
728            this = self._parse_lambda()
729            params = self._parse_func_params()
730            if params:
731                return self.expression(exp.Quantile, this=params[0], quantile=this)
732            return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5))
733
734        def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
735            return super()._parse_wrapped_id_vars(optional=True)
736
737        def _parse_primary_key(
738            self, wrapped_optional: bool = False, in_props: bool = False
739        ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
740            return super()._parse_primary_key(
741                wrapped_optional=wrapped_optional or in_props, in_props=in_props
742            )
743
744        def _parse_on_property(self) -> t.Optional[exp.Expression]:
745            index = self._index
746            if self._match_text_seq("CLUSTER"):
747                this = self._parse_id_var()
748                if this:
749                    return self.expression(exp.OnCluster, this=this)
750                else:
751                    self._retreat(index)
752            return None
753
754        def _parse_index_constraint(
755            self, kind: t.Optional[str] = None
756        ) -> exp.IndexColumnConstraint:
757            # INDEX name1 expr TYPE type1(args) GRANULARITY value
758            this = self._parse_id_var()
759            expression = self._parse_assignment()
760
761            index_type = self._match_text_seq("TYPE") and (
762                self._parse_function() or self._parse_var()
763            )
764
765            granularity = self._match_text_seq("GRANULARITY") and self._parse_term()
766
767            return self.expression(
768                exp.IndexColumnConstraint,
769                this=this,
770                expression=expression,
771                index_type=index_type,
772                granularity=granularity,
773            )
774
775        def _parse_partition(self) -> t.Optional[exp.Partition]:
776            # https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#how-to-set-partition-expression
777            if not self._match(TokenType.PARTITION):
778                return None
779
780            if self._match_text_seq("ID"):
781                # Corresponds to the PARTITION ID <string_value> syntax
782                expressions: t.List[exp.Expression] = [
783                    self.expression(exp.PartitionId, this=self._parse_string())
784                ]
785            else:
786                expressions = self._parse_expressions()
787
788            return self.expression(exp.Partition, expressions=expressions)
789
790        def _parse_alter_table_replace(self) -> t.Optional[exp.Expression]:
791            partition = self._parse_partition()
792
793            if not partition or not self._match(TokenType.FROM):
794                return None
795
796            return self.expression(
797                exp.ReplacePartition, expression=partition, source=self._parse_table_parts()
798            )
799
800        def _parse_projection_def(self) -> t.Optional[exp.ProjectionDef]:
801            if not self._match_text_seq("PROJECTION"):
802                return None
803
804            return self.expression(
805                exp.ProjectionDef,
806                this=self._parse_id_var(),
807                expression=self._parse_wrapped(self._parse_statement),
808            )
809
810        def _parse_constraint(self) -> t.Optional[exp.Expression]:
811            return super()._parse_constraint() or self._parse_projection_def()
812
813        def _parse_alias(
814            self, this: t.Optional[exp.Expression], explicit: bool = False
815        ) -> t.Optional[exp.Expression]:
816            # In clickhouse "SELECT <expr> APPLY(...)" is a query modifier,
817            # so "APPLY" shouldn't be parsed as <expr>'s alias. However, "SELECT <expr> apply" is a valid alias
818            if self._match_pair(TokenType.APPLY, TokenType.L_PAREN, advance=False):
819                return this
820
821            return super()._parse_alias(this=this, explicit=explicit)
822
823        def _parse_expression(self) -> t.Optional[exp.Expression]:
824            this = super()._parse_expression()
825
826            # Clickhouse allows "SELECT <expr> [APPLY(func)] [...]]" modifier
827            while self._match_pair(TokenType.APPLY, TokenType.L_PAREN):
828                this = exp.Apply(this=this, expression=self._parse_var(any_token=True))
829                self._match(TokenType.R_PAREN)
830
831            return this
832
833        def _parse_columns(self) -> exp.Expression:
834            this: exp.Expression = self.expression(exp.Columns, this=self._parse_lambda())
835
836            while self._next and self._match_text_seq(")", "APPLY", "("):
837                self._match(TokenType.R_PAREN)
838                this = exp.Apply(this=this, expression=self._parse_var(any_token=True))
839            return this

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

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