sqlite-requests 0.0.2

Represent SQLite queries and executes as request objects
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
113
114

use sqlite_requests::query::Query;
use sqlite_requests::execute::Execute;
use sqlite_requests::query::BulkQuery;
use sqlite_requests::execute::BulkExecute;
use integration_test::indexed_test_cases;
use integration_test::named_test_cases;
use integration_test::queued_params_as_arg;
use sqlite_requests::request::SqliteRequest;
use sqlite_requests::request::SqliteResponse;
use sqlite_requests::connection::AccessConnection;
use sqlite_requests::connection::ReadOnly;
use sqlite_requests::connection::ReadWrite;
use utils::temp_db::with_single_test_db;

mod serde;
mod proto;

struct SerializationRequests {
    queries: Vec<Query>,
    executes: Vec<Execute>,
    bulk_query: BulkQuery,
    bulk_execute: BulkExecute,
}

fn serialization_requests() -> SerializationRequests {
    let query_indexed_test_cases = indexed_test_cases(
        include_str!("../../res/sql/test_query_no_param.sql"),
        include_str!("../../res/sql/test_query_indexed_param.sql"),
        include_str!("../../res/sql/test_query_indexed_params.sql"),
    );
    let query_named_test_cases = named_test_cases(
        include_str!("../../res/sql/test_query_no_param.sql"),
        include_str!("../../res/sql/test_query_named_param.sql"),
        include_str!("../../res/sql/test_query_named_params.sql"),
    );
    let execute_indexed_test_cases = indexed_test_cases(
        include_str!("../../res/sql/test_execute_no_param.sql"),
        include_str!("../../res/sql/test_execute_indexed_param.sql"),
        include_str!("../../res/sql/test_execute_indexed_params.sql"),
    );
    let execute_named_test_cases = named_test_cases(
        include_str!("../../res/sql/test_execute_no_param.sql"),
        include_str!("../../res/sql/test_execute_named_param.sql"),
        include_str!("../../res/sql/test_execute_named_params.sql"),
    );

    let queries: Vec<Query> = query_indexed_test_cases.iter()
        .map(|(sql, queued_params)| {
            let queued_params = queued_params_as_arg(queued_params);
            Query::new_indexed(sql, &queued_params).unwrap()
        })
        .chain(
            query_named_test_cases.iter().map(|(sql, queued_params)| {
                let queued_params = queued_params_as_arg(queued_params);
                Query::new_named(sql, &queued_params).unwrap()
            })
        ).collect();

    let executes: Vec<Execute> = execute_indexed_test_cases.iter()
        .map(|(sql, queued_params)| {
            let queued_params = queued_params_as_arg(queued_params);
            Execute::new_indexed(sql, &queued_params).unwrap()
        })
        .chain(
            execute_named_test_cases.iter().map(|(sql, queued_params)| {
                let queued_params = queued_params_as_arg(queued_params);
                Execute::new_named(sql, &queued_params).unwrap()
            })
        )
        .collect();

    let bulk_query = BulkQuery::new(queries.clone());
    let bulk_execute = BulkExecute::new(executes.clone());

    SerializationRequests {
        queries,
        executes,
        bulk_query,
        bulk_execute,
    }
}

fn sqlite_requests() -> Vec<SqliteRequest> {
    let SerializationRequests {
        queries,
        executes,
        bulk_query,
        bulk_execute,
    } = serialization_requests();

    let mut commands: Vec<SqliteRequest> = vec![bulk_execute.into(), bulk_query.into(), ];

    commands.extend(queries.into_iter().map(Into::into));
    commands.extend(executes.into_iter().map(Into::into));

    commands
}

fn sqlite_responses() -> Vec<SqliteResponse> {
    let commands = sqlite_requests();

    commands.iter().map(|command| {
        with_single_test_db(|mut conn_ro: AccessConnection<ReadOnly>, mut conn_rw: AccessConnection<ReadWrite>| {
            match command {
                SqliteRequest::Query(sqlite_query) => {
                    SqliteResponse::Query(conn_ro.run(sqlite_query).unwrap())
                }
                SqliteRequest::Execute(sqlite_execute) => {
                    SqliteResponse::Execute(conn_rw.run(sqlite_execute).unwrap())
                }
            }
        })
    }).collect()
}