continuo-validation-trino 0.1.0__tar.gz

continuo_validation_trino-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+.venv/
+__pycache__/
+*.pyc
+dist/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage

continuo_validation_trino-0.1.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: continuo-validation-trino
+Version: 0.1.0
+Summary: Trino warehouse adapter for the continuo validation runner.
+Author: Simone Carolini
+Maintainer: Simone Carolini
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.14
+Requires-Dist: continuo-validation-contract==0.2.0
+Requires-Dist: trino==0.338.0
+Description-Content-Type: text/markdown
+
+# continuo-validation-trino
+
+Trino warehouse adapter for the [continuo](https://github.com/carolsimone/continuo)
+validation runner. Implements `continuo_validation_contract.port.WarehouseAdapter`;
+continuo's harness discovers it through the `continuo_validation.adapters` entry point.
+
+Trino's namespace is `catalog.schema`. The catalog comes from `TRINO_CATALOG` and every
+statement is fully qualified, so continuo passes a bare candidate schema name and never
+needs to know about catalogs.
+
+## Connection env
+
+| Env | Required | Default | Purpose |
+|---|---|---|---|
+| `TRINO_HOST` | yes | — | Coordinator host |
+| `TRINO_CATALOG` | yes | — | Catalog holding candidate schemas (e.g. `iceberg`) |
+| `TRINO_PORT` | no | `8080` | Coordinator port |
+| `TRINO_USER` | no | `continuo` | Trino user |
+| `TRINO_HTTP_SCHEME` | no | `http` | `http` or `https` |
+| `TRINO_PASSWORD` | no | unset | Basic auth; requires `TRINO_HTTP_SCHEME=https` |
+
+The catalog must be backed by a connector that supports schema and table creation
+(Iceberg and Hive do). The library is tested live against Iceberg (REST catalog + S3).

continuo_validation_trino-0.1.0/README.md

@@ -0,0 +1,23 @@
+# continuo-validation-trino
+
+Trino warehouse adapter for the [continuo](https://github.com/carolsimone/continuo)
+validation runner. Implements `continuo_validation_contract.port.WarehouseAdapter`;
+continuo's harness discovers it through the `continuo_validation.adapters` entry point.
+
+Trino's namespace is `catalog.schema`. The catalog comes from `TRINO_CATALOG` and every
+statement is fully qualified, so continuo passes a bare candidate schema name and never
+needs to know about catalogs.
+
+## Connection env
+
+| Env | Required | Default | Purpose |
+|---|---|---|---|
+| `TRINO_HOST` | yes | — | Coordinator host |
+| `TRINO_CATALOG` | yes | — | Catalog holding candidate schemas (e.g. `iceberg`) |
+| `TRINO_PORT` | no | `8080` | Coordinator port |
+| `TRINO_USER` | no | `continuo` | Trino user |
+| `TRINO_HTTP_SCHEME` | no | `http` | `http` or `https` |
+| `TRINO_PASSWORD` | no | unset | Basic auth; requires `TRINO_HTTP_SCHEME=https` |
+
+The catalog must be backed by a connector that supports schema and table creation
+(Iceberg and Hive do). The library is tested live against Iceberg (REST catalog + S3).

continuo_validation_trino-0.1.0/continuo_validation_trino/__init__.py

@@ -0,0 +1 @@
+"""Trino warehouse adapter for the continuo validation runner."""

continuo_validation_trino-0.1.0/continuo_validation_trino/adapter.py

@@ -0,0 +1,130 @@
+"""Trino implementation of the WarehouseAdapter port.
+
+Trino's namespace is catalog.schema: the catalog comes from TRINO_CATALOG and every
+statement is fully qualified, so the contract's `schema` argument stays an opaque bare
+name. Two Trino traits shape this adapter: there is no DROP SCHEMA ... CASCADE, so
+teardown drops the schema's tables first; and there are no advisory locks, so
+ensure_schema relies on IF NOT EXISTS plus tolerating a concurrent creation.
+"""
+import logging
+import os
+
+from continuo_validation_contract.port import WarehouseAdapter
+
+import trino
+
+from trino.auth import BasicAuthentication
+
+logger = logging.getLogger("continuo_validation_trino")
+
+
+def _quote(identifier: str) -> str:
+    """Double-quote a Trino identifier, escaping any embedded double quotes."""
+    escaped = identifier.replace('"', '""')
+    return f'"{escaped}"'
+
+
+class TrinoAdapter(WarehouseAdapter):
+    """WarehouseAdapter speaking Trino DDL over the trino DBAPI."""
+
+    def __init__(self, conn: "trino.dbapi.Connection", catalog: str) -> None:
+        self._conn = conn
+        self._catalog = catalog
+
+    @classmethod
+    def required_env(cls) -> list[str]:
+        """Vars that must be non-empty before connecting."""
+        return ["TRINO_HOST", "TRINO_CATALOG"]
+
+    @classmethod
+    def from_env(cls) -> "TrinoAdapter":
+        """Connect from TRINO_* env (port 8080, user continuo, http; password optional)."""
+        catalog = os.environ["TRINO_CATALOG"]
+        user = os.environ.get("TRINO_USER", "continuo")
+        http_scheme = os.environ.get("TRINO_HTTP_SCHEME", "http")
+        password = os.environ.get("TRINO_PASSWORD", "")
+        if password and http_scheme != "https":
+            raise ValueError(
+                "TRINO_PASSWORD is set but TRINO_HTTP_SCHEME is not 'https'; "
+                "Trino refuses basic auth over plaintext"
+            )
+        conn = trino.dbapi.connect(
+            host=os.environ["TRINO_HOST"],
+            port=int(os.environ.get("TRINO_PORT", "8080")),
+            user=user,
+            catalog=catalog,
+            http_scheme=http_scheme,
+            auth=BasicAuthentication(user, password) if password else None,
+        )
+        return cls(conn, catalog)
+
+    def _schema_ref(self, schema: str) -> str:
+        return f"{_quote(self._catalog)}.{_quote(schema)}"
+
+    def _table_ref(self, schema: str, table: str) -> str:
+        return f"{self._schema_ref(schema)}.{_quote(table)}"
+
+    def _execute(self, statement: str) -> list[tuple]:
+        """Run one statement to completion and return its rows.
+
+        The trino DBAPI is lazy: execute() only starts the query, so the results must
+        be consumed for DDL to actually take effect.
+        """
+        cur = self._conn.cursor()
+        try:
+            cur.execute(statement)
+            rows: list[tuple] = cur.fetchall()
+            return rows
+        finally:
+            cur.close()
+
+    def ensure_schema(self, schema: str) -> None:
+        """Idempotently create *schema*; safe under concurrent callers."""
+        logger.info("ensuring candidate schema %s.%s exists", self._catalog, schema)
+        try:
+            self._execute(f"CREATE SCHEMA IF NOT EXISTS {self._schema_ref(schema)}")
+        except trino.exceptions.TrinoUserError as exc:
+            # Trino has no advisory locks; a concurrent creator can still win the race
+            # between IF NOT EXISTS and the metastore write. The desired end state holds.
+            if "already exists" not in str(exc).lower():
+                raise
+            logger.info("schema %s already exists (concurrent create); continuing", schema)
+
+    def drop_schema(self, schema: str) -> None:
+        """Idempotently drop *schema* and everything in it; no-op if absent.
+
+        Trino has no DROP SCHEMA ... CASCADE, so the schema's tables are dropped first.
+        """
+        ref = self._schema_ref(schema)
+        try:
+            rows = self._execute(f"SHOW TABLES FROM {ref}")
+        except trino.exceptions.TrinoUserError as exc:
+            if "does not exist" not in str(exc).lower():
+                raise
+            logger.info("candidate schema %s absent; nothing to drop", schema)
+            return
+        logger.info("dropping candidate schema %s (%d tables)", schema, len(rows))
+        for row in rows:
+            self._execute(f"DROP TABLE IF EXISTS {self._table_ref(schema, row[0])}")
+        self._execute(f"DROP SCHEMA IF EXISTS {ref}")
+
+    def build_empty_from_sql(self, schema: str, table: str, compiled_sql: str) -> None:
+        """Create ``schema.table`` empty, shaped by the compiled SELECT."""
+        # Strip any trailing terminator so the SELECT nests cleanly inside AS ( ... ).
+        inner = compiled_sql.strip().rstrip(";").strip()
+        ref = self._table_ref(schema, table)
+        self._execute(f"DROP TABLE IF EXISTS {ref}")
+        self._execute(f"CREATE TABLE {ref} AS ({inner}) WITH NO DATA")
+
+    def clone_empty_from_prod(self, candidate_schema: str, prod_schema: str, table: str) -> None:
+        """Create ``candidate_schema.table`` empty, shaped like ``prod_schema.table``."""
+        ref = self._table_ref(candidate_schema, table)
+        self._execute(f"DROP TABLE IF EXISTS {ref}")
+        self._execute(
+            f"CREATE TABLE {ref} AS "
+            f"SELECT * FROM {self._table_ref(prod_schema, table)} WITH NO DATA"
+        )
+
+    def close(self) -> None:
+        """Release the underlying connection."""
+        self._conn.close()

continuo_validation_trino-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+version = "0.1.0"
+name = "continuo-validation-trino"
+description = "Trino warehouse adapter for the continuo validation runner."
+authors = [{ name = "Simone Carolini" }]
+maintainers = [{ name = "Simone Carolini" }]
+readme = "README.md"
+requires-python = ">= 3.14"
+dependencies = [
+    "continuo-validation-contract==0.2.0",
+    "trino==0.338.0",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.14",
+]
+
+[project.entry-points."continuo_validation.adapters"]
+trino = "continuo_validation_trino.adapter:TrinoAdapter"
+
+[dependency-groups]
+dev = [
+    "ruff==0.3.0",
+    "mypy==1.18.2",
+]
+test = [
+    "pytest==9.0.3",
+    "pytest-cov==4.1.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["continuo_validation_trino"]

continuo_validation_trino-0.1.0/testinfra/catalog/iceberg.properties

@@ -0,0 +1,10 @@
+connector.name=iceberg
+iceberg.catalog.type=rest
+iceberg.rest-catalog.uri=http://iceberg-rest:8181
+iceberg.rest-catalog.warehouse=s3://warehouse/
+fs.native-s3.enabled=true
+s3.endpoint=http://minio:9000
+s3.region=us-east-1
+s3.path-style-access=true
+s3.aws-access-key=minioadmin
+s3.aws-secret-key=minioadmin

continuo_validation_trino-0.1.0/tests/test_adapter.py

@@ -0,0 +1,22 @@
+"""Unit tests for the trino adapter — mock-free.
+
+DDL behavior (ensure_schema, drop_schema, build_empty_from_sql, clone_empty_from_prod,
+the connection built by from_env, and DDL validity) is verified against a live Trino +
+Iceberg stack in test_integration_trino.py, not with mocked cursors/connections here.
+"""
+from importlib.metadata import entry_points
+
+from continuo_validation_trino.adapter import TrinoAdapter
+
+
+def test_required_env_names_host_and_catalog():
+    """Test that required_env lists exactly the two mandatory TRINO_* vars."""
+    assert TrinoAdapter.required_env() == ["TRINO_HOST", "TRINO_CATALOG"]
+
+
+def test_entry_point_registered_and_loads_adapter():
+    """Test that the trino entry point is registered and loads TrinoAdapter."""
+    eps = [ep for ep in entry_points(group="continuo_validation.adapters")
+           if ep.name == "trino"]
+    assert len(eps) == 1
+    assert eps[0].load() is TrinoAdapter

continuo_validation_trino-0.1.0/tests/test_integration_trino.py

@@ -0,0 +1,149 @@
+"""Tier-2 live tests against Trino + Iceberg REST (docker-compose.integration.yml).
+
+Run the stack first:
+    docker compose -f docker-compose.integration.yml --profile trino up -d --wait
+"""
+import os
+import uuid
+
+import pytest
+
+from continuo_validation_trino.adapter import TrinoAdapter
+
+TRINO_ENV = {
+    "TRINO_HOST": "localhost",
+    "TRINO_PORT": os.environ.get("VR_IT_TRINO_PORT", "18080"),
+    "TRINO_USER": "continuo",
+    "TRINO_CATALOG": "iceberg",
+    "TRINO_HTTP_SCHEME": "http",
+}
+
+
+def _adapter() -> TrinoAdapter:
+    """Build an adapter from the live stack's connection env."""
+    for key, value in TRINO_ENV.items():
+        os.environ[key] = value
+    os.environ.pop("TRINO_PASSWORD", None)
+    return TrinoAdapter.from_env()
+
+
+def _schema_exists(adapter: TrinoAdapter, schema: str) -> bool:
+    rows = adapter._execute("SHOW SCHEMAS FROM iceberg")
+    return any(row[0] == schema for row in rows)
+
+
+@pytest.fixture()
+def candidate_schema():
+    """Yield a unique candidate schema name, dropped after the test."""
+    schema = f"_candidate_it_{uuid.uuid4().hex[:8]}"
+    yield schema
+    cleanup = _adapter()
+    cleanup.drop_schema(schema)
+    cleanup.close()
+
+
+@pytest.mark.integration
+def test_ensure_schema_creates_and_is_idempotent(candidate_schema):
+    """ensure_schema creates the schema; a second call succeeds unchanged."""
+    a = _adapter()
+    a.ensure_schema(candidate_schema)
+    assert _schema_exists(a, candidate_schema)
+    a.ensure_schema(candidate_schema)  # must not raise
+    assert _schema_exists(a, candidate_schema)
+    a.close()
+
+
+@pytest.mark.integration
+def test_drop_schema_removes_schema_containing_tables(candidate_schema):
+    """Trino has no DROP SCHEMA CASCADE: drop_schema must drop the tables first."""
+    a = _adapter()
+    a.ensure_schema(candidate_schema)
+    # Two tables, created directly so this test does not depend on the build methods.
+    for table in ("t_one", "t_two"):
+        a._execute(
+            f'CREATE TABLE iceberg."{candidate_schema}"."{table}" AS '
+            f"SELECT 1 AS id WITH NO DATA"
+        )
+    a.drop_schema(candidate_schema)
+    assert not _schema_exists(a, candidate_schema)
+    a.close()
+
+
+@pytest.mark.integration
+def test_drop_schema_on_absent_schema_is_a_noop():
+    """Teardown must never fail a release for an already-clean warehouse."""
+    a = _adapter()
+    a.drop_schema(f"_candidate_missing_{uuid.uuid4().hex[:8]}")  # must not raise
+    a.close()
+
+
+def _columns(adapter: TrinoAdapter, schema: str, table: str) -> list[tuple[str, str]]:
+    rows = adapter._execute(
+        "SELECT column_name, data_type FROM iceberg.information_schema.columns "
+        f"WHERE table_schema = '{schema}' AND table_name = '{table}' "
+        "ORDER BY ordinal_position"
+    )
+    return [(row[0], row[1]) for row in rows]
+
+
+def _count(adapter: TrinoAdapter, schema: str, table: str) -> int:
+    rows = adapter._execute(f'SELECT count(*) FROM iceberg."{schema}"."{table}"')
+    return int(rows[0][0])
+
+
+@pytest.fixture()
+def prod_table():
+    """Yield a prod-like schema with one populated table; dropped after the test."""
+    schema = f"_prod_it_{uuid.uuid4().hex[:8]}"
+    a = _adapter()
+    a.ensure_schema(schema)
+    a._execute(
+        f'CREATE TABLE iceberg."{schema}"."src_table" AS '
+        "SELECT * FROM (VALUES (1, 'a'), (2, 'b')) AS t(id, name)"
+    )
+    a.close()
+    yield schema
+    cleanup = _adapter()
+    cleanup.drop_schema(schema)
+    cleanup.close()
+
+
+@pytest.mark.integration
+def test_build_empty_from_sql_live(candidate_schema, prod_table):
+    """Build an empty candidate table shaped by a compiled SELECT."""
+    a = _adapter()
+    a.ensure_schema(candidate_schema)
+    a.build_empty_from_sql(
+        candidate_schema, "built",
+        f'SELECT id, name FROM iceberg."{prod_table}"."src_table"',
+    )
+    assert _columns(a, candidate_schema, "built") == [("id", "integer"), ("name", "varchar")]
+    assert _count(a, candidate_schema, "built") == 0
+    a.close()
+
+
+@pytest.mark.integration
+def test_build_is_rerun_idempotent(candidate_schema, prod_table):
+    """Building the same table twice drops and recreates instead of failing."""
+    a = _adapter()
+    a.ensure_schema(candidate_schema)
+    for _ in range(2):
+        a.build_empty_from_sql(
+            candidate_schema, "rerun",
+            f'SELECT id FROM iceberg."{prod_table}"."src_table"',
+        )
+    assert _count(a, candidate_schema, "rerun") == 0
+    a.close()
+
+
+@pytest.mark.integration
+def test_clone_empty_from_prod_live(candidate_schema, prod_table):
+    """Clone an empty candidate table shaped like the prod table."""
+    a = _adapter()
+    a.ensure_schema(candidate_schema)
+    a.clone_empty_from_prod(candidate_schema, prod_table, "src_table")
+    assert _columns(a, candidate_schema, "src_table") == [
+        ("id", "integer"), ("name", "varchar"),
+    ]
+    assert _count(a, candidate_schema, "src_table") == 0
+    a.close()