/home/noah/src/ruchy/src/runtime/transaction.rs

Source
//! Transactional state management for REPL evaluation
//!
//! Provides atomic evaluation with rollback capability for safe experimentation.

use anyhow::{Result, anyhow};
use std::collections::HashMap;
use std::time::{Duration, Instant};

use crate::runtime::repl::Value;
use crate::runtime::safe_arena::{TransactionalArena, SafeArena as Arena};

// ============================================================================
// Transactional REPL State
// ============================================================================

/// Transaction ID for tracking evaluation transactions
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct TransactionId(pub u64);

/// Transactional wrapper for REPL state with O(1) checkpoint/rollback
pub struct TransactionalState {
    /// Current bindings
    bindings: HashMap<String, Value>,
    /// Binding mutability tracking
    binding_mutability: HashMap<String, bool>,
    /// Transaction stack
    transactions: Vec<Transaction>,
    /// Next transaction ID
    next_tx_id: u64,
    /// Arena for memory allocation
    arena: TransactionalArena,
    /// Maximum transaction depth
    max_depth: usize,
}

/// A single transaction in the stack
#[derive(Debug, Clone)]
struct Transaction {
    id: TransactionId,
    /// Snapshot of bindings at transaction start
    bindings_snapshot: HashMap<String, Value>,
    /// Snapshot of mutability at transaction start
    mutability_snapshot: HashMap<String, bool>,
    /// Arena checkpoint
    arena_checkpoint: usize,
    /// Start time for timeout tracking
    start_time: Instant,
    /// Transaction metadata
    metadata: TransactionMetadata,
}

/// Metadata about a transaction
#[derive(Debug, Clone)]
pub struct TransactionMetadata {
    /// Description of the transaction
    pub description: String,
    /// Memory limit for this transaction
    pub memory_limit: Option<usize>,
    /// Time limit for this transaction
    pub time_limit: Option<Duration>,
    /// Whether this is a speculative evaluation
    pub speculative: bool,
}

impl Default for TransactionMetadata {
    fn default() -> Self {
        Self {
            description: "evaluation".to_string(),
            memory_limit: None,
            time_limit: None,
            speculative: false,
        }
    }
}

impl TransactionalState {
    /// Create a new transactional state with the given memory limit
    pub fn new(max_memory: usize) -> Self {
        Self {
            bindings: HashMap::new(),
            binding_mutability: HashMap::new(),
            transactions: Vec::new(),
            next_tx_id: 1,
            arena: TransactionalArena::new(max_memory),
            max_depth: 100, // Prevent unbounded nesting
        }
    }
    
    /// Begin a new transaction
    pub fn begin_transaction(&mut self, metadata: TransactionMetadata) -> Result<TransactionId> {
        if self.transactions.len() >= self.max_depth {
            return Err(anyhow!("Transaction depth limit exceeded"));
        }
        
        let id = TransactionId(self.next_tx_id);
        self.next_tx_id += 1;
        
        // Create checkpoint in arena
        let arena_checkpoint = self.arena.checkpoint();
        
        // Create transaction with current state snapshot
        let transaction = Transaction {
            id,
            bindings_snapshot: self.bindings.clone(),
            mutability_snapshot: self.binding_mutability.clone(),
            arena_checkpoint,
            start_time: Instant::now(),
            metadata,
        };
        
        self.transactions.push(transaction);
        Ok(id)
    }
    
    /// Commit the current transaction
    pub fn commit_transaction(&mut self, id: TransactionId) -> Result<()> {
        let tx = self.transactions.last()
            .ok_or_else(|| anyhow!("No active transaction"0))?0;
        
        if tx.id != id {
            return Err(anyhow!("Transaction ID mismatch"));
        }
        
        // Commit arena changes
        self.arena.commit()?0;
        
        // Remove transaction from stack
        self.transactions.pop();
        
        Ok(())
    }
    
    /// Rollback the current transaction
    pub fn rollback_transaction(&mut self, id: TransactionId) -> Result<()> {
        let tx = self.transactions.last()
            .ok_or_else(|| anyhow!("No active transaction"0))?0;
        
        if tx.id != id {
            return Err(anyhow!("Transaction ID mismatch"));
        }
        
        // Restore state from snapshot
        let tx = self.transactions.pop().unwrap();
        self.bindings = tx.bindings_snapshot;
        self.binding_mutability = tx.mutability_snapshot;
        
        // Rollback arena
        self.arena.rollback(tx.arena_checkpoint)?0;
        
        Ok(())
    }
    
    /// Check if a transaction has exceeded its limits
    pub fn check_transaction_limits(&self, id: TransactionId) -> Result<()> {
        let tx = self.transactions.iter()
            .find(|t| t.id == id)
            .ok_or_else(|| anyhow!("Transaction not found"))?;
        
        // Check time limit
        if let Some(time_limit) = tx.metadata.time_limit {
            if tx.start_time.elapsed() > time_limit {
                return Err(anyhow!("Transaction time limit exceeded"));
            }
        }
        
        // Check memory limit
        if let Some(memory_limit) = tx.metadata.memory_limit {
            if self.arena.arena().used() > memory_limit {
                return Err(anyhow!("Transaction memory limit exceeded"));
            }
        }
        
        Ok(())
    }
    
    /// Get current transaction depth
    pub fn depth(&self) -> usize {
        self.transactions.len()
    }
    
    /// Get current bindings
    pub fn bindings(&self) -> &HashMap<String, Value> {
        &self.bindings
    }
    
    /// Get mutable bindings
    pub fn bindings_mut(&mut self) -> &mut HashMap<String, Value> {
        &mut self.bindings
    }
    
    /// Insert a binding
    pub fn insert_binding(&mut self, name: String, value: Value, mutable: bool) {
        self.bindings.insert(name.clone(), value);
        self.binding_mutability.insert(name, mutable);
    }
    
    /// Get binding mutability
    pub fn is_mutable(&self, name: &str) -> bool {
        self.binding_mutability.get(name).copied().unwrap_or(false)
    }
    
    /// Clear all bindings
    pub fn clear(&mut self) {
        self.bindings.clear();
        self.binding_mutability.clear();
        self.transactions.clear();
        self.arena.reset();
    }
    
    /// Get arena for allocation
    pub fn arena(&self) -> &Arena {
        self.arena.arena()
    }
    
    /// Get memory usage
    pub fn memory_used(&self) -> usize {
        self.arena.arena().used()
    }
    
    // SavePoint feature temporarily disabled - requires complex lifetime management
    // /// Create a savepoint for nested transactions
    // pub fn savepoint(&mut self) -> Result<SavePoint> {
    //     let tx_id = self.begin_transaction(TransactionMetadata {
    //         description: "savepoint".to_string(),
    //         speculative: true,
    //         ..Default::default()
    //     })?;
    //     
    //     Ok(SavePoint {
    //         tx_id,
    //         state: Rc::new(RefCell::new(*self)),
    //     })
    // }
}

// ============================================================================
// SavePoint - RAII Guard for Automatic Rollback
// ============================================================================

// SavePoint temporarily disabled - requires complex lifetime management
// /// RAII guard for automatic transaction rollback
// pub struct SavePoint {
//     tx_id: TransactionId,
//     state: Rc<RefCell<TransactionalState>>,
// }

// Placeholder for SavePoint
pub struct SavePoint;

// ============================================================================
// Transaction Log for Debugging
// ============================================================================

/// Log entry for transaction events
#[derive(Debug, Clone)]
pub enum TransactionEvent {
    Begin {
        id: TransactionId,
        metadata: TransactionMetadata,
    },
    Commit {
        id: TransactionId,
        duration: Duration,
        memory_used: usize,
    },
    Rollback {
        id: TransactionId,
        reason: String,
    },
    BindingAdded {
        name: String,
        value_type: String,
    },
    BindingModified {
        name: String,
        old_type: String,
        new_type: String,
    },
}

/// Transaction log for debugging and analysis
pub struct TransactionLog {
    events: Vec<(Instant, TransactionEvent)>,
    max_entries: usize,
}

impl TransactionLog {
    pub fn new(max_entries: usize) -> Self {
        Self {
            events: Vec::new(),
            max_entries,
        }
    }
    
    pub fn log(&mut self, event: TransactionEvent) {
        self.events.push((Instant::now(), event));
        
        // Maintain size limit
        if self.events.len() > self.max_entries {
            self.events.remove(0);
        }
    }
    
    pub fn recent_events(&self, count: usize) -> &[(Instant, TransactionEvent)] {
        let start = self.events.len().saturating_sub(count);
        &self.events[start..]
    }
    
    pub fn clear(&mut self) {
        self.events.clear();
    }
}

// ============================================================================
// Optimistic Concurrency Control
// ============================================================================

/// Version number for optimistic concurrency control
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct Version(u64);

/// Versioned value for optimistic concurrency
#[derive(Debug, Clone)]
pub struct VersionedValue<T> {
    pub value: T,
    pub version: Version,
}

/// Multi-version concurrency control for parallel evaluation
pub struct MVCC {
    /// Current version
    current_version: Version,
    /// Versioned bindings
    bindings: HashMap<String, Vec<VersionedValue<Value>>>,
    /// Maximum versions to keep per binding
    max_versions: usize,
}

impl MVCC {
    pub fn new() -> Self {
        Self {
            current_version: Version(0),
            bindings: HashMap::new(),
            max_versions: 10,
        }
    }
    
    /// Start a new read transaction
    pub fn begin_read(&self) -> Version {
        self.current_version
    }
    
    /// Start a new write transaction
    pub fn begin_write(&mut self) -> Version {
        self.current_version.0 += 1;
        self.current_version
    }
    
    /// Read a value at a specific version
    pub fn read(&self, name: &str, version: Version) -> Option<&Value> {
        self.bindings.get(name).and_then(|versions| {
            // Find the latest version <= requested version
            versions.iter()
                .rev()
                .find2(|v| v.version <= version)
                .map(|v| &v.value)
        })
    }
    
    /// Write a value at a specific version
    pub fn write(&mut self, name: String, value: Value, version: Version) {
        let entry = self.bindings.entry(name).or_default();
        
        // Add new version
        entry.push(VersionedValue { value, version });
        
        // Maintain version limit
        if entry.len() > self.max_versions {
            entry.remove(0);
        }
    }
    
    /// Garbage collect old versions
    pub fn gc(&mut self, keep_after: Version) {
        for versions in self.bindings.values_mut() {
            versions.retain(|v| v.version >= keep_after);
        }
    }
}

impl Default for MVCC {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_transaction_commit() {
        let mut state = TransactionalState::new(1024 * 1024);
        
        // Add initial binding
        state.insert_binding("x".to_string(), Value::Int(1), false);
        
        // Begin transaction
        let tx = state.begin_transaction(TransactionMetadata::default()).unwrap();
        
        // Modify binding
        state.insert_binding("x".to_string(), Value::Int(2), false);
        state.insert_binding("y".to_string(), Value::Int(3), false);
        
        // Commit
        state.commit_transaction(tx).unwrap();
        
        // Changes should persist
        assert_eq!(state.bindings.get("x"), Some(&Value::Int(2)));
        assert_eq!(state.bindings.get("y"), Some(&Value::Int(3)));
    }
    
    #[test]
    fn test_transaction_rollback() {
        let mut state = TransactionalState::new(1024 * 1024);
        
        // Add initial binding
        state.insert_binding("x".to_string(), Value::Int(1), false);
        
        // Begin transaction
        let tx = state.begin_transaction(TransactionMetadata::default()).unwrap();
        
        // Modify binding
        state.insert_binding("x".to_string(), Value::Int(2), false);
        state.insert_binding("y".to_string(), Value::Int(3), false);
        
        // Rollback
        state.rollback_transaction(tx).unwrap();
        
        // Changes should be reverted
        assert_eq!(state.bindings.get("x"), Some(&Value::Int(1)));
        assert_eq!(state.bindings.get("y"), None);
    }
    
    // SavePoint test disabled - feature temporarily disabled
    // #[test]
    // fn test_savepoint() {
    //     let mut state = TransactionalState::new(1024 * 1024);
    //     
    //     state.insert_binding("x".to_string(), Value::Int(1), false);
    //     
    //     {
    //         let sp = state.savepoint().unwrap();
    //         state.insert_binding("x".to_string(), Value::Int(2), false);
    //         // SavePoint dropped here, automatic rollback
    //     }
    //     
    //     // Should be rolled back
    //     assert_eq!(state.bindings.get("x"), Some(&Value::Int(1)));
    // }
    
    #[test]
    fn test_mvcc() {
        let mut mvcc = MVCC::new();
        
        let v1 = mvcc.begin_write();
        mvcc.write("x".to_string(), Value::Int(1), v1);
        
        let v2 = mvcc.begin_write();
        mvcc.write("x".to_string(), Value::Int(2), v2);
        
        // Read at different versions
        assert_eq!(mvcc.read("x", v1), Some(&Value::Int(1)));
        assert_eq!(mvcc.read("x", v2), Some(&Value::Int(2)));
    }
}

Coverage Report

Created: 2025-09-05 15:26

Line	Count	Source
1		//! Transactional state management for REPL evaluation
2		//!
3		//! Provides atomic evaluation with rollback capability for safe experimentation.
4
5		use anyhow::{Result, anyhow};
6		use std::collections::HashMap;
7		use std::time::{Duration, Instant};
8
9		use crate::runtime::repl::Value;
10		use crate::runtime::safe_arena::{TransactionalArena, SafeArena as Arena};
11
12		// ============================================================================
13		// Transactional REPL State
14		// ============================================================================
15
16		/// Transaction ID for tracking evaluation transactions
17		#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
18		pub struct TransactionId(pub u64);
19
20		/// Transactional wrapper for REPL state with O(1) checkpoint/rollback
21		pub struct TransactionalState {
22		/// Current bindings
23		bindings: HashMap<String, Value>,
24		/// Binding mutability tracking
25		binding_mutability: HashMap<String, bool>,
26		/// Transaction stack
27		transactions: Vec<Transaction>,
28		/// Next transaction ID
29		next_tx_id: u64,
30		/// Arena for memory allocation
31		arena: TransactionalArena,
32		/// Maximum transaction depth
33		max_depth: usize,
34		}
35
36		/// A single transaction in the stack
37		#[derive(Debug, Clone)]
38		struct Transaction {
39		id: TransactionId,
40		/// Snapshot of bindings at transaction start
41		bindings_snapshot: HashMap<String, Value>,
42		/// Snapshot of mutability at transaction start
43		mutability_snapshot: HashMap<String, bool>,
44		/// Arena checkpoint
45		arena_checkpoint: usize,
46		/// Start time for timeout tracking
47		start_time: Instant,
48		/// Transaction metadata
49		metadata: TransactionMetadata,
50		}
51
52		/// Metadata about a transaction
53		#[derive(Debug, Clone)]
54		pub struct TransactionMetadata {
55		/// Description of the transaction
56		pub description: String,
57		/// Memory limit for this transaction
58		pub memory_limit: Option<usize>,
59		/// Time limit for this transaction
60		pub time_limit: Option<Duration>,
61		/// Whether this is a speculative evaluation
62		pub speculative: bool,
63		}
64
65		impl Default for TransactionMetadata {
66	2	fn default() -> Self {
67	2	Self {
68	2	description: "evaluation".to_string(),
69	2	memory_limit: None,
70	2	time_limit: None,
71	2	speculative: false,
72	2	}
73	2	}
74		}
75
76		impl TransactionalState {
77		/// Create a new transactional state with the given memory limit
78	26	pub fn new(max_memory: usize) -> Self {
79	26	Self {
80	26	bindings: HashMap::new(),
81	26	binding_mutability: HashMap::new(),
82	26	transactions: Vec::new(),
83	26	next_tx_id: 1,
84	26	arena: TransactionalArena::new(max_memory),
85	26	max_depth: 100, // Prevent unbounded nesting
86	26	}
87	26	}
88
89		/// Begin a new transaction
90	2	pub fn begin_transaction(&mut self, metadata: TransactionMetadata) -> Result<TransactionId> {
91	2	if self.transactions.len() >= self.max_depth {
92	0	return Err(anyhow!("Transaction depth limit exceeded"));
93	2	}
94
95	2	let id = TransactionId(self.next_tx_id);
96	2	self.next_tx_id += 1;
97
98		// Create checkpoint in arena
99	2	let arena_checkpoint = self.arena.checkpoint();
100
101		// Create transaction with current state snapshot
102	2	let transaction = Transaction {
103	2	id,
104	2	bindings_snapshot: self.bindings.clone(),
105	2	mutability_snapshot: self.binding_mutability.clone(),
106	2	arena_checkpoint,
107	2	start_time: Instant::now(),
108	2	metadata,
109	2	};
110
111	2	self.transactions.push(transaction);
112	2	Ok(id)
113	2	}
114
115		/// Commit the current transaction
116	1	pub fn commit_transaction(&mut self, id: TransactionId) -> Result<()> {
117	1	let tx = self.transactions.last()
118	1	.ok_or_else(\|\| anyhow!( "No active transaction"0 )) ?0 ;
119
120	1	if tx.id != id {
121	0	return Err(anyhow!("Transaction ID mismatch"));
122	1	}
123
124		// Commit arena changes
125	1	self.arena.commit() ?0 ;
126
127		// Remove transaction from stack
128	1	self.transactions.pop();
129
130	1	Ok(())
131	1	}
132
133		/// Rollback the current transaction
134	1	pub fn rollback_transaction(&mut self, id: TransactionId) -> Result<()> {
135	1	let tx = self.transactions.last()
136	1	.ok_or_else(\|\| anyhow!( "No active transaction"0 )) ?0 ;
137
138	1	if tx.id != id {
139	0	return Err(anyhow!("Transaction ID mismatch"));
140	1	}
141
142		// Restore state from snapshot
143	1	let tx = self.transactions.pop().unwrap();
144	1	self.bindings = tx.bindings_snapshot;
145	1	self.binding_mutability = tx.mutability_snapshot;
146
147		// Rollback arena
148	1	self.arena.rollback(tx.arena_checkpoint) ?0 ;
149
150	1	Ok(())
151	1	}
152
153		/// Check if a transaction has exceeded its limits
154	0	pub fn check_transaction_limits(&self, id: TransactionId) -> Result<()> {
155	0	let tx = self.transactions.iter()
156	0	.find(\|t\| t.id == id)
157	0	.ok_or_else(\|\| anyhow!("Transaction not found"))?;
158
159		// Check time limit
160	0	if let Some(time_limit) = tx.metadata.time_limit {
161	0	if tx.start_time.elapsed() > time_limit {
162	0	return Err(anyhow!("Transaction time limit exceeded"));
163	0	}
164	0	}
165
166		// Check memory limit
167	0	if let Some(memory_limit) = tx.metadata.memory_limit {
168	0	if self.arena.arena().used() > memory_limit {
169	0	return Err(anyhow!("Transaction memory limit exceeded"));
170	0	}
171	0	}
172
173	0	Ok(())
174	0	}
175
176		/// Get current transaction depth
177	0	pub fn depth(&self) -> usize {
178	0	self.transactions.len()
179	0	}
180
181		/// Get current bindings
182	0	pub fn bindings(&self) -> &HashMap<String, Value> {
183	0	&self.bindings
184	0	}
185
186		/// Get mutable bindings
187	0	pub fn bindings_mut(&mut self) -> &mut HashMap<String, Value> {
188	0	&mut self.bindings
189	0	}
190
191		/// Insert a binding
192	6	pub fn insert_binding(&mut self, name: String, value: Value, mutable: bool) {
193	6	self.bindings.insert(name.clone(), value);
194	6	self.binding_mutability.insert(name, mutable);
195	6	}
196
197		/// Get binding mutability
198	0	pub fn is_mutable(&self, name: &str) -> bool {
199	0	self.binding_mutability.get(name).copied().unwrap_or(false)
200	0	}
201
202		/// Clear all bindings
203	0	pub fn clear(&mut self) {
204	0	self.bindings.clear();
205	0	self.binding_mutability.clear();
206	0	self.transactions.clear();
207	0	self.arena.reset();
208	0	}
209
210		/// Get arena for allocation
211	0	pub fn arena(&self) -> &Arena {
212	0	self.arena.arena()
213	0	}
214
215		/// Get memory usage
216	0	pub fn memory_used(&self) -> usize {
217	0	self.arena.arena().used()
218	0	}
219
220		// SavePoint feature temporarily disabled - requires complex lifetime management
221		// /// Create a savepoint for nested transactions
222		// pub fn savepoint(&mut self) -> Result<SavePoint> {
223		// let tx_id = self.begin_transaction(TransactionMetadata {
224		// description: "savepoint".to_string(),
225		// speculative: true,
226		// ..Default::default()
227		// })?;
228		//
229		// Ok(SavePoint {
230		// tx_id,
231		// state: Rc::new(RefCell::new(*self)),
232		// })
233		// }
234		}
235
236		// ============================================================================
237		// SavePoint - RAII Guard for Automatic Rollback
238		// ============================================================================
239
240		// SavePoint temporarily disabled - requires complex lifetime management
241		// /// RAII guard for automatic transaction rollback
242		// pub struct SavePoint {
243		// tx_id: TransactionId,
244		// state: Rc<RefCell<TransactionalState>>,
245		// }
246
247		// Placeholder for SavePoint
248		pub struct SavePoint;
249
250		// ============================================================================
251		// Transaction Log for Debugging
252		// ============================================================================
253
254		/// Log entry for transaction events
255		#[derive(Debug, Clone)]
256		pub enum TransactionEvent {
257		Begin {
258		id: TransactionId,
259		metadata: TransactionMetadata,
260		},
261		Commit {
262		id: TransactionId,
263		duration: Duration,
264		memory_used: usize,
265		},
266		Rollback {
267		id: TransactionId,
268		reason: String,
269		},
270		BindingAdded {
271		name: String,
272		value_type: String,
273		},
274		BindingModified {
275		name: String,
276		old_type: String,
277		new_type: String,
278		},
279		}
280
281		/// Transaction log for debugging and analysis
282		pub struct TransactionLog {
283		events: Vec<(Instant, TransactionEvent)>,
284		max_entries: usize,
285		}
286
287		impl TransactionLog {
288	0	pub fn new(max_entries: usize) -> Self {
289	0	Self {
290	0	events: Vec::new(),
291	0	max_entries,
292	0	}
293	0	}
294
295	0	pub fn log(&mut self, event: TransactionEvent) {
296	0	self.events.push((Instant::now(), event));
297
298		// Maintain size limit
299	0	if self.events.len() > self.max_entries {
300	0	self.events.remove(0);
301	0	}
302	0	}
303
304	0	pub fn recent_events(&self, count: usize) -> &[(Instant, TransactionEvent)] {
305	0	let start = self.events.len().saturating_sub(count);
306	0	&self.events[start..]
307	0	}
308
309	0	pub fn clear(&mut self) {
310	0	self.events.clear();
311	0	}
312		}
313
314		// ============================================================================
315		// Optimistic Concurrency Control
316		// ============================================================================
317
318		/// Version number for optimistic concurrency control
319		#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
320		pub struct Version(u64);
321
322		/// Versioned value for optimistic concurrency
323		#[derive(Debug, Clone)]
324		pub struct VersionedValue<T> {
325		pub value: T,
326		pub version: Version,
327		}
328
329		/// Multi-version concurrency control for parallel evaluation
330		pub struct MVCC {
331		/// Current version
332		current_version: Version,
333		/// Versioned bindings
334		bindings: HashMap<String, Vec<VersionedValue<Value>>>,
335		/// Maximum versions to keep per binding
336		max_versions: usize,
337		}
338
339		impl MVCC {
340	1	pub fn new() -> Self {
341	1	Self {
342	1	current_version: Version(0),
343	1	bindings: HashMap::new(),
344	1	max_versions: 10,
345	1	}
346	1	}
347
348		/// Start a new read transaction
349	0	pub fn begin_read(&self) -> Version {
350	0	self.current_version
351	0	}
352
353		/// Start a new write transaction
354	2	pub fn begin_write(&mut self) -> Version {
355	2	self.current_version.0 += 1;
356	2	self.current_version
357	2	}
358
359		/// Read a value at a specific version
360	2	pub fn read(&self, name: &str, version: Version) -> Option<&Value> {
361	2	self.bindings.get(name).and_then(\|versions\| {
362		// Find the latest version <= requested version
363	2	versions.iter()
364	2	.rev()
365	3	. find2 (\|v\| v.version <= version)
366	2	.map(\|v\| &v.value)
367	2	})
368	2	}
369
370		/// Write a value at a specific version
371	2	pub fn write(&mut self, name: String, value: Value, version: Version) {
372	2	let entry = self.bindings.entry(name).or_default();
373
374		// Add new version
375	2	entry.push(VersionedValue { value, version });
376
377		// Maintain version limit
378	2	if entry.len() > self.max_versions {
379	0	entry.remove(0);
380	2	}
381	2	}
382
383		/// Garbage collect old versions
384	0	pub fn gc(&mut self, keep_after: Version) {
385	0	for versions in self.bindings.values_mut() {
386	0	versions.retain(\|v\| v.version >= keep_after);
387		}
388	0	}
389		}
390
391		impl Default for MVCC {
392	0	fn default() -> Self {
393	0	Self::new()
394	0	}
395		}
396
397		#[cfg(test)]
398		mod tests {
399		use super::*;
400
401		#[test]
402	1	fn test_transaction_commit() {
403	1	let mut state = TransactionalState::new(1024 * 1024);
404
405		// Add initial binding
406	1	state.insert_binding("x".to_string(), Value::Int(1), false);
407
408		// Begin transaction
409	1	let tx = state.begin_transaction(TransactionMetadata::default()).unwrap();
410
411		// Modify binding
412	1	state.insert_binding("x".to_string(), Value::Int(2), false);
413	1	state.insert_binding("y".to_string(), Value::Int(3), false);
414
415		// Commit
416	1	state.commit_transaction(tx).unwrap();
417
418		// Changes should persist
419	1	assert_eq!(state.bindings.get("x"), Some(&Value::Int(2)));
420	1	assert_eq!(state.bindings.get("y"), Some(&Value::Int(3)));
421	1	}
422
423		#[test]
424	1	fn test_transaction_rollback() {
425	1	let mut state = TransactionalState::new(1024 * 1024);
426
427		// Add initial binding
428	1	state.insert_binding("x".to_string(), Value::Int(1), false);
429
430		// Begin transaction
431	1	let tx = state.begin_transaction(TransactionMetadata::default()).unwrap();
432
433		// Modify binding
434	1	state.insert_binding("x".to_string(), Value::Int(2), false);
435	1	state.insert_binding("y".to_string(), Value::Int(3), false);
436
437		// Rollback
438	1	state.rollback_transaction(tx).unwrap();
439
440		// Changes should be reverted
441	1	assert_eq!(state.bindings.get("x"), Some(&Value::Int(1)));
442	1	assert_eq!(state.bindings.get("y"), None);
443	1	}
444
445		// SavePoint test disabled - feature temporarily disabled
446		// #[test]
447		// fn test_savepoint() {
448		// let mut state = TransactionalState::new(1024 * 1024);
449		//
450		// state.insert_binding("x".to_string(), Value::Int(1), false);
451		//
452		// {
453		// let sp = state.savepoint().unwrap();
454		// state.insert_binding("x".to_string(), Value::Int(2), false);
455		// // SavePoint dropped here, automatic rollback
456		// }
457		//
458		// // Should be rolled back
459		// assert_eq!(state.bindings.get("x"), Some(&Value::Int(1)));
460		// }
461
462		#[test]
463	1	fn test_mvcc() {
464	1	let mut mvcc = MVCC::new();
465
466	1	let v1 = mvcc.begin_write();
467	1	mvcc.write("x".to_string(), Value::Int(1), v1);
468
469	1	let v2 = mvcc.begin_write();
470	1	mvcc.write("x".to_string(), Value::Int(2), v2);
471
472		// Read at different versions
473	1	assert_eq!(mvcc.read("x", v1), Some(&Value::Int(1)));
474	1	assert_eq!(mvcc.read("x", v2), Some(&Value::Int(2)));
475	1	}
476		}