mainsequence-metatable 0.1.11.dev23__tar.gz → 0.1.12__tar.gz

{mainsequence_metatable-0.1.11.dev23 → mainsequence_metatable-0.1.12}/.agents/skills/client/metatables-local-development/SKILL.md

@@ -145,7 +145,12 @@ existing database just to obtain a clean test run.
 SQLite verifies portable application behavior, not PostgreSQL/MySQL/MSSQL-specific
 SQL, Timescale features, database roles or every concurrency behavior. Report that
 limit and use the intended engine in an isolated test database when the task
-requires those checks. Do not use the shared environment database as the default
+requires those checks. Application models keep their hosted column types: a
+PostgreSQL `JSONB` column runs as JSON, and `Numeric` runs as a SQLite number exact
+to about 15 significant digits, the precision the client's float64 frames carry on
+every engine. Unsigned 64-bit integers and arrays are rejected, naming the column.
+Revisions need no SQLite variants: column and constraint changes run through Alembic
+batch mode. Only raw PostgreSQL SQL must check `op.get_bind().dialect.name`. Do not use the shared environment database as the default
 integration-test fixture.
 
 ## Finish verification and switch back

{mainsequence_metatable-0.1.11.dev23 → mainsequence_metatable-0.1.12}/.agents/skills/client/metatables-migrations/SKILL.md

@@ -154,6 +154,12 @@ The global `--local` selects the running project's API connection; inspect runti
 status because Admin can switch that API to Hosted. Upgrade/downgrade accept
 Alembic targets. Use `--no-autogenerate` for offline revision authoring.
 
+Write each revision once, for the hosted engine. On local SQLite, MetaTables runs
+column and constraint changes through Alembic batch mode, generated revisions use
+batch blocks, `JSONB` runs as JSON, and `postgresql_where` predicates also apply to
+SQLite. Raw PostgreSQL SQL, such as `ctid`, `::` casts or `jsonb_*` functions, must
+branch on `op.get_bind().dialect.name`.
+
 The client imports and executes application revisions, using the connection
 resolved for the selected environment. Environment operators supply the database
 login's DDL privileges. MetaTables does not mint migration roles or sandbox DDL.

{mainsequence_metatable-0.1.11.dev23/src/mainsequence_metatable.egg-info → mainsequence_metatable-0.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.11.dev23
+Version: 0.1.12
 Summary: Main Sequence MetaTables Python client and standalone API
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence_metatable-0.1.11.dev23 → mainsequence_metatable-0.1.12}/docs/adr/api/0001-unified-api-storage-and-local-sqlite.md

@@ -732,8 +732,12 @@ Both SQLite catalog mutations and table writes use explicit `BEGIN IMMEDIATE`
 transactions with foreign-key enforcement and a 30-second connection busy timeout.
 Bounded physical operations select a 5-second lock timeout. The
 catalog uses WAL. Application DDL uses the same Alembic reservation/finalization
-workflow as PostgreSQL. SQLite rejects named schemas, exact decimal, unsigned
-64-bit integer, array, PostgreSQL JSONB, and specialized index contracts.
+workflow as PostgreSQL. SQLite rejects named schemas, unsigned 64-bit integer,
+array, and specialized index contracts, naming the column or index. PostgreSQL
+JSONB is stored as JSON, and NUMERIC as SQLite numbers exact to about 15
+significant digits, the precision the client's float64 frames already carry.
+Revisions written for PostgreSQL run unchanged: column and constraint changes use
+Alembic batch mode, with foreign keys checked before commit.
 Timestamps require UTC offsets and preserve microseconds; finer precision is
 rejected rather than truncated. UUID coordinate filters use the same contract
 conversion for reads and deletes.

{mainsequence_metatable-0.1.11.dev23 → mainsequence_metatable-0.1.12}/docs/operations/local-runtime.md

@@ -144,6 +144,23 @@ updates and governed SQL within its dialect. PostgreSQL-specific SQL, database r
 Timescale hypertables and policies are unavailable. Select expressions and writes must
 use the API-advertised dialect; SQL is not translated between engines.
 
+Application models keep their hosted column types. A PostgreSQL `JSONB` column is
+created and decoded as JSON. `Numeric` columns are SQLite numbers, exact to about 15
+significant digits; reads return `Decimal`, and the client's frames carry them as
+float64 on every engine. Unsigned 64-bit integers and arrays have no SQLite type:
+registration rejects them with `unsupported_sqlite_type`, naming the table and
+column.
+
+Application revisions written for PostgreSQL run unchanged. SQLite cannot alter
+columns or constraints in place, so the migration environment runs `alter_column`,
+`add_column`, `drop_column` and constraint operations through Alembic batch mode,
+which copies the table and swaps it in. Foreign keys are not enforced while the
+revisions run; `PRAGMA foreign_key_check` runs before commit and rolls back every
+revision if a key dangles. A `postgresql_where` predicate also becomes the SQLite
+partial-index predicate. Generated revisions use batch blocks, which PostgreSQL
+applies as plain `ALTER` statements. Raw PostgreSQL SQL, such as `ctid`, `::` casts
+or `jsonb_*` functions, must branch on `op.get_bind().dialect.name`.
+
 The SQLite adapter shares the request's transaction for catalog and physical work.
 Physical savepoints preserve rollback semantics and avoid two writers competing for
 the same file. Application migration connections are blocked; see the

{mainsequence_metatable-0.1.11.dev23 → mainsequence_metatable-0.1.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence-metatable"
-version = "0.1.11.dev23"
+version = "0.1.12"
 description = "Main Sequence MetaTables Python client and standalone API"
 readme = "README.md"
 requires-python = ">=3.13"

{mainsequence_metatable-0.1.11.dev23 → mainsequence_metatable-0.1.12/src/mainsequence_metatable.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.11.dev23
+Version: 0.1.12
 Summary: Main Sequence MetaTables Python client and standalone API
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence_metatable-0.1.11.dev23 → mainsequence_metatable-0.1.12}/src/mainsequence_metatable.egg-info/SOURCES.txt

@@ -392,6 +392,7 @@ src/metatables/migrations/provider.py
 src/metatables/migrations/registry.py
 src/metatables/migrations/runner.py
 src/metatables/migrations/scaffold.py
+src/metatables/migrations/sqlite.py
 src/metatables/migrations/tls.py
 src/metatables/migrations/templates/__init__.py
 src/metatables/migrations/templates/env.py.mako

{mainsequence_metatable-0.1.11.dev23 → mainsequence_metatable-0.1.12}/src/metatables/api/app/routes/table_registration.py

@@ -161,7 +161,9 @@ def _registration(payload, *, indexed, actor, session, sources, creator, introsp
 def _failure(session, exc):
     session.rollback()
     if isinstance(exc, DataSourceAdmissionError):
-        raise HTTPException(exc.status_code, exc.code) from exc
+        # Contract rejections name the offending column or index, as contract validation does.
+        detail = exc.code if exc.field == "data_source" else {"code": exc.code, "field": exc.field, "message": str(exc)}
+        raise HTTPException(exc.status_code, detail) from exc
     if isinstance(exc, (DataSourceIntegrationError, PhysicalConnectionUnavailable, PhysicalTableOutcomeUnknown, SQLAlchemyError)):
         raise HTTPException(503, 'Catalog or DataSource is unavailable.') from exc
     raise HTTPException(409 if isinstance(exc, (PhysicalTableError, PhysicalIntrospectionError, TimescaleError)) else 422,

{mainsequence_metatable-0.1.11.dev23 → mainsequence_metatable-0.1.12}/src/metatables/api/backend/backends/adapters/sqlite_connection.py

@@ -12,6 +12,7 @@ import time
 from collections import namedtuple
 from contextlib import contextmanager
 from datetime import date, datetime, timezone
+from decimal import Decimal
 from uuid import UUID
 
 from psycopg2 import sql
@@ -63,6 +64,11 @@ def bind_value(value):
         return json.dumps(value.adapted, separators=(",", ":"), allow_nan=False)
     if isinstance(value, (dict, list)):
         return json.dumps(value, separators=(",", ":"), allow_nan=False)
+    if isinstance(value, Decimal):
+        # SQLite stores NUMERIC as INTEGER or REAL; keep integral values exact.
+        if value == value.to_integral_value() and -(2**63) <= value < 2**63:
+            return int(value)
+        return float(value)
     return value
 
 
@@ -178,6 +184,8 @@ def register_converters():
     sqlite3.register_converter("BOOLEAN", lambda v: v == b"1")
     sqlite3.register_converter("JSON", lambda v: json.loads(v.decode()))
     sqlite3.register_converter("DATE", lambda v: date.fromisoformat(v.decode()))
+    sqlite3.register_converter("NUMERIC", lambda v: Decimal(v.decode()))
+    sqlite3.register_converter("DECIMAL", lambda v: Decimal(v.decode()))
 
 
 @contextmanager

{mainsequence_metatable-0.1.11.dev23 → mainsequence_metatable-0.1.12}/src/metatables/api/backend/backends/adapters/sqlite_introspection.py

@@ -41,7 +41,9 @@ def introspect_sqlite_table(*, source, physical_schema, physical_table_name):
                     "INTEGER": "int64",
                     "JSON": "json",
                     "DATE": "date",
-                }.get(backend, "string")
+                    "NUMERIC": "numeric",
+                    "DECIMAL": "numeric",
+                }.get(backend.split("(", 1)[0].strip(), "string")
                 columns.append(
                     {
                         "name": item["name"],
@@ -118,20 +120,27 @@ def validate_sqlite_contract(contract):
     """Reject unsupported DDL before reserving catalog state or opening a store."""
     from metatables.api.backend.domain.data_source_rules import DataSourceAdmissionError
 
-    normalize_schema((contract.get("physical") or {}).get("schema"))
+    physical = contract.get("physical") or {}
+    normalize_schema(physical.get("schema"))
+    table = physical.get("table_name") or "the table"
+    # JSONB is stored as JSON and NUMERIC as SQLite numbers (about 15 significant
+    # digits, the precision the client's float64 frames already carry).
     for column in contract.get("columns", []):
         kind = str(column.get("data_type", "")).lower()
         backend = str(column.get("backend_type") or "").lower()
-        if kind in {"numeric", "decimal", "uint64"} or any(
-            t in backend for t in ("numeric", "decimal", "[]", "jsonb")
-        ):
+        if kind == "uint64" or "[]" in backend:
             raise DataSourceAdmissionError(
                 "unsupported_sqlite_type",
-                "SQLite does not support exact decimal, unsigned 64-bit integers, arrays, or PostgreSQL JSONB contracts.",
+                f"Column {column.get('name')!r} of {table} is {column.get('backend_type') or kind}; "
+                "SQLite has no unsigned 64-bit integer or array type.",
                 status_code=409,
+                field=f"table_contract.columns.{column.get('name')}",
             )
     for index in contract.get("indexes", []):
         if index.get("method") not in (None, "", "btree") or index.get("expression"):
             raise DataSourceAdmissionError(
-                "unsupported_sqlite_index", "SQLite supports column indexes only.", status_code=409
+                "unsupported_sqlite_index",
+                f"Index {index.get('name')!r} of {table} is not a column index; SQLite supports column indexes only.",
+                status_code=409,
+                field=f"table_contract.indexes.{index.get('name')}",
             )

{mainsequence_metatable-0.1.11.dev23 → mainsequence_metatable-0.1.12}/src/metatables/migrations/connection.py

@@ -6,6 +6,7 @@ from sqlalchemy import create_engine, event
 from sqlalchemy.engine import make_url
 from sqlalchemy.pool import NullPool
 
+from . import sqlite as _sqlite  # noqa: F401  Registers SQLite DDL and batch rules.
 from .tls import migration_tls_arguments
 
 
@@ -42,7 +43,9 @@ def migration_engine(config):
                 @event.listens_for(engine, "connect")
                 def sqlite_connect(connection, _record):
                     connection.isolation_level = None
-                    connection.execute("PRAGMA foreign_keys = ON")
+                    # Batch rebuilds drop and recreate referenced tables; the
+                    # environment runs PRAGMA foreign_key_check before commit.
+                    connection.execute("PRAGMA foreign_keys = OFF")
                     connection.execute("PRAGMA busy_timeout = 30000")
 
                 @event.listens_for(engine, "begin")

{mainsequence_metatable-0.1.11.dev23 → mainsequence_metatable-0.1.12}/src/metatables/migrations/env.py

@@ -15,6 +15,7 @@ def run_mainsequence_alembic_env(
 
     from metatables.migrations import apply_mainsequence_migration_role
     from metatables.migrations.connection import migration_engine
+    from metatables.migrations.sqlite import AUTO_BATCH_OPTION, check_foreign_keys
 
     def migration_provider() -> Any:
         provider = context.config.attributes.get("mainsequence_migration_provider")
@@ -78,8 +79,18 @@ def run_mainsequence_alembic_env(
             "include_object": include_object,
             "compare_type": True,
             "compare_server_default": True,
+            # Generated revisions alter tables in batch blocks: plain ALTERs on
+            # PostgreSQL, copy-and-swap on the local SQLite runtime.
+            "render_as_batch": True,
+            AUTO_BATCH_OPTION: connection is not None and connection.dialect.name == "sqlite",
         }
 
+    def run(connection) -> None:
+        with context.begin_transaction():
+            context.run_migrations()
+            if connection.dialect.name == "sqlite":
+                check_foreign_keys(connection)
+
     def run_migrations_offline() -> None:
         context.configure(
             url=context.config.get_main_option("sqlalchemy.url"),
@@ -95,16 +106,14 @@ def run_mainsequence_alembic_env(
         if connection is not None:
             apply_mainsequence_migration_role(connection, config)
             context.configure(connection=connection, **configure_kwargs(connection))
-            with context.begin_transaction():
-                context.run_migrations()
+            run(connection)
             return
 
         config.attributes.setdefault("mainsequence_migration_provider", migration_provider())
         with migration_engine(config) as engine, engine.connect() as connection:
             apply_mainsequence_migration_role(connection, config)
             context.configure(connection=connection, **configure_kwargs(connection))
-            with context.begin_transaction():
-                context.run_migrations()
+            run(connection)
 
     if context.is_offline_mode():
         run_migrations_offline()

mainsequence_metatable-0.1.12/src/metatables/migrations/sqlite.py

@@ -0,0 +1,82 @@
+"""Run application revisions written for PostgreSQL on the local SQLite runtime.
+
+SQLite cannot alter columns or constraints in place. Inside the MetaTables
+Alembic environment, those operations run through Alembic batch mode (copy the
+table, then swap it in), so revisions need no SQLite-specific code. PostgreSQL
+and other dialects keep Alembic's own implementations.
+"""
+
+from __future__ import annotations
+
+from alembic.operations import BatchOperations, Operations, ops
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.ext.compiler import compiles
+
+AUTO_BATCH_OPTION = "metatables_sqlite_auto_batch"
+
+
+@compiles(JSONB, "sqlite")
+def _sqlite_jsonb(_type, _compiler, **_kw):
+    # Applications declare PostgreSQL JSONB; the local runtime stores and
+    # decodes it as JSON, so models and reflected columns compare equal.
+    return "JSON"
+
+
+def _table(operation):
+    if isinstance(operation, ops.CreateForeignKeyOp):
+        return operation.source_table, operation.kw.get("source_schema")
+    return operation.table_name, operation.schema
+
+
+def _batched(default):
+    def run(operations, operation):
+        if (
+            isinstance(operations, BatchOperations)
+            or not operations.migration_context.opts.get(AUTO_BATCH_OPTION)
+        ):
+            return default(operations, operation)
+        connection = operations.migration_context.connection
+        if connection.exec_driver_sql("PRAGMA foreign_keys").scalar():
+            # Rebuilding a parent table with enforcement on deletes or rejects
+            # its children; the environment checks every key after migrating.
+            raise RuntimeError("SQLite batch migrations require foreign_keys=OFF.")
+        name, schema = _table(operation)
+        with operations.batch_alter_table(name, schema=None if schema == "public" else schema) as batch:
+            batch.invoke(operation)
+
+    return run
+
+
+def _partial_index(default):
+    def run(operations, operation):
+        # Portable predicates such as "status = 'active'" keep the index partial.
+        if operations.migration_context.opts.get(AUTO_BATCH_OPTION):
+            kw = operation.kw
+            if "postgresql_where" in kw and "sqlite_where" not in kw:
+                kw["sqlite_where"] = kw["postgresql_where"]
+        return default(operations, operation)
+
+    return run
+
+
+for _operation in (
+    ops.AlterColumnOp,
+    ops.AddColumnOp,
+    ops.DropColumnOp,
+    ops.AddConstraintOp,
+    ops.DropConstraintOp,
+):
+    Operations._to_impl.dispatch_for(_operation, qualifier="sqlite")(
+        _batched(Operations._to_impl.dispatch(_operation))
+    )
+Operations._to_impl.dispatch_for(ops.CreateIndexOp, qualifier="sqlite")(
+    _partial_index(Operations._to_impl.dispatch(ops.CreateIndexOp))
+)
+
+
+def check_foreign_keys(connection) -> None:
+    """Fail the migration transaction when a revision left a dangling key."""
+    violations = connection.exec_driver_sql("PRAGMA foreign_key_check").fetchall()
+    if violations:
+        tables = sorted({str(row[0]) for row in violations})
+        raise RuntimeError(f"Migration left foreign-key violations in: {', '.join(tables)}.")

{mainsequence_metatable-0.1.11.dev23 → mainsequence_metatable-0.1.12}/tests/contracts/capabilities.json

@@ -2854,7 +2854,7 @@
       "hidden": false,
       "note": "Offline client skill copying delegated to the SDK scaffold helper; bundles matching guide/example resources, supports dry-run and global JSON output, and records the installed version.",
       "tests": [
-        "tests/packaging/test_client_skills.py::test_copy_and_refresh_preserve_other_namespaces_and_deliver_portable_references",
+        "tests/packaging/test_client_skills.py::test_copy_and_refresh_replace_only_the_metatables_namespace_with_portable_references",
         "tests/packaging/test_client_skills.py::test_dry_run_reports_version_and_destinations_without_creating_project",
         "tests/packaging/test_installed_distribution.py::test_client_skills_copy_from_installed_bundle_outside_checkout"
       ]

{mainsequence_metatable-0.1.11.dev23 → mainsequence_metatable-0.1.12}/tests/integrations/test_sqlite_operations.py

@@ -103,12 +103,107 @@ def test_serialized_writers_and_failed_replacement_preserve_existing_rows(sqlite
 def test_sqlite_rejects_unrepresentable_contracts_before_effects():
     for contract in (
         {"physical": {"schema": "analytics"}},
-        {"columns": [{"name": "exact", "data_type": "numeric"}]},
+        {"columns": [{"name": "unsigned", "data_type": "uint64"}]},
         {"columns": [{"name": "array", "backend_type": "INTEGER[]"}]},
         {"indexes": [{"name": "special", "method": "gin"}]},
     ):
         with pytest.raises(DataSourceAdmissionError):
             validate_sqlite_contract(contract)
+    with pytest.raises(DataSourceAdmissionError) as rejected:
+        validate_sqlite_contract({"physical": {"table_name": "positions"},
+                                  "columns": [{"name": "lots", "backend_type": "INTEGER[]"}]})
+    assert rejected.value.field == "table_contract.columns.lots"
+    assert "'lots'" in str(rejected.value) and "positions" in str(rejected.value)
+
+
+def test_sqlite_runs_postgresql_jsonb_as_json_and_numeric_as_numbers(sqlite_source):
+    source, engine = sqlite_source
+    from decimal import Decimal
+
+    from alembic.autogenerate import compare_metadata
+    from alembic.migration import MigrationContext
+    from sqlalchemy import Column, Integer, MetaData, Numeric, Table
+    from sqlalchemy.dialects.postgresql import JSONB
+
+    import metatables.migrations.sqlite  # noqa: F401  Registers the SQLite JSONB rule.
+    from metatables.api.backend.backends.adapters.sqlite_introspection import (
+        introspect_sqlite_table,
+    )
+
+    columns = [{"name": "payload", "data_type": "jsonb", "backend_type": "JSONB"},
+               {"name": "amount", "data_type": "numeric", "backend_type": "NUMERIC(38, 18)"}]
+    validate_sqlite_contract({"columns": columns})
+    metadata = MetaData()
+    Table("typed_numbers", metadata, Column("id", Integer, primary_key=True),
+          Column("payload", JSONB()), Column("amount", Numeric(38, 18)))
+    with engine.begin() as connection:
+        metadata.create_all(connection)
+        context = MigrationContext.configure(connection, opts={
+            "compare_type": True,
+            "include_name": lambda name, kind, _parents: kind != "table" or name == "typed_numbers",
+        })
+        assert compare_metadata(context, metadata) == []
+    snapshot = introspect_sqlite_table(source=source, physical_schema="public",
+                                       physical_table_name="typed_numbers")
+    assert {c["name"]: (c["data_type"], c["backend_type"]) for c in snapshot["columns"]} == {
+        "id": ("int64", "INTEGER"), "payload": ("json", "JSON"), "amount": ("numeric", "NUMERIC(38, 18)")}
+    inserted = execute_fixture_sql(
+        source=source,
+        operation="insert",
+        sql_text="INSERT INTO typed_numbers (id, payload, amount) VALUES (1, :payload, :amount), (2, NULL, :whole) RETURNING *",
+        parameters={"payload": {"nodes": [0.5, 1]}, "amount": Decimal("1234.000125"), "whole": Decimal("100")},
+    )["rows"]
+    assert inserted[0]["payload"] == {"nodes": [0.5, 1]}
+    assert Decimal(str(inserted[0]["amount"])) == Decimal("1234.000125")
+    selected = execute_fixture_sql(source=source, sql_text="SELECT id FROM typed_numbers WHERE amount > :limit ORDER BY amount",
+                                   parameters={"limit": Decimal("99.5")})["rows"]
+    assert [row["id"] for row in selected] == [2, 1]
+
+
+def test_postgresql_style_alter_revisions_run_through_sqlite_batch_mode(tmp_path):
+    from alembic.migration import MigrationContext
+    from alembic.operations import Operations
+    from sqlalchemy import Column, Integer, String, event, text
+
+    from metatables.migrations.sqlite import AUTO_BATCH_OPTION, check_foreign_keys
+
+    engine = create_engine(f"sqlite:///{tmp_path / 'batch.sqlite'}")
+    event.listen(engine, "connect", lambda raw, _record: raw.execute("PRAGMA foreign_keys = OFF"))
+    with engine.begin() as connection:
+        connection.exec_driver_sql("CREATE TABLE parent (id INTEGER PRIMARY KEY, code TEXT)")
+        connection.exec_driver_sql("CREATE TABLE child (id INTEGER PRIMARY KEY, parent_id INTEGER, "
+                                   "CONSTRAINT fk_child_parent FOREIGN KEY (parent_id) REFERENCES parent (id) ON DELETE CASCADE)")
+        connection.exec_driver_sql("INSERT INTO parent VALUES (1, 'a'), (2, 'b')")
+        connection.exec_driver_sql("INSERT INTO child VALUES (10, 1), (11, 2)")
+        op = Operations(MigrationContext.configure(connection, opts={AUTO_BATCH_OPTION: True}))
+        # The same calls a PostgreSQL revision makes; none of them is native SQLite DDL.
+        op.add_column("parent", Column("status", String(), nullable=True))
+        op.alter_column("parent", "code", existing_type=String(), nullable=False)
+        op.create_unique_constraint("uq_parent_code", "parent", ["code"])
+        op.drop_constraint("fk_child_parent", "child", type_="foreignkey")
+        op.create_foreign_key("fk_child_parent_restrict", "child", "parent", ["parent_id"], ["id"])
+        op.alter_column("child", "parent_id", existing_type=Integer(), nullable=False)
+        op.create_index("ix_parent_active", "parent", ["status"], unique=True,
+                        postgresql_where=text("status = 'active'"))
+        check_foreign_keys(connection)
+        inspector = inspect(connection)
+        assert [fk["name"] for fk in inspector.get_foreign_keys("child")] == ["fk_child_parent_restrict"]
+        assert [c["nullable"] for c in inspector.get_columns("child") if c["name"] == "parent_id"] == [False]
+        assert [u["name"] for u in inspector.get_unique_constraints("parent")] == ["uq_parent_code"]
+        index = next(i for i in inspector.get_indexes("parent") if i["name"] == "ix_parent_active")
+        assert str(index["dialect_options"]["sqlite_where"]) == "status = 'active'"
+        # Rebuilding the parent kept every child row instead of cascading.
+        assert connection.exec_driver_sql("SELECT id, parent_id FROM child ORDER BY id").all() == [(10, 1), (11, 2)]
+        connection.exec_driver_sql("INSERT INTO child VALUES (12, 99)")
+        with pytest.raises(RuntimeError, match="child"):
+            check_foreign_keys(connection)
+        connection.exec_driver_sql("DELETE FROM child WHERE id = 12")
+    with engine.connect() as connection:
+        connection.exec_driver_sql("PRAGMA foreign_keys = ON")
+        with pytest.raises(RuntimeError, match="foreign_keys=OFF"):
+            Operations(MigrationContext.configure(connection, opts={AUTO_BATCH_OPTION: True})).add_column(
+                "parent", Column("note", String()))
+    engine.dispose()
 
 
 def test_sub_microsecond_timestamps_fail_before_serialization():

{mainsequence_metatable-0.1.11.dev23 → mainsequence_metatable-0.1.12}/uv.lock

@@ -632,7 +632,7 @@ server = [
 
 [[package]]
 name = "mainsequence-metatable"
-version = "0.1.11"
+version = "0.1.12"
 source = { editable = "." }
 dependencies = [
     { name = "alembic" },