sqlbuild 0.18.0__tar.gz → 0.19.0__tar.gz

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

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

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.19.0](https://github.com/chio-labs/sqlbuild/compare/v0.18.0...v0.19.0) (2026-05-24)
+
+
+### Features
+
+* add ingestr integration loaders ([d824860](https://github.com/chio-labs/sqlbuild/commit/d824860cb186b9a069e42c629b3680180fdd0552))
+* formalize adapter identity ([3977fad](https://github.com/chio-labs/sqlbuild/commit/3977fad13c39ab93c7d5dacda2c1074b1a5b62c5))
+
+
+### Bug Fixes
+
+* run external loaders before warehouse connections ([b4427a4](https://github.com/chio-labs/sqlbuild/commit/b4427a4188f772b71011197ab87d25de52bdf932))
+
 ## [0.18.0](https://github.com/chio-labs/sqlbuild/compare/v0.17.0...v0.18.0) (2026-05-23)
 
 

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.18.0
+Version: 0.19.0
 Summary: Typed, test-first SQL pipelines with local E2E testing
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -14,6 +14,8 @@ Requires-Dist: dagster-webserver>=1.13.0; extra == 'dagster'
 Requires-Dist: dagster>=1.13.0; extra == 'dagster'
 Provides-Extra: databricks
 Requires-Dist: databricks-sql-connector[pyarrow]>=4.1.2; extra == 'databricks'
+Provides-Extra: ingestr
+Requires-Dist: ingestr>=1.0.0; extra == 'ingestr'
 Provides-Extra: performance
 Requires-Dist: sqlglot[c]>=30.7.0; extra == 'performance'
 Provides-Extra: postgres

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlbuild"
-version = "0.18.0"
+version = "0.19.0"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -40,6 +40,9 @@ postgres = [
 sqlserver = [
   "pymssql>=2.3.0",
 ]
+ingestr = [
+  "ingestr>=1.0.0",
+]
 
 [project.scripts]
 sqb = "sqlbuild.cli.commands.main.entry:main"
@@ -53,6 +56,7 @@ dev = [
   "commitizen>=4.9.1",
   "dbt-core>=1.9.0,<1.11",
   "dbt-duckdb>=1.9.0,<1.11",
+  "ingestr>=1.0.0",
   "jsonschema>=4.23.0",
   "pre-commit>=4.3.0",
   "pytest>=8.4.2",

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/src/sqlbuild/adapter/base/base_adapter.py

@@ -42,6 +42,7 @@ class BaseAdapter(StrictAdapter):
     Override only the methods your engine requires.
     """
 
+    adapter_name: ClassVar[str]
     sqlglot_dialect_name: ClassVar[str | None] = None
     max_identifier_length: ClassVar[int] = 63
 

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/src/sqlbuild/adapter/shared/helpers/builtins.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from sqlbuild.adapter.base.base_adapter import BaseAdapter
-from sqlbuild.adapter.shared.types import BuiltinAdapter
 
 
 def builtin_adapter_classes() -> dict[str, type[BaseAdapter]]:
@@ -17,12 +16,13 @@ def builtin_adapter_classes() -> dict[str, type[BaseAdapter]]:
     from sqlbuild.integrations.snowflake.client import SnowflakeAdapter
     from sqlbuild.integrations.sqlserver.client import SqlServerAdapter
 
-    return {
-        BuiltinAdapter.DUCKDB.value: DuckDbAdapter,
-        BuiltinAdapter.MOTHERDUCK.value: MotherDuckAdapter,
-        BuiltinAdapter.SNOWFLAKE.value: SnowflakeAdapter,
-        BuiltinAdapter.BIGQUERY.value: BigQueryAdapter,
-        BuiltinAdapter.DATABRICKS.value: DatabricksAdapter,
-        BuiltinAdapter.POSTGRES.value: PostgresAdapter,
-        BuiltinAdapter.SQLSERVER.value: SqlServerAdapter,
-    }
+    adapters: tuple[type[BaseAdapter], ...] = (
+        DuckDbAdapter,
+        MotherDuckAdapter,
+        SnowflakeAdapter,
+        BigQueryAdapter,
+        DatabricksAdapter,
+        PostgresAdapter,
+        SqlServerAdapter,
+    )
+    return {adapter.adapter_name: adapter for adapter in adapters}

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/src/sqlbuild/adapter/strict/strict_adapter.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from abc import abstractmethod
 from decimal import Decimal
-from typing import Any
+from typing import Any, ClassVar
 
 from sqlbuild.adapter.shared.classes.connection import ConnectionMixin
 from sqlbuild.adapter.shared.classes.diff import DiffMixin
@@ -40,6 +40,8 @@ class StrictAdapter(
     transaction, supports_transactions) are inherited but may be overridden.
     """
 
+    adapter_name: ClassVar[str]
+
     @abstractmethod
     def supports_zero_copy_clone(self) -> bool:
         """Return whether clone operations can use zero-copy semantics."""

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/src/sqlbuild/cli/commands/main/build.py

@@ -96,12 +96,6 @@ def run_build(
         stream=progress_stream,
         use_color=use_color,
     )
-    execution_connection_progress: ConnectionProgressReporter = ConnectionProgressReporter(
-        adapter_name=adapter_name,
-        stream=progress_stream,
-        blank_line_after_complete=True,
-        use_color=use_color,
-    )
     planning_progress: PlanningProgressReporter = PlanningProgressReporter(
         stream=progress_stream,
         use_color=use_color,
@@ -173,6 +167,17 @@ def run_build(
     progress_stream.write(f"{execution_label}  {header_detail}\n\n")
     progress_stream.flush()
 
+    has_external_source_loads: bool = any(
+        entry.integration_kind is not None for entry in plan_output.source_load_entries
+    )
+    execution_connection_progress: ConnectionProgressReporter = ConnectionProgressReporter(
+        adapter_name=adapter_name,
+        stream=progress_stream,
+        blank_line_before_start=has_external_source_loads,
+        blank_line_after_complete=True,
+        use_color=use_color,
+    )
+
     result: BuildExecutionResult = run_build_pipeline(
         plan=plan_output,
         connection_config=connection_config,
@@ -198,6 +203,7 @@ def run_build(
         on_connection_start=execution_connection_progress.on_connection_start,
         on_connection_complete=execution_connection_progress.on_connection_complete,
         on_connection_error=execution_connection_progress.on_connection_error,
+        use_color=use_color,
     )
     write_runtime_target(
         target_dir=effective_project_dir / "target",

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/src/sqlbuild/cli/commands/main/helpers/dbt_sqlbuild_work.py

@@ -84,6 +84,7 @@ def execute_sqlbuild_build_work(
         on_connection_start=execution_connection_progress.on_connection_start,
         on_connection_complete=execution_connection_progress.on_connection_complete,
         on_connection_error=execution_connection_progress.on_connection_error,
+        use_color=use_color,
     )
     write_runtime_target(target_dir=project_dir / "target", plan_output=plan_output, result=result)
     footer: str = format_build_footer(result=result, elapsed=callbacks.elapsed, use_color=use_color)

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/src/sqlbuild/cli/commands/main/helpers/plan/formatter.py

@@ -347,9 +347,7 @@ def _format_load_entry_group(
 
 
 def _source_load_label(entry: SourceLoadPlanEntry) -> str:
-    strategy: str = (
-        entry.write_strategy.value if entry.write_strategy is not None else "self-managed"
-    )
+    strategy: str = _source_load_strategy_label(entry)
     details: list[str] = []
     if entry.cursor_column is not None:
         details.append(f"cursor: {entry.cursor_column}")
@@ -361,6 +359,14 @@ def _source_load_label(entry: SourceLoadPlanEntry) -> str:
     return f"{strategy} ({'; '.join(details)})"
 
 
+def _source_load_strategy_label(entry: SourceLoadPlanEntry) -> str:
+    if entry.integration_kind is not None:
+        return f"external ({entry.integration_kind})"
+    if entry.write_strategy is not None:
+        return entry.write_strategy.value
+    return "self-managed"
+
+
 def _collect_normal(entries: list[ModelPlanEntry]) -> list[ModelPlanEntry]:
     """Collect entries that belong in the Normal aggregate section."""
 

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/src/sqlbuild/cli/commands/main/load.py

@@ -9,6 +9,8 @@ from pathlib import Path
 from typing import TextIO
 
 from sqlbuild.adapter.base.base_adapter import BaseAdapter
+from sqlbuild.adapter.shared.models import LifeCycleEvent
+from sqlbuild.adapter.shared.types import LifeCycleEventKind
 from sqlbuild.cli.commands.main.helpers.load_selection import select_load_entries
 from sqlbuild.cli.commands.main.shared.helpers.adapters import resolve_adapter
 from sqlbuild.cli.commands.main.shared.helpers.connection import resolve_project_connection_config
@@ -172,6 +174,7 @@ def run_load(
         on_connection_start=connection_progress.on_connection_start,
         on_connection_complete=connection_progress.on_connection_complete,
         on_connection_error=connection_progress.on_connection_error,
+        use_color=use_color,
     )
     elapsed: float = time.monotonic() - start
     success_count: int = sum(1 for result in results if result.status.value == "success")
@@ -219,6 +222,14 @@ def _build_on_complete(
             f"  {ordinal}/{total_count}  {result.resource_kind.value:<10}"
             f"{result.source_name:<30} {status:<6} {duration}  {rows_loaded}\n"
         )
+        event: LifeCycleEvent
+        for event in result.lifecycle_events:
+            if event.kind == LifeCycleEventKind.LOG:
+                lines: list[str] = event.content.splitlines() or [""]
+                stream.write(f"    log  {lines[0]}\n")
+                line: str
+                for line in lines[1:]:
+                    stream.write(f"         {line}\n")
         if result.error_message is not None:
             stream.write(f"    {result.error_message}\n")
         stream.flush()

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/src/sqlbuild/cli/commands/main/run.py

@@ -96,12 +96,6 @@ def run_run(
         stream=progress_stream,
         use_color=use_color,
     )
-    execution_connection_progress: ConnectionProgressReporter = ConnectionProgressReporter(
-        adapter_name=adapter_name,
-        stream=progress_stream,
-        blank_line_after_complete=True,
-        use_color=use_color,
-    )
     planning_progress: PlanningProgressReporter = PlanningProgressReporter(
         stream=progress_stream,
         use_color=use_color,
@@ -173,6 +167,17 @@ def run_run(
     progress_stream.write(f"{execution_label}  {header_detail}\n\n")
     progress_stream.flush()
 
+    has_external_source_loads: bool = any(
+        entry.integration_kind is not None for entry in plan_output.source_load_entries
+    )
+    execution_connection_progress: ConnectionProgressReporter = ConnectionProgressReporter(
+        adapter_name=adapter_name,
+        stream=progress_stream,
+        blank_line_before_start=has_external_source_loads,
+        blank_line_after_complete=True,
+        use_color=use_color,
+    )
+
     result: BuildExecutionResult = run_build_pipeline(
         plan=plan_output,
         connection_config=connection_config,
@@ -198,6 +203,7 @@ def run_run(
         on_connection_start=execution_connection_progress.on_connection_start,
         on_connection_complete=execution_connection_progress.on_connection_complete,
         on_connection_error=execution_connection_progress.on_connection_error,
+        use_color=use_color,
     )
     write_runtime_target(
         target_dir=effective_project_dir / "target",

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/src/sqlbuild/cli/commands/main/shared/helpers/connection_progress.py

@@ -15,10 +15,13 @@ class ConnectionProgressReporter:
         *,
         adapter_name: str,
         stream: TextIO,
+        blank_line_before_start: bool = False,
         blank_line_after_complete: bool = False,
         use_color: bool = False,
     ) -> None:
         self._adapter_name: str = adapter_name
+        self._stream: TextIO = stream
+        self._blank_line_before_start: bool = blank_line_before_start
         self._blank_line_after_complete: bool = blank_line_after_complete
         self._status: TransientStatusReporter = TransientStatusReporter(
             stream=stream,
@@ -26,6 +29,9 @@ class ConnectionProgressReporter:
         )
 
     def on_connection_start(self, connection_count: int) -> None:
+        if self._blank_line_before_start:
+            self._stream.write("\n")
+            self._stream.flush()
         self._status.start(self._start_message(connection_count))
 
     def on_connection_complete(self, connection_count: int, elapsed_seconds: float) -> None:

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/src/sqlbuild/cli/commands/main/shared/helpers/progress.py

@@ -176,8 +176,16 @@ class BuildProgressCallbacks:
     def _write_log_block(self, message: str) -> None:
         """Write a log message with indent and muted styling."""
 
-        styled: str = blue_dim(f"    log  {message}") if self._use_color else f"    log  {message}"
-        self._stream.write(f"\n{styled}\n")
+        lines: list[str] = message.splitlines() or [""]
+        prefix: str = blue_dim("    log  ") if self._use_color else "    log  "
+        first_content: str = dim(lines[0]) if self._use_color else lines[0]
+        styled_first: str = f"{prefix}{first_content}"
+        self._stream.write(f"\n{styled_first}\n")
+        line: str
+        for line in lines[1:]:
+            continuation: str = f"         {line}"
+            styled_continuation: str = dim(continuation) if self._use_color else continuation
+            self._stream.write(f"{styled_continuation}\n")
 
     def on_node_start(self, name: str, resource_kind: ExecutionResourceKind) -> None:
         self._current_node_name = name
@@ -332,6 +340,12 @@ class BuildProgressCallbacks:
                 duration=duration,
                 detail=detail,
             )
+            event: LifeCycleEvent
+            for event in node_result.lifecycle_events:
+                if event.kind == LifeCycleEventKind.LOG:
+                    self._write_log_block(event.content)
+                elif self._verbose and event.kind == LifeCycleEventKind.SQL:
+                    self._write_sql_block(event.content)
             if node_result.status == ExecutionStatus.FAILED and node_result.error_message:
                 self._write_error_detail(
                     error_code=None,

sqlbuild-0.19.0/src/sqlbuild/compiler/compile/main/expand_template_data.py

@@ -0,0 +1,30 @@
+"""Public entrypoint for recursive template expansion."""
+
+from __future__ import annotations
+
+from sqlbuild.compiler.compile.helpers.templating import (
+    expand_template_data as _expand_template_data,
+)
+
+
+def expand_template_data(
+    value: object,
+    *,
+    variables: dict[str, object],
+    context_values: dict[str, str | None],
+    context_label: str,
+    allow_context: bool,
+    preserve_context_tokens: bool,
+    preserve_unknown_context: bool,
+) -> object:
+    """Recursively expand template strings inside supported Python container values."""
+
+    return _expand_template_data(
+        value,
+        variables=variables,
+        context_values=context_values,
+        context_label=context_label,
+        allow_context=allow_context,
+        preserve_context_tokens=preserve_context_tokens,
+        preserve_unknown_context=preserve_unknown_context,
+    )

sqlbuild-0.19.0/src/sqlbuild/compiler/discovery/helpers/integration_loaders.py

@@ -0,0 +1,138 @@
+"""Discovery helpers for declarative integration loaders."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import cast
+
+from sqlbuild.compiler.discovery.exceptions import SourceParseError
+from sqlbuild.compiler.discovery.helpers.yml_primitives import (
+    optional_non_empty_string,
+    require_non_empty_string,
+)
+from sqlbuild.compiler.discovery.models import DiscoveredLoaderFunction, DiscoveredSourceFile
+from sqlbuild.integrations.ingestr.models import IngestrSourceConfig
+from sqlbuild.spec.models.source import IntegrationLoaderConfig
+
+_ingestr_strategies: frozenset[str] = frozenset(
+    {"replace", "append", "merge", "delete+insert", "truncate+insert"}
+)
+
+
+def integration_loader_name(*, kind: str, source_name: str) -> str:
+    """Return the generated loader name for a declarative integration loader."""
+
+    return f"{kind}__{source_name}"
+
+
+def build_integration_loader_functions(
+    source_files: tuple[DiscoveredSourceFile, ...],
+) -> tuple[DiscoveredLoaderFunction, ...]:
+    """Build synthetic loader functions for declarative integration loaders."""
+
+    from sqlbuild.integrations.ingestr.main.loaders import build_ingestr_loader_functions
+
+    return build_ingestr_loader_functions(source_files)
+
+
+def parse_source_integration_loader(
+    *, entry: dict[str, object], file_path: Path
+) -> IntegrationLoaderConfig | None:
+    """Parse any source-level integration loader declaration."""
+
+    raw_ingestr: object | None = entry.get("ingestr")
+    if raw_ingestr is not None:
+        return IntegrationLoaderConfig(
+            kind="ingestr",
+            config=_parse_ingestr_source_config(raw_config=raw_ingestr, file_path=file_path),
+        )
+    return None
+
+
+def _parse_ingestr_source_config(*, raw_config: object, file_path: Path) -> IngestrSourceConfig:
+    if not isinstance(raw_config, dict):
+        raise SourceParseError(f"{file_path} source 'ingestr' must be a mapping")
+    config: dict[str, object] = cast(dict[str, object], raw_config)
+    parsed: IngestrSourceConfig = IngestrSourceConfig(
+        source_uri=require_non_empty_string(
+            entry=config,
+            key="source_uri",
+            file_path=file_path,
+            label="source ingestr",
+            error_class=SourceParseError,
+        ),
+        source_table=require_non_empty_string(
+            entry=config,
+            key="source_table",
+            file_path=file_path,
+            label="source ingestr",
+            error_class=SourceParseError,
+        ),
+        strategy=optional_non_empty_string(
+            entry=config,
+            key="strategy",
+            file_path=file_path,
+            label="source ingestr",
+            error_class=SourceParseError,
+        ),
+        incremental_key=optional_non_empty_string(
+            entry=config,
+            key="incremental_key",
+            file_path=file_path,
+            label="source ingestr",
+            error_class=SourceParseError,
+        ),
+        primary_key=_optional_ingestr_primary_key(entry=config, file_path=file_path),
+        columns=optional_non_empty_string(
+            entry=config,
+            key="columns",
+            file_path=file_path,
+            label="source ingestr",
+            error_class=SourceParseError,
+        ),
+        extra_args=_optional_ingestr_string_tuple(
+            entry=config, key="extra_args", file_path=file_path
+        ),
+    )
+    if parsed.strategy is not None and parsed.strategy not in _ingestr_strategies:
+        strategies: str = ", ".join(sorted(_ingestr_strategies))
+        raise SourceParseError(f"{file_path} source ingestr strategy must be one of: {strategies}")
+    return parsed
+
+
+def _optional_ingestr_primary_key(*, entry: dict[str, object], file_path: Path) -> tuple[str, ...]:
+    primary_key: tuple[str, ...] = _optional_ingestr_string_tuple(
+        entry=entry, key="primary_key", file_path=file_path
+    )
+    unique_key: tuple[str, ...] = _optional_ingestr_string_tuple(
+        entry=entry, key="unique_key", file_path=file_path
+    )
+    if primary_key and unique_key:
+        raise SourceParseError(
+            f"{file_path} source ingestr cannot define both primary_key and unique_key"
+        )
+    return primary_key or unique_key
+
+
+def _optional_ingestr_string_tuple(
+    *, entry: dict[str, object], key: str, file_path: Path
+) -> tuple[str, ...]:
+    value: object | None = entry.get(key)
+    if value is None:
+        return ()
+    if isinstance(value, str):
+        stripped: str = value.strip()
+        if not stripped:
+            raise SourceParseError(f"{file_path} source ingestr '{key}' must be non-empty")
+        return (stripped,)
+    if isinstance(value, list):
+        items: list[str] = []
+        item: object
+        for item in value:
+            if not isinstance(item, str) or not item.strip():
+                raise SourceParseError(
+                    f"{file_path} source ingestr '{key}' must contain only non-empty strings"
+                )
+            items.append(item.strip())
+        return tuple(items)
+    raise SourceParseError(f"{file_path} source ingestr '{key}' must be a string or list")

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/src/sqlbuild/compiler/discovery/helpers/yml_sources.py

@@ -9,6 +9,10 @@ import yaml
 from yaml import YAMLError
 
 from sqlbuild.compiler.discovery.exceptions import SourceParseError
+from sqlbuild.compiler.discovery.helpers.integration_loaders import (
+    integration_loader_name,
+    parse_source_integration_loader,
+)
 from sqlbuild.compiler.discovery.helpers.yml_primitives import (
     optional_bool,
     optional_mapping,
@@ -17,7 +21,7 @@ from sqlbuild.compiler.discovery.helpers.yml_primitives import (
     require_non_empty_string,
 )
 from sqlbuild.spec.models.schema import SchemaAuditInstance
-from sqlbuild.spec.models.source import SourceColumnEntry, SourceEntry
+from sqlbuild.spec.models.source import IntegrationLoaderConfig, SourceColumnEntry, SourceEntry
 from sqlbuild.spec.models.types import SourceWriteStrategy
 
 _SOURCE_WRITE_STRATEGIES: frozenset[str] = frozenset(
@@ -85,14 +89,32 @@ def _parse_source_entry(*, entry: dict[str, object], file_path: Path) -> SourceE
     if type_enforcement is None and any(column.type is not None for column in columns):
         type_enforcement = True
 
+    loader: str | None = optional_non_empty_string(
+        entry=entry,
+        key="loader",
+        file_path=file_path,
+        label="source",
+        error_class=SourceParseError,
+    )
+    source_name: str = require_non_empty_string(
+        entry=entry,
+        key="name",
+        file_path=file_path,
+        label="source",
+        error_class=SourceParseError,
+    )
+    integration_loader: IntegrationLoaderConfig | None = parse_source_integration_loader(
+        entry=entry, file_path=file_path
+    )
+    resolved_loader: str | None = loader
+    if resolved_loader is None and integration_loader is not None:
+        resolved_loader = integration_loader_name(
+            kind=integration_loader.kind,
+            source_name=source_name,
+        )
+
     source_entry: SourceEntry = SourceEntry(
-        name=require_non_empty_string(
-            entry=entry,
-            key="name",
-            file_path=file_path,
-            label="source",
-            error_class=SourceParseError,
-        ),
+        name=source_name,
         database=optional_non_empty_string(
             entry=entry,
             key="database",
@@ -114,13 +136,8 @@ def _parse_source_entry(*, entry: dict[str, object], file_path: Path) -> SourceE
             label="source",
             error_class=SourceParseError,
         ),
-        loader=optional_non_empty_string(
-            entry=entry,
-            key="loader",
-            file_path=file_path,
-            label="source",
-            error_class=SourceParseError,
-        ),
+        loader=resolved_loader,
+        integration_loader=integration_loader,
         write_strategy=_optional_write_strategy(entry=entry, file_path=file_path),
         load_batch_size=_optional_positive_int(
             entry=entry,
@@ -185,6 +202,20 @@ def _validate_source_entry(entry: SourceEntry, file_path: Path) -> None:
                 f"{file_path} source '{entry.name}' uses expression with type_enforcement "
                 "but has no typed columns"
             )
+    if entry.integration_loader is not None:
+        expected_loader_name: str = integration_loader_name(
+            kind=entry.integration_loader.kind, source_name=entry.name
+        )
+        if entry.loader != expected_loader_name:
+            raise SourceParseError(
+                f"{file_path} source '{entry.name}' cannot define both loader and "
+                f"{entry.integration_loader.kind}"
+            )
+        if entry.write_strategy is not None:
+            raise SourceParseError(
+                f"{file_path} source '{entry.name}' cannot define write_strategy with "
+                f"{entry.integration_loader.kind}"
+            )
     if entry.write_strategy is not None and entry.loader is None:
         raise SourceParseError(
             f"{file_path} source '{entry.name}' defines write_strategy but has no loader"

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/src/sqlbuild/compiler/discovery/main/discover.py

@@ -20,11 +20,18 @@ from sqlbuild.compiler.discovery.helpers.filesystem import (
     discover_sql_function_files,
     discover_test_files,
 )
+from sqlbuild.compiler.discovery.helpers.integration_loaders import (
+    build_integration_loader_functions,
+)
 from sqlbuild.compiler.discovery.helpers.yml_project import (
     load_local_config,
     load_project_config,
 )
-from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs
+from sqlbuild.compiler.discovery.models import (
+    DiscoveredLoaderFunction,
+    DiscoveredProjectInputs,
+    DiscoveredSourceFile,
+)
 from sqlbuild.spec.models.project import LocalConfig, ProjectConfig
 
 
@@ -39,6 +46,10 @@ def discover_project_inputs(*, project_dir: Path) -> DiscoveredProjectInputs:
         else project_config.settings.sqlglot
     )
 
+    source_files: tuple[DiscoveredSourceFile, ...] = discover_source_files(project_dir=project_dir)
+    loader_functions: tuple[DiscoveredLoaderFunction, ...] = discover_loader_functions(
+        project_dir=project_dir
+    ) + build_integration_loader_functions(source_files)
     discovered_inputs: DiscoveredProjectInputs = DiscoveredProjectInputs(
         project_config=project_config,
         local_config=local_config,
@@ -49,14 +60,14 @@ def discover_project_inputs(*, project_dir: Path) -> DiscoveredProjectInputs:
         sql_function_files=discover_sql_function_files(project_dir=project_dir),
         python_function_files=discover_python_function_files(project_dir=project_dir),
         schema_files=discover_schema_files(project_dir=project_dir),
-        source_files=discover_source_files(project_dir=project_dir),
+        source_files=source_files,
         seed_files=discover_seed_files(project_dir=project_dir),
         test_files=discover_test_files(project_dir=project_dir),
         scenario_files=discover_scenario_files(project_dir=project_dir),
         audit_files=discover_audit_files(project_dir=project_dir),
         macro_files=discover_macro_files(project_dir=project_dir),
         materialization_files=discover_materialization_files(project_dir=project_dir),
-        loader_functions=discover_loader_functions(project_dir=project_dir),
+        loader_functions=loader_functions,
         adapter_file=discover_adapter_file(project_dir=project_dir),
     )
     validate_discovered_inputs(discovered_inputs)

{sqlbuild-0.18.0 → sqlbuild-0.19.0}/src/sqlbuild/compiler/discovery/models.py

@@ -8,6 +8,7 @@ from pathlib import Path
 
 from sqlbuild.compiler.compile.constants import DEFAULT_SQL_TEST_MODE
 from sqlbuild.compiler.compile.types import SqlTestMode
+from sqlbuild.compiler.discovery.types import LoaderConnectionMode
 from sqlbuild.spec.models.project import LocalConfig, ProjectConfig
 from sqlbuild.spec.models.schema import SchemaModelEntry, SchemaSeedEntry, SourceLocation
 from sqlbuild.spec.models.source import SourceColumnEntry, SourceEntry
@@ -173,6 +174,7 @@ class DiscoveredLoaderFunction:
     unique_key: tuple[str, ...] = field(default_factory=tuple)
     columns: tuple[SourceColumnEntry, ...] = field(default_factory=tuple)
     contract: str | None = None
+    connection_mode: LoaderConnectionMode = LoaderConnectionMode.SQLBUILD
 
 
 @dataclass(frozen=True)