continuo-postgres-adapter 0.3.1__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.1 → 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
@@ -28,8 +30,10 @@ import contextlib
 import hashlib
 import logging
 import os
+import re
+import time
 
-from collections.abc import Iterator, Sequence
+from collections.abc import Callable, Iterator, Sequence
 from typing import Any
 
 import psycopg2  # type: ignore[import-untyped]
@@ -38,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,
@@ -79,6 +86,42 @@ _DEFAULT_INDEX_TYPE = "btree"
 # postgres actually stores.
 _MAX_IDENTIFIER_BYTES = 63
 
+# 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: an
+# engine that rejects (k3s's kube-router) refuses at once instead of dropping
+# the packets. So a connection the server never answered, refused or
+# unroutable, is tried again. A connect timeout is not: an engine that drops
+# packets only delays the first connection, which TCP's own retransmissions
+# carry through, so a timeout means the server stayed silent for the whole
+# timeout and every retry would wait that long again.
+_CONNECT_ATTEMPTS = 5
+_CONNECT_RETRY_SECONDS = 2.0
+# libpq writes one line per address it tried, the reason after "failed: "
+# (libpq 14 and later) or after "could not connect to server: " (libpq 13 and
+# earlier); pgcode is None for every connection failure, so the text is all
+# there is.
+_ADDRESS_FAILURE = re.compile(r"(?:failed|could not connect to server): ([^\n]*)")
+_UNREACHABLE_REASONS = frozenset({"Connection refused", "No route to host", "Network is unreachable"})
+
+
+def _is_unreachable(exc: "psycopg2.OperationalError") -> bool:
+    """Whether *exc* says that every address of the host refused or could not be routed to.
+
+    A host name can have several addresses, and libpq reports each one it
+    tried. One that timed out means a retry would wait out its timeout again;
+    a FATAL line came from a server that answered (a failed authentication, an
+    unknown database). libpq 13 and earlier print a timeout as a bare
+    "timeout expired" line, with no prefix.
+    """
+    message = str(exc)
+    reasons = [reason.strip() for reason in _ADDRESS_FAILURE.findall(message)]
+    return (
+        bool(reasons)
+        and all(reason in _UNREACHABLE_REASONS for reason in reasons)
+        and "FATAL:" not in message
+        and "timeout expired" not in message
+    )
+
 
 def _truncate_explicit_identifier(name: str) -> str:
     """Truncate an explicit, author-given identifier to at most 63 bytes.
@@ -405,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
@@ -418,16 +588,35 @@ class PostgresAdapter(WarehouseAdapter, AppendCapable, UpsertCapable):
         return ["POSTGRES_HOST", "POSTGRES_DB", "POSTGRES_USER"]
 
     @classmethod
-    def from_env(cls) -> "PostgresAdapter":
-        """Connect from POSTGRES_* env (port defaults 5432, password empty)."""
-        conn = psycopg2.connect(
-            host=os.environ["POSTGRES_HOST"],
-            port=os.environ.get("POSTGRES_PORT", "5432"),
-            dbname=os.environ["POSTGRES_DB"],
-            user=os.environ["POSTGRES_USER"],
-            password=os.environ.get("POSTGRES_PASSWORD", ""),
-        )
-        return cls(conn)
+    def from_env(cls, *, sleep: Callable[[float], None] = time.sleep) -> "PostgresAdapter":
+        """Connect from POSTGRES_* env (port defaults 5432, password empty).
+
+        A connection no server answered (refused, no route, network
+        unreachable) is tried again, up to ``_CONNECT_ATTEMPTS`` times in all,
+        ``_CONNECT_RETRY_SECONDS`` apart, each retry logged; the last failure
+        is raised. Every other failure is raised at once.
+        """
+        params = {
+            "host": os.environ["POSTGRES_HOST"],
+            "port": os.environ.get("POSTGRES_PORT", "5432"),
+            "dbname": os.environ["POSTGRES_DB"],
+            "user": os.environ["POSTGRES_USER"],
+            "password": os.environ.get("POSTGRES_PASSWORD", ""),
+        }
+        for attempt in range(1, _CONNECT_ATTEMPTS + 1):
+            try:
+                conn = psycopg2.connect(**params)
+            except psycopg2.OperationalError as exc:
+                if attempt == _CONNECT_ATTEMPTS or not _is_unreachable(exc):
+                    raise
+                logger.warning(
+                    "postgres not reachable yet (attempt %d of %d), retrying in %.0f s: %s",
+                    attempt, _CONNECT_ATTEMPTS, _CONNECT_RETRY_SECONDS, str(exc).strip(),
+                )
+                sleep(_CONNECT_RETRY_SECONDS)
+                continue
+            return cls(conn)
+        raise AssertionError("unreachable")  # pragma: no cover
 
     # --- Schema lifecycle ---------------------------------------------------
 
@@ -659,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.1 → continuo_postgres_adapter-0.4.0}/pyproject.toml

@@ -1,5 +1,5 @@
 [project]
-version = "0.3.1"
+version = "0.4.0"
 name = "continuo-postgres-adapter"
 description = "Postgres warehouse adapter for Continuo: validation and python-node runtime."
 authors = [{ name = "Simone Carolini" }]
@@ -12,9 +12,9 @@ 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.8.1",
-    "psycopg2-binary==2.9.12",
-    "pyarrow==25.0.1",
+    "continuo-engine-contract==0.10.0",
+    "psycopg2-binary==2.9.13",
+    "pyarrow==26.0.0",
 ]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -27,8 +27,8 @@ postgres = "continuo_postgres_adapter.adapter:PostgresAdapter"
 
 [dependency-groups]
 dev = [
-    "ruff==0.16.5",
-    "mypy==2.3.1",
+    "ruff==0.17.1",
+    "mypy==2.4.0",
 ]
 test = [
     "pytest==9.1.1",