sqlglot.dialects.clickhouse

  1from __future__ import annotations
  2
  3import typing as t
  4
  5from sqlglot import exp, generator, parser, tokens, transforms
  6from sqlglot.dialects.dialect import (
  7    Dialect,
  8    arg_max_or_min_no_count,
  9    date_delta_sql,
 10    inline_array_sql,
 11    no_pivot_sql,
 12    rename_func,
 13    var_map_sql,
 14)
 15from sqlglot.errors import ParseError
 16from sqlglot.helper import seq_get
 17from sqlglot.parser import parse_var_map
 18from sqlglot.tokens import Token, TokenType
 19
 20
 21def _lower_func(sql: str) -> str:
 22    index = sql.index("(")
 23    return sql[:index].lower() + sql[index:]
 24
 25
 26def _quantile_sql(self: ClickHouse.Generator, e: exp.Quantile) -> str:
 27    quantile = e.args["quantile"]
 28    args = f"({self.sql(e, 'this')})"
 29
 30    if isinstance(quantile, exp.Array):
 31        func = self.func("quantiles", *quantile)
 32    else:
 33        func = self.func("quantile", quantile)
 34
 35    return func + args
 36
 37
 38def _parse_count_if(args: t.List) -> exp.CountIf | exp.CombinedAggFunc:
 39    if len(args) == 1:
 40        return exp.CountIf(this=seq_get(args, 0))
 41
 42    return exp.CombinedAggFunc(this="countIf", expressions=args, parts=("count", "If"))
 43
 44
 45class ClickHouse(Dialect):
 46    NORMALIZE_FUNCTIONS: bool | str = False
 47    NULL_ORDERING = "nulls_are_last"
 48    SUPPORTS_USER_DEFINED_TYPES = False
 49    SAFE_DIVISION = True
 50
 51    ESCAPE_SEQUENCES = {
 52        "\\0": "\0",
 53    }
 54
 55    class Tokenizer(tokens.Tokenizer):
 56        COMMENTS = ["--", "#", "#!", ("/*", "*/")]
 57        IDENTIFIERS = ['"', "`"]
 58        STRING_ESCAPES = ["'", "\\"]
 59        BIT_STRINGS = [("0b", "")]
 60        HEX_STRINGS = [("0x", ""), ("0X", "")]
 61        HEREDOC_STRINGS = ["$"]
 62
 63        KEYWORDS = {
 64            **tokens.Tokenizer.KEYWORDS,
 65            "ATTACH": TokenType.COMMAND,
 66            "DATE32": TokenType.DATE32,
 67            "DATETIME64": TokenType.DATETIME64,
 68            "DICTIONARY": TokenType.DICTIONARY,
 69            "ENUM": TokenType.ENUM,
 70            "ENUM8": TokenType.ENUM8,
 71            "ENUM16": TokenType.ENUM16,
 72            "FINAL": TokenType.FINAL,
 73            "FIXEDSTRING": TokenType.FIXEDSTRING,
 74            "FLOAT32": TokenType.FLOAT,
 75            "FLOAT64": TokenType.DOUBLE,
 76            "GLOBAL": TokenType.GLOBAL,
 77            "INT256": TokenType.INT256,
 78            "LOWCARDINALITY": TokenType.LOWCARDINALITY,
 79            "MAP": TokenType.MAP,
 80            "NESTED": TokenType.NESTED,
 81            "SAMPLE": TokenType.TABLE_SAMPLE,
 82            "TUPLE": TokenType.STRUCT,
 83            "UINT128": TokenType.UINT128,
 84            "UINT16": TokenType.USMALLINT,
 85            "UINT256": TokenType.UINT256,
 86            "UINT32": TokenType.UINT,
 87            "UINT64": TokenType.UBIGINT,
 88            "UINT8": TokenType.UTINYINT,
 89            "IPV4": TokenType.IPV4,
 90            "IPV6": TokenType.IPV6,
 91            "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION,
 92            "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION,
 93        }
 94
 95        SINGLE_TOKENS = {
 96            **tokens.Tokenizer.SINGLE_TOKENS,
 97            "$": TokenType.HEREDOC_STRING,
 98        }
 99
100    class Parser(parser.Parser):
101        # Tested in ClickHouse's playground, it seems that the following two queries do the same thing
102        # * select x from t1 union all select x from t2 limit 1;
103        # * select x from t1 union all (select x from t2 limit 1);
104        MODIFIERS_ATTACHED_TO_UNION = False
105
106        FUNCTIONS = {
107            **parser.Parser.FUNCTIONS,
108            "ANY": exp.AnyValue.from_arg_list,
109            "ARRAYSUM": exp.ArraySum.from_arg_list,
110            "COUNTIF": _parse_count_if,
111            "DATE_ADD": lambda args: exp.DateAdd(
112                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
113            ),
114            "DATEADD": lambda args: exp.DateAdd(
115                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
116            ),
117            "DATE_DIFF": lambda args: exp.DateDiff(
118                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
119            ),
120            "DATEDIFF": lambda args: exp.DateDiff(
121                this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0)
122            ),
123            "MAP": parse_var_map,
124            "MATCH": exp.RegexpLike.from_arg_list,
125            "RANDCANONICAL": exp.Rand.from_arg_list,
126            "UNIQ": exp.ApproxDistinct.from_arg_list,
127            "XOR": lambda args: exp.Xor(expressions=args),
128        }
129
130        AGG_FUNCTIONS = {
131            "count",
132            "min",
133            "max",
134            "sum",
135            "avg",
136            "any",
137            "stddevPop",
138            "stddevSamp",
139            "varPop",
140            "varSamp",
141            "corr",
142            "covarPop",
143            "covarSamp",
144            "entropy",
145            "exponentialMovingAverage",
146            "intervalLengthSum",
147            "kolmogorovSmirnovTest",
148            "mannWhitneyUTest",
149            "median",
150            "rankCorr",
151            "sumKahan",
152            "studentTTest",
153            "welchTTest",
154            "anyHeavy",
155            "anyLast",
156            "boundingRatio",
157            "first_value",
158            "last_value",
159            "argMin",
160            "argMax",
161            "avgWeighted",
162            "topK",
163            "topKWeighted",
164            "deltaSum",
165            "deltaSumTimestamp",
166            "groupArray",
167            "groupArrayLast",
168            "groupUniqArray",
169            "groupArrayInsertAt",
170            "groupArrayMovingAvg",
171            "groupArrayMovingSum",
172            "groupArraySample",
173            "groupBitAnd",
174            "groupBitOr",
175            "groupBitXor",
176            "groupBitmap",
177            "groupBitmapAnd",
178            "groupBitmapOr",
179            "groupBitmapXor",
180            "sumWithOverflow",
181            "sumMap",
182            "minMap",
183            "maxMap",
184            "skewSamp",
185            "skewPop",
186            "kurtSamp",
187            "kurtPop",
188            "uniq",
189            "uniqExact",
190            "uniqCombined",
191            "uniqCombined64",
192            "uniqHLL12",
193            "uniqTheta",
194            "quantile",
195            "quantiles",
196            "quantileExact",
197            "quantilesExact",
198            "quantileExactLow",
199            "quantilesExactLow",
200            "quantileExactHigh",
201            "quantilesExactHigh",
202            "quantileExactWeighted",
203            "quantilesExactWeighted",
204            "quantileTiming",
205            "quantilesTiming",
206            "quantileTimingWeighted",
207            "quantilesTimingWeighted",
208            "quantileDeterministic",
209            "quantilesDeterministic",
210            "quantileTDigest",
211            "quantilesTDigest",
212            "quantileTDigestWeighted",
213            "quantilesTDigestWeighted",
214            "quantileBFloat16",
215            "quantilesBFloat16",
216            "quantileBFloat16Weighted",
217            "quantilesBFloat16Weighted",
218            "simpleLinearRegression",
219            "stochasticLinearRegression",
220            "stochasticLogisticRegression",
221            "categoricalInformationValue",
222            "contingency",
223            "cramersV",
224            "cramersVBiasCorrected",
225            "theilsU",
226            "maxIntersections",
227            "maxIntersectionsPosition",
228            "meanZTest",
229            "quantileInterpolatedWeighted",
230            "quantilesInterpolatedWeighted",
231            "quantileGK",
232            "quantilesGK",
233            "sparkBar",
234            "sumCount",
235            "largestTriangleThreeBuckets",
236        }
237
238        AGG_FUNCTIONS_SUFFIXES = [
239            "If",
240            "Array",
241            "ArrayIf",
242            "Map",
243            "SimpleState",
244            "State",
245            "Merge",
246            "MergeState",
247            "ForEach",
248            "Distinct",
249            "OrDefault",
250            "OrNull",
251            "Resample",
252            "ArgMin",
253            "ArgMax",
254        ]
255
256        AGG_FUNC_MAPPING = (
257            lambda functions, suffixes: {
258                f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions
259            }
260        )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES)
261
262        FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"}
263
264        FUNCTION_PARSERS = {
265            **parser.Parser.FUNCTION_PARSERS,
266            "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()),
267            "QUANTILE": lambda self: self._parse_quantile(),
268        }
269
270        FUNCTION_PARSERS.pop("MATCH")
271
272        NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy()
273        NO_PAREN_FUNCTION_PARSERS.pop("ANY")
274
275        RANGE_PARSERS = {
276            **parser.Parser.RANGE_PARSERS,
277            TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN)
278            and self._parse_in(this, is_global=True),
279        }
280
281        # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to
282        # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler.
283        COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy()
284        COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
285
286        JOIN_KINDS = {
287            *parser.Parser.JOIN_KINDS,
288            TokenType.ANY,
289            TokenType.ASOF,
290            TokenType.ARRAY,
291        }
292
293        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - {
294            TokenType.ANY,
295            TokenType.ARRAY,
296            TokenType.FINAL,
297            TokenType.FORMAT,
298            TokenType.SETTINGS,
299        }
300
301        LOG_DEFAULTS_TO_LN = True
302
303        QUERY_MODIFIER_PARSERS = {
304            **parser.Parser.QUERY_MODIFIER_PARSERS,
305            TokenType.SETTINGS: lambda self: (
306                "settings",
307                self._advance() or self._parse_csv(self._parse_conjunction),
308            ),
309            TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()),
310        }
311
312        def _parse_conjunction(self) -> t.Optional[exp.Expression]:
313            this = super()._parse_conjunction()
314
315            if self._match(TokenType.PLACEHOLDER):
316                return self.expression(
317                    exp.If,
318                    this=this,
319                    true=self._parse_conjunction(),
320                    false=self._match(TokenType.COLON) and self._parse_conjunction(),
321                )
322
323            return this
324
325        def _parse_placeholder(self) -> t.Optional[exp.Expression]:
326            """
327            Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier}
328            https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters
329            """
330            if not self._match(TokenType.L_BRACE):
331                return None
332
333            this = self._parse_id_var()
334            self._match(TokenType.COLON)
335            kind = self._parse_types(check_func=False, allow_identifiers=False) or (
336                self._match_text_seq("IDENTIFIER") and "Identifier"
337            )
338
339            if not kind:
340                self.raise_error("Expecting a placeholder type or 'Identifier' for tables")
341            elif not self._match(TokenType.R_BRACE):
342                self.raise_error("Expecting }")
343
344            return self.expression(exp.Placeholder, this=this, kind=kind)
345
346        def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In:
347            this = super()._parse_in(this)
348            this.set("is_global", is_global)
349            return this
350
351        def _parse_table(
352            self,
353            schema: bool = False,
354            joins: bool = False,
355            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
356            parse_bracket: bool = False,
357            is_db_reference: bool = False,
358        ) -> t.Optional[exp.Expression]:
359            this = super()._parse_table(
360                schema=schema,
361                joins=joins,
362                alias_tokens=alias_tokens,
363                parse_bracket=parse_bracket,
364                is_db_reference=is_db_reference,
365            )
366
367            if self._match(TokenType.FINAL):
368                this = self.expression(exp.Final, this=this)
369
370            return this
371
372        def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
373            return super()._parse_position(haystack_first=True)
374
375        # https://clickhouse.com/docs/en/sql-reference/statements/select/with/
376        def _parse_cte(self) -> exp.CTE:
377            index = self._index
378            try:
379                # WITH <identifier> AS <subquery expression>
380                return super()._parse_cte()
381            except ParseError:
382                # WITH <expression> AS <identifier>
383                self._retreat(index)
384
385                return self.expression(
386                    exp.CTE,
387                    this=self._parse_field(),
388                    alias=self._parse_table_alias(),
389                    scalar=True,
390                )
391
392        def _parse_join_parts(
393            self,
394        ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
395            is_global = self._match(TokenType.GLOBAL) and self._prev
396            kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev
397
398            if kind_pre:
399                kind = self._match_set(self.JOIN_KINDS) and self._prev
400                side = self._match_set(self.JOIN_SIDES) and self._prev
401                return is_global, side, kind
402
403            return (
404                is_global,
405                self._match_set(self.JOIN_SIDES) and self._prev,
406                self._match_set(self.JOIN_KINDS) and self._prev,
407            )
408
409        def _parse_join(
410            self, skip_join_token: bool = False, parse_bracket: bool = False
411        ) -> t.Optional[exp.Join]:
412            join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True)
413
414            if join:
415                join.set("global", join.args.pop("method", None))
416            return join
417
418        def _parse_function(
419            self,
420            functions: t.Optional[t.Dict[str, t.Callable]] = None,
421            anonymous: bool = False,
422            optional_parens: bool = True,
423        ) -> t.Optional[exp.Expression]:
424            func = super()._parse_function(
425                functions=functions, anonymous=anonymous, optional_parens=optional_parens
426            )
427
428            if isinstance(func, exp.Anonymous):
429                parts = self.AGG_FUNC_MAPPING.get(func.this)
430                params = self._parse_func_params(func)
431
432                if params:
433                    if parts and parts[1]:
434                        return self.expression(
435                            exp.CombinedParameterizedAgg,
436                            this=func.this,
437                            expressions=func.expressions,
438                            params=params,
439                            parts=parts,
440                        )
441                    return self.expression(
442                        exp.ParameterizedAgg,
443                        this=func.this,
444                        expressions=func.expressions,
445                        params=params,
446                    )
447
448                if parts:
449                    if parts[1]:
450                        return self.expression(
451                            exp.CombinedAggFunc,
452                            this=func.this,
453                            expressions=func.expressions,
454                            parts=parts,
455                        )
456                    return self.expression(
457                        exp.AnonymousAggFunc,
458                        this=func.this,
459                        expressions=func.expressions,
460                    )
461
462            return func
463
464        def _parse_func_params(
465            self, this: t.Optional[exp.Func] = None
466        ) -> t.Optional[t.List[exp.Expression]]:
467            if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN):
468                return self._parse_csv(self._parse_lambda)
469
470            if self._match(TokenType.L_PAREN):
471                params = self._parse_csv(self._parse_lambda)
472                self._match_r_paren(this)
473                return params
474
475            return None
476
477        def _parse_quantile(self) -> exp.Quantile:
478            this = self._parse_lambda()
479            params = self._parse_func_params()
480            if params:
481                return self.expression(exp.Quantile, this=params[0], quantile=this)
482            return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5))
483
484        def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
485            return super()._parse_wrapped_id_vars(optional=True)
486
487        def _parse_primary_key(
488            self, wrapped_optional: bool = False, in_props: bool = False
489        ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
490            return super()._parse_primary_key(
491                wrapped_optional=wrapped_optional or in_props, in_props=in_props
492            )
493
494        def _parse_on_property(self) -> t.Optional[exp.Expression]:
495            index = self._index
496            if self._match_text_seq("CLUSTER"):
497                this = self._parse_id_var()
498                if this:
499                    return self.expression(exp.OnCluster, this=this)
500                else:
501                    self._retreat(index)
502            return None
503
504    class Generator(generator.Generator):
505        QUERY_HINTS = False
506        STRUCT_DELIMITER = ("(", ")")
507        NVL2_SUPPORTED = False
508        TABLESAMPLE_REQUIRES_PARENS = False
509        TABLESAMPLE_SIZE_IS_ROWS = False
510        TABLESAMPLE_KEYWORDS = "SAMPLE"
511        LAST_DAY_SUPPORTS_DATE_PART = False
512
513        STRING_TYPE_MAPPING = {
514            exp.DataType.Type.CHAR: "String",
515            exp.DataType.Type.LONGBLOB: "String",
516            exp.DataType.Type.LONGTEXT: "String",
517            exp.DataType.Type.MEDIUMBLOB: "String",
518            exp.DataType.Type.MEDIUMTEXT: "String",
519            exp.DataType.Type.TINYBLOB: "String",
520            exp.DataType.Type.TINYTEXT: "String",
521            exp.DataType.Type.TEXT: "String",
522            exp.DataType.Type.VARBINARY: "String",
523            exp.DataType.Type.VARCHAR: "String",
524        }
525
526        TYPE_MAPPING = {
527            **generator.Generator.TYPE_MAPPING,
528            **STRING_TYPE_MAPPING,
529            exp.DataType.Type.ARRAY: "Array",
530            exp.DataType.Type.BIGINT: "Int64",
531            exp.DataType.Type.DATE32: "Date32",
532            exp.DataType.Type.DATETIME64: "DateTime64",
533            exp.DataType.Type.DOUBLE: "Float64",
534            exp.DataType.Type.ENUM: "Enum",
535            exp.DataType.Type.ENUM8: "Enum8",
536            exp.DataType.Type.ENUM16: "Enum16",
537            exp.DataType.Type.FIXEDSTRING: "FixedString",
538            exp.DataType.Type.FLOAT: "Float32",
539            exp.DataType.Type.INT: "Int32",
540            exp.DataType.Type.MEDIUMINT: "Int32",
541            exp.DataType.Type.INT128: "Int128",
542            exp.DataType.Type.INT256: "Int256",
543            exp.DataType.Type.LOWCARDINALITY: "LowCardinality",
544            exp.DataType.Type.MAP: "Map",
545            exp.DataType.Type.NESTED: "Nested",
546            exp.DataType.Type.NULLABLE: "Nullable",
547            exp.DataType.Type.SMALLINT: "Int16",
548            exp.DataType.Type.STRUCT: "Tuple",
549            exp.DataType.Type.TINYINT: "Int8",
550            exp.DataType.Type.UBIGINT: "UInt64",
551            exp.DataType.Type.UINT: "UInt32",
552            exp.DataType.Type.UINT128: "UInt128",
553            exp.DataType.Type.UINT256: "UInt256",
554            exp.DataType.Type.USMALLINT: "UInt16",
555            exp.DataType.Type.UTINYINT: "UInt8",
556            exp.DataType.Type.IPV4: "IPv4",
557            exp.DataType.Type.IPV6: "IPv6",
558            exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction",
559            exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction",
560        }
561
562        TRANSFORMS = {
563            **generator.Generator.TRANSFORMS,
564            exp.AnyValue: rename_func("any"),
565            exp.ApproxDistinct: rename_func("uniq"),
566            exp.ArraySum: rename_func("arraySum"),
567            exp.ArgMax: arg_max_or_min_no_count("argMax"),
568            exp.ArgMin: arg_max_or_min_no_count("argMin"),
569            exp.Array: inline_array_sql,
570            exp.CastToStrType: rename_func("CAST"),
571            exp.CountIf: rename_func("countIf"),
572            exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"),
573            exp.DateAdd: date_delta_sql("DATE_ADD"),
574            exp.DateDiff: date_delta_sql("DATE_DIFF"),
575            exp.Explode: rename_func("arrayJoin"),
576            exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL",
577            exp.IsNan: rename_func("isNaN"),
578            exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)),
579            exp.Nullif: rename_func("nullIf"),
580            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
581            exp.Pivot: no_pivot_sql,
582            exp.Quantile: _quantile_sql,
583            exp.RegexpLike: lambda self, e: f"match({self.format_args(e.this, e.expression)})",
584            exp.Rand: rename_func("randCanonical"),
585            exp.Select: transforms.preprocess([transforms.eliminate_qualify]),
586            exp.StartsWith: rename_func("startsWith"),
587            exp.StrPosition: lambda self,
588            e: f"position({self.format_args(e.this, e.args.get('substr'), e.args.get('position'))})",
589            exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)),
590            exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions),
591        }
592
593        PROPERTIES_LOCATION = {
594            **generator.Generator.PROPERTIES_LOCATION,
595            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
596            exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA,
597            exp.OnCluster: exp.Properties.Location.POST_NAME,
598        }
599
600        JOIN_HINTS = False
601        TABLE_HINTS = False
602        EXPLICIT_UNION = True
603        GROUPINGS_SEP = ""
604
605        # there's no list in docs, but it can be found in Clickhouse code
606        # see `ClickHouse/src/Parsers/ParserCreate*.cpp`
607        ON_CLUSTER_TARGETS = {
608            "DATABASE",
609            "TABLE",
610            "VIEW",
611            "DICTIONARY",
612            "INDEX",
613            "FUNCTION",
614            "NAMED COLLECTION",
615        }
616
617        def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
618            return f"AS {self.sql(expression, 'this')}"
619
620        def _any_to_has(
621            self,
622            expression: exp.EQ | exp.NEQ,
623            default: t.Callable[[t.Any], str],
624            prefix: str = "",
625        ) -> str:
626            if isinstance(expression.left, exp.Any):
627                arr = expression.left
628                this = expression.right
629            elif isinstance(expression.right, exp.Any):
630                arr = expression.right
631                this = expression.left
632            else:
633                return default(expression)
634            return prefix + self.func("has", arr.this.unnest(), this)
635
636        def eq_sql(self, expression: exp.EQ) -> str:
637            return self._any_to_has(expression, super().eq_sql)
638
639        def neq_sql(self, expression: exp.NEQ) -> str:
640            return self._any_to_has(expression, super().neq_sql, "NOT ")
641
642        def regexpilike_sql(self, expression: exp.RegexpILike) -> str:
643            # Manually add a flag to make the search case-insensitive
644            regex = self.func("CONCAT", "'(?i)'", expression.expression)
645            return f"match({self.format_args(expression.this, regex)})"
646
647        def datatype_sql(self, expression: exp.DataType) -> str:
648            # String is the standard ClickHouse type, every other variant is just an alias.
649            # Additionally, any supplied length parameter will be ignored.
650            #
651            # https://clickhouse.com/docs/en/sql-reference/data-types/string
652            if expression.this in self.STRING_TYPE_MAPPING:
653                return "String"
654
655            return super().datatype_sql(expression)
656
657        def cte_sql(self, expression: exp.CTE) -> str:
658            if expression.args.get("scalar"):
659                this = self.sql(expression, "this")
660                alias = self.sql(expression, "alias")
661                return f"{this} AS {alias}"
662
663            return super().cte_sql(expression)
664
665        def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
666            return super().after_limit_modifiers(expression) + [
667                (
668                    self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True)
669                    if expression.args.get("settings")
670                    else ""
671                ),
672                (
673                    self.seg("FORMAT ") + self.sql(expression, "format")
674                    if expression.args.get("format")
675                    else ""
676                ),
677            ]
678
679        def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
680            params = self.expressions(expression, key="params", flat=True)
681            return self.func(expression.name, *expression.expressions) + f"({params})"
682
683        def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
684            return self.func(expression.name, *expression.expressions)
685
686        def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
687            return self.anonymousaggfunc_sql(expression)
688
689        def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
690            return self.parameterizedagg_sql(expression)
691
692        def placeholder_sql(self, expression: exp.Placeholder) -> str:
693            return f"{{{expression.name}: {self.sql(expression, 'kind')}}}"
694
695        def oncluster_sql(self, expression: exp.OnCluster) -> str:
696            return f"ON CLUSTER {self.sql(expression, 'this')}"
697
698        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
699            kind = self.sql(expression, "kind").upper()
700            if kind in self.ON_CLUSTER_TARGETS and locations.get(exp.Properties.Location.POST_NAME):
701                this_name = self.sql(expression.this, "this")
702                this_properties = " ".join(
703                    [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]]
704                )
705                this_schema = self.schema_columns_sql(expression.this)
706                return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}"
707
708            return super().createable_sql(expression, locations)