sqlbuild 0.74.4__tar.gz → 0.75.1__tar.gz

{sqlbuild-0.74.4 → sqlbuild-0.75.1}/Cargo.lock

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

{sqlbuild-0.74.4 → sqlbuild-0.75.1}/PKG-INFO

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

{sqlbuild-0.74.4 → sqlbuild-0.75.1}/crates/sqlbuild-kata-native/Cargo.toml

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

{sqlbuild-0.74.4 → sqlbuild-0.75.1}/pyproject.toml

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

{sqlbuild-0.74.4 → sqlbuild-0.75.1}/src/sqlbuild/compiler/contracts/_helpers/columns.py

@@ -32,6 +32,7 @@ _MISSING_DECLARATIONS_CODE: str = "K006"
 def collect_model_column_contract_diagnostics(
     *,
     model: CompiledModel,
+    validate_declared_shape: bool,
     dialect: TypeDialect | str | None = None,
 ) -> tuple[CompilerDiagnostic, ...]:
     """Collect diagnostics for one compiled model's declared column contract."""
@@ -54,17 +55,30 @@ def collect_model_column_contract_diagnostics(
     for declared_column in model.schema_entry.columns:
         inferred_column: InferredColumn | None = inferred_by_name.get(declared_column.name)
         if inferred_column is None:
-            diagnostics.append(_missing_column_diagnostic(model=model, column=declared_column))
+            if validate_declared_shape:
+                diagnostics.append(
+                    _missing_column_diagnostic(
+                        model=model,
+                        column=declared_column,
+                        contract_enforced=contract_enforced,
+                    )
+                )
             continue
-        diagnostics.extend(
-            _nullability_diagnostics(
-                model=model,
-                declared_column=declared_column,
-                inferred_column=inferred_column,
+        if validate_declared_shape:
+            diagnostics.extend(
+                _nullability_diagnostics(
+                    model=model,
+                    declared_column=declared_column,
+                    inferred_column=inferred_column,
+                )
             )
-        )
         if declared_column.type is None:
             continue
+        type_enforcement: bool = model.schema_entry is not None and bool(
+            model.schema_entry.type_enforcement
+        )
+        if not validate_declared_shape and not type_enforcement:
+            continue
         diagnostics.extend(
             _type_diagnostics(
                 model=model,
@@ -160,22 +174,45 @@ def _declares_not_null(column: SchemaColumn) -> bool:
     return any(audit.definition_name == NOT_NULL_AUDIT_NAME for audit in column.audits)
 
 
-def _missing_column_diagnostic(*, model: CompiledModel, column: SchemaColumn) -> CompilerDiagnostic:
+def _missing_column_diagnostic(
+    *, model: CompiledModel, column: SchemaColumn, contract_enforced: bool
+) -> CompilerDiagnostic:
+    contract_label: str = "enforced contract column" if contract_enforced else "declared column"
+    declared_in_named_schema: bool = (
+        model.schema_entry is not None
+        and model.schema_entry.model_schema is not None
+        and column.location is not None
+        and column.location.path != model.relative_path
+    )
+    declaration_label: str = (
+        "the named SCHEMA declaration" if declared_in_named_schema else "MODEL(columns (...))"
+    )
+    help_text: str = (
+        f"add {column.name} to the SELECT list or correct {declaration_label}; "
+        "validation is active because this model declares contract enforced"
+        if contract_enforced
+        else (
+            f"add {column.name} to the SELECT list or correct/remove {declaration_label}; "
+            f"{declaration_label} is validated using static SQL analysis because "
+            'settings.column_contract_mode is "implicit" (the default). If this project '
+            "intentionally uses columns only for metadata and audits, set [settings] "
+            'column_contract_mode = "explicit"; models with contract enforced remain validated'
+        )
+    )
     return CompilerDiagnostic(
         phase=DiagnosticPhase.CONTRACT,
         severity=DiagnosticSeverity.ERROR,
         code=_MISSING_COLUMN_CODE,
-        message=f"required column '{column.name}' missing from model output",
+        message=(
+            f"{contract_label} '{column.name}' was not found in statically inferred output "
+            f"for model '{model.name}'"
+        ),
         resource_type=CompiledResourceType.MODEL,
         resource_name=model.name,
         column_name=column.name,
         path=model.relative_path,
         location=column.location,
-        help=(
-            f"add {column.name} to the SELECT list or remove it from the named SCHEMA"
-            if model.schema_entry is not None and model.schema_entry.model_schema is not None
-            else f"add {column.name} to the SELECT list or remove it from MODEL(columns)"
-        ),
+        help=help_text,
     )
 
 
@@ -219,7 +256,7 @@ def _type_diagnostics(
                     column_name=declared_column.name,
                     message="output expression with unproven type",
                 ),
-                help="add an explicit CAST if this contract should be checked statically",
+                help="add an explicit CAST if this declared type should be checked statically",
             ),
         )
 
@@ -235,7 +272,7 @@ def _type_diagnostics(
             code=_TYPE_MISMATCH_CODE,
             message=(
                 f"column '{declared_column.name}' inferred as {inferred_column.type} "
-                f"but contract declares {declared_type}"
+                f"but declared type is {declared_type}"
             ),
             resource_type=CompiledResourceType.MODEL,
             resource_name=model.name,

sqlbuild-0.75.1/src/sqlbuild/compiler/contracts/main/validate.py

@@ -0,0 +1,56 @@
+"""Validate compiled model contracts."""
+
+from __future__ import annotations
+
+from sqlbuild.adapter.contract.types import TypeDialect
+from sqlbuild.compiler.compile.models import CompiledModel, CompiledProject, CompilerDiagnostic
+from sqlbuild.compiler.contracts._helpers.columns import collect_model_column_contract_diagnostics
+from sqlbuild.compiler.contracts.models import ContractValidationResult
+from sqlbuild.compiler.planner.types import ContractPolicy
+from sqlbuild.spec.contracts.types import ColumnContractMode
+
+
+def evaluate_model_contracts(
+    *,
+    project: CompiledProject,
+    dialect: TypeDialect | str | None = None,
+) -> ContractValidationResult:
+    """Evaluate model header column contracts against inferred output columns."""
+
+    if not any(
+        _requires_contract_evaluation(model=model, mode=project.settings.column_contract_mode)
+        for model in project.models
+    ):
+        return ContractValidationResult(diagnostics=())
+
+    diagnostics: list[CompilerDiagnostic] = []
+    for model in project.models:
+        if _requires_contract_evaluation(model=model, mode=project.settings.column_contract_mode):
+            diagnostics.extend(
+                collect_model_column_contract_diagnostics(
+                    model=model,
+                    validate_declared_shape=_declared_shape_validation_is_active(
+                        model=model,
+                        mode=project.settings.column_contract_mode,
+                    ),
+                    dialect=dialect,
+                )
+            )
+    return ContractValidationResult(diagnostics=tuple(diagnostics))
+
+
+def _requires_contract_evaluation(*, model: CompiledModel, mode: ColumnContractMode) -> bool:
+    if _declared_shape_validation_is_active(model=model, mode=mode):
+        return True
+    return model.schema_entry is not None and bool(model.schema_entry.type_enforcement)
+
+
+def _declared_shape_validation_is_active(*, model: CompiledModel, mode: ColumnContractMode) -> bool:
+    contract: object = model.config.values.get("contract")
+    if contract == ContractPolicy.ENFORCED:
+        return True
+    if contract == ContractPolicy.NONE:
+        return False
+    return mode == ColumnContractMode.IMPLICIT and bool(
+        model.schema_entry is not None and model.schema_entry.columns
+    )

{sqlbuild-0.74.4 → sqlbuild-0.75.1}/src/sqlbuild/compiler/discovery/_helpers/yml/project.py

@@ -65,6 +65,7 @@ from sqlbuild.spec.contracts.models import (
     TargetConfig,
 )
 from sqlbuild.spec.contracts.types import (
+    ColumnContractMode,
     FutureCursorAction,
     MicrobatchLimitAction,
     TableType,
@@ -322,6 +323,15 @@ def _load_settings(*, payload: object, file_path: Path) -> SettingsConfig:
         default=True,
     )
     sql_validation: bool = _optional_bool(mapping=mapping, key="sql_validation", default=True)
+    raw_column_contract_mode: object = mapping.get(
+        "column_contract_mode", ColumnContractMode.IMPLICIT.value
+    )
+    try:
+        column_contract_mode: ColumnContractMode = ColumnContractMode(raw_column_contract_mode)
+    except (TypeError, ValueError) as error:
+        raise ProjectConfigError(
+            "settings.column_contract_mode must be one of: implicit, explicit"
+        ) from error
     auto_load_sources: bool = _optional_bool(mapping=mapping, key="auto_load_sources", default=True)
     virtual_environments: bool = _optional_bool(
         mapping=mapping,
@@ -361,6 +371,7 @@ def _load_settings(*, payload: object, file_path: Path) -> SettingsConfig:
         sql_analysis=sql_analysis,
         query_change_tracking=query_change_tracking,
         sql_validation=sql_validation,
+        column_contract_mode=column_contract_mode,
         concurrency=concurrency,
         auto_load_sources=auto_load_sources,
         changes_only=changes_only,

{sqlbuild-0.74.4 → sqlbuild-0.75.1}/src/sqlbuild/integrations/dagster/_helpers/invocation.py

@@ -11,6 +11,7 @@ from typing import IO, TYPE_CHECKING, Any, TextIO
 
 from sqlbuild.integrations.dagster.constants import (
     ASSET_SELECTION_COMMANDS,
+    CHECK_COMMAND,
     CHECK_METADATA_EXCLUDED_KEYS,
     CHECK_NAME_SEPARATOR_CHARACTER,
     CLONE_ASSET_EVENT,
@@ -88,10 +89,27 @@ def _with_selected_asset_args(
         return args, (), None
     if not EXPLICIT_SELECTION_FLAGS.isdisjoint(args):
         return args, (), None
-    selected_keys: object = getattr(context, "selected_asset_keys", None)
-    if selected_keys is None:
+    selected_paths: set[tuple[str, ...]] = _selected_asset_paths(context=context)
+    selected_check_keys: set[tuple[tuple[str, ...], str]] = _selected_asset_check_keys(
+        context=context
+    )
+    if args[0] == CHECK_COMMAND and selected_check_keys:
+        check_selectors: tuple[str, ...] = _selected_check_selectors(
+            dag=dag, selected_check_keys=selected_check_keys
+        )
+        if check_selectors:
+            selector_file: Path = _write_selector_file(check_selectors)
+            return (
+                (*args, SELECT_FILE_FLAG, str(selector_file)),
+                check_selectors,
+                selector_file,
+            )
+    if selected_check_keys:
+        selected_paths.update(
+            _selected_check_asset_paths(dag=dag, selected_check_keys=selected_check_keys)
+        )
+    if not selected_paths:
         return args, (), None
-    selected_paths: set[tuple[str, ...]] = {tuple(key.path) for key in selected_keys}
     selectors: list[str] = []
     for node in _sort_nodes_topologically(dag=dag):
         if tuple(str(part) for part in node["asset_key"]) not in selected_paths:
@@ -140,7 +158,7 @@ def _with_selected_scenario_args(
         ):
             continue
         check_name: str = _dagster_check_name(check)
-        if selected_check_keys and not _scenario_check_is_selected(
+        if selected_check_keys and not _check_is_selected(
             check=check,
             check_name=check_name,
             nodes_by_id=nodes_by_id,
@@ -170,7 +188,7 @@ def _has_explicit_scenario_selector(*, args: tuple[str, ...]) -> bool:
     return False
 
 
-def _scenario_check_is_selected(
+def _check_is_selected(
     *,
     check: Mapping[str, Any],
     check_name: str,
@@ -454,6 +472,10 @@ def _build_results_from_execution_payload(
         )
     check: Mapping[str, Any]
     seen_check_outputs: set[tuple[tuple[str, ...], str]] = set()
+    selected_check_keys: set[tuple[tuple[str, ...], str]] = _selected_asset_check_keys(
+        context=context
+    )
+    check_selection_is_explicit: bool = _check_selection_is_explicit(context=context)
     for check in payload.get("checks", ()):  # type: ignore[assignment]
         check_results, seen_check_outputs = _build_check_results_from_execution_check(
             dg=dg,
@@ -462,6 +484,8 @@ def _build_results_from_execution_payload(
             nodes_by_name=nodes_by_name,
             check=check,
             selected_paths=selected_paths,
+            selected_check_keys=selected_check_keys,
+            check_selection_is_explicit=check_selection_is_explicit,
             seen_check_outputs=seen_check_outputs,
         )
         results.extend(check_results)
@@ -478,6 +502,8 @@ def _build_check_results_from_execution_check(
     nodes_by_name: Mapping[tuple[str, str], Mapping[str, Any]],
     check: Mapping[str, Any],
     selected_paths: set[tuple[str, ...]],
+    selected_check_keys: set[tuple[tuple[str, ...], str]],
+    check_selection_is_explicit: bool,
     seen_check_outputs: set[tuple[tuple[str, ...], str]],
 ) -> tuple[tuple[Any, ...], set[tuple[tuple[str, ...], str]]]:
     dag_check: Mapping[str, Any] | None = _dag_check_for_execution_check(dag=dag, check=check)
@@ -496,9 +522,15 @@ def _build_check_results_from_execution_check(
         if node is None:
             continue
         asset_key: Any = dg.AssetKey([str(part) for part in node["asset_key"]])
-        if selected_paths and tuple(asset_key.path) not in selected_paths:
-            continue
         output_key: tuple[tuple[str, ...], str] = (tuple(asset_key.path), check_name)
+        if check_selection_is_explicit and output_key not in selected_check_keys:
+            continue
+        if (
+            not check_selection_is_explicit
+            and selected_paths
+            and output_key[0] not in selected_paths
+        ):
+            continue
         if output_key in seen_check_outputs:
             continue
         seen_check_outputs.add(output_key)
@@ -568,6 +600,55 @@ def _selected_asset_check_keys(*, context: Any) -> set[tuple[tuple[str, ...], st
     return check_keys
 
 
+def _check_selection_is_explicit(*, context: Any) -> bool:
+    return context is not None and getattr(context, "selected_asset_check_keys", None) is not None
+
+
+def _selected_check_asset_paths(
+    *,
+    dag: Mapping[str, Any],
+    selected_check_keys: set[tuple[tuple[str, ...], str]],
+) -> set[tuple[str, ...]]:
+    nodes_by_id: dict[str, Mapping[str, Any]] = {
+        str(node.get("id")): node for node in dag.get("nodes", ())
+    }
+    paths: set[tuple[str, ...]] = set()
+    for check in dag.get("checks", ()):  # type: ignore[assignment]
+        check_name: str = _dagster_check_name(check)
+        if not _check_is_selected(
+            check=check,
+            check_name=check_name,
+            nodes_by_id=nodes_by_id,
+            selected_check_keys=selected_check_keys,
+        ):
+            continue
+        for asset_id in check.get("checked_asset_ids", ()):
+            node: Mapping[str, Any] | None = nodes_by_id.get(str(asset_id))
+            if node is None:
+                continue
+            asset_path: tuple[str, ...] = tuple(str(part) for part in node.get("asset_key", ()))
+            paths.add(asset_path)
+    return paths
+
+
+def _selected_check_selectors(
+    *, dag: Mapping[str, Any], selected_check_keys: set[tuple[tuple[str, ...], str]]
+) -> tuple[str, ...]:
+    nodes_by_id: dict[str, Mapping[str, Any]] = {
+        str(node.get("id")): node for node in dag.get("nodes", ())
+    }
+    selectors: list[str] = []
+    for check in dag.get("checks", ()):  # type: ignore[assignment]
+        if _check_is_selected(
+            check=check,
+            check_name=_dagster_check_name(check),
+            nodes_by_id=nodes_by_id,
+            selected_check_keys=selected_check_keys,
+        ):
+            selectors.append(str(check.get("name")))
+    return tuple(dict.fromkeys(selectors))
+
+
 def _asset_check_only_context(*, context: Any) -> bool:
     return bool(_selected_asset_check_keys(context=context)) and not bool(
         _selected_asset_paths(context=context)

{sqlbuild-0.74.4 → sqlbuild-0.75.1}/src/sqlbuild/integrations/dagster/constants.py

@@ -19,6 +19,7 @@ ASSET_SELECTION_COMMANDS: frozenset[str] = frozenset(
 CLONE_COMMAND: str = "clone"
 CLONE_ASSET_EVENT: str = "asset"
 CHECK_EVENT: str = "check"
+CHECK_COMMAND: str = "check"
 EVENT_OUTPUT_FLAG: str = "--event-output"
 LIVE_EVENT_COMMANDS: frozenset[str] = ASSET_SELECTION_COMMANDS
 VIRTUAL_ENV_FLAG: str = "--virtual-env"

{sqlbuild-0.74.4 → sqlbuild-0.75.1}/src/sqlbuild/spec/contracts/models.py

@@ -8,6 +8,7 @@ from pathlib import Path
 
 from sqlbuild.cost.constants import DEFAULT_USD_PER_CREDIT
 from sqlbuild.spec.contracts.types import (
+    ColumnContractMode,
     FutureCursorAction,
     MicrobatchLimitAction,
     SourceFreshnessStrategy,
@@ -159,6 +160,7 @@ class SettingsConfig:
     sql_analysis: bool = True
     query_change_tracking: bool = True
     sql_validation: bool = True
+    column_contract_mode: ColumnContractMode = ColumnContractMode.IMPLICIT
     concurrency: int = 1
     auto_load_sources: bool = True
     changes_only: bool = False

{sqlbuild-0.74.4 → sqlbuild-0.75.1}/src/sqlbuild/spec/contracts/types.py

@@ -28,6 +28,13 @@ class MicrobatchLimitAction(StrEnum):
     WARN = "warn"
 
 
+class ColumnContractMode(StrEnum):
+    """Default contract behavior for model column declarations."""
+
+    IMPLICIT = "implicit"
+    EXPLICIT = "explicit"
+
+
 class SourceFreshnessStrategy(StrEnum):
     ADAPTER = "adapter"
     COLUMN = "column"

sqlbuild-0.74.4/src/sqlbuild/compiler/contracts/main/validate.py

@@ -1,29 +0,0 @@
-"""Validate compiled model contracts."""
-
-from __future__ import annotations
-
-from sqlbuild.adapter.contract.types import TypeDialect
-from sqlbuild.compiler.compile.models import CompiledProject, CompilerDiagnostic
-from sqlbuild.compiler.contracts._helpers.columns import collect_model_column_contract_diagnostics
-from sqlbuild.compiler.contracts.models import ContractValidationResult
-from sqlbuild.compiler.planner.types import ContractPolicy
-
-
-def evaluate_model_contracts(
-    *,
-    project: CompiledProject,
-    dialect: TypeDialect | str | None = None,
-) -> ContractValidationResult:
-    """Evaluate model header column contracts against inferred output columns."""
-
-    if not any(
-        model.config.values.get("contract") == ContractPolicy.ENFORCED
-        or (model.schema_entry is not None and model.schema_entry.columns)
-        for model in project.models
-    ):
-        return ContractValidationResult(diagnostics=())
-
-    diagnostics: list[CompilerDiagnostic] = []
-    for model in project.models:
-        diagnostics.extend(collect_model_column_contract_diagnostics(model=model, dialect=dialect))
-    return ContractValidationResult(diagnostics=tuple(diagnostics))