Struct Transaction 

pub struct Transaction {
    pub transaction_id: u32,
    pub commit_timestamp: DateTime<Utc>,
    pub commit_lsn: Option<Lsn>,
    pub events: Vec<ChangeEvent>,
    pub is_final_batch: bool,
}

Represents a complete PostgreSQL transaction from BEGIN to COMMIT

A Transaction contains all the change events that occurred within a single database transaction. Workers process entire transactions atomically to ensure consistency at the destination.

When PostgreSQL streaming mode is enabled (protocol v2+), large in-progress transactions are sent in chunks between StreamStart and StreamStop messages. The final commit is signaled by StreamCommit. This struct supports both modes:

• Normal Mode: Events collected between BEGIN and COMMIT
• Streaming Mode: Events collected between StreamStart and StreamStop, with batch processing for high-performance ingestion

Both modes use batch-based processing where transactions are sent to the consumer when event count reaches batch_size. The is_final_batch flag indicates when to commit the database transaction.

Fields

transaction_id: u32

Transaction ID from PostgreSQL

commit_timestamp: DateTime<Utc>

Commit timestamp of the transaction

commit_lsn: Option<Lsn>

LSN of the commit

events: Vec<ChangeEvent>

All change events in this transaction (INSERT, UPDATE, DELETE, TRUNCATE) Events are in the order they occurred within the transaction

is_final_batch: bool

Whether this is the final batch of a transaction When true, destination should commit the database transaction When false, destination should keep the transaction open for more batches

Implementations

impl Transaction

pub fn new(transaction_id: u32, commit_timestamp: DateTime<Utc>) -> Self

Create a new transaction with the given ID and timestamp

pub fn new_batch( transaction_id: u32, commit_timestamp: DateTime<Utc>, is_final: bool, ) -> Self

Create a new transaction batch (can be used for both normal and streaming)

pub fn new_streaming( transaction_id: u32, commit_timestamp: DateTime<Utc>, is_final: bool, ) -> Self

Create a new streaming transaction batch (alias for new_batch for compatibility)

pub fn add_event(&mut self, event: ChangeEvent)

Add an event to this transaction

pub fn set_commit_lsn(&mut self, lsn: Lsn)

Set the commit LSN

pub fn event_count(&self) -> usize

Get the number of events in this transaction

pub fn is_empty(&self) -> bool

Check if this transaction is empty (no events)

pub fn set_final_batch(&mut self, is_final: bool)

Mark this as the final batch of a transaction

Trait Implementations

impl Debug for Transaction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Transaction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Transaction

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.