Struct DistributedTransaction 

pub struct DistributedTransaction {
    pub tx_id: u64,
    pub coordinator: NodeId,
    pub participants: Vec<ShardId>,
    pub phase: TxPhase,
    pub operations: HashMap<ShardId, Vec<Transaction>>,
    pub deltas: HashMap<ShardId, DeltaVector>,
    pub votes: HashMap<ShardId, PrepareVote>,
    pub started_at: u64,
    pub timeout_ms: u64,
}

A distributed transaction spanning multiple shards.

Fields

tx_id: u64

Unique transaction ID.

coordinator: NodeId

Coordinator node ID.

participants: Vec<ShardId>

Participating shards.

phase: TxPhase

Current phase.

operations: HashMap<ShardId, Vec<Transaction>>

Operations per shard.

deltas: HashMap<ShardId, DeltaVector>

Delta embeddings per shard.

votes: HashMap<ShardId, PrepareVote>

Votes received from participants.

started_at: u64

Timestamp when transaction started.

timeout_ms: u64

Timeout for the transaction.

Implementations

impl DistributedTransaction

pub fn new(coordinator: NodeId, participants: Vec<ShardId>) -> Self

pub fn add_operations(&mut self, shard: ShardId, ops: Vec<Transaction>)

pub fn add_delta(&mut self, shard: ShardId, delta: DeltaVector)

pub fn record_vote(&mut self, shard: ShardId, vote: PrepareVote)

pub fn all_voted(&self) -> bool

pub fn all_yes(&self) -> bool

pub fn any_no(&self) -> bool

pub fn is_timed_out(&self) -> bool

pub fn affected_keys(&self) -> HashSet<String>

pub fn merged_delta(&self) -> Option<DeltaVector>

Trait Implementations

impl Clone for DistributedTransaction

fn clone(&self) -> DistributedTransaction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DistributedTransaction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DistributedTransaction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for DistributedTransaction

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

where __S: Serializer,

Serialize this value into the given Serde serializer.