continuo-postgres-adapter 0.3.2__tar.gz → 0.4.0__tar.gz

continuo_postgres_adapter-0.4.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.5
+Name: continuo-postgres-adapter
+Version: 0.4.0
+Summary: Postgres warehouse adapter for Continuo: validation and python-node runtime.
+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-engine-contract==0.10.0
+Requires-Dist: psycopg2-binary==2.9.13
+Requires-Dist: pyarrow==26.0.0
+Description-Content-Type: text/markdown
+
+# continuo-postgres-adapter
+
+Postgres engine-adapter library for Continuo python nodes. `PostgresAdapter`
+implements `continuo_engine_contract.port.WarehouseAdapter` (from the
+`continuo-engine-contract` package) — one class covering both the data plane
+(`fetch` / `ensure_table` / `load`) and release-time validation
+(`ensure_schema` / `drop_schema` / `build_empty_from_sql` /
+`build_empty_from_columns` / `clone_empty_from_prod` / `check_binds`) — and
+registers itself under entry-point group `continuo_engine.adapters` as
+`postgres`.
+
+Connection env: `POSTGRES_HOST`, `POSTGRES_DB`, `POSTGRES_USER` (required);
+`POSTGRES_PORT` (default 5432), `POSTGRES_PASSWORD` (default empty).
+
+`from_env` tries a connection that no server answered (every address of the
+host refused, had no route or sat on an unreachable network) up to 5 times,
+2 s apart, logging each retry: a Job pod's first connection can be refused
+for a few seconds after the pod starts, until the cluster's NetworkPolicy
+engine has admitted the pod. Every other failure, an authentication failure or
+a connect timeout on any address among them, is raised at once.
+
+The connection runs with `autocommit = True`; every method owns its
+transaction explicitly. `load()` and `ensure_table()` open an explicit
+`BEGIN` around their statements and `COMMIT`/`ROLLBACK` themselves, so a
+mid-sequence failure leaves no partial change. `fetch()` executes a single
+read and commits (or rolls back on error), never leaving an open transaction
+dangling.
+
+`PostgresAdapter` declares `drop_semantics = "cascade"` and is a
+`DependentsIntrospection`: `dependents(schema, table)` lists every object a
+`DROP TABLE ... CASCADE` of the table destroys or changes, with
+`completeness="exact"`. It walks `pg_depend` from the table through every normal
+dependency, so it lists views and materialized views (found through their
+`_RETURN` rule, at any depth: a view of a view of the table is depth 2),
+SQL-standard functions and procedures, foreign keys and policies on other
+tables, rules, inheriting tables, tables with a column of the table's row type
+or of an array of it, the types built on it (a domain, a range, a composite
+type, a domain over an array of it) and what reads them, including a column of
+the array or multirange type of such a type, a generated column over a dropped
+column and what reads it, and what reads a partition of the table or a sequence
+of it (owned or identity). A table that only loses a column is listed, and from
+it only what reads that column is walked on.
+`information_schema.view_table_usage` misses the materialized views, the
+functions and every view past the first level. The table's own indexes,
+constraints (a self-referencing foreign key included), policies, rules, column
+defaults, sequences, partitions and triggers are parts of the table, and the
+array and multirange types, constructor functions and casts a type internally
+owns (the constructors of a range or multirange type and the range-to-multirange
+cast) are parts of the type: none is listed. A cast a user created, such as
+`CREATE CAST (seed AS text)`, is dropped by the cascade and is listed as `other`
+(`cast from <schema>.seed to text`). Each object appears once, at its shallowest depth.
+The walk follows at most 32 dependency levels; an object deeper than that is not
+listed. The table is found case-insensitively, so a seed loaded under another
+letter case never makes the walk skip it, and a schema holding two tables that
+differ only by letter case lists the dependants of both; a missing table or
+schema gives no objects. Each `kind` is one of `view`, `materialized_view`,
+`table`, `function`, `procedure`, `constraint`, `policy`, `rule` or `other`.
+`other` is anything else: a domain, a range type or another type (named
+`type <name>`), a composite type (its own name), an index, a user cast, a column
+default of another table (named `default value for column ...`) or a trigger.
+A name that Postgres describes (a type, a cast, a column default) is
+schema-qualified unless the object is visible on the connection's `search_path`
+(a domain in `public` is named `type my_domain`). The
+name of a function carries its argument types (`seed_count()`), and that of a
+constraint, policy or rule the table or domain it sits on
+(`orders_seed_id_fkey on orders`). A listed object that has no table of its own
+(a type, a column default, a trigger) has an empty schema and an empty owner.
+CI runs the dependents suite against the postgres:16 test stack; it was also
+verified against a postgres:18.3 server by pointing the suite at it with
+`VR_IT_PG_PORT` (host `localhost`, database `warehouse`, user and password
+`continuo`).
+
+The `config:` index vocabulary is the union of the two vocabularies this
+adapter inherited from the merge: `columns`, `unique`, `type`, and `name`,
+with the strictest check from each side applied. The derived index name is
+built from the table and the column list only — `type` and `unique` are not
+folded into it, so two index entries on the same columns that differ only in
+`type` (or only in `unique`) collide on that derived name and are rejected as
+a duplicate. Give one of them an explicit `name:` when that is genuinely
+intended.
+
+Verification tier: unit tests are mock-free pure-logic tests (type-grammar
+validation, Arrow table construction from rows); DDL/transactional behavior
+(schema/table creation, load truncate+insert+rollback, validation DDL) is
+verified against a live postgres:16 engine in
+`tests/test_integration_runtime_postgres.py` and
+`tests/test_integration_postgres_validation.py`.

continuo_postgres_adapter-0.4.0/README.md

@@ -0,0 +1,87 @@
+# continuo-postgres-adapter
+
+Postgres engine-adapter library for Continuo python nodes. `PostgresAdapter`
+implements `continuo_engine_contract.port.WarehouseAdapter` (from the
+`continuo-engine-contract` package) — one class covering both the data plane
+(`fetch` / `ensure_table` / `load`) and release-time validation
+(`ensure_schema` / `drop_schema` / `build_empty_from_sql` /
+`build_empty_from_columns` / `clone_empty_from_prod` / `check_binds`) — and
+registers itself under entry-point group `continuo_engine.adapters` as
+`postgres`.
+
+Connection env: `POSTGRES_HOST`, `POSTGRES_DB`, `POSTGRES_USER` (required);
+`POSTGRES_PORT` (default 5432), `POSTGRES_PASSWORD` (default empty).
+
+`from_env` tries a connection that no server answered (every address of the
+host refused, had no route or sat on an unreachable network) up to 5 times,
+2 s apart, logging each retry: a Job pod's first connection can be refused
+for a few seconds after the pod starts, until the cluster's NetworkPolicy
+engine has admitted the pod. Every other failure, an authentication failure or
+a connect timeout on any address among them, is raised at once.
+
+The connection runs with `autocommit = True`; every method owns its
+transaction explicitly. `load()` and `ensure_table()` open an explicit
+`BEGIN` around their statements and `COMMIT`/`ROLLBACK` themselves, so a
+mid-sequence failure leaves no partial change. `fetch()` executes a single
+read and commits (or rolls back on error), never leaving an open transaction
+dangling.
+
+`PostgresAdapter` declares `drop_semantics = "cascade"` and is a
+`DependentsIntrospection`: `dependents(schema, table)` lists every object a
+`DROP TABLE ... CASCADE` of the table destroys or changes, with
+`completeness="exact"`. It walks `pg_depend` from the table through every normal
+dependency, so it lists views and materialized views (found through their
+`_RETURN` rule, at any depth: a view of a view of the table is depth 2),
+SQL-standard functions and procedures, foreign keys and policies on other
+tables, rules, inheriting tables, tables with a column of the table's row type
+or of an array of it, the types built on it (a domain, a range, a composite
+type, a domain over an array of it) and what reads them, including a column of
+the array or multirange type of such a type, a generated column over a dropped
+column and what reads it, and what reads a partition of the table or a sequence
+of it (owned or identity). A table that only loses a column is listed, and from
+it only what reads that column is walked on.
+`information_schema.view_table_usage` misses the materialized views, the
+functions and every view past the first level. The table's own indexes,
+constraints (a self-referencing foreign key included), policies, rules, column
+defaults, sequences, partitions and triggers are parts of the table, and the
+array and multirange types, constructor functions and casts a type internally
+owns (the constructors of a range or multirange type and the range-to-multirange
+cast) are parts of the type: none is listed. A cast a user created, such as
+`CREATE CAST (seed AS text)`, is dropped by the cascade and is listed as `other`
+(`cast from <schema>.seed to text`). Each object appears once, at its shallowest depth.
+The walk follows at most 32 dependency levels; an object deeper than that is not
+listed. The table is found case-insensitively, so a seed loaded under another
+letter case never makes the walk skip it, and a schema holding two tables that
+differ only by letter case lists the dependants of both; a missing table or
+schema gives no objects. Each `kind` is one of `view`, `materialized_view`,
+`table`, `function`, `procedure`, `constraint`, `policy`, `rule` or `other`.
+`other` is anything else: a domain, a range type or another type (named
+`type <name>`), a composite type (its own name), an index, a user cast, a column
+default of another table (named `default value for column ...`) or a trigger.
+A name that Postgres describes (a type, a cast, a column default) is
+schema-qualified unless the object is visible on the connection's `search_path`
+(a domain in `public` is named `type my_domain`). The
+name of a function carries its argument types (`seed_count()`), and that of a
+constraint, policy or rule the table or domain it sits on
+(`orders_seed_id_fkey on orders`). A listed object that has no table of its own
+(a type, a column default, a trigger) has an empty schema and an empty owner.
+CI runs the dependents suite against the postgres:16 test stack; it was also
+verified against a postgres:18.3 server by pointing the suite at it with
+`VR_IT_PG_PORT` (host `localhost`, database `warehouse`, user and password
+`continuo`).
+
+The `config:` index vocabulary is the union of the two vocabularies this
+adapter inherited from the merge: `columns`, `unique`, `type`, and `name`,
+with the strictest check from each side applied. The derived index name is
+built from the table and the column list only — `type` and `unique` are not
+folded into it, so two index entries on the same columns that differ only in
+`type` (or only in `unique`) collide on that derived name and are rejected as
+a duplicate. Give one of them an explicit `name:` when that is genuinely
+intended.
+
+Verification tier: unit tests are mock-free pure-logic tests (type-grammar
+validation, Arrow table construction from rows); DDL/transactional behavior
+(schema/table creation, load truncate+insert+rollback, validation DDL) is
+verified against a live postgres:16 engine in
+`tests/test_integration_runtime_postgres.py` and
+`tests/test_integration_postgres_validation.py`.

{continuo_postgres_adapter-0.3.2 → continuo_postgres_adapter-0.4.0}/continuo_postgres_adapter/adapter.py

@@ -12,6 +12,8 @@ One class covers both roles Continuo asks of an engine:
   its ``PRIMARY KEY``); ``load`` atomically replaces its contents, ``append``
   adds rows and ``_upsert`` inserts or overwrites by key, all through one
   insert helper; ``table_columns`` reads its shape.
+* **Drop impact** — ``dependents`` lists every object a drop of a table would
+  cascade to, from ``pg_depend``.
 
 The connection runs with ``autocommit = True``: every method owns its
 transaction explicitly rather than relying on psycopg2's implicit
@@ -40,6 +42,9 @@ import pyarrow as pa  # type: ignore[import-untyped]
 from continuo_engine_contract.config import ensure_known_keys  # type: ignore[import-untyped]
 from continuo_engine_contract.port import (  # type: ignore[import-untyped]
     AppendCapable,
+    Dependent,
+    DependentsIntrospection,
+    Dependents,
     LiveColumn,
     UpsertCapable,
     WarehouseAdapter,
@@ -443,9 +448,136 @@ def _arrow_table_from_rows(colnames: list[str], rows: list[tuple[Any, ...]]) ->
     return pa.table({name: pa.array(values) for name, values in zip(colnames, by_column)})
 
 
-class PostgresAdapter(WarehouseAdapter, AppendCapable, UpsertCapable):
+# Every object that depends on a table, found by following pg_depend's normal
+# dependencies (deptype 'n'), the ones DROP ... CASCADE follows. The walk's
+# nodes are (class, object, subid): subid 0 is the whole object, a positive
+# subid one column of a table or composite type. A column a cascade drops leaves
+# its table in place, so from a column node only the dependencies on that column
+# are followed, and the table itself is still listed. A view's dependency is
+# recorded on its _RETURN rewrite rule, so the walk steps from the rule to the
+# view it belongs to. The expression of a generated column (a pg_attrdef row) is
+# dropped together with its column, so the walk steps from it to that column. A
+# table that has a column of the walked table's row type, or of an array of it,
+# depends on that type (pg_type), not on the table, so a whole-table step also
+# follows the dependencies on its reltype and typarray. What a type the walk
+# reaches (a domain, a range) internally owns (deptype 'i': its array type, its
+# multirange type, its constructor functions and casts) is dropped with it, so a
+# pg_type step also follows every internal dependency on it. A partition, a
+# sequence owned by a column (deptype 'a'), an identity sequence and an
+# internally owned object are parts of their owner, yet what reads them is
+# dropped with it: the walk steps through them without adding a level, and lists
+# none of them. The table's own indexes and triggers are automatic dependencies
+# that nothing reads, so the walk does not follow them. The depth bound of 32
+# keeps a dependency cycle from running forever, and ends a chain deeper than
+# that unlisted.
+_DEPENDENTS_SQL = """
+WITH RECURSIVE walk(classid, objid, subid, depth) AS (
+    SELECT 'pg_class'::regclass::oid, c.oid, 0, 0
+    FROM pg_class c
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    WHERE lower(n.nspname) = lower(%(schema)s)
+      AND lower(c.relname) = lower(%(table)s)
+      AND c.relkind IN ('r', 'p')
+  UNION
+    SELECT CASE WHEN rw.oid IS NULL AND gad.oid IS NULL THEN dep.classid ELSE 'pg_class'::regclass::oid END,
+           CASE WHEN rw.oid IS NOT NULL THEN rw.ev_class
+                WHEN gad.oid IS NOT NULL THEN gad.adrelid
+                ELSE dep.objid END,
+           CASE WHEN rw.oid IS NOT NULL THEN 0
+                WHEN gad.oid IS NOT NULL THEN gad.adnum::int
+                ELSE dep.objsubid END,
+           w.depth + CASE WHEN dep.deptype IN ('a', 'i') THEN 0 ELSE 1 END
+    FROM walk w
+    LEFT JOIN pg_class wc
+      ON w.classid = 'pg_class'::regclass::oid AND w.subid = 0 AND wc.oid = w.objid
+    LEFT JOIN pg_type rowtype ON rowtype.oid = wc.reltype
+    JOIN pg_depend dep
+      ON (dep.refclassid = w.classid AND dep.refobjid = w.objid
+          AND (w.subid = 0 OR dep.refobjsubid = w.subid))
+      OR (dep.refclassid = 'pg_type'::regclass::oid
+          AND dep.refobjid IN (rowtype.oid, rowtype.typarray))
+    LEFT JOIN pg_class dc
+      ON dep.classid = 'pg_class'::regclass::oid AND dc.oid = dep.objid
+    LEFT JOIN pg_rewrite rw
+      ON dep.classid = 'pg_rewrite'::regclass::oid AND rw.oid = dep.objid AND rw.rulename = '_RETURN'
+    LEFT JOIN pg_attrdef gad
+      ON dep.classid = 'pg_attrdef'::regclass::oid AND gad.oid = dep.objid
+     AND EXISTS (SELECT 1 FROM pg_attribute ga
+                 WHERE ga.attrelid = gad.adrelid AND ga.attnum = gad.adnum AND ga.attgenerated <> '')
+    WHERE w.depth < 32
+      AND (dep.deptype = 'n'
+           OR (dep.deptype IN ('a', 'i') AND dc.relkind = 'S')
+           OR (dep.deptype = 'a' AND dc.relkind IN ('r', 'p', 'f') AND dc.relispartition)
+           OR (dep.deptype = 'i' AND w.classid = 'pg_type'::regclass::oid AND dep.refclassid = w.classid))
+      AND (rw.oid IS NULL OR rw.ev_class <> w.objid)
+)
+SELECT found.catalog,
+       CASE found.catalog WHEN 'pg_class' THEN c.relkind::text WHEN 'pg_proc' THEN p.prokind::text ELSE '' END,
+       COALESCE(n.nspname, ''),
+       CASE found.catalog
+           WHEN 'pg_class' THEN c.relname
+           WHEN 'pg_proc' THEN p.proname || '(' || pg_get_function_identity_arguments(p.oid) || ')'
+           WHEN 'pg_constraint' THEN
+               CASE WHEN k.conrelid = 0 THEN k.conname || ' on ' || format_type(k.contypid, NULL)
+                    ELSE k.conname || ' on ' || t.relname END
+           WHEN 'pg_policy' THEN pol.polname || ' on ' || t.relname
+           WHEN 'pg_rewrite' THEN rw.rulename || ' on ' || t.relname
+           ELSE pg_describe_object(found.classid, found.objid, 0)
+       END,
+       COALESCE(pg_get_userbyid(COALESCE(c.relowner, p.proowner, t.relowner)), ''),
+       found.depth
+FROM (
+    SELECT classid, objid, classid::regclass::text AS catalog, min(depth) AS depth
+    FROM walk
+    GROUP BY classid, objid
+    HAVING min(depth) > 0
+) found
+LEFT JOIN pg_class c ON found.catalog = 'pg_class' AND c.oid = found.objid
+LEFT JOIN pg_proc p ON found.catalog = 'pg_proc' AND p.oid = found.objid
+LEFT JOIN pg_constraint k ON found.catalog = 'pg_constraint' AND k.oid = found.objid
+LEFT JOIN pg_policy pol ON found.catalog = 'pg_policy' AND pol.oid = found.objid
+LEFT JOIN pg_rewrite rw ON found.catalog = 'pg_rewrite' AND rw.oid = found.objid
+LEFT JOIN pg_attrdef ad ON found.catalog = 'pg_attrdef' AND ad.oid = found.objid
+LEFT JOIN pg_trigger tg ON found.catalog = 'pg_trigger' AND tg.oid = found.objid
+LEFT JOIN pg_class t ON t.oid = COALESCE(k.conrelid, pol.polrelid, rw.ev_class)
+LEFT JOIN pg_namespace n ON n.oid = COALESCE(c.relnamespace, p.pronamespace, t.relnamespace)
+-- a sequence, a partition and the per-partition copy of a foreign key are parts of their owner
+WHERE NOT (found.catalog = 'pg_class'
+           AND (c.relkind = 'S' OR (c.relkind IN ('r', 'p', 'f') AND c.relispartition)))
+-- so is whatever a type internally owns (its array and multirange types, its constructor functions and
+-- casts), except a composite type's own pg_class row
+  AND NOT (found.catalog <> 'pg_class'
+           AND EXISTS (SELECT 1 FROM pg_depend own
+                       WHERE own.classid = found.classid AND own.objid = found.objid
+                         AND own.deptype = 'i' AND own.refclassid = 'pg_type'::regclass::oid))
+  AND NOT (found.catalog = 'pg_constraint' AND k.conparentid <> 0)
+-- a constraint, default, policy, rule or trigger of the table itself is part of the table
+  AND NOT COALESCE(COALESCE(k.conrelid, ad.adrelid, pol.polrelid, rw.ev_class, tg.tgrelid) IN (
+           SELECT objid FROM walk WHERE depth = 0 AND classid = 'pg_class'::regclass::oid), false)
+ORDER BY found.depth, 3, 4
+"""
+
+
+def _dependent_kind(catalog: str, subkind: str) -> str:
+    """The contract's kind for a catalog row: *subkind* is ``relkind`` for ``pg_class``, ``prokind`` for ``pg_proc``.
+
+    A ``pg_class`` row that is no table, view or materialized view (a composite
+    type, an index) is ``other``.
+    """
+    if catalog == "pg_class":
+        return {"v": "view", "m": "materialized_view", "r": "table", "p": "table", "f": "table"}.get(
+            subkind, "other"
+        )
+    if catalog == "pg_proc":
+        return "procedure" if subkind == "p" else "function"
+    return {"pg_constraint": "constraint", "pg_policy": "policy", "pg_rewrite": "rule"}.get(catalog, "other")
+
+
+class PostgresAdapter(WarehouseAdapter, AppendCapable, UpsertCapable, DependentsIntrospection):
     """WarehouseAdapter speaking postgres over a psycopg2 connection."""
 
+    drop_semantics = "cascade"
+
     def __init__(self, conn: "psycopg2.extensions.connection") -> None:
         self._conn = conn
         self._conn.autocommit = True
@@ -716,6 +848,43 @@ class PostgresAdapter(WarehouseAdapter, AppendCapable, UpsertCapable):
             raise LookupError(f"table {schema}.{table} does not exist")
         return [LiveColumn(name=name, nullable=is_nullable == "YES") for name, is_nullable in rows]
 
+    def dependents(self, schema: str, table: str) -> Dependents:
+        """Every object a ``DROP TABLE schema.table CASCADE`` destroys or changes, exactly.
+
+        Lists views, materialized views, SQL-standard functions and procedures,
+        foreign keys and policies on other tables, rules, inheriting tables,
+        tables with a column of this table's row type, or of an array of it,
+        and the types built on it (a domain, a range, a composite type, and a
+        domain over an array of it), each once at its shallowest depth, with
+        what reads them: a column of an array or multirange type of such a
+        type, a generated column over a dropped column, and what reads a
+        partition of the table or a sequence of it (owned or identity). A table
+        that only loses a column is listed, and only what reads that column is
+        walked on from it. The table's own indexes, constraints (a
+        self-referencing foreign key included), policies, rules, column
+        defaults, sequences, partitions and triggers, and what a type owns
+        internally (its array and multirange types, constructor functions and
+        casts), are parts of their owner and are not listed.
+
+        The walk follows at most 32 dependency levels: an object deeper than
+        that is not listed.
+
+        The table is found case-insensitively, so a seed loaded under another
+        letter case still has its dependants listed, and the walk never
+        under-reports; a schema holding two tables that differ only by case
+        lists the dependants of both. A missing table or schema gives no objects.
+        """
+        with self._conn.cursor() as cur:
+            cur.execute(_DEPENDENTS_SQL, {"schema": schema, "table": table})
+            rows = cur.fetchall()
+        return Dependents(
+            objects=tuple(
+                Dependent(dep_schema, name, _dependent_kind(catalog, subkind), owner or "", depth)
+                for catalog, subkind, dep_schema, name, owner, depth in rows
+            ),
+            completeness="exact",
+        )
+
     @classmethod
     def validate_config(
         cls, config: dict[str, Any] | None, column_names: list[str]

{continuo_postgres_adapter-0.3.2 → continuo_postgres_adapter-0.4.0}/pyproject.toml

@@ -1,5 +1,5 @@
 [project]
-version = "0.3.2"
+version = "0.4.0"
 name = "continuo-postgres-adapter"
 description = "Postgres warehouse adapter for Continuo: validation and python-node runtime."
 authors = [{ name = "Simone Carolini" }]
@@ -12,7 +12,7 @@ dependencies = [
     # of this adapter would otherwise accept whatever contract release is
     # newest. This adapter subclasses the contract's WarehouseAdapter port
     # directly, so the pair must stay the tested one.
-    "continuo-engine-contract==0.9.0",
+    "continuo-engine-contract==0.10.0",
     "psycopg2-binary==2.9.13",
     "pyarrow==26.0.0",
 ]

{continuo_postgres_adapter-0.3.2 → continuo_postgres_adapter-0.4.0}/tests/test_adapter_postgres_validation.py

@@ -7,7 +7,12 @@ cursors/connections here.
 """
 import pytest
 
-from continuo_postgres_adapter.adapter import PostgresAdapter, _index_name, _validated_indexes
+from continuo_postgres_adapter.adapter import (
+    PostgresAdapter,
+    _dependent_kind,
+    _index_name,
+    _validated_indexes,
+)
 
 
 def test_required_env_names_connection_vars():
@@ -17,6 +22,10 @@ def test_required_env_names_connection_vars():
     ]
 
 
+def test_dropping_a_table_cascades_to_its_dependents():
+    assert PostgresAdapter.drop_semantics == "cascade"
+
+
 def test_build_empty_from_columns_rejects_bad_type_before_touching_db() -> None:
     """Test that a malformed type string is rejected before any DB access."""
     adapter = PostgresAdapter.__new__(PostgresAdapter)  # no connection needed
@@ -197,3 +206,15 @@ def test_an_explicit_name_admits_two_access_methods_over_one_column_set():
     ]
     entries = _validated_indexes({"indexes": indexes}, "t", ["id"])
     assert [e["name"] for e in entries] == ["ix_t_id", "ix_t_id_hash"]
+
+
+@pytest.mark.parametrize(("catalog", "subkind", "kind"), [
+    ("pg_class", "v", "view"), ("pg_class", "m", "materialized_view"), ("pg_class", "r", "table"),
+    ("pg_class", "p", "table"), ("pg_class", "f", "table"), ("pg_proc", "f", "function"),
+    ("pg_proc", "p", "procedure"), ("pg_constraint", "", "constraint"), ("pg_policy", "", "policy"),
+    ("pg_rewrite", "", "rule"), ("pg_trigger", "", "other"), ("pg_class", "c", "other"),
+    ("pg_class", "i", "other"), ("pg_class", "I", "other"), ("pg_class", "S", "other"),
+    ("pg_class", "t", "other"),
+])
+def test_dependent_kind_maps_each_catalog_row(catalog, subkind, kind):
+    assert _dependent_kind(catalog, subkind) == kind

{continuo_postgres_adapter-0.3.2 → continuo_postgres_adapter-0.4.0}/tests/test_integration_postgres_conformance.py

@@ -17,6 +17,7 @@ from continuo_engine_contract.testing.conformance import (
     NAMES,
     AppendConformance,
     ConformanceBase,
+    DependentsConformance,
     IntrospectionConformance,
     StartupConformance,
     UpsertConformance,
@@ -83,6 +84,10 @@ class TestPostgresUpsert(UpsertConformance):
     pass
 
 
+class TestPostgresDependents(DependentsConformance):
+    pass
+
+
 def _primary_key_columns(schema: str, table: str) -> list[str]:
     conn = psycopg2.connect(**PG)
     try: