sqlbuild 0.63.0__tar.gz → 0.63.2__tar.gz

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/Cargo.lock

@@ -572,7 +572,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-kata-native"
-version = "0.63.0"
+version = "0.63.2"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.63.0
+Version: 0.63.2
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: polyglot-sql>=0.9.2

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/crates/sqlbuild-kata-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-kata-native"
-version = "0.63.0"
+version = "0.63.2"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.63.0"
+version = "0.63.2"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/src/sqlbuild/adapter/contract/classes/base_adapter.py

@@ -43,6 +43,9 @@ from sqlbuild.adapter.contract.types import (
     PromotionStrategy,
     TablePromotionMode,
 )
+from sqlbuild.adapter.relations.main.get_columns_for_relations import (
+    get_columns_for_relations_bulk,
+)
 from sqlbuild.adapter.state_sql.main.render_insert_source_freshness_records_sql import (
     render_insert_source_freshness_records_sql,
 )
@@ -370,6 +373,18 @@ class BaseAdapter(StrictAdapter):
             result[table_name].append(ColumnInfo(name=row[1], type=row[2]))
         return {k: tuple(v) for k, v in result.items()}
 
+    def get_columns_for_relations(
+        self,
+        *,
+        connection: Any,
+        relations: tuple[RelationInfo, ...],
+    ) -> dict[tuple[str | None, str | None, str], tuple[ColumnInfo, ...]]:
+        """Fetch columns keyed by fully qualified physical relation identity."""
+
+        return get_columns_for_relations_bulk(
+            adapter=self, connection=connection, relations=relations
+        )
+
     def render_create_schema(
         self,
         *,

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/src/sqlbuild/adapter/contract/classes/duckdb_backed_adapter.py

@@ -51,6 +51,9 @@ from sqlbuild.adapter.contract.types import (
     PromotionStrategy,
     TablePromotionMode,
 )
+from sqlbuild.adapter.relations.main.get_columns_for_relations import (
+    get_columns_for_relations_bulk,
+)
 from sqlbuild.adapter.state_sql.main.render_insert_source_freshness_records_sql import (
     render_insert_source_freshness_records_sql,
 )
@@ -69,6 +72,16 @@ from sqlbuild.sql_values.models import SqlValue
 class DuckDbBackedAdapter(BaseAdapter):
     """Shared adapter implementation for DuckDB-backed connections."""
 
+    def get_columns_for_relations(
+        self,
+        *,
+        connection: Any,
+        relations: tuple[RelationInfo, ...],
+    ) -> dict[tuple[str | None, str | None, str], tuple[ColumnInfo, ...]]:
+        return get_columns_for_relations_bulk(
+            adapter=self, connection=connection, relations=relations
+        )
+
     sql_analysis_dialect_name: ClassVar[str | None] = "duckdb"
 
     def supports_zero_copy_clone(self) -> bool:

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/src/sqlbuild/adapter/contract/classes/schema.py

@@ -59,6 +59,16 @@ class SchemaMixin(ABC):
         """Return column metadata for all relations in the given scope."""
         ...
 
+    @abstractmethod
+    def get_columns_for_relations(
+        self,
+        *,
+        connection: Any,
+        relations: tuple[RelationInfo, ...],
+    ) -> dict[tuple[str | None, str | None, str], tuple[ColumnInfo, ...]]:
+        """Return columns keyed by fully qualified physical relation identity."""
+        ...
+
     @abstractmethod
     def relation_exists(
         self,

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/src/sqlbuild/adapter/contract/models.py

@@ -73,6 +73,12 @@ class RelationInfo:
     last_altered_at: datetime | None = None
     is_transient: bool | None = None
 
+    @property
+    def identity(self) -> tuple[str | None, str | None, str]:
+        """Return the case-insensitive physical relation identity."""
+
+        return RelationLookup.key(database=self.database, schema=self.schema, name=self.name)
+
 
 @dataclass(frozen=True)
 class RelationLookup:

sqlbuild-0.63.2/src/sqlbuild/adapter/relations/constants.py

@@ -0,0 +1,3 @@
+"""Shared relation metadata limits."""
+
+METADATA_NAME_FILTER_LIMIT: int = 250

sqlbuild-0.63.2/src/sqlbuild/adapter/relations/main/get_columns_for_relations.py

@@ -0,0 +1,69 @@
+"""Adapter-neutral qualified bulk column retrieval."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sqlbuild.adapter.contract.models import ColumnInfo, RelationInfo
+from sqlbuild.adapter.relations.constants import METADATA_NAME_FILTER_LIMIT
+
+
+def get_columns_for_relations_bulk(
+    *,
+    adapter: Any,
+    connection: Any,
+    relations: tuple[RelationInfo, ...],
+) -> dict[tuple[str | None, str | None, str], tuple[ColumnInfo, ...]]:
+    """Fetch one bulk column result per database/schema and restore qualified keys."""
+
+    relations_by_scope: dict[tuple[str | None, str | None], list[RelationInfo]] = {}
+    relation: RelationInfo
+    for relation in relations:
+        scope: tuple[str | None, str | None] = (relation.database, relation.schema)
+        relations_by_scope.setdefault(scope, []).append(relation)
+    return _gather_scope_columns(
+        adapter=adapter,
+        connection=connection,
+        scopes=tuple(relations_by_scope.items()),
+        scope_index=0,
+        result={},
+    )
+
+
+def _gather_scope_columns(
+    *,
+    adapter: Any,
+    connection: Any,
+    scopes: tuple[tuple[tuple[str | None, str | None], list[RelationInfo]], ...],
+    scope_index: int,
+    result: dict[tuple[str | None, str | None, str], tuple[ColumnInfo, ...]],
+) -> dict[tuple[str | None, str | None, str], tuple[ColumnInfo, ...]]:
+    if scope_index >= len(scopes):
+        return result
+    scope, relations = scopes[scope_index]
+    database, schema = scope
+    columns_by_name: dict[str, tuple[ColumnInfo, ...]] = adapter.get_all_columns(
+        connection=connection,
+        database=database,
+        schemas=None if schema is None else (schema,),
+        names=(
+            None
+            if len(relations) > METADATA_NAME_FILTER_LIMIT
+            else tuple(relation.name for relation in relations)
+        ),
+    )
+    normalized_columns: dict[str, tuple[ColumnInfo, ...]] = {
+        name.lower(): columns for name, columns in columns_by_name.items()
+    }
+    relation: RelationInfo
+    for relation in relations:
+        columns: tuple[ColumnInfo, ...] | None = normalized_columns.get(relation.name.lower())
+        if columns is not None:
+            result[relation.identity] = columns
+    return _gather_scope_columns(
+        adapter=adapter,
+        connection=connection,
+        scopes=scopes,
+        scope_index=scope_index + 1,
+        result=result,
+    )

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/src/sqlbuild/adapters/bigquery/classes/bigquery_adapter.py

@@ -52,6 +52,9 @@ from sqlbuild.adapter.contract.types import (
     PromotionStrategy,
     TablePromotionMode,
 )
+from sqlbuild.adapter.relations.main.get_columns_for_relations import (
+    get_columns_for_relations_bulk,
+)
 from sqlbuild.adapter.state_sql.main.render_insert_source_freshness_records_sql import (
     render_insert_source_freshness_records_sql,
 )
@@ -92,6 +95,16 @@ from sqlbuild.sql_values.types import SqlValueKind
 class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
     """BigQuery adapter backed by google-cloud-bigquery."""
 
+    def get_columns_for_relations(
+        self,
+        *,
+        connection: Any,
+        relations: tuple[RelationInfo, ...],
+    ) -> dict[tuple[str | None, str | None, str], tuple[ColumnInfo, ...]]:
+        return get_columns_for_relations_bulk(
+            adapter=self, connection=connection, relations=relations
+        )
+
     adapter_name: ClassVar[str] = BuiltinAdapter.BIGQUERY.value
     sql_analysis_dialect_name: ClassVar[str | None] = "bigquery"
     max_identifier_length: ClassVar[int] = 1024

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/src/sqlbuild/adapters/databricks/classes/databricks_adapter.py

@@ -49,6 +49,9 @@ from sqlbuild.adapter.contract.types import (
     RelationType,
     TablePromotionMode,
 )
+from sqlbuild.adapter.relations.main.get_columns_for_relations import (
+    get_columns_for_relations_bulk,
+)
 from sqlbuild.adapter.state_sql.main.render_insert_source_freshness_records_sql import (
     render_insert_source_freshness_records_sql,
 )
@@ -75,6 +78,16 @@ from sqlbuild.sql_values.models import SqlValue
 class DatabricksAdapter(MicrobatchMixin, BaseAdapter):
     """Databricks adapter backed by databricks-sql-connector."""
 
+    def get_columns_for_relations(
+        self,
+        *,
+        connection: Any,
+        relations: tuple[RelationInfo, ...],
+    ) -> dict[tuple[str | None, str | None, str], tuple[ColumnInfo, ...]]:
+        return get_columns_for_relations_bulk(
+            adapter=self, connection=connection, relations=relations
+        )
+
     adapter_name: ClassVar[str] = BuiltinAdapter.DATABRICKS.value
     sql_analysis_dialect_name: ClassVar[str | None] = "databricks"
     max_identifier_length: ClassVar[int] = 255

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/src/sqlbuild/adapters/postgres/classes/postgres_adapter.py

@@ -63,6 +63,9 @@ from sqlbuild.adapter.contract.types import (
     PromotionStrategy,
     TablePromotionMode,
 )
+from sqlbuild.adapter.relations.main.get_columns_for_relations import (
+    get_columns_for_relations_bulk,
+)
 from sqlbuild.adapter.state_sql.main.render_insert_source_freshness_records_sql import (
     render_insert_source_freshness_records_sql,
 )
@@ -81,6 +84,16 @@ from sqlbuild.sql_values.models import SqlValue
 class PostgresAdapter(MicrobatchMixin, BaseAdapter):
     """PostgreSQL adapter backed by psycopg."""
 
+    def get_columns_for_relations(
+        self,
+        *,
+        connection: Any,
+        relations: tuple[RelationInfo, ...],
+    ) -> dict[tuple[str | None, str | None, str], tuple[ColumnInfo, ...]]:
+        return get_columns_for_relations_bulk(
+            adapter=self, connection=connection, relations=relations
+        )
+
     adapter_name: ClassVar[str] = BuiltinAdapter.POSTGRES.value
     sql_analysis_dialect_name: ClassVar[str | None] = "postgres"
     max_identifier_length: ClassVar[int] = 63

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/src/sqlbuild/adapters/snowflake/classes/snowflake_adapter.py

@@ -27,6 +27,7 @@ from sqlbuild.adapter.contract.models import (
     FunctionDefinition,
     FunctionInfo,
     QueryResult,
+    RelationInfo,
     RowDiffColumnResult,
     RowDiffResult,
     RowDiffSampleCell,
@@ -66,6 +67,7 @@ from sqlbuild.adapters.snowflake.constants import (
     SUCCESS_STATUS_TOKENS,
     TEXT_TYPE_NAMES,
     TRUE_METADATA_VALUE,
+    VIEW_RELATION_TYPE_TOKEN,
 )
 from sqlbuild.compiler.compile.types import FunctionLanguage
 from sqlbuild.compiler.planner.types import InitialValidFrom, SnapshotStrategy
@@ -78,6 +80,9 @@ from sqlbuild.spec.contracts.constants import DEFAULT_SEED_CSV_SETTINGS
 from sqlbuild.spec.contracts.models import SeedCsvSettings
 from sqlbuild.sql_values.models import SqlValue
 
+_EXACT_COLUMN_INSPECTION_LIMIT: int = 32
+_BULK_COLUMN_RELATION_CHUNK_SIZE: int = 200
+
 
 class SnowflakeAdapter(MicrobatchMixin, BaseAdapter):
     """Snowflake adapter backed by snowflake-connector-python."""
@@ -155,6 +160,11 @@ class SnowflakeAdapter(MicrobatchMixin, BaseAdapter):
     def _information_schema_identifier(value: str) -> str:
         return value.upper()
 
+    def _information_schema_relation(self, *, database: str | None, name: str) -> str:
+        if database is None:
+            return f"information_schema.{name}"
+        return f"{self.render_identifier(database)}.information_schema.{name}"
+
     @staticmethod
     def _freshness_request_key(
         *, database: str | None, schema: str | None, name: str
@@ -367,7 +377,9 @@ class SnowflakeAdapter(MicrobatchMixin, BaseAdapter):
         cursor: Any = connection.cursor()
         try:
             cursor.execute(
-                "SELECT table_type, last_altered FROM information_schema.tables WHERE "
+                "SELECT table_type, last_altered FROM "
+                + self._information_schema_relation(database=database, name="tables")
+                + " WHERE "
                 + " AND ".join(clauses),
                 tuple(params),
             )
@@ -441,7 +453,12 @@ class SnowflakeAdapter(MicrobatchMixin, BaseAdapter):
             try:
                 cursor.execute(
                     "SELECT table_catalog, table_schema, table_name, table_type, last_altered "
-                    "FROM information_schema.tables WHERE " + " AND ".join(clauses),
+                    "FROM "
+                    + self._information_schema_relation(
+                        database=scoped_requests[0].database, name="tables"
+                    )
+                    + " WHERE "
+                    + " AND ".join(clauses),
                     tuple(params),
                 )
                 rows: list[tuple[Any, ...]] = list(cursor.fetchall())
@@ -1539,7 +1556,10 @@ class SnowflakeAdapter(MicrobatchMixin, BaseAdapter):
         cursor: Any = connection.cursor()
         try:
             cursor.execute(
-                "SELECT 1 FROM information_schema.tables WHERE " + " AND ".join(clauses),
+                "SELECT 1 FROM "
+                + self._information_schema_relation(database=database, name="tables")
+                + " WHERE "
+                + " AND ".join(clauses),
                 tuple(params),
             )
             return cursor.fetchone() is not None
@@ -1556,7 +1576,7 @@ class SnowflakeAdapter(MicrobatchMixin, BaseAdapter):
     ) -> tuple[Any, ...]:
         query: str = (
             "SELECT table_name, table_schema, table_type, is_transient "
-            "FROM information_schema.tables WHERE 1=1"
+            f"FROM {self._information_schema_relation(database=database, name='tables')} WHERE 1=1"
         )
         params: list[str] = []
         if schemas:
@@ -1641,7 +1661,9 @@ class SnowflakeAdapter(MicrobatchMixin, BaseAdapter):
     ) -> tuple[ColumnInfo, ...]:
         query: str = (
             "SELECT column_name, data_type, numeric_precision, numeric_scale, "
-            "character_maximum_length FROM information_schema.columns "
+            "character_maximum_length FROM "
+            + self._information_schema_relation(database=database, name="columns")
+            + " "
             "WHERE table_name = %s"
         )
         params: list[str] = [self._information_schema_identifier(name)]
@@ -1681,7 +1703,9 @@ class SnowflakeAdapter(MicrobatchMixin, BaseAdapter):
     ) -> dict[str, tuple[ColumnInfo, ...]]:
         query: str = (
             "SELECT table_name, column_name, data_type, numeric_precision, numeric_scale, "
-            "character_maximum_length FROM information_schema.columns WHERE 1=1"
+            "character_maximum_length FROM "
+            + self._information_schema_relation(database=database, name="columns")
+            + " WHERE 1=1"
         )
         params: list[str] = []
         if schemas:
@@ -1719,6 +1743,157 @@ class SnowflakeAdapter(MicrobatchMixin, BaseAdapter):
             )
         return {key: tuple(value) for key, value in result.items()}
 
+    def get_columns_for_relations(
+        self,
+        *,
+        connection: _SnowflakeConnection,
+        relations: tuple[RelationInfo, ...],
+    ) -> dict[tuple[str | None, str | None, str], tuple[ColumnInfo, ...]]:
+        """Use exact SHOW calls for sparse plans and qualified bulk metadata for broad plans."""
+
+        ordered_relations: tuple[RelationInfo, ...] = tuple(
+            sorted(
+                relations,
+                key=lambda relation: tuple(part or "" for part in relation.identity),
+            )
+        )
+        if len(ordered_relations) <= _EXACT_COLUMN_INSPECTION_LIMIT:
+            return {
+                relation.identity: self._show_columns_for_relation(
+                    connection=connection, relation=relation
+                )
+                for relation in ordered_relations
+            }
+        return self._get_columns_for_relations_bulk(
+            connection=connection, relations=ordered_relations
+        )
+
+    def _show_columns_for_relation(
+        self,
+        *,
+        connection: _SnowflakeConnection,
+        relation: RelationInfo,
+    ) -> tuple[ColumnInfo, ...]:
+        qualified_name: str | None = self.render_qualified_name(
+            database=relation.database,
+            schema=relation.schema,
+            name=relation.name,
+        )
+        if qualified_name is None:
+            raise AdapterUserError(message=f"Snowflake relation is not qualified: {relation.name}")
+        relation_kind: str = (
+            "VIEW" if VIEW_RELATION_TYPE_TOKEN in relation.relation_type.lower() else "TABLE"
+        )
+        cursor: Any = connection.cursor()
+        try:
+            cursor.execute(f"SHOW COLUMNS IN {relation_kind} {qualified_name}")
+            rows: list[tuple[Any, ...]] = list(cursor.fetchall())
+        finally:
+            cursor.close()
+        return tuple(
+            ColumnInfo(
+                name=str(row[2]).lower(),
+                type=self._build_show_columns_type(raw_data_type=row[3]),
+            )
+            for row in rows
+        )
+
+    def _get_columns_for_relations_bulk(
+        self,
+        *,
+        connection: _SnowflakeConnection,
+        relations: tuple[RelationInfo, ...],
+    ) -> dict[tuple[str | None, str | None, str], tuple[ColumnInfo, ...]]:
+        by_database: dict[str | None, list[RelationInfo]] = {}
+        for relation in relations:
+            by_database.setdefault(relation.database, []).append(relation)
+        result: dict[tuple[str | None, str | None, str], list[ColumnInfo]] = {}
+        for database, database_relations in by_database.items():
+            chunk_start: int
+            for chunk_start in range(0, len(database_relations), _BULK_COLUMN_RELATION_CHUNK_SIZE):
+                chunk: list[RelationInfo] = database_relations[
+                    chunk_start : chunk_start + _BULK_COLUMN_RELATION_CHUNK_SIZE
+                ]
+                rows: list[tuple[Any, ...]] = self._get_columns_for_relations_bulk_chunk(
+                    connection=connection, database=database, relations=chunk
+                )
+                for row in rows:
+                    identity: tuple[str | None, str | None, str] = (
+                        None if database is None else str(row[0]).lower(),
+                        None if row[1] is None else str(row[1]).lower(),
+                        str(row[2]).lower(),
+                    )
+                    result.setdefault(identity, []).append(
+                        ColumnInfo(
+                            name=str(row[3]).lower(),
+                            type=self._build_information_schema_type(
+                                data_type=str(row[4]),
+                                numeric_precision=row[5],
+                                numeric_scale=row[6],
+                                character_maximum_length=row[7],
+                            ),
+                        )
+                    )
+        return {identity: tuple(columns) for identity, columns in result.items()}
+
+    def _get_columns_for_relations_bulk_chunk(
+        self,
+        *,
+        connection: _SnowflakeConnection,
+        database: str | None,
+        relations: list[RelationInfo],
+    ) -> list[tuple[Any, ...]]:
+        scopes: dict[str | None, list[str]] = {}
+        for relation in relations:
+            scopes.setdefault(relation.schema, []).append(relation.name)
+        clauses: list[str] = []
+        params: list[str] = []
+        for schema, names in sorted(scopes.items(), key=lambda item: item[0] or ""):
+            name_placeholders: str = ", ".join(["%s"] * len(names))
+            if schema is None:
+                clauses.append(f"table_name IN ({name_placeholders})")
+            else:
+                clauses.append(f"(table_schema = %s AND table_name IN ({name_placeholders}))")
+                params.append(self._information_schema_identifier(schema))
+            params.extend(self._information_schema_identifier(name) for name in names)
+        metadata_table: str = self._information_schema_relation(database=database, name="columns")
+        query: str = (
+            "SELECT table_catalog, table_schema, table_name, column_name, data_type, "
+            "numeric_precision, numeric_scale, character_maximum_length "
+            f"FROM {metadata_table} WHERE "
+            + " OR ".join(clauses)
+            + " ORDER BY table_catalog, table_schema, table_name, ordinal_position"
+        )
+        cursor: Any = connection.cursor()
+        try:
+            cursor.execute(query, tuple(params))
+            return list(cursor.fetchall())
+        finally:
+            cursor.close()
+
+    def _build_show_columns_type(self, *, raw_data_type: object) -> str:
+        try:
+            decoded_data_type: object = json.loads(str(raw_data_type))
+        except (json.JSONDecodeError, TypeError) as error:
+            raise AdapterUserError(
+                message="Snowflake SHOW COLUMNS returned invalid type metadata"
+            ) from error
+        if not isinstance(decoded_data_type, dict):
+            raise AdapterUserError(message="Snowflake SHOW COLUMNS returned invalid type metadata")
+        data_type: dict[str, object] = decoded_data_type
+        raw_name: str = str(data_type.get("type", ""))
+        normalized_name: str = {
+            "FIXED": NUMBER_TYPE_NAME,
+            "TEXT": "VARCHAR",
+            "REAL": "FLOAT",
+        }.get(raw_name.upper(), raw_name.upper())
+        return self._build_information_schema_type(
+            data_type=normalized_name,
+            numeric_precision=data_type.get("precision"),
+            numeric_scale=data_type.get("scale"),
+            character_maximum_length=data_type.get("length"),
+        )
+
     def close(self, connection: _SnowflakeConnection) -> None:
         """Close a Snowflake connection."""
 

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/src/sqlbuild/adapters/snowflake/constants.py

@@ -1,6 +1,7 @@
 """Snowflake adapter constants."""
 
 BASE_TABLE_METADATA_TYPE: str = "BASE TABLE"
+VIEW_RELATION_TYPE_TOKEN: str = "view"
 EXTERNAL_BROWSER_AUTHENTICATOR: str = "externalbrowser"
 MFA_AUTHENTICATOR: str = "username_password_mfa"
 OAUTH_AUTHORIZATION_CODE_AUTHENTICATOR: str = "oauth_authorization_code"

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/src/sqlbuild/adapters/sqlserver/classes/sqlserver_adapter.py

@@ -58,6 +58,9 @@ from sqlbuild.adapter.contract.types import (
     PromotionStrategy,
     TablePromotionMode,
 )
+from sqlbuild.adapter.relations.main.get_columns_for_relations import (
+    get_columns_for_relations_bulk,
+)
 from sqlbuild.adapter.state_sql.main.render_insert_source_freshness_records_sql import (
     render_insert_source_freshness_records_sql,
 )
@@ -84,6 +87,16 @@ from sqlbuild.sql_values.types import SqlValueKind
 class SqlServerAdapter(MicrobatchMixin, BaseAdapter):
     """Microsoft SQL Server adapter backed by pymssql."""
 
+    def get_columns_for_relations(
+        self,
+        *,
+        connection: Any,
+        relations: tuple[RelationInfo, ...],
+    ) -> dict[tuple[str | None, str | None, str], tuple[ColumnInfo, ...]]:
+        return get_columns_for_relations_bulk(
+            adapter=self, connection=connection, relations=relations
+        )
+
     adapter_name: ClassVar[str] = BuiltinAdapter.SQLSERVER.value
     sql_analysis_dialect_name: ClassVar[str | None] = "tsql"
     max_identifier_length: ClassVar[int] = 128

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/src/sqlbuild/cli/commands/_helpers/build_python_nodes/python_lifecycle.py

@@ -21,9 +21,7 @@ from sqlbuild.cli.commands.models import DirectLifecycleCallbacks
 from sqlbuild.compiler.compile.models import CompiledObjectKey
 from sqlbuild.compiler.compile.types import CompiledResourceType
 from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs
-from sqlbuild.compiler.pipeline.main.relation_targets import (
-    build_python_relation_targets,
-)
+from sqlbuild.compiler.pipeline.main.relation_targets import build_python_relation_targets
 from sqlbuild.compiler.pipeline.models import CompilePipelineResult
 from sqlbuild.compiler.planner.main.selection.loader_dag import build_intermediate_source_map
 from sqlbuild.compiler.planner.models import PlanOutput
@@ -95,6 +93,12 @@ def prepare_direct_python_lifecycle(
         adapter=adapter,
         project=pipeline_result.project,
         plan_output=plan_output,
+        required_refs=python_graph.selected_sql_refs(
+            selected_names=(
+                lifecycle_plan.ingress_python_node_names
+                | lifecycle_plan.read_side_python_node_names
+            ),
+        ),
     )
     default_database: str | None = pipeline_result.project.effective_target_database
     if default_database is None:

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/src/sqlbuild/cli/commands/_helpers/check/core.py

@@ -15,9 +15,7 @@ from sqlbuild.adapter.relations.main.resolve_relation_location_qualified_name im
 from sqlbuild.cli.commands.exceptions import CliUserError
 from sqlbuild.compiler.compile.models import CompiledRelationLocation
 from sqlbuild.compiler.discovery.models import DiscoveredCheckFunction, DiscoveredProjectInputs
-from sqlbuild.compiler.pipeline.main.relation_targets import (
-    build_python_relation_targets,
-)
+from sqlbuild.compiler.pipeline.main.relation_targets import build_python_relation_targets
 from sqlbuild.compiler.pipeline.models import CompilePipelineResult
 from sqlbuild.compiler.planner.exceptions import PlannerInputError
 from sqlbuild.compiler.planner.main.selection.selector_parse import parse_project_selector
@@ -141,7 +139,11 @@ def record_python_run_state_results(
 
 
 def build_check_relation_targets(
-    *, adapter: BaseAdapter, pipeline_result: CompilePipelineResult
+    *,
+    adapter: BaseAdapter,
+    pipeline_result: CompilePipelineResult,
+    python_graph: PythonNodeGraph,
+    selected_python_names: frozenset[str],
 ) -> dict[SqlResourceRef, str]:
     """Return SQL relation locations available to Python check dependencies."""
 
@@ -149,6 +151,9 @@ def build_check_relation_targets(
         adapter=adapter,
         project=pipeline_result.project,
         plan_output=pipeline_result.plan_output,
+        required_refs=python_graph.selected_sql_refs(
+            selected_names=selected_python_names,
+        ),
     )
 
 

{sqlbuild-0.63.0 → sqlbuild-0.63.2}/src/sqlbuild/cli/commands/_helpers/check/execution.py

@@ -67,6 +67,8 @@ def prepare_check_execution(
     relation_targets: dict[SqlResourceRef, str] = build_check_relation_targets(
         adapter=invocation.adapter,
         pipeline_result=pipeline_result,
+        python_graph=python_graph,
+        selected_python_names=check_names,
     )
     return CheckExecutionPreparation(
         python_graph=python_graph,