sqlglot.dialects.clickhouse

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