sqlpush 0.2.0__tar.gz → 0.3.0__tar.gz

{sqlpush-0.2.0 → sqlpush-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlpush
-Version: 0.2.0
+Version: 0.3.0
 Summary: Schema lifecycle tool for production PostgreSQL/TimescaleDB on SQLAlchemy 2.0 (SQLModel included): diff, push and check schema drift straight from your models
 Keywords: sqlalchemy,alembic,postgresql,timescaledb,prisma,schema,migrations,database,drift,cli
 Author: Juan Miguel Contreras

{sqlpush-0.2.0 → sqlpush-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlpush"
-version = "0.2.0"
+version = "0.3.0"
 description = "Schema lifecycle tool for production PostgreSQL/TimescaleDB on SQLAlchemy 2.0 (SQLModel included): diff, push and check schema drift straight from your models"
 readme = "README.md"
 requires-python = ">=3.10"

{sqlpush-0.2.0 → sqlpush-0.3.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "sqlpush"
-version = "0.2.0"
+version = "0.3.0"
 description = "Schema lifecycle tool for production PostgreSQL/TimescaleDB on SQLAlchemy 2.0 (SQLModel included): diff, push and check schema drift straight from your models"
 readme = "README.md"
 authors = [

{sqlpush-0.2.0 → sqlpush-0.3.0}/src/sqlpush/core/classify.py

@@ -8,9 +8,13 @@ DESTRUCTIVE = frozenset({"drop_column", "drop_table", "drop_index", "drop_constr
 
 
 def classify(op_type: str) -> RiskClass:
-    """Standalone add_index targets an EXISTING table
-    (indexes of new tables ride along with add_table), so it is risky:
-    a plain CREATE INDEX takes a SHARE lock that blocks writes."""
+    """add_index renders standalone: on alembic 1.19.1 even plain
+    declared indexes of NEW tables arrive standalone
+    (CreateTableOp.from_table captures columns+constraints, not
+    indexes; only instrumentation-embedded ones ride inside the
+    add_table render, and the diff dedups those away). What survives
+    runs CREATE INDEX alone — a SHARE lock that blocks writes, hence
+    risky."""
     if op_type in DESTRUCTIVE:
         return RiskClass.DESTRUCTIVE
     if op_type in SAFE:

{sqlpush-0.2.0 → sqlpush-0.3.0}/src/sqlpush/core/diff.py

@@ -274,6 +274,45 @@ def _flatten(ops):
             yield op
 
 
+def _dedup_embedded_indexes(ops: list[PlannedOperation]) -> list[PlannedOperation]:
+    """Drop standalone ``add_index`` ops already embedded in an ``add_table`` render.
+
+    On alembic 1.19.1 ``CreateTableOp.from_table`` captures columns and
+    constraints only, NOT indexes: a plain declared ``Index(...)`` on a
+    new table never reaches the create render — it arrives
+    standalone-only and is untouched here. The embedding this dedup
+    targets happens when the table carries instrumentation-appended
+    indexes (geoalchemy2-style listeners attaching at Table
+    construction): ``to_table()`` reconstruction re-fires the
+    attachment, the rebuilt table carries the index again, the offline
+    create render embeds it, and autogen ALSO emits the standalone
+    CreateIndexOp — executing both is a guaranteed duplicate-object
+    failure (push fire-test F1/F2: the renders are byte-identical and
+    the second execution collides with 42P07). Suppression side: the
+    standalone op is the redundant one — its statement already runs
+    inside the add_table op, whose render embeds it verbatim; the
+    embedded copy has no other carrier op. Exact-statement containment
+    is safe: both renders come from the same renderer over the same
+    Index objects, so an embedded index matches its standalone op
+    byte-for-byte while a different index's statement cannot be a
+    substring of the create-table render (statement text runs to its
+    own terminator). Known limitation: the keys are bare table names,
+    so two NEW tables sharing a bare name across schemas under-dedup
+    (last-wins in the dict) — containment is SQL-qualified either way,
+    so no wrong suppression is possible.
+    """
+    table_renders = {op.table: op.sql for op in ops if op.type == "add_table"}
+    return [
+        op
+        for op in ops
+        if not (
+            op.type == "add_index"
+            and op.table in table_renders
+            and op.sql.strip() in table_renders[op.table]
+        )
+    ]
+
+
 def _render_op_sql(op, engine: Engine) -> str:
     buf = io.StringIO()
     offline = MigrationContext.configure(
@@ -336,6 +375,7 @@ class DiffEngine:
         ops: list[PlannedOperation] = []
         for op in _flatten(script.upgrade_ops.ops):
             ops.extend(self._translate(op, engine, exclude))
+        ops = _dedup_embedded_indexes(ops)
         return Plan(operations=tuple(ops))
 
     def _translate(self, op, engine: Engine, exclude: tuple[str, ...]) -> list[PlannedOperation]:

{sqlpush-0.2.0 → sqlpush-0.3.0}/src/sqlpush/directives/timescale.py

@@ -9,15 +9,15 @@ from sqlpush.annotations import HYPERTABLE_KEY
 from sqlpush.types import PlannedOperation, RiskClass
 
 
-def _is_hypertable(conn: Connection, table_name: str) -> bool:
+def _is_hypertable(conn: Connection, schema: str, table_name: str) -> bool:
     try:
         return bool(
             conn.execute(
                 text(
                     "SELECT 1 FROM timescaledb_information.hypertables "
-                    "WHERE hypertable_name = :name"
+                    "WHERE hypertable_schema = :schema AND hypertable_name = :name"
                 ),
-                {"name": table_name},
+                {"schema": schema, "name": table_name},
             ).scalar()
         )
     except ProgrammingError:
@@ -50,12 +50,22 @@ def hypertable_operations(
         table for table in metadata.tables.values() if table.info.get(HYPERTABLE_KEY) is not None
     ]
     if engine is not None and pending:
+        default_schema = engine.dialect.default_schema_name or "public"
         with engine.connect() as conn:
-            pending = [t for t in pending if not _is_hypertable(conn, t.name)]
+            pending = [
+                t for t in pending if not _is_hypertable(conn, t.schema or default_schema, t.name)
+            ]
     ops: list[PlannedOperation] = []
     for table in pending:
         info = table.info[HYPERTABLE_KEY]
-        name = _lit(table.name)
+        # Schema-qualified relation: create_hypertable resolves an
+        # unqualified name via the session search_path, so a table in a
+        # non-default schema MUST carry its schema or the op lands on
+        # public.<name> (UndefinedTable). Schema-less tables keep the
+        # bare name: they live in the default schema, which the
+        # search_path already resolves.
+        relation = table.name if table.schema is None else f"{table.schema}.{table.name}"
+        name = _lit(relation)
         time_column = _lit(info.time_column)
         parts = [f"SELECT create_hypertable('{name}', '{time_column}'"]
         if info.chunk_time_interval: