vantage-sql 0.5.6

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
102
103
104
105
106
107
108
109
110
111
112

//! Rhai DSL test suite
//!
//! Tests .rhai files against pinned .sql output for each database backend.

#[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>;

    fn eval_rhai_file(path: &str) -> Select {
        let code = std::fs::read_to_string(path)
            .unwrap_or_else(|e| panic!("Failed to read {}: {}", path, e));
        let engine = __create_engine();
        engine
            .eval::<Select>(&code)
            .unwrap_or_else(|e| panic!("Rhai eval failed for {}: {}", path, e))
    }

    #[test]
    fn q1_basic_query() {
        let result = eval_rhai_file("tests/rhai-tests/q1.rhai");
        let sql = result.inner.preview();
        let expected = std::fs::read_to_string("tests/rhai-tests/sqlite/q1.sql")
            .expect("Failed to read sqlite/q1.sql");
        assert_eq!(sql.trim(), expected.trim());
    }
}

#[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>;

    fn eval_rhai_file(path: &str) -> Select {
        let code = std::fs::read_to_string(path)
            .unwrap_or_else(|e| panic!("Failed to read {}: {}", path, e));
        let engine = __create_engine();
        engine
            .eval::<Select>(&code)
            .unwrap_or_else(|e| panic!("Rhai eval failed for {}: {}", path, e))
    }

    #[test]
    fn q1_basic_query() {
        let result = eval_rhai_file("tests/rhai-tests/q1.rhai");
        let sql = result.inner.preview();
        let expected = std::fs::read_to_string("tests/rhai-tests/postgres/q1.sql")
            .expect("Failed to read postgres/q1.sql");
        assert_eq!(sql.trim(), expected.trim());
    }
}

#[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>;

    fn eval_rhai_file(path: &str) -> Select {
        let code = std::fs::read_to_string(path)
            .unwrap_or_else(|e| panic!("Failed to read {}: {}", path, e));
        let engine = __create_engine();
        engine
            .eval::<Select>(&code)
            .unwrap_or_else(|e| panic!("Rhai eval failed for {}: {}", path, e))
    }

    #[test]
    fn q1_basic_query() {
        let result = eval_rhai_file("tests/rhai-tests/q1.rhai");
        let sql = result.inner.preview();
        let expected = std::fs::read_to_string("tests/rhai-tests/mysql/q1.sql")
            .expect("Failed to read mysql/q1.sql");
        assert_eq!(sql.trim(), expected.trim());
    }
}