reifydb_core/value/column/data/
factory.rs

1// Copyright (c) reifydb.com 2025
2// This file is licensed under the AGPL-3.0-or-later, see license.md file
3
4use reifydb_type::{Blob, Date, DateTime, Decimal, Duration, IdentityId, Int, Time, Uint, Uuid4, Uuid7};
5
6use crate::{
7	BitVec,
8	value::{
9		column::ColumnData,
10		container::{
11			AnyContainer, BlobContainer, BoolContainer, IdentityIdContainer, NumberContainer,
12			TemporalContainer, UndefinedContainer, Utf8Container, UuidContainer,
13		},
14	},
15};
16
17impl ColumnData {
18	pub fn bool(data: impl IntoIterator<Item = bool>) -> Self {
19		let data = data.into_iter().collect::<Vec<_>>();
20		ColumnData::Bool(BoolContainer::from_vec(data))
21	}
22
23	pub fn bool_optional(data: impl IntoIterator<Item = Option<bool>>) -> Self {
24		let mut values = Vec::new();
25		let mut bitvec = Vec::new();
26
27		for opt in data {
28			match opt {
29				Some(value) => {
30					values.push(value);
31					bitvec.push(true);
32				}
33				None => {
34					values.push(false);
35					bitvec.push(false);
36				}
37			}
38		}
39
40		ColumnData::Bool(BoolContainer::new(values, BitVec::from(bitvec)))
41	}
42
43	pub fn bool_with_capacity(capacity: usize) -> Self {
44		ColumnData::Bool(BoolContainer::with_capacity(capacity))
45	}
46
47	pub fn bool_with_bitvec(data: impl IntoIterator<Item = bool>, bitvec: impl Into<BitVec>) -> Self {
48		let data = data.into_iter().collect::<Vec<_>>();
49		let bitvec = bitvec.into();
50		assert_eq!(bitvec.len(), data.len());
51		ColumnData::Bool(BoolContainer::new(data, bitvec))
52	}
53
54	pub fn float4(data: impl IntoIterator<Item = f32>) -> Self {
55		let data = data.into_iter().collect::<Vec<_>>();
56		ColumnData::Float4(NumberContainer::from_vec(data))
57	}
58
59	pub fn float4_optional(data: impl IntoIterator<Item = Option<f32>>) -> Self {
60		let mut values = Vec::new();
61		let mut bitvec = Vec::new();
62
63		for opt in data {
64			match opt {
65				Some(value) => {
66					values.push(value);
67					bitvec.push(true);
68				}
69				None => {
70					values.push(0.0);
71					bitvec.push(false);
72				}
73			}
74		}
75
76		ColumnData::Float4(NumberContainer::new(values, BitVec::from(bitvec)))
77	}
78
79	pub fn float4_with_capacity(capacity: usize) -> Self {
80		ColumnData::Float4(NumberContainer::with_capacity(capacity))
81	}
82
83	pub fn float4_with_bitvec(data: impl IntoIterator<Item = f32>, bitvec: impl Into<BitVec>) -> Self {
84		let data = data.into_iter().collect::<Vec<_>>();
85		let bitvec = bitvec.into();
86		assert_eq!(bitvec.len(), data.len());
87		ColumnData::Float4(NumberContainer::new(data, bitvec))
88	}
89
90	pub fn float8(data: impl IntoIterator<Item = f64>) -> Self {
91		let data = data.into_iter().collect::<Vec<_>>();
92		ColumnData::Float8(NumberContainer::from_vec(data))
93	}
94
95	pub fn float8_optional(data: impl IntoIterator<Item = Option<f64>>) -> Self {
96		let mut values = Vec::new();
97		let mut bitvec = Vec::new();
98
99		for opt in data {
100			match opt {
101				Some(value) => {
102					values.push(value);
103					bitvec.push(true);
104				}
105				None => {
106					values.push(0.0);
107					bitvec.push(false);
108				}
109			}
110		}
111
112		ColumnData::Float8(NumberContainer::new(values, BitVec::from(bitvec)))
113	}
114
115	pub fn float8_with_capacity(capacity: usize) -> Self {
116		ColumnData::Float8(NumberContainer::with_capacity(capacity))
117	}
118
119	pub fn float8_with_bitvec(data: impl IntoIterator<Item = f64>, bitvec: impl Into<BitVec>) -> Self {
120		let data = data.into_iter().collect::<Vec<_>>();
121		let bitvec = bitvec.into();
122		assert_eq!(bitvec.len(), data.len());
123		ColumnData::Float8(NumberContainer::new(data, bitvec))
124	}
125
126	pub fn int1(data: impl IntoIterator<Item = i8>) -> Self {
127		let data = data.into_iter().collect::<Vec<_>>();
128		ColumnData::Int1(NumberContainer::from_vec(data))
129	}
130
131	pub fn int1_optional(data: impl IntoIterator<Item = Option<i8>>) -> Self {
132		let mut values = Vec::new();
133		let mut bitvec = Vec::new();
134
135		for opt in data {
136			match opt {
137				Some(value) => {
138					values.push(value);
139					bitvec.push(true);
140				}
141				None => {
142					values.push(0);
143					bitvec.push(false);
144				}
145			}
146		}
147
148		ColumnData::Int1(NumberContainer::new(values, BitVec::from(bitvec)))
149	}
150
151	pub fn int1_with_capacity(capacity: usize) -> Self {
152		ColumnData::Int1(NumberContainer::with_capacity(capacity))
153	}
154
155	pub fn int1_with_bitvec(data: impl IntoIterator<Item = i8>, bitvec: impl Into<BitVec>) -> Self {
156		let data = data.into_iter().collect::<Vec<_>>();
157		let bitvec = bitvec.into();
158		assert_eq!(bitvec.len(), data.len());
159		ColumnData::Int1(NumberContainer::new(data, bitvec))
160	}
161
162	pub fn int2(data: impl IntoIterator<Item = i16>) -> Self {
163		let data = data.into_iter().collect::<Vec<_>>();
164		ColumnData::Int2(NumberContainer::from_vec(data))
165	}
166
167	pub fn int2_optional(data: impl IntoIterator<Item = Option<i16>>) -> Self {
168		let mut values = Vec::new();
169		let mut bitvec = Vec::new();
170
171		for opt in data {
172			match opt {
173				Some(value) => {
174					values.push(value);
175					bitvec.push(true);
176				}
177				None => {
178					values.push(0);
179					bitvec.push(false);
180				}
181			}
182		}
183
184		ColumnData::Int2(NumberContainer::new(values, BitVec::from(bitvec)))
185	}
186
187	pub fn int2_with_capacity(capacity: usize) -> Self {
188		ColumnData::Int2(NumberContainer::with_capacity(capacity))
189	}
190
191	pub fn int2_with_bitvec(data: impl IntoIterator<Item = i16>, bitvec: impl Into<BitVec>) -> Self {
192		let data = data.into_iter().collect::<Vec<_>>();
193		let bitvec = bitvec.into();
194		assert_eq!(bitvec.len(), data.len());
195		ColumnData::Int2(NumberContainer::new(data, bitvec))
196	}
197
198	pub fn int4(data: impl IntoIterator<Item = i32>) -> Self {
199		let data = data.into_iter().collect::<Vec<_>>();
200		ColumnData::Int4(NumberContainer::from_vec(data))
201	}
202
203	pub fn int4_optional(data: impl IntoIterator<Item = Option<i32>>) -> Self {
204		let mut values = Vec::new();
205		let mut bitvec = Vec::new();
206
207		for opt in data {
208			match opt {
209				Some(value) => {
210					values.push(value);
211					bitvec.push(true);
212				}
213				None => {
214					values.push(0);
215					bitvec.push(false);
216				}
217			}
218		}
219
220		ColumnData::Int4(NumberContainer::new(values, BitVec::from(bitvec)))
221	}
222
223	pub fn int4_with_capacity(capacity: usize) -> Self {
224		ColumnData::Int4(NumberContainer::with_capacity(capacity))
225	}
226
227	pub fn int4_with_bitvec(data: impl IntoIterator<Item = i32>, bitvec: impl Into<BitVec>) -> Self {
228		let data = data.into_iter().collect::<Vec<_>>();
229		let bitvec = bitvec.into();
230		assert_eq!(bitvec.len(), data.len());
231		ColumnData::Int4(NumberContainer::new(data, bitvec))
232	}
233
234	pub fn int8(data: impl IntoIterator<Item = i64>) -> Self {
235		let data = data.into_iter().collect::<Vec<_>>();
236		ColumnData::Int8(NumberContainer::from_vec(data))
237	}
238
239	pub fn int8_optional(data: impl IntoIterator<Item = Option<i64>>) -> Self {
240		let mut values = Vec::new();
241		let mut bitvec = Vec::new();
242
243		for opt in data {
244			match opt {
245				Some(value) => {
246					values.push(value);
247					bitvec.push(true);
248				}
249				None => {
250					values.push(0);
251					bitvec.push(false);
252				}
253			}
254		}
255
256		ColumnData::Int8(NumberContainer::new(values, BitVec::from(bitvec)))
257	}
258
259	pub fn int8_with_capacity(capacity: usize) -> Self {
260		ColumnData::Int8(NumberContainer::with_capacity(capacity))
261	}
262
263	pub fn int8_with_bitvec(data: impl IntoIterator<Item = i64>, bitvec: impl Into<BitVec>) -> Self {
264		let data = data.into_iter().collect::<Vec<_>>();
265		let bitvec = bitvec.into();
266		assert_eq!(bitvec.len(), data.len());
267		ColumnData::Int8(NumberContainer::new(data, bitvec))
268	}
269
270	pub fn int16(data: impl IntoIterator<Item = i128>) -> Self {
271		let data = data.into_iter().collect::<Vec<_>>();
272		ColumnData::Int16(NumberContainer::from_vec(data))
273	}
274
275	pub fn int16_optional(data: impl IntoIterator<Item = Option<i128>>) -> Self {
276		let mut values = Vec::new();
277		let mut bitvec = Vec::new();
278
279		for opt in data {
280			match opt {
281				Some(value) => {
282					values.push(value);
283					bitvec.push(true);
284				}
285				None => {
286					values.push(0);
287					bitvec.push(false);
288				}
289			}
290		}
291
292		ColumnData::Int16(NumberContainer::new(values, BitVec::from(bitvec)))
293	}
294
295	pub fn int16_with_capacity(capacity: usize) -> Self {
296		ColumnData::Int16(NumberContainer::with_capacity(capacity))
297	}
298
299	pub fn int16_with_bitvec(data: impl IntoIterator<Item = i128>, bitvec: impl Into<BitVec>) -> Self {
300		let data = data.into_iter().collect::<Vec<_>>();
301		let bitvec = bitvec.into();
302		assert_eq!(bitvec.len(), data.len());
303		ColumnData::Int16(NumberContainer::new(data, bitvec))
304	}
305
306	pub fn utf8(data: impl IntoIterator<Item = impl Into<String>>) -> Self {
307		use reifydb_type::value::constraint::bytes::MaxBytes;
308		let data = data.into_iter().map(|c| c.into()).collect::<Vec<_>>();
309		ColumnData::Utf8 {
310			container: Utf8Container::from_vec(data),
311			max_bytes: MaxBytes::MAX,
312		}
313	}
314
315	pub fn utf8_optional(data: impl IntoIterator<Item = Option<String>>) -> Self {
316		use reifydb_type::value::constraint::bytes::MaxBytes;
317		let mut values = Vec::new();
318		let mut bitvec = Vec::new();
319
320		for opt in data {
321			match opt {
322				Some(value) => {
323					values.push(value);
324					bitvec.push(true);
325				}
326				None => {
327					values.push(String::new());
328					bitvec.push(false);
329				}
330			}
331		}
332
333		ColumnData::Utf8 {
334			container: Utf8Container::new(values, BitVec::from(bitvec)),
335			max_bytes: MaxBytes::MAX,
336		}
337	}
338
339	pub fn utf8_with_capacity(capacity: usize) -> Self {
340		use reifydb_type::value::constraint::bytes::MaxBytes;
341		ColumnData::Utf8 {
342			container: Utf8Container::with_capacity(capacity),
343			max_bytes: MaxBytes::MAX,
344		}
345	}
346
347	pub fn utf8_with_bitvec(data: impl IntoIterator<Item = impl Into<String>>, bitvec: impl Into<BitVec>) -> Self {
348		use reifydb_type::value::constraint::bytes::MaxBytes;
349		let data = data.into_iter().map(Into::into).collect::<Vec<_>>();
350		let bitvec = bitvec.into();
351		assert_eq!(bitvec.len(), data.len());
352		ColumnData::Utf8 {
353			container: Utf8Container::new(data, bitvec),
354			max_bytes: MaxBytes::MAX,
355		}
356	}
357
358	pub fn uint1(data: impl IntoIterator<Item = u8>) -> Self {
359		let data = data.into_iter().collect::<Vec<_>>();
360		ColumnData::Uint1(NumberContainer::from_vec(data))
361	}
362
363	pub fn uint1_optional(data: impl IntoIterator<Item = Option<u8>>) -> Self {
364		let mut values = Vec::new();
365		let mut bitvec = Vec::new();
366
367		for opt in data {
368			match opt {
369				Some(value) => {
370					values.push(value);
371					bitvec.push(true);
372				}
373				None => {
374					values.push(0);
375					bitvec.push(false);
376				}
377			}
378		}
379
380		ColumnData::Uint1(NumberContainer::new(values, BitVec::from(bitvec)))
381	}
382
383	pub fn uint1_with_capacity(capacity: usize) -> Self {
384		ColumnData::Uint1(NumberContainer::with_capacity(capacity))
385	}
386
387	pub fn uint1_with_bitvec(data: impl IntoIterator<Item = u8>, bitvec: impl Into<BitVec>) -> Self {
388		let data = data.into_iter().collect::<Vec<_>>();
389		let bitvec = bitvec.into();
390		assert_eq!(bitvec.len(), data.len());
391		ColumnData::Uint1(NumberContainer::new(data, bitvec))
392	}
393
394	pub fn uint2(data: impl IntoIterator<Item = u16>) -> Self {
395		let data = data.into_iter().collect::<Vec<_>>();
396		ColumnData::Uint2(NumberContainer::from_vec(data))
397	}
398
399	pub fn uint2_optional(data: impl IntoIterator<Item = Option<u16>>) -> Self {
400		let mut values = Vec::new();
401		let mut bitvec = Vec::new();
402
403		for opt in data {
404			match opt {
405				Some(value) => {
406					values.push(value);
407					bitvec.push(true);
408				}
409				None => {
410					values.push(0);
411					bitvec.push(false);
412				}
413			}
414		}
415
416		ColumnData::Uint2(NumberContainer::new(values, BitVec::from(bitvec)))
417	}
418
419	pub fn uint2_with_capacity(capacity: usize) -> Self {
420		ColumnData::Uint2(NumberContainer::with_capacity(capacity))
421	}
422
423	pub fn uint2_with_bitvec(data: impl IntoIterator<Item = u16>, bitvec: impl Into<BitVec>) -> Self {
424		let data = data.into_iter().collect::<Vec<_>>();
425		let bitvec = bitvec.into();
426		assert_eq!(bitvec.len(), data.len());
427		ColumnData::Uint2(NumberContainer::new(data, bitvec))
428	}
429
430	pub fn uint4(data: impl IntoIterator<Item = u32>) -> Self {
431		let data = data.into_iter().collect::<Vec<_>>();
432		ColumnData::Uint4(NumberContainer::from_vec(data))
433	}
434
435	pub fn uint4_optional(data: impl IntoIterator<Item = Option<u32>>) -> Self {
436		let mut values = Vec::new();
437		let mut bitvec = Vec::new();
438
439		for opt in data {
440			match opt {
441				Some(value) => {
442					values.push(value);
443					bitvec.push(true);
444				}
445				None => {
446					values.push(0);
447					bitvec.push(false);
448				}
449			}
450		}
451
452		ColumnData::Uint4(NumberContainer::new(values, BitVec::from(bitvec)))
453	}
454
455	pub fn uint4_with_capacity(capacity: usize) -> Self {
456		ColumnData::Uint4(NumberContainer::with_capacity(capacity))
457	}
458
459	pub fn uint4_with_bitvec(data: impl IntoIterator<Item = u32>, bitvec: impl Into<BitVec>) -> Self {
460		let data = data.into_iter().collect::<Vec<_>>();
461		let bitvec = bitvec.into();
462		assert_eq!(bitvec.len(), data.len());
463		ColumnData::Uint4(NumberContainer::new(data, bitvec))
464	}
465
466	pub fn uint8(data: impl IntoIterator<Item = u64>) -> Self {
467		let data = data.into_iter().collect::<Vec<_>>();
468		ColumnData::Uint8(NumberContainer::from_vec(data))
469	}
470
471	pub fn uint8_optional(data: impl IntoIterator<Item = Option<u64>>) -> Self {
472		let mut values = Vec::new();
473		let mut bitvec = Vec::new();
474
475		for opt in data {
476			match opt {
477				Some(value) => {
478					values.push(value);
479					bitvec.push(true);
480				}
481				None => {
482					values.push(0);
483					bitvec.push(false);
484				}
485			}
486		}
487
488		ColumnData::Uint8(NumberContainer::new(values, BitVec::from(bitvec)))
489	}
490
491	pub fn uint8_with_capacity(capacity: usize) -> Self {
492		ColumnData::Uint8(NumberContainer::with_capacity(capacity))
493	}
494
495	pub fn uint8_with_bitvec(data: impl IntoIterator<Item = u64>, bitvec: impl Into<BitVec>) -> Self {
496		let data = data.into_iter().collect::<Vec<_>>();
497		let bitvec = bitvec.into();
498		assert_eq!(bitvec.len(), data.len());
499		ColumnData::Uint8(NumberContainer::new(data, bitvec))
500	}
501
502	pub fn uint16(data: impl IntoIterator<Item = u128>) -> Self {
503		let data = data.into_iter().collect::<Vec<_>>();
504		ColumnData::Uint16(NumberContainer::from_vec(data))
505	}
506
507	pub fn uint16_optional(data: impl IntoIterator<Item = Option<u128>>) -> Self {
508		let mut values = Vec::new();
509		let mut bitvec = Vec::new();
510
511		for opt in data {
512			match opt {
513				Some(value) => {
514					values.push(value);
515					bitvec.push(true);
516				}
517				None => {
518					values.push(0);
519					bitvec.push(false);
520				}
521			}
522		}
523
524		ColumnData::Uint16(NumberContainer::new(values, BitVec::from(bitvec)))
525	}
526
527	pub fn uint16_with_capacity(capacity: usize) -> Self {
528		ColumnData::Uint16(NumberContainer::with_capacity(capacity))
529	}
530
531	pub fn uint16_with_bitvec(data: impl IntoIterator<Item = u128>, bitvec: impl Into<BitVec>) -> Self {
532		let data = data.into_iter().collect::<Vec<_>>();
533		let bitvec = bitvec.into();
534		assert_eq!(bitvec.len(), data.len());
535		ColumnData::Uint16(NumberContainer::new(data, bitvec))
536	}
537
538	pub fn date(data: impl IntoIterator<Item = Date>) -> Self {
539		let data = data.into_iter().collect::<Vec<_>>();
540		ColumnData::Date(TemporalContainer::from_vec(data))
541	}
542
543	pub fn date_optional(data: impl IntoIterator<Item = Option<Date>>) -> Self {
544		let mut values = Vec::new();
545		let mut bitvec = Vec::new();
546
547		for opt in data {
548			match opt {
549				Some(value) => {
550					values.push(value);
551					bitvec.push(true);
552				}
553				None => {
554					values.push(Date::default());
555					bitvec.push(false);
556				}
557			}
558		}
559
560		ColumnData::Date(TemporalContainer::new(values, BitVec::from(bitvec)))
561	}
562
563	pub fn date_with_capacity(capacity: usize) -> Self {
564		ColumnData::Date(TemporalContainer::with_capacity(capacity))
565	}
566
567	pub fn date_with_bitvec(data: impl IntoIterator<Item = Date>, bitvec: impl Into<BitVec>) -> Self {
568		let data = data.into_iter().collect::<Vec<_>>();
569		let bitvec = bitvec.into();
570		assert_eq!(bitvec.len(), data.len());
571		ColumnData::Date(TemporalContainer::new(data, bitvec))
572	}
573
574	pub fn datetime(data: impl IntoIterator<Item = DateTime>) -> Self {
575		let data = data.into_iter().collect::<Vec<_>>();
576		ColumnData::DateTime(TemporalContainer::from_vec(data))
577	}
578
579	pub fn datetime_optional(data: impl IntoIterator<Item = Option<DateTime>>) -> Self {
580		let mut values = Vec::new();
581		let mut bitvec = Vec::new();
582
583		for opt in data {
584			match opt {
585				Some(value) => {
586					values.push(value);
587					bitvec.push(true);
588				}
589				None => {
590					values.push(DateTime::default());
591					bitvec.push(false);
592				}
593			}
594		}
595
596		ColumnData::DateTime(TemporalContainer::new(values, BitVec::from(bitvec)))
597	}
598
599	pub fn datetime_with_capacity(capacity: usize) -> Self {
600		ColumnData::DateTime(TemporalContainer::with_capacity(capacity))
601	}
602
603	pub fn datetime_with_bitvec(data: impl IntoIterator<Item = DateTime>, bitvec: impl Into<BitVec>) -> Self {
604		let data = data.into_iter().collect::<Vec<_>>();
605		let bitvec = bitvec.into();
606		assert_eq!(bitvec.len(), data.len());
607		ColumnData::DateTime(TemporalContainer::new(data, bitvec))
608	}
609
610	pub fn time(data: impl IntoIterator<Item = Time>) -> Self {
611		let data = data.into_iter().collect::<Vec<_>>();
612		ColumnData::Time(TemporalContainer::from_vec(data))
613	}
614
615	pub fn time_optional(data: impl IntoIterator<Item = Option<Time>>) -> Self {
616		let mut values = Vec::new();
617		let mut bitvec = Vec::new();
618
619		for opt in data {
620			match opt {
621				Some(value) => {
622					values.push(value);
623					bitvec.push(true);
624				}
625				None => {
626					values.push(Time::default());
627					bitvec.push(false);
628				}
629			}
630		}
631
632		ColumnData::Time(TemporalContainer::new(values, BitVec::from(bitvec)))
633	}
634
635	pub fn time_with_capacity(capacity: usize) -> Self {
636		ColumnData::Time(TemporalContainer::with_capacity(capacity))
637	}
638
639	pub fn time_with_bitvec(data: impl IntoIterator<Item = Time>, bitvec: impl Into<BitVec>) -> Self {
640		let data = data.into_iter().collect::<Vec<_>>();
641		let bitvec = bitvec.into();
642		assert_eq!(bitvec.len(), data.len());
643		ColumnData::Time(TemporalContainer::new(data, bitvec))
644	}
645
646	pub fn duration(data: impl IntoIterator<Item = Duration>) -> Self {
647		let data = data.into_iter().collect::<Vec<_>>();
648		ColumnData::Duration(TemporalContainer::from_vec(data))
649	}
650
651	pub fn duration_optional(data: impl IntoIterator<Item = Option<Duration>>) -> Self {
652		let mut values = Vec::new();
653		let mut bitvec = Vec::new();
654
655		for opt in data {
656			match opt {
657				Some(value) => {
658					values.push(value);
659					bitvec.push(true);
660				}
661				None => {
662					values.push(Duration::default());
663					bitvec.push(false);
664				}
665			}
666		}
667
668		ColumnData::Duration(TemporalContainer::new(values, BitVec::from(bitvec)))
669	}
670
671	pub fn duration_with_capacity(capacity: usize) -> Self {
672		ColumnData::Duration(TemporalContainer::with_capacity(capacity))
673	}
674
675	pub fn duration_with_bitvec(data: impl IntoIterator<Item = Duration>, bitvec: impl Into<BitVec>) -> Self {
676		let data = data.into_iter().collect::<Vec<_>>();
677		let bitvec = bitvec.into();
678		assert_eq!(bitvec.len(), data.len());
679		ColumnData::Duration(TemporalContainer::new(data, bitvec))
680	}
681
682	pub fn uuid4(data: impl IntoIterator<Item = Uuid4>) -> Self {
683		let data = data.into_iter().collect::<Vec<_>>();
684		ColumnData::Uuid4(UuidContainer::from_vec(data))
685	}
686
687	pub fn uuid4_optional(data: impl IntoIterator<Item = Option<Uuid4>>) -> Self {
688		let mut values = Vec::new();
689		let mut bitvec = Vec::new();
690
691		for opt in data {
692			match opt {
693				Some(value) => {
694					values.push(value);
695					bitvec.push(true);
696				}
697				None => {
698					values.push(Uuid4::default());
699					bitvec.push(false);
700				}
701			}
702		}
703
704		ColumnData::Uuid4(UuidContainer::new(values, BitVec::from(bitvec)))
705	}
706
707	pub fn uuid4_with_capacity(capacity: usize) -> Self {
708		ColumnData::Uuid4(UuidContainer::with_capacity(capacity))
709	}
710
711	pub fn uuid4_with_bitvec(data: impl IntoIterator<Item = Uuid4>, bitvec: impl Into<BitVec>) -> Self {
712		let data = data.into_iter().collect::<Vec<_>>();
713		let bitvec = bitvec.into();
714		assert_eq!(bitvec.len(), data.len());
715		ColumnData::Uuid4(UuidContainer::new(data, bitvec))
716	}
717
718	pub fn uuid7(data: impl IntoIterator<Item = Uuid7>) -> Self {
719		let data = data.into_iter().collect::<Vec<_>>();
720		ColumnData::Uuid7(UuidContainer::from_vec(data))
721	}
722
723	pub fn uuid7_optional(data: impl IntoIterator<Item = Option<Uuid7>>) -> Self {
724		let mut values = Vec::new();
725		let mut bitvec = Vec::new();
726
727		for opt in data {
728			match opt {
729				Some(value) => {
730					values.push(value);
731					bitvec.push(true);
732				}
733				None => {
734					values.push(Uuid7::default());
735					bitvec.push(false);
736				}
737			}
738		}
739
740		ColumnData::Uuid7(UuidContainer::new(values, BitVec::from(bitvec)))
741	}
742
743	pub fn uuid7_with_capacity(capacity: usize) -> Self {
744		ColumnData::Uuid7(UuidContainer::with_capacity(capacity))
745	}
746
747	pub fn uuid7_with_bitvec(data: impl IntoIterator<Item = Uuid7>, bitvec: impl Into<BitVec>) -> Self {
748		let data = data.into_iter().collect::<Vec<_>>();
749		let bitvec = bitvec.into();
750		assert_eq!(bitvec.len(), data.len());
751		ColumnData::Uuid7(UuidContainer::new(data, bitvec))
752	}
753
754	pub fn blob(data: impl IntoIterator<Item = Blob>) -> Self {
755		use reifydb_type::value::constraint::bytes::MaxBytes;
756		let data = data.into_iter().collect::<Vec<_>>();
757		ColumnData::Blob {
758			container: BlobContainer::from_vec(data),
759			max_bytes: MaxBytes::MAX,
760		}
761	}
762
763	pub fn blob_optional(data: impl IntoIterator<Item = Option<Blob>>) -> Self {
764		use reifydb_type::value::constraint::bytes::MaxBytes;
765		let mut values = Vec::new();
766		let mut bitvec = Vec::new();
767
768		for opt in data {
769			match opt {
770				Some(value) => {
771					values.push(value);
772					bitvec.push(true);
773				}
774				None => {
775					values.push(Blob::default());
776					bitvec.push(false);
777				}
778			}
779		}
780
781		ColumnData::Blob {
782			container: BlobContainer::new(values, BitVec::from(bitvec)),
783			max_bytes: MaxBytes::MAX,
784		}
785	}
786
787	pub fn blob_with_capacity(capacity: usize) -> Self {
788		use reifydb_type::value::constraint::bytes::MaxBytes;
789		ColumnData::Blob {
790			container: BlobContainer::with_capacity(capacity),
791			max_bytes: MaxBytes::MAX,
792		}
793	}
794
795	pub fn blob_with_bitvec(data: impl IntoIterator<Item = Blob>, bitvec: impl Into<BitVec>) -> Self {
796		use reifydb_type::value::constraint::bytes::MaxBytes;
797		let data = data.into_iter().collect::<Vec<_>>();
798		let bitvec = bitvec.into();
799		assert_eq!(bitvec.len(), data.len());
800		ColumnData::Blob {
801			container: BlobContainer::new(data, bitvec),
802			max_bytes: MaxBytes::MAX,
803		}
804	}
805
806	pub fn identity_id(identity_ids: impl IntoIterator<Item = IdentityId>) -> Self {
807		let data = identity_ids.into_iter().collect::<Vec<_>>();
808		ColumnData::IdentityId(IdentityIdContainer::from_vec(data))
809	}
810
811	pub fn identity_id_optional(identity_ids: impl IntoIterator<Item = Option<IdentityId>>) -> Self {
812		let mut values = Vec::new();
813		let mut bitvec = Vec::new();
814
815		for opt in identity_ids {
816			match opt {
817				Some(value) => {
818					values.push(value);
819					bitvec.push(true);
820				}
821				None => {
822					values.push(IdentityId::default());
823					bitvec.push(false);
824				}
825			}
826		}
827
828		ColumnData::IdentityId(IdentityIdContainer::new(values, BitVec::from(bitvec)))
829	}
830
831	pub fn identity_id_with_capacity(capacity: usize) -> Self {
832		ColumnData::IdentityId(IdentityIdContainer::with_capacity(capacity))
833	}
834
835	pub fn identity_id_with_bitvec(
836		identity_ids: impl IntoIterator<Item = IdentityId>,
837		bitvec: impl Into<BitVec>,
838	) -> Self {
839		let data = identity_ids.into_iter().collect::<Vec<_>>();
840		let bitvec = bitvec.into();
841		assert_eq!(bitvec.len(), data.len());
842		ColumnData::IdentityId(IdentityIdContainer::new(data, bitvec))
843	}
844
845	pub fn int(data: impl IntoIterator<Item = Int>) -> Self {
846		use reifydb_type::value::constraint::bytes::MaxBytes;
847		let data = data.into_iter().collect::<Vec<_>>();
848		ColumnData::Int {
849			container: NumberContainer::from_vec(data),
850			max_bytes: MaxBytes::MAX,
851		}
852	}
853
854	pub fn int_optional(data: impl IntoIterator<Item = Option<Int>>) -> Self {
855		use reifydb_type::value::constraint::bytes::MaxBytes;
856		let mut values = Vec::new();
857		let mut bitvec = Vec::new();
858
859		for opt in data {
860			match opt {
861				Some(value) => {
862					values.push(value);
863					bitvec.push(true);
864				}
865				None => {
866					values.push(Int::default());
867					bitvec.push(false);
868				}
869			}
870		}
871
872		ColumnData::Int {
873			container: NumberContainer::new(values, BitVec::from(bitvec)),
874			max_bytes: MaxBytes::MAX,
875		}
876	}
877
878	pub fn uint(data: impl IntoIterator<Item = Uint>) -> Self {
879		use reifydb_type::value::constraint::bytes::MaxBytes;
880		let data = data.into_iter().collect::<Vec<_>>();
881		ColumnData::Uint {
882			container: NumberContainer::from_vec(data),
883			max_bytes: MaxBytes::MAX,
884		}
885	}
886
887	pub fn uint_optional(data: impl IntoIterator<Item = Option<Uint>>) -> Self {
888		use reifydb_type::value::constraint::bytes::MaxBytes;
889		let mut values = Vec::new();
890		let mut bitvec = Vec::new();
891
892		for opt in data {
893			match opt {
894				Some(value) => {
895					values.push(value);
896					bitvec.push(true);
897				}
898				None => {
899					values.push(Uint::default());
900					bitvec.push(false);
901				}
902			}
903		}
904
905		ColumnData::Uint {
906			container: NumberContainer::new(values, BitVec::from(bitvec)),
907			max_bytes: MaxBytes::MAX,
908		}
909	}
910
911	pub fn int_with_capacity(capacity: usize) -> Self {
912		use reifydb_type::value::constraint::bytes::MaxBytes;
913		ColumnData::Int {
914			container: NumberContainer::with_capacity(capacity),
915			max_bytes: MaxBytes::MAX,
916		}
917	}
918
919	pub fn uint_with_capacity(capacity: usize) -> Self {
920		use reifydb_type::value::constraint::bytes::MaxBytes;
921		ColumnData::Uint {
922			container: NumberContainer::with_capacity(capacity),
923			max_bytes: MaxBytes::MAX,
924		}
925	}
926
927	pub fn int_with_bitvec(data: impl IntoIterator<Item = Int>, bitvec: impl Into<BitVec>) -> Self {
928		use reifydb_type::value::constraint::bytes::MaxBytes;
929		let data = data.into_iter().collect::<Vec<_>>();
930		let bitvec = bitvec.into();
931		assert_eq!(bitvec.len(), data.len());
932		ColumnData::Int {
933			container: NumberContainer::new(data, bitvec),
934			max_bytes: MaxBytes::MAX,
935		}
936	}
937
938	pub fn uint_with_bitvec(data: impl IntoIterator<Item = Uint>, bitvec: impl Into<BitVec>) -> Self {
939		use reifydb_type::value::constraint::bytes::MaxBytes;
940		let data = data.into_iter().collect::<Vec<_>>();
941		let bitvec = bitvec.into();
942		assert_eq!(bitvec.len(), data.len());
943		ColumnData::Uint {
944			container: NumberContainer::new(data, bitvec),
945			max_bytes: MaxBytes::MAX,
946		}
947	}
948
949	pub fn decimal(data: impl IntoIterator<Item = Decimal>) -> Self {
950		use reifydb_type::value::constraint::{precision::Precision, scale::Scale};
951		let data = data.into_iter().collect::<Vec<_>>();
952		ColumnData::Decimal {
953			container: NumberContainer::from_vec(data),
954			precision: Precision::MAX,
955			scale: Scale::new(0),
956		}
957	}
958
959	pub fn decimal_optional(data: impl IntoIterator<Item = Option<Decimal>>) -> Self {
960		use reifydb_type::value::constraint::{precision::Precision, scale::Scale};
961		let mut values = Vec::new();
962		let mut bitvec = Vec::new();
963
964		for opt in data {
965			match opt {
966				Some(value) => {
967					values.push(value);
968					bitvec.push(true);
969				}
970				None => {
971					values.push(Decimal::default());
972					bitvec.push(false);
973				}
974			}
975		}
976
977		ColumnData::Decimal {
978			container: NumberContainer::new(values, BitVec::from(bitvec)),
979			precision: Precision::MAX,
980			scale: Scale::new(0),
981		}
982	}
983
984	pub fn decimal_with_capacity(capacity: usize) -> Self {
985		use reifydb_type::value::constraint::{precision::Precision, scale::Scale};
986		ColumnData::Decimal {
987			container: NumberContainer::with_capacity(capacity),
988			precision: Precision::MAX,
989			scale: Scale::new(0),
990		}
991	}
992
993	pub fn decimal_with_bitvec(data: impl IntoIterator<Item = Decimal>, bitvec: impl Into<BitVec>) -> Self {
994		use reifydb_type::value::constraint::{precision::Precision, scale::Scale};
995		let data = data.into_iter().collect::<Vec<_>>();
996		let bitvec = bitvec.into();
997		assert_eq!(bitvec.len(), data.len());
998		ColumnData::Decimal {
999			container: NumberContainer::new(data, bitvec),
1000			precision: Precision::MAX,
1001			scale: Scale::new(0),
1002		}
1003	}
1004
1005	pub fn any(data: impl IntoIterator<Item = Box<reifydb_type::Value>>) -> Self {
1006		let data = data.into_iter().collect::<Vec<_>>();
1007		ColumnData::Any(AnyContainer::from_vec(data))
1008	}
1009
1010	pub fn any_optional(data: impl IntoIterator<Item = Option<Box<reifydb_type::Value>>>) -> Self {
1011		let mut values = Vec::new();
1012		let mut bitvec = Vec::new();
1013
1014		for opt in data {
1015			match opt {
1016				Some(value) => {
1017					values.push(value);
1018					bitvec.push(true);
1019				}
1020				None => {
1021					values.push(Box::new(reifydb_type::Value::Undefined));
1022					bitvec.push(false);
1023				}
1024			}
1025		}
1026
1027		ColumnData::Any(AnyContainer::new(values, BitVec::from(bitvec)))
1028	}
1029
1030	pub fn any_with_capacity(capacity: usize) -> Self {
1031		ColumnData::Any(AnyContainer::with_capacity(capacity))
1032	}
1033
1034	pub fn any_with_bitvec(
1035		data: impl IntoIterator<Item = Box<reifydb_type::Value>>,
1036		bitvec: impl Into<BitVec>,
1037	) -> Self {
1038		let data = data.into_iter().collect::<Vec<_>>();
1039		let bitvec = bitvec.into();
1040		assert_eq!(bitvec.len(), data.len());
1041		ColumnData::Any(AnyContainer::new(data, bitvec))
1042	}
1043
1044	pub fn undefined(len: usize) -> Self {
1045		ColumnData::Undefined(UndefinedContainer::new(len))
1046	}
1047}
reifydb_core/value/column/data/factory.rs

reifydb_core/value/column/data/
factory.rs
