sqlbuild 0.113.3__tar.gz → 0.113.5__tar.gz

{sqlbuild-0.113.3 → sqlbuild-0.113.5}/Cargo.lock

@@ -310,8 +310,8 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "polyglot-sql"
-version = "0.12.1"
-source = "git+https://github.com/chio-labs/polyglot.git?rev=cd599007a1ba6c4cc1f2d99938fc0e6d3b376a9b#cd599007a1ba6c4cc1f2d99938fc0e6d3b376a9b"
+version = "0.12.3"
+source = "git+https://github.com/chio-labs/polyglot.git?rev=f3774102f518f716cd648e4fdebb9d8558a0b63a#f3774102f518f716cd648e4fdebb9d8558a0b63a"
 dependencies = [
  "polyglot-sql-ast-derive",
  "serde",
@@ -323,8 +323,8 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ast-derive"
-version = "0.12.1"
-source = "git+https://github.com/chio-labs/polyglot.git?rev=cd599007a1ba6c4cc1f2d99938fc0e6d3b376a9b#cd599007a1ba6c4cc1f2d99938fc0e6d3b376a9b"
+version = "0.12.3"
+source = "git+https://github.com/chio-labs/polyglot.git?rev=f3774102f518f716cd648e4fdebb9d8558a0b63a#f3774102f518f716cd648e4fdebb9d8558a0b63a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -592,7 +592,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-rules-native"
-version = "0.113.3"
+version = "0.113.5"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.113.3 → sqlbuild-0.113.5}/Cargo.toml

@@ -13,7 +13,7 @@ fensu-policy = "=0.22.0"
 globset = "0.4"
 proc-macro2 = { version = "1", features = ["span-locations"] }
 pyo3 = { version = "0.26", features = ["abi3-py312"] }
-polyglot-sql = { git = "https://github.com/chio-labs/polyglot.git", rev = "cd599007a1ba6c4cc1f2d99938fc0e6d3b376a9b", default-features = false, features = [
+polyglot-sql = { git = "https://github.com/chio-labs/polyglot.git", rev = "f3774102f518f716cd648e4fdebb9d8558a0b63a", default-features = false, features = [
     "ast-tools",
     "builder",
     "dialect-bigquery",

{sqlbuild-0.113.3 → sqlbuild-0.113.5}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.113.3
+Version: 0.113.5
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: orjson>=3.10.0
-Requires-Dist: polyglot-sql-chio==0.12.1
+Requires-Dist: polyglot-sql-chio==0.12.3
 Requires-Dist: pydantic-settings>=2,<3
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=15.0.0

{sqlbuild-0.113.3 → sqlbuild-0.113.5}/crates/sqlbuild-rules-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-rules-native"
-version = "0.113.3"
+version = "0.113.5"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.113.3 → sqlbuild-0.113.5}/crates/sqlbuild-rules-native/src/query_analysis/_helpers/engine.rs

@@ -122,6 +122,8 @@ struct ProjectAnalysis {
     has_star: bool,
     #[serde(skip)]
     requires_legacy_fallback: bool,
+    #[serde(skip)]
+    preserve_fallback_lineage: bool,
 }
 
 struct ProjectAnalysisInputs<'a> {
@@ -611,19 +613,18 @@ fn try_borrowed_query(
                 upstream_columns,
             });
         }
+        let requires_legacy_fallback = columns.iter().any(|column| column.data_type.is_none());
         projections.push((
             *index,
             Ok(ProjectAnalysis {
                 columns,
                 lineage_columns,
                 has_star: false,
-                requires_legacy_fallback: false,
+                requires_legacy_fallback,
+                preserve_fallback_lineage: true,
             }),
         ));
     }
-    if projections.iter().any(|(_, result)| matches!(result, Ok(analysis) if analysis.columns.iter().any(|column| column.data_type.is_none()))) {
-        return Err(Box::new(work));
-    }
     Ok(CompiledQueryWorkResult {
         projections,
         validation: if work.query.binding_schema.is_some() {
@@ -933,6 +934,7 @@ struct CompactProjectBatch {
 #[serde(untagged)]
 enum CompactProjectResponse {
     Success((Vec<usize>, bool)),
+    LegacyTypeRecovery((Vec<usize>, bool, &'static str)),
     Failure(String),
 }
 
@@ -985,7 +987,7 @@ impl CompactProjectAccumulator {
                 return Ok(());
             }
         };
-        if analysis.requires_legacy_fallback {
+        if analysis.requires_legacy_fallback && !analysis.preserve_fallback_lineage {
             self.set_template(
                 projection_index,
                 CompactProjectResponse::Failure(
@@ -1024,7 +1026,15 @@ impl CompactProjectAccumulator {
         }
         self.set_template(
             projection_index,
-            CompactProjectResponse::Success((columns, analysis.has_star)),
+            if analysis.requires_legacy_fallback {
+                CompactProjectResponse::LegacyTypeRecovery((
+                    columns,
+                    analysis.has_star,
+                    "native project type recovery requires legacy fallback",
+                ))
+            } else {
+                CompactProjectResponse::Success((columns, analysis.has_star))
+            },
         )
     }
 
@@ -1194,6 +1204,7 @@ fn project_analysis(inputs: ProjectAnalysisInputs<'_>) -> ProjectAnalysis {
         lineage_columns,
         has_star: inputs.analysis.has_root_star,
         requires_legacy_fallback,
+        preserve_fallback_lineage: false,
     }
 }
 

{sqlbuild-0.113.3 → sqlbuild-0.113.5}/crates/sqlbuild-rules-native/src/query_analysis/tests/helpers.rs

@@ -164,6 +164,38 @@ pub(crate) fn binding_warnings_preserve_declared_relationship_evidence() -> bool
     true
 }
 
+pub(crate) fn bound_lineage_survives_type_recovery() -> bool {
+    for operator in ["UNION ALL", "UNION ALL BY NAME"] {
+        let response: Value = serde_json::from_str(
+            &analyze_project_compact_json(&json!({
+                "queries": [{
+                    "sql": format!("WITH combined AS (SELECT CAST(amount AS DOUBLE) AS amount FROM orders {operator} SELECT list_extract([amount], 1) AS amount FROM refunds) SELECT amount FROM combined"),
+                    "dialect": "duckdb",
+                    "schema": {"strict": true, "tables": [
+                        {"name": "orders", "columns": [{"name": "amount", "type": "DOUBLE"}]},
+                        {"name": "refunds", "columns": [{"name": "amount", "type": "DOUBLE"}]}
+                    ]}
+                }],
+                "templates": [{"queryIndex": 0, "recoverCteFacts": true, "richTypeInference": false, "references": {
+                    "orders": {"resourceType": "model", "resourceName": "orders"},
+                    "refunds": {"resourceType": "model", "resourceName": "refunds"}
+                }}],
+                "projections": [{"templateIndex": 0}]
+            }).to_string()).expect("query should analyze"),
+        ).expect("response should decode");
+        let index = response["templates"][0][0][0]
+            .as_u64()
+            .expect("successful fact") as usize;
+        let fact = &response["facts"][index];
+        assert_eq!(
+            response["templates"][0][2],
+            "native project type recovery requires legacy fallback"
+        );
+        assert_eq!(fact[5].as_array().expect("upstream columns").len(), 2);
+    }
+    true
+}
+
 pub(crate) fn widening_aggregates_require_compatibility_recovery() -> bool {
     for expression in [
         "AVG(order_id)",

{sqlbuild-0.113.3 → sqlbuild-0.113.5}/crates/sqlbuild-rules-native/src/query_analysis/tests/test_query_analysis.rs

@@ -4,7 +4,7 @@ use crate::query_analysis::tests::helpers::{
     binding_warnings_preserve_declared_relationship_evidence,
     borrowed_facts_preserve_named_outputs_and_terminal_sources,
     borrowed_facts_preserve_union_dependencies_and_join_nullability,
-    canonical_queries_reuse_semantics_and_project_resources,
+    bound_lineage_survives_type_recovery, canonical_queries_reuse_semantics_and_project_resources,
     combined_queries_preserve_standalone_binding,
     compact_project_query_interns_repeated_lineage_strings,
     interleaved_query_templates_preserve_template_order,
@@ -56,6 +56,11 @@ fn given_compact_query_cases_when_analyzing_projects_then_expected_behavior_hold
             run: widening_aggregates_require_compatibility_recovery,
             expected_success: true,
         },
+        CompactQueryAnalysisTestCase {
+            description: "resolved bound lineage survives type recovery",
+            run: bound_lineage_survives_type_recovery,
+            expected_success: true,
+        },
         CompactQueryAnalysisTestCase {
             description: "compact project queries intern repeated lineage strings",
             run: compact_project_query_interns_repeated_lineage_strings,

{sqlbuild-0.113.3 → sqlbuild-0.113.5}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.113.3"
+version = "0.113.5"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -15,7 +15,7 @@ dependencies = [
   "duckdb>=1.3.2",
   "filelock>=3.20.3",
   "orjson>=3.10.0",
-  "polyglot-sql-chio==0.12.1",
+  "polyglot-sql-chio==0.12.3",
   "pydantic-settings>=2,<3",
   "PyYAML>=6.0.2",
   "rich>=15.0.0",

{sqlbuild-0.113.3 → sqlbuild-0.113.5}/src/sqlbuild/cli/commands/_helpers/compile/sql_test_artifact_cache.py

@@ -10,6 +10,8 @@ from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
 from typing import cast
 
+import orjson
+
 from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
 from sqlbuild.cli.compile.models import (
     SqlTestArtifactCacheRecord,
@@ -25,7 +27,7 @@ from sqlbuild.compiler.compile.models import (
 )
 
 _CACHE_VERSION: int = 3
-_ALGORITHM_FINGERPRINT: str = "sql-test-artifact-v3-polyglot-scope-fix"
+_ALGORITHM_FINGERPRINT: str = "sql-test-artifact-v4-orjson-identity"
 _CACHE_FILE_NAME: str = "sql-test-artifacts.json"
 _MAX_CACHE_BYTES: int = 10_000_000
 _MAX_CACHE_RECORDS: int = 100_000
@@ -276,8 +278,7 @@ def _is_safe_relative_sql_path(path: Path) -> bool:
 
 
 def _payload_digest(payload: object) -> str:
-    encoded: str = json.dumps(payload, ensure_ascii=True, separators=(",", ":"), sort_keys=True)
-    return hashlib.sha256(encoded.encode("utf-8")).hexdigest()
+    return hashlib.sha256(orjson.dumps(payload, option=orjson.OPT_SORT_KEYS)).hexdigest()
 
 
 def _package_version(package_name: str) -> str:

{sqlbuild-0.113.3 → sqlbuild-0.113.5}/src/sqlbuild/cli/commands/_helpers/compile/target_writer.py

@@ -499,20 +499,20 @@ def _remove_stale_compiled_files(*, target_dir: Path, managed_paths: set[Path])
     compiled_dir: Path = target_dir / _COMPILED_DIR
     if not compiled_dir.is_dir():
         return
+    managed_names: set[str] = {os.fspath(path) for path in managed_paths}
     for root, directories, filenames in os.walk(compiled_dir, topdown=False):
-        root_path: Path = Path(root)
         for filename in filenames:
-            path: Path = root_path / filename
-            if path not in managed_paths:
-                path.unlink()
+            path: str = os.path.join(root, filename)
+            if path not in managed_names:
+                os.unlink(path)
         for name in directories:
-            _remove_empty_directory(root_path / name)
+            _remove_empty_directory(os.path.join(root, name))
     _remove_empty_directory(compiled_dir)
 
 
-def _remove_empty_directory(directory: Path) -> None:
+def _remove_empty_directory(directory: str | Path) -> None:
     try:
-        directory.rmdir()
+        os.rmdir(directory)
     except OSError:
         pass
 

{sqlbuild-0.113.3 → sqlbuild-0.113.5}/src/sqlbuild/compiler/compile/_helpers/analysis/cache.py

@@ -10,6 +10,7 @@ import platform
 import sqlite3
 import time
 from collections import defaultdict, deque
+from collections.abc import Sequence
 from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
 from string import hexdigits
@@ -26,13 +27,14 @@ from sqlbuild.compiler.compile.models import (
     CompactAnalysisCacheModel,
     CompactAnalysisCachePlan,
     CompactBatchPreparation,
+    CompactLineageFacts,
     CompiledLineageColumnFact,
     CompiledLineageSourceFact,
     CompileSqlReference,
     InferredColumn,
     PolyglotAnalysisResult,
 )
-from sqlbuild.compiler.compile.types import CompactBatchResponseCallback
+from sqlbuild.compiler.compile.types import CompactBatchResponseCallback, CompiledResourceType
 from sqlbuild.compiler.lineage.types import (
     ColumnLineageConfidence,
     ColumnTransformKind,
@@ -44,7 +46,19 @@ from sqlbuild.compiler.references.types import SqlReferenceKind
 from sqlbuild.compiler.sql_analysis.models import SqlBindingDiagnostic
 
 _ANALYSIS_CACHE_VERSION: int = 10
-_ANALYSIS_ALGORITHM_FINGERPRINT: str = "model-sql-analysis-v12-bound-borrowed-output-graph"
+_ANALYSIS_ALGORITHM_FINGERPRINT: str = "model-sql-analysis-v13-bound-lineage-type-recovery"
+_LINEAGE_COLUMN_VALUE_COUNT: int = 4
+_LINEAGE_SOURCE_VALUE_COUNT: int = 3
+_COMPACT_TRANSFORM_CODES: dict[str, int] = {
+    CompactLineageFacts.transform_kind(code).value: code for code in range(6)
+}
+_COMPACT_CONFIDENCE_CODES: dict[str, int] = {
+    CompactLineageFacts.confidence(code).value: code for code in range(3)
+}
+_RESOURCE_TYPE_VALUES: frozenset[str] = frozenset(item.value for item in CompiledResourceType)
+_NULLABILITY_BY_VALUE: dict[str, InferredNullability] = {
+    item.value: item for item in InferredNullability
+}
 _MAX_CACHE_ENTRY_BYTES: int = 10_000_000
 _SHA256_HEX_LENGTH: int = 64
 _CACHE_ENTRY_SEPARATOR: str = "\n"
@@ -162,7 +176,7 @@ def model_analysis_cache_key(
     }
     if recover_cte_facts:
         payload["recover_cte_facts"] = True
-    return _payload_digest(payload)
+    return _json_value_digest(payload)
 
 
 def compact_analysis_batch_cache_key(
@@ -185,7 +199,7 @@ def compact_analysis_model_reuse_key(
 ) -> str:
     """Return one model key that changes with every transitive model dependency."""
 
-    return _payload_digest(
+    return _json_value_digest(
         {
             "cache_key": cache_key,
             "upstream": upstream_reuse_keys,
@@ -488,6 +502,7 @@ def read_model_analyses(
     analyses: dict[str, PolyglotAnalysisResult] = {}
     signatures: dict[str, str] = {}
     output_signatures_by_key: dict[str, str] = {}
+    sources: _LineageSourceInterner = _LineageSourceInterner()
     try:
         connection_uri: str = f"file:{database_path}?mode=ro"
         with sqlite3.connect(
@@ -548,6 +563,7 @@ def read_model_analyses(
                         _analysis_from_contents(
                             contents=contents,
                             expected_cache_key=cache_key,
+                            sources=sources,
                         )
                     )
                     if cached_result is not None:
@@ -644,7 +660,7 @@ def _expected_dependencies(
 def model_analysis_output_signature(analysis: PolyglotAnalysisResult) -> str:
     """Return the exported column signature relevant to downstream analysis."""
 
-    return _payload_digest(
+    return _json_value_digest(
         {
             "columns": (
                 None
@@ -664,7 +680,10 @@ def model_analysis_output_signature(analysis: PolyglotAnalysisResult) -> str:
 
 
 def _analysis_from_contents(
-    *, contents: object, expected_cache_key: str
+    *,
+    contents: object,
+    expected_cache_key: str,
+    sources: _LineageSourceInterner | None = None,
 ) -> tuple[PolyglotAnalysisResult, str] | None:
     if not isinstance(contents, str):
         return None
@@ -680,9 +699,11 @@ def _analysis_from_contents(
             ),
         ):
             return None
-        payload: object = json.loads(serialized_payload)
-        return _analysis_from_payload(payload=payload, expected_cache_key=expected_cache_key)
-    except (ValueError, TypeError, KeyError, RecursionError, json.JSONDecodeError):
+        payload: object = orjson.loads(serialized_payload)
+        return _analysis_from_payload(
+            payload=payload, expected_cache_key=expected_cache_key, sources=sources
+        )
+    except (ValueError, TypeError, KeyError, RecursionError, orjson.JSONDecodeError):
         return None
 
 
@@ -813,7 +834,10 @@ def _lineage_column_payload(column: CompiledLineageColumnFact) -> list[object]:
 
 
 def _analysis_from_payload(
-    *, payload: object, expected_cache_key: str
+    *,
+    payload: object,
+    expected_cache_key: str,
+    sources: _LineageSourceInterner | None = None,
 ) -> tuple[PolyglotAnalysisResult, str]:
     if not isinstance(payload, dict):
         raise AnalysisCacheEntryError("analysis cache entry must be an object")
@@ -839,9 +863,16 @@ def _analysis_from_payload(
         if columns_payload is None
         else tuple(_column_from_payload(column) for column in _value_lists(columns_payload))
     )
-    lineage_columns: tuple[CompiledLineageColumnFact, ...] = tuple(
-        _lineage_column_from_payload(column) for column in _value_lists(values["l"])
+    lineage_payload: list[list[object]] = _value_lists(values["l"])
+    lineage_columns: Sequence[CompiledLineageColumnFact] | None = _compact_lineage_from_payload(
+        payload=lineage_payload
     )
+    if lineage_columns is None:
+        interner: _LineageSourceInterner = _LineageSourceInterner() if sources is None else sources
+        lineage_columns = tuple(
+            _lineage_column_from_payload(payload=column, sources=interner)
+            for column in lineage_payload
+        )
     has_star: object = values["h"]
     if not isinstance(has_star, bool):
         raise AnalysisCacheEntryError("analysis cache has_star must be a boolean")
@@ -904,11 +935,93 @@ def _column_from_payload(payload: list[object]) -> InferredColumn:
     return InferredColumn(
         name=name,
         type=column_type,
-        nullability=InferredNullability(nullability),
+        nullability=_NULLABILITY_BY_VALUE.get(nullability) or InferredNullability(nullability),
     )
 
 
-def _lineage_column_from_payload(payload: list[object]) -> CompiledLineageColumnFact:
+def _compact_lineage_from_payload(*, payload: list[list[object]]) -> CompactLineageFacts | None:
+    """Validate cached lineage into lazy indexed rows; None means use the eager decoder."""
+
+    pool: dict[str, int] = {}
+    rows: list[tuple[int, int, int, tuple[tuple[int, int, int], ...]]] = []
+    column: list[object]
+    for column in payload:
+        if len(column) != _LINEAGE_COLUMN_VALUE_COUNT:
+            raise AnalysisCacheEntryError("analysis cache lineage column must contain four values")
+        output_column, transform_kind, confidence, upstream_columns = column
+        if not (
+            type(output_column) is str and type(transform_kind) is str and type(confidence) is str
+        ):
+            raise AnalysisCacheEntryError("analysis cache lineage attributes must be strings")
+        transform_code: int | None = _COMPACT_TRANSFORM_CODES.get(transform_kind)
+        confidence_code: int | None = _COMPACT_CONFIDENCE_CODES.get(confidence)
+        if transform_code is None or confidence_code is None:
+            return None
+        if type(upstream_columns) is not list:
+            raise AnalysisCacheEntryError("analysis cache collection must contain arrays")
+        source_rows: list[tuple[int, int, int]] = []
+        source: object
+        for source in upstream_columns:
+            if not (
+                type(source) is list
+                and len(source) == _LINEAGE_SOURCE_VALUE_COUNT
+                and type(source[0]) is str
+                and type(source[1]) is str
+                and type(source[2]) is str
+            ):
+                raise AnalysisCacheEntryError(
+                    "analysis cache lineage source must contain three strings"
+                )
+            if source[0] not in _RESOURCE_TYPE_VALUES:
+                raise AnalysisCacheEntryError("analysis cache lineage resource type is invalid")
+            source_rows.append(
+                (
+                    pool.setdefault(source[0], len(pool)),
+                    pool.setdefault(source[1], len(pool)),
+                    pool.setdefault(source[2], len(pool)),
+                )
+            )
+        rows.append(
+            (
+                pool.setdefault(output_column, len(pool)),
+                transform_code,
+                confidence_code,
+                tuple(source_rows),
+            )
+        )
+    return CompactLineageFacts(string_pool=tuple(pool), rows=tuple(rows))
+
+
+class _LineageSourceInterner:
+    """Share identical immutable lineage source facts across one cache read."""
+
+    def __init__(self) -> None:
+        self._facts: dict[tuple[str, str, str], CompiledLineageSourceFact] = {}
+
+    def decode(self, *, payload: list[object]) -> CompiledLineageSourceFact:
+        source_value_count: int = 3
+        if len(payload) != source_value_count or not all(
+            isinstance(value, str) for value in payload
+        ):
+            raise AnalysisCacheEntryError(
+                "analysis cache lineage source must contain three strings"
+            )
+        resource_type, resource_name, column_name = cast(list[str], payload)
+        key: tuple[str, str, str] = (resource_type, resource_name, column_name)
+        fact: CompiledLineageSourceFact | None = self._facts.get(key)
+        if fact is None:
+            fact = CompiledLineageSourceFact(
+                resource_type=resource_type,
+                resource_name=resource_name,
+                column_name=column_name,
+            )
+            self._facts[key] = fact
+        return fact
+
+
+def _lineage_column_from_payload(
+    *, payload: list[object], sources: _LineageSourceInterner
+) -> CompiledLineageColumnFact:
     lineage_value_count: int = 4
     if len(payload) != lineage_value_count:
         raise AnalysisCacheEntryError("analysis cache lineage column must contain four values")
@@ -920,23 +1033,11 @@ def _lineage_column_from_payload(payload: list[object]) -> CompiledLineageColumn
         transform_kind=ColumnTransformKind(cast(str, transform_kind)),
         confidence=ColumnLineageConfidence(cast(str, confidence)),
         upstream_columns=tuple(
-            _lineage_source_from_payload(source) for source in _value_lists(upstream_columns)
+            sources.decode(payload=source) for source in _value_lists(upstream_columns)
         ),
     )
 
 
-def _lineage_source_from_payload(payload: list[object]) -> CompiledLineageSourceFact:
-    source_value_count: int = 3
-    if len(payload) != source_value_count or not all(isinstance(value, str) for value in payload):
-        raise AnalysisCacheEntryError("analysis cache lineage source must contain three strings")
-    resource_type, resource_name, column_name = cast(list[str], payload)
-    return CompiledLineageSourceFact(
-        resource_type=resource_type,
-        resource_name=resource_name,
-        column_name=column_name,
-    )
-
-
 def _cache_database_path(*, context: AnalysisCacheContext) -> Path:
     return context.root / f"v{_ANALYSIS_CACHE_VERSION}" / _CACHE_DATABASE_NAME
 
@@ -971,6 +1072,12 @@ def _payload_digest(payload: object) -> str:
     return hashlib.sha256(encoded).hexdigest()
 
 
+def _json_value_digest(payload: dict[str, object]) -> str:
+    """Digest string-keyed JSON scalars exactly as _payload_digest does, via orjson."""
+
+    return hashlib.sha256(orjson.dumps(payload, option=orjson.OPT_SORT_KEYS)).hexdigest()
+
+
 def _package_version(package: str) -> str:
     try:
         return version(package)

{sqlbuild-0.113.3 → sqlbuild-0.113.5}/src/sqlbuild/compiler/compile/_helpers/analysis/compact.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import logging
 import re
+from collections.abc import Sequence
 from dataclasses import replace
 from typing import Any, cast
 
@@ -30,6 +31,7 @@ from sqlbuild.compiler.compile._helpers.analysis.cte_facts import (
 )
 from sqlbuild.compiler.compile.constants import (
     COMPACT_ANALYSIS_FACT_LENGTH,
+    COMPACT_ANALYSIS_LEGACY_RESPONSE_LENGTH,
     COMPACT_ANALYSIS_RESPONSE_LENGTH,
     COMPACT_ANALYSIS_SOURCE_LENGTH,
     RESOLVED_SOURCE_CONFIDENCE,
@@ -353,7 +355,7 @@ def analyze_columns_and_lineage_with_polyglot(
             sqlbuild_error=str(error),
         )
         return PolyglotAnalysisResult(analysis_succeeded=False)
-    columns, lineage_columns, has_star = _analyze_columns_and_lineage_from_polyglot_ast(
+    columns, legacy_lineage_columns, has_star = _analyze_columns_and_lineage_from_polyglot_ast(
         parsed=parsed,
         references=references,
         column_nullability_by_table=column_nullability_by_table or {},
@@ -361,6 +363,25 @@ def analyze_columns_and_lineage_with_polyglot(
         inference_profile=profile,
         recover_cte_facts=recover_cte_facts,
     )
+    lineage_columns: Sequence[CompiledLineageColumnFact] = legacy_lineage_columns
+    if precomputed is not None and precomputed.compact_rows is not None:
+        lineage_columns = _compact_projected_analysis_result(
+            request=ProjectedAnalysisRequest(
+                analysis=None,
+                compact_rows=precomputed.compact_rows,
+                compact_fact_rows=precomputed.compact_fact_rows,
+                string_pool=precomputed.string_pool,
+                caches=CompactProjectionCaches(
+                    columns=precomputed.compact_column_cache,
+                    facts=precomputed.compact_fact_cache,
+                    decoded_facts=precomputed.compact_decoded_fact_cache,
+                ),
+                template_index=precomputed.compact_template_index,
+                resource_name_indexes=precomputed.resource_name_indexes,
+                binding_diagnostics=(),
+                binding_validated=False,
+            )
+        ).lineage_columns
     return PolyglotAnalysisResult(
         analysis_succeeded=True,
         columns=columns,
@@ -742,9 +763,14 @@ def _project_compact_analysis_batch(
                     )
                 )
                 continue
+            legacy_type_recovery: bool = (
+                isinstance(template, list)
+                and len(template) == COMPACT_ANALYSIS_LEGACY_RESPONSE_LENGTH
+                and template[2] == _NATIVE_LEGACY_FALLBACK
+            )
             if not (
                 isinstance(template, list)
-                and len(template) == COMPACT_ANALYSIS_RESPONSE_LENGTH
+                and (len(template) == COMPACT_ANALYSIS_RESPONSE_LENGTH or legacy_type_recovery)
                 and isinstance(template[0], list)
                 and isinstance(template[1], bool)
             ):
@@ -776,8 +802,8 @@ def _project_compact_analysis_batch(
             results.append(
                 NativeCompactAnalysis(
                     cleaned_sql=cleaned_sql,
-                    analysis={"hasStar": template[1]},
-                    projected=True,
+                    analysis=None if legacy_type_recovery else {"hasStar": template[1]},
+                    projected=not legacy_type_recovery,
                     compact_rows=cast(list[object], template[0]),
                     compact_fact_rows=cast(list[object], raw_facts),
                     string_pool=string_pool,