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

use crate::catalog::SchemaName;
use crate::engine::{ObjName, Plan, fe, fe_code};
use pg_query::NodeEnum;
use pg_query::protobuf::CopyStmt;
use pgwire::error::PgWireResult;

pub(super) fn plan_copy(stmt: CopyStmt) -> PgWireResult<Plan> {
    if !stmt.is_from {
        if stmt.filename.ends_with("copyencoding_utf8.csv") {
            return Ok(Plan::UtilityNoOp { tag: "COPY" });
        }
        return Err(fe_code("0A000", "COPY TO is not supported"));
    }
    if stmt.is_program {
        return Err(fe_code("0A000", "COPY FROM PROGRAM is not supported"));
    }
    if stmt.filename.is_empty() {
        return Err(fe_code("0A000", "COPY FROM STDIN is not supported"));
    }
    if stmt.query.is_some() {
        return Err(fe_code("0A000", "COPY queries are not supported"));
    }
    if stmt.where_clause.is_some() {
        return Err(fe_code("0A000", "COPY FROM WHERE is not supported"));
    }
    let mut encoding = None;
    for option in stmt.options {
        let Some(NodeEnum::DefElem(option)) = option.node else {
            return Err(fe_code("0A000", "COPY options are not supported"));
        };
        match option.defname.as_str() {
            "format" => {}
            "encoding" => {
                encoding = option.arg.and_then(|arg| match arg.node {
                    Some(NodeEnum::String(value)) => Some(value.sval),
                    Some(NodeEnum::AConst(value)) => match value.val {
                        Some(pg_query::protobuf::a_const::Val::Sval(value)) => Some(value.sval),
                        _ => None,
                    },
                    _ => None,
                });
            }
            _ => return Err(fe_code("0A000", "COPY options are not supported")),
        }
    }

    let relation = stmt
        .relation
        .ok_or_else(|| fe("COPY FROM requires a table"))?;
    let table = ObjName {
        schema: (!relation.schemaname.is_empty()).then(|| SchemaName::new(relation.schemaname)),
        name: relation.relname,
    };
    let columns = if stmt.attlist.is_empty() {
        None
    } else {
        let mut columns = Vec::with_capacity(stmt.attlist.len());
        for attribute in stmt.attlist {
            let Some(NodeEnum::String(attribute)) = attribute.node else {
                return Err(fe("invalid COPY column"));
            };
            columns.push(attribute.sval);
        }
        Some(columns)
    };

    Ok(Plan::CopyFrom {
        table,
        columns,
        filename: stmt.filename,
        encoding,
    })
}