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

use execute::BulkExecute;
use execute::Execute;
use execute::ExecuteResult;
use proto::ProtoExecuteRequest;
use proto::ProtoExecuteResponse;
use proto::ProtoExecuteResult;
use proto::ProtoBulkExecuteRequest;
use proto::ProtoBulkExecuteResponse;

impl From<Execute> for ProtoExecuteRequest {
    fn from(execute: Execute) -> Self {
        let mut proto_execute_request = ProtoExecuteRequest::new();
        proto_execute_request.set_sql(execute.sql);
        proto_execute_request.set_queued_parameters(execute.queued_parameters.into());
        proto_execute_request
    }
}

impl From<ProtoExecuteRequest> for Execute {
    fn from(mut proto_execute_request: ProtoExecuteRequest) -> Self {
        Execute {
            sql: proto_execute_request.take_sql(),
            queued_parameters: proto_execute_request.take_queued_parameters().into(),
        }
    }
}

impl From<Vec<ExecuteResult>> for ProtoExecuteResponse {
    fn from(vec_execute_result: Vec<ExecuteResult>) -> Self {
        let mut proto_execute_response = ProtoExecuteResponse::new();
        let vec_proto_execute_result: Vec<ProtoExecuteResult> =
            vec_execute_result.into_iter().map(Into::into).collect();
        proto_execute_response.set_execute_results(vec_proto_execute_result.into());
        proto_execute_response
    }
}

impl From<ProtoExecuteResponse> for Vec<ExecuteResult> {
    fn from(mut proto_execute_response: ProtoExecuteResponse) -> Self {
        proto_execute_response
            .take_execute_results()
            .into_vec()
            .into_iter()
            .map(Into::into)
            .collect()
    }
}

impl From<ExecuteResult> for ProtoExecuteResult {
    fn from(execute_result: ExecuteResult) -> Self {
        let mut proto_execute_result = ProtoExecuteResult::new();
        proto_execute_result.set_changes(execute_result.changes as u64);
        proto_execute_result
    }
}

impl From<ProtoExecuteResult> for ExecuteResult {
    fn from(proto_execute_result: ProtoExecuteResult) -> Self {
        ExecuteResult {
            changes: proto_execute_result.get_changes() as usize,
        }
    }
}


impl From<BulkExecute> for ProtoBulkExecuteRequest {
    fn from(bulk_execute: BulkExecute) -> Self {
        let mut proto_bulk_execute_request = ProtoBulkExecuteRequest::new();
        let vec_proto_execute_request: Vec<ProtoExecuteRequest> =
            bulk_execute.executes.into_iter().map(Into::into).collect();
        proto_bulk_execute_request.set_executes(vec_proto_execute_request.into());
        proto_bulk_execute_request
    }
}

impl From<ProtoBulkExecuteRequest> for BulkExecute {
    fn from(mut proto_bulk_execute_request: ProtoBulkExecuteRequest) -> Self {
        BulkExecute {
            executes: proto_bulk_execute_request
                .take_executes()
                .into_vec()
                .into_iter()
                .map(Into::into)
                .collect(),
        }
    }
}

impl From<Vec<Vec<ExecuteResult>>> for ProtoBulkExecuteResponse {
    fn from(vec_vec_execute_response: Vec<Vec<ExecuteResult>>) -> Self {
        let mut proto_bulk_execute_response = ProtoBulkExecuteResponse::new();
        let vec_proto_execute_response: Vec<ProtoExecuteResponse> =
            vec_vec_execute_response.into_iter().map(Into::into).collect();
        proto_bulk_execute_response.set_execute_responses(vec_proto_execute_response.into());
        proto_bulk_execute_response
    }
}

impl From<ProtoBulkExecuteResponse> for Vec<Vec<ExecuteResult>> {
    fn from(mut proto_bulk_execute_response: ProtoBulkExecuteResponse) -> Self {
        proto_bulk_execute_response
            .take_execute_responses()
            .into_vec()
            .into_iter()
            .map(Into::into)
            .collect()
    }
}