Struct XminReader 

pub struct XminReader<'a> { /* private fields */ }

Reads changed rows from a PostgreSQL table using xmin-based change detection.

PostgreSQL’s xmin system column contains the transaction ID that last modified each row. By tracking the maximum xmin seen, we can query for only rows that have been modified since the last sync.

Warning: xmin wraps around at 2^32 transactions. Use detect_wraparound() to check for this condition and trigger a full table sync when detected.

Implementations

impl<'a> XminReader<'a>

pub fn new(client: &'a Client) -> Self

Create a new XminReader for the given PostgreSQL client connection.

pub fn client(&self) -> &Client

Get the underlying database client.

pub async fn get_current_xmin(&self) -> Result<u32>

Get the current transaction ID (xmin snapshot) from the database.

This should be called at the start of a sync to establish the high-water mark.

pub async fn read_changes( &self, schema: &str, table: &str, columns: &[String], since_xmin: u32, ) -> Result<(Vec<Row>, u32)>

Read all rows from a table that have xmin greater than the given value.

Arguments

• schema - The schema name (e.g., “public”)
• table - The table name
• columns - Column names to select (pass empty slice to select all)
• since_xmin - Only return rows with xmin > this value (0 = all rows)

Returns

A tuple of (rows, max_xmin) where max_xmin is the highest xmin seen in the result set.

pub async fn read_changes_batched( &self, schema: &str, table: &str, columns: &[String], since_xmin: u32, batch_size: usize, ) -> Result<BatchReader>

Read changes in batches to handle large tables efficiently.

Arguments

• schema - The schema name
• table - The table name
• columns - Column names to select
• since_xmin - Only return rows with xmin > this value
• batch_size - Maximum rows per batch

Returns

An iterator-like struct that yields batches of rows.

pub async fn fetch_batch( &self, batch_reader: &mut BatchReader, ) -> Result<Option<(Vec<Row>, u32)>>

Execute a batched read query and return the next batch.

Uses (xmin, ctid) as the pagination key to correctly handle cases where many rows share the same xmin (e.g., bulk inserts in a single transaction). Without ctid tie-breaking, rows with duplicate xmin values would be skipped.

pub async fn estimate_changes( &self, schema: &str, table: &str, since_xmin: u32, ) -> Result<i64>

Get the estimated row count for changes since a given xmin.

This uses EXPLAIN to estimate without actually scanning the table.

pub async fn list_tables(&self, schema: &str) -> Result<Vec<String>>

Get list of all tables in a schema.

pub async fn get_columns( &self, schema: &str, table: &str, ) -> Result<Vec<ColumnInfo>>

Get column information for a table.

pub async fn get_primary_key( &self, schema: &str, table: &str, ) -> Result<Vec<String>>

Get primary key columns for a table.

pub async fn read_all_rows( &self, schema: &str, table: &str, columns: &[String], ) -> Result<(Vec<Row>, u32)>

Read ALL rows from a table (full sync).

This is used when xmin wraparound is detected and we need to resync the entire table to ensure data consistency.

Arguments

• schema - The schema name (e.g., “public”)
• table - The table name
• columns - Column names to select (pass empty slice to select all)

Returns

A tuple of (rows, max_xmin) where max_xmin is the highest xmin seen.

pub async fn read_changes_with_wraparound_check( &self, schema: &str, table: &str, columns: &[String], since_xmin: u32, ) -> Result<(Vec<Row>, u32, bool)>

Check for wraparound and read changes accordingly.

This is the recommended method for reading changes as it automatically handles wraparound detection and triggers full table sync when needed.

Arguments

• schema - The schema name
• table - The table name
• columns - Column names to select
• since_xmin - The last synced xmin value

Returns

A tuple of (rows, max_xmin, was_full_sync) where was_full_sync indicates if a full table sync was performed due to wraparound.