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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use parameter::IndexedParameters;
use parameter::NamedParameter;
use parameter::NamedParameters;
use parameter::QueuedParameters;
use proto::ProtoIndexedParameters;
use proto::ProtoNamedParameter;
use proto::ProtoNamedParameters;
use proto::ProtoQueuedIndexedParameters;
use proto::ProtoQueuedNamedParameters;
use proto::ProtoQueuedParameters;
use proto::ProtoQueuedParameters_oneof_queued_parameters;
use proto::ProtoValue;

impl From<QueuedParameters> for ProtoQueuedParameters {
    fn from(queued_parameters: QueuedParameters) -> Self {
        let mut proto_query_request = ProtoQueuedParameters::new();
        match queued_parameters {
            QueuedParameters::Indexed(indexed) =>
                proto_query_request.set_queued_indexed_parameters(indexed.into()),
            QueuedParameters::Named(named) =>
                proto_query_request.set_queued_named_parameters(named.into()),
        }
        proto_query_request
    }
}

impl From<ProtoQueuedParameters> for QueuedParameters {
    fn from(proto_queued_parameters: ProtoQueuedParameters) -> Self {
        match proto_queued_parameters.queued_parameters.unwrap() {
            ProtoQueuedParameters_oneof_queued_parameters::queued_indexed_parameters(
                proto_queued_indexed_parameters
            ) => {
                QueuedParameters::Indexed(proto_queued_indexed_parameters.into())
            }
            ProtoQueuedParameters_oneof_queued_parameters::queued_named_parameters(
                proto_queued_named_parameters
            ) => {
                QueuedParameters::Named(proto_queued_named_parameters.into())
            }
        }
    }
}


impl From<Vec<IndexedParameters>> for ProtoQueuedIndexedParameters {
    fn from(vec_indexed_parameters: Vec<IndexedParameters>) -> Self {
        let mut proto_queued_indexed_parameters = ProtoQueuedIndexedParameters::new();
        let vec_proto_indexed_parameters: Vec<ProtoIndexedParameters> =
            vec_indexed_parameters.into_iter().map(Into::into).collect();
        proto_queued_indexed_parameters.set_queued_indexed_parameters(vec_proto_indexed_parameters.into());
        proto_queued_indexed_parameters
    }
}

impl From<ProtoQueuedIndexedParameters> for Vec<IndexedParameters> {
    fn from(mut proto_queued_indexed_parameters: ProtoQueuedIndexedParameters) -> Self {
        proto_queued_indexed_parameters
            .take_queued_indexed_parameters()
            .into_vec()
            .into_iter()
            .map(Into::into)
            .collect()
    }
}

impl From<Vec<NamedParameters>> for ProtoQueuedNamedParameters {
    fn from(vec_named_parameters: Vec<NamedParameters>) -> Self {
        let mut proto_queued_named_parameters = ProtoQueuedNamedParameters::new();
        let vec_proto_named_parameters: Vec<ProtoNamedParameters> =
            vec_named_parameters.into_iter().map(Into::into).collect();
        proto_queued_named_parameters.set_queued_named_parameters(vec_proto_named_parameters.into());
        proto_queued_named_parameters
    }
}

impl From<ProtoQueuedNamedParameters> for Vec<NamedParameters> {
    fn from(mut proto_queued_named_parameters: ProtoQueuedNamedParameters) -> Self {
        proto_queued_named_parameters
            .take_queued_named_parameters()
            .into_vec()
            .into_iter()
            .map(Into::into)
            .collect()
    }
}

impl From<IndexedParameters> for ProtoIndexedParameters {
    fn from(indexed_parameters: IndexedParameters) -> Self {
        let mut proto_indexed_parameters = ProtoIndexedParameters::new();
        let vec_proto_value: Vec<ProtoValue> =
            indexed_parameters.parameters.into_iter().map(Into::into).collect();
        proto_indexed_parameters.set_parameters(vec_proto_value.into());
        proto_indexed_parameters
    }
}

impl From<ProtoIndexedParameters> for IndexedParameters {
    fn from(mut proto_indexed_parameters: ProtoIndexedParameters) -> Self {
        IndexedParameters {
            parameters: proto_indexed_parameters
                .take_parameters()
                .into_vec()
                .into_iter()
                .map(Into::into)
                .collect(),
        }
    }
}

impl From<NamedParameters> for ProtoNamedParameters {
    fn from(named_parameters: NamedParameters) -> Self {
        let mut proto_named_parameters = ProtoNamedParameters::new();
        let vec_proto_named_parameter: Vec<ProtoNamedParameter> =
            named_parameters.parameters.into_iter().map(Into::into).collect();
        proto_named_parameters.set_parameters(vec_proto_named_parameter.into());
        proto_named_parameters
    }
}

impl From<ProtoNamedParameters> for NamedParameters {
    fn from(mut proto_named_parameters: ProtoNamedParameters) -> Self {
        NamedParameters {
            parameters: proto_named_parameters
                .take_parameters()
                .into_vec()
                .into_iter()
                .map(Into::into)
                .collect(),
        }
    }
}

impl From<NamedParameter> for ProtoNamedParameter {
    fn from(named_parameter: NamedParameter) -> Self {
        let mut proto_named_parameter = ProtoNamedParameter::new();
        proto_named_parameter.set_name(named_parameter.name);
        proto_named_parameter.set_value(named_parameter.value.into());
        proto_named_parameter
    }
}

impl From<ProtoNamedParameter> for NamedParameter {
    fn from(mut proto_named_parameter: ProtoNamedParameter) -> Self {
        NamedParameter {
            name: proto_named_parameter.take_name(),
            value: proto_named_parameter.take_value().into(),
        }
    }
}