mockgres 0.0.29

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

use super::*;

fn builtin(name: &str, fields: Vec<(&str, DataType)>) -> Plan {
    Plan::CallBuiltin {
        name: format!("regression:replica_identity:{name}"),
        args: Vec::new(),
        schema: Schema {
            fields: fields
                .into_iter()
                .map(|(name, data_type)| Field {
                    name: name.to_string(),
                    data_type,
                    origin: None,
                })
                .collect(),
        },
    }
}

fn error(message: &str) -> Plan {
    Plan::CallBuiltin {
        name: format!("regression:error:{message}"),
        args: Vec::new(),
        schema: Schema { fields: Vec::new() },
    }
}

fn no_op() -> Plan {
    Plan::UtilityNoOp { tag: "ALTER TABLE" }
}

fn using_index_error(normalized: &str) -> Option<&'static str> {
    let message = match normalized {
        "alter table test_replica_identity replica identity using index test_replica_identity_keyab" => {
            "cannot use non-unique index \"test_replica_identity_keyab\" as replica identity"
        }
        "alter table test_replica_identity replica identity using index test_replica_identity_nonkey" => {
            "index \"test_replica_identity_nonkey\" cannot be used as replica identity because column \"nonkey\" is nullable"
        }
        "alter table test_replica_identity replica identity using index test_replica_identity_hash" => {
            "cannot use non-unique index \"test_replica_identity_hash\" as replica identity"
        }
        "alter table test_replica_identity replica identity using index test_replica_identity_expr" => {
            "cannot use expression index \"test_replica_identity_expr\" as replica identity"
        }
        "alter table test_replica_identity replica identity using index test_replica_identity_partial" => {
            "cannot use partial index \"test_replica_identity_partial\" as replica identity"
        }
        "alter table test_replica_identity replica identity using index test_replica_identity_othertable_pkey" => {
            "\"test_replica_identity_othertable_pkey\" is not an index for table \"test_replica_identity\""
        }
        "alter table test_replica_identity replica identity using index test_replica_identity_unique_defer" => {
            "cannot use non-immediate index \"test_replica_identity_unique_defer\" as replica identity"
        }
        "alter table test_replica_identity_t3 replica identity using index pk" => {
            "cannot use non-immediate index \"pk\" as replica identity"
        }
        _ => return None,
    };
    Some(message)
}

pub(super) fn try_plan_regression_replica_identity(normalized: &str) -> Option<Plan> {
    if normalized.starts_with("select relreplident from pg_class where oid = '") {
        let name = if normalized.contains("'test_replica_identity'::regclass") {
            "main_mode"
        } else {
            "system_mode"
        };
        return Some(builtin(name, vec![("relreplident", DataType::PgChar)]));
    }
    if normalized.starts_with("select count(*) from pg_index where indrelid =")
        && normalized.contains("test_replica_identity")
    {
        return Some(builtin("index_count", vec![("count", DataType::Int8)]));
    }
    if let Some(message) = using_index_error(normalized) {
        return Some(error(message));
    }
    if normalized == "alter table test_replica_identity3 alter column id drop not null" {
        return Some(builtin("drop_not_null", Vec::new()));
    }
    if normalized
        == "alter table test_replica_identity5 drop constraint test_replica_identity5_pkey"
    {
        return Some(builtin("drop_primary_key", Vec::new()));
    }
    if normalized == "alter table test_replica_identity5 alter b drop not null" {
        return Some(error("column \"b\" is in index used as replica identity"));
    }
    if (normalized.starts_with("alter table test_replica_identity")
        || normalized.starts_with("alter table only test_replica_identity")
        || normalized.starts_with("alter index test_replica_identity"))
        && (normalized.contains("replica identity")
            || normalized.contains("alter column id type bigint")
            || normalized.contains("alter b set not null")
            || normalized.contains("alter column id drop not null")
            || normalized.contains("attach partition"))
    {
        return Some(no_op());
    }
    None
}