vantage-sql 0.9.0

Vantage extension for SQL databases (Postgres, MySQL, SQLite)
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

//! Rhai DSL golden suite: every `tests/rhai-tests/*.rhai` script against its
//! pinned `.sql` output or `.err` message, once per SQL dialect. A golden
//! that no longer matches the renderer fails here.

#[cfg(feature = "rhai")]
#[path = "common/rhai_golden.rs"]
mod golden;

#[cfg(feature = "rhai")]
fn assert_goldens(vendor: &str, eval: impl Fn(&str) -> Result<String, String>) {
    let mismatches = golden::mismatches(vendor, eval);
    assert!(mismatches.is_empty(), "{}", mismatches.join("\n\n"));
}

#[cfg(all(feature = "sqlite", feature = "rhai"))]
mod sqlite_tests {
    use vantage_sql::condition::SqliteCondition;
    use vantage_sql::rhai_engine::RhaiSelect;
    use vantage_sql::sqlite::AnySqliteType;
    use vantage_sql::sqlite::statements::SqliteSelect;
    use vantage_sql::sqlite::statements::select::join::SqliteSelectJoin;

    vantage_sql::register_engine!(
        value: AnySqliteType,
        select: SqliteSelect,
        join: SqliteSelectJoin,
        cond: SqliteCondition,
    );

    type Select = RhaiSelect<AnySqliteType, SqliteSelect, SqliteSelectJoin, SqliteCondition>;

    #[test]
    fn every_fixture_matches_its_golden() {
        super::assert_goldens("sqlite", |code| {
            __host()
                .compile(&vantage_rhai::Block::from(code))
                .and_then(|script| script.eval_as::<Select>(&vantage_rhai::Env::new()))
                .map(|select| select.inner.preview())
                .map_err(|e| e.to_string())
        });
    }
}

#[cfg(all(feature = "postgres", feature = "rhai"))]
mod postgres_tests {
    use vantage_sql::condition::PostgresCondition;
    use vantage_sql::postgres::AnyPostgresType;
    use vantage_sql::postgres::statements::PostgresSelect;
    use vantage_sql::postgres::statements::select::join::PostgresSelectJoin;
    use vantage_sql::rhai_engine::RhaiSelect;

    vantage_sql::register_engine!(
        value: AnyPostgresType,
        select: PostgresSelect,
        join: PostgresSelectJoin,
        cond: PostgresCondition,
    );

    type Select =
        RhaiSelect<AnyPostgresType, PostgresSelect, PostgresSelectJoin, PostgresCondition>;

    #[test]
    fn every_fixture_matches_its_golden() {
        super::assert_goldens("postgres", |code| {
            __host()
                .compile(&vantage_rhai::Block::from(code))
                .and_then(|script| script.eval_as::<Select>(&vantage_rhai::Env::new()))
                .map(|select| select.inner.preview())
                .map_err(|e| e.to_string())
        });
    }
}

#[cfg(all(feature = "mysql", feature = "rhai"))]
mod mysql_tests {
    use vantage_sql::condition::MysqlCondition;
    use vantage_sql::mysql::AnyMysqlType;
    use vantage_sql::mysql::statements::MysqlSelect;
    use vantage_sql::mysql::statements::select::join::MysqlSelectJoin;
    use vantage_sql::rhai_engine::RhaiSelect;

    vantage_sql::register_engine!(
        value: AnyMysqlType,
        select: MysqlSelect,
        join: MysqlSelectJoin,
        cond: MysqlCondition,
    );

    type Select = RhaiSelect<AnyMysqlType, MysqlSelect, MysqlSelectJoin, MysqlCondition>;

    #[test]
    fn every_fixture_matches_its_golden() {
        super::assert_goldens("mysql", |code| {
            __host()
                .compile(&vantage_rhai::Block::from(code))
                .and_then(|script| script.eval_as::<Select>(&vantage_rhai::Env::new()))
                .map(|select| select.inner.preview())
                .map_err(|e| e.to_string())
        });
    }
}