1
type Version struct {
2
    Timestamp int
3
    Value     string
4
    Deleted   bool
5
}
6

7
type MVCCStore struct {
8
    data map[string][]Version
9
}
10

11
func NewMVCCStore() *MVCCStore {
12
    return &MVCCStore{data: make(map[string][]Version)}
13
}
14

15
func (s *MVCCStore) Put(key, value string, ts int) {
16
    s.data[key] = append(s.data[key], Version{Timestamp: ts, Value: value})
17
}
18

19
func (s *MVCCStore) Get(key string, ts int) (string, bool) {
20
    versions := s.data[key]
21
    var best *Version
22
    for i := range versions {
23
        v := &versions[i]
24
        if v.Timestamp <= ts && (best == nil || v.Timestamp > best.Timestamp) {
25
            best = v
26
        }
27
    }
28
    if best == nil || best.Deleted {
29
        return "", false
30
    }
31
    return best.Value, true
32
}
33

34
func (s *MVCCStore) Delete(key string, ts int) {
35
    s.data[key] = append(s.data[key], Version{Timestamp: ts, Deleted: true})
36
}

1
interface Version<T> {
2
  timestamp: number;
3
  value: T;
4
  deleted: boolean;
5
}
6

7
class MVCCStore<T> {
8
  private store = new Map<string, Version<T>[]>();
9

10
  put(key: string, value: T, timestamp: number): void {
11
    if (!this.store.has(key)) this.store.set(key, []);
12
    this.store.get(key)!.push({ timestamp, value, deleted: false });
13
  }
14

15
  get(key: string, timestamp: number): T | undefined {
16
    const versions = this.store.get(key);
17
    if (!versions) return undefined;
18
    let best: Version<T> | undefined;
19
    for (const v of versions) {
20
      if (v.timestamp <= timestamp && (!best || v.timestamp > best.timestamp)) {
21
        best = v;
22
      }
23
    }
24
    return best && !best.deleted ? best.value : undefined;
25
  }
26

27
  delete(key: string, timestamp: number): void {
28
    if (!this.store.has(key)) this.store.set(key, []);
29
    this.store.get(key)!.push({ timestamp, value: undefined as T, deleted: true });
30
  }
31
}