mainsequence-metatable 0.1.14__tar.gz → 0.1.15.dev27__tar.gz

{mainsequence_metatable-0.1.14 → mainsequence_metatable-0.1.15.dev27}/.agents/skills/client/metatables-meta-tables/SKILL.md

@@ -80,6 +80,25 @@ the time name for updater compatibility. The mixin automatically creates the
 unique index for the full grain; add only additional lookup indexes. Declare
 `__cadence__` when the stable observation interval is known.
 
+The default storage layout names its lookup index by joining the identity
+columns (`__index_names__[1:]`) with `_`. MetaTables never shortens that name: if
+it exceeds 63 characters, registration raises and names the model. Declare an
+explicit `__storage_layout__` with a short `secondary_indexes[0].name` (at most
+59 characters, leaving room for the `_idx` suffix); the other fields must restate
+the grain:
+
+```python
+__storage_layout__ = {
+    "version": 1,
+    "time_index": {"name": "time_index"},
+    "identity_dimensions": DIMENSIONS,  # __index_names__[1:]
+    "index_progress": {"grain": DIMENSIONS},
+    "uniqueness": {"columns": ["time_index", *DIMENSIONS]},
+    "tail_delete": {"scope_dimensions": DIMENSIONS},
+    "secondary_indexes": [{"name": "portfolio_event_lookup", "columns": DIMENSIONS}],
+}
+```
+
 Physical names remain stable across schema changes. Evolve through new Alembic
 revisions; do not recompute identity from columns or rewrite applied history.
 

{mainsequence_metatable-0.1.14/src/mainsequence_metatable.egg-info → mainsequence_metatable-0.1.15.dev27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.14
+Version: 0.1.15.dev27
 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.14 → mainsequence_metatable-0.1.15.dev27}/pyproject.toml

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

{mainsequence_metatable-0.1.14 → mainsequence_metatable-0.1.15.dev27}/scripts/check_boundaries.py

@@ -22,7 +22,8 @@ SDK_MODULES = frozenset({
     'mainsequence.instrumentation', 'mainsequence.logconf', 'mainsequence.server.caller_assertions',
 })
 SHARED_MODULES = frozenset({'metatables.local_connection', 'metatables.local_files', 'metatables.sdk_compat', 'metatables.update_configuration_contract',
-                           'metatables.transfer_contract', 'metatables.runtime_contract', 'metatables.log_contract', 'metatables.local_run_logs'})
+                           'metatables.transfer_contract', 'metatables.runtime_contract', 'metatables.log_contract', 'metatables.local_run_logs',
+                           'metatables.storage_layout_contract'})
 # Read-only platform provenance for initialization and endpoint discovery. These exact
 # identifiers are allowed only at the SDK admission/display/discovery boundary; catalog
 # models, constraints and storage policy remain forbidden from owning them.

{mainsequence_metatable-0.1.14 → mainsequence_metatable-0.1.15.dev27/src/mainsequence_metatable.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.14
+Version: 0.1.15.dev27
 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.14 → mainsequence_metatable-0.1.15.dev27}/src/mainsequence_metatable.egg-info/SOURCES.txt

@@ -158,6 +158,7 @@ src/metatables/runtime_contract.py
 src/metatables/schema_names.py
 src/metatables/sdk_compat.py
 src/metatables/sqlalchemy_contracts.py
+src/metatables/storage_layout_contract.py
 src/metatables/time_index_table_refs.py
 src/metatables/transfer.py
 src/metatables/transfer_contract.py

{mainsequence_metatable-0.1.14 → mainsequence_metatable-0.1.15.dev27}/src/metatables/api/app/routes/table_registration.py

@@ -23,6 +23,7 @@ from metatables.api.backend.backends.operations import (
     create_physical_table,
 )
 from metatables.api.backend.backends.timescale import TimescaleError, convert_time_index_table
+from metatables.api.backend.contracts.storage_layouts import StorageLayoutValidationError
 from metatables.api.backend.contracts.table_contracts import ContractValidationError
 from metatables.api.backend.domain.catalog_rules import CatalogInvariantError
 from metatables.api.backend.domain.data_source_rules import DataSourceAdmissionError
@@ -158,16 +159,28 @@ def _registration(payload, *, indexed, actor, session, sources, creator, introsp
     return result, source
 
 
-def _failure(session, exc):
+def _failure(session, exc, *, item=None):
     session.rollback()
-    if isinstance(exc, DataSourceAdmissionError):
+    cause = exc
+    if isinstance(exc, HTTPException):
+        status, detail, cause = exc.status_code, exc.detail, exc.__cause__
+    elif isinstance(exc, DataSourceAdmissionError):
         # Contract rejections name the offending column or index, as contract validation does.
+        status = exc.status_code
         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)):
+    elif 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,
-                        getattr(exc, 'code', str(exc))) from exc
+    else:
+        status = 409 if isinstance(exc, (PhysicalTableError, PhysicalIntrospectionError, TimescaleError)) else 422
+        detail = exc.errors if isinstance(exc, StorageLayoutValidationError) else getattr(exc, 'code', str(exc))
+    if item is not None:
+        # A bulk rejection names the table it rejects; nothing in the request is reserved.
+        position, request = item
+        detail = {'item': position, 'identifier': request.identifier,
+                  'physical_table_name': request.physical_table_name
+                  or (request.table_contract.get('physical') or {}).get('table_name'),
+                  'detail': detail}
+    raise HTTPException(status, detail) from cause
 
 
 def _register(payload, response, actor, session, sources, creator, introspector, *, indexed=False):
@@ -206,18 +219,25 @@ def reserve_tables(payload: list[ReservationRequest] | ReservationRequest, actor
     payload = [payload] if single else payload
     if not 1 <= len(payload) <= 200:
         raise HTTPException(422, 'Reserve between 1 and 200 tables.')
+    current = None
     try:
         results = []
         resolved_sources = {}
-        for item in payload:
+        for position, item in enumerate(payload):
+            current = (position, item)
             indexed = bool(item.time_index_name or item.table_contract.get('table_kind') == 'time_indexed')
             result, _source = _registration(item, indexed=indexed, actor=actor, session=session,
                 sources=sources, creator=None, introspector=None, reserve=True)
             results.append(result.table)
             resolved_sources[_source.uid] = _source
+        current = None
         output = project_meta_tables(session, rows=tuple(results), actor=actor, sources=resolved_sources)
         session.commit()
         return output[0] if single else output
+    except HTTPException as exc:
+        if single or current is None:
+            raise
+        _failure(session, exc, item=current)
     except (CatalogInvariantError, ContractValidationError, DataSourceAdmissionError,
             DataSourceIntegrationError, PhysicalConnectionUnavailable, SQLAlchemyError, ValueError) as exc:
-        _failure(session, exc)
+        _failure(session, exc, item=None if single else current)

{mainsequence_metatable-0.1.14 → mainsequence_metatable-0.1.15.dev27}/src/metatables/api/backend/contracts/storage_layouts.py

@@ -1,9 +1,14 @@
-import re
 from typing import Any, Literal, Mapping, Optional, Sequence
 
 from pydantic import BaseModel, ConfigDict, Field, ValidationError, model_validator
 
-POSTGRESQL_IDENTIFIER_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]{0,62}$")
+from metatables.storage_layout_contract import (
+    POSTGRESQL_IDENTIFIER_MAX_LENGTH,
+    POSTGRESQL_IDENTIFIER_RE,
+    SECONDARY_INDEX_PHYSICAL_SUFFIX,
+    default_secondary_index_name,
+    derived_secondary_index_name_error,
+)
 
 
 class StorageLayoutValidationError(ValueError):
@@ -48,7 +53,11 @@ class StorageLayoutSecondaryIndex(StrictStorageLayoutModel):
         if not self.name:
             raise ValueError("secondary index name is required")
         if not POSTGRESQL_IDENTIFIER_RE.match(self.name):
-            raise ValueError("secondary index name must be a valid PostgreSQL identifier")
+            raise ValueError(
+                f"secondary index name {self.name!r} ({len(self.name)} characters) must be "
+                "a valid PostgreSQL identifier: letters, digits and underscores, not "
+                f"starting with a digit, at most {POSTGRESQL_IDENTIFIER_MAX_LENGTH} characters"
+            )
         if not self.columns:
             raise ValueError("secondary index columns are required")
         return self
@@ -157,7 +166,7 @@ def build_default_storage_layout(
     if identity_dimensions:
         secondary_indexes.append(
             {
-                "name": "_".join(identity_dimensions),
+                "name": default_secondary_index_name(identity_dimensions),
                 "columns": identity_dimensions,
                 "kind": "lookup",
             }
@@ -190,6 +199,9 @@ def parse_storage_layout(
     columns_by_name: Mapping[str, Any],
 ) -> DynamicTableStorageLayoutV1:
     if not storage_layout:
+        derived_name_error = derived_secondary_index_name_error(list(index_names or [])[1:])
+        if derived_name_error:
+            raise StorageLayoutValidationError({"secondary_indexes": [derived_name_error]})
         storage_layout = build_default_storage_layout(
             time_index_name=time_index_name,
             index_names=index_names,
@@ -225,7 +237,22 @@ def render_postgresql_physical_index_plan(
     }
 
     for secondary_index in storage_layout.secondary_indexes:
-        plan[f"{secondary_index.name}_idx"] = {
+        physical_name = f"{secondary_index.name}{SECONDARY_INDEX_PHYSICAL_SUFFIX}"
+        if len(physical_name) > POSTGRESQL_IDENTIFIER_MAX_LENGTH:
+            # PostgreSQL would silently truncate the name; raise instead.
+            raise StorageLayoutValidationError(
+                {
+                    "secondary_indexes": [
+                        f"Physical index name {physical_name!r} ({len(physical_name)} "
+                        "characters) exceeds the PostgreSQL limit of "
+                        f"{POSTGRESQL_IDENTIFIER_MAX_LENGTH} characters. Use a secondary "
+                        "index name of at most "
+                        f"{POSTGRESQL_IDENTIFIER_MAX_LENGTH - len(SECONDARY_INDEX_PHYSICAL_SUFFIX)} "
+                        "characters."
+                    ]
+                }
+            )
+        plan[physical_name] = {
             "type": "INDEX",
             "query": (
                 f"USING {postgresql_hints.secondary_index_method.upper()} "

{mainsequence_metatable-0.1.14 → mainsequence_metatable-0.1.15.dev27}/src/metatables/sqlalchemy_contracts.py

@@ -29,6 +29,7 @@ from metatables.models import (
     SchemaManagementRequest,
     TimeIndexMetaTable,
 )
+from metatables.storage_layout_contract import derived_secondary_index_name_error
 
 from .hashing import build_meta_table_configured_storage_hash
 from .schema_names import schema_index_name
@@ -526,6 +527,11 @@ def time_indexed_registration_request_from_sqlalchemy_model(
         time_index_name=resolved_time_index_name,
         index_names=resolved_index_names,
     )
+    _validate_default_storage_layout(
+        model_or_table,
+        storage_layout=resolved_storage_layout,
+        index_names=resolved_index_names,
+    )
 
     column_contracts = [
         _column_contract(column, ordinal_position=position).model_dump(
@@ -1463,6 +1469,28 @@ def _validate_time_index_contract(
         )
 
 
+def _validate_default_storage_layout(
+    model_or_table: Any,
+    *,
+    storage_layout: Mapping[str, Any] | None,
+    index_names: Sequence[str],
+) -> None:
+    # The API applies the same rule; checking here names the model before any request.
+    if storage_layout:
+        return
+    error = derived_secondary_index_name_error([str(name) for name in index_names][1:])
+    if error:
+        module, qualname = _resolve_model_path(
+            model_or_table,
+            table_model_module=None,
+            table_model_qualname=None,
+        )
+        raise ValueError(
+            f"PlatformTimeIndexMetaTable {module}.{qualname} cannot use the default "
+            f"storage layout. {error}"
+        )
+
+
 def _ensure_time_index_unique_grain_index(
     *,
     table: Any,

mainsequence_metatable-0.1.15.dev27/src/metatables/storage_layout_contract.py

@@ -0,0 +1,27 @@
+"""Storage-layout naming rules shared by the client and the API."""
+
+import re
+from typing import Sequence
+
+POSTGRESQL_IDENTIFIER_MAX_LENGTH = 63
+POSTGRESQL_IDENTIFIER_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]{0,62}$")
+SECONDARY_INDEX_PHYSICAL_SUFFIX = "_idx"
+
+
+def default_secondary_index_name(identity_dimensions: Sequence[str]) -> str:
+    return "_".join(identity_dimensions)
+
+
+def derived_secondary_index_name_error(identity_dimensions: Sequence[str]) -> str | None:
+    """Explain why the default name is unusable; derived names are never shortened."""
+    name = default_secondary_index_name(identity_dimensions)
+    if not identity_dimensions or POSTGRESQL_IDENTIFIER_RE.match(name):
+        return None
+    return (
+        f"The default secondary index name {name!r} ({len(name)} characters) is derived "
+        f"by joining identity_dimensions {list(identity_dimensions)!r} and is not a valid "
+        f"PostgreSQL identifier of at most {POSTGRESQL_IDENTIFIER_MAX_LENGTH} characters. "
+        "MetaTables does not shorten derived names. Declare an explicit storage_layout "
+        "(__storage_layout__ on a PlatformTimeIndexMetaTable model) whose secondary index "
+        "has a valid name."
+    )

mainsequence_metatable-0.1.15.dev27/tests/contracts/test_storage_layouts.py

@@ -0,0 +1,216 @@
+"""Time-index table contract behavior."""
+
+import pytest
+
+from metatables.api.backend.contracts.storage_layouts import (
+    StorageLayoutValidationError,
+    normalize_storage_layout,
+    render_physical_index_plan,
+)
+
+
+def test_default_layout_preserves_time_first_identity_and_physical_index_plan():
+    columns = {"observation_time": "timestamptz", "asset_uid": "uuid", "price": "numeric"}
+    layout = normalize_storage_layout(
+        None,
+        time_index_name="observation_time",
+        index_names=["observation_time", "asset_uid"],
+        columns_by_name=columns,
+    )
+
+    assert layout["identity_dimensions"] == ["asset_uid"]
+    assert layout["uniqueness"]["columns"] == ["observation_time", "asset_uid"]
+    assert layout["tail_delete"]["scope_dimensions"] == ["asset_uid"]
+
+    index_plan = render_physical_index_plan(
+        layout,
+        time_index_name="observation_time",
+        index_names=["observation_time", "asset_uid"],
+        columns_by_name=columns,
+    )
+    assert index_plan["time_idx"]["query"] == 'USING BRIN ("observation_time")'
+    assert index_plan["asset_uid_idx"]["query"] == 'USING BTREE ("asset_uid")'
+    assert index_plan["time_identifier_ev_idx"]["query"] == (
+        '("observation_time", "asset_uid")'
+    )
+
+
+def test_layout_rejects_dimensions_that_disagree_with_table_contract():
+    with pytest.raises(StorageLayoutValidationError) as error:
+        normalize_storage_layout(
+            {
+                "version": 1,
+                "time_index": {"name": "observation_time"},
+                "identity_dimensions": ["wrong_asset"],
+                "index_progress": {"grain": ["wrong_asset"]},
+                "uniqueness": {"columns": ["observation_time", "wrong_asset"]},
+                "tail_delete": {"scope_dimensions": ["wrong_asset"]},
+            },
+            time_index_name="observation_time",
+            index_names=["observation_time", "asset_uid"],
+            columns_by_name={"observation_time": "timestamptz", "asset_uid": "uuid"},
+        )
+
+    assert "identity_dimensions" in error.value.errors
+    assert "columns" in error.value.errors
+
+
+def test_layout_rejects_unknown_secondary_index_column():
+    with pytest.raises(StorageLayoutValidationError) as error:
+        normalize_storage_layout(
+            {
+                "version": 1,
+                "time_index": {"name": "observation_time"},
+                "identity_dimensions": [],
+                "index_progress": {"grain": []},
+                "uniqueness": {"columns": ["observation_time"]},
+                "tail_delete": {"scope_dimensions": []},
+                "secondary_indexes": [
+                    {"name": "lookup_idx", "columns": ["missing_column"]}
+                ],
+            },
+            time_index_name="observation_time",
+            index_names=["observation_time"],
+            columns_by_name={"observation_time": "timestamptz"},
+        )
+
+    assert "secondary_indexes" in error.value.errors
+
+
+LEDGER_DIMENSIONS = ["portfolio_identifier", "event_identifier", "event_revision", "record_identifier"]
+LEDGER_DERIVED_NAME = "portfolio_identifier_event_identifier_event_revision_record_identifier"
+
+
+def explicit_layout(dimensions, secondary_index_name):
+    return {
+        "version": 1,
+        "time_index": {"name": "time_index"},
+        "identity_dimensions": dimensions,
+        "index_progress": {"grain": dimensions},
+        "uniqueness": {"columns": ["time_index", *dimensions]},
+        "tail_delete": {"scope_dimensions": dimensions},
+        "secondary_indexes": [{"name": secondary_index_name, "columns": dimensions}],
+    }
+
+
+def columns_for(dimensions):
+    return {"time_index": "timestamptz", **{name: "text" for name in dimensions}}
+
+
+def test_default_layout_raises_instead_of_shortening_a_derived_name_over_63_characters():
+    with pytest.raises(StorageLayoutValidationError) as error:
+        normalize_storage_layout(
+            None,
+            time_index_name="time_index",
+            index_names=["time_index", *LEDGER_DIMENSIONS],
+            columns_by_name=columns_for(LEDGER_DIMENSIONS),
+        )
+
+    [message] = error.value.errors["secondary_indexes"]
+    assert f"'{LEDGER_DERIVED_NAME}' (70 characters)" in message
+    assert "derived by joining identity_dimensions" in message
+    assert "does not shorten" in message
+    assert "__storage_layout__" in message
+
+
+@pytest.mark.parametrize(
+    ("dimensions", "valid"),
+    [(["a" * 63], True), (["a" * 31, "b" * 32], False)],
+)
+def test_default_layout_accepts_derived_names_up_to_63_characters(dimensions, valid):
+    def normalize():
+        return normalize_storage_layout(
+            None,
+            time_index_name="time_index",
+            index_names=["time_index", *dimensions],
+            columns_by_name=columns_for(dimensions),
+        )
+
+    if valid:
+        assert normalize()["secondary_indexes"][0]["name"] == "a" * 63
+    else:
+        with pytest.raises(StorageLayoutValidationError, match="64 characters"):
+            normalize()
+
+
+def test_explicit_secondary_index_name_unblocks_long_identity_dimensions():
+    layout = normalize_storage_layout(
+        explicit_layout(LEDGER_DIMENSIONS, "portfolio_event_record_lookup"),
+        time_index_name="time_index",
+        index_names=["time_index", *LEDGER_DIMENSIONS],
+        columns_by_name=columns_for(LEDGER_DIMENSIONS),
+    )
+
+    assert layout["secondary_indexes"][0]["name"] == "portfolio_event_record_lookup"
+
+
+def test_explicit_secondary_index_name_error_shows_the_declared_value():
+    with pytest.raises(StorageLayoutValidationError) as error:
+        normalize_storage_layout(
+            explicit_layout(LEDGER_DIMENSIONS, LEDGER_DERIVED_NAME),
+            time_index_name="time_index",
+            index_names=["time_index", *LEDGER_DIMENSIONS],
+            columns_by_name=columns_for(LEDGER_DIMENSIONS),
+        )
+
+    [message] = error.value.errors["secondary_indexes.0"]
+    assert f"'{LEDGER_DERIVED_NAME}' (70 characters)" in message
+    assert "derived" not in message
+
+
+def test_physical_index_plan_raises_when_the_idx_suffix_would_exceed_63_characters():
+    def plan(name):
+        return render_physical_index_plan(
+            explicit_layout(["asset_uid"], name),
+            time_index_name="time_index",
+            index_names=["time_index", "asset_uid"],
+            columns_by_name=columns_for(["asset_uid"]),
+        )
+
+    assert f"{'a' * 59}_idx" in plan("a" * 59)
+    with pytest.raises(StorageLayoutValidationError, match="at most 59 characters"):
+        plan("a" * 60)
+
+
+def test_client_names_the_model_before_sending_an_invalid_derived_name():
+    from datetime import datetime
+
+    from sqlalchemy import DateTime, String
+    from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+    from metatables import (
+        PlatformTimeIndexMetaTable,
+        time_indexed_registration_request_from_sqlalchemy_model,
+    )
+
+    class Base(DeclarativeBase):
+        pass
+
+    class PortfolioEventLedger(PlatformTimeIndexMetaTable, Base):
+        __tablename__ = "ledger__portfolio_event"
+        __metatable_namespace__ = "ledger"
+        __metatable_identifier__ = "ledger.portfolio_event"
+        __index_names__ = ["time_index", *LEDGER_DIMENSIONS]
+
+        time_index: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+        portfolio_identifier: Mapped[str] = mapped_column(String(64), nullable=False)
+        event_identifier: Mapped[str] = mapped_column(String(64), nullable=False)
+        event_revision: Mapped[str] = mapped_column(String(64), nullable=False)
+        record_identifier: Mapped[str] = mapped_column(String(64), nullable=False)
+
+    with pytest.raises(ValueError, match="cannot use the default storage layout") as error:
+        time_indexed_registration_request_from_sqlalchemy_model(
+            PortfolioEventLedger, data_source_uid="00000000-0000-0000-0000-000000000001"
+        )
+    assert f"{__name__}." in str(error.value)
+    assert ".PortfolioEventLedger cannot use the default storage layout" in str(error.value)
+    assert LEDGER_DERIVED_NAME in str(error.value)
+
+    PortfolioEventLedger.__storage_layout__ = explicit_layout(
+        LEDGER_DIMENSIONS, "portfolio_event_record_lookup"
+    )
+    request = time_indexed_registration_request_from_sqlalchemy_model(
+        PortfolioEventLedger, data_source_uid="00000000-0000-0000-0000-000000000001"
+    )
+    profile = request.table_contract["authoring"]["time_indexed"]
+    assert profile["storage_layout"]["secondary_indexes"][0]["name"] == "portfolio_event_record_lookup"

{mainsequence_metatable-0.1.14 → mainsequence_metatable-0.1.15.dev27}/tests/e2e/test_remaining_client_routes.py

@@ -138,6 +138,33 @@ def test_public_registration_bulk_and_time_index_get_or_create(closed_app):
     assert not [call for call in f.calls[before:] if call[0] in {'create', 'introspect'}]
 
 
+
+def time_index_reservation(source_uid, name, dimensions):
+    columns = [{'name': 'time_index', 'data_type': 'datetime'}, *({'name': d, 'data_type': 'int64'} for d in dimensions)]
+    contract = {**CONTRACT, 'columns': columns, 'physical': {'schema': 'public', 'table_name': name},
+                'table_kind': 'time_indexed', 'authoring': {'time_indexed': {
+                    'time_index_name': 'time_index', 'index_names': ['time_index', *dimensions]}}}
+    return {**reservation(source_uid, name), 'identifier': f'example.{name}', 'time_index_name': 'time_index',
+            'table_contract': contract}
+
+
+def test_bulk_reservation_rejection_names_the_failing_table(closed_app):
+    f = closed_app
+    ledger = time_index_reservation(f.source.uid, 'ledger',
+        ['portfolio_identifier', 'event_identifier', 'event_revision', 'record_identifier'])
+    response = f.http.post('/time-index-meta-tables/', json=[
+        time_index_reservation(f.source.uid, 'prices', ['asset_uid']), ledger])
+    assert response.status_code == 422
+    detail = response.json()['detail']
+    assert {key: detail[key] for key in ('item', 'identifier', 'physical_table_name')} == {
+        'item': 1, 'identifier': 'example.ledger', 'physical_table_name': 'ledger'}
+    [message] = detail['detail']['secondary_indexes']
+    assert "'portfolio_identifier_event_identifier_event_revision_record_identifier' (70 characters)" in message
+    with Session(f.engine) as session:
+        assert session.scalars(select(StoredTable)).all() == []
+    single = f.http.post('/time-index-meta-tables/', json=ledger)
+    assert single.status_code == 422 and single.json()['detail'] == detail['detail']
+
 def test_public_sql_and_migration_connection_check_local_scope(closed_app):
     f = closed_app
     table = MetaTable.register(data_source_uid=str(f.source.uid), management_mode='platform_managed', table_contract=CONTRACT)

{mainsequence_metatable-0.1.14 → mainsequence_metatable-0.1.15.dev27}/uv.lock

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

mainsequence_metatable-0.1.14/tests/contracts/test_storage_layouts.py

@@ -1,77 +0,0 @@
-"""Time-index table contract behavior."""
-
-import pytest
-
-from metatables.api.backend.contracts.storage_layouts import (
-    StorageLayoutValidationError,
-    normalize_storage_layout,
-    render_physical_index_plan,
-)
-
-
-def test_default_layout_preserves_time_first_identity_and_physical_index_plan():
-    columns = {"observation_time": "timestamptz", "asset_uid": "uuid", "price": "numeric"}
-    layout = normalize_storage_layout(
-        None,
-        time_index_name="observation_time",
-        index_names=["observation_time", "asset_uid"],
-        columns_by_name=columns,
-    )
-
-    assert layout["identity_dimensions"] == ["asset_uid"]
-    assert layout["uniqueness"]["columns"] == ["observation_time", "asset_uid"]
-    assert layout["tail_delete"]["scope_dimensions"] == ["asset_uid"]
-
-    index_plan = render_physical_index_plan(
-        layout,
-        time_index_name="observation_time",
-        index_names=["observation_time", "asset_uid"],
-        columns_by_name=columns,
-    )
-    assert index_plan["time_idx"]["query"] == 'USING BRIN ("observation_time")'
-    assert index_plan["asset_uid_idx"]["query"] == 'USING BTREE ("asset_uid")'
-    assert index_plan["time_identifier_ev_idx"]["query"] == (
-        '("observation_time", "asset_uid")'
-    )
-
-
-def test_layout_rejects_dimensions_that_disagree_with_table_contract():
-    with pytest.raises(StorageLayoutValidationError) as error:
-        normalize_storage_layout(
-            {
-                "version": 1,
-                "time_index": {"name": "observation_time"},
-                "identity_dimensions": ["wrong_asset"],
-                "index_progress": {"grain": ["wrong_asset"]},
-                "uniqueness": {"columns": ["observation_time", "wrong_asset"]},
-                "tail_delete": {"scope_dimensions": ["wrong_asset"]},
-            },
-            time_index_name="observation_time",
-            index_names=["observation_time", "asset_uid"],
-            columns_by_name={"observation_time": "timestamptz", "asset_uid": "uuid"},
-        )
-
-    assert "identity_dimensions" in error.value.errors
-    assert "columns" in error.value.errors
-
-
-def test_layout_rejects_unknown_secondary_index_column():
-    with pytest.raises(StorageLayoutValidationError) as error:
-        normalize_storage_layout(
-            {
-                "version": 1,
-                "time_index": {"name": "observation_time"},
-                "identity_dimensions": [],
-                "index_progress": {"grain": []},
-                "uniqueness": {"columns": ["observation_time"]},
-                "tail_delete": {"scope_dimensions": []},
-                "secondary_indexes": [
-                    {"name": "lookup_idx", "columns": ["missing_column"]}
-                ],
-            },
-            time_index_name="observation_time",
-            index_names=["observation_time"],
-            columns_by_name={"observation_time": "timestamptz"},
-        )
-
-    assert "secondary_indexes" in error.value.errors