sqlglotc 30.9.0__tar.gz → 30.10.0__tar.gz

{sqlglotc-30.9.0/sqlglotc.egg-info → sqlglotc-30.10.0}/PKG-INFO

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

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/expressions/functions.py

@@ -70,7 +70,12 @@ class Cast(Expression, Func):
 
 
 class TryCast(Cast):
-    arg_types = {**Cast.arg_types, "requires_string": False, "null_on_text_overflow": False}
+    arg_types = {
+        **Cast.arg_types,
+        "requires_string": False,
+        "null_on_text_overflow": False,
+        "probe_date_format": False,
+    }
 
 
 class JSONCast(Cast):

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/expressions/properties.py

@@ -75,6 +75,10 @@ class ChecksumProperty(Property):
     arg_types = {"on": False, "default": False}
 
 
+class ClusterProperty(Property):
+    arg_types = {"this": False, "expressions": False}
+
+
 class CollateProperty(Property):
     arg_types = {"this": True, "default": False}
 

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/expressions/query.py

@@ -859,8 +859,8 @@ class SkipJSONColumn(Expression):
     arg_types = {"regexp": False, "expression": True}
 
 
-class Cluster(Order):
-    pass
+class Cluster(Expression):
+    arg_types = {"expressions": True}
 
 
 class Distribute(Order):
@@ -1271,8 +1271,8 @@ class Select(Expression, Query):
         Set the CLUSTER BY expression.
 
         Example:
-            >>> Select().from_("tbl").select("x").cluster_by("x DESC").sql(dialect="hive")
-            'SELECT x FROM tbl CLUSTER BY x DESC'
+            >>> Select().from_("tbl").select("x").cluster_by("x").sql(dialect="hive")
+            'SELECT x FROM tbl CLUSTER BY x'
 
         Args:
             *expressions: the SQL code strings to parse.

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/generator.py

@@ -676,6 +676,7 @@ class Generator:
         exp.CopyGrantsProperty: 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,
         exp.DistributedByProperty: exp.Properties.Location.POST_SCHEMA,
         exp.DuplicateKeyProperty: exp.Properties.Location.POST_SCHEMA,
         exp.DataBlocksizeProperty: exp.Properties.Location.POST_NAME,
@@ -3042,6 +3043,13 @@ class Generator:
     def cluster_sql(self, expression: exp.Cluster) -> str:
         return self.op_expressions("CLUSTER BY", expression)
 
+    def clusterproperty_sql(self, expression: exp.ClusterProperty) -> str:
+        if expression.this:
+            self.unsupported(f"Unsupported CLUSTER BY {self.sql(expression, 'this')}")
+            return ""
+        expressions = self.expressions(expression, flat=True)
+        return f"CLUSTER BY ({expressions})"
+
     def distribute_sql(self, expression: exp.Distribute) -> str:
         return self.op_expressions("DISTRIBUTE BY", expression)
 

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/generators/bigquery.py

@@ -688,3 +688,9 @@ class BigQueryGenerator(generator.Generator):
                 return f"{self.sql(expression, 'to')}{self.sql(this)}"
 
         return super().cast_sql(expression, safe_prefix=safe_prefix)
+
+    def clusterproperty_sql(self, expression: exp.ClusterProperty) -> str:
+        if expression.this:
+            self.unsupported(f"Unsupported CLUSTER BY {self.sql(expression, 'this')}")
+            return ""
+        return self.op_expressions("CLUSTER BY", expression)

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/generators/databricks.py

@@ -109,3 +109,7 @@ class DatabricksGenerator(SparkGenerator):
             seed = gen.this
 
         return self.func("UNIFORM", expression.this, expression.expression, seed)
+
+    def clusterproperty_sql(self, expression):
+        this = self.sql(expression, "this") or f"({self.expressions(expression, flat=True)})"
+        return f"CLUSTER BY {this}"

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/generators/duckdb.py

@@ -2181,6 +2181,14 @@ class DuckDBGenerator(generator.Generator):
         """
     )
 
+    # Snowflake AUTO detects 3 DATE formats: YYYY-MM-DD (ISO-8601), MM/DD/YYYY, DD-MON-YYYY.
+    # DuckDB TRY_CAST handles ISO-8601 natively. For the other two formats we use CONTAINS('/')
+    # and REGEXP_MATCHES('[A-Za-z]') as heuristics — these correctly handle single-digit months
+    # and days (e.g. 1/5/2020, 5-JAN-2020) where a positional char check would fail.
+    # Ref: https://docs.snowflake.com/en/sql-reference/date-time-input-output#date-formats
+    _TRYCAST_DATE_SLASH_FMT = "%m/%d/%Y"
+    _TRYCAST_DATE_MON_FMT = "%d-%b-%Y"
+
     def _array_bag_sql(self, condition: exp.Expr, arr1: exp.Expr, arr2: exp.Expr) -> str:
         cond = exp.Paren(this=exp.replace_placeholders(condition, arr1=arr1, arr2=arr2))
         return self.sql(
@@ -4329,13 +4337,13 @@ class DuckDBGenerator(generator.Generator):
     def trycast_sql(self, expression: exp.TryCast) -> str:
         to = expression.to
         to_type = to.this
+        src = expression.this
 
         if (
             expression.args.get("null_on_text_overflow")
             and to_type in exp.DataType.TEXT_TYPES
             and to.expressions
         ):
-            src = expression.this
             return self.sql(
                 exp.case()
                 .when(
@@ -4344,6 +4352,24 @@ class DuckDBGenerator(generator.Generator):
                 )
                 .else_(exp.Null())
             )
+        elif to_type == exp.DType.DATE and expression.args.get("probe_date_format"):
+            slash_strptime = exp.cast(
+                exp.func("TRY_STRPTIME", src, exp.Literal.string(self._TRYCAST_DATE_SLASH_FMT)),
+                "DATE",
+            )
+            mon_strptime = exp.cast(
+                exp.func("TRY_STRPTIME", src, exp.Literal.string(self._TRYCAST_DATE_MON_FMT)),
+                "DATE",
+            )
+            return self.sql(
+                exp.case()
+                .when(exp.func("CONTAINS", src, exp.Literal.string("/")), slash_strptime)
+                .when(
+                    exp.RegexpLike(this=src, expression=exp.Literal.string("[A-Za-z]")),
+                    mon_strptime,
+                )
+                .else_(exp.TryCast(this=src, to=to))
+            )
 
         return super().trycast_sql(expression)
 

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/generators/presto.py

@@ -279,14 +279,10 @@ class PrestoGenerator(generator.Generator):
         exp.ArraySlice: rename_func("SLICE"),
         exp.AtTimeZone: rename_func("AT_TIMEZONE"),
         exp.BitwiseAnd: lambda self, e: self.func("BITWISE_AND", e.this, e.expression),
-        exp.BitwiseLeftShift: lambda self, e: self.func(
-            "BITWISE_ARITHMETIC_SHIFT_LEFT", e.this, e.expression
-        ),
+        exp.BitwiseLeftShift: rename_func("BITWISE_LEFT_SHIFT"),
         exp.BitwiseNot: lambda self, e: self.func("BITWISE_NOT", e.this),
         exp.BitwiseOr: lambda self, e: self.func("BITWISE_OR", e.this, e.expression),
-        exp.BitwiseRightShift: lambda self, e: self.func(
-            "BITWISE_ARITHMETIC_SHIFT_RIGHT", e.this, e.expression
-        ),
+        exp.BitwiseRightShift: rename_func("BITWISE_RIGHT_SHIFT"),
         exp.BitwiseXor: lambda self, e: self.func("BITWISE_XOR", e.this, e.expression),
         exp.Cast: transforms.preprocess([transforms.epoch_cast_to_ts]),
         exp.CurrentTime: lambda *_: "CURRENT_TIME",

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/generators/snowflake.py

@@ -903,9 +903,6 @@ class SnowflakeGenerator(generator.Generator):
 
         return f"AUTOINCREMENT{start}{increment}{order_clause}"
 
-    def cluster_sql(self, expression: exp.Cluster) -> str:
-        return f"CLUSTER BY ({self.expressions(expression, flat=True)})"
-
     def struct_sql(self, expression: exp.Struct) -> str:
         if len(expression.expressions) == 1:
             arg = expression.expressions[0]

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/generators/starrocks.py

@@ -310,10 +310,13 @@ class StarRocksGenerator(MySQLGenerator):
 
         return f"PARTITION BY {self.sql(this)}"
 
-    def cluster_sql(self, expression: exp.Cluster) -> str:
+    def clusterproperty_sql(self, expression: exp.ClusterProperty) -> str:
         """Generate StarRocks ORDER BY clause for clustering."""
+        if expression.this:
+            self.unsupported(f"Unsupported CLUSTER BY {self.sql(expression, 'this')}")
+            return ""
         expressions = self.expressions(expression, flat=True)
-        return f"ORDER BY ({expressions})" if expressions else ""
+        return f"ORDER BY ({expressions})"
 
     def refreshtriggerproperty_sql(self, expression: exp.RefreshTriggerProperty) -> str:
         """Generate StarRocks REFRESH clause for materialized views.

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/optimizer/qualify_columns.py

@@ -544,7 +544,7 @@ def _convert_columns_to_dots(scope: Scope, resolver: Resolver) -> None:
         dot_parts = column.meta.pop("dot_parts", [])
         if (
             column_table
-            and column_table not in scope.sources
+            and column_table not in scope.selected_sources
             and (
                 not scope.parent
                 or column_table not in scope.parent.sources
@@ -553,7 +553,7 @@ def _convert_columns_to_dots(scope: Scope, resolver: Resolver) -> None:
         ):
             root, *parts = column.parts
 
-            if isinstance(root, exp.Identifier) and root.name in scope.sources:
+            if isinstance(root, exp.Identifier) and root.name in scope.selected_sources:
                 # The struct is already qualified, but we still need to change the AST
                 column_table = root
                 root, *parts = parts

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/parser.py

@@ -1238,7 +1238,7 @@ class Parser:
         "CHARSET": lambda self, **kwargs: self._parse_character_set(**kwargs),
         "CHARACTER SET": lambda self, **kwargs: self._parse_character_set(**kwargs),
         "CHECKSUM": lambda self: self._parse_checksum(),
-        "CLUSTER BY": lambda self: self._parse_cluster(),
+        "CLUSTER BY": lambda self: self._parse_cluster_property(),
         "CLUSTERED": lambda self: self._parse_clustered_by(),
         "COLLATE": lambda self, **kwargs: self._parse_property_assignment(
             exp.CollateProperty, **kwargs
@@ -1437,7 +1437,7 @@ class Parser:
         "ADD": lambda self: self._parse_alter_table_add(),
         "AS": lambda self: self._parse_select(),
         "ALTER": lambda self: self._parse_alter_table_alter(),
-        "CLUSTER BY": lambda self: self._parse_cluster(wrapped=True),
+        "CLUSTER BY": lambda self: self._parse_cluster_property(),
         "DELETE": lambda self: self.expression(exp.Delete(where=self._parse_where())),
         "DROP": lambda self: self._parse_alter_table_drop(),
         "RENAME": lambda self: self._parse_alter_table_rename(),
@@ -1537,7 +1537,7 @@ class Parser:
         TokenType.USING: lambda self: ("sample", self._parse_table_sample(as_modifier=True)),
         TokenType.CLUSTER_BY: lambda self: (
             "cluster",
-            self._parse_sort(exp.Cluster, TokenType.CLUSTER_BY),
+            self._parse_cluster(),
         ),
         TokenType.DISTRIBUTE_BY: lambda self: (
             "distribute",
@@ -3064,14 +3064,18 @@ class Parser:
 
         return self.expression(exp.ChecksumProperty(on=on, default=self._match(TokenType.DEFAULT)))
 
-    def _parse_cluster(self, wrapped: bool = False) -> exp.Cluster:
+    def _parse_cluster(self) -> exp.Cluster:
+        self._match(TokenType.CLUSTER_BY)
         return self.expression(
             exp.Cluster(
-                expressions=(
-                    self._parse_wrapped_csv(self._parse_ordered)
-                    if wrapped
-                    else self._parse_csv(self._parse_ordered)
-                )
+                expressions=self._parse_csv(self._parse_column),
+            )
+        )
+
+    def _parse_cluster_property(self) -> exp.ClusterProperty:
+        return self.expression(
+            exp.ClusterProperty(
+                expressions=self._parse_wrapped_csv(self._parse_column),
             )
         )
 

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/parsers/bigquery.py

@@ -509,6 +509,13 @@ class BigQueryParser(parser.Parser):
 
         return column
 
+    def _parse_cluster_property(self) -> exp.ClusterProperty:
+        return self.expression(
+            exp.ClusterProperty(
+                expressions=self._parse_csv(self._parse_column),
+            )
+        )
+
     @t.overload
     def _parse_json_object(self, agg: t.Literal[False]) -> exp.JSONObject: ...
 

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/parsers/clickhouse.py

@@ -316,6 +316,7 @@ class ClickHouseParser(parser.Parser):
     FUNC_TOKENS = {
         *parser.Parser.FUNC_TOKENS,
         TokenType.AND,
+        TokenType.FILE,
         TokenType.OR,
         TokenType.SET,
     }

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/parsers/databricks.py

@@ -53,3 +53,8 @@ class DatabricksParser(SparkParser):
         if self._match(TokenType.L_PAREN):
             self._match_r_paren()
         return self.expression(exp.CurrentDate())
+
+    def _parse_cluster_property(self):
+        if self._match_texts(("AUTO", "NONE")):
+            return self.expression(exp.ClusterProperty(this=self._prev.text.upper()))
+        return super()._parse_cluster_property()

{sqlglotc-30.9.0 → sqlglotc-30.10.0}/sqlglot/parsers/snowflake.py

@@ -89,11 +89,14 @@ def _build_datetime(name: str, kind: exp.DType, safe: bool = False) -> t.Callabl
         if isinstance(value, (exp.Literal, exp.Neg)) or (value and scale_or_fmt):
             # Converts calls like `TO_TIME('01:02:03')` into casts
             if len(args) == 1 and value.is_string and not int_value:
-                return (
+                cast = (
                     exp.TryCast(this=value, to=kind.into_expr(), requires_string=True)
                     if safe
                     else exp.cast(value, kind)
                 )
+                if safe and kind == exp.DType.DATE:
+                    cast.set("probe_date_format", True)
+                return cast
 
             # Handles `TO_TIMESTAMP(str, fmt)` and `TO_TIMESTAMP(num, scale)` as special
             # cases so we can transpile them, since they're relatively common
@@ -1308,13 +1311,11 @@ class SnowflakeParser(parser.Parser):
         if not strict and to and to.this == exp.DataType.Type.BOOLEAN:
             return self.expression(exp.ToBoolean(this=kwargs.get("this"), safe=True))
         cast = super().build_cast(strict, **kwargs)
-        if (
-            isinstance(cast, exp.TryCast)
-            and to
-            and to.this in exp.DataType.TEXT_TYPES
-            and to.expressions
-        ):
-            cast.set("null_on_text_overflow", True)
+        if isinstance(cast, exp.TryCast) and to:
+            if to.this in exp.DataType.TEXT_TYPES and to.expressions:
+                cast.set("null_on_text_overflow", True)
+            elif to.this == exp.DType.DATE and cast.this.is_string:
+                cast.set("probe_date_format", True)
         return cast
 
     def _parse_window(self, this: exp.Expr | None, alias: bool = False) -> exp.Expr | None:

{sqlglotc-30.9.0 → sqlglotc-30.10.0/sqlglotc.egg-info}/PKG-INFO

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