sqlbuild 0.30.0__tar.gz → 0.30.1__tar.gz

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

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

{sqlbuild-0.30.0 → sqlbuild-0.30.1}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.30.1](https://github.com/chio-labs/sqlbuild/compare/v0.30.0...v0.30.1) (2026-06-08)
+
+
+### Bug Fixes
+
+* avoid recursive compile layer counting ([312090f](https://github.com/chio-labs/sqlbuild/commit/312090f894f3284ab2a962f0d8ef3760fe74466d))
+* restore compile analysis parity ([f3bdf6e](https://github.com/chio-labs/sqlbuild/commit/f3bdf6ed9495bdc485e97b619232274b609bb25b))
+
+
+### Performance Improvements
+
+* fuse compact sql analysis ([07982a5](https://github.com/chio-labs/sqlbuild/commit/07982a588e10a76f16a13093e2b4c550894a8dbc))
+* parallelize compile sql analysis ([703550f](https://github.com/chio-labs/sqlbuild/commit/703550fe0db48373c0135a840bbb5674dd4c72c3))
+* reduce compile discovery overhead ([64375cf](https://github.com/chio-labs/sqlbuild/commit/64375cf8996e0ec52afa197884cfc228a1612442))
+* reduce compile scanner overhead ([d4f2d75](https://github.com/chio-labs/sqlbuild/commit/d4f2d750a3a6daaf941dd0bab813e5cc9b187ea2))
+* speed up compile analysis ([507b61d](https://github.com/chio-labs/sqlbuild/commit/507b61da545fb30a245d3e2143e23a0a8977f640))
+* speed up compile analysis ([e33eedc](https://github.com/chio-labs/sqlbuild/commit/e33eedca6cbb90c6402920168e7f8e4401067a30))
+
 ## [0.30.0](https://github.com/chio-labs/sqlbuild/compare/v0.29.0...v0.30.0) (2026-06-07)
 
 

{sqlbuild-0.30.0 → sqlbuild-0.30.1}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.30.0
+Version: 0.30.1
 Summary: Typed, test-first SQL pipelines with local E2E testing
 License-File: LICENSE
 Requires-Python: >=3.12
 Requires-Dist: duckdb>=1.3.2
+Requires-Dist: polyglot-sql>=0.3.12
 Requires-Dist: pydantic-settings<3,>=2
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=15.0.0

{sqlbuild-0.30.0 → sqlbuild-0.30.1}/pyproject.toml

@@ -4,12 +4,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlbuild"
-version = "0.30.0"
+version = "0.30.1"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
   "duckdb>=1.3.2",
+  "polyglot-sql>=0.3.12",
   "pydantic-settings>=2,<3",
   "PyYAML>=6.0.2",
   "rich>=15.0.0",

{sqlbuild-0.30.0 → sqlbuild-0.30.1}/src/sqlbuild/cli/commands/main/compile.py

@@ -49,6 +49,10 @@ def run_compile(
     no_color: bool = False,
     lineage_mode: CompileLineageMode = CompileLineageMode.FAST,
     cli_vars: dict[str, object] | None = None,
+    profile_skip_discovery_sqlglot: bool = False,
+    profile_skip_column_inference: bool = False,
+    profile_skip_contracts: bool = False,
+    profile_skip_write: bool = False,
 ) -> int:
     """Execute the compile command."""
 
@@ -57,7 +61,8 @@ def run_compile(
     effective_project_dir: Path = project_dir if project_dir is not None else Path.cwd()
     discover_start: float = time.monotonic()
     discovered_inputs: DiscoveredProjectInputs = discover_project_inputs(
-        project_dir=effective_project_dir
+        project_dir=effective_project_dir,
+        sqlglot_enabled_override=False if profile_skip_discovery_sqlglot else None,
     )
     discover_ms: int = _elapsed_ms(discover_start)
     adapter: BaseAdapter = resolve_adapter(
@@ -72,6 +77,7 @@ def run_compile(
         discovered_inputs=discovered_inputs,
         adapter=adapter,
         no_sql_validation=no_sql_validation,
+        skip_column_inference=profile_skip_column_inference,
         cli_vars=cli_vars,
     )
     graph_ms: int = _elapsed_ms(graph_start)
@@ -83,10 +89,14 @@ def run_compile(
     )
     lineage_ms: int = _elapsed_ms(lineage_start)
     contracts_start: float = time.monotonic()
-    contract_result: ContractValidationResult = validate_model_contracts(
-        graph.project,
-        dialect=adapter.sqlglot_dialect(),
-    )
+    contract_result: ContractValidationResult
+    if profile_skip_contracts:
+        contract_result = ContractValidationResult(diagnostics=())
+    else:
+        contract_result = validate_model_contracts(
+            graph.project,
+            dialect=adapter.sqlglot_dialect(),
+        )
     contract_ms: int = _elapsed_ms(contracts_start)
     diagnostics: tuple[CompilerDiagnostic, ...] = (
         *graph.project.diagnostics,
@@ -125,12 +135,24 @@ def run_compile(
         )
 
     write_start: float = time.monotonic()
-    written: WrittenTarget = write_static_compile_target(
-        target_dir=effective_project_dir / "target",
-        adapter=adapter,
-        project=graph.project,
-        manifest=manifest_payload,
-    )
+    target_dir: Path = effective_project_dir / "target"
+    written: WrittenTarget
+    if profile_skip_write:
+        written = WrittenTarget(
+            model_count=0,
+            seed_count=0,
+            function_count=0,
+            audit_count=0,
+            test_count=0,
+            target_dir=target_dir,
+        )
+    else:
+        written = write_static_compile_target(
+            target_dir=target_dir,
+            adapter=adapter,
+            project=graph.project,
+            manifest=manifest_payload,
+        )
     write_ms: int = _elapsed_ms(write_start)
     timings_ms: dict[str, int] = {
         "discover_ms": discover_ms,

{sqlbuild-0.30.0 → sqlbuild-0.30.1}/src/sqlbuild/cli/commands/main/entry.py

@@ -73,6 +73,30 @@ def _build_parser(*, use_color: bool = False) -> argparse.ArgumentParser:
         default=CompileLineageMode.FAST.value,
         help="Column lineage mode: fast (default), rich (slower), or none",
     )
+    compile_parser.add_argument(
+        "--profile-skip-discovery-sqlglot",
+        action="store_true",
+        default=False,
+        help="Diagnostic: skip SQLGlot-assisted discovery parsing",
+    )
+    compile_parser.add_argument(
+        "--profile-skip-column-inference",
+        action="store_true",
+        default=False,
+        help="Diagnostic: skip compile-time column inference",
+    )
+    compile_parser.add_argument(
+        "--profile-skip-contracts",
+        action="store_true",
+        default=False,
+        help="Diagnostic: skip offline contract validation",
+    )
+    compile_parser.add_argument(
+        "--profile-skip-write",
+        action="store_true",
+        default=False,
+        help="Diagnostic: skip writing target/compiled artifacts",
+    )
     add_vars_args(compile_parser)
     add_dbt_config_args(compile_parser)
 
@@ -547,6 +571,10 @@ def _main_with_dependencies(
                 args.no_color,
                 CompileLineageMode(args.compile_lineage_mode),
                 args.vars,
+                args.profile_skip_discovery_sqlglot,
+                args.profile_skip_column_inference,
+                args.profile_skip_contracts,
+                args.profile_skip_write,
             )
         if args.command == CliCommand.DAG:
             return handlers.run_dag(

{sqlbuild-0.30.0 → sqlbuild-0.30.1}/src/sqlbuild/cli/commands/main/helpers/compile/output.py

@@ -487,22 +487,34 @@ def _execution_layer_count(graph: ProjectGraph) -> int:
     model_keys: set[CompiledObjectKey] = {model.key for model in graph.project.models}
     if not model_keys:
         return 0
-    cache: dict[CompiledObjectKey, int] = {}
-
-    def layer_for(key: CompiledObjectKey, visiting: frozenset[CompiledObjectKey]) -> int:
-        if key in cache:
-            return cache[key]
-        if key in visiting:
-            return 1
-        dep_layers: list[int] = []
-        for dep in graph.upstream_deps.get(key, ()):
-            if dep in model_keys:
-                dep_layers.append(layer_for(dep, visiting | {key}))
-        layer: int = 1 + max(dep_layers, default=0)
-        cache[key] = layer
-        return layer
-
-    return max(layer_for(key, frozenset()) for key in model_keys)
+    remaining_model_deps: dict[CompiledObjectKey, set[CompiledObjectKey]] = {
+        key: {dep for dep in graph.upstream_deps.get(key, ()) if dep in model_keys}
+        for key in model_keys
+    }
+    downstream_model_deps: dict[CompiledObjectKey, set[CompiledObjectKey]] = {
+        key: {dep for dep in graph.downstream_deps.get(key, ()) if dep in model_keys}
+        for key in model_keys
+    }
+    current_layer: set[CompiledObjectKey] = {
+        key for key, deps in remaining_model_deps.items() if not deps
+    }
+    visited: set[CompiledObjectKey] = set()
+    layer_count: int = 0
+    while current_layer:
+        layer_count += 1
+        next_layer: set[CompiledObjectKey] = set()
+        for key in current_layer:
+            visited.add(key)
+            for downstream_key in downstream_model_deps.get(key, set()):
+                if downstream_key in visited:
+                    continue
+                remaining_model_deps[downstream_key].discard(key)
+                if not remaining_model_deps[downstream_key]:
+                    next_layer.add(downstream_key)
+        current_layer = next_layer
+    if len(visited) != len(model_keys):
+        return max(layer_count, 1)
+    return layer_count
 
 
 def _relative_target_path(path: Path) -> str:

{sqlbuild-0.30.0 → sqlbuild-0.30.1}/src/sqlbuild/cli/commands/main/helpers/entry/models.py

@@ -35,6 +35,10 @@ class CliNamespace:
     manifest: bool = False
     dag: str | None = None
     compile_lineage_mode: CompileLineageMode = CompileLineageMode.FAST
+    profile_skip_discovery_sqlglot: bool = False
+    profile_skip_column_inference: bool = False
+    profile_skip_contracts: bool = False
+    profile_skip_write: bool = False
     start_cursor_ts: str | None = None
     end_cursor_ts: str | None = None
     start_cursor_int: str | None = None
@@ -126,6 +130,10 @@ class CliEntrypointHandlers:
             bool,
             CompileLineageMode,
             dict[str, object],
+            bool,
+            bool,
+            bool,
+            bool,
         ],
         int,
     ]

{sqlbuild-0.30.0 → sqlbuild-0.30.1}/src/sqlbuild/compiler/compile/helpers/assembly.py

@@ -3,7 +3,8 @@
 from __future__ import annotations
 
 import re
-from dataclasses import replace
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass, replace
 
 from sqlbuild.adapter.shared.models import ExpressionInferenceProfile
 from sqlbuild.compiler.compile.helpers.deps import (
@@ -13,12 +14,17 @@ from sqlbuild.compiler.compile.helpers.deps import (
     sql_test_scope_deps,
 )
 from sqlbuild.compiler.compile.helpers.macros import expand_sql_macros, find_macro_call_names
-from sqlbuild.compiler.compile.helpers.sqlglot_columns import infer_columns_with_sqlglot
+from sqlbuild.compiler.compile.helpers.sqlglot_columns import (
+    analyze_columns_and_lineage_with_polyglot,
+    infer_columns_with_sqlglot,
+)
+from sqlbuild.compiler.compile.helpers.sqlglot_validation import validate_sql_syntax
 from sqlbuild.compiler.compile.helpers.templating import expand_template_data
 from sqlbuild.compiler.compile.models.core import (
     CompileAuditInput,
     CompiledAudit,
     CompiledFunction,
+    CompiledLineageColumnFact,
     CompiledModel,
     CompiledObjectKey,
     CompiledProject,
@@ -60,21 +66,41 @@ from sqlbuild.spec.models.project import (
 from sqlbuild.spec.models.schema import SchemaAuditInstance, SchemaColumn, SchemaSeedEntry
 from sqlbuild.spec.models.source import SourceColumnEntry, SourceEntry
 
+_POLYGLOT_ANALYSIS_WORKERS: int = 2
+_POLYGLOT_PARALLEL_ANALYSIS_MIN_MODELS: int = 32
+
+
+@dataclass(frozen=True)
+class _ModelSqlAnalysis:
+    polyglot_analysis: (
+        tuple[tuple[InferredColumn, ...] | None, tuple[CompiledLineageColumnFact, ...], bool] | bool
+    )
+    placeholders: dict[str, str] | None
+
 
 def assemble_compiled_project(
     inputs: CompileProjectInputs,
     *,
     inference_profile: ExpressionInferenceProfile | None = None,
+    skip_column_inference: bool = False,
 ) -> CompiledProject:
     """Convert attached compile inputs into the planner-ready project view."""
 
-    sqlglot_enabled: bool = inputs.effective_settings.sqlglot
+    sqlglot_enabled: bool = inputs.effective_settings.sqlglot and not skip_column_inference
     seed_names: frozenset[str] = frozenset(
         seed_input.schema_entry.name for seed_input in inputs.seed_inputs
     )
     column_nullability_by_table: dict[str, dict[str, InferredNullability]] = (
         _build_column_nullability_by_table(inputs)
     )
+    profile: ExpressionInferenceProfile = inference_profile or ExpressionInferenceProfile()
+    model_sql_analysis_by_name: dict[str, _ModelSqlAnalysis] = {}
+    if sqlglot_enabled:
+        model_sql_analysis_by_name = _analyze_model_sql_in_parallel(
+            model_inputs=inputs.model_inputs,
+            column_nullability_by_table=column_nullability_by_table,
+            inference_profile=profile,
+        )
     return CompiledProject(
         run_id=inputs.run_id,
         effective_target_name=inputs.effective_target_name,
@@ -97,7 +123,8 @@ def assemble_compiled_project(
                 sqlglot_enabled=sqlglot_enabled,
                 seed_names=seed_names,
                 column_nullability_by_table=column_nullability_by_table,
-                inference_profile=inference_profile,
+                inference_profile=profile,
+                sql_analysis=model_sql_analysis_by_name.get(model_input.model_file.file_path.stem),
             )
             for model_input in inputs.model_inputs
         ),
@@ -145,21 +172,58 @@ def _assemble_compiled_model(
     seed_names: frozenset[str] = frozenset(),
     column_nullability_by_table: dict[str, dict[str, InferredNullability]] | None = None,
     inference_profile: ExpressionInferenceProfile | None = None,
+    sql_analysis: _ModelSqlAnalysis | None = None,
 ) -> CompiledModel:
     model_name: str = model_input.model_file.file_path.stem
     inferred_columns: tuple[InferredColumn, ...] | None = None
-    raw_placeholders: object | None = model_input.config.values.get("placeholders")
+    fast_lineage_columns: tuple[CompiledLineageColumnFact, ...] | None = None
+    fast_lineage_has_star: bool = False
     placeholders: dict[str, str] | None = (
-        {str(k): str(v) for k, v in raw_placeholders.items()}
-        if isinstance(raw_placeholders, dict)
-        else None
+        sql_analysis.placeholders if sql_analysis is not None else _model_placeholders(model_input)
     )
     if sqlglot_enabled:
-        inferred_columns = infer_columns_with_sqlglot(
+        profile: ExpressionInferenceProfile = inference_profile or ExpressionInferenceProfile()
+        polyglot_analysis: (
+            tuple[tuple[InferredColumn, ...] | None, tuple[CompiledLineageColumnFact, ...], bool]
+            | bool
+        ) = (
+            sql_analysis.polyglot_analysis
+            if sql_analysis is not None
+            else analyze_columns_and_lineage_with_polyglot(
+                query_sql=model_input.query_sql,
+                references=model_input.references,
+                placeholders=placeholders,
+                column_nullability_by_table=column_nullability_by_table,
+                inference_profile=profile,
+            )
+        )
+        if isinstance(polyglot_analysis, tuple):
+            inferred_columns = polyglot_analysis[0]
+            fast_lineage_columns = polyglot_analysis[1]
+            fast_lineage_has_star = polyglot_analysis[2]
+        else:
+            if model_input.sql_validation_enabled:
+                validate_sql_syntax(
+                    query_sql=model_input.query_sql,
+                    model_name=model_name,
+                    file_path=model_input.model_file.file_path,
+                    placeholders=placeholders,
+                    dialect=profile.sqlglot_dialect,
+                )
+            inferred_columns = infer_columns_with_sqlglot(
+                query_sql=model_input.query_sql,
+                placeholders=placeholders,
+                column_nullability_by_table=column_nullability_by_table,
+                inference_profile=profile,
+            )
+    elif model_input.sql_validation_enabled:
+        profile = inference_profile or ExpressionInferenceProfile()
+        validate_sql_syntax(
             query_sql=model_input.query_sql,
+            model_name=model_name,
+            file_path=model_input.model_file.file_path,
             placeholders=placeholders,
-            column_nullability_by_table=column_nullability_by_table,
-            inference_profile=inference_profile,
+            dialect=profile.sqlglot_dialect,
         )
     return CompiledModel(
         key=CompiledObjectKey(resource_type=CompiledResourceType.MODEL, name=model_name),
@@ -172,12 +236,80 @@ def _assemble_compiled_model(
         references=model_input.references,
         schema_entry=model_input.schema_entry,
         inferred_columns=inferred_columns,
+        fast_lineage_columns=fast_lineage_columns,
+        fast_lineage_has_star=fast_lineage_has_star,
         authored_sql=model_input.model_file.contents,
         output_column_locations=model_input.model_file.output_column_locations,
         macro_deps=find_macro_call_names(model_input.macro_source_sql),
     )
 
 
+def _analyze_model_sql_in_parallel(
+    *,
+    model_inputs: tuple[CompileModelInput, ...],
+    column_nullability_by_table: dict[str, dict[str, InferredNullability]],
+    inference_profile: ExpressionInferenceProfile,
+) -> dict[str, _ModelSqlAnalysis]:
+    if not model_inputs:
+        return {}
+    if len(model_inputs) < _POLYGLOT_PARALLEL_ANALYSIS_MIN_MODELS:
+        return {
+            _model_name(model_input): _analyze_model_sql(
+                model_input,
+                column_nullability_by_table,
+                inference_profile,
+            )
+            for model_input in model_inputs
+        }
+    workers: int = min(_POLYGLOT_ANALYSIS_WORKERS, len(model_inputs))
+    with ThreadPoolExecutor(max_workers=workers) as executor:
+        analyses: tuple[_ModelSqlAnalysis, ...] = tuple(
+            executor.map(
+                lambda model_input: _analyze_model_sql(
+                    model_input,
+                    column_nullability_by_table,
+                    inference_profile,
+                ),
+                model_inputs,
+            )
+        )
+    return {
+        _model_name(model_input): analysis
+        for model_input, analysis in zip(model_inputs, analyses, strict=True)
+    }
+
+
+def _analyze_model_sql(
+    model_input: CompileModelInput,
+    column_nullability_by_table: dict[str, dict[str, InferredNullability]],
+    inference_profile: ExpressionInferenceProfile,
+) -> _ModelSqlAnalysis:
+    placeholders: dict[str, str] | None = _model_placeholders(model_input)
+    return _ModelSqlAnalysis(
+        polyglot_analysis=analyze_columns_and_lineage_with_polyglot(
+            query_sql=model_input.query_sql,
+            references=model_input.references,
+            placeholders=placeholders,
+            column_nullability_by_table=column_nullability_by_table,
+            inference_profile=inference_profile,
+        ),
+        placeholders=placeholders,
+    )
+
+
+def _model_placeholders(model_input: CompileModelInput) -> dict[str, str] | None:
+    raw_placeholders: object | None = model_input.config.values.get("placeholders")
+    return (
+        {str(k): str(v) for k, v in raw_placeholders.items()}
+        if isinstance(raw_placeholders, dict)
+        else None
+    )
+
+
+def _model_name(model_input: CompileModelInput) -> str:
+    return model_input.model_file.file_path.stem
+
+
 def _build_column_nullability_by_table(
     inputs: CompileProjectInputs,
 ) -> dict[str, dict[str, InferredNullability]]:

{sqlbuild-0.30.0 → sqlbuild-0.30.1}/src/sqlbuild/compiler/compile/helpers/attachment.py

@@ -134,6 +134,7 @@ def build_model_inputs(
     run_id: str,
     macro_context: MacroContext,
     no_sql_validation: bool = False,
+    defer_model_sql_validation: bool = False,
     external_sql_reference_resolver: ExternalSqlReferenceResolver | None = None,
 ) -> tuple[CompileModelInput, ...]:
     """Attach schema metadata to discovered model files."""
@@ -191,14 +192,15 @@ def build_model_inputs(
             if isinstance(raw_placeholders, dict)
             else None
         )
-        if (
+        sql_validation_enabled: bool = (
             effective_settings.sqlglot
             and not no_sql_validation
             and _is_sql_validation_enabled(
                 project_setting=effective_settings.sql_validation,
                 model_config=effective_config,
             )
-        ):
+        )
+        if sql_validation_enabled and not defer_model_sql_validation:
             validate_sql_syntax(
                 query_sql=expanded_query_sql,
                 model_name=model_file.file_path.stem,
@@ -310,6 +312,7 @@ def build_model_inputs(
                     query_sql=expanded_query_sql,
                     macro_source_sql=var_substituted_sql,
                     references=references,
+                    sql_validation_enabled=sql_validation_enabled,
                 )
             )
             continue
@@ -322,6 +325,7 @@ def build_model_inputs(
                 macro_source_sql=var_substituted_sql,
                 references=references,
                 schema_entry=header_schema_entry,
+                sql_validation_enabled=sql_validation_enabled,
             )
         )
 

{sqlbuild-0.30.0 → sqlbuild-0.30.1}/src/sqlbuild/compiler/compile/helpers/deps.py

@@ -22,6 +22,10 @@ def model_build_deps(
 ) -> tuple[CompiledObjectKey, ...]:
     """Return build graph dependencies implied by model SQL references."""
 
+    if not references:
+        return ()
+    if len(references) == 1:
+        return (_reference_dep(reference=references[0], seed_names=seed_names),)
     return _dedupe_object_keys(
         _reference_dep(reference=reference, seed_names=seed_names) for reference in references
     )
@@ -34,6 +38,10 @@ def function_build_deps(
 ) -> tuple[CompiledObjectKey, ...]:
     """Return build graph dependencies implied by function SQL references."""
 
+    if not references:
+        return ()
+    if len(references) == 1:
+        return (_reference_dep(reference=references[0], seed_names=seed_names),)
     return _dedupe_object_keys(
         _reference_dep(reference=reference, seed_names=seed_names) for reference in references
     )
@@ -72,6 +80,14 @@ def audit_scope_deps(
 def sql_test_scope_deps(*, expected_model_names: tuple[str, ...]) -> tuple[CompiledObjectKey, ...]:
     """Return model targets that select a SQL-native unit test."""
 
+    if not expected_model_names:
+        return ()
+    if len(expected_model_names) == 1:
+        return (
+            CompiledObjectKey(
+                resource_type=CompiledResourceType.MODEL, name=expected_model_names[0]
+            ),
+        )
     return _dedupe_object_keys(
         CompiledObjectKey(resource_type=CompiledResourceType.MODEL, name=model_name)
         for model_name in expected_model_names

{sqlbuild-0.30.0 → sqlbuild-0.30.1}/src/sqlbuild/compiler/compile/helpers/macros.py

@@ -114,6 +114,9 @@ def expand_sql_macros(
 def find_macro_call_names(sql: str) -> tuple[str, ...]:
     """Return unique authored macro call names in encounter order."""
 
+    if "@" not in sql:
+        return ()
+
     names: list[str] = []
     seen: set[str] = set()
     cursor: int = 0

{sqlbuild-0.30.0 → sqlbuild-0.30.1}/src/sqlbuild/compiler/compile/helpers/refs.py

@@ -13,6 +13,17 @@ from sqlbuild.compiler.shared.helpers.sql_scanning import (
 from sqlbuild.shared.types import SqlReferenceKind
 
 _CONTEXT: str = "SQL reference"
+_REFERENCE_PREFIXES: tuple[tuple[str, SqlReferenceKind], ...] = (
+    ("__dbt_ref(", SqlReferenceKind.DBT_REF),
+    ("__table_fn(", SqlReferenceKind.TABLE_FUNCTION),
+    ("__source(", SqlReferenceKind.SOURCE),
+    ("__seed(", SqlReferenceKind.SEED),
+    ("__udf(", SqlReferenceKind.UDF),
+    ("__ref(", SqlReferenceKind.REF),
+)
+_REFERENCE_PREFIX_BY_KIND: dict[SqlReferenceKind, str] = {
+    ref_kind: prefix[:-1] for prefix, ref_kind in _REFERENCE_PREFIXES
+}
 
 
 def extract_sql_references(sql: str) -> tuple[CompileSqlReference, ...]:
@@ -22,6 +33,9 @@ def extract_sql_references(sql: str) -> tuple[CompileSqlReference, ...]:
     index: int = 0
     length: int = len(sql)
     while index < length:
+        index = _next_reference_scan_position(sql=sql, start=index)
+        if index >= length:
+            break
         if sql.startswith("--", index):
             index = skip_line_comment(sql=sql, start=index)
             continue
@@ -44,24 +58,27 @@ def extract_sql_references(sql: str) -> tuple[CompileSqlReference, ...]:
     return tuple(references)
 
 
+def _next_reference_scan_position(*, sql: str, start: int) -> int:
+    positions: list[int] = []
+    token: str
+    for token in ("__", "--", "/*", "'", '"', "`"):
+        position: int = sql.find(token, start)
+        if position >= 0:
+            positions.append(position)
+    return min(positions, default=len(sql))
+
+
 def _parse_reference_at(*, sql: str, start: int) -> tuple[CompileSqlReference, int] | None:
     ref_kind: SqlReferenceKind | None = None
-    if sql.startswith(f"{SqlReferenceKind.DBT_REF.function_name}(", start):
-        ref_kind = SqlReferenceKind.DBT_REF
-    elif sql.startswith(f"{SqlReferenceKind.SEED.function_name}(", start):
-        ref_kind = SqlReferenceKind.SEED
-    elif sql.startswith(f"{SqlReferenceKind.SOURCE.function_name}(", start):
-        ref_kind = SqlReferenceKind.SOURCE
-    elif sql.startswith(f"{SqlReferenceKind.UDF.function_name}(", start):
-        ref_kind = SqlReferenceKind.UDF
-    elif sql.startswith(f"{SqlReferenceKind.TABLE_FUNCTION.function_name}(", start):
-        ref_kind = SqlReferenceKind.TABLE_FUNCTION
-    elif sql.startswith(f"{SqlReferenceKind.REF.function_name}(", start):
-        ref_kind = SqlReferenceKind.REF
+    prefix: str
+    for prefix, candidate_kind in _REFERENCE_PREFIXES:
+        if sql.startswith(prefix, start):
+            ref_kind = candidate_kind
+            break
     if ref_kind is None:
         return None
 
-    open_paren_index: int = start + len(ref_prefix(ref_kind))
+    open_paren_index: int = start + len(_REFERENCE_PREFIX_BY_KIND[ref_kind])
     closing_paren_index: int = find_matching_paren(
         sql=sql, open_paren_index=open_paren_index, context=_CONTEXT
     )
@@ -96,7 +113,7 @@ def _parse_reference_at(*, sql: str, start: int) -> tuple[CompileSqlReference, i
 
 def ref_prefix(ref_kind: SqlReferenceKind | str) -> str:
     normalized_ref_kind: SqlReferenceKind = SqlReferenceKind(ref_kind)
-    return normalized_ref_kind.function_name
+    return _REFERENCE_PREFIX_BY_KIND[normalized_ref_kind]
 
 
 def _split_top_level_arguments(raw_arguments: str) -> tuple[str, ...]: