Function read

python/pathway/io/postgres/__init__.py:284–600

**This module is available when using one of the following licenses only:** `Pathway Live Data Framework Scale, Pathway Live Data Framework Enterprise `_. Reads a table from a PostgreSQL database. This connector provides a lightweight alternative to ``pw.io.debezium.read

(
    postgres_settings: dict,
    table_name: str,
    schema: type[Schema],
    *,
    mode: Literal["streaming", "static"] = "streaming",
    is_append_only: bool = False,
    publication_name: str | None = None,
    schema_name: str | None = "public",
    autocommit_duration_ms: int | None = 1500,
    name: str | None = None,
    max_backlog_size: int | None = None,
    debug_data: Any = None,
)

@check_arg_types
@trace_user_frame
def read(
    postgres_settings: dict,
    table_name: str,
    schema: type[Schema],
    *,
    mode: Literal["streaming", "static"] = "streaming",
    is_append_only: bool = False,
    publication_name: str | None = None,
    schema_name: str | None = "public",
    autocommit_duration_ms: int | None = 1500,
    name: str | None = None,
    max_backlog_size: int | None = None,
    debug_data: Any = None,
) -> Table:
    """
    **This module is available when using one of the following licenses only:**
    `Pathway Live Data Framework Scale, Pathway Live Data Framework Enterprise </pricing>`_.

    Reads a table from a PostgreSQL database.

    This connector provides a lightweight alternative to ``pw.io.debezium.read``.
    It supports two modes: ``"static"`` and ``"streaming"``.

    In ``"static"`` mode, the table is read once and the connector stops afterward.

    In ``"streaming"`` mode, a *temporary* replication slot is created using the
    ``pgoutput`` logical decoding plugin, which is bundled with PostgreSQL and requires
    no additional installation. The slot is created with the ``export snapshot`` option,
    ensuring a consistent initial read. On startup, the connector first performs a
    snapshot of the table as it existed at the moment the replication slot was created,
    and then begins consuming the PostgreSQL write-ahead log (WAL), applying incremental
    changes on top of that snapshot. Because the replication slot is temporary,
    PostgreSQL will automatically drop it once the connection is closed (i.e., when the
    program terminates).

    To enable replication, a publication must be created in the database beforehand:

    .. code-block:: sql

        CREATE PUBLICATION {publication_name} FOR TABLE {table_name};

    Args:
        postgres_settings: Connection parameters for PostgreSQL, provided as a
            dictionary of key-value pairs. The connection string is assembled by joining
            all pairs with spaces, each formatted as ``key=value``. Keys must be strings;
            values of other types are converted via Python&#x27;s ``str()``.
            The Pathway Live Data Framework injects conservative TCP-keepalive defaults (``keepalives``,
            ``keepalives_idle=300``, ``keepalives_interval=30``, ``keepalives_count=3``,
            and ``tcp_user_timeout=300000``) so that an unreachable
            the Pathway Live Data Framework process is detected by PostgreSQL within minutes rather than
            the OS-inherited ~2-hour default; any of these can be overridden by
            passing the same key in ``postgres_settings``.
        table_name: Name of the PostgreSQL table to read from. Any PostgreSQL
            identifier is accepted — the connector quotes the name before
            interpolating it into generated SQL, so hyphens, mixed case, and
            reserved words round-trip as-is.
        schema: Pathway Live Data Framework schema describing the table&#x27;s columns and their types.
            Column names may be any PostgreSQL identifier for the same reason