sqlbuild 0.37.7__tar.gz → 0.38.0__tar.gz

sqlbuild-0.38.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.38.0"
+}

{sqlbuild-0.37.7 → sqlbuild-0.38.0}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.38.0](https://github.com/chio-labs/sqlbuild/compare/v0.37.7...v0.38.0) (2026-06-23)
+
+
+### Features
+
+* **dbt:** add configured force and vars merging ([b8bf236](https://github.com/chio-labs/sqlbuild/commit/b8bf23629c37c1808870b03f45830f0119b72cb1))
+* **dbt:** add configured force and vars merging ([fecc042](https://github.com/chio-labs/sqlbuild/commit/fecc04240c3dd9e30fbd718b01add1e61f9f7a78))
+* **lineage:** use polyglot for rich column lineage ([e269447](https://github.com/chio-labs/sqlbuild/commit/e269447cfc33d1f195390f4e0632bfa57dbdda7c))
+* **lineage:** use polyglot for rich column lineage ([7493ecf](https://github.com/chio-labs/sqlbuild/commit/7493ecf3df3bfd18373c3a9182be801725eb766e))
+
 ## [0.37.7](https://github.com/chio-labs/sqlbuild/compare/v0.37.6...v0.37.7) (2026-06-23)
 
 

{sqlbuild-0.37.7 → sqlbuild-0.38.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.37.7
+Version: 0.38.0
 Summary: Typed, test-first SQL pipelines with local E2E testing
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -9,7 +9,6 @@ Requires-Dist: polyglot-sql>=0.5.9
 Requires-Dist: pydantic-settings<3,>=2
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=15.0.0
-Requires-Dist: sqlglot<31,>=27
 Provides-Extra: bigquery
 Requires-Dist: google-cloud-bigquery>=3.37.0; extra == 'bigquery'
 Provides-Extra: dagster

{sqlbuild-0.37.7 → sqlbuild-0.38.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlbuild"
-version = "0.37.7"
+version = "0.38.0"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -14,7 +14,6 @@ dependencies = [
   "pydantic-settings>=2,<3",
   "PyYAML>=6.0.2",
   "rich>=15.0.0",
-  "sqlglot>=27,<31",
 ]
 
 [project.optional-dependencies]

{sqlbuild-0.37.7 → sqlbuild-0.38.0}/src/sqlbuild/cli/commands/main/build.py

@@ -82,6 +82,7 @@ from sqlbuild.executor.python_nodes.models import (
 from sqlbuild.provider.main.session import build_provider_session
 from sqlbuild.shared.helpers.colors import supports_color
 from sqlbuild.spec.models.project import resolve_effective_adapter_name
+from sqlbuild.spec.models.targets import resolve_effective_force
 
 
 def run_build(
@@ -118,6 +119,12 @@ def run_build(
     discovered_inputs: DiscoveredProjectInputs = discover_project_inputs(
         project_dir=effective_project_dir
     )
+    effective_force: bool = resolve_effective_force(
+        project_config=discovered_inputs.project_config,
+        local_config=discovered_inputs.local_config,
+        selected_target=None,
+        cli_force=force,
+    )
     enforce_no_defer_to_in_virtual_mode(
         discovered_inputs=discovered_inputs,
         command_name="build",
@@ -167,7 +174,7 @@ def run_build(
                 full_refresh=full_refresh,
                 virtual_environment_name=virtual_env,
                 include_stale_upstreams=include_stale_upstreams,
-                changes_only=not force,
+                changes_only=not effective_force,
                 auto_load_sources=should_load_sources,
                 reload_sources=reload_sources,
                 include_python=include_python,
@@ -200,7 +207,7 @@ def run_build(
             select=select,
             exclude=exclude,
             full_refresh=full_refresh,
-            changes_only=not force,
+            changes_only=not effective_force,
             auto_load_sources=should_load_sources,
             reload_sources=reload_sources,
             connection_config=connection_config,

{sqlbuild-0.37.7 → sqlbuild-0.38.0}/src/sqlbuild/cli/commands/main/plan.py

@@ -32,6 +32,7 @@ from sqlbuild.compiler.planner.models import CursorOverrides, PlanOutput
 from sqlbuild.shared.helpers.colors import supports_color
 from sqlbuild.shared.helpers.display import DisplayOptions
 from sqlbuild.spec.models.project import resolve_effective_adapter_name
+from sqlbuild.spec.models.targets import resolve_effective_force
 from sqlbuild.virtual.planner.main.plan import run_virtual_plan_pipeline
 
 
@@ -60,6 +61,12 @@ def run_plan(
     discovered_inputs: DiscoveredProjectInputs = discover_project_inputs(
         project_dir=effective_project_dir
     )
+    effective_force: bool = resolve_effective_force(
+        project_config=discovered_inputs.project_config,
+        local_config=discovered_inputs.local_config,
+        selected_target=None,
+        cli_force=force,
+    )
     enforce_no_defer_to_in_virtual_mode(
         discovered_inputs=discovered_inputs,
         command_name="plan",
@@ -113,7 +120,7 @@ def run_plan(
             full_refresh=full_refresh,
             virtual_environment_name=virtual_env,
             include_stale_upstreams=include_stale_upstreams,
-            changes_only=not force,
+            changes_only=not effective_force,
             auto_load_sources=should_load_sources,
             include_python=include_python,
             select=select,
@@ -135,7 +142,7 @@ def run_plan(
             defer_sources_to=defer_sources_to,
             cursor_overrides=cursor_overrides,
             full_refresh=full_refresh,
-            changes_only=not force,
+            changes_only=not effective_force,
             auto_load_sources=should_load_sources,
             select=select,
             exclude=exclude,

{sqlbuild-0.37.7 → sqlbuild-0.38.0}/src/sqlbuild/compiler/discovery/helpers/yml/project.py

@@ -26,6 +26,7 @@ from sqlbuild.spec.models.project import (
     JanitorConfig,
     LocalClonePolicy,
     LocalConfig,
+    LocalDbtConfig,
     LocalStateConfig,
     LocalTargetConfig,
     ProjectConfig,
@@ -124,6 +125,7 @@ def load_local_config(*, project_dir: Path) -> LocalConfig:
     vars_map: dict[str, str] = _load_string_mapping(
         payload=payload.get("vars"), file_path=file_path
     )
+    dbt: LocalDbtConfig = _load_local_dbt(payload=payload.get("dbt"), file_path=file_path)
     scenario: ScenarioConfig = _load_scenario(payload=payload.get("scenario"), file_path=file_path)
     return LocalConfig(
         target=target,
@@ -133,6 +135,7 @@ def load_local_config(*, project_dir: Path) -> LocalConfig:
         settings=settings,
         setting_overrides=setting_overrides,
         vars=vars_map,
+        dbt=dbt,
         scenario=scenario,
     )
 
@@ -258,6 +261,7 @@ def _load_settings(*, payload: object, file_path: Path) -> SettingsConfig:
         key="virtual_environments",
         default=False,
     )
+    force: bool = _optional_bool(mapping=mapping, key="force", default=False)
     concurrency_key: str = "max_concurrency" if "max_concurrency" in mapping else "concurrency"
     concurrency: int = _optional_int(mapping=mapping, key=concurrency_key, default=1)
     table_promotion_mode: str | None = _optional_str(payload=mapping, key="table_promotion_mode")
@@ -273,6 +277,7 @@ def _load_settings(*, payload: object, file_path: Path) -> SettingsConfig:
         sql_validation=sql_validation,
         concurrency=concurrency,
         auto_load_sources=auto_load_sources,
+        force=force,
         virtual_environments=virtual_environments,
         table_promotion_mode=table_promotion_mode,
         default_audit_severity=default_audit_severity,
@@ -444,6 +449,7 @@ def _load_targets(*, payload: object, file_path: Path) -> dict[str, TargetConfig
             schema=_optional_str(payload=target_mapping, key="schema"),
             defer_sources_to=_optional_str(payload=target_mapping, key="defer_sources_to"),
             reuse_from=_optional_str(payload=target_mapping, key="reuse_from"),
+            force=_optional_nullable_bool(mapping=target_mapping, key="force"),
             reuse_hard_copy=_optional_bool(
                 mapping=target_mapping,
                 key="reuse_hard_copy",
@@ -509,6 +515,7 @@ def _load_local_targets(*, payload: object, file_path: Path) -> dict[str, LocalT
             schema=_optional_str(payload=target_mapping, key="schema"),
             defer_sources_to=_optional_str(payload=target_mapping, key="defer_sources_to"),
             reuse_from=_optional_str(payload=target_mapping, key="reuse_from"),
+            force=_optional_nullable_bool(mapping=target_mapping, key="force"),
             reuse_hard_copy=_optional_nullable_bool(
                 mapping=target_mapping,
                 key="reuse_hard_copy",
@@ -669,6 +676,7 @@ def _load_dbt(*, payload: object, file_path: Path) -> DbtConfig:
                 "profiles_dir",
                 "target",
                 "target_path",
+                "vars",
                 "replay_on_change",
                 "reuse_from",
             }
@@ -681,6 +689,7 @@ def _load_dbt(*, payload: object, file_path: Path) -> DbtConfig:
         profiles_dir=_optional_str(payload=mapping, key="profiles_dir"),
         target=_optional_str(payload=mapping, key="target"),
         target_path=_optional_str(payload=mapping, key="target_path"),
+        vars=_load_object_mapping(payload=mapping.get("vars"), file_path=file_path),
         replay_on_change=_optional_str(payload=mapping, key="replay_on_change"),
         reuse_from=_load_dbt_reuse_from(
             payload=mapping.get("reuse_from"),
@@ -689,6 +698,21 @@ def _load_dbt(*, payload: object, file_path: Path) -> DbtConfig:
     )
 
 
+def _load_local_dbt(*, payload: object, file_path: Path) -> LocalDbtConfig:
+    """Load optional local dbt interop configuration."""
+
+    mapping: dict[str, object] = _coerce_mapping(payload=payload, label="dbt", file_path=file_path)
+    _validate_allowed_keys(
+        mapping=mapping,
+        allowed_keys=frozenset({"vars"}),
+        label="dbt",
+        file_path=file_path,
+    )
+    return LocalDbtConfig(
+        vars=_load_object_mapping(payload=mapping.get("vars"), file_path=file_path),
+    )
+
+
 def _load_dbt_reuse_from(*, payload: object, file_path: Path) -> DbtReuseFromConfig:
     mapping: dict[str, object] = _coerce_mapping(
         payload=payload,
@@ -798,6 +822,13 @@ def _load_string_mapping(*, payload: object, file_path: Path) -> dict[str, str]:
     return result
 
 
+def _load_object_mapping(*, payload: object, file_path: Path) -> dict[str, object]:
+    mapping: dict[str, object] = _coerce_mapping(
+        payload=payload, label="mapping", file_path=file_path
+    )
+    return dict(mapping)
+
+
 def _load_string_sequence(*, payload: object, label: str, file_path: Path) -> list[str]:
     if payload is None:
         return []

sqlbuild-0.38.0/src/sqlbuild/compiler/lineage/helpers/rich_columns.py

@@ -0,0 +1,333 @@
+"""Polyglot-backed rich column lineage analyzer."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from sqlbuild.adapter.shared.types import BuiltinAdapter, TypeDialect
+from sqlbuild.compiler.compile.models.core import CompiledModel, CompiledProject
+from sqlbuild.compiler.compile.types import CompiledResourceType
+from sqlbuild.compiler.lineage.helpers.columns import (
+    _build_schema_mapping,
+    _build_star_lineage,
+    _normalize_sqlbuild_refs,
+    _PhysicalResource,
+)
+from sqlbuild.compiler.lineage.models import (
+    ColumnLineage,
+    ColumnLineageEdge,
+    ColumnLineageSource,
+    ModelColumnLineage,
+    ProjectColumnLineage,
+    QualifiedLineageColumn,
+)
+from sqlbuild.compiler.lineage.types import (
+    ColumnLineageConfidence,
+    ColumnTransformKind,
+    InferredNullability,
+    PolyglotAnalysisDialect,
+)
+from sqlbuild.shared.constants import (
+    POLYGLOT_ANALYSIS_IS_STAR,
+    POLYGLOT_ANALYSIS_NAME,
+    POLYGLOT_ANALYSIS_NULLABILITY,
+    POLYGLOT_ANALYSIS_NULLABILITY_NON_NULL,
+    POLYGLOT_ANALYSIS_NULLABILITY_NULLABLE,
+    POLYGLOT_ANALYSIS_PROJECTIONS,
+    POLYGLOT_ANALYSIS_SOURCE_ALIAS,
+    POLYGLOT_ANALYSIS_SOURCE_CONFIDENCE,
+    POLYGLOT_ANALYSIS_SOURCE_NAME,
+    POLYGLOT_ANALYSIS_STAR_PROJECTIONS,
+    POLYGLOT_ANALYSIS_TABLE,
+    POLYGLOT_ANALYSIS_TRANSFORM_AGGREGATION,
+    POLYGLOT_ANALYSIS_TRANSFORM_CAST,
+    POLYGLOT_ANALYSIS_TRANSFORM_CONSTANT,
+    POLYGLOT_ANALYSIS_TRANSFORM_DIRECT,
+    POLYGLOT_ANALYSIS_TRANSFORM_KIND,
+    POLYGLOT_ANALYSIS_UPSTREAM,
+    POLYGLOT_PAYLOAD_COLUMN,
+)
+from sqlbuild.shared.helpers.diagnostics_logging import log_debug_event
+from sqlbuild.shared.helpers.polyglot import import_polyglot_sql
+
+_DEBUG_LOGGER: logging.Logger = logging.getLogger("sqlbuild.lineage")
+_POLYGLOT_DIALECT_ALIASES: dict[str, PolyglotAnalysisDialect] = {
+    "": PolyglotAnalysisDialect.GENERIC,
+    "ansi": PolyglotAnalysisDialect.GENERIC,
+    "generic": PolyglotAnalysisDialect.GENERIC,
+    TypeDialect.GENERIC.value: PolyglotAnalysisDialect.GENERIC,
+    TypeDialect.BIGQUERY.value: PolyglotAnalysisDialect.BIGQUERY,
+    TypeDialect.SNOWFLAKE.value: PolyglotAnalysisDialect.SNOWFLAKE,
+    TypeDialect.DUCKDB.value: PolyglotAnalysisDialect.DUCKDB,
+    TypeDialect.MOTHERDUCK.value: PolyglotAnalysisDialect.DUCKDB,
+    TypeDialect.DATABRICKS.value: PolyglotAnalysisDialect.DATABRICKS,
+    TypeDialect.POSTGRES.value: PolyglotAnalysisDialect.POSTGRESQL,
+    TypeDialect.TSQL.value: PolyglotAnalysisDialect.TSQL,
+    BuiltinAdapter.SQLSERVER.value: PolyglotAnalysisDialect.TSQL,
+    "postgresql": PolyglotAnalysisDialect.POSTGRESQL,
+}
+
+
+def build_rich_project_column_lineage(
+    project: CompiledProject,
+    *,
+    dialect: str | None = None,
+    model_names: frozenset[str] | None = None,
+) -> ProjectColumnLineage | None:
+    """Build a rich project column lineage graph using Polyglot query analysis."""
+
+    if not project.settings.sql_analysis:
+        return None
+
+    schema: dict[str, dict[str, str]] = _build_schema_mapping(project)
+    model_results: dict[str, ModelColumnLineage] = {}
+    collapsed_edges: list[ColumnLineageEdge] = []
+
+    for model in project.models:
+        if model_names is not None and model.name not in model_names:
+            continue
+        result: ModelColumnLineage | None = _build_polyglot_model_column_lineage(
+            model,
+            schema=schema,
+            dialect=dialect,
+        )
+        if result is None:
+            continue
+        model_results[model.name] = result
+        target_resource_name: str = model.name
+        for column in result.columns:
+            target: QualifiedLineageColumn = QualifiedLineageColumn(
+                resource_type=CompiledResourceType.MODEL,
+                resource_name=target_resource_name,
+                column_name=column.output_column,
+            )
+            for upstream in column.upstream_columns:
+                collapsed_edges.append(
+                    ColumnLineageEdge(
+                        source=upstream.as_qualified_column(),
+                        target=target,
+                        transform_kind=column.transform_kind,
+                        confidence=column.confidence,
+                    )
+                )
+
+    return ProjectColumnLineage(models=model_results, edges=tuple(collapsed_edges))
+
+
+def _build_polyglot_model_column_lineage(
+    model: CompiledModel,
+    *,
+    schema: dict[str, dict[str, str]],
+    dialect: str | None,
+) -> ModelColumnLineage | None:
+    normalized_sql: str
+    physical_resources: tuple[_PhysicalResource, ...]
+    normalized_sql, physical_resources = _normalize_sqlbuild_refs(model.query_sql)
+    resource_by_physical_name: dict[str, _PhysicalResource] = {
+        resource.physical_name: resource for resource in physical_resources
+    }
+    polyglot_module: Any | None = import_polyglot_sql()
+    if polyglot_module is None:
+        return None
+    try:
+        analysis: Any = polyglot_module.analyze_query(
+            normalized_sql,
+            {
+                "dialect": _polyglot_dialect(dialect),
+                "schema": _polyglot_schema(schema),
+            },
+        )
+    except Exception as error:
+        log_debug_event(
+            _DEBUG_LOGGER,
+            "rich column lineage analysis failed; skipping model",
+            sqlbuild_model=model.name,
+            sqlbuild_error=str(error),
+        )
+        return None
+    if not isinstance(analysis, dict):
+        return None
+    projections: object = analysis.get(POLYGLOT_ANALYSIS_PROJECTIONS)
+    if not isinstance(projections, list):
+        return None
+
+    lineages: list[ColumnLineage] = []
+    star_expanded_columns: frozenset[str] = _star_expanded_columns(analysis)
+    projection: object
+    for projection in projections:
+        if not isinstance(projection, dict):
+            continue
+        if bool(projection.get(POLYGLOT_ANALYSIS_IS_STAR)):
+            continue
+        output_value: object = projection.get(POLYGLOT_ANALYSIS_NAME)
+        output_column: str = output_value if isinstance(output_value, str) else ""
+        if not output_column:
+            continue
+        if output_column in star_expanded_columns:
+            continue
+        upstream_columns, confidence = _projection_upstreams(
+            projection=projection,
+            resource_by_physical_name=resource_by_physical_name,
+        )
+        transform_kind: ColumnTransformKind = _projection_transform_kind(
+            projection=projection,
+            has_upstream=bool(upstream_columns),
+        )
+        lineages.append(
+            ColumnLineage(
+                output_column=output_column,
+                transform_kind=transform_kind,
+                expression_sql=None,
+                upstream_columns=upstream_columns,
+                nullability=_projection_nullability(projection),
+                confidence=(
+                    confidence
+                    if upstream_columns or transform_kind == ColumnTransformKind.CONSTANT
+                    else ColumnLineageConfidence.UNKNOWN
+                ),
+            )
+        )
+
+    has_star: bool = bool(star_expanded_columns)
+    if has_star:
+        lineages.extend(
+            _build_star_lineage(
+                model=model,
+                schema=schema,
+                physical_resources=physical_resources,
+                existing_columns={lineage.output_column for lineage in lineages},
+            )
+        )
+
+    return ModelColumnLineage(
+        model_name=model.name,
+        columns=tuple(lineages),
+        has_star=has_star,
+    )
+
+
+def _projection_upstreams(
+    *,
+    projection: dict[str, Any],
+    resource_by_physical_name: dict[str, _PhysicalResource],
+) -> tuple[tuple[ColumnLineageSource, ...], ColumnLineageConfidence]:
+    upstream_values: object = projection.get(POLYGLOT_ANALYSIS_UPSTREAM)
+    if not isinstance(upstream_values, list):
+        return (), ColumnLineageConfidence.UNKNOWN
+    sources: list[ColumnLineageSource] = []
+    seen: set[tuple[CompiledResourceType, str, str]] = set()
+    confidence: ColumnLineageConfidence = ColumnLineageConfidence.HIGH
+    upstream: object
+    for upstream in upstream_values:
+        if not isinstance(upstream, dict):
+            continue
+        column_value: object = upstream.get(POLYGLOT_PAYLOAD_COLUMN)
+        if not isinstance(column_value, str) or not column_value or column_value == "*":
+            continue
+        source_name: object = upstream.get(POLYGLOT_ANALYSIS_SOURCE_NAME) or upstream.get(
+            POLYGLOT_ANALYSIS_TABLE
+        )
+        if not isinstance(source_name, str) or not source_name:
+            confidence = ColumnLineageConfidence.UNKNOWN
+            continue
+        resource: _PhysicalResource | None = resource_by_physical_name.get(source_name)
+        if resource is None:
+            continue
+        source_confidence: object = upstream.get(POLYGLOT_ANALYSIS_SOURCE_CONFIDENCE)
+        source_alias: object = upstream.get(POLYGLOT_ANALYSIS_SOURCE_ALIAS)
+        if source_confidence != "resolved" and not isinstance(source_alias, str):
+            confidence = ColumnLineageConfidence.MEDIUM
+        key: tuple[CompiledResourceType, str, str] = (
+            resource.resource_type,
+            resource.resource_name,
+            column_value,
+        )
+        if key in seen:
+            continue
+        seen.add(key)
+        sources.append(
+            ColumnLineageSource(
+                resource_type=resource.resource_type,
+                resource_name=resource.resource_name,
+                column_name=column_value,
+            )
+        )
+    return tuple(
+        sorted(
+            sources,
+            key=lambda source: (
+                source.resource_type.value,
+                source.resource_name,
+                source.column_name,
+            ),
+        )
+    ), confidence
+
+
+def _star_expanded_columns(analysis: dict[str, Any]) -> frozenset[str]:
+    expanded: set[str] = set()
+    star_projections: object = analysis.get(POLYGLOT_ANALYSIS_STAR_PROJECTIONS)
+    if not isinstance(star_projections, list):
+        return frozenset()
+    star_projection: object
+    for star_projection in star_projections:
+        if not isinstance(star_projection, dict):
+            continue
+        columns: object = star_projection.get("expandedColumns")
+        if not isinstance(columns, list):
+            continue
+        column: object
+        for column in columns:
+            if isinstance(column, str) and column:
+                expanded.add(column)
+    return frozenset(expanded)
+
+
+def _polyglot_schema(schema: dict[str, dict[str, str]]) -> dict[str, object]:
+    return {
+        "tables": [
+            {
+                "name": table_name,
+                "columns": [
+                    {"name": column_name, "type": column_type or "UNKNOWN"}
+                    for column_name, column_type in sorted(columns.items())
+                ],
+            }
+            for table_name, columns in sorted(schema.items())
+        ]
+    }
+
+
+def _polyglot_dialect(dialect: str | TypeDialect | None) -> PolyglotAnalysisDialect:
+    if dialect is None:
+        return PolyglotAnalysisDialect.GENERIC
+    normalized: str = dialect.strip().lower()
+    mapped: PolyglotAnalysisDialect | None = _POLYGLOT_DIALECT_ALIASES.get(normalized)
+    if mapped is not None:
+        return mapped
+    return PolyglotAnalysisDialect(normalized)
+
+
+def _projection_nullability(projection: dict[str, Any]) -> InferredNullability:
+    value: object = projection.get(POLYGLOT_ANALYSIS_NULLABILITY)
+    if value == POLYGLOT_ANALYSIS_NULLABILITY_NON_NULL:
+        return InferredNullability.NON_NULL
+    if value == POLYGLOT_ANALYSIS_NULLABILITY_NULLABLE:
+        return InferredNullability.NULLABLE
+    return InferredNullability.UNKNOWN
+
+
+def _projection_transform_kind(
+    *, projection: dict[str, Any], has_upstream: bool
+) -> ColumnTransformKind:
+    transform_kind: str = str(projection.get(POLYGLOT_ANALYSIS_TRANSFORM_KIND) or "")
+    if transform_kind == POLYGLOT_ANALYSIS_TRANSFORM_CAST:
+        return ColumnTransformKind.CAST
+    if transform_kind == POLYGLOT_ANALYSIS_TRANSFORM_AGGREGATION:
+        return ColumnTransformKind.AGGREGATION
+    if transform_kind == POLYGLOT_ANALYSIS_TRANSFORM_CONSTANT or not has_upstream:
+        return ColumnTransformKind.CONSTANT
+    if transform_kind == POLYGLOT_ANALYSIS_TRANSFORM_DIRECT:
+        return ColumnTransformKind.DIRECT
+    return ColumnTransformKind.EXPRESSION

sqlbuild-0.38.0/src/sqlbuild/compiler/lineage/types.py

@@ -0,0 +1,80 @@
+"""Column lineage domain types."""
+
+from __future__ import annotations
+
+from enum import StrEnum
+
+
+class ColumnTransformKind(StrEnum):
+    """High-level transform classification for one output column."""
+
+    DIRECT = "direct"
+    CAST = "cast"
+    EXPRESSION = "expression"
+    AGGREGATION = "aggregation"
+    STAR = "star"
+    CONSTANT = "constant"
+    UNKNOWN = "unknown"
+
+
+class InferredNullability(StrEnum):
+    """Conservative nullability state inferred for an output column."""
+
+    NON_NULL = "non_null"
+    NULLABLE = "nullable"
+    UNKNOWN = "unknown"
+
+
+class ColumnLineageConfidence(StrEnum):
+    """Coarse confidence that a lineage edge is fully understood."""
+
+    HIGH = "high"
+    MEDIUM = "medium"
+    LOW = "low"
+    UNKNOWN = "unknown"
+
+
+class ColumnLineageMode(StrEnum):
+    """Column lineage analyzer mode."""
+
+    RICH = "rich"
+    FAST = "fast"
+
+
+class PolyglotAnalysisDialect(StrEnum):
+    """Dialect names accepted by Polyglot analyze_query."""
+
+    GENERIC = "generic"
+    POSTGRESQL = "postgresql"
+    MYSQL = "mysql"
+    BIGQUERY = "bigquery"
+    SNOWFLAKE = "snowflake"
+    DUCKDB = "duckdb"
+    SQLITE = "sqlite"
+    HIVE = "hive"
+    SPARK = "spark"
+    TRINO = "trino"
+    PRESTO = "presto"
+    REDSHIFT = "redshift"
+    TSQL = "tsql"
+    ORACLE = "oracle"
+    CLICKHOUSE = "clickhouse"
+    DATABRICKS = "databricks"
+    ATHENA = "athena"
+    TERADATA = "teradata"
+    DORIS = "doris"
+    STARROCKS = "starrocks"
+    MATERIALIZE = "materialize"
+    RISINGWAVE = "risingwave"
+    SINGLESTORE = "singlestore"
+    COCKROACHDB = "cockroachdb"
+    TIDB = "tidb"
+    DRUID = "druid"
+    SOLR = "solr"
+    TABLEAU = "tableau"
+    DUNE = "dune"
+    FABRIC = "fabric"
+    DRILL = "drill"
+    DREMIO = "dremio"
+    EXASOL = "exasol"
+    DATAFUSION = "datafusion"