reductstore 1.19.8

ReductStore is a time series database designed specifically for storing and managing large amounts of blob data.
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
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272

// Copyright 2021-2026 ReductSoftware UG
// Licensed under the Apache License, Version 2.0

use crate::storage::query::condition::value::Value;

impl PartialEq<Self> for Value {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Value::Bool(left), Value::Bool(right)) => left == right,
            (Value::Bool(left), Value::Int(right) | Value::Duration(right)) => {
                *left as i64 == *right
            }
            (Value::Bool(left), Value::Float(right)) => *left as i64 as f64 == *right,

            (
                Value::Int(left) | Value::Duration(left),
                Value::Int(right) | Value::Duration(right),
            ) => left == right,
            (Value::Int(left) | Value::Duration(left), Value::Bool(right)) => {
                *left == *right as i64
            }
            (Value::Int(left) | Value::Duration(left), Value::Float(right)) => {
                *left as f64 == *right
            }

            (Value::Float(left), Value::Float(right)) => left == right,
            (Value::Float(left), Value::Int(right) | Value::Duration(right)) => {
                *left == *right as f64
            }
            (Value::Float(left), Value::Bool(right)) => *left == *right as i64 as f64,

            (Value::String(left), Value::String(right)) => left == right,
            (Value::String(_), _) => false,
            (_, Value::String(_)) => false,
        }
    }
}

impl PartialOrd for Value {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        match (self, other) {
            (Value::Bool(left), Value::Bool(right)) => left.partial_cmp(right),
            (Value::Bool(left), Value::Int(right) | Value::Duration(right)) => {
                (*left as i64).partial_cmp(right)
            }
            (Value::Bool(left), Value::Float(right)) => (*left as i64 as f64).partial_cmp(right),

            (
                Value::Int(left) | Value::Duration(left),
                Value::Int(right) | Value::Duration(right),
            ) => left.partial_cmp(right),
            (Value::Int(left) | Value::Duration(left), Value::Bool(right)) => {
                left.partial_cmp(&(*right as i64))
            }
            (Value::Int(left) | Value::Duration(left), Value::Float(right)) => {
                (*left as f64).partial_cmp(right)
            }

            (Value::Float(left), Value::Float(right)) => left.partial_cmp(right),
            (Value::Float(left), Value::Int(right) | Value::Duration(right)) => {
                left.partial_cmp(&(*right as f64))
            }
            (Value::Float(left), Value::Bool(right)) => left.partial_cmp(&(*right as i64 as f64)),

            (Value::String(left), Value::String(right)) => left.partial_cmp(right),
            (Value::String(_), _) => None,
            (_, Value::String(_)) => None,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::Value;
    use rstest::rstest;
    mod partial_eq {
        use super::*;

        #[rstest]
        #[case(Value::Bool(true), Value::Bool(true), true)]
        #[case(Value::Bool(true), Value::Bool(false), false)]
        #[case(Value::Bool(false), Value::Bool(true), false)]
        #[case(Value::Bool(true), Value::Int(1), true)]
        #[case(Value::Bool(true), Value::Int(0), false)]
        #[case(Value::Bool(true), Value::Int(-1), false)]
        #[case(Value::Bool(true), Value::Float(1.0), true)]
        #[case(Value::Bool(true), Value::Float(0.0), false)]
        #[case(Value::Bool(true), Value::Float(-1.0), false)]
        #[case(Value::Bool(true), Value::String("string".to_string()), false)]
        #[case(Value::Bool(false), Value::String("string".to_string()), false)]
        #[case(Value::Bool(true), Value::String("true".to_string()), false)]
        #[case(Value::Bool(true), Value::Duration(1), true)]
        fn partial_eq_bool(#[case] left: Value, #[case] right: Value, #[case] expected: bool) {
            let result = left == right;
            assert_eq!(result, expected);
        }

        #[rstest]
        #[case(Value::Int(1), Value::Int(1), true)]
        #[case(Value::Int(1), Value::Int(-1), false)]
        #[case(Value::Int(-1), Value::Int(-1), true)]
        #[case(Value::Int(-1), Value::Int(1), false)]
        #[case(Value::Int(1), Value::Bool(true), true)]
        #[case(Value::Int(1), Value::Bool(false), false)]
        #[case(Value::Int(0), Value::Bool(true), false)]
        #[case(Value::Int(0), Value::Bool(false), true)]
        #[case(Value::Int(-1), Value::Bool(true), false)]
        #[case(Value::Int(-1), Value::Bool(false), false)]
        #[case(Value::Int(1), Value::Float(1.0), true)]
        #[case(Value::Int(1), Value::Float(0.0), false)]
        #[case(Value::Int(1), Value::Float(-1.0), false)]
        #[case(Value::Int(1), Value::String("string".to_string()), false)]
        #[case(Value::Int(-1), Value::String("string".to_string()), false)]
        #[case(Value::Int(1), Value::Duration(1), true)]
        #[case(Value::Int(-1), Value::Duration(1), false)]
        fn partial_eq_int(#[case] left: Value, #[case] right: Value, #[case] expected: bool) {
            let result = left == right;
            assert_eq!(result, expected);
        }

        #[rstest]
        #[case(Value::Float(1.0), Value::Float(1.0), true)]
        #[case(Value::Float(1.0), Value::Float(-1.0), false)]
        #[case(Value::Float(-1.0), Value::Float(-1.0), true)]
        #[case(Value::Float(-1.0), Value::Float(1.0), false)]
        #[case(Value::Float(1.0), Value::Bool(true), true)]
        #[case(Value::Float(1.0), Value::Bool(false), false)]
        #[case(Value::Float(0.0), Value::Bool(true), false)]
        #[case(Value::Float(0.0), Value::Bool(false), true)]
        #[case(Value::Float(-1.0), Value::Bool(true), false)]
        #[case(Value::Float(-1.0), Value::Bool(false), false)]
        #[case(Value::Float(1.0), Value::Int(1), true)]
        #[case(Value::Float(1.0), Value::Int(0), false)]
        #[case(Value::Float(1.0), Value::Int(-1), false)]
        #[case(Value::Float(1.0), Value::String("string".to_string()), false)]
        #[case(Value::Float(-1.0), Value::String("string".to_string()), false)]
        #[case(Value::Float(1.0), Value::Duration(1), true)]
        #[case(Value::Float(-1.0), Value::Duration(1), false)]
        fn partial_eq_float(#[case] left: Value, #[case] right: Value, #[case] expected: bool) {
            let result = left == right;
            assert_eq!(result, expected);
        }

        #[rstest]
        #[case(Value::String("a".to_string()), Value::String("a".to_string()), true)]
        #[case(Value::String("a".to_string()), Value::String("b".to_string()), false)]
        #[case(Value::String("b".to_string()), Value::String("a".to_string()), false)]
        #[case(Value::String("a".to_string()), Value::Bool(true), false)]
        #[case(Value::String("a".to_string()), Value::Bool(false), false)]
        #[case(Value::String("a".to_string()), Value::Int(1), false)]
        #[case(Value::String("a".to_string()), Value::Float(1.0), false)]
        #[case(Value::String("a".to_string()), Value::Duration(1), false)]
        fn partial_eq_string(#[case] left: Value, #[case] right: Value, #[case] expected: bool) {
            let result = left == right;
            assert_eq!(result, expected);
        }
    }

    mod partial_cmp {
        use super::*;
        use std::cmp::Ordering;

        #[rstest]
        #[case(Value::Bool(true), Value::Bool(true), Some(Ordering::Equal))]
        #[case(Value::Bool(true), Value::Bool(false), Some(Ordering::Greater))]
        #[case(Value::Bool(false), Value::Bool(true), Some(Ordering::Less))]
        #[case(Value::Bool(true), Value::Int(2), Some(Ordering::Less))]
        #[case(Value::Bool(true), Value::Int(1), Some(Ordering::Equal))]
        #[case(Value::Bool(true), Value::Int(0), Some(Ordering::Greater))]
        #[case(Value::Bool(true), Value::Int(-1), Some(Ordering::Greater))]
        #[case(Value::Bool(false), Value::Int(1), Some(Ordering::Less))]
        #[case(Value::Bool(false), Value::Int(0), Some(Ordering::Equal))]
        #[case(Value::Bool(false), Value::Int(-1), Some(Ordering::Greater))]
        #[case(Value::Bool(true), Value::Float(2.0), Some(Ordering::Less))]
        #[case(Value::Bool(true), Value::Float(1.0), Some(Ordering::Equal))]
        #[case(Value::Bool(true), Value::Float(0.0), Some(Ordering::Greater))]
        #[case(Value::Bool(true), Value::Float(-1.0), Some(Ordering::Greater))]
        #[case(Value::Bool(false), Value::Float(1.0), Some(Ordering::Less))]
        #[case(Value::Bool(false), Value::Float(0.0), Some(Ordering::Equal))]
        #[case(Value::Bool(false), Value::Float(-1.0), Some(Ordering::Greater))]
        #[case(Value::Bool(true), Value::String("string".to_string()), None)]
        #[case(Value::Bool(false), Value::String("string".to_string()), None)]
        #[case(Value::Bool(true), Value::String("true".to_string()), None)]
        #[case(Value::Bool(false), Value::String("true".to_string()), None)]
        #[case(Value::Bool(true), Value::Duration(1), Some(Ordering::Equal))]
        #[case(Value::Bool(false), Value::Duration(1), Some(Ordering::Less))]
        #[case(Value::Bool(true), Value::Duration(0), Some(Ordering::Greater))]
        fn partial_cmp_bool(
            #[case] left: Value,
            #[case] right: Value,
            #[case] expected: Option<Ordering>,
        ) {
            let result = left.partial_cmp(&right);
            assert_eq!(result, expected);
        }

        #[rstest]
        #[case(Value::Int(1), Value::Int(1), Some(Ordering::Equal))]
        #[case(Value::Int(1), Value::Int(-1), Some(Ordering::Greater))]
        #[case(Value::Int(-1), Value::Int(-1), Some(Ordering::Equal))]
        #[case(Value::Int(-1), Value::Int(1), Some(Ordering::Less))]
        #[case(Value::Int(1), Value::Bool(true), Some(Ordering::Equal))]
        #[case(Value::Int(1), Value::Bool(false), Some(Ordering::Greater))]
        #[case(Value::Int(0), Value::Bool(true), Some(Ordering::Less))]
        #[case(Value::Int(0), Value::Bool(false), Some(Ordering::Equal))]
        #[case(Value::Int(-1), Value::Bool(true), Some(Ordering::Less))]
        #[case(Value::Int(-1), Value::Bool(false), Some(Ordering::Less))]
        #[case(Value::Int(1), Value::Float(2.0), Some(Ordering::Less))]
        #[case(Value::Int(1), Value::Float(1.0), Some(Ordering::Equal))]
        #[case(Value::Int(1), Value::Float(0.0), Some(Ordering::Greater))]
        #[case(Value::Int(1), Value::Float(-1.0), Some(Ordering::Greater))]
        #[case(Value::Int(1), Value::String("string".to_string()), None)]
        #[case(Value::Int(-1), Value::String("string".to_string()), None)]
        #[case(Value::Int(1), Value::Duration(1), Some(Ordering::Equal))]
        #[case(Value::Int(-1), Value::Duration(1), Some(Ordering::Less))]
        #[case(Value::Int(1), Value::Duration(0), Some(Ordering::Greater))]
        fn partial_cmp_int(
            #[case] left: Value,
            #[case] right: Value,
            #[case] expected: Option<Ordering>,
        ) {
            let result = left.partial_cmp(&right);
            assert_eq!(result, expected);
        }

        #[rstest]
        #[case(Value::Float(1.0), Value::Float(1.0), Some(Ordering::Equal))]
        #[case(Value::Float(1.0), Value::Float(-1.0), Some(Ordering::Greater))]
        #[case(Value::Float(-1.0), Value::Float(-1.0), Some(Ordering::Equal))]
        #[case(Value::Float(-1.0), Value::Float(1.0), Some(Ordering::Less))]
        #[case(Value::Float(1.0), Value::Bool(true), Some(Ordering::Equal))]
        #[case(Value::Float(1.0), Value::Bool(false), Some(Ordering::Greater))]
        #[case(Value::Float(0.0), Value::Bool(true), Some(Ordering::Less))]
        #[case(Value::Float(0.0), Value::Bool(false), Some(Ordering::Equal))]
        #[case(Value::Float(-1.0), Value::Bool(true), Some(Ordering::Less))]
        #[case(Value::Float(-1.0), Value::Bool(false), Some(Ordering::Less))]
        #[case(Value::Float(1.0), Value::Int(2), Some(Ordering::Less))]
        #[case(Value::Float(1.0), Value::Int(1), Some(Ordering::Equal))]
        #[case(Value::Float(1.0), Value::Int(0), Some(Ordering::Greater))]
        #[case(Value::Float(1.0), Value::Int(-1), Some(Ordering::Greater))]
        #[case(Value::Float(1.0), Value::String("string".to_string()), None)]
        #[case(Value::Float(-1.0), Value::String("string".to_string()), None)]
        #[case(Value::Float(1.0), Value::Duration(1), Some(Ordering::Equal))]
        #[case(Value::Float(-1.0), Value::Duration(1), Some(Ordering::Less))]
        fn partial_cmp_float(
            #[case] left: Value,
            #[case] right: Value,
            #[case] expected: Option<Ordering>,
        ) {
            let result = left.partial_cmp(&right);
            assert_eq!(result, expected);
        }

        #[rstest]
        #[case(Value::String("a".to_string()), Value::String("a".to_string()), Some(Ordering::Equal))]
        #[case(Value::String("a".to_string()), Value::String("b".to_string()), Some(Ordering::Less))]
        #[case(Value::String("b".to_string()), Value::String("a".to_string()), Some(Ordering::Greater))]
        #[case(Value::String("a".to_string()), Value::Bool(true), None)]
        #[case(Value::String("a".to_string()), Value::Bool(false), None)]
        #[case(Value::String("a".to_string()), Value::Int(1), None)]
        #[case(Value::String("a".to_string()), Value::Float(1.0), None)]
        #[case(Value::String("a".to_string()), Value::Duration(1), None)]
        fn partial_cmp_string(
            #[case] left: Value,
            #[case] right: Value,
            #[case] expected: Option<Ordering>,
        ) {
            let result = left.partial_cmp(&right);
            assert_eq!(result, expected);
        }
    }
}