sqlglotc 30.24.0__tar.gz → 30.26.0__tar.gz

{sqlglotc-30.24.0/sqlglotc.egg-info → sqlglotc-30.26.0}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.24.0
+Version: 30.26.0
 Summary: mypyc-compiled extensions for sqlglot
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://sqlglot.com/
 Project-URL: Repository, https://github.com/tobymao/sqlglot
 Requires-Python: >=3.10
-Requires-Dist: sqlglot==30.24.0
+Requires-Dist: sqlglot==30.26.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
-Requires-Dist: setuptools_scm; extra == "dev"
+Requires-Dist: setuptools_scm>=10.2; extra == "dev"
 Requires-Dist: mypy>=2.4.0; extra == "dev"
 Dynamic: requires-dist

{sqlglotc-30.24.0 → sqlglotc-30.26.0}/pyproject.toml

@@ -7,7 +7,7 @@ license = "MIT"
 requires-python = ">= 3.10"
 
 [project.optional-dependencies]
-dev = ["setuptools >= 61.0", "setuptools_scm", "mypy >= 2.4.0"]
+dev = ["setuptools >= 61.0", "setuptools_scm >= 10.2", "mypy >= 2.4.0"]
 
 [project.urls]
 Homepage = "https://sqlglot.com/"
@@ -16,7 +16,7 @@ Repository = "https://github.com/tobymao/sqlglot"
 [build-system]
 requires = [
     "setuptools >= 61.0",
-    "setuptools_scm",
+    "setuptools_scm >= 10.2",
     "mypy >= 2.4.0",
     "types-python-dateutil",
     "sqlglot",
@@ -28,6 +28,7 @@ include-package-data = false
 
 [tool.setuptools_scm]
 root = ".."
+write_to_source = true
 fallback_version = "0.0.0"
 local_scheme = "no-local-version"
 

{sqlglotc-30.24.0 → sqlglotc-30.26.0}/sqlglot/expressions/array.py

@@ -254,6 +254,10 @@ class SplitToTable(Expression, Func, UDTF):
     arg_types = {"this": True, "expression": True}
 
 
+class StrtokSplitToTable(Expression, Func, UDTF):
+    arg_types = {"this": True, "expression": False}
+
+
 class Stack(Expression, Func, UDTF):
     arg_types = {"this": True, "expressions": True}
     is_var_len_args = True

{sqlglotc-30.24.0 → sqlglotc-30.26.0}/sqlglot/expressions/builders.py

@@ -921,7 +921,7 @@ def replace_placeholders(expression: Expr, *args: object, **kwargs: t.Any) -> Ex
     def _replace_placeholders(node: Expr, args: Iterator[object], **kwargs: object) -> Expr:
         if isinstance(node, Placeholder):
             if node.this:
-                new_name = kwargs.get(node.this)
+                new_name = kwargs.get(node.name)
                 if new_name is not None:
                     return _replace_placeholder(node, convert(new_name))
             else:

{sqlglotc-30.24.0 → sqlglotc-30.26.0}/sqlglot/expressions/constraints.py

@@ -161,7 +161,7 @@ class OnUpdateColumnConstraint(Expression, ColumnConstraintKind):
 
 
 class PrimaryKeyColumnConstraint(Expression, ColumnConstraintKind):
-    arg_types = {"desc": False, "options": False}
+    arg_types = {"desc": False, "options": False, "include": False}
 
 
 class TitleColumnConstraint(Expression, ColumnConstraintKind):
@@ -175,6 +175,7 @@ class UniqueColumnConstraint(Expression, ColumnConstraintKind):
         "on_conflict": False,
         "nulls": False,
         "options": False,
+        "include": False,
     }
 
 

{sqlglotc-30.24.0 → sqlglotc-30.26.0}/sqlglot/expressions/core.py

@@ -1734,13 +1734,13 @@ class Column(Expression, Condition):
         return self.name
 
     @property
-    def parts(self) -> list[Identifier | Star]:
+    def parts(self) -> list[Expr]:
         """Return the parts of a column in order catalog, db, table, name."""
         return [
             self.args[part] for part in ("catalog", "db", "table", "this") if self.args.get(part)
         ]
 
-    def to_dot(self, include_dots: bool = True) -> Dot | Identifier | Star:
+    def to_dot(self, include_dots: bool = True) -> Expr:
         """Converts the column into a dot expression."""
         parts = self.parts
         parent = self.parent
@@ -2108,6 +2108,10 @@ class Filter(Expression):
     arg_types = {"this": True, "expression": True}
 
 
+class Per(Expression):
+    arg_types = {"this": True, "expressions": True}
+
+
 class Check(Expression):
     pass
 
@@ -3071,7 +3075,7 @@ def alias_(
 
 @t.overload
 def column(
-    col: str | Identifier,
+    col: str | Expr,
     table: str | Identifier | None = None,
     db: str | Identifier | None = None,
     catalog: str | Identifier | None = None,
@@ -3085,7 +3089,7 @@ def column(
 
 @t.overload
 def column(
-    col: str | Identifier | Star,
+    col: str | Expr,
     table: str | Identifier | None = None,
     db: str | Identifier | None = None,
     catalog: str | Identifier | None = None,
@@ -3111,19 +3115,18 @@ def column(
     Build a Column.
 
     Args:
-        col: Column name.
+        col: Column name or expression.
         table: Table name.
         db: Database name.
         catalog: Catalog name.
         fields: Additional fields using dots.
         quoted: Whether to force quotes on the column's identifiers.
-        copy: Whether to copy identifiers if passed in.
+        copy: Whether to copy expressions if passed in.
 
     Returns:
         The new Column instance.
     """
-    if not isinstance(col, Star):
-        col = to_identifier(col, quoted=quoted, copy=copy)
+    col = maybe_copy(col, copy) if isinstance(col, Expr) else to_identifier(col, quoted=quoted)
 
     this: Column | Dot = Column(
         this=col,

{sqlglotc-30.24.0 → sqlglotc-30.26.0}/sqlglot/expressions/datatypes.py

@@ -461,7 +461,9 @@ class IntervalSpan(DataType):
 
 
 class Interval(_TimeUnit):
-    arg_types = {"this": False, "unit": False}
+    # fraction_in_string: a fractional amount was written with its unit in one string, e.g.
+    # INTERVAL '1.5 DAY', which differs from INTERVAL '1.5' DAY in e.g. DuckDB and Postgres
+    arg_types = {"this": False, "unit": False, "fraction_in_string": False}
 
 
 DATA_TYPE = t.Union[str, Identifier, Dot, DataType, DType]

{sqlglotc-30.24.0 → sqlglotc-30.26.0}/sqlglot/expressions/ddl.py

@@ -131,6 +131,14 @@ class Describe(Expression):
     }
 
 
+class ConnectTo(Expression):
+    pass
+
+
+class Disconnect(Expression):
+    arg_types = {}
+
+
 class Attach(Expression):
     arg_types = {"this": True, "exists": False, "expressions": False}
 

{sqlglotc-30.24.0 → sqlglotc-30.26.0}/sqlglot/expressions/properties.py

@@ -107,6 +107,10 @@ class CopyGrantsProperty(Property):
     arg_types = {}
 
 
+class CopyTagsProperty(Property):
+    arg_types = {}
+
+
 class DataBlocksizeProperty(Property):
     arg_types = {
         "size": False,

{sqlglotc-30.24.0 → sqlglotc-30.26.0}/sqlglot/expressions/query.py

@@ -663,7 +663,7 @@ class GroupingSets(Expression):
 
 
 class Lambda(Expression):
-    arg_types = {"this": True, "expressions": True, "colon": False}
+    arg_types = {"this": True, "expressions": True}
 
 
 class Limit(Expression):
@@ -699,8 +699,9 @@ class Join(Expression):
         "method": False,
         "global_": False,
         "hint": False,
-        "match_condition": False,  # Snowflake
-        "directed": False,  # Snowflake
+        "match_condition": False,
+        "nearest": False,
+        "directed": False,
         "expressions": False,
         "pivots": False,
     }
@@ -817,6 +818,10 @@ class Join(Expression):
         return join
 
 
+class Nearest(Expression):
+    arg_types = {"this": True, "count": True, "approximate": False, "similarity": False}
+
+
 class Lateral(Expression, UDTF):
     arg_types = {
         "this": True,

{sqlglotc-30.24.0 → sqlglotc-30.26.0}/sqlglot/generator.py

@@ -169,6 +169,7 @@ class Generator:
             "CONVERT", e.this, e.args["dest"], e.args.get("source")
         ),
         exp.CopyGrantsProperty: lambda *_: "COPY GRANTS",
+        exp.CopyTagsProperty: lambda *_: "COPY TAGS",
         exp.CredentialsProperty: lambda self, e: (
             f"CREDENTIALS=({self.expressions(e, 'expressions', sep=' ')})"
         ),
@@ -333,6 +334,9 @@ class Generator:
     # Whether MERGE ... WHEN MATCHED/NOT MATCHED THEN UPDATE/INSERT ... WHERE is supported
     SUPPORTS_MERGE_WHERE = False
 
+    # Whether MERGE uses ALL BY NAME instead of a star to update or insert all columns
+    MERGE_ALL_BY_NAME = False
+
     # Whether the INTERVAL expression works only with values like '1 day'
     SINGLE_STRING_INTERVAL = False
 
@@ -370,6 +374,9 @@ class Generator:
     # Whether directed joins are supported
     DIRECTED_JOINS = False
 
+    # Whether top-k distance/similarity joins are supported
+    SUPPORTS_NEAREST_JOIN = False
+
     # Whether table hints should be generated
     TABLE_HINTS = True
 
@@ -414,9 +421,12 @@ class Generator:
     # SELECT * VALUES into SELECT UNION
     VALUES_AS_TABLE = True
 
-    # Whether the word COLUMN is included when adding a column with ALTER TABLE
+    # Whether COLUMN/COLUMNS keywords are included when adding columns with ALTER TABLE.
     ALTER_TABLE_INCLUDE_COLUMN_KEYWORD = True
 
+    # Whether ALTER TABLE mutli-column additions are wrapped in parentheses.
+    ALTER_TABLE_ADD_COLUMNS_WRAPPED = True
+
     # UNNEST WITH ORDINALITY (presto) instead of UNNEST WITH OFFSET (bigquery)
     UNNEST_WITH_ORDINALITY = True
 
@@ -722,6 +732,7 @@ class Generator:
         exp.CollateProperty: exp.Properties.Location.POST_SCHEMA,
         exp.ComputeProperty: exp.Properties.Location.POST_CREATE,
         exp.CopyGrantsProperty: exp.Properties.Location.POST_SCHEMA,
+        exp.CopyTagsProperty: exp.Properties.Location.POST_SCHEMA,
         exp.Cluster: exp.Properties.Location.POST_SCHEMA,
         exp.ClusteredByProperty: exp.Properties.Location.POST_SCHEMA,
         exp.ClusterProperty: exp.Properties.Location.POST_SCHEMA,
@@ -1322,7 +1333,8 @@ class Generator:
             return f"PRIMARY KEY{' DESC' if desc else ' ASC'}"
         options = self.expressions(expression, key="options", flat=True, sep=" ")
         options = f" {options}" if options else ""
-        return f"PRIMARY KEY{options}"
+        include = self.sql(expression, "include")
+        return f"PRIMARY KEY{include}{options}"
 
     def uniquecolumnconstraint_sql(self, expression: exp.UniqueColumnConstraint) -> str:
         this = self.sql(expression, "this")
@@ -1334,7 +1346,8 @@ class Generator:
         nulls_sql = " NULLS NOT DISTINCT" if expression.args.get("nulls") else ""
         options = self.expressions(expression, key="options", flat=True, sep=" ")
         options = f" {options}" if options else ""
-        return f"UNIQUE{nulls_sql}{this}{index_type}{on_conflict}{options}"
+        include = self.sql(expression, "include")
+        return f"UNIQUE{nulls_sql}{this}{index_type}{on_conflict}{include}{options}"
 
     def inoutcolumnconstraint_sql(self, expression: exp.InOutColumnConstraint) -> str:
         input_ = expression.args.get("input_")
@@ -1953,19 +1966,63 @@ class Generator:
                 return self.sql(select)
 
         sqls: list[str] = []
-        stack: list[str | exp.Expr] = [expression]
+        stack: list[str | exp.Expr | int | None] = [expression]
+        depth = 0
+        open_parens = ""
 
         while stack:
             node = stack.pop()
 
-            if isinstance(node, exp.SetOperation):
+            if isinstance(node, int):
+                # Closes a plain grouping opened below, restoring its depth
+                depth = node
+                sqls[-1] += self.sep("") + self.indent(")", level=depth, pad=0)
+            elif isinstance(node, exp.SetOperation):
                 stack.append(node.expression)
                 stack.append(
                     self.maybe_comment(
                         self.set_operation(node), comments=node.comments, separated=True
                     )
                 )
-                stack.append(node.this)
+                left = node.this
+                if (
+                    not self.SET_OP_PARENTHESIZED_OPERANDS
+                    and not self.dialect.INTERSECT_BINDS_TIGHTER_THAN_UNION_AND_EXCEPT
+                ):
+                    # Left grouping is implicit, so skip the `SELECT * FROM (...)` wrapper:
+                    # it renames duplicate columns and deepens recursion. Inner CTEs and
+                    # modifiers still need the wrapper.
+                    wrappers: list[exp.Subquery] = []
+                    inner = left
+                    while isinstance(inner, exp.Subquery) and inner.is_wrapper:
+                        wrappers.append(inner)
+                        inner = inner.this
+
+                    if (
+                        isinstance(inner, exp.SetOperation)
+                        and not inner.args.get("with_")
+                        and not any(inner.args.get(key) for key in exp.QUERY_MODIFIERS)
+                    ):
+                        for wrapper in wrappers:
+                            inner.add_comments(wrapper.pop_comments())
+                        left = inner
+                elif (
+                    self.SET_OP_PARENTHESIZED_OPERANDS
+                    and isinstance(left, exp.Subquery)
+                    and left.is_wrapper
+                    and not left.comments
+                    and isinstance(left.this, exp.SetOperation)
+                    and not left.this.args.get("with_")
+                    and not any(left.this.args.get(key) for key in exp.QUERY_MODIFIERS)
+                ):
+                    # Write a plain grouping's parentheses here rather than recursing through
+                    # subquery_sql: left-to-right chains nest one grouping per INTERSECT, and
+                    # long ones would exhaust the stack. The depth pushed here marks the close.
+                    open_parens += self.indent("(", level=depth, pad=0) + self.sep("")
+                    stack.append(depth)
+                    depth += 1
+                    left = left.this
+                stack.append(left)
             else:
                 if (
                     not self.SET_OP_LIMITS
@@ -1975,7 +2032,14 @@ class Generator:
                     node = node.subquery(copy=False)
                     if not self.SET_OP_PARENTHESIZED_OPERANDS:
                         node = exp.select("*").from_(node, copy=False)
-                sqls.append(self.sql(node))
+                elif (
+                    not self.SET_OP_PARENTHESIZED_OPERANDS
+                    and isinstance(node, exp.Subquery)
+                    and isinstance(node.unnest(), exp.SetOperation)
+                ):
+                    node = exp.select("*").from_(node, copy=False)
+                sqls.append(open_parens + self.indent(self.sql(node), level=depth, pad=0))
+                open_parens = ""
 
         this = self.sep().join(sqls)
         this = self.query_modifiers(expression, this)
@@ -2003,6 +2067,9 @@ class Generator:
         where = self.sql(expression, "expression").strip()
         return f"{this} FILTER({where})"
 
+    def per_sql(self, expression: exp.Per) -> str:
+        return f"{self.sql(expression, 'this')} PER ({self.expressions(expression, flat=True)})"
+
     def hint_sql(self, expression: exp.Hint) -> str:
         if not self.QUERY_HINTS:
             self.unsupported("Hints are not supported")
@@ -2024,7 +2091,9 @@ class Generator:
         with_storage = self.expressions(expression, key="with_storage", flat=True)
         with_storage = f" WITH ({with_storage})" if with_storage else ""
         tablespace = self.sql(expression, "tablespace")
-        tablespace = f" USING INDEX TABLESPACE {tablespace}" if tablespace else ""
+        if tablespace:
+            prefix = "" if isinstance(expression.parent, exp.Index) else " USING INDEX"
+            tablespace = f"{prefix} TABLESPACE {tablespace}"
         on = self.sql(expression, "on")
         on = f" ON {on}" if on else ""
 
@@ -2168,7 +2237,7 @@ class Generator:
     def property_name(self, expression: exp.Property, string_key: bool = False) -> str:
         if isinstance(expression.this, exp.Dot):
             return self.sql(expression, "this")
-        return f"'{expression.name}'" if string_key else expression.name
+        return self.sql(exp.Literal.string(expression.name)) if string_key else expression.name
 
     def property_sql(self, expression: exp.Property) -> str:
         property_cls = expression.__class__
@@ -2911,6 +2980,12 @@ class Generator:
         this = self.indent(self.sql(expression, "this"))
         return f"{self.seg('HAVING')}{self.sep()}{this}"
 
+    def connectto_sql(self, expression: exp.ConnectTo) -> str:
+        return f"CONNECT {self.sql(expression, 'this')}"
+
+    def disconnect_sql(self, expression: exp.Disconnect) -> str:
+        return "DISCONNECT"
+
     def connect_sql(self, expression: exp.Connect) -> str:
         start = self.sql(expression, "start")
         start = self.seg(f"START WITH {start}") if start else ""
@@ -2922,7 +2997,7 @@ class Generator:
     def prior_sql(self, expression: exp.Prior) -> str:
         return f"PRIOR {self.sql(expression, 'this')}"
 
-    def join_sql(self, expression: exp.Join) -> str:
+    def join_sql(self, expression: exp.Join, join_op: str | None = None) -> str:
         if not self.SEMI_ANTI_JOIN_WITH_SIDE and expression.kind in ("SEMI", "ANTI"):
             side = None
         else:
@@ -2942,6 +3017,8 @@ class Generator:
         )
         match_cond = self.sql(expression, "match_condition")
         match_cond = f" MATCH_CONDITION ({match_cond})" if match_cond else ""
+        nearest = self.sql(expression, "nearest")
+        nearest = f" {nearest}" if nearest else ""
         on_sql = self.sql(expression, "on")
         using = expression.args.get("using")
 
@@ -2962,17 +3039,27 @@ class Generator:
                 on_sql = f"{space}USING ({on_sql})"
             else:
                 on_sql = f"{space}ON {on_sql}"
-        elif not op_sql:
+        elif not op_sql and not nearest:
             if isinstance(this, exp.Lateral) and this.args.get("cross_apply") is not None:
                 return f" {this_sql}"
 
             return f", {this_sql}"
 
-        if op_sql != "STRAIGHT_JOIN":
+        if join_op:
+            op_sql = join_op
+        elif op_sql != "STRAIGHT_JOIN":
             op_sql = f"{op_sql} JOIN" if op_sql else "JOIN"
 
         pivots = self.expressions(expression, key="pivots", sep="", flat=True)
-        return f"{self.seg(op_sql)} {this_sql}{match_cond}{on_sql}{pivots}"
+        return f"{self.seg(op_sql)} {this_sql}{match_cond}{nearest}{on_sql}{pivots}"
+
+    def nearest_sql(self, expression: exp.Nearest) -> str:
+        if not self.SUPPORTS_NEAREST_JOIN:
+            self.unsupported("NEAREST joins are not supported")
+
+        approximate = "APPROX " if expression.args.get("approximate") else ""
+        metric = "SIMILARITY" if expression.args.get("similarity") else "DISTANCE"
+        return f"{approximate}NEAREST {self.sql(expression, 'count')} BY {metric} {self.sql(expression, 'this')}"
 
     def lambda_sql(self, expression: exp.Lambda, arrow_sep: str = "->", wrap: bool = True) -> str:
         args = self.expressions(expression, flat=True)
@@ -3636,6 +3723,9 @@ class Generator:
             first = "FIRST" if first else "LAST"
 
         if not partition and not order and not spec and alias:
+            # WINDOW w2 AS w1 is unparseable in DuckDB/Postgres; parens are required.
+            if expression.arg_key == "windows":
+                return f"{this} ({alias})"
             return f"{this} {alias}"
 
         args = self.format_args(
@@ -4085,8 +4175,8 @@ class Generator:
             if this:
                 interval_keyword = f"{interval_keyword} " if interval_keyword else ""
                 if unit_expression and isinstance(unit_expression, exp.IntervalSpan):
-                    return f"{interval_keyword}'{this}'{unit}"
-                return f"{interval_keyword}'{this}{unit}'"
+                    return f"{interval_keyword}{self.sql(exp.Literal.string(this))}{unit}"
+                return f"{interval_keyword}{self.sql(exp.Literal.string(f'{this}{unit}'))}"
             return f"{interval_keyword}{unit}"
 
         this = self.sql(expression, "this")
@@ -4508,13 +4598,17 @@ class Generator:
         return f"{keyword} {items_sql}"
 
     def add_column_sql(self, expression: exp.Expr) -> str:
-        sql = self.sql(expression)
-        if isinstance(expression, exp.Schema):
-            column_text = " COLUMNS"
-        elif isinstance(expression, exp.ColumnDef) and self.ALTER_TABLE_INCLUDE_COLUMN_KEYWORD:
-            column_text = " COLUMN"
+        column_text = ""
+        if self.ALTER_TABLE_INCLUDE_COLUMN_KEYWORD:
+            if isinstance(expression, exp.ColumnDef):
+                column_text = " COLUMN"
+            elif isinstance(expression, exp.Schema):
+                column_text = " COLUMNS"
+
+        if isinstance(expression, exp.Schema) and not self.ALTER_TABLE_ADD_COLUMNS_WRAPPED:
+            sql = self.expressions(expression, flat=True)
         else:
-            column_text = ""
+            sql = self.sql(expression)
 
         return f"ADD{column_text} {sql}"
 
@@ -4980,13 +5074,27 @@ class Generator:
 
         then_expression = expression.args.get("then")
         if isinstance(then_expression, exp.Insert):
-            this = self.sql(then_expression, "this")
+            this = (
+                "ALL BY NAME"
+                if self.MERGE_ALL_BY_NAME and isinstance(then_expression.this, exp.Star)
+                else self.sql(then_expression, "this")
+            )
             this = f"INSERT {this}" if this else "INSERT"
             then = self.sql(then_expression, "expression")
             then = f"{this} VALUES {then}" if then else this
         elif isinstance(then_expression, exp.Update):
             if isinstance(then_expression.args.get("expressions"), exp.Star):
-                then = f"UPDATE {self.sql(then_expression, 'expressions')}"
+                then = (
+                    "UPDATE ALL BY NAME"
+                    if self.MERGE_ALL_BY_NAME
+                    else f"UPDATE {self.sql(then_expression, 'expressions')}"
+                )
+            elif (
+                self.MERGE_ALL_BY_NAME
+                and len(then_expression.expressions) == 1
+                and isinstance(then_expression.expressions[0], exp.Star)
+            ):
+                then = "UPDATE ALL BY NAME"
             else:
                 expressions_sql = self.expressions(then_expression)
                 then = f"UPDATE SET{self.sep()}{expressions_sql}" if expressions_sql else "UPDATE"
@@ -5947,7 +6055,8 @@ class Generator:
 
     def slice_sql(self, expression: exp.Slice) -> str:
         step = self.sql(expression, "step")
-        end = self.sql(expression.expression)
+        # An omitted end is written as `-` before a step, since `::` is the cast operator
+        end = self.sql(expression.expression) or ("-" if step else "")
         begin = self.sql(expression.this)
 
         sql = f"{end}:{step}" if step else end

{sqlglotc-30.24.0 → sqlglotc-30.26.0}/sqlglot/generators/bigquery.py

@@ -429,6 +429,7 @@ class BigQueryGenerator(generator.Generator):
         exp.DateFromUnixDate: rename_func("DATE_FROM_UNIX_DATE"),
         exp.Day: _extract_part("DAY"),
         exp.DayOfMonth: _extract_part("DAY"),
+        exp.DayOfWeek: _extract_part("DAYOFWEEK"),
         exp.DayOfWeekIso: _day_of_week_iso_sql,
         exp.DayOfYear: _extract_part("DAYOFYEAR"),
         exp.Filter: no_filter_sql,

{sqlglotc-30.24.0 → sqlglotc-30.26.0}/sqlglot/generators/clickhouse.py

@@ -24,6 +24,7 @@ from sqlglot.dialects.dialect import (
 )
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import is_int
+from sqlglot.optimizer.simplify import simplify_parens
 from collections import defaultdict
 
 DATETIME_DELTA = t.Union[exp.DateAdd, exp.DateDiff, exp.DateSub, exp.TimestampSub, exp.TimestampAdd]
@@ -433,13 +434,12 @@ class ClickHouseGenerator(generator.Generator):
 
     @unsupported_args("json_scope")
     def contains_sql(self, expression: exp.Contains) -> str:
-        # ClickHouse has no CONTAINS; the comparison needs parentheses inside another operator
-        result = exp.StrPosition(this=expression.this, substr=expression.expression) > 0
-        if isinstance(expression.parent, exp.Binary) and not isinstance(
-            expression.parent, exp.Connector
-        ):
-            return self.sql(exp.paren(result, copy=False))
-        return self.sql(result)
+        # ClickHouse has no CONTAINS; keep the parentheses only where the parent needs them
+        result = exp.paren(
+            exp.StrPosition(this=expression.this, substr=expression.expression) > 0, copy=False
+        )
+        result.parent = expression.parent
+        return self.sql(simplify_parens(result, self.dialect))
 
     def groupconcat_sql(self, expression: exp.GroupConcat) -> str:
         this = expression.this

{sqlglotc-30.24.0 → sqlglotc-30.26.0}/sqlglot/generators/databricks.py

@@ -19,6 +19,7 @@ class DatabricksGenerator(SparkGenerator):
     SAFE_JSON_PATH_KEY_RE = exp.SAFE_IDENTIFIER_RE
     QUOTE_JSON_PATH = False
     PARSE_JSON_NAME: str | None = "PARSE_JSON"
+    SUPPORTS_TEMPORAL_PRECISION = True
 
     TRANSFORMS = {
         k: v