mainsequence-metatable 0.1.60.dev91__tar.gz → 0.1.61__tar.gz

{mainsequence_metatable-0.1.60.dev91/src/mainsequence_metatable.egg-info → mainsequence_metatable-0.1.61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.60.dev91
+Version: 0.1.61
 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.60.dev91 → mainsequence_metatable-0.1.61}/pyproject.toml

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

{mainsequence_metatable-0.1.60.dev91 → mainsequence_metatable-0.1.61/src/mainsequence_metatable.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.60.dev91
+Version: 0.1.61
 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.60.dev91 → mainsequence_metatable-0.1.61}/src/mainsequence_metatable.egg-info/SOURCES.txt

@@ -583,6 +583,7 @@ tests/integrations/test_postgresql_time_index_queries.py
 tests/integrations/test_request_timing.py
 tests/integrations/test_serving_policy.py
 tests/integrations/test_source_validation.py
+tests/integrations/test_sqlite_expanded_in.py
 tests/integrations/test_sqlite_operations.py
 tests/integrations/test_sqlite_statement_lists.py
 tests/labels/test_labels.py

{mainsequence_metatable-0.1.60.dev91 → mainsequence_metatable-0.1.61}/src/metatables/compiled_sql/v1.py

@@ -173,20 +173,27 @@ def _compile(
     )
     parameter_types = _compiled_sqlalchemy_parameter_types(compiled)
     parameters = dict(compiled.params)
+    # render_postcompile renames each IN value: uid_1 becomes uid_1_1, uid_1_2, ...
+    # SQLAlchemy's expanded state names them and their processors (MetaTables #100).
+    expanded = compiled.construct_expanded_state()
+    bind_types = dict(_rendered_bind_types(compiled, expanded.parameter_expansion))
     # Values bound to an EncryptedString leave the process encrypted on every dialect (ADR 0025).
     from metatables.encryption import EncryptedString
-    for name, bind in getattr(compiled, "binds", {}).items():
-        if isinstance(bind.type, EncryptedString) and name in parameters:
-            parameters[name] = bind.type.process_bind_param(parameters[name], compiled.dialect)
+    for name, bind_type in bind_types.items():
+        if isinstance(bind_type, EncryptedString) and name in parameters:
+            parameters[name] = bind_type.process_bind_param(parameters[name], compiled.dialect)
     if dialect in {"sqlite", "mysql", "mssql"}:
         from datetime import datetime, timezone
-        for name, processor in compiled._bind_processors.items():
+        processors = {**compiled._bind_processors, **expanded.processors}
+        for name, processor in processors.items():
             if name in parameters:
                 value = parameters[name]
                 if isinstance(value, datetime):
                     if value.tzinfo is None:
                         raise ValueError("Timestamps require a UTC offset.")
                     value = value.astimezone(timezone.utc)
+                elif isinstance(value, str) and _binds_uuid_objects(bind_types.get(name)):
+                    value = _uuid_from_text(name, value)
                 parameters[name] = value if isinstance(value, datetime) else processor(value)
 
     if paramstyle == "qmark":
@@ -286,6 +293,41 @@ def compile_sqlalchemy_statements(
     )
 
 
+def _binds_uuid_objects(bind_type: Any) -> bool:
+    """A plain ``Uuid(as_uuid=True)``, whose SQLite and MySQL processor needs ``uuid.UUID``."""
+    from sqlalchemy import Uuid
+
+    return isinstance(bind_type, Uuid) and bool(bind_type.as_uuid)
+
+
+def _uuid_from_text(name: str, value: str):
+    """Accept a UUID written as text, as PostgreSQL does (MetaTables #101)."""
+    from uuid import UUID
+
+    try:
+        return UUID(value)
+    except ValueError:
+        raise ValueError(
+            f"Parameter {name!r} binds a Uuid column, but {value!r} is not a UUID."
+        ) from None
+
+
+def _rendered_bind_types(compiled: Any, expansion: Mapping[str, Sequence[str]]):
+    """Each rendered parameter's name with its bind's type, expanded IN values included.
+
+    A tuple IN expands row by row, one parameter per element, each with its element's type.
+    """
+    from sqlalchemy.sql.sqltypes import TupleType
+
+    for bind, name in compiled.bind_names.items():
+        if name not in expansion:
+            yield name, bind.type
+            continue
+        types = bind.type.types if isinstance(bind.type, TupleType) else (bind.type,)
+        for index, rendered in enumerate(expansion[name]):
+            yield rendered, types[index % len(types)]
+
+
 def _compiled_sqlalchemy_parameter_types(compiled: Any) -> dict[str, str]:
     parameter_types: dict[str, str] = {}
     bind_names = getattr(compiled, "bind_names", {}) or {}

{mainsequence_metatable-0.1.60.dev91 → mainsequence_metatable-0.1.61}/tests/contracts/test_encryption.py

@@ -188,6 +188,25 @@ def test_compiled_statements_carry_envelopes_on_every_dialect(keyrings):
         assert any(is_envelope(value) for value in values)
 
 
+def test_values_of_an_in_list_leave_encrypted_on_every_dialect(keyrings):
+    """IN values render as api_key_1_1, api_key_1_2, ...; each is sealed (MetaTables #100)."""
+    from sqlalchemy import select
+
+    from metatables.compiled_sql.v1 import compile_sqlalchemy_statement
+
+    physical = Account.__table__
+    statement = select(physical.c.uid).where(physical.c.api_key.in_(["hunter2", "swordfish"]))
+    for dialect in ("postgresql", "sqlite", "mysql", "mssql"):
+        operation = compile_sqlalchemy_statement(
+            statement, operation="select", data_source_uid="00000000-0000-0000-0000-000000000001",
+            dialect=dialect,
+        )
+        parameters = operation.statement.parameters
+        values = parameters if isinstance(parameters, list) else list(parameters.values())
+        assert len(values) == 2 and all(is_envelope(value) for value in values), (dialect, values)
+        assert "hunter2" not in json.dumps(values) and "swordfish" not in json.dumps(values)
+
+
 @pytest.mark.parametrize("definition, message", [
     ("Column(Integer, primary_key=True)", "primary key"),
     ("Column(unique=True)", "unique"),

mainsequence_metatable-0.1.61/tests/integrations/test_sqlite_expanded_in.py

@@ -0,0 +1,108 @@
+"""IN lists and text UUIDs bind like equality on the local SQLite backend.
+
+render_postcompile renames each IN value (uid_1 becomes uid_1_1, uid_1_2, ...); the
+compiler must still run each value through its column type's bind processor
+(MetaTables #100). A UUID written as text binds like a ``uuid.UUID``, as PostgreSQL
+accepts it (MetaTables #101).
+"""
+
+import sqlite3
+import uuid
+
+import pytest
+from mainsequence.code_repository_context import GitCodeRepositorySourceContext
+from sqlalchemy import Boolean, Column, Integer, MetaData, Table, Uuid, insert, select, tuple_
+
+from metatables import MetaTableCompiledSQLOperation
+from metatables.api.backend.backends.access import ExecutionIdentity
+from metatables.api.backend.backends.registry import backend_for
+from metatables.api.backend.integrations.local_workspace import select_local_workspace
+from metatables.compiled_sql.v1 import compile_sqlalchemy_statement
+
+item = Table(
+    "item", MetaData(),
+    Column("uid", Uuid(as_uuid=True), primary_key=True),
+    Column("active", Boolean, nullable=False),
+    Column("rank", Integer, nullable=False),
+)
+FIRST = uuid.UUID("95dcdfeb-f8c0-4b33-b942-4ecc3fc73431")
+SECOND = uuid.UUID("0b8a3c1e-4f2d-4e6a-9c7b-1d2e3f405162")
+MISSING = uuid.UUID("11111111-2222-4333-8444-555555555555")
+
+
+@pytest.fixture
+def run(tmp_path):
+    context = GitCodeRepositorySourceContext(tmp_path, "https://example.test/repo", "test", "refs/heads/test", "a" * 40)
+    workspace = select_local_workspace(source=context, values={"METATABLES_LOCAL_STORAGE_DIR": str(tmp_path)})
+    workspace.tables_path.parent.mkdir(parents=True, exist_ok=True)
+    with sqlite3.connect(workspace.tables_path) as raw:
+        # How SQLAlchemy stores sa.Uuid and sa.Boolean on SQLite: 32-hex text and 0/1.
+        raw.execute("CREATE TABLE item (uid CHAR(32) PRIMARY KEY, active BOOLEAN NOT NULL, rank INTEGER NOT NULL)")
+    backend = backend_for(workspace.data_source)
+    tables = frozenset({("main", "item")})
+    identity = ExecutionIdentity(uuid.uuid4(), "fixture", None, tables, tables)
+
+    def run(statement, operation="select"):
+        compiled = compile_sqlalchemy_statement(
+            statement, operation=operation, data_source_uid=str(workspace.data_source.uid), dialect="sqlite"
+        )
+        wire = MetaTableCompiledSQLOperation.model_validate_json(compiled.model_dump_json())  # What the API receives.
+        return backend.sql.execute(
+            identity=identity, sql_text=wire.statement.sql, operation=wire.operation,
+            parameters=wire.statement.parameters, parameter_types=wire.statement.parameter_types,
+        )["rows"]
+
+    run(insert(item).values([dict(uid=FIRST, active=True, rank=1), dict(uid=SECOND, active=False, rank=2)]),
+        operation="insert")
+    return run
+
+
+def ranks(rows):
+    return sorted(row["rank"] for row in rows)
+
+
+def test_uuid_in_finds_what_equality_finds(run):
+    assert ranks(run(select(item.c.rank).where(item.c.uid == FIRST))) == [1]
+    assert ranks(run(select(item.c.rank).where(item.c.uid.in_([FIRST])))) == [1]
+    assert ranks(run(select(item.c.rank).where(item.c.uid.in_([FIRST, SECOND, MISSING])))) == [1, 2]
+    assert ranks(run(select(item.c.rank).where(item.c.uid.not_in([FIRST])))) == [2]
+
+
+def test_boolean_in_binds_as_stored(run):
+    assert ranks(run(select(item.c.rank).where(item.c.active.in_([True])))) == [1]
+    assert ranks(run(select(item.c.rank).where(item.c.active.in_([True, False])))) == [1, 2]
+
+
+def test_tuple_in_binds_each_element_with_its_type(run):
+    statement = select(item.c.rank).where(tuple_(item.c.uid, item.c.active).in_([(FIRST, True), (SECOND, True)]))
+    assert ranks(run(statement)) == [1]
+
+
+def test_in_binds_in_writes_too(run):
+    run(item.update().where(item.c.uid.in_([SECOND])).values(rank=20), operation="update")
+    run(item.delete().where(item.c.uid.in_([FIRST])), operation="delete")
+    assert ranks(run(select(item.c.rank))) == [20]
+
+
+@pytest.mark.parametrize("value", [str(FIRST), FIRST.hex, str(FIRST).upper(), FIRST])
+def test_a_uuid_as_text_or_object_finds_the_row(run, value):
+    assert ranks(run(select(item.c.rank).where(item.c.uid == value))) == [1]
+    assert ranks(run(select(item.c.rank).where(item.c.uid.in_([value, str(SECOND)])))) == [1, 2]
+    assert ranks(run(select(item.c.rank).where(item.c.uid.in_([value, MISSING])))) == [1]
+
+
+def test_text_uuids_write_and_read_back_like_uuid_objects(run):
+    added = "6f1c2b3a-4d5e-4f60-8a7b-9c0d1e2f3a4b"
+    run(insert(item).values(uid=added, active=True, rank=3), operation="insert")
+    assert ranks(run(select(item.c.rank).where(item.c.uid == uuid.UUID(added)))) == [3]
+    run(item.update().where(item.c.uid.in_([added])).values(rank=30), operation="update")
+    assert ranks(run(select(item.c.rank).where(item.c.uid == added))) == [30]
+
+
+@pytest.mark.parametrize("statement, name", [
+    (select(item.c.rank).where(item.c.uid == "not-a-uuid"), "uid_1"),
+    (select(item.c.rank).where(item.c.uid.in_([str(FIRST), "not-a-uuid"])), "uid_1_2"),
+])
+def test_text_that_is_not_a_uuid_fails_naming_its_parameter(run, statement, name):
+    with pytest.raises(ValueError, match=f"Parameter '{name}' binds a Uuid column, but 'not-a-uuid' is not a UUID"):
+        run(statement)

{mainsequence_metatable-0.1.60.dev91 → mainsequence_metatable-0.1.61}/uv.lock

@@ -855,7 +855,7 @@ mcp = [
 
 [[package]]
 name = "mainsequence-metatable"
-version = "0.1.60"
+version = "0.1.61"
 source = { editable = "." }
 dependencies = [
     { name = "alembic" },