1use std::collections::HashMap;
5
6use reifydb_type::{Blob, Date, DateTime, Decimal, Duration, IdentityId, Int, Time, Type, Uint, Uuid4, Uuid7, Value};
7
8use super::{EncodedValues, EncodedValuesLayout, EncodedValuesLayoutInner};
9
10#[derive(Debug, Clone)]
12pub struct EncodedValuesNamedLayout {
13 layout: EncodedValuesLayout,
14 names: Vec<String>,
15 name_to_index: HashMap<String, usize>,
16}
17
18impl EncodedValuesNamedLayout {
19 pub fn new(fields: impl IntoIterator<Item = (String, Type)>) -> Self {
20 let (names, types): (Vec<String>, Vec<Type>) =
21 fields.into_iter().map(|(name, r#type)| (name, r#type)).unzip();
22
23 let layout = EncodedValuesLayout::new(&types);
24
25 let name_to_index = names.iter().enumerate().map(|(idx, name)| (name.clone(), idx)).collect();
26
27 Self {
28 layout,
29 names,
30 name_to_index,
31 }
32 }
33
34 pub fn get_name(&self, index: usize) -> Option<&str> {
37 self.names.get(index).map(|s| s.as_str())
38 }
39
40 pub fn names(&self) -> &[String] {
41 &self.names
42 }
43
44 pub fn field_index(&self, name: &str) -> Option<usize> {
45 self.name_to_index.get(name).copied()
46 }
47
48 pub fn layout(&self) -> &EncodedValuesLayout {
49 &self.layout
50 }
51
52 pub fn fields(&self) -> &EncodedValuesLayoutInner {
53 &self.layout
54 }
55
56 pub fn allocate(&self) -> EncodedValues {
57 self.layout.allocate()
58 }
59
60 pub fn get_value(&self, row: &EncodedValues, name: &str) -> Option<Value> {
61 self.field_index(name).map(|idx| self.layout.get_value(row, idx))
62 }
63
64 pub fn set_value(&self, row: &mut EncodedValues, name: &str, value: &Value) -> Option<()> {
65 self.field_index(name).map(|idx| self.layout.set_value(row, idx, value))
66 }
67
68 pub fn set_values(&self, row: &mut EncodedValues, values: &[Value]) {
69 debug_assert_eq!(self.layout.fields.len(), values.len());
70 self.layout.set_values(row, values)
71 }
72
73 pub fn set_undefined(&self, row: &mut EncodedValues, name: &str) -> Option<()> {
74 self.field_index(name).map(|idx| self.layout.set_undefined(row, idx))
75 }
76
77 pub fn get_value_by_idx(&self, row: &EncodedValues, index: usize) -> Value {
78 self.layout.get_value(row, index)
79 }
80
81 pub fn set_value_by_idx(&self, row: &mut EncodedValues, index: usize, value: &Value) {
82 self.layout.set_value(row, index, value)
83 }
84
85 pub fn set_undefined_by_idx(&self, row: &mut EncodedValues, index: usize) {
86 self.layout.set_undefined(row, index)
87 }
88
89 pub fn get_bool(&self, row: &EncodedValues, name: &str) -> Option<bool> {
90 self.field_index(name).map(|idx| self.layout.get_bool(row, idx))
91 }
92
93 pub fn set_bool(&self, row: &mut EncodedValues, name: &str, value: bool) -> Option<()> {
94 self.field_index(name).map(|idx| self.layout.set_bool(row, idx, value))
95 }
96
97 pub fn get_i8(&self, row: &EncodedValues, name: &str) -> Option<i8> {
98 self.field_index(name).map(|idx| self.layout.get_i8(row, idx))
99 }
100
101 pub fn set_i8(&self, row: &mut EncodedValues, name: &str, value: i8) -> Option<()> {
102 self.field_index(name).map(|idx| self.layout.set_i8(row, idx, value))
103 }
104
105 pub fn get_i16(&self, row: &EncodedValues, name: &str) -> Option<i16> {
106 self.field_index(name).map(|idx| self.layout.get_i16(row, idx))
107 }
108
109 pub fn set_i16(&self, row: &mut EncodedValues, name: &str, value: i16) -> Option<()> {
110 self.field_index(name).map(|idx| self.layout.set_i16(row, idx, value))
111 }
112
113 pub fn get_i32(&self, row: &EncodedValues, name: &str) -> Option<i32> {
114 self.field_index(name).map(|idx| self.layout.get_i32(row, idx))
115 }
116
117 pub fn set_i32(&self, row: &mut EncodedValues, name: &str, value: i32) -> Option<()> {
118 self.field_index(name).map(|idx| self.layout.set_i32(row, idx, value))
119 }
120
121 pub fn get_i64(&self, row: &EncodedValues, name: &str) -> Option<i64> {
122 self.field_index(name).map(|idx| self.layout.get_i64(row, idx))
123 }
124
125 pub fn set_i64(&self, row: &mut EncodedValues, name: &str, value: i64) -> Option<()> {
126 self.field_index(name).map(|idx| self.layout.set_i64(row, idx, value))
127 }
128
129 pub fn get_i128(&self, row: &EncodedValues, name: &str) -> Option<i128> {
130 self.field_index(name).map(|idx| self.layout.get_i128(row, idx))
131 }
132
133 pub fn set_i128(&self, row: &mut EncodedValues, name: &str, value: i128) -> Option<()> {
134 self.field_index(name).map(|idx| self.layout.set_i128(row, idx, value))
135 }
136
137 pub fn get_u8(&self, row: &EncodedValues, name: &str) -> Option<u8> {
138 self.field_index(name).map(|idx| self.layout.get_u8(row, idx))
139 }
140
141 pub fn set_u8(&self, row: &mut EncodedValues, name: &str, value: u8) -> Option<()> {
142 self.field_index(name).map(|idx| self.layout.set_u8(row, idx, value))
143 }
144
145 pub fn get_u16(&self, row: &EncodedValues, name: &str) -> Option<u16> {
146 self.field_index(name).map(|idx| self.layout.get_u16(row, idx))
147 }
148
149 pub fn set_u16(&self, row: &mut EncodedValues, name: &str, value: u16) -> Option<()> {
150 self.field_index(name).map(|idx| self.layout.set_u16(row, idx, value))
151 }
152
153 pub fn get_u32(&self, row: &EncodedValues, name: &str) -> Option<u32> {
154 self.field_index(name).map(|idx| self.layout.get_u32(row, idx))
155 }
156
157 pub fn set_u32(&self, row: &mut EncodedValues, name: &str, value: u32) -> Option<()> {
158 self.field_index(name).map(|idx| self.layout.set_u32(row, idx, value))
159 }
160
161 pub fn get_u64(&self, row: &EncodedValues, name: &str) -> Option<u64> {
162 self.field_index(name).map(|idx| self.layout.get_u64(row, idx))
163 }
164
165 pub fn set_u64(&self, row: &mut EncodedValues, name: &str, value: u64) -> Option<()> {
166 self.field_index(name).map(|idx| self.layout.set_u64(row, idx, value))
167 }
168
169 pub fn get_u128(&self, row: &EncodedValues, name: &str) -> Option<u128> {
170 self.field_index(name).map(|idx| self.layout.get_u128(row, idx))
171 }
172
173 pub fn set_u128(&self, row: &mut EncodedValues, name: &str, value: u128) -> Option<()> {
174 self.field_index(name).map(|idx| self.layout.set_u128(row, idx, value))
175 }
176
177 pub fn get_f32(&self, row: &EncodedValues, name: &str) -> Option<f32> {
178 self.field_index(name).map(|idx| self.layout.get_f32(row, idx))
179 }
180
181 pub fn set_f32(&self, row: &mut EncodedValues, name: &str, value: f32) -> Option<()> {
182 self.field_index(name).map(|idx| self.layout.set_f32(row, idx, value))
183 }
184
185 pub fn get_f64(&self, row: &EncodedValues, name: &str) -> Option<f64> {
186 self.field_index(name).map(|idx| self.layout.get_f64(row, idx))
187 }
188
189 pub fn set_f64(&self, row: &mut EncodedValues, name: &str, value: f64) -> Option<()> {
190 self.field_index(name).map(|idx| self.layout.set_f64(row, idx, value))
191 }
192
193 pub fn get_utf8<'a>(&'a self, row: &'a EncodedValues, name: &str) -> Option<&'a str> {
194 self.field_index(name).map(|idx| self.layout.get_utf8(row, idx))
195 }
196
197 pub fn set_utf8(&self, row: &mut EncodedValues, name: &str, value: &str) -> Option<()> {
198 self.field_index(name).map(|idx| self.layout.set_utf8(row, idx, value))
199 }
200
201 pub fn get_date(&self, row: &EncodedValues, name: &str) -> Option<Date> {
202 self.field_index(name).map(|idx| self.layout.get_date(row, idx))
203 }
204
205 pub fn set_date(&self, row: &mut EncodedValues, name: &str, value: Date) -> Option<()> {
206 self.field_index(name).map(|idx| self.layout.set_date(row, idx, value))
207 }
208
209 pub fn get_datetime(&self, row: &EncodedValues, name: &str) -> Option<DateTime> {
210 self.field_index(name).map(|idx| self.layout.get_datetime(row, idx))
211 }
212
213 pub fn set_datetime(&self, row: &mut EncodedValues, name: &str, value: DateTime) -> Option<()> {
214 self.field_index(name).map(|idx| self.layout.set_datetime(row, idx, value))
215 }
216
217 pub fn get_time(&self, row: &EncodedValues, name: &str) -> Option<Time> {
218 self.field_index(name).map(|idx| self.layout.get_time(row, idx))
219 }
220
221 pub fn set_time(&self, row: &mut EncodedValues, name: &str, value: Time) -> Option<()> {
222 self.field_index(name).map(|idx| self.layout.set_time(row, idx, value))
223 }
224
225 pub fn get_duration(&self, row: &EncodedValues, name: &str) -> Option<Duration> {
226 self.field_index(name).map(|idx| self.layout.get_duration(row, idx))
227 }
228
229 pub fn set_duration(&self, row: &mut EncodedValues, name: &str, value: Duration) -> Option<()> {
230 self.field_index(name).map(|idx| self.layout.set_duration(row, idx, value))
231 }
232
233 pub fn get_uuid4(&self, row: &EncodedValues, name: &str) -> Option<Uuid4> {
234 self.field_index(name).map(|idx| self.layout.get_uuid4(row, idx))
235 }
236
237 pub fn set_uuid4(&self, row: &mut EncodedValues, name: &str, value: Uuid4) -> Option<()> {
238 self.field_index(name).map(|idx| self.layout.set_uuid4(row, idx, value))
239 }
240
241 pub fn get_uuid7(&self, row: &EncodedValues, name: &str) -> Option<Uuid7> {
242 self.field_index(name).map(|idx| self.layout.get_uuid7(row, idx))
243 }
244
245 pub fn set_uuid7(&self, row: &mut EncodedValues, name: &str, value: Uuid7) -> Option<()> {
246 self.field_index(name).map(|idx| self.layout.set_uuid7(row, idx, value))
247 }
248
249 pub fn get_identity_id(&self, row: &EncodedValues, name: &str) -> Option<IdentityId> {
250 self.field_index(name).map(|idx| self.layout.get_identity_id(row, idx))
251 }
252
253 pub fn set_identity_id(&self, row: &mut EncodedValues, name: &str, value: IdentityId) -> Option<()> {
254 self.field_index(name).map(|idx| self.layout.set_identity_id(row, idx, value))
255 }
256
257 pub fn get_blob(&self, row: &EncodedValues, name: &str) -> Option<Blob> {
258 self.field_index(name).map(|idx| self.layout.get_blob(row, idx))
259 }
260
261 pub fn set_blob(&self, row: &mut EncodedValues, name: &str, value: &Blob) -> Option<()> {
262 self.field_index(name).map(|idx| self.layout.set_blob(row, idx, value))
263 }
264
265 pub fn get_decimal(&self, row: &EncodedValues, name: &str) -> Option<Decimal> {
266 self.field_index(name).map(|idx| self.layout.get_decimal(row, idx))
267 }
268
269 pub fn set_decimal(&self, row: &mut EncodedValues, name: &str, value: &Decimal) -> Option<()> {
270 self.field_index(name).map(|idx| self.layout.set_decimal(row, idx, value))
271 }
272
273 pub fn get_int(&self, row: &EncodedValues, name: &str) -> Option<Int> {
274 self.field_index(name).map(|idx| self.layout.get_int(row, idx))
275 }
276
277 pub fn set_int(&self, row: &mut EncodedValues, name: &str, value: &Int) -> Option<()> {
278 self.field_index(name).map(|idx| self.layout.set_int(row, idx, value))
279 }
280
281 pub fn get_uint(&self, row: &EncodedValues, name: &str) -> Option<Uint> {
282 self.field_index(name).map(|idx| self.layout.get_uint(row, idx))
283 }
284
285 pub fn set_uint(&self, row: &mut EncodedValues, name: &str, value: &Uint) -> Option<()> {
286 self.field_index(name).map(|idx| self.layout.set_uint(row, idx, value))
287 }
288
289 pub fn get_bool_by_idx(&self, row: &EncodedValues, index: usize) -> bool {
290 self.layout.get_bool(row, index)
291 }
292
293 pub fn set_bool_by_idx(&self, row: &mut EncodedValues, index: usize, value: bool) {
294 self.layout.set_bool(row, index, value)
295 }
296
297 pub fn get_i8_by_idx(&self, row: &EncodedValues, index: usize) -> i8 {
298 self.layout.get_i8(row, index)
299 }
300
301 pub fn set_i8_by_idx(&self, row: &mut EncodedValues, index: usize, value: i8) {
302 self.layout.set_i8(row, index, value)
303 }
304
305 pub fn get_i16_by_idx(&self, row: &EncodedValues, index: usize) -> i16 {
306 self.layout.get_i16(row, index)
307 }
308
309 pub fn set_i16_by_idx(&self, row: &mut EncodedValues, index: usize, value: i16) {
310 self.layout.set_i16(row, index, value)
311 }
312
313 pub fn get_i32_by_idx(&self, row: &EncodedValues, index: usize) -> i32 {
314 self.layout.get_i32(row, index)
315 }
316
317 pub fn set_i32_by_idx(&self, row: &mut EncodedValues, index: usize, value: i32) {
318 self.layout.set_i32(row, index, value)
319 }
320
321 pub fn get_i64_by_idx(&self, row: &EncodedValues, index: usize) -> i64 {
322 self.layout.get_i64(row, index)
323 }
324
325 pub fn set_i64_by_idx(&self, row: &mut EncodedValues, index: usize, value: i64) {
326 self.layout.set_i64(row, index, value)
327 }
328
329 pub fn get_i128_by_idx(&self, row: &EncodedValues, index: usize) -> i128 {
330 self.layout.get_i128(row, index)
331 }
332
333 pub fn set_i128_by_idx(&self, row: &mut EncodedValues, index: usize, value: i128) {
334 self.layout.set_i128(row, index, value)
335 }
336
337 pub fn get_u8_by_idx(&self, row: &EncodedValues, index: usize) -> u8 {
338 self.layout.get_u8(row, index)
339 }
340
341 pub fn set_u8_by_idx(&self, row: &mut EncodedValues, index: usize, value: u8) {
342 self.layout.set_u8(row, index, value)
343 }
344
345 pub fn get_u16_by_idx(&self, row: &EncodedValues, index: usize) -> u16 {
346 self.layout.get_u16(row, index)
347 }
348
349 pub fn set_u16_by_idx(&self, row: &mut EncodedValues, index: usize, value: u16) {
350 self.layout.set_u16(row, index, value)
351 }
352
353 pub fn get_u32_by_idx(&self, row: &EncodedValues, index: usize) -> u32 {
354 self.layout.get_u32(row, index)
355 }
356
357 pub fn set_u32_by_idx(&self, row: &mut EncodedValues, index: usize, value: u32) {
358 self.layout.set_u32(row, index, value)
359 }
360
361 pub fn get_u64_by_idx(&self, row: &EncodedValues, index: usize) -> u64 {
362 self.layout.get_u64(row, index)
363 }
364
365 pub fn set_u64_by_idx(&self, row: &mut EncodedValues, index: usize, value: u64) {
366 self.layout.set_u64(row, index, value)
367 }
368
369 pub fn get_u128_by_idx(&self, row: &EncodedValues, index: usize) -> u128 {
370 self.layout.get_u128(row, index)
371 }
372
373 pub fn set_u128_by_idx(&self, row: &mut EncodedValues, index: usize, value: u128) {
374 self.layout.set_u128(row, index, value)
375 }
376
377 pub fn get_f32_by_idx(&self, row: &EncodedValues, index: usize) -> f32 {
378 self.layout.get_f32(row, index)
379 }
380
381 pub fn set_f32_by_idx(&self, row: &mut EncodedValues, index: usize, value: f32) {
382 self.layout.set_f32(row, index, value)
383 }
384
385 pub fn get_f64_by_idx(&self, row: &EncodedValues, index: usize) -> f64 {
386 self.layout.get_f64(row, index)
387 }
388
389 pub fn set_f64_by_idx(&self, row: &mut EncodedValues, index: usize, value: f64) {
390 self.layout.set_f64(row, index, value)
391 }
392
393 pub fn get_utf8_by_idx<'a>(&'a self, row: &'a EncodedValues, index: usize) -> &'a str {
394 self.layout.get_utf8(row, index)
395 }
396
397 pub fn set_utf8_by_idx(&self, row: &mut EncodedValues, index: usize, value: &str) {
398 self.layout.set_utf8(row, index, value)
399 }
400
401 pub fn get_date_by_idx(&self, row: &EncodedValues, index: usize) -> Date {
402 self.layout.get_date(row, index)
403 }
404
405 pub fn set_date_by_idx(&self, row: &mut EncodedValues, index: usize, value: Date) {
406 self.layout.set_date(row, index, value)
407 }
408
409 pub fn get_datetime_by_idx(&self, row: &EncodedValues, index: usize) -> DateTime {
410 self.layout.get_datetime(row, index)
411 }
412
413 pub fn set_datetime_by_idx(&self, row: &mut EncodedValues, index: usize, value: DateTime) {
414 self.layout.set_datetime(row, index, value)
415 }
416
417 pub fn get_time_by_idx(&self, row: &EncodedValues, index: usize) -> Time {
418 self.layout.get_time(row, index)
419 }
420
421 pub fn set_time_by_idx(&self, row: &mut EncodedValues, index: usize, value: Time) {
422 self.layout.set_time(row, index, value)
423 }
424
425 pub fn get_duration_by_idx(&self, row: &EncodedValues, index: usize) -> Duration {
426 self.layout.get_duration(row, index)
427 }
428
429 pub fn set_duration_by_idx(&self, row: &mut EncodedValues, index: usize, value: Duration) {
430 self.layout.set_duration(row, index, value)
431 }
432
433 pub fn get_uuid4_by_idx(&self, row: &EncodedValues, index: usize) -> Uuid4 {
434 self.layout.get_uuid4(row, index)
435 }
436
437 pub fn set_uuid4_by_idx(&self, row: &mut EncodedValues, index: usize, value: Uuid4) {
438 self.layout.set_uuid4(row, index, value)
439 }
440
441 pub fn get_uuid7_by_idx(&self, row: &EncodedValues, index: usize) -> Uuid7 {
442 self.layout.get_uuid7(row, index)
443 }
444
445 pub fn set_uuid7_by_idx(&self, row: &mut EncodedValues, index: usize, value: Uuid7) {
446 self.layout.set_uuid7(row, index, value)
447 }
448
449 pub fn get_identity_id_by_idx(&self, row: &EncodedValues, index: usize) -> IdentityId {
450 self.layout.get_identity_id(row, index)
451 }
452
453 pub fn set_identity_id_by_idx(&self, row: &mut EncodedValues, index: usize, value: IdentityId) {
454 self.layout.set_identity_id(row, index, value)
455 }
456
457 pub fn get_blob_by_idx(&self, row: &EncodedValues, index: usize) -> Blob {
458 self.layout.get_blob(row, index)
459 }
460
461 pub fn set_blob_by_idx(&self, row: &mut EncodedValues, index: usize, value: &Blob) {
462 self.layout.set_blob(row, index, value)
463 }
464
465 pub fn get_decimal_by_idx(&self, row: &EncodedValues, index: usize) -> Decimal {
466 self.layout.get_decimal(row, index)
467 }
468
469 pub fn set_decimal_by_idx(&self, row: &mut EncodedValues, index: usize, value: &Decimal) {
470 self.layout.set_decimal(row, index, value)
471 }
472
473 pub fn get_int_by_idx(&self, row: &EncodedValues, index: usize) -> Int {
474 self.layout.get_int(row, index)
475 }
476
477 pub fn set_int_by_idx(&self, row: &mut EncodedValues, index: usize, value: &Int) {
478 self.layout.set_int(row, index, value)
479 }
480
481 pub fn get_uint_by_idx(&self, row: &EncodedValues, index: usize) -> Uint {
482 self.layout.get_uint(row, index)
483 }
484
485 pub fn set_uint_by_idx(&self, row: &mut EncodedValues, index: usize, value: &Uint) {
486 self.layout.set_uint(row, index, value)
487 }
488
489 pub fn iter_fields<'a>(&'a self, row: &'a EncodedValues) -> impl Iterator<Item = (&'a str, Value)> + 'a {
490 self.names.iter().enumerate().map(|(idx, name)| {
491 let value = self.layout.get_value(row, idx);
492 (name.as_str(), value)
493 })
494 }
495}