interlaced 2.8.2__tar.gz → 2.8.4__tar.gz

{interlaced-2.8.2/src/interlaced.egg-info → interlaced-2.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interlaced
-Version: 2.8.2
+Version: 2.8.4
 Summary: Python and SQL models in one DAG. Transformation, orchestration and durable streaming in one process, on DuckDB and Postgres.
 Author-email: Mark <mark@interlace.sh>
 License-Expression: MIT
@@ -110,12 +110,11 @@ pip install 'interlaced[service]'   # the CLI + daemon; core CLI only: pip insta
 # more extras: [adbc] postgres/redshift · [spark] · [polars] · [all]
 ```
 
-> **Platforms.** Developed on Linux; CI runs Linux only. Nothing in the codebase is
-> platform-specific — no `fork`, no signal handling, no POSIX-only calls, no shelling out — and
-> every dependency ships macOS and Windows wheels, so both are expected to work. But
-> **neither is tested**, so treat them as unverified rather than supported. If you run interlace
-> on macOS or Windows, please open an issue either way; that is the fastest route to changing
-> this paragraph.
+> **Platforms.** Developed on Linux. CI runs the full suite on Linux, and a macOS job runs
+> `interlace init` plus `apply` on the quickstart. Nothing in the codebase is platform-specific —
+> no `fork`, no signal handling, no POSIX-only calls, no shelling out — and every dependency
+> ships macOS and Windows wheels. Windows is still unverified. If you run interlace on Windows,
+> please open an issue either way; that is the fastest route to changing this paragraph.
 
 ## Sixty seconds
 

{interlaced-2.8.2 → interlaced-2.8.4}/README.md

@@ -42,12 +42,11 @@ pip install 'interlaced[service]'   # the CLI + daemon; core CLI only: pip insta
 # more extras: [adbc] postgres/redshift · [spark] · [polars] · [all]
 ```
 
-> **Platforms.** Developed on Linux; CI runs Linux only. Nothing in the codebase is
-> platform-specific — no `fork`, no signal handling, no POSIX-only calls, no shelling out — and
-> every dependency ships macOS and Windows wheels, so both are expected to work. But
-> **neither is tested**, so treat them as unverified rather than supported. If you run interlace
-> on macOS or Windows, please open an issue either way; that is the fastest route to changing
-> this paragraph.
+> **Platforms.** Developed on Linux. CI runs the full suite on Linux, and a macOS job runs
+> `interlace init` plus `apply` on the quickstart. Nothing in the codebase is platform-specific —
+> no `fork`, no signal handling, no POSIX-only calls, no shelling out — and every dependency
+> ships macOS and Windows wheels. Windows is still unverified. If you run interlace on Windows,
+> please open an issue either way; that is the fastest route to changing this paragraph.
 
 ## Sixty seconds
 

{interlaced-2.8.2 → interlaced-2.8.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "interlaced"
-version = "2.8.2"
+version = "2.8.4"
 description = "Python and SQL models in one DAG. Transformation, orchestration and durable streaming in one process, on DuckDB and Postgres."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -61,7 +61,8 @@ service = [
     "msgspec>=0.18,<1.0",  # the wire types (litestar serialises msgspec structs natively)
 ]
 # Remote engines via Arrow-native ADBC transfer. postgres (+ redshift, same wire)
-# are the tested transport; snowflake/bigquery are ALPHA (wired, not run live).
+# are the tested transport. snowflake and bigquery are ALPHA: snowflake has been
+# exercised against one account, outside CI; bigquery has not been run live.
 adbc = [
     "adbc-driver-manager>=1.2,<2.0",
     "adbc-driver-postgresql>=1.2,<2.0",
@@ -113,11 +114,11 @@ select = [
     "B",   # flake8-bugbear
     "C4",  # flake8-comprehensions
     "UP",  # pyupgrade
+    "C901",  # mccabe; existing hotspots are allow-listed with noqa
 ]
 ignore = [
     "E501",  # line too long (handled by formatter)
     "B008",  # function calls in argument defaults
-    "C901",  # too complex
 ]
 
 [tool.ruff.lint.per-file-ignores]
@@ -171,6 +172,7 @@ exclude_lines = [
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+pythonpath = ["tests"]
 python_files = ["test_*.py", "*_test.py"]
 python_classes = ["Test*"]
 python_functions = ["test_*"]

{interlaced-2.8.2 → interlaced-2.8.4}/src/interlace/checks/builtin.py

@@ -14,7 +14,6 @@ NULLs as pattern/range failures, which conflated the two).
 
 from __future__ import annotations
 
-import re
 from collections.abc import Callable
 from typing import Any, cast
 
@@ -24,10 +23,9 @@ from interlace.checks.spec import CheckSpec
 from interlace.exceptions import DefinitionError
 from interlace.ir.canonicalize import as_query
 from interlace.ir.relation import TableRef
+from interlace.state.interval import as_grain
 
 _FAILURES = "failures"
-_AGE_RE = re.compile(r"^\s*(\d+)\s*([smhdw])\s*$")
-_AGE_UNITS = {"s": "SECOND", "m": "MINUTE", "h": "HOUR", "d": "DAY", "w": "WEEK"}
 
 ResolveTable = Callable[[str], TableRef]
 """Maps an upstream model name to its physical table (for ``relationships``)."""
@@ -59,11 +57,24 @@ def _parse_expr(sql: str, dialect: str) -> exp.Expr:
     return parse_one(sql, read=dialect)
 
 
+def sql_interval(amount: int, unit: str) -> exp.Interval:
+    """``amount`` of a SQL unit (``HOUR``, ``DAY``, …) as an interval expression."""
+    return exp.Interval(this=exp.Literal.string(str(amount)), unit=exp.Var(this=unit))
+
+
+def max_is_stale(column: exp.Expr, interval: exp.Expr) -> exp.Expr:
+    """``max(column)`` is null or older than ``interval``. An empty table counts."""
+    newest = exp.Max(this=column)
+    threshold = exp.Sub(this=exp.CurrentTimestamp(), expression=interval)
+    return exp.or_(exp.LT(this=newest, expression=threshold), newest.copy().is_(exp.null()))
+
+
 def _interval(max_age: str) -> exp.Interval:
-    match = _AGE_RE.fullmatch(str(max_age))
-    if match is None:
-        raise DefinitionError(f"invalid max_age {max_age!r}; expected like '2h', '30m', '1d'")
-    return exp.Interval(this=exp.Literal.string(match.group(1)), unit=exp.Var(this=_AGE_UNITS[match.group(2)]))
+    try:
+        parsed = as_grain(str(max_age))
+    except ValueError as exc:
+        raise DefinitionError(f"invalid max_age {max_age!r}; expected like '2h', '30m', '1d'") from exc
+    return sql_interval(parsed.amount, parsed.sql_unit)
 
 
 def _row_predicate(spec: CheckSpec, model: str, dialect: str, resolve: ResolveTable) -> exp.Expr | None:
@@ -147,10 +158,7 @@ def build_check_query(spec: CheckSpec, table: TableRef, model: str, dialect: str
 
     if spec.type == "freshness":
         _require(spec, model, columns=1, params=("max_age",))
-        threshold = exp.Sub(this=exp.CurrentTimestamp(), expression=_interval(str(params["max_age"])))
-        newest = exp.Max(this=cols[0])
-        stale = exp.or_(exp.LT(this=newest, expression=threshold), newest.copy().is_(exp.null()))  # no rows = stale
-        return _flag(table, stale)
+        return _flag(table, max_is_stale(cols[0], _interval(str(params["max_age"]))))
 
     if spec.type == "sql":
         _require(spec, model, params=("query",))

{interlaced-2.8.2 → interlaced-2.8.4}/src/interlace/cli/build.py

@@ -311,7 +311,7 @@ async def _table_diff(
         engines.close()
 
 
-async def _apply(
+async def _apply(  # noqa: C901
     environment: str,
     path: Path,
     select: list[str],
@@ -420,7 +420,7 @@ def restate(
     asyncio.run(_execute(environment, path, select, start, end, restate=True, parallelism=parallelism))
 
 
-async def _execute(
+async def _execute(  # noqa: C901
     environment: str,
     path: Path,
     select: list[str],

{interlaced-2.8.2 → interlaced-2.8.4}/src/interlace/cli/operate.py

@@ -170,7 +170,14 @@ async def _scheduler(environment: str, path: Path, interval: float, once: bool)
     """Same loops as ``interlace serve``: reload, tick, trim, drain, flush, CDC."""
     from types import SimpleNamespace
 
-    from interlace.scheduler.daemon import cdc_loop, flush_once, flusher_loop, scheduler_loop, source_mtime
+    from interlace.scheduler.daemon import (
+        cdc_loop,
+        flush_once,
+        flusher_loop,
+        remember_runtime,
+        scheduler_loop,
+        source_mtime,
+    )
     from interlace.streaming.materializer import quarantine_stream, stream_consumers
 
     project = Project.load(path)
@@ -209,6 +216,7 @@ async def _scheduler(environment: str, path: Path, interval: float, once: bool)
         stream_consumer_map={name: sorted(stream_consumers(compiled, name)) for name in streams},
     )
     host.flushed_heads = dict(host.log_heads)
+    remember_runtime(host, project.config)
     flusher: asyncio.Task[None] | None = None
     cdc: asyncio.Task[None] | None = None
     try:
@@ -277,6 +285,11 @@ def serve(
         True, "--scheduler/--no-scheduler", help="Run the scheduler loop in this process (combined daemon)."
     ),
     interval: float = typer.Option(60.0, "--interval", help="Seconds between scheduler ticks."),
+    apply_on_start: bool = typer.Option(
+        True,
+        "--apply/--no-apply",
+        help="Apply the project once at startup. --no-apply serves the warehouse as it is.",
+    ),
     allow_open: bool = typer.Option(
         False,
         "--allow-open",
@@ -286,6 +299,7 @@ def serve(
     """Run the interlace daemon: HTTP API + scheduler in one process (requires the `service` extra).
 
     Use --no-scheduler for an API-only process (run `interlace scheduler` separately).
+    The project is applied once before the loops start; pass --no-apply to skip that.
     A `cdc:` block in the project config is read here: each Postgres slot appends into its stream.
     """
     try:
@@ -331,6 +345,7 @@ def serve(
         quack_token=token or None,
         scheduler=scheduler,
         scheduler_interval=interval,
+        apply_on_start=apply_on_start,
     )
     config = uvicorn.Config(
         app,

{interlaced-2.8.2 → interlaced-2.8.4}/src/interlace/cli/support.py

@@ -243,7 +243,7 @@ def _window(value: str, flag: str) -> datetime | None:
         raise typer.Exit(2) from exc
 
 
-def _render(plan: Plan, environment: str) -> None:
+def _render(plan: Plan, environment: str) -> None:  # noqa: C901
     if not plan.changes and not plan.physical and not plan.transfers and not plan.drift and not plan.warnings:
         console.print(f"No changes for [bold]{environment}[/bold].")
         return

{interlaced-2.8.2 → interlaced-2.8.4}/src/interlace/config/config.py

@@ -13,6 +13,7 @@ left literal so a missing one surfaces as an obvious ``${VAR}`` in errors.
 
 from __future__ import annotations
 
+import datetime
 import os
 import re
 from pathlib import Path
@@ -143,6 +144,9 @@ class InputConfig(BaseModel):
     format: Literal["parquet", "csv", "json", "delta", "iceberg"]
     path: str
     connection: str | None = None  # http connection or an engine secret, for remote paths
+    # Hash the local file bytes into every model that reads this input, so an edit
+    # is a plan change. ``schedule: {watch:}`` only re-runs; it does not do this.
+    watch: bool = False
 
     @model_validator(mode="after")
     def _env_resolved(self) -> InputConfig:
@@ -154,8 +158,9 @@ class EngineConfig(BaseModel):
     """One named execution engine (warehouse gateway).
 
     DuckDB-family types (``duckdb`` / ``ducklake`` / ``quack``) and ``postgres`` are
-    the tested set. ``spark`` is beta; ``motherduck`` / ``redshift`` / ``snowflake`` /
-    ``bigquery`` are alpha (wired and dialect-correct, not yet live-validated).
+    the tested set. ``spark`` is beta. ``snowflake`` is alpha and has been exercised
+    against one account (not in CI). ``motherduck`` / ``redshift`` / ``bigquery`` are
+    alpha (wired and dialect-correct, not yet live-validated).
     """
 
     type: str = "duckdb"
@@ -181,6 +186,60 @@ class EngineConfig(BaseModel):
         return _TYPE_DIALECT.get(self.type, "duckdb")
 
 
+class VarConfig(BaseModel):
+    """A typed value a SQL model reads with ``var('name')``.
+
+    The call is replaced in the AST before fingerprinting, so editing ``value``
+    rebuilds every model that references the name. ``${VAR}`` in the YAML is
+    already expanded by the time this is parsed.
+    """
+
+    type: Literal["string", "int", "float", "bool", "date", "timestamp"]
+    value: str | int | float | bool
+
+    @model_validator(mode="after")
+    def _value_matches_type(self) -> VarConfig:
+        kind = self.type
+        value = self.value
+        if kind == "string":
+            if not isinstance(value, str):
+                raise ValueError("string var value must be a string")
+        elif kind == "int":
+            if type(value) is not int:
+                raise ValueError("int var value must be an integer")
+        elif kind == "float":
+            if type(value) not in (int, float):
+                raise ValueError("float var value must be a number")
+        elif kind == "bool":
+            if type(value) is not bool:
+                raise ValueError("bool var value must be true or false")
+        elif kind == "date":
+            self.value = _as_date(value)
+        else:
+            self.value = _as_timestamp(value)
+        return self
+
+
+def _as_date(value: object) -> str:
+    if isinstance(value, str):
+        try:
+            datetime.date.fromisoformat(value)
+        except ValueError as exc:
+            raise ValueError(f"date var value must be YYYY-MM-DD, got {value!r}") from exc
+        return value
+    raise ValueError("date var value must be a YYYY-MM-DD string")
+
+
+def _as_timestamp(value: object) -> str:
+    if isinstance(value, str):
+        try:
+            datetime.datetime.fromisoformat(value)
+        except ValueError as exc:
+            raise ValueError(f"timestamp var value must be ISO-8601, got {value!r}") from exc
+        return value
+    raise ValueError("timestamp var value must be an ISO-8601 string")
+
+
 class ProjectConfig(BaseModel):
     """Top-level project settings."""
 
@@ -234,10 +293,20 @@ class ProjectConfig(BaseModel):
     connections: dict[str, ConnectionConfig] = Field(default_factory=dict)
     # External files DuckDB scans as relations models can FROM. Other engines reject them.
     inputs: dict[str, InputConfig] = Field(default_factory=dict)
+    # Typed literals SQL models read with var('name'). Expanded into the AST at
+    # compile time, so a changed value is a plan change for the models that use it.
+    vars: dict[str, VarConfig] = Field(default_factory=dict)
     # Postgres logical replication into a declared @stream. Empty means the daemon
     # does not open a replication connection.
     cdc: dict[str, CdcConfig] = Field(default_factory=dict)
 
+    @model_validator(mode="after")
+    def _var_names_are_identifiers(self) -> ProjectConfig:
+        for name in self.vars:
+            if not _ENV_KEY.fullmatch(name):
+                raise ValueError(f"var {name!r} must be an identifier")
+        return self
+
     @model_validator(mode="after")
     def _cdc_uses_postgres(self) -> ProjectConfig:
         for name, source in self.cdc.items():

{interlaced-2.8.2 → interlaced-2.8.4}/src/interlace/dsl/decorators.py

@@ -9,7 +9,7 @@ Compilation, planning, and execution happen later over the registry. UK spelling
 from __future__ import annotations
 
 import re
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from contextvars import ContextVar
 from dataclasses import dataclass, field
 from typing import Any
@@ -30,6 +30,28 @@ from interlace.strategies import named_strategy
 
 ModelFn = Callable[..., Any]
 
+
+def normalize_schedule(schedule: Mapping[str, Any] | None, *, model: str) -> dict[str, str] | None:
+    """Schedules are string values. ``fresh: {column, within}`` becomes ``"column within"``."""
+    if not schedule:
+        return None
+    normalised: dict[str, str] = {}
+    for key, value in schedule.items():
+        if key == "fresh" and isinstance(value, dict):
+            column = value.get("column")
+            window = value.get("within")
+            if not isinstance(column, str) or not column.strip():
+                raise DefinitionError(f"model {model!r}: fresh.column must name a timestamp column")
+            if not isinstance(window, str) or not window.strip():
+                raise DefinitionError(f"model {model!r}: fresh.within must be a window like '2h'")
+            normalised[key] = f"{column.strip()} {window.strip()}"
+            continue
+        if not isinstance(value, str):
+            raise DefinitionError(f"model {model!r}: schedule {key!r} must be a string")
+        normalised[key] = value
+    return normalised
+
+
 # Set while a Python model function is running. Registrations then replace a
 # model this run already created, and are recorded for the apply that builds them.
 dynamic_owner: ContextVar[str | None] = ContextVar("interlace_dynamic_owner", default=None)
@@ -130,7 +152,9 @@ class ModelDef:
     path: str | None = None  # output path for materialise: file
     format: str | None = None  # csv | parquet | json for materialise: file
     environments: tuple[str, ...] = ("prod",)  # which environments actually deliver a terminal model
-    schedule: dict[str, str] | None = None  # cron, every, watch (glob), or webhook name
+    # cron, every, watch, on_change, fresh, or webhook. ``fresh`` may be the
+    # mapping ``{column, within}`` at construction; __post_init__ stores "column within".
+    schedule: dict[str, Any] | None = None
     checks: tuple[CheckSpec, ...] = ()  # data-quality checks; error severity gates promotion
     indexes: tuple[IndexSpec, ...] = ()  # physical indexes; not part of the data fingerprint
     constraints: tuple[ConstraintSpec, ...] = ()  # physical constraints; engine-enforced, not checks
@@ -151,6 +175,7 @@ class ModelDef:
         self.constraints = parse_constraints(self.constraints, self.name)
         self.schema_policy = parse_schema_policy(self.schema_policy, self.name)
         validate_physical_allowed(self.name, self.materialise, self.indexes, self.constraints, self.schema_policy)
+        self.schedule = normalize_schedule(self.schedule, model=self.name)
 
     @property
     def is_terminal(self) -> bool:
@@ -242,7 +267,7 @@ def model(
     owner: str | None = None,
     description: str | None = None,
     columns: dict[str, str | None] | Sequence[str] | None = None,
-    schedule: dict[str, str] | None = None,
+    schedule: dict[str, Any] | None = None,
     checks: Sequence[dict[str, Any] | CheckSpec] | None = None,
     indexes: Sequence[dict[str, Any] | IndexSpec] | None = None,
     constraints: Sequence[dict[str, Any] | ConstraintSpec] | None = None,

{interlaced-2.8.2 → interlaced-2.8.4}/src/interlace/dsl/dynamic.py

@@ -95,7 +95,7 @@ def render_model_sql(definition: ModelDef) -> str:
     return f"/*\n{header}\n*/\n{definition.sql.strip()}\n"
 
 
-def model_to_config(definition: ModelDef) -> dict[str, Any]:
+def model_to_config(definition: ModelDef) -> dict[str, Any]:  # noqa: C901
     """The ``interlace:`` mapping ``_sql_model`` reads. Defaults are omitted."""
     config: dict[str, Any] = {"name": definition.name}
     _keep(config, "materialise", definition.materialise, MATERIALISE_DEFAULT)

{interlaced-2.8.2 → interlaced-2.8.4}/src/interlace/engines/adbc.py

@@ -22,11 +22,11 @@ from typing import Any
 import pyarrow as pa
 from sqlglot import exp
 
-from interlace.engines.base import EngineAdapter, EngineCaps, LoadMode, note_statement
+from interlace.engines.base import EngineAdapter, EngineCaps, LoadMode, note_statement, relation_is_absent
 from interlace.ir.relation import TableRef
 
 
-def arrow_type_name(dtype: pa.DataType) -> str:
+def arrow_type_name(dtype: pa.DataType) -> str:  # noqa: C901
     """A canonical SQL type name for an Arrow type, in the vocabulary the planner's
     alignment/widening logic understands (see ``plan.apply``)."""
     if pa.types.is_boolean(dtype):
@@ -162,6 +162,8 @@ class AdbcAdapter(EngineAdapter):
         with self._lock:
             try:
                 schema = self._conn.adbc_get_table_schema(table.name, db_schema_filter=table.schema)
-            except Exception:  # driver raises when the table is absent -> treat as "no columns"
-                return {}
+            except Exception as exc:
+                if relation_is_absent(exc):
+                    return {}
+                raise
         return {field.name: arrow_type_name(field.type) for field in schema}

{interlaced-2.8.2 → interlaced-2.8.4}/src/interlace/engines/base.py

@@ -42,6 +42,19 @@ def note_statement(exc: BaseException, sql: str) -> None:
         return
 
 
+def relation_is_absent(exc: BaseException) -> bool:
+    """Whether ``exc`` means the relation is missing, not that the probe itself failed.
+
+    Catalog helpers treat a missing table as an empty description. Any other
+    error has to surface: swallowing it makes a broken catalog look like no columns.
+    """
+    message = str(exc).casefold()
+    if "table function" in message:
+        return False
+    markers = ("does not exist", "doesn't exist", "not found", "no such table", "undefined table", "unknown table")
+    return any(marker in message for marker in markers)
+
+
 def statement_of(exc: BaseException) -> str | None:
     """The SQL attached to ``exc`` or to the error it was raised from."""
     seen: set[int] = set()
@@ -163,7 +176,9 @@ class EngineAdapter(ABC):
 
     def transpile(self, ast: exp.Expr) -> str:
         """Canonical AST -> this engine's SQL. The one place dialect leaks back in."""
-        return ast.sql(dialect=self.dialect)
+        from interlace.ir.dialect import render_sql
+
+        return render_sql(ast, self.dialect)
 
     def refresh_inputs(self) -> None:
         """Re-expand input views whose paths contain date tokens.
@@ -178,3 +193,7 @@ class EngineAdapter(ABC):
     def attach(self, alias: str, uri: str) -> None:
         """ATTACH another database under ``alias``. Only engines with ``supports_attach``."""
         raise NotImplementedError(f"{type(self).__name__} cannot ATTACH another database")
+
+    @abstractmethod
+    def close(self) -> None:
+        """Release the connection this adapter holds."""

{interlaced-2.8.2 → interlaced-2.8.4}/src/interlace/engines/duckdb.py

@@ -39,7 +39,7 @@ import pyarrow as pa
 import tenacity
 from sqlglot import exp
 
-from interlace.engines.base import EngineAdapter, EngineCaps, LoadMode, note_statement
+from interlace.engines.base import EngineAdapter, EngineCaps, LoadMode, note_statement, relation_is_absent
 from interlace.exceptions import ConfigurationError
 from interlace.ir.relation import TableRef
 
@@ -307,8 +307,10 @@ class DuckDBAdapter(EngineAdapter):
         )
         try:
             reader = await self.fetch_sql(sql)
-        except Exception:
-            return []
+        except Exception as exc:
+            if relation_is_absent(exc):
+                return []
+            raise
         return [str(row[column]) for row in reader.read_all().to_pylist() if row.get(column)]
 
     # --- sync workers (run in a thread) -------------------------------------

{interlaced-2.8.2 → interlaced-2.8.4}/src/interlace/engines/postgres.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 from sqlglot import exp
 
 from interlace.engines.adbc import AdbcAdapter
-from interlace.engines.base import EngineCaps
+from interlace.engines.base import EngineCaps, relation_is_absent
 from interlace.exceptions import ConfigurationError
 from interlace.ir.relation import TableRef
 
@@ -83,8 +83,10 @@ class PostgresAdapter(AdbcAdapter):
             reader = await self.fetch_sql(
                 f"SELECT indexname FROM pg_indexes WHERE schemaname = {schema} AND tablename = {name}"
             )
-        except Exception:
-            return []
+        except Exception as exc:
+            if relation_is_absent(exc):
+                return []
+            raise
         return [str(row["indexname"]) for row in reader.read_all().to_pylist() if row.get("indexname")]
 
     async def list_constraints(self, table: TableRef) -> list[str]:
@@ -97,6 +99,8 @@ class PostgresAdapter(AdbcAdapter):
                 "JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace "
                 f"WHERE nsp.nspname = {schema} AND rel.relname = {name}"
             )
-        except Exception:
-            return []
+        except Exception as exc:
+            if relation_is_absent(exc):
+                return []
+            raise
         return [str(row["name"]) for row in reader.read_all().to_pylist() if row.get("name")]

{interlaced-2.8.2 → interlaced-2.8.4}/src/interlace/engines/registry.py

@@ -33,6 +33,7 @@ class EngineRegistry(Mapping[str, EngineAdapter]):
         *,
         default: str = "default",
         attach_uris: Mapping[str, str] | None = None,
+        sinks: Mapping[str, str] | None = None,
     ) -> None:
         self._names = frozenset(names)
         self._opener = opener
@@ -41,6 +42,9 @@ class EngineRegistry(Mapping[str, EngineAdapter]):
         # engine name -> URI another DuckDB-family engine could ATTACH (transfer
         # fast lane); absent/None = only reachable through its own adapter.
         self.attach_uris: dict[str, str] = dict(attach_uris or {})
+        # reverse-ETL alias -> database URI. A DuckDB warehouse ATTACHes these.
+        # An engine that cannot ATTACH opens the URI and writes the delivery there.
+        self.sinks: dict[str, str] = dict(sinks or {})
         if default not in self._names:
             raise ConfigurationError(
                 f"default_engine {default!r} is not a configured engine",

interlaced-2.8.4/src/interlace/engines/snowflake.py

@@ -0,0 +1,89 @@
+"""Snowflake engine adapter (ALPHA — exercised against one account, not in CI).
+
+An ADBC-transport engine: it inherits all of :class:`~interlace.engines.adbc.AdbcAdapter`
+(execute / fetch → Arrow / ``adbc_ingest`` bulk load / metadata ``describe``) and
+only sets the dialect and capabilities. Snowflake supports the full strategy set:
+``CREATE OR REPLACE TABLE``, ``SELECT * EXCLUDE`` (so scd works with ``SELECT *``),
+and a native ``MERGE``.
+
+Snowflake folds unquoted identifiers to uppercase and returns those names. Fetch
+and describe fold them back, so contracts and Python models keep the names the
+SQL was written with. ``adbc_ingest`` on this driver rejects a target schema, so
+loads ``USE SCHEMA`` first.
+
+Requires the ``adbc-snowflake`` extra. The connection string is the Snowflake ADBC
+URI (``user[:password]@account/database/schema?warehouse=WH&role=R``); key-pair and
+external-browser auth go through ``db_kwargs``.
+"""
+
+from __future__ import annotations
+
+import pyarrow as pa
+from sqlglot import exp
+
+from interlace.engines.adbc import AdbcAdapter
+from interlace.engines.base import EngineCaps, LoadMode
+from interlace.exceptions import ConfigurationError
+from interlace.ir.relation import TableRef
+
+_SNOWFLAKE_CAPS = EngineCaps(
+    supports_create_or_replace=True,
+    supports_star_exclude=True,  # SELECT * EXCLUDE (...)
+    supports_merge=True,
+    supports_transactions=True,
+    # PRIMARY KEY / UNIQUE / FOREIGN KEY are informational. NOT NULL is enforced.
+    enforced_constraints=frozenset({"not_null"}),
+)
+
+
+class SnowflakeAdapter(AdbcAdapter):
+    """Executes canonical ASTs inside Snowflake; Arrow in and out via ADBC."""
+
+    dialect = "snowflake"
+    caps = _SNOWFLAKE_CAPS
+
+    @classmethod
+    def connect(cls, dsn: str) -> SnowflakeAdapter:
+        try:
+            import adbc_driver_snowflake.dbapi as dbapi
+        except ImportError as exc:  # pragma: no cover - import guard
+            raise ConfigurationError(
+                "the snowflake engine needs the 'adbc-snowflake' extra: pip install 'interlaced[adbc-snowflake]'"
+            ) from exc
+        return cls(dbapi.connect(dsn))
+
+    def _fetch_sync(self, sql: str) -> pa.RecordBatchReader:
+        table = super()._fetch_sync(sql).read_all()
+        return table.rename_columns([name.casefold() for name in table.column_names]).to_reader()
+
+    def _describe_sync(self, table: TableRef) -> dict[str, str]:
+        # The driver quotes the name it is given. Unquoted SQL folds to uppercase,
+        # so a lowercase lookup looks for a different table and comes back empty.
+        folded = TableRef(
+            schema=table.schema.upper(),
+            name=table.name.upper(),
+            catalog=table.catalog.upper() if table.catalog else None,
+        )
+        described = super()._describe_sync(folded)
+        return {name.casefold(): kind for name, kind in described.items()}
+
+    def _load_sync(self, table: TableRef, reader: pa.RecordBatchReader, mode: LoadMode) -> int:
+        # This driver rejects adbc.ingest.target_db_schema. The session schema is
+        # the ingest target; unquoted names fold the same way the model's SQL does.
+        ingest_mode = "replace" if mode == "create" else "append"
+        schema = exp.to_identifier(table.schema).sql(dialect=self.dialect) if table.schema else ""
+        # Arrow names are the SQL as written (lowercase). The driver quotes them,
+        # so they must be the uppercase form unquoted SQL folds to.
+        loaded_table = reader.read_all()
+        batch = loaded_table.rename_columns([name.upper() for name in loaded_table.column_names])
+        with self._lock:
+            try:
+                with self._conn.cursor() as cur:
+                    if schema:
+                        cur.execute(f"USE SCHEMA {schema}")
+                    loaded = cur.adbc_ingest(table.name.upper(), batch, mode=ingest_mode)
+                self._conn.commit()
+            except Exception:
+                self._conn.rollback()
+                raise
+        return int(loaded) if isinstance(loaded, int) and loaded > 0 else 0