reifydb-transaction 0.9.3

Transaction management and concurrency control for ReifyDB
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 ReifyDB

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct TxId(pub u32);

#[derive(Debug, Clone)]
pub enum Op {
	BeginCommand,
	BeginQuery,
	Set {
		key: String,
		value: String,
	},
	Get {
		key: String,
	},
	Remove {
		key: String,
	},
	Scan,
	Commit,
	Rollback,
}

#[derive(Debug, Clone)]
pub struct Step {
	pub tx_id: TxId,
	pub op: Op,
}

/// Step order is the interleaving under test, so it is executed exactly as written.
#[derive(Debug, Clone)]
pub struct Schedule {
	pub steps: Vec<Step>,
}

impl Schedule {
	pub fn builder() -> ScheduleBuilder {
		ScheduleBuilder {
			steps: Vec::new(),
		}
	}
}

pub struct ScheduleBuilder {
	steps: Vec<Step>,
}

impl ScheduleBuilder {
	pub fn begin(mut self, tx: u32) -> Self {
		self.steps.push(Step {
			tx_id: TxId(tx),
			op: Op::BeginCommand,
		});
		self
	}

	pub fn begin_query(mut self, tx: u32) -> Self {
		self.steps.push(Step {
			tx_id: TxId(tx),
			op: Op::BeginQuery,
		});
		self
	}

	pub fn set(mut self, tx: u32, key: &str, value: &str) -> Self {
		self.steps.push(Step {
			tx_id: TxId(tx),
			op: Op::Set {
				key: key.to_string(),
				value: value.to_string(),
			},
		});
		self
	}

	pub fn get(mut self, tx: u32, key: &str) -> Self {
		self.steps.push(Step {
			tx_id: TxId(tx),
			op: Op::Get {
				key: key.to_string(),
			},
		});
		self
	}

	pub fn remove(mut self, tx: u32, key: &str) -> Self {
		self.steps.push(Step {
			tx_id: TxId(tx),
			op: Op::Remove {
				key: key.to_string(),
			},
		});
		self
	}

	pub fn scan(mut self, tx: u32) -> Self {
		self.steps.push(Step {
			tx_id: TxId(tx),
			op: Op::Scan,
		});
		self
	}

	pub fn commit(mut self, tx: u32) -> Self {
		self.steps.push(Step {
			tx_id: TxId(tx),
			op: Op::Commit,
		});
		self
	}

	pub fn rollback(mut self, tx: u32) -> Self {
		self.steps.push(Step {
			tx_id: TxId(tx),
			op: Op::Rollback,
		});
		self
	}

	pub fn build(self) -> Schedule {
		Schedule {
			steps: self.steps,
		}
	}
}