mockgres 0.0.25

An in-memory database that replicates a reasonable subset of Postgres functionality to make unit tests that rely on a database to run.
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

use std::sync::atomic::{AtomicU64, Ordering};

use dashmap::DashMap;

use crate::storage::VersionedRow;

pub type TxId = u64;
pub const SYSTEM_TXID: TxId = 0;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TxnStatus {
    InProgress,
    Committed,
    Aborted,
}

#[derive(Debug, Default)]
pub struct TransactionManager {
    next_xid: AtomicU64,
    // don't evict entries so tuple metadata never references an unknown xid
    statuses: DashMap<TxId, TxnStatus>,
}

impl TransactionManager {
    pub fn new() -> Self {
        let statuses = DashMap::new();
        statuses.insert(SYSTEM_TXID, TxnStatus::Committed);
        Self {
            next_xid: AtomicU64::new(0),
            statuses,
        }
    }

    pub fn allocate(&self) -> TxId {
        self.next_xid.fetch_add(1, Ordering::SeqCst) + 1
    }

    pub fn snapshot_xid(&self) -> TxId {
        self.next_xid.load(Ordering::SeqCst)
    }

    pub fn set_status(&self, txid: TxId, status: TxnStatus) {
        self.statuses.insert(txid, status);
    }

    pub fn status(&self, txid: TxId) -> Option<TxnStatus> {
        self.statuses.get(&txid).map(|entry| *entry)
    }

    pub fn is_committed(&self, txid: TxId) -> bool {
        if txid == SYSTEM_TXID {
            return true;
        }
        // unknown txids are considered uncommitted
        matches!(self.status(txid), Some(TxnStatus::Committed))
    }
}

pub struct VisibilityContext<'a> {
    txn_manager: &'a TransactionManager,
    pub snapshot_xid: TxId,
    pub current_tx: Option<TxId>,
}

impl<'a> VisibilityContext<'a> {
    pub fn new(
        txn_manager: &'a TransactionManager,
        snapshot_xid: TxId,
        current_tx: Option<TxId>,
    ) -> Self {
        Self {
            txn_manager,
            snapshot_xid,
            current_tx,
        }
    }

    pub fn is_visible(&self, version: &VersionedRow) -> bool {
        if let Some(current) = self.current_tx {
            if version.xmin == current {
                return true;
            }
            if version.xmax == Some(current) {
                return false;
            }
        }

        if !self.txn_manager.is_committed(version.xmin) {
            return false;
        }
        if version.xmin > self.snapshot_xid {
            return false;
        }

        if let Some(xmax) = version.xmax {
            if let Some(current) = self.current_tx
                && xmax == current
            {
                return false;
            }
            if self.txn_manager.is_committed(xmax) && xmax <= self.snapshot_xid {
                return false;
            }
        }

        true
    }
}