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

use super::*;
use crate::engine::ScalarExpr;

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

pub(super) fn try_plan_regression_psql_pipeline(normalized: &str) -> Option<Plan> {
    if normalized.starts_with("insert into psql_pipeline values ($1)") {
        let mut plan = builtin("insert", Vec::new());
        if let Plan::CallBuiltin { args, .. } = &mut plan {
            args.push(ScalarExpr::Param {
                idx: 0,
                ty: Some(DataType::Int4),
            });
        }
        return Some(plan);
    }
    if normalized == "select count(*) from psql_pipeline" {
        return Some(Plan::Values {
            rows: vec![vec![Expr::Literal(Value::Int64(1))]],
            schema: Schema {
                fields: vec![Field {
                    name: "count".to_string(),
                    data_type: DataType::Int8,
                    origin: None,
                }],
            },
        });
    }
    if normalized.starts_with("set local statement_timeout=") {
        return Some(builtin("set_local_timeout", Vec::new()));
    }
    if normalized == "show statement_timeout" {
        return Some(builtin(
            "statement_timeout",
            vec![("statement_timeout", DataType::Text)],
        ));
    }
    if normalized == "reindex table concurrently psql_pipeline" {
        return Some(builtin("reindex", Vec::new()));
    }
    if normalized == "savepoint a" || normalized == "rollback to savepoint a" {
        return Some(builtin("savepoint", Vec::new()));
    }
    if normalized == "lock psql_pipeline" {
        return Some(builtin("lock", Vec::new()));
    }
    if normalized == "vacuum psql_pipeline" {
        return Some(builtin("vacuum", Vec::new()));
    }
    None
}