sqlglotc 30.22.0__tar.gz → 30.24.0__tar.gz

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

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

{sqlglotc-30.22.0 → sqlglotc-30.24.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.22.0 → sqlglotc-30.24.0}/sqlglot/anonymize.py

@@ -15,6 +15,7 @@ ANONYMIZED_TYPES = {
     TokenType.HEX_STRING,
     TokenType.HEREDOC_STRING,
     TokenType.IDENTIFIER,
+    TokenType.NATIONAL_RAW_STRING,
     TokenType.NATIONAL_STRING,
     TokenType.NUMBER,
     TokenType.RAW_STRING,

{sqlglotc-30.22.0 → sqlglotc-30.24.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
 
 

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

@@ -10,14 +10,25 @@ from sqlglot.errors import ParseError, TokenError
 from sqlglot.expressions.core import (
     Alias,
     Anonymous,
+    AtTimeZone,
+    Between,
+    Binary,
+    BitwiseNot,
     Boolean,
+    Bracket,
     Column,
     Condition,
+    Dot,
     EQ,
     Expr,
+    Func,
     Identifier,
+    In,
     Literal,
+    Neg,
+    Not,
     Null,
+    Paren,
     Placeholder,
     TABLE_PARTS,
     Var,
@@ -36,6 +47,8 @@ from sqlglot.expressions.query import (
     From,
     Schema,
     Select,
+    SetOperation,
+    Subquery,
     Table,
     TableAlias,
     Tuple,
@@ -44,7 +57,7 @@ from sqlglot.expressions.query import (
     With,
     Query,
 )
-from sqlglot.expressions.ddl import Alter, AlterRename, RenameColumn
+from sqlglot.expressions.ddl import Alter, AlterRename, Create, RenameColumn
 from sqlglot.expressions.dml import Delete, Insert, Merge, Update, When, Whens
 from sqlglot.expressions.functions import Case, Cast
 from sqlglot.expressions.array import Array
@@ -53,11 +66,10 @@ from sqlglot.expressions.array import Array
 if t.TYPE_CHECKING:
     from collections.abc import Sequence, Iterable, Iterator
     from sqlglot.dialects.dialect import DialectType
-    from sqlglot.expressions.core import ExpOrStr, Func
+    from sqlglot.expressions.core import ExpOrStr
     from sqlglot.expressions.datatypes import DATA_TYPE
     from sqlglot._typing import ParserArgs, ParserNoDialectArgs, E, P
     from typing_extensions import Unpack, Concatenate
-    from sqlglot.expressions.core import Dot
 
 
 def select(
@@ -849,6 +861,43 @@ def replace_tables(
     return expression.transform(_replace_tables, copy=copy)  # type: ignore
 
 
+OPERATORS = (AtTimeZone, Between, Binary, BitwiseNot, In, Neg, Not)
+
+
+def _is_operand(placeholder: Placeholder) -> bool:
+    parent = placeholder.parent
+    if isinstance(parent, (Bracket, In)):
+        return placeholder.arg_key == "this"
+    return isinstance(parent, OPERATORS)
+
+
+def _takes_query(placeholder: Placeholder) -> bool:
+    parent = placeholder.parent
+    if isinstance(parent, In):
+        return placeholder.arg_key == "expressions" and len(parent.expressions) == 1
+    if isinstance(parent, Func):
+        return len(list(parent.iter_expressions())) == 1
+    if isinstance(parent, Table):
+        return isinstance(parent.parent, (Create, Subquery))
+    return not parent or isinstance(parent, (CTE, Paren, SetOperation))
+
+
+def _replace_placeholder(placeholder: Placeholder, expression: Expr) -> Expr:
+    if (
+        isinstance(expression, Query)
+        and not isinstance(expression, Subquery)
+        and not _takes_query(placeholder)
+    ):
+        return expression.subquery(copy=False)
+    if (
+        _is_operand(placeholder)
+        and isinstance(expression, OPERATORS)
+        and not isinstance(expression, Dot)
+    ):
+        return Paren(this=expression)
+    return expression
+
+
 def replace_placeholders(expression: Expr, *args: object, **kwargs: t.Any) -> Expr:
     """Replace placeholders in an expression.
 
@@ -874,10 +923,10 @@ def replace_placeholders(expression: Expr, *args: object, **kwargs: t.Any) -> Ex
             if node.this:
                 new_name = kwargs.get(node.this)
                 if new_name is not None:
-                    return convert(new_name)
+                    return _replace_placeholder(node, convert(new_name))
             else:
                 try:
-                    return convert(next(args))
+                    return _replace_placeholder(node, convert(next(args)))
                 except StopIteration:
                     pass
         return node

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

@@ -208,6 +208,7 @@ class Constraint(Expression):
 
 class ForeignKey(Expression):
     arg_types = {
+        "this": False,
         "expressions": False,
         "reference": False,
         "delete": False,

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

@@ -867,7 +867,7 @@ class Expression(Expr):
                     for k in sorted(node.args):
                         v = node.args[k]
                         if v:
-                            hash_ = hash((hash_, k, v))
+                            hash_ = hash((hash_, k, tuple(v) if type(v) is list else v))
                 else:
                     for k in sorted(node.args):
                         v = node.args[k]
@@ -1595,7 +1595,14 @@ class Uncache(Expression):
 
 
 class Refresh(Expression):
-    arg_types = {"this": True, "kind": True}
+    arg_types = {
+        "this": True,
+        "kind": True,
+        "partition_start": False,
+        "partition_end": False,
+        "force": False,
+        "mode": False,
+    }
 
 
 class LockingStatement(Expression):
@@ -1859,6 +1866,7 @@ class SessionParameter(Expression, Condition):
 
 class Placeholder(Expression, Condition):
     arg_types = {"this": False, "kind": False, "widget": False, "jdbc": False}
+    _hash_raw_args = True
 
     @property
     def name(self) -> str:
@@ -1994,6 +2002,7 @@ class Typeof(Expression, Func):
 
 class ParameterizedAgg(Expression, AggFunc):
     arg_types = {"this": True, "expressions": True, "params": True}
+    _hash_raw_args = True
 
 
 class Anonymous(Expression, Func):
@@ -2008,6 +2017,7 @@ class Anonymous(Expression, Func):
 class AnonymousAggFunc(Expression, AggFunc):
     arg_types = {"this": True, "expressions": False}
     is_var_len_args = True
+    _hash_raw_args = True
 
 
 class CombinedAggFunc(AnonymousAggFunc):
@@ -2211,7 +2221,7 @@ class Like(Expression, Binary, Predicate):
 
 
 class Match(Expression, Binary, Predicate):
-    pass
+    arg_types = {"this": True, "expression": True, "kind": False, "analyzer": False}
 
 
 class LT(Expression, Binary, Predicate):

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

@@ -176,6 +176,7 @@ class Set(Expression):
 
 class Heredoc(Expression):
     arg_types = {"this": True, "tag": False}
+    _hash_raw_args = True
 
 
 class SetItem(Expression):
@@ -382,6 +383,7 @@ class Undrop(Expression):
 
 class Command(Expression):
     arg_types = {"this": True, "expression": False}
+    _hash_raw_args = True
 
 
 class Transaction(Expression):

{sqlglotc-30.22.0 → sqlglotc-30.24.0}/sqlglot/expressions/json.py

@@ -100,6 +100,7 @@ class JSONExists(Expression, Func):
         "on_condition": False,
         "from_dcolonqmark": False,
     }
+    _hash_raw_args = True
 
 
 class JSONExtract(Expression, Binary, Func):

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

@@ -25,6 +25,10 @@ class AllowedValuesProperty(Expression):
     arg_types = {"expressions": True}
 
 
+class AggregateKeyProperty(Property):
+    arg_types = {"expressions": True}
+
+
 class AlgorithmProperty(Property):
     arg_types = {"this": True}
 
@@ -123,6 +127,7 @@ class DatabaseProperty(Property):
 
 class DefinerProperty(Property):
     arg_types = {"this": True}
+    _hash_raw_args = True
 
 
 class DistKeyProperty(Property):
@@ -390,6 +395,10 @@ class PartitionedOfProperty(Property):
     arg_types = {"this": True, "expression": True}
 
 
+class PhysicalProperty(Property):
+    arg_types = {"this": True, "value": False}
+
+
 class StreamingTableProperty(Property):
     arg_types = {}
 
@@ -497,6 +506,10 @@ class StorageHandlerProperty(Property):
     arg_types = {"this": True}
 
 
+class StorageProperty(Property):
+    arg_types = {"expressions": True}
+
+
 class UsingProperty(Property):
     # kind: JAR, FILE, or ARCHIVE; this: the resource path (string literal)
     arg_types = {"this": True, "kind": True}
@@ -522,6 +535,10 @@ class Tags(Property, ColumnConstraintKind):
     arg_types = {"expressions": True}
 
 
+class TableSpaceProperty(Property):
+    arg_types = {"this": True}
+
+
 class PropertiesLocation(AutoName):
     POST_CREATE = auto()
     POST_NAME = auto()

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

@@ -500,14 +500,17 @@ class HexString(Expression, Condition):
 class ByteString(Expression, Condition):
     arg_types = {"this": True, "is_bytes": False}
     is_primitive = True
+    _hash_raw_args = True
 
 
 class RawString(Expression, Condition):
     is_primitive = True
+    _hash_raw_args = True
 
 
 class UnicodeString(Expression, Condition):
     arg_types = {"this": True, "escape": False}
+    _hash_raw_args = True
 
 
 class ColumnPosition(Expression):
@@ -599,6 +602,7 @@ class Introducer(Expression):
 
 class National(Expression):
     is_primitive = True
+    _hash_raw_args = True
 
 
 class Partition(Expression):
@@ -1934,6 +1938,10 @@ class WindowSpec(Expression):
     }
 
 
+class PartitionByExcluding(Expression):
+    arg_types = {"expressions": True}
+
+
 class PreWhere(Expression):
     pass
 
@@ -2016,6 +2024,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}
 
@@ -2047,14 +2059,17 @@ class JSONPathPart(Expression):
 
 class JSONPathFilter(JSONPathPart):
     arg_types = {"this": True}
+    _hash_raw_args = True
 
 
 class JSONPathKey(JSONPathPart):
     arg_types = {"this": True, "quoted": False}
+    _hash_raw_args = True
 
 
 class JSONPathRecursive(JSONPathPart):
     arg_types = {"this": False}
+    _hash_raw_args = True
 
 
 class JSONPathRoot(JSONPathPart):
@@ -2063,6 +2078,7 @@ class JSONPathRoot(JSONPathPart):
 
 class JSONPathScript(JSONPathPart):
     arg_types = {"this": True}
+    _hash_raw_args = True
 
 
 class JSONPathSlice(JSONPathPart):
@@ -2079,6 +2095,7 @@ class JSONPathSubscript(JSONPathPart):
 
 class JSONPathUnion(JSONPathPart):
     arg_types = {"expressions": True}
+    _hash_raw_args = True
 
 
 class JSONPathWildcard(JSONPathPart):

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

@@ -706,6 +706,7 @@ class Generator:
     EXPRESSION_PRECEDES_PROPERTIES_CREATABLES: t.ClassVar[set[str]] = set()
 
     PROPERTIES_LOCATION: t.ClassVar = {
+        exp.AggregateKeyProperty: exp.Properties.Location.POST_SCHEMA,
         exp.AllowedValuesProperty: exp.Properties.Location.POST_SCHEMA,
         exp.AlgorithmProperty: exp.Properties.Location.POST_CREATE,
         exp.ApiProperty: exp.Properties.Location.POST_CREATE,
@@ -773,6 +774,7 @@ class Generator:
         exp.OutputModelProperty: exp.Properties.Location.POST_SCHEMA,
         exp.PartitionedByProperty: exp.Properties.Location.POST_WITH,
         exp.PartitionedOfProperty: exp.Properties.Location.POST_SCHEMA,
+        exp.PhysicalProperty: exp.Properties.Location.UNSUPPORTED,
         exp.PrimaryKey: exp.Properties.Location.POST_SCHEMA,
         exp.Property: exp.Properties.Location.POST_WITH,
         exp.RefreshTriggerProperty: exp.Properties.Location.POST_SCHEMA,
@@ -800,9 +802,11 @@ class Generator:
         exp.SqlSecurityProperty: exp.Properties.Location.POST_SCHEMA,
         exp.StabilityProperty: exp.Properties.Location.POST_SCHEMA,
         exp.StorageHandlerProperty: exp.Properties.Location.POST_SCHEMA,
+        exp.StorageProperty: exp.Properties.Location.UNSUPPORTED,
         exp.StreamingTableProperty: exp.Properties.Location.POST_CREATE,
         exp.StrictProperty: exp.Properties.Location.POST_SCHEMA,
         exp.Tags: exp.Properties.Location.POST_WITH,
+        exp.TableSpaceProperty: exp.Properties.Location.UNSUPPORTED,
         exp.TemporaryProperty: exp.Properties.Location.POST_CREATE,
         exp.ToTableProperty: exp.Properties.Location.POST_SCHEMA,
         exp.TransientProperty: exp.Properties.Location.POST_CREATE,
@@ -2174,6 +2178,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')}"
 
@@ -2315,6 +2320,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")
@@ -2557,6 +2566,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")
@@ -3634,6 +3647,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=" ")
@@ -3840,6 +3856,8 @@ class Generator:
         return f"CHECK ({this})"
 
     def foreignkey_sql(self, expression: exp.ForeignKey) -> str:
+        this = self.sql(expression, "this")
+        this = f" {this}" if this else ""
         expressions = self.expressions(expression, flat=True)
         expressions = f" ({expressions})" if expressions else ""
         reference = self.sql(expression, "reference")
@@ -3850,7 +3868,7 @@ class Generator:
         update = f" ON UPDATE {update}" if update else ""
         options = self.expressions(expression, key="options", flat=True, sep=" ")
         options = f" {options}" if options else ""
-        return f"FOREIGN KEY{expressions}{reference}{delete}{update}{options}"
+        return f"FOREIGN KEY{this}{expressions}{reference}{delete}{update}{options}"
 
     def primarykey_sql(self, expression: exp.PrimaryKey) -> str:
         this = self.sql(expression, "this")
@@ -4511,6 +4529,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")
@@ -4688,6 +4709,8 @@ class Generator:
         return self._like_sql(expression)
 
     def match_sql(self, expression: exp.Match) -> str:
+        if expression.args.get("kind") or expression.args.get("analyzer"):
+            self.unsupported("MATCH variants and USING ANALYZER are not supported in this dialect")
         return self.binary(expression, "MATCH")
 
     def similarto_sql(self, expression: exp.SimilarTo) -> str:
@@ -4763,14 +4786,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)} ")
@@ -5043,6 +5074,9 @@ class Generator:
     def dictsubproperty_sql(self, expression: exp.DictSubProperty) -> str:
         return f"{self.sql(expression, 'this')} {self.sql(expression, 'value')}"
 
+    def aggregatekeyproperty_sql(self, expression: exp.AggregateKeyProperty) -> str:
+        return f"AGGREGATE KEY ({self.expressions(expression, flat=True)})"
+
     def duplicatekeyproperty_sql(self, expression: exp.DuplicateKeyProperty) -> str:
         return f"DUPLICATE KEY ({self.expressions(expression, flat=True)})"
 
@@ -5281,6 +5315,7 @@ class Generator:
         expression_sql = self.sql(expression, "expression")
         return f"FOR {this} DO {expression_sql}"
 
+    @unsupported_args("partition_start", "partition_end", "force", "mode")
     def refresh_sql(self, expression: exp.Refresh) -> str:
         this = self.sql(expression, "this")
         kind = "" if isinstance(expression.this, exp.Literal) else f"{expression.text('kind')} "
@@ -6041,6 +6076,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
 

{sqlglotc-30.22.0 → sqlglotc-30.24.0}/sqlglot/generators/athena.py

@@ -54,7 +54,11 @@ def _generate_as_hive(expression: exp.Expr) -> bool:
 
             # Any CREATE TABLE other than CREATE TABLE ... As <query> is Hive
             if not isinstance(expression.expression, exp.Query):
-                return True
+                # CTAS with a leading USING EXTERNAL FUNCTION clause is Trino
+                return not (
+                    isinstance(expression.expression, exp.Command)
+                    and expression.expression.text("this").upper() == "USING"
+                )
         else:
             # CREATE VIEW is Trino, but CREATE SCHEMA, CREATE DATABASE, etc, is Hive
             return expression.kind != "VIEW"