1
package tombstone
2

3
import (
4
    "sync"
5
    "time"
6
)
7

8
// Entry 存储条目，支持墓碑标记
9
type Entry struct {
10
    Value     string
11
    Deleted   bool
12
    Timestamp int64
13
}
14

15
// TombstoneStore 带墓碑删除的键值存储
16
type TombstoneStore struct {
17
    mu              sync.RWMutex
18
    store           map[string]*Entry
19
    tombstoneCount  int
20
}
21

22
func NewTombstoneStore() *TombstoneStore {
23
    return &TombstoneStore{
24
        store: make(map[string]*Entry),
25
    }
26
}
27

28
// Put 写入键值对
29
func (s *TombstoneStore) Put(key, value string) {
30
    s.mu.Lock()
31
    defer s.mu.Unlock()
32
    s.store[key] = &Entry{
33
        Value:     value,
34
        Deleted:   false,
35
        Timestamp: time.Now().UnixMilli(),
36
    }
37
}
38

39
// Get 读取值，墓碑标记的条目视为不存在
40
func (s *TombstoneStore) Get(key string) (string, bool) {
41
    s.mu.RLock()
42
    defer s.mu.RUnlock()
43
    entry, ok := s.store[key]
44
    if !ok || entry.Deleted {
45
        return "", false
46
    }
47
    return entry.Value, true
48
}
49

50
// Delete 墓碑删除：标记而非物理删除
51
func (s *TombstoneStore) Delete(key string) bool {
52
    s.mu.Lock()
53
    defer s.mu.Unlock()
54
    entry, ok := s.store[key]
55
    if !ok || entry.Deleted {
56
        return false
57
    }
58
    entry.Deleted = true
59
    entry.Value = ""       // 释放值引用
60
    entry.Timestamp = time.Now().UnixMilli()
61
    s.tombstoneCount++
62
    return true
63
}
64

65
// Compact 压缩：物理删除过期的墓碑
66
func (s *TombstoneStore) Compact(maxAgeMs int64) int {
67
    s.mu.Lock()
68
    defer s.mu.Unlock()
69
    cutoff := time.Now().UnixMilli() - maxAgeMs
70
    removed := 0
71
    for key, entry := range s.store {
72
        if entry.Deleted && entry.Timestamp < cutoff {
73
            delete(s.store, key)
74
            removed++
75
            s.tombstoneCount--
76
        }
77
    }
78
    return removed
79
}
80

81
// Size 返回活跃条目数量（不含墓碑）
82
func (s *TombstoneStore) Size() int {
83
    s.mu.RLock()
84
    defer s.mu.RUnlock()
85
    count := 0
86
    for _, entry := range s.store {
87
        if !entry.Deleted {
88
            count++
89
        }
90
    }
91
    return count
92
}
93

94
// PendingTombstones 返回待压缩的墓碑数量
95
func (s *TombstoneStore) PendingTombstones() int {
96
    s.mu.RLock()
97
    defer s.mu.RUnlock()
98
    return s.tombstoneCount
99
}

1
interface Entry<V> {
2
  value: V | null;
3
  deleted: boolean;
4
  timestamp: number;
5
}
6

7
class TombstoneStore<V> {
8
  private store = new Map<string, Entry<V>>();
9
  private tombstoneCount = 0;
10

11
  // 写入键值对
12
  put(key: string, value: V): void {
13
    this.store.set(key, {
14
      value,
15
      deleted: false,
16
      timestamp: Date.now(),
17
    });
18
  }
19

20
  // 读取：墓碑标记的条目视为不存在
21
  get(key: string): V | undefined {
22
    const entry = this.store.get(key);
23
    if (!entry || entry.deleted) return undefined;
24
    return entry.value!;
25
  }
26

27
  // 墓碑删除：标记而非物理删除
28
  delete(key: string): boolean {
29
    const entry = this.store.get(key);
30
    if (!entry || entry.deleted) return false;
31
    entry.deleted = true;
32
    entry.value = null;
33
    entry.timestamp = Date.now();
34
    this.tombstoneCount++;
35
    return true;
36
  }
37

38
  // 压缩：物理删除过期的墓碑
39
  compact(maxAge: number): number {
40
    const cutoff = Date.now() - maxAge;
41
    let removed = 0;
42
    for (const [key, entry] of this.store) {
43
      if (entry.deleted && entry.timestamp < cutoff) {
44
        this.store.delete(key);
45
        removed++;
46
        this.tombstoneCount--;
47
      }
48
    }
49
    return removed;
50
  }
51

52
  get size(): number {
53
    let count = 0;
54
    for (const entry of this.store.values()) {
55
      if (!entry.deleted) count++;
56
    }
57
    return count;
58
  }
59

60
  get pendingTombstones(): number {
61
    return this.tombstoneCount;
62
  }
63
}