ironwal 0.6.3

A high performance, high durability, deterministic Write-Ahead Log (WAL) for reliable systems of record.
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

mod common;
use common::TestEnv;
use ironwal::WalOptions;

fn segment_filename(id: u64) -> String {
  format!("{:020}.wal", id)
}

#[test]
fn test_basic_truncation() {
  let mut opts = WalOptions::default();
  // STRATEGY: Rotate based on COUNT, not size.
  // This ensures deterministic boundaries regardless of header overhead.
  opts.max_segment_size = u64::MAX;
  opts.max_entries_per_segment = 10;

  let env = TestEnv::new(opts);
  let stream = "truncate_basic";

  // Create 3 segments:
  // Seg 0:  IDs 0..9   (10 items)
  // Seg 10: IDs 10..19 (10 items)
  // Seg 20: IDs 20..29 (10 items) -> Active
  for _ in 0..30 {
    env.wal.append(stream, &[0u8; 100]).unwrap();
  }

  let stream_dir = env.root.join(stream);

  // Verify pre-conditions
  assert!(stream_dir.join(segment_filename(0)).exists());
  assert!(stream_dir.join(segment_filename(10)).exists());
  assert!(stream_dir.join(segment_filename(20)).exists());

  // Truncate(15):
  // - Record 15 lives in Seg 10 (starts at 10).
  // - We must KEEP Seg 10.
  // - We delete everything BEFORE Seg 10 (i.e., Seg 0).
  let deleted = env.wal.truncate(stream, 15).unwrap();

  // Expectation: Delete exactly 1 segment (Seg 0).
  assert_eq!(deleted, 1, "Should delete exactly 1 segment (Start ID 0)");

  // Verify file 00...00.wal is gone
  let seg0 = stream_dir.join(segment_filename(0));
  assert!(!seg0.exists(), "Segment 0 should be deleted");

  // Verify file 00...10.wal exists
  let seg10 = stream_dir.join(segment_filename(10));
  assert!(seg10.exists(), "Segment 10 must exist");

  // Verify we can still read from Seg 10
  let val = env.wal.get(stream, 10).unwrap();
  assert!(val.is_some(), "Should be able to read preserved data");

  // Verify we CANNOT read from Seg 0 (it's gone)
  let val_old = env.wal.get(stream, 0).unwrap();
  assert!(val_old.is_none(), "Deleted data should be inaccessible");
}

#[test]
fn test_truncate_active_safety() {
  let mut opts = WalOptions::default();
  opts.max_segment_size = u64::MAX;
  opts.max_entries_per_segment = 10;

  let env = TestEnv::new(opts);
  let stream = "truncate_safety";

  // Create 2 segments:
  // Seg 0: IDs 0..9
  // Seg 10: IDs 10..14 (Active)
  for _ in 0..15 {
    env.wal.append(stream, &[0u8; 100]).unwrap();
  }

  // Truncate up to ID 100 (Way past head).
  let deleted = env.wal.truncate(stream, 100).unwrap();

  assert_eq!(deleted, 1, "Should delete old segment but preserve active one");

  // Verify we can still write
  env.wal.append(stream, b"new_data").unwrap();
}

#[test]
fn test_index_rebuild_after_truncate() {
  let mut opts = WalOptions::default();
  opts.max_segment_size = u64::MAX;
  opts.max_entries_per_segment = 10;

  let env = TestEnv::new(opts);
  let stream = "truncate_index";

  for _ in 0..30 {
    env.wal.append(stream, &[0u8; 100]).unwrap();
  }

  // Truncate
  env.wal.truncate(stream, 15).unwrap();

  // RESTART the WAL to verify index on disk is correct

  // Destructure env to drop the old WAL (releasing locks) BUT keep _dir alive.
  // If we just `drop(env)`, the TempDir is dropped and the files are deleted.
  let common::TestEnv {
    wal: old_wal,
    _dir,
    root,
  } = env;
  drop(old_wal);

  let wal = ironwal::Wal::new(ironwal::WalOptions::new(root)).unwrap();

  // We kept Seg 10 (ID 10..19) and Seg 20 (ID 20..29)
  // We should be able to read ID 20.
  let val = wal.get(stream, 20).unwrap();
  assert!(val.is_some());
}