sqlglotc 30.23.0__tar.gz → 30.25.0__tar.gz

{sqlglotc-30.23.0/sqlglotc.egg-info → sqlglotc-30.25.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.23.0
+Version: 30.25.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.23.0
+Requires-Dist: sqlglot==30.25.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"

{sqlglotc-30.23.0 → sqlglotc-30.25.0}/pyproject.toml

@@ -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.23.0 → sqlglotc-30.25.0}/setup.py

@@ -90,6 +90,16 @@ def _source_paths():
 
 
 class build_ext(_build_ext):
+    def _remove_obsolete_extensions(self, directory, expected):
+        if self.dry_run:
+            return
+        expected = {os.path.abspath(path) for path in expected}
+        for root, _, files in os.walk(directory):
+            for filename in files:
+                path = os.path.join(root, filename)
+                if filename.endswith((".so", ".pyd")) and os.path.abspath(path) not in expected:
+                    self.execute(os.remove, (path,), f"removing obsolete extension {path}")
+
     def finalize_options(self):
         super().finalize_options()
         # Compile in parallel by default; builds driven by pip (wheel/sdist installs)
@@ -97,8 +107,13 @@ class build_ext(_build_ext):
         if self.parallel is None:
             self.parallel = os.cpu_count() or 1
 
+    def build_extensions(self):
+        self._remove_obsolete_extensions(self.build_lib, self.get_outputs())
+        super().build_extensions()
+
     def copy_extensions_to_source(self):
         """For editable installs, put sqlglot.* .so files in the sqlglot source dir."""
+        expected = []
         for ext in self.extensions:
             fullname = self.get_ext_fullname(ext.name)
             filename = self.get_ext_filename(fullname)
@@ -112,7 +127,9 @@ class build_ext(_build_ext):
                 # Place the mypyc runtime helper (e.g., HASH__mypyc) inside sqlglot/.
                 # sqlglot/__init__.py bootstraps it into sys.modules for editable installs.
                 dst = os.path.join(SQLGLOT_SRC, os.path.basename(filename))
+            expected.append(dst)
             self.copy_file(src, dst, level=self.verbose)
+        self._remove_obsolete_extensions(SQLGLOT_SRC, expected)
 
 
 class sdist(_sdist):

{sqlglotc-30.23.0 → sqlglotc-30.25.0}/sqlglot/expressions/array.py

@@ -98,17 +98,13 @@ class ArraySlice(Expression, Func):
 
 
 class ArraySort(Expression, Func):
-    arg_types = {"this": True, "expression": False}
+    arg_types = {"this": True, "expression": False, "asc": False, "nulls_first": False}
 
 
 class Shuffle(Expression, Func):
     pass
 
 
-class SortArray(Expression, Func):
-    arg_types = {"this": True, "asc": False, "nulls_first": False}
-
-
 # Array predicates / search
 
 
@@ -258,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.23.0 → sqlglotc-30.25.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.23.0 → sqlglotc-30.25.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.23.0 → sqlglotc-30.25.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
@@ -3071,7 +3071,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 +3085,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 +3111,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.23.0 → sqlglotc-30.25.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.23.0 → sqlglotc-30.25.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.23.0 → sqlglotc-30.25.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,
@@ -1938,6 +1943,10 @@ class WindowSpec(Expression):
     }
 
 
+class PartitionByExcluding(Expression):
+    arg_types = {"expressions": True}
+
+
 class PreWhere(Expression):
     pass
 
@@ -2020,6 +2029,10 @@ class DropPartition(Expression):
     arg_types = {"expressions": True, "exists": False}
 
 
+class ReplaceColumns(Expression):
+    arg_types = {"expressions": True}
+
+
 class ReplacePartition(Expression):
     arg_types = {"expression": True, "source": True}
 

{sqlglotc-30.23.0 → sqlglotc-30.25.0}/sqlglot/generator.py

@@ -333,6 +333,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 +373,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 +420,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
 
@@ -1322,7 +1331,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 +1344,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_")
@@ -2024,7 +2035,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 +2181,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__
@@ -2178,6 +2191,7 @@ class Generator:
         property_name = exp.Properties.PROPERTY_TO_NAME.get(property_cls)
         if not property_name:
             self.unsupported(f"Unsupported property {expression.key}")
+            return ""
 
         return f"{property_name}={self.sql(expression, 'this')}"
 
@@ -2319,6 +2333,10 @@ class Generator:
         override = " OVERRIDE" if expression.args.get("override") else ""
         return f"LOCKING {kind}{this}{for_or_in} {lock_type}{override}"
 
+    def lockingstatement_sql(self, expression: exp.LockingStatement) -> str:
+        self.unsupported("LOCKING request modifier is not supported")
+        return self.sql(expression, "expression")
+
     def withdataproperty_sql(self, expression: exp.WithDataProperty) -> str:
         data_sql = f"WITH {'NO ' if expression.args.get('no') else ''}DATA"
         statistics = expression.args.get("statistics")
@@ -2561,6 +2579,10 @@ class Generator:
         expression: exp.TableSample,
         tablesample_keyword: str | None = None,
     ) -> str:
+        if expression.expressions:
+            self.unsupported("Multiple sample sets are not supported")
+            return ""
+
         method = self.sql(expression, "method")
         method = f"{method} " if method and self.TABLESAMPLE_WITH_METHOD else ""
         numerator = self.sql(expression, "bucket_numerator")
@@ -2902,6 +2924,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 ""
@@ -2913,7 +2941,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:
@@ -2933,6 +2961,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")
 
@@ -2953,17 +2983,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)
@@ -3627,6 +3667,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(
@@ -3638,6 +3681,9 @@ class Generator:
         partition = self.expressions(expression, key="partition_by", flat=True)
         return f"PARTITION BY {partition}" if partition else ""
 
+    def partitionbyexcluding_sql(self, expression: exp.PartitionByExcluding) -> str:
+        return f"EXCLUDING {self.expressions(expression, flat=True)}"
+
     def windowspec_sql(self, expression: exp.WindowSpec) -> str:
         kind = self.sql(expression, "kind")
         start = csv(self.sql(expression, "start"), self.sql(expression, "start_side"), sep=" ")
@@ -4073,8 +4119,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")
@@ -4496,13 +4542,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}"
 
@@ -4517,6 +4567,9 @@ class Generator:
     def addconstraint_sql(self, expression: exp.AddConstraint) -> str:
         return f"ADD {self.expressions(expression, indent=False)}"
 
+    def replacecolumns_sql(self, expression: exp.ReplaceColumns) -> str:
+        return f"REPLACE COLUMNS ({self.expressions(expression, flat=True)})"
+
     def addpartition_sql(self, expression: exp.AddPartition) -> str:
         exists = "IF NOT EXISTS " if expression.args.get("exists") else ""
         location = self.sql(expression, "location")
@@ -4771,14 +4824,22 @@ class Generator:
         sqls: list[str] = []
         stack: list[None | str | exp.Expr] = [expression]
         binary_type = type(expression)
+        is_is = binary_type is exp.Is and op in ("IS", "IS NOT")
+        negate = expression.args.get("negate")
 
         while stack:
             node = stack.pop()
 
-            if type(node) is binary_type:
+            if type(node) is binary_type and (
+                node is expression
+                or (is_is and not isinstance(node.expression, exp.Boolean))
+                or node.args.get("negate") == negate
+            ):
                 op_func = node.args.get("operator")
                 if op_func:
                     op = f"OPERATOR({self.sql(op_func)})"
+                elif is_is:
+                    op = "IS NOT" if node.args.get("negate") else "IS"
 
                 stack.append(node.args.get("expression"))
                 stack.append(f" {self.maybe_comment(op, comments=node.comments)} ")
@@ -4957,13 +5018,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"
@@ -5924,7 +5999,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
@@ -6053,6 +6129,13 @@ class Generator:
             exp.TimestampDiff(this=expression.this, expression=start_ts, unit=exp.var("SECONDS"))
         )
 
+    def arraysort_sql(self, expression: exp.ArraySort) -> str:
+        asc = expression.args.get("asc")
+        nulls_first = expression.args.get("nulls_first")
+        if (asc and asc != exp.true()) or (nulls_first and nulls_first != exp.false()):
+            self.unsupported("ARRAY_SORT only sorts ascending with NULLs last")
+        return self.func("ARRAY_SORT", expression.this, expression.expression)
+
     def arraysize_sql(self, expression: exp.ArraySize) -> str:
         dim = expression.expression