mainsequence 4.3.0__tar.gz → 4.3.5__tar.gz

{mainsequence-4.3.0/mainsequence.egg-info → mainsequence-4.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 4.3.0
+Version: 4.3.5
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License: MainSequence GmbH SDK License Agreement

{mainsequence-4.3.0 → mainsequence-4.3.5}/mainsequence/cli/migrations.py

@@ -122,12 +122,21 @@ def _load_alembic_command(command_name: str) -> Any:
     return command
 
 
+def _coerce_alembic_version_path(version_path: str) -> str:
+    try:
+        from alembic import util
+    except ImportError as exc:
+        raise typer.BadParameter("Alembic is required for migration commands.") from exc
+    return str(util.coerce_resource_to_filename(version_path))
+
+
 def _emit_alembic_script_context(
     config: Any,
     *,
     target_revision: str | None = None,
 ) -> None:
     script_location = config.get_main_option("script_location")
+    version_locations = config.get_main_option("version_locations")
     version_table = config.get_main_option("version_table")
     version_table_schema = config.get_main_option("version_table_schema")
     version_table_label = (
@@ -135,9 +144,14 @@ def _emit_alembic_script_context(
         if version_table_schema not in (None, "")
         else version_table
     )
+    version_locations_label = (
+        version_locations.replace("\n", ", ") if version_locations else "<default>"
+    )
     _emit_status(
         "Alembic script context "
-        f"script_location={script_location} version_table={version_table_label}"
+        f"script_location={script_location} "
+        f"version_locations={version_locations_label} "
+        f"version_table={version_table_label}"
     )
     try:
         from alembic.script import ScriptDirectory
@@ -745,14 +759,17 @@ def revision(
     )
     _emit_alembic_script_context(config, target_revision=head)
     _emit_status(f"Starting Alembic revision now rev_id={resolved_rev_id}...")
+    revision_kwargs = {
+        "message": resolved_message,
+        "autogenerate": autogenerate,
+        "rev_id": resolved_rev_id,
+        "head": head,
+    }
+    version_path = migration.resolved_version_path()
+    if version_path is not None:
+        revision_kwargs["version_path"] = _coerce_alembic_version_path(version_path)
     with _forward_alembic_logging():
-        script = command.revision(
-            config,
-            message=resolved_message,
-            autogenerate=autogenerate,
-            rev_id=resolved_rev_id,
-            head=head,
-        )
+        script = command.revision(config, **revision_kwargs)
     _emit_status("Alembic revision finished.")
     _emit(
         {

{mainsequence-4.3.0 → mainsequence-4.3.5}/mainsequence/client/metatables/core.py

@@ -452,8 +452,43 @@ class MetaTableOperationScopeTable(BasePydanticModel):
 
 
 class MetaTableOperationScope(BasePydanticModel):
+    data_source_uid: str | None = Field(
+        default=None,
+        min_length=1,
+        validation_alias=AliasChoices("data_source_uid", "dataSourceUid"),
+        description=(
+            "Public UID of the DynamicTableDataSource that owns the compiled "
+            "SQL execution connection. If omitted, the SDK resolves the "
+            "configured project/session default data source. Scoped MetaTables "
+            "are the permission contract, not the source of execution routing."
+        ),
+    )
     tables: list[MetaTableOperationScopeTable] = Field(..., min_length=1)
 
+    model_config = ConfigDict(populate_by_name=True)
+
+    @model_validator(mode="after")
+    def resolve_default_data_source_uid(self):
+        if self.data_source_uid not in (None, ""):
+            self.data_source_uid = str(self.data_source_uid)
+            return self
+
+        try:
+            data_source = get_session_data_source()
+        except Exception as exc:
+            raise ValueError(
+                "MetaTable compiled SQL scope requires data_source_uid or a "
+                "configured project/session default data source."
+            ) from exc
+
+        uid = getattr(data_source, "uid", None) or getattr(data_source, "data_source_uid", None)
+        if uid in (None, ""):
+            raise ValueError(
+                "Configured project/session default data source does not expose a uid."
+            )
+        self.data_source_uid = str(uid)
+        return self
+
 
 class MetaTableOperationLimits(BasePydanticModel):
     max_rows: int | None = Field(default=None, ge=1)
@@ -2928,15 +2963,6 @@ class TimeIndexMetaTable(MetaTable):
         "labels__in": "str",
         "labels__contains": "str",
     }
-    READ_QUERY_PARAMS: ClassVar[dict[str, str]] = {
-        "include_relations_detail": "bool",
-    }
-    READ_QUERY_PARAM_DESCRIPTIONS: ClassVar[dict[str, str]] = {
-        "include_relations_detail": (
-            "Expand related objects in the serializer response. "
-            "This changes response detail only and does not change which rows are returned."
-        ),
-    }
     build_configuration_json_schema: dict[str, Any] | None = Field(
         None,
         description="JSON schema describing the DataNode update build configuration.",

{mainsequence-4.3.0 → mainsequence-4.3.5}/mainsequence/meta_tables/compiled_sql/v1.py

@@ -34,8 +34,8 @@ def build_operation(
     Build and validate the TS Manager compiled-sql.v1 operation contract.
 
     This is the client-side protocol object. It is intentionally plain SQL plus
-    bound parameters and declared MetaTable scope, not a serialized SQLAlchemy
-    object.
+    bound parameters, an explicit execution data source, and declared MetaTable
+    scope, not a serialized SQLAlchemy object.
     """
 
     if parameters is None:
@@ -72,6 +72,7 @@ def compile_sqlalchemy_statement(
     statement: Any,
     *,
     operation: MetaTableOperation,
+    data_source_uid: str | None = None,
     scope_tables: Sequence[MetaTableOperationScopeTable | Mapping[str, Any]],
     limits: MetaTableOperationLimits | Mapping[str, Any] | None = None,
     dialect: MetaTableCompiledSQLDialect = "postgresql",
@@ -80,6 +81,11 @@ def compile_sqlalchemy_statement(
 ) -> MetaTableCompiledSQLOperation:
     """
     Compile a SQLAlchemy/Core statement into the TS Manager compiled-sql.v1 payload.
+
+    ``data_source_uid`` selects the DynamicTableDataSource connection. If it is
+    omitted, the SDK resolves the configured project/session default data source.
+    ``scope_tables`` remains the declared MetaTable permission scope for the
+    operation.
     """
 
     if dialect != "postgresql":
@@ -97,6 +103,7 @@ def compile_sqlalchemy_statement(
     )
     parameter_types = _compiled_sqlalchemy_parameter_types(compiled)
     scope = MetaTableOperationScope(
+        data_source_uid=data_source_uid,
         tables=[
             (
                 table

{mainsequence-4.3.0 → mainsequence-4.3.5}/mainsequence/meta_tables/data_nodes/data_nodes.py

@@ -211,7 +211,6 @@ class APIDataNode(DataAccessMixin):
     def build_from_table_name(cls, table_name: str) -> "APIDataNode":
         storage_table = TimeIndexMetaTable.get_or_none(
             physical_table_name=table_name,
-            include_relations_detail=True,
         )
         if storage_table is None:
             raise DoesNotExist(

{mainsequence-4.3.0 → mainsequence-4.3.5}/mainsequence/meta_tables/data_nodes/persist_managers.py

@@ -567,7 +567,6 @@ class APIPersistManager:
             result = TimeIndexMetaTable.get_or_none(
                 physical_table_name=self.storage_hash,
                 data_source__uid=self.data_source_uid,
-                include_relations_detail=True,
             )
             self._storage_table_future.set_result(result)
         except Exception as exc:

{mainsequence-4.3.0 → mainsequence-4.3.5}/mainsequence/meta_tables/migrations.py

@@ -101,6 +101,49 @@ class AlembicProviderPhysicalStateError(RuntimeError):
         )
 
 
+def _normalize_optional_alembic_location(value: Any, field_name: str) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    if not text:
+        raise ValueError(f"AlembicMetaTableMigration {field_name} cannot be empty.")
+    return text
+
+
+def _normalize_alembic_version_locations(value: str | Sequence[str] | None) -> tuple[str, ...]:
+    if value is None:
+        return ()
+    raw_locations: Sequence[str]
+    if isinstance(value, str):
+        raw_locations = [value]
+    else:
+        raw_locations = value
+
+    locations: list[str] = []
+    seen: set[str] = set()
+    for raw_location in raw_locations:
+        location = _normalize_optional_alembic_location(raw_location, "version_locations")
+        if location is None or location in seen:
+            continue
+        seen.add(location)
+        locations.append(location)
+    if not locations:
+        raise ValueError("AlembicMetaTableMigration version_locations cannot be empty.")
+    return tuple(locations)
+
+
+def _configure_alembic_version_locations(
+    config: Any,
+    version_locations: str | Sequence[str] | None,
+) -> tuple[str, ...]:
+    locations = _normalize_alembic_version_locations(version_locations)
+    if not locations:
+        return ()
+    config.set_main_option("version_locations", "\n".join(locations))
+    config.set_main_option("path_separator", "newline")
+    return locations
+
+
 class AlembicVersionMetaTable:
     """MetaTable catalog binding for Alembic's version table.
 
@@ -255,6 +298,8 @@ class AlembicMetaTableMigration:
     script_location: str
     target_metadata: Any
     alembic_registry: type[AlembicVersionMetaTable]
+    version_locations: str | Sequence[str] | None = None
+    version_path: str | None = None
     metatable_models: Sequence[type[Any]] = field(default_factory=tuple)
     after_register_metatables: Callable[[AlembicMetaTableCatalogRefreshContext], Any] | None = None
     include_name_hook: Any | None = None
@@ -273,6 +318,8 @@ class AlembicMetaTableMigration:
             self.after_register_metatables
         ):
             raise TypeError("after_register_metatables must be callable when provided.")
+        self.resolved_version_locations()
+        self.resolved_version_path()
         _normalize_provider_default_schemas(self.metatable_models)
         _ensure_provider_time_index_grain_indexes(self.metatable_models)
 
@@ -292,6 +339,23 @@ class AlembicMetaTableMigration:
     def version_table_schema(self) -> str | None:
         return self.alembic_registry.__alembic_version_schema__
 
+    def resolved_version_locations(self) -> tuple[str, ...]:
+        return _normalize_alembic_version_locations(self.version_locations)
+
+    def resolved_version_path(self) -> str | None:
+        explicit = _normalize_optional_alembic_location(self.version_path, "version_path")
+        if explicit is not None:
+            return explicit
+        locations = self.resolved_version_locations()
+        if len(locations) == 1:
+            return locations[0]
+        if len(locations) > 1:
+            raise ValueError(
+                "AlembicMetaTableMigration with multiple version_locations requires "
+                "an explicit version_path for revision generation."
+            )
+        return None
+
     def include_name(self, name: str | None, type_: str, parent_names: dict[str, Any]) -> bool:
         if self.include_name_hook is not None:
             return bool(self.include_name_hook(name, type_, parent_names))
@@ -750,6 +814,7 @@ def alembic_config_for_provider(
     if output_buffer is not None:
         config.output_buffer = output_buffer
     config.set_main_option("script_location", migration.script_location)
+    version_locations = _configure_alembic_version_locations(config, migration.version_locations)
     config.set_main_option("sqlalchemy.url", sqlalchemy_url.replace("%", "%%"))
     config.set_main_option("sqlalchemy.echo", "true")
     config.set_main_option("version_table", migration.version_table)
@@ -764,6 +829,8 @@ def alembic_config_for_provider(
     config.attributes["alembic_version_table"] = migration.alembic_version_table
     config.attributes["version_table"] = migration.version_table
     config.attributes["version_table_schema"] = migration.version_table_schema
+    config.attributes["version_locations"] = version_locations
+    config.attributes["version_path"] = migration.resolved_version_path()
     return config
 
 
@@ -805,6 +872,7 @@ def resolve_alembic_revision_metadata(
     *,
     script_location: str,
     revision: str,
+    version_locations: str | Sequence[str] | None = None,
 ) -> tuple[str, str | None]:
     try:
         from alembic.config import Config
@@ -814,6 +882,7 @@ def resolve_alembic_revision_metadata(
 
     config = Config()
     config.set_main_option("script_location", script_location)
+    _configure_alembic_version_locations(config, version_locations)
     script = ScriptDirectory.from_config(config)
     resolved = script.get_revision(revision)
     if resolved is None:

{mainsequence-4.3.0 → mainsequence-4.3.5/mainsequence.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 4.3.0
+Version: 4.3.5
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License: MainSequence GmbH SDK License Agreement

{mainsequence-4.3.0 → mainsequence-4.3.5}/mainsequence.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 mainsequence = mainsequence.cli.cli:app
+ms = mainsequence.cli.cli:app

{mainsequence-4.3.0 → mainsequence-4.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence"
-version = "4.3.0"
+version = "4.3.5"
 description = "Main Sequence SDK "
 readme = "README.md"
 requires-python = ">=3.11"
@@ -60,6 +60,7 @@ Homepage = "https://github.com/mainsequence-sdk/mainsequence-sdk"
 Issues = "https://github.com/mainsequence-sdk/mainsequence-sdk/issues"
 [project.scripts]
 mainsequence = "mainsequence.cli.cli:app"
+ms = "mainsequence.cli.cli:app"
 
 # PEP 621 dependencies (published requirements)
 [dependency-groups]

{mainsequence-4.3.0 → mainsequence-4.3.5}/tests/test_cli_migrations.py

@@ -5,6 +5,7 @@ import logging
 import pathlib
 import sys
 import types
+from collections.abc import Sequence
 
 import pytest
 from sqlalchemy import MetaData
@@ -37,7 +38,11 @@ def _load_cli_module():
         return importlib.import_module("mainsequence.cli.cli")
 
 
-def _migration() -> AlembicMetaTableMigration:
+def _migration(
+    *,
+    version_locations: str | Sequence[str] | None = None,
+    version_path: str | None = None,
+) -> AlembicMetaTableMigration:
     class Registry(AlembicVersionMetaTable):
         __metatable_uid__ = "registry-meta-table-uid"
         __metatable_data_source_uid__ = "data-source-uid"
@@ -54,6 +59,8 @@ def _migration() -> AlembicMetaTableMigration:
         script_location="msm:alembic",
         target_metadata=MetaData(),
         alembic_registry=Registry,
+        version_locations=version_locations,
+        version_path=version_path,
     )
 
 
@@ -360,6 +367,100 @@ def test_migrations_revision_forwards_alembic_logs_and_scans_revision_id(monkeyp
     assert "Preparing platform-managed MetaTable reservations" not in output
 
 
+def test_coerce_alembic_version_path_resolves_package_resource(tmp_path, monkeypatch):
+    migration_cli = importlib.import_module("mainsequence.cli.migrations")
+    package_root = tmp_path / "sample_provider"
+    namespace_versions = package_root / "migrations" / "versions" / "mainsequence_examples"
+    namespace_versions.mkdir(parents=True)
+    (package_root / "__init__.py").write_text("", encoding="utf-8")
+    (package_root / "migrations" / "__init__.py").write_text("", encoding="utf-8")
+    monkeypatch.syspath_prepend(str(tmp_path))
+
+    assert migration_cli._coerce_alembic_version_path(
+        "sample_provider:migrations/versions/mainsequence_examples"
+    ) == str(namespace_versions)
+
+
+def test_migrations_revision_passes_provider_version_path(monkeypatch):
+    cli_mod = _load_cli_module()
+    runner = CliRunner()
+    migration_cli = importlib.import_module("mainsequence.cli.migrations")
+    version_location = "msm:alembic/versions/mainsequence_examples"
+    resolved_version_path = "/tmp/msm/alembic/versions/mainsequence_examples"
+    migration = _migration(version_locations=[version_location], version_path=version_location)
+    captured = {}
+    monkeypatch.setattr(migration_cli, "_load_migration", lambda provider: migration)
+
+    def fake_coerce_version_path(path):
+        captured["unresolved_version_path"] = path
+        return resolved_version_path
+
+    monkeypatch.setattr(migration_cli, "_coerce_alembic_version_path", fake_coerce_version_path)
+
+    def fail_backend_call(*args, **kwargs):
+        raise AssertionError("revision must not provision MetaTables")
+
+    monkeypatch.setattr(
+        AlembicMetaTableMigration,
+        "ensure_alembic_registry",
+        fail_backend_call,
+    )
+    monkeypatch.setattr(
+        AlembicMetaTableMigration,
+        "prepare_for_alembic",
+        fail_backend_call,
+    )
+
+    from alembic import command
+    from alembic.script import ScriptDirectory
+
+    class FakeScriptDirectory:
+        def get_heads(self):
+            return ["0004"]
+
+    def fake_script_directory_from_config(config):
+        captured["script_context_version_locations"] = config.get_main_option(
+            "version_locations"
+        )
+        captured["script_context_path_separator"] = config.get_main_option("path_separator")
+        return FakeScriptDirectory()
+
+    monkeypatch.setattr(
+        ScriptDirectory,
+        "from_config",
+        staticmethod(fake_script_directory_from_config),
+    )
+
+    def fake_revision(config, **kwargs):
+        captured["revision_version_locations"] = config.get_main_option("version_locations")
+        captured["revision_path_separator"] = config.get_main_option("path_separator")
+        captured["version_path"] = kwargs["version_path"]
+        return types.SimpleNamespace(revision=kwargs["rev_id"], path="/tmp/0005_migration.py")
+
+    monkeypatch.setattr(command, "revision", fake_revision)
+
+    result = runner.invoke(
+        cli_mod.app,
+        [
+            "migrations",
+            "revision",
+            "--provider",
+            "ignored:migration",
+            "--rev-id",
+            "0005",
+            "--no-autogenerate",
+        ],
+    )
+
+    assert result.exit_code == 0
+    assert captured["script_context_version_locations"] == version_location
+    assert captured["script_context_path_separator"] == "newline"
+    assert captured["revision_version_locations"] == version_location
+    assert captured["revision_path_separator"] == "newline"
+    assert captured["unresolved_version_path"] == version_location
+    assert captured["version_path"] == resolved_version_path
+
+
 def test_migrations_revision_default_autogenerates_without_metatable_provisioning(monkeypatch):
     cli_mod = _load_cli_module()
     runner = CliRunner()

{mainsequence-4.3.0 → mainsequence-4.3.5}/tests/test_data_access_mixin_dimension_audit.py

@@ -142,7 +142,6 @@ def test_api_data_node_build_from_table_name_uses_physical_table_name(monkeypatc
 
     assert captured == {
         "physical_table_name": "prices_table",
-        "include_relations_detail": True,
     }
     assert node.storage_hash == "prices_table"
     assert node.data_source_uid == "data-source-uid"
@@ -182,7 +181,6 @@ def test_api_persist_manager_resolves_storage_by_table_name_and_data_source(monk
     assert captured == {
         "physical_table_name": "prices_table",
         "data_source__uid": "data-source-uid",
-        "include_relations_detail": True,
     }
 
 

{mainsequence-4.3.0 → mainsequence-4.3.5}/tests/test_filter_normalization.py

@@ -287,6 +287,22 @@ def test_data_node_storage_rejects_data_source_id_filter():
         TimeIndexMetaTable._normalize_filter_kwargs({"data_source__id": {"id": 7}})
 
 
+def test_include_relations_detail_is_only_data_node_update_read_param():
+    from mainsequence.client.metatables import DataNodeUpdate, TimeIndexMetaTable
+
+    assert "include_relations_detail" in DataNodeUpdate.READ_QUERY_PARAMS
+    assert "include_relations_detail" not in (TimeIndexMetaTable.READ_QUERY_PARAMS or {})
+
+    filter_kwargs, read_query_kwargs = TimeIndexMetaTable._split_filter_and_read_query_kwargs(
+        {"include_relations_detail": True}
+    )
+
+    assert read_query_kwargs == {}
+    assert filter_kwargs == {"include_relations_detail": True}
+    with pytest.raises(ValueError, match="Unsupported TimeIndexMetaTable filter"):
+        TimeIndexMetaTable._normalize_filter_kwargs(filter_kwargs)
+
+
 def test_data_node_storage_delete_after_date_posts_tail_delete(monkeypatch):
     from mainsequence.client import metatables as models_metatables
 

{mainsequence-4.3.0 → mainsequence-4.3.5}/tests/test_meta_table_migrations.py

@@ -34,6 +34,7 @@ from mainsequence.meta_tables.migrations import (
     alembic_config_for_provider,
     apply_mainsequence_migration_role,
     load_alembic_metatable_migration_provider,
+    resolve_alembic_revision_metadata,
 )
 
 
@@ -659,6 +660,57 @@ def test_alembic_config_for_provider_uses_scoped_url_and_owner_role():
     )
 
 
+def test_alembic_config_for_provider_supports_namespace_version_locations(tmp_path):
+    script_root = tmp_path / "migrations"
+    namespace_versions = script_root / "versions" / "mainsequence_examples"
+    namespace_versions.mkdir(parents=True)
+    (script_root / "env.py").write_text("", encoding="utf-8")
+    (namespace_versions / "0003_migration.py").write_text(
+        "revision = '0003'\n"
+        "down_revision = None\n"
+        "branch_labels = None\n"
+        "depends_on = None\n",
+        encoding="utf-8",
+    )
+    (namespace_versions / "0004_migration.py").write_text(
+        "revision = '0004'\n"
+        "down_revision = '0003'\n"
+        "branch_labels = None\n"
+        "depends_on = None\n",
+        encoding="utf-8",
+    )
+
+    class ProjectAlembicVersion(AlembicVersionMetaTable):
+        __metatable_data_source_uid__ = "data-source-uid"
+
+    migration = AlembicMetaTableMigration(
+        package="sample",
+        migration_namespace="markets",
+        script_location=str(script_root),
+        version_locations=[str(namespace_versions)],
+        version_path=str(namespace_versions),
+        target_metadata=MetaData(),
+        alembic_registry=ProjectAlembicVersion,
+    )
+
+    config = alembic_config_for_provider(migration, sqlalchemy_url="postgresql://example")
+
+    assert config.get_main_option("version_locations") == str(namespace_versions)
+    assert config.get_main_option("path_separator") == "newline"
+    assert config.attributes["version_locations"] == (str(namespace_versions),)
+    assert config.attributes["version_path"] == str(namespace_versions)
+
+    from alembic.script import ScriptDirectory
+
+    script = ScriptDirectory.from_config(config)
+    assert script.get_revision("0004").revision == "0004"
+    assert resolve_alembic_revision_metadata(
+        script_location=str(script_root),
+        version_locations=[str(namespace_versions)],
+        revision="0004",
+    ) == ("0004", "0003")
+
+
 def test_apply_mainsequence_migration_role_executes_quoted_set_role():
     class FakeConnection:
         def __init__(self):

{mainsequence-4.3.0 → mainsequence-4.3.5}/tests/test_meta_tables_client_models.py

@@ -350,6 +350,7 @@ def test_meta_table_execute_operation_serializes_scope_uid(monkeypatch):
                 parameters={"symbol_1": "%BTC%"},
             ),
             scope=meta_table_models.MetaTableOperationScope(
+                data_source_uid="dddddddd-dddd-4ddd-8ddd-dddddddddddd",
                 tables=[
                     meta_table_models.MetaTableOperationScopeTable(
                         metaTableUid="aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
@@ -367,6 +368,10 @@ def test_meta_table_execute_operation_serializes_scope_uid(monkeypatch):
     assert result["ok"] is True
     assert captured["r_type"] == "POST"
     assert captured["url"].endswith("/ts_manager/meta_table/execute-operation/")
+    assert (
+        captured["payload"]["json"]["scope"]["data_source_uid"]
+        == "dddddddd-dddd-4ddd-8ddd-dddddddddddd"
+    )
     assert captured["payload"]["json"]["scope"]["tables"][0] == {
         "meta_table_uid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
         "alias": "asset",
@@ -697,6 +702,7 @@ def test_compiled_sql_v1_protocol_is_validated_by_pydantic():
         sql="SELECT asset.symbol FROM public.asset AS asset",
         parameters={"symbol_1": "%BTC%"},
         scope={
+            "dataSourceUid": "dddddddd-dddd-4ddd-8ddd-dddddddddddd",
             "tables": [
                 {
                     "metaTableUid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
@@ -712,6 +718,7 @@ def test_compiled_sql_v1_protocol_is_validated_by_pydantic():
     assert operation.version == "compiled-sql.v1"
     assert operation.dialect == "postgresql"
     assert operation.statement.paramstyle == "pyformat"
+    assert operation.scope.data_source_uid == "dddddddd-dddd-4ddd-8ddd-dddddddddddd"
     assert operation.scope.tables[0].meta_table_uid == "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"
     assert operation.scope.tables[0].reserved_policy == "reconcile"
     assert (
@@ -725,6 +732,7 @@ def test_compiled_sql_v1_protocol_is_validated_by_pydantic():
             version="compiled-sql.v2",
             statement=meta_table_models.MetaTableStatementPayload(sql="SELECT 1"),
             scope=meta_table_models.MetaTableOperationScope(
+                data_source_uid="dddddddd-dddd-4ddd-8ddd-dddddddddddd",
                 tables=[
                     meta_table_models.MetaTableOperationScopeTable(
                         metaTableUid="aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
@@ -737,10 +745,40 @@ def test_compiled_sql_v1_protocol_is_validated_by_pydantic():
         meta_table_models.MetaTableCompiledSQLOperation(
             operation="select",
             statement=meta_table_models.MetaTableStatementPayload(sql="SELECT 1"),
-            scope=meta_table_models.MetaTableOperationScope(tables=[]),
+            scope=meta_table_models.MetaTableOperationScope(
+                data_source_uid="dddddddd-dddd-4ddd-8ddd-dddddddddddd",
+                tables=[],
+            ),
         )
 
 
+def test_compiled_sql_v1_scope_resolves_session_data_source(monkeypatch):
+    monkeypatch.setattr(
+        meta_table_models,
+        "get_session_data_source",
+        lambda: SimpleNamespace(uid="dddddddd-dddd-4ddd-8ddd-dddddddddddd"),
+    )
+
+    operation = build_operation(
+        operation="select",
+        sql="SELECT asset.symbol FROM public.asset AS asset",
+        scope={
+            "tables": [
+                {
+                    "metaTableUid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+                    "alias": "asset",
+                }
+            ]
+        },
+    )
+
+    assert operation.scope.data_source_uid == "dddddddd-dddd-4ddd-8ddd-dddddddddddd"
+    assert (
+        operation.model_dump(mode="json", by_alias=True)["scope"]["data_source_uid"]
+        == "dddddddd-dddd-4ddd-8ddd-dddddddddddd"
+    )
+
+
 def test_compiled_sql_v1_serializes_typed_temporal_parameters():
     operation = build_operation(
         operation="select",
@@ -754,6 +792,7 @@ def test_compiled_sql_v1_serializes_typed_temporal_parameters():
             "seen_at": "datetime64[ns, UTC]",
         },
         scope={
+            "data_source_uid": "dddddddd-dddd-4ddd-8ddd-dddddddddddd",
             "tables": [
                 {
                     "metaTableUid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
@@ -780,6 +819,7 @@ def test_compiled_sql_v1_rejects_untyped_temporal_parameters():
             sql="SELECT * FROM asset WHERE as_of = %(as_of)s",
             parameters={"as_of": datetime.date(2026, 5, 28)},
             scope={
+                "data_source_uid": "dddddddd-dddd-4ddd-8ddd-dddddddddddd",
                 "tables": [
                     {
                         "metaTableUid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
@@ -804,6 +844,7 @@ def test_compile_sqlalchemy_statement_emits_temporal_parameter_types():
     operation = compile_sqlalchemy_statement(
         statement,
         operation="select",
+        data_source_uid="dddddddd-dddd-4ddd-8ddd-dddddddddddd",
         scope_tables=[
             {
                 "metaTableUid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
@@ -815,6 +856,7 @@ def test_compile_sqlalchemy_statement_emits_temporal_parameter_types():
     assert operation.statement.parameter_types == {
         "seen_at": "timestamp with time zone",
     }
+    assert operation.scope.data_source_uid == "dddddddd-dddd-4ddd-8ddd-dddddddddddd"
     assert operation.statement.parameters["seen_at"] == "2026-05-28T12:30:00Z"
 
 
@@ -833,6 +875,7 @@ def test_compile_sqlalchemy_statement_rejects_naive_datetime_bind_types():
         compile_sqlalchemy_statement(
             statement,
             operation="select",
+            data_source_uid="dddddddd-dddd-4ddd-8ddd-dddddddddddd",
             scope_tables=[
                 {
                     "metaTableUid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",