sqlglotc 30.3.0__tar.gz → 30.4.0__tar.gz

{sqlglotc-30.3.0 → sqlglotc-30.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.3.0
+Version: 30.4.0
 Summary: mypyc-compiled extensions for sqlglot
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT

{sqlglotc-30.3.0 → sqlglotc-30.4.0}/sqlglot/generator.py

@@ -3416,6 +3416,17 @@ class Generator:
         return self.func("CONCAT", *expressions)
 
     def concatws_sql(self, expression: exp.ConcatWs) -> str:
+        if self.dialect.CONCAT_COALESCE and not expression.args.get("coalesce"):
+            # Dialect's CONCAT_WS function coalesces NULLs to empty strings, but the expression does not.
+            # Wrap the entire call in a CASE expression that returns NULL if any input IS NULL.
+            all_args = expression.expressions
+            expression.set("coalesce", True)
+            return self.sql(
+                exp.case()
+                .when(exp.or_(*(arg.is_(exp.null()) for arg in all_args)), exp.null())
+                .else_(expression)
+            )
+
         return self.func(
             "CONCAT_WS", seq_get(expression.expressions, 0), *self.convert_concat_args(expression)
         )

{sqlglotc-30.3.0 → sqlglotc-30.4.0}/sqlglot/generators/duckdb.py

@@ -82,6 +82,13 @@ WEEK_START_DAY_TO_DOW = {
 
 MAX_BIT_POSITION = exp.Literal.number(32768)
 
+# cs/as/ps are Snowflake defaults; DuckDB already behaves the same way, so they are safe to drop.
+# Note: "as" is also a reserved keyword in DuckDB, making it impossible to pass through.
+_SNOWFLAKE_COLLATION_DEFAULTS = frozenset({"cs", "as", "ps"})
+_SNOWFLAKE_COLLATION_UNSUPPORTED = frozenset(
+    {"ci", "ai", "upper", "lower", "utf8", "bin", "pi", "fl", "fu", "trim", "ltrim", "rtrim"}
+)
+
 # Window functions that support IGNORE/RESPECT NULLS in DuckDB
 _IGNORE_RESPECT_NULLS_WINDOW_FUNCTIONS = (
     exp.FirstValue,
@@ -2997,6 +3004,30 @@ class DuckDBGenerator(generator.Generator):
         self.unsupported("COLLATION function is not supported by DuckDB")
         return self.function_fallback_sql(expression)
 
+    def collate_sql(self, expression: exp.Collate) -> str:
+        if not expression.expression.is_string:
+            return super().collate_sql(expression)
+
+        raw = expression.expression.name
+        if not raw:
+            return self.sql(expression.this)
+
+        parts = []
+        for part in raw.split("-"):
+            lower = part.lower()
+            if lower not in _SNOWFLAKE_COLLATION_DEFAULTS:
+                if lower in _SNOWFLAKE_COLLATION_UNSUPPORTED:
+                    self.unsupported(
+                        f"Snowflake collation specifier '{part}' has no DuckDB equivalent"
+                    )
+                parts.append(lower)
+
+        if not parts:
+            return self.sql(expression.this)
+        return super().collate_sql(
+            exp.Collate(this=expression.this, expression=exp.var(".".join(parts)))
+        )
+
     def _validate_regexp_flags(self, flags: exp.Expr | None, supported_flags: str) -> str | None:
         """
         Validate and filter regexp flags for DuckDB compatibility.
@@ -3362,6 +3393,9 @@ class DuckDBGenerator(generator.Generator):
     def right_sql(self, expression: exp.Right) -> str:
         return self._left_right_sql(expression, "RIGHT")
 
+    def rtrimmedlength_sql(self, expression: exp.RtrimmedLength) -> str:
+        return self.func("LENGTH", exp.Trim(this=expression.this, position="TRAILING"))
+
     def rand_sql(self, expression: exp.Rand) -> str:
         seed = expression.this
         if seed is not None:
@@ -3733,6 +3767,21 @@ class DuckDBGenerator(generator.Generator):
 
         return self.func("ARRAY_TO_STRING", expression.this, expression.expression)
 
+    def concatws_sql(self, expression: exp.ConcatWs) -> str:
+        # DuckDB-specific: handle binary types using DPipe (||) operator
+        separator = seq_get(expression.expressions, 0)
+        args = expression.expressions[1:]
+
+        if any(_is_binary(arg) for arg in [separator, *args]):
+            result = args[0]
+            for arg in args[1:]:
+                result = exp.DPipe(
+                    this=exp.DPipe(this=result, expression=separator), expression=arg
+                )
+            return self.sql(result)
+
+        return super().concatws_sql(expression)
+
     def _regexp_extract_sql(self, expression: exp.RegexpExtract | exp.RegexpExtractAll) -> str:
         this = expression.this
         group = expression.args.get("group")

{sqlglotc-30.3.0 → sqlglotc-30.4.0}/sqlglot/generators/snowflake.py

@@ -481,6 +481,7 @@ class SnowflakeGenerator(generator.Generator):
         ),
         exp.CosineDistance: rename_func("VECTOR_COSINE_SIMILARITY"),
         exp.EuclideanDistance: rename_func("VECTOR_L2_DISTANCE"),
+        exp.HandlerProperty: lambda self, e: f"HANDLER = {self.sql(e, 'this')}",
         exp.FileFormatProperty: lambda self, e: (
             f"FILE_FORMAT=({self.expressions(e, 'expressions', sep=' ')})"
         ),

{sqlglotc-30.3.0 → sqlglotc-30.4.0}/sqlglot/parser.py

@@ -5399,7 +5399,11 @@ class Parser:
             comments = self._prev_comments
             if top:
                 limit_paren = self._match(TokenType.L_PAREN)
-                expression = self._parse_term() if limit_paren else self._parse_number()
+                expression = (
+                    self._parse_term() or self._parse_select()
+                    if limit_paren
+                    else self._parse_number()
+                )
 
                 if limit_paren:
                     self._match_r_paren()

{sqlglotc-30.3.0 → sqlglotc-30.4.0}/sqlglotc.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.3.0
+Version: 30.4.0
 Summary: mypyc-compiled extensions for sqlglot
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT