sqlpush 0.4.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

sqlpush/annotations.py

@@ -12,12 +12,78 @@ class HypertableInfo:
     chunk_time_interval: str | None = None
 
 
+def _lit(value: str) -> str:
+    # single-quoted SQL literal escaping: ' -> '' (defense in depth
+    # against quote break-out via table/column names from user metadata)
+    return value.replace("'", "''")
+
+
+def create_hypertable_sql(table_name: str, schema: str | None, info: HypertableInfo) -> str:
+    """Render the idempotent ``create_hypertable`` statement for an annotated table.
+
+    Single source of truth shared by the directive planner
+    (``directives/timescale.py`` — push/revision) and the decorator's
+    ``after_create`` listener (``create_all``): both mechanisms must
+    always emit identical SQL.
+    """
+    # 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 schema is None else f"{schema}.{table_name}"
+    parts = [f"SELECT create_hypertable('{_lit(relation)}', '{_lit(info.time_column)}'"]
+    if info.chunk_time_interval:
+        parts.append(f", chunk_time_interval => INTERVAL '{_lit(info.chunk_time_interval)}'")
+    # if_not_exists: race insurance between state checks and apply —
+    # and what makes listener (create_all) + directive (push) coexistence
+    # duplicate-free. migrate_data: required when the directive runs on an
+    # existing populated table; a no-op on the empty table the listener
+    # just created. create_default_indexes=false: timescale's implicit
+    # time-column index is invisible to metadata, so the default would
+    # drift forever (destructive drop_index) on a fully synced schema;
+    # users declare wanted indexes in the Table instead (metadata is the
+    # source of truth).
+    parts.append(", migrate_data => true, if_not_exists => true, create_default_indexes => false)")
+    return "".join(parts)
+
+
+def _listen_after_create(table, info: HypertableInfo) -> None:
+    # Dual-mechanism (0.4.1): besides the info entry (planned from
+    # metadata on push/revision paths), register an after_create
+    # listener so create_all paths register the hypertable too —
+    # the same idempotent SQL the directive plans, executed via
+    # text() exactly like the executor runs planned ops. With a
+    # declared index on the time column, create_hypertable sees the
+    # column indexed and create_default_indexes => false adds nothing
+    # (see tests/test_annotations_createall.py).
+    # Imports stay inside the function: this module must remain free of
+    # heavy imports at module level (pinned by test_annotations.py).
+    from sqlalchemy import event, text
+
+    sql = create_hypertable_sql(table.name, table.schema, info)
+
+    def _after_create(target, connection, **kw):
+        connection.execute(text(sql))
+
+    event.listen(table, "after_create", _after_create)
+
+
 def hypertable(*, time_column: str, chunk_time_interval: str | None = None):
-    """Record hypertable intent on the model's Table (MetaData level).
+    """Record hypertable intent on the model's Table (dual-mechanism).
 
     Works with SQLModel, Flask-SQLAlchemy and plain declarative, anything
     whose class already carries a built ``__table__`` when decorated.
 
+    Mechanism 1 (metadata): the annotation is recorded on ``Table.info``
+    and planned as a ``create_hypertable`` op by push/revision.
+
+    Mechanism 2 (create_all): an ``after_create`` listener runs the same
+    idempotent ``create_hypertable``, so ``MetaData.create_all`` paths
+    register the hypertable too; coexistence with a later push is
+    duplicate-free (``if_not_exists``) and ``check()`` stays clean.
+
     The generated ``create_hypertable`` runs with
     ``create_default_indexes => false``: timescale's implicit time-column
     index is invisible to metadata and would drift forever. Declare it
@@ -29,9 +95,9 @@ def hypertable(*, time_column: str, chunk_time_interval: str | None = None):
         table = getattr(cls, "__table__", None)
         if table is None:
             raise TypeError(f"{cls.__name__} has no __table__; decorate a mapped class")
-        table.info[HYPERTABLE_KEY] = HypertableInfo(
-            time_column=time_column, chunk_time_interval=chunk_time_interval
-        )
+        info = HypertableInfo(time_column=time_column, chunk_time_interval=chunk_time_interval)
+        table.info[HYPERTABLE_KEY] = info
+        _listen_after_create(table, info)
         return cls
 
     return decorator

sqlpush/core/diff.py

@@ -107,6 +107,12 @@ def _timescale_auto_indexes(conn) -> dict[str, set[str]]:
     ``a_b`` dim ``c`` both yield ``a_b_c_idx``) — a str value would
     last-win and leak the other as false drift. Qualified keys carry
     cross-schema hypertables. Empty when the extension is absent.
+
+    Consumed twice in ``_make_include``: DB-only prunes (the reflected
+    auto index with no metadata counterpart) and the S1 both-present
+    sibling (a metadata-declared index with the same qualified name and
+    column sequence compares EQUAL — the default's born-DESC ordering is
+    extension state, not drift).
     """
     installed = conn.execute(
         text("SELECT 1 FROM pg_extension WHERE extname = 'timescaledb'")
@@ -222,6 +228,24 @@ def _make_include_name(schemas: frozenset[str], default_schema: str):
     return include_name
 
 
+def _expr_name(e) -> str | None:
+    """Best-effort column name of an Index expression, order-insensitive.
+
+    Metadata-side expressions may be bare strings (``Index(..., "col")``)
+    or Column objects; reflected-side ones arrive wrapped in
+    ``UnaryExpression`` (the born-DESC/ASC ordering modifier). Unwrap
+    wrapper elements (UnaryExpression/Label carry ``.element``), resolve
+    strings and Columns to their names. Functions fall back to ``.name``
+    — a sufficient equality proxy for the suppression check below.
+    """
+    if isinstance(e, str):
+        return e
+    inner = getattr(e, "element", None)
+    if inner is not None:
+        return _expr_name(inner)
+    return getattr(e, "name", None)
+
+
 def _make_include(
     schemas: frozenset[str],
     default_schema: str,
@@ -241,6 +265,11 @@ def _make_include(
         )
         if schema not in schemas or _is_system_schema(schema):
             return False
+        parent = getattr(obj, "table", None)
+        parent_table = getattr(parent, "name", None)
+        parent_schema = getattr(parent, "schema", None) or default_schema
+        qualified_index = f"{parent_schema}.{name}"
+        qualified_parent = f"{parent_schema}.{parent_table}"
         if reflected and compare_to is None:
             # DB-only object: skip system tables. NB: alembic also
             # auto-excludes its own version table from autogen; the
@@ -251,16 +280,29 @@ def _make_include(
             # state no model declares. Qualified name AND owner set must
             # both match, so a same-named index on another table stays
             # real drift, as does one the metadata actually declares
-            # (that arrives in the both-present branch above).
-            parent = getattr(obj, "table", None)
-            parent_table = getattr(parent, "name", None)
-            parent_schema = getattr(parent, "schema", None) or default_schema
-            qualified_index = f"{parent_schema}.{name}"
-            qualified_parent = f"{parent_schema}.{parent_table}"
+            # (that arrives in the both-present branches below).
             if type_ == "index" and qualified_index in spatial_auto_indexes:
                 return False
             owners = ts_auto_indexes.get(qualified_index, frozenset())
             return not (type_ == "index" and qualified_parent in owners)
+        if type_ == "index" and not reflected and compare_to is not None:
+            # S1 both-present sibling (atlas cycle-6): alembic gates the
+            # drop+add PAIR for a "changed" index behind exactly ONE
+            # include_object call (metadata index, reflected=False,
+            # compare_to=reflected index). TimescaleDB's default time
+            # index is born DESC (pg_index.indoption DESC bit); a
+            # metadata-declared index with the same name, same owning
+            # hypertable and the SAME column sequence is its metadata
+            # stand-in — the sort-order difference is extension-birth
+            # state, not drift. Column names compared ORDER-SENSITIVELY:
+            # a genuinely different declaration (reorder, extra column)
+            # still reports the pair.
+            owners = ts_auto_indexes.get(qualified_index, frozenset())
+            if qualified_parent in owners:
+                m_cols = [_expr_name(e) for e in obj.expressions]
+                r_cols = [_expr_name(e) for e in compare_to.expressions]
+                if m_cols == r_cols:
+                    return False
         return True
 
     return include_object
@@ -316,6 +358,93 @@ def _dedup_embedded_indexes(ops: list[PlannedOperation]) -> list[PlannedOperatio
     ]
 
 
+def _split_statements(sql: str) -> list[str]:
+    """Split a multi-statement op render on top-level ``;`` only.
+
+    Quote-aware: ``;`` inside single-quoted SQL literals (enum labels
+    can carry them) never splits; ``''`` escapes are consumed in pairs.
+    """
+    parts: list[str] = []
+    buf: list[str] = []
+    in_quote = False
+    i = 0
+    while i < len(sql):
+        ch = sql[i]
+        if ch == "'":
+            if in_quote and i + 1 < len(sql) and sql[i + 1] == "'":
+                buf.append("''")
+                i += 2
+                continue
+            in_quote = not in_quote
+            buf.append(ch)
+        elif ch == ";" and not in_quote:
+            parts.append("".join(buf))
+            buf = []
+        else:
+            buf.append(ch)
+        i += 1
+    if "".join(buf).strip():
+        parts.append("".join(buf))
+    return parts
+
+
+def _dedup_enum_types(ops: list[PlannedOperation]) -> list[PlannedOperation]:
+    """Emit each native enum's ``CREATE/DROP TYPE`` once across the plan (S2).
+
+    SQLAlchemy's offline render embeds a native enum's DDL inside EVERY
+    table op that references it (per-invoke create/drop memos — unlike
+    metadata-level ``create_all``, which memoizes per metadata), so two
+    tables sharing a Python enum each carry a verbatim copy of the
+    ``CREATE TYPE`` in their add_table render; executing both is a
+    guaranteed DuplicateObject (atlas cycle-6 finding S2 — the enum
+    sibling of F1/F2's embedded-index dedup, but statement-level and
+    cross-table).
+
+    Statement-level: only VERBATIM duplicates (whitespace-normalized)
+    are dropped — later byte-identical copies leave their op, the first
+    copy stays embedded in its original add_table render. A metadata
+    that defines one type name two DIFFERENT ways keeps both statements
+    and still fails loudly at apply time: silent first-win would mask a
+    genuine contradiction.
+    """
+    seen: set[str] = set()
+
+    def _is_type_stmt(norm: str) -> bool:
+        low = norm.lower()
+        return low.startswith(("create type ", "drop type "))
+
+    out: list[PlannedOperation] = []
+    for op in ops:
+        if "type" not in op.sql.lower() or ";" not in op.sql:
+            out.append(op)
+            continue
+        stmts = _split_statements(op.sql)
+        kept: list[str] = []
+        for stmt in stmts:
+            norm = " ".join(stmt.split())
+            if _is_type_stmt(norm):
+                if norm in seen:
+                    continue
+                seen.add(norm)
+            if norm:
+                kept.append(stmt)
+        if not kept:
+            # unreachable for table ops (their CREATE/DROP TABLE always
+            # survives); guard anyway — an empty op.sql is worse than
+            # the duplicate it replaced
+            continue
+        out.append(
+            PlannedOperation(
+                type=op.type,
+                risk=op.risk,
+                sql=";\n\n".join(stmt.strip() for stmt in kept if stmt.strip()),
+                table=op.table,
+                column=op.column,
+            )
+        )
+    return out
+
+
 def _render_op_sql(op, engine: Engine) -> str:
     buf = io.StringIO()
     offline = MigrationContext.configure(
@@ -379,6 +508,7 @@ class DiffEngine:
         for op in _flatten(script.upgrade_ops.ops):
             ops.extend(self._translate(op, engine, exclude))
         ops = _dedup_embedded_indexes(ops)
+        ops = _dedup_enum_types(ops)
         return Plan(operations=tuple(ops))
 
     def _translate(self, op, engine: Engine, exclude: tuple[str, ...]) -> list[PlannedOperation]:

sqlpush/directives/timescale.py

@@ -5,7 +5,7 @@ from sqlalchemy import MetaData, text
 from sqlalchemy.engine import Connection, Engine
 from sqlalchemy.exc import ProgrammingError
 
-from sqlpush.annotations import HYPERTABLE_KEY
+from sqlpush.annotations import HYPERTABLE_KEY, create_hypertable_sql
 from sqlpush.types import PlannedOperation, RiskClass
 
 
@@ -29,12 +29,6 @@ def _is_hypertable(conn: Connection, schema: str, table_name: str) -> bool:
         return False
 
 
-def _lit(value: str) -> str:
-    # single-quoted SQL literal escaping: ' -> '' (defense in depth
-    # against quote break-out via table/column names from user metadata)
-    return value.replace("'", "''")
-
-
 def hypertable_operations(
     metadata: MetaData, engine: Engine | None = None
 ) -> list[PlannedOperation]:
@@ -58,31 +52,14 @@ def hypertable_operations(
     ops: list[PlannedOperation] = []
     for table in pending:
         info = table.info[HYPERTABLE_KEY]
-        # 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:
-            parts.append(f", chunk_time_interval => INTERVAL '{_lit(info.chunk_time_interval)}'")
-        parts.append(", migrate_data => true")
-        # if_not_exists: race insurance between the state check above
-        # and the apply. create_default_indexes=false: timescale's
-        # implicit time-column index is invisible to metadata, so the
-        # default would drift forever (destructive drop_index) on a
-        # fully synced schema; users declare wanted indexes in the
-        # Table instead (metadata is the source of truth).
-        parts.append(", if_not_exists => true, create_default_indexes => false)")
+        # SQL parity with the decorator's after_create listener is by
+        # construction: both render through create_hypertable_sql (the
+        # directive's render adds the statement terminator).
         ops.append(
             PlannedOperation(
                 type="create_hypertable",
                 risk=RiskClass.SAFE,
-                sql="".join(parts) + ";",
+                sql=create_hypertable_sql(table.name, table.schema, info) + ";",
                 table=table.name,
             )
         )

{sqlpush-0.4.0.dist-info → sqlpush-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlpush
-Version: 0.4.0
+Version: 0.4.1
 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.4.0.dist-info → sqlpush-0.4.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 sqlpush/__init__.py,sha256=Px0jJFHbwwM1-UHtDwD3xQlRifEMW4StSXQs5DD9z6w,1697
-sqlpush/annotations.py,sha256=AKK4t30lRznTFUfDYaH9r8WslHzzVs57GNtZGHxS8LM,1222
+sqlpush/annotations.py,sha256=xe5EoYPvraLJy-WvMkFK_zOIKquB3-VsrAzy6HE_hiA,4652
 sqlpush/api.py,sha256=Hm8YBiCEQ6GVI-p1HPe_2YJ0xoa4RnCtBucaxQgprII,8530
 sqlpush/apply/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlpush/apply/executor.py,sha256=-HgmscUO6M_xQ5HPBQhJkUo6XwEPPqBig7_G9aWQJAU,7242
@@ -9,12 +9,12 @@ sqlpush/chain/migrate.py,sha256=V2OG7C7BtPXcomTN7sDJSRrzKy0wN_eazq2u1-Ad41k,7313
 sqlpush/cli.py,sha256=xDyYqPgpkn2nh-SrCJ3iOL5UjCtW170UbRKa3X6xkvU,10175
 sqlpush/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlpush/core/classify.py,sha256=-HNPQ1Kfnr0MMYLoP26_VC14JjcQHravrbT7lPGqlIU,927
-sqlpush/core/diff.py,sha256=rJ_YjaxcCVYDb41Jd2tRizOyZ73eBUwFyNppYw9vgF8,18586
+sqlpush/core/diff.py,sha256=bkaNBCitTzUBCGKonX-_u_CsUhFS9r2ivAiDJbeZtx8,23876
 sqlpush/core/render.py,sha256=9SNEyHOGmMxKUfIjvo3x0MNVQ6N2o2fl3noWT1EWO3M,609
 sqlpush/directives/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlpush/directives/timescale.py,sha256=o0WW9J32SYDLcGwzMAXpRcZ7XM0DXBvkoFz3MSJiAOI,3874
+sqlpush/directives/timescale.py,sha256=W_Cd_stdhKZlzlMum7Bdzq99VfXOulYxq0B-sukz-xE,2645
 sqlpush/types.py,sha256=IMA1HRLIumat7tpt8Yscv-9g2U5U_--xxnfcf_pfkyo,2938
-sqlpush-0.4.0.dist-info/WHEEL,sha256=y6e-a5KI2W-qDAJKfh9Xr81bin8NgUdfWgz3VSXXpe4,80
-sqlpush-0.4.0.dist-info/entry_points.txt,sha256=VYha3PJSvklRgpcDAZYJdE66EXM79MSKQf0z8igyAOI,46
-sqlpush-0.4.0.dist-info/METADATA,sha256=zo2nJV5gBbPlAOCxvShKg_Xs4X87CD0ruTGOCH8Rzxs,8373
-sqlpush-0.4.0.dist-info/RECORD,,
+sqlpush-0.4.1.dist-info/WHEEL,sha256=y6e-a5KI2W-qDAJKfh9Xr81bin8NgUdfWgz3VSXXpe4,80
+sqlpush-0.4.1.dist-info/entry_points.txt,sha256=VYha3PJSvklRgpcDAZYJdE66EXM79MSKQf0z8igyAOI,46
+sqlpush-0.4.1.dist-info/METADATA,sha256=sOurmy4zPSrgMqftJXcNLlDP7bS96_xEqbKSh3tT4fE,8373
+sqlpush-0.4.1.dist-info/RECORD,,