sqlbuild 0.88.0__tar.gz → 0.89.1__tar.gz

{sqlbuild-0.88.0 → sqlbuild-0.89.1}/Cargo.lock

@@ -597,7 +597,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-kata-native"
-version = "0.88.0"
+version = "0.89.1"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.88.0 → sqlbuild-0.89.1}/PKG-INFO

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

{sqlbuild-0.88.0 → sqlbuild-0.89.1}/crates/sqlbuild-kata-native/Cargo.toml

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

{sqlbuild-0.88.0 → sqlbuild-0.89.1}/crates/sqlbuild-kata-native/src/sql_lint/_helpers/formatter.rs

@@ -1,6 +1,6 @@
 use std::str::FromStr;
 
-use polyglot_sql::tokens::{Token, TokenType};
+use polyglot_sql::tokens::Token;
 use polyglot_sql::{Dialect, DialectType, format_by_name};
 
 use crate::sql_lint::constants::LINT_API_VERSION;
@@ -8,6 +8,7 @@ use crate::sql_lint::models::{FormatRequest, FormatResponse};
 
 const COMMENT_ATTACHMENT_FAILURE: &str =
     "native formatter could not preserve comment token attachments";
+const UNSUPPORTED_SQL_FAILURE: &str = "native formatter could not safely format unsupported SQL";
 
 pub(crate) fn format_json_impl(request_json: &str) -> Result<String, String> {
     let request: FormatRequest =
@@ -27,12 +28,15 @@ fn format_sql(request: FormatRequest) -> Result<FormatResponse, String> {
     let dialect_type =
         DialectType::from_str(&request.dialect).map_err(|error| error.to_string())?;
     let dialect = Dialect::get(dialect_type);
-    let tokens = dialect
-        .tokenize(&original)
-        .map_err(|error| error.to_string())?;
+    let tokens = match dialect.tokenize(&original) {
+        Ok(value) => value,
+        Err(_) => return response(original, false, false, Some(UNSUPPORTED_SQL_FAILURE)),
+    };
     let comments = comments_in(&original, &tokens);
     let neutral = neutralize_comments(&original, &comments);
-    let before = dialect.parse(&neutral).map_err(|error| error.to_string())?;
+    if dialect.parse(&neutral).is_err() {
+        return response(original, false, false, Some(UNSUPPORTED_SQL_FAILURE));
+    }
     let semantic_tokens = without_statement_terminators(&tokens);
     let formatted_context = FormatOnceContext {
         dialect_name: &request.dialect,
@@ -45,21 +49,16 @@ fn format_sql(request: FormatRequest) -> Result<FormatResponse, String> {
         Err(error) if error == COMMENT_ATTACHMENT_FAILURE => {
             return response(original, false, false, Some(COMMENT_ATTACHMENT_FAILURE));
         }
-        Err(error) => return Err(error),
+        Err(_) => return response(original, false, false, Some(UNSUPPORTED_SQL_FAILURE)),
     };
     let formatted_tokens = dialect
         .tokenize(&formatted)
         .map_err(|error| error.to_string())?;
     let formatted_neutral =
         neutralize_comments(&formatted, &comments_in(&formatted, &formatted_tokens));
-    let after = dialect
+    let _ = dialect
         .parse(&formatted_neutral)
         .map_err(|error| error.to_string())?;
-    let formatted_semantic_tokens = without_statement_terminators(&formatted_tokens);
-    if before != after && !equivalent_semantic_tokens(&semantic_tokens, &formatted_semantic_tokens)
-    {
-        return Err("native formatter changed the parsed SQL structure".to_string());
-    }
     let second_tokens = dialect
         .tokenize(&formatted)
         .map_err(|error| error.to_string())?;
@@ -86,43 +85,6 @@ fn format_sql(request: FormatRequest) -> Result<FormatResponse, String> {
     response(formatted, changed, true, None)
 }
 
-fn equivalent_semantic_tokens(before: &[Token], after: &[Token]) -> bool {
-    before.len() == after.len()
-        && before.iter().enumerate().all(|(index, token)| {
-            let candidate = &after[index];
-            token.token_type == candidate.token_type && equivalent_token_text(before, after, index)
-        })
-}
-
-fn equivalent_token_text(before: &[Token], after: &[Token], index: usize) -> bool {
-    let token = &before[index];
-    let candidate = &after[index];
-    if token.text == candidate.text {
-        return true;
-    }
-    if !token.text.eq_ignore_ascii_case(&candidate.text) {
-        return false;
-    }
-    if matches!(
-        token.token_type,
-        TokenType::QuotedIdentifier
-            | TokenType::String
-            | TokenType::DollarString
-            | TokenType::Number
-    ) {
-        return false;
-    }
-    if matches!(token.token_type, TokenType::Var | TokenType::Identifier) {
-        return before.get(index + 1).is_some_and(|next| {
-            next.token_type == TokenType::LParen
-                && after
-                    .get(index + 1)
-                    .is_some_and(|formatted| formatted.token_type == TokenType::LParen)
-        });
-    }
-    true
-}
-
 #[derive(Debug, Clone)]
 struct Comment {
     start: usize,

{sqlbuild-0.88.0 → sqlbuild-0.89.1}/pyproject.toml

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

{sqlbuild-0.88.0 → sqlbuild-0.89.1}/src/sqlbuild/cli/commands/_helpers/compile/output.py

@@ -50,19 +50,24 @@ def format_compile_text(
     diagnostics: tuple[CompilerDiagnostic, ...],
     lineage_mode: CompileLineageMode = CompileLineageMode.FAST,
     use_color: bool,
+    selected_keys: frozenset[CompiledObjectKey] | None = None,
 ) -> str:
     """Format human-readable compile output."""
 
     style: CliStyle = CliStyle(use_color=use_color)
+    visible_project_models: tuple[CompiledModel, ...] = _selected_models(
+        graph=graph,
+        selected_keys=selected_keys,
+    )
     lines: list[str] = [
         format_surface_header(
             style=style,
             title="Compile ready",
-            context=_count_label(count=len(graph.project.models), singular="model"),
+            context=_count_label(count=len(visible_project_models), singular="model"),
         ),
         "",
     ]
-    visible_models: tuple[CompiledModel, ...] = graph.project.models[:_HUMAN_MODEL_LIMIT]
+    visible_models: tuple[CompiledModel, ...] = visible_project_models[:_HUMAN_MODEL_LIMIT]
     model_name_width: int = _model_name_width(visible_models)
     error_models: frozenset[str] = _models_with_error_diagnostics(diagnostics)
     model_index: int
@@ -75,12 +80,12 @@ def format_compile_text(
             f"{format_status_cell(style=style, status=status, width=4)} "
             f"{style.muted(f'{_column_count(model)} columns')}"
         )
-    hidden_model_count: int = len(graph.project.models) - len(visible_models)
+    hidden_model_count: int = len(visible_project_models) - len(visible_models)
     if hidden_model_count > 0:
         lines.append("")
         lines.append(
             "  "
-            + style.muted(f"Showing {len(visible_models)} of {len(graph.project.models)} models.")
+            + style.muted(f"Showing {len(visible_models)} of {len(visible_project_models)} models.")
         )
         lines.append("  " + style.muted("Use --json for the full compile report."))
     lines.append("")
@@ -97,10 +102,20 @@ def format_compile_text(
     warning_count: int = _diagnostic_count(
         diagnostics=diagnostics, severity=DiagnosticSeverity.WARNING
     )
+    selected_seed_count: int = _selected_resource_count(
+        graph=graph,
+        selected_keys=selected_keys,
+        resource_types={CompiledResourceType.SEED},
+    )
+    selected_function_count: int = _selected_resource_count(
+        graph=graph,
+        selected_keys=selected_keys,
+        resource_types={CompiledResourceType.UDF, CompiledResourceType.TABLE_FN},
+    )
     compiled_summary: str = (
-        f"{_count_label(count=len(graph.project.models), singular='model')}, "
-        f"{_count_label(count=len(graph.project.seeds), singular='seed')}, "
-        f"{_count_label(count=len(graph.project.functions), singular='function')}, "
+        f"{_count_label(count=len(visible_project_models), singular='model')}, "
+        f"{_count_label(count=selected_seed_count, singular='seed')}, "
+        f"{_count_label(count=selected_function_count, singular='function')}, "
         f"{_count_label(count=error_count, singular='error')}, "
         f"{_count_label(count=warning_count, singular='warning')}"
     )
@@ -138,6 +153,7 @@ def format_compile_json(
     lineage: ProjectColumnLineage | None,
     diagnostics: tuple[CompilerDiagnostic, ...],
     lineage_mode: CompileLineageMode = CompileLineageMode.FAST,
+    selected_keys: frozenset[CompiledObjectKey] | None = None,
 ) -> str:
     """Serialize the offline compile report as JSON."""
 
@@ -146,7 +162,11 @@ def format_compile_json(
         "command": "compile",
         "offline": True,
         "has_errors": any(diagnostic.is_error for diagnostic in diagnostics),
-        "summary": _summary(graph=graph, diagnostics=diagnostics),
+        "summary": _summary(
+            graph=graph,
+            diagnostics=diagnostics,
+            selected_keys=selected_keys,
+        ),
         "diagnostics": [_diagnostic_to_json(diagnostic) for diagnostic in diagnostics],
         "compile_timings": timings_ms,
         "lineage_mode": lineage_mode.value,
@@ -156,14 +176,29 @@ def format_compile_json(
     return json.dumps(result, indent=2)
 
 
-def _summary(*, graph: ProjectGraph, diagnostics: tuple[CompilerDiagnostic, ...]) -> dict[str, int]:
+def _summary(
+    *,
+    graph: ProjectGraph,
+    diagnostics: tuple[CompilerDiagnostic, ...],
+    selected_keys: frozenset[CompiledObjectKey] | None = None,
+) -> dict[str, int]:
     project: CompiledProject = graph.project
     return {
         "models": len(project.models),
-        "selected_models": len(project.models),
+        "selected_models": len(_selected_models(graph=graph, selected_keys=selected_keys)),
         "sources": len(project.sources),
         "seeds": len(project.seeds),
+        "selected_seeds": _selected_resource_count(
+            graph=graph,
+            selected_keys=selected_keys,
+            resource_types={CompiledResourceType.SEED},
+        ),
         "functions": len(project.functions),
+        "selected_functions": _selected_resource_count(
+            graph=graph,
+            selected_keys=selected_keys,
+            resource_types={CompiledResourceType.UDF, CompiledResourceType.TABLE_FN},
+        ),
         "audits": len(project.audits),
         "tests": len(project.sql_tests),
         "hooks": len(project.sql_hook_files) + len(project.hook_functions),
@@ -173,6 +208,31 @@ def _summary(*, graph: ProjectGraph, diagnostics: tuple[CompilerDiagnostic, ...]
     }
 
 
+def _selected_models(
+    *,
+    graph: ProjectGraph,
+    selected_keys: frozenset[CompiledObjectKey] | None,
+) -> tuple[CompiledModel, ...]:
+    if selected_keys is None:
+        return graph.project.models
+    selected_names: frozenset[str] = frozenset(
+        key.name for key in selected_keys if key.resource_type == CompiledResourceType.MODEL
+    )
+    return tuple(model for model in graph.project.models if model.name in selected_names)
+
+
+def _selected_resource_count(
+    *,
+    graph: ProjectGraph,
+    selected_keys: frozenset[CompiledObjectKey] | None,
+    resource_types: set[CompiledResourceType],
+) -> int:
+    effective_keys: frozenset[CompiledObjectKey] = (
+        frozenset(graph.all_keys.values()) if selected_keys is None else selected_keys
+    )
+    return sum(key.resource_type in resource_types for key in effective_keys)
+
+
 def _resources(*, graph: ProjectGraph, lineage: ProjectColumnLineage | None) -> dict[str, object]:
     project: CompiledProject = graph.project
     return {

{sqlbuild-0.88.0 → sqlbuild-0.89.1}/src/sqlbuild/cli/commands/_helpers/compile/pipeline.py

@@ -25,6 +25,7 @@ from sqlbuild.cli.commands.models import (
     WrittenTarget,
 )
 from sqlbuild.cli.commands.types import CompileLineageMode
+from sqlbuild.compiler.compile.models import CompileAnalysisSelection
 from sqlbuild.compiler.contracts.main.validate import evaluate_model_contracts
 from sqlbuild.compiler.contracts.models import ContractValidationResult
 from sqlbuild.compiler.dag.main.build import build_dag_json
@@ -32,8 +33,11 @@ from sqlbuild.compiler.discovery.main.discover import discover_project_inputs
 from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs
 from sqlbuild.compiler.lineage.models import ProjectColumnLineage
 from sqlbuild.compiler.manifest.main.build import build_manifest
-from sqlbuild.compiler.pipeline.main.graph import build_project_graph
+from sqlbuild.compiler.pipeline.main.selected_graph import (
+    build_project_graph_with_analysis_selection,
+)
 from sqlbuild.compiler.pipeline.models import ProjectGraph
+from sqlbuild.compiler.planner.main.selection.selection import resolve_project_selectors
 from sqlbuild.compiler.python_nodes.main.graph import build_discovered_python_node_graph
 from sqlbuild.compiler.python_nodes.models import PythonNodeGraph
 from sqlbuild.presentation.classes.transient_status_reporter import TransientStatusReporter
@@ -52,6 +56,8 @@ def analyze_compile_project(
     lineage_mode: CompileLineageMode,
     cli_vars: dict[str, object] | None,
     profile_flags: CompileProfileFlags,
+    select: tuple[str, ...],
+    exclude: tuple[str, ...],
     status: TransientStatusReporter | None,
 ) -> CompileAnalysis:
     """Discover, compile, and validate the project into one analysis result."""
@@ -79,7 +85,7 @@ def analyze_compile_project(
     graph_start: float = time.monotonic()
     _ = start_compile_phase(status=status, message="Compiling project graph...")
     with OperationLifecycle(operation_kind="project", operation_name="project_compile"):
-        graph: ProjectGraph = build_project_graph(
+        graph: ProjectGraph = build_project_graph_with_analysis_selection(
             discovered_inputs=discovered_inputs,
             adapter=adapter,
             selected_target=selected_target,
@@ -87,7 +93,11 @@ def analyze_compile_project(
             skip_column_inference=profile_flags.skip_column_inference,
             column_lineage_mode=compile_analysis_lineage_mode(lineage_mode),
             cli_vars=cli_vars,
-            no_cache=no_cache,
+            analysis_selection=CompileAnalysisSelection(
+                select=select,
+                exclude=exclude,
+                no_cache=no_cache,
+            ),
         )
     graph_ms: int = elapsed_ms(graph_start)
     _ = complete_compile_phase(
@@ -123,6 +133,15 @@ def analyze_compile_project(
         discovered_inputs=discovered_inputs,
         adapter=adapter,
         graph=graph,
+        selected_keys=resolve_project_selectors(
+            select=select,
+            exclude=exclude,
+            all_keys=graph.all_keys,
+            upstream_deps=graph.upstream_deps,
+            downstream_deps=graph.downstream_deps,
+            tag_index=graph.tag_index,
+            path_index=graph.path_index,
+        ),
         lineage=lineage,
         diagnostics=(*graph.project.diagnostics, *contract_result.diagnostics),
         discover_ms=discover_ms,

{sqlbuild-0.88.0 → sqlbuild-0.89.1}/src/sqlbuild/cli/commands/_helpers/entry/dispatch.py

@@ -70,6 +70,8 @@ def dispatch_cli_command(*, args: CliNamespace, handlers: CliEntrypointHandlers)
                 dag_path=args.dag,
                 no_color=args.no_color,
                 lineage_mode=CompileLineageMode(args.compile_lineage_mode),
+                select=select,
+                exclude=tuple(args.exclude),
                 cli_vars=args.vars,
                 profile_flags=CompileProfileFlags(
                     skip_discovery_sql_analysis=args.profile_skip_discovery_sql_analysis,

{sqlbuild-0.88.0 → sqlbuild-0.89.1}/src/sqlbuild/cli/commands/_helpers/entry/parser.py

@@ -122,6 +122,7 @@ def _add_compile_and_dag_parsers(
         default=False,
         help="Diagnostic: skip writing target/compiled artifacts",
     )
+    add_select_args(compile_parser)
     _ = add_vars_args(compile_parser)
     _ = add_dbt_config_args(parser=compile_parser)
 

sqlbuild-0.89.1/src/sqlbuild/cli/commands/_helpers/lint/selection.py

@@ -0,0 +1,133 @@
+"""Canonical model selector resolution for lint and format CLI commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
+from sqlbuild.cli.commands._helpers.runtime.adapters import resolve_adapter
+from sqlbuild.compiler.compile.models import CompiledObjectKey
+from sqlbuild.compiler.compile.types import CompiledResourceType
+from sqlbuild.compiler.discovery.main.discover import discover_project_inputs
+from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs, DiscoveredSqlModelFile
+from sqlbuild.compiler.pipeline.main.graph import build_project_graph
+from sqlbuild.compiler.pipeline.models import ProjectGraph
+from sqlbuild.compiler.planner.exceptions import PlannerInputError
+from sqlbuild.compiler.planner.main.selection.selection import resolve_project_selectors
+from sqlbuild.spec.contracts.main.resolve_effective_adapter_name import (
+    resolve_effective_adapter_name,
+)
+
+_GRAPH_SELECTOR_MARKERS: tuple[str, ...] = ("+", ":", "~", "/", "\\", ",")
+
+
+def resolve_lint_inputs(
+    *, project_dir: Path, select: tuple[str, ...], exclude: tuple[str, ...]
+) -> tuple[BaseAdapter, frozenset[Path] | None, DiscoveredProjectInputs]:
+    """Resolve the adapter and optional model-file scope through canonical selectors."""
+
+    discovered: DiscoveredProjectInputs = discover_project_inputs(
+        project_dir=project_dir,
+        sql_analysis_enabled_override=False,
+        extract_output_column_locations=False,
+    )
+    adapter: BaseAdapter = resolve_adapter(
+        adapter_name=resolve_effective_adapter_name(
+            project_config=discovered.project_config,
+            local_config=discovered.local_config,
+        ),
+        project_dir=project_dir,
+    )
+    if not select and not exclude:
+        return adapter, None, discovered
+    exact_paths: frozenset[Path] | None = _resolve_exact_model_paths(
+        project_dir=project_dir,
+        discovered=discovered,
+        select=select,
+        exclude=exclude,
+    )
+    if exact_paths is not None:
+        _validate_selected_paths(paths=exact_paths)
+        return adapter, exact_paths, discovered
+    graph: ProjectGraph = build_project_graph(discovered_inputs=discovered, adapter=adapter)
+    selected_keys: frozenset[CompiledObjectKey] = resolve_project_selectors(
+        select=select,
+        exclude=exclude,
+        all_keys=graph.all_keys,
+        upstream_deps=graph.upstream_deps,
+        downstream_deps=graph.downstream_deps,
+        tag_index=graph.tag_index,
+        path_index=graph.path_index,
+    )
+    selected_names: frozenset[str] = frozenset(
+        key.name for key in selected_keys if key.resource_type == CompiledResourceType.MODEL
+    )
+    paths: frozenset[Path] = frozenset(
+        (project_dir / model.relative_path).resolve()
+        for model in graph.project.models
+        if model.name in selected_names
+    )
+    _validate_selected_paths(paths=paths)
+    return adapter, paths, discovered
+
+
+def _resolve_exact_model_paths(
+    *,
+    project_dir: Path,
+    discovered: DiscoveredProjectInputs,
+    select: tuple[str, ...],
+    exclude: tuple[str, ...],
+) -> frozenset[Path] | None:
+    """Resolve unexpanded model-name selectors without compiling the project graph."""
+
+    model_names_and_paths: list[tuple[str, Path]] = []
+    model_file: DiscoveredSqlModelFile
+    for model_file in discovered.model_files:
+        configured_name: object = model_file.header_values.get("name")
+        model_name: str = (
+            configured_name
+            if isinstance(configured_name, str) and configured_name
+            else model_file.relative_path.stem
+        )
+        model_names_and_paths.append(
+            (model_name, (project_dir / model_file.relative_path).resolve())
+        )
+    selected_names: frozenset[str] | None = _exact_names(raw_selectors=select)
+    excluded_names: frozenset[str] | None = _exact_names(raw_selectors=exclude)
+    if selected_names is None or excluded_names is None:
+        return None
+    available_names: frozenset[str] = frozenset(name for name, _path in model_names_and_paths)
+    unknown_names: frozenset[str] = (selected_names | excluded_names) - available_names
+    if unknown_names:
+        unknown_name: str = sorted(unknown_names)[0]
+        raise PlannerInputError(f"unknown selector name '{unknown_name}'", code="S007")
+    names: frozenset[str] = selected_names or available_names
+    return frozenset(
+        path for name, path in model_names_and_paths if name in names and name not in excluded_names
+    )
+
+
+def _exact_names(*, raw_selectors: tuple[str, ...]) -> frozenset[str] | None:
+    """Return plain model names, or None when canonical graph resolution is required."""
+
+    names: set[str] = set()
+    raw_selector: str
+    for raw_selector in raw_selectors:
+        if not raw_selector.strip():
+            return None
+        token: str
+        for token in raw_selector.split():
+            if any(marker in token for marker in _GRAPH_SELECTOR_MARKERS):
+                return None
+            names.add(token)
+    return frozenset(names)
+
+
+def _validate_selected_paths(*, paths: frozenset[Path]) -> None:
+    """Reject lint selections that contain no SQL model files."""
+
+    if not paths:
+        raise PlannerInputError(
+            "lint selection matched no SQL model files",
+            code="S007",
+        )

{sqlbuild-0.88.0 → sqlbuild-0.89.1}/src/sqlbuild/cli/commands/main/project/_compile.py

@@ -75,6 +75,8 @@ def _run_compile_with_status(
         lineage_mode=lineage_mode,
         cli_vars=request.cli_vars,
         profile_flags=request.profile_flags,
+        select=request.select,
+        exclude=request.exclude,
         status=status,
     )
     manifest_payload: dict[str, object] | None = build_compile_manifest_payload(
@@ -119,6 +121,7 @@ def _run_compile_with_status(
                 lineage=analysis.lineage,
                 lineage_mode=lineage_mode,
                 diagnostics=analysis.diagnostics,
+                selected_keys=analysis.selected_keys,
             )
         )
         return exit_code
@@ -131,6 +134,7 @@ def _run_compile_with_status(
             lineage=analysis.lineage,
             lineage_mode=lineage_mode,
             diagnostics=analysis.diagnostics,
+            selected_keys=analysis.selected_keys,
             use_color=(not no_color) and supports_color(),
         )
     )

{sqlbuild-0.88.0 → sqlbuild-0.89.1}/src/sqlbuild/cli/commands/models.py

@@ -519,6 +519,8 @@ class CompileCommandRequest:
     dag_path: str | None = None
     no_color: bool = False
     lineage_mode: CompileLineageMode = CompileLineageMode.FAST
+    select: tuple[str, ...] = ()
+    exclude: tuple[str, ...] = ()
     cli_vars: dict[str, object] | None = None
     profile_flags: CompileProfileFlags = CompileProfileFlags()
     no_cache: bool = False
@@ -531,6 +533,7 @@ class CompileAnalysis:
     discovered_inputs: DiscoveredProjectInputs
     adapter: BaseAdapter
     graph: ProjectGraph
+    selected_keys: frozenset[CompiledObjectKey]
     lineage: ProjectColumnLineage | None
     diagnostics: tuple[CompilerDiagnostic, ...]
     discover_ms: int

sqlbuild-0.89.1/src/sqlbuild/compiler/pipeline/main/graph.py

@@ -0,0 +1,44 @@
+"""Build the static compiled project dependency graph."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
+from sqlbuild.compiler.compile.models import CompileAnalysisSelection
+from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs
+from sqlbuild.compiler.lineage.types import ColumnLineageMode
+from sqlbuild.compiler.pipeline.main.selected_graph import (
+    build_project_graph_with_analysis_selection,
+)
+from sqlbuild.compiler.pipeline.models import ProjectGraph
+from sqlbuild.compiler.references.types import ExternalSqlReferenceResolver
+
+
+def build_project_graph(
+    *,
+    discovered_inputs: DiscoveredProjectInputs,
+    adapter: BaseAdapter,
+    selected_target: str | None = None,
+    no_sql_validation: bool = False,
+    skip_column_inference: bool = False,
+    column_lineage_mode: ColumnLineageMode = ColumnLineageMode.FAST,
+    cli_vars: dict[str, object] | None = None,
+    external_sql_reference_resolver: ExternalSqlReferenceResolver | None = None,
+    on_progress: Callable[[str], None] | None = None,
+    no_cache: bool = False,
+) -> ProjectGraph:
+    """Build the static dependency graph for a compiled project."""
+
+    return build_project_graph_with_analysis_selection(
+        discovered_inputs=discovered_inputs,
+        adapter=adapter,
+        selected_target=selected_target,
+        no_sql_validation=no_sql_validation,
+        skip_column_inference=skip_column_inference,
+        column_lineage_mode=column_lineage_mode,
+        cli_vars=cli_vars,
+        external_sql_reference_resolver=external_sql_reference_resolver,
+        on_progress=on_progress,
+        analysis_selection=CompileAnalysisSelection(no_cache=no_cache),
+    )

sqlbuild-0.88.0/src/sqlbuild/compiler/pipeline/main/graph.py → sqlbuild-0.89.1/src/sqlbuild/compiler/pipeline/main/selected_graph.py

@@ -1,4 +1,4 @@
-"""Build the static compiled project dependency graph."""
+"""Build a project graph with explicit deep-analysis selection."""
 
 from __future__ import annotations
 
@@ -31,10 +31,11 @@ from sqlbuild.compiler.planner.main.selection._build_model_tag_index import (
 from sqlbuild.compiler.references.types import ExternalSqlReferenceResolver
 
 
-def build_project_graph(
+def build_project_graph_with_analysis_selection(
     *,
     discovered_inputs: DiscoveredProjectInputs,
     adapter: BaseAdapter,
+    analysis_selection: CompileAnalysisSelection,
     selected_target: str | None = None,
     no_sql_validation: bool = False,
     skip_column_inference: bool = False,
@@ -42,9 +43,8 @@ def build_project_graph(
     cli_vars: dict[str, object] | None = None,
     external_sql_reference_resolver: ExternalSqlReferenceResolver | None = None,
     on_progress: Callable[[str], None] | None = None,
-    no_cache: bool = False,
 ) -> ProjectGraph:
-    """Build the static dependency graph for a compiled project."""
+    """Build a static graph with an explicit deep-analysis selection."""
 
     if on_progress is not None:
         on_progress("Compiling project...")
@@ -58,7 +58,7 @@ def build_project_graph(
         column_lineage_mode=column_lineage_mode,
         cli_vars=cli_vars,
         external_sql_reference_resolver=external_sql_reference_resolver,
-        analysis_selection=CompileAnalysisSelection(no_cache=no_cache),
+        analysis_selection=analysis_selection,
     )
     if on_progress is not None:
         on_progress(f"Compiled project. ({time.monotonic() - compile_start:.2f}s)")

{sqlbuild-0.88.0 → sqlbuild-0.89.1}/src/sqlbuild/compiler/planner/_helpers/graph/selectors.py

@@ -114,10 +114,10 @@ def resolve_selectors(
     effective_tag_index: dict[str, frozenset[CompiledObjectKey]] = tag_index or {}
     effective_path_index: dict[CompiledObjectKey, str] = path_index or {}
 
-    if not select:
+    if not select and not exclude:
         return frozenset(all_keys.values())
 
-    selected: set[CompiledObjectKey] = set()
+    selected: set[CompiledObjectKey] = set(all_keys.values()) if not select else set()
     raw_select: str
     for raw_select in select:
         tokens: list[str] = raw_select.split()