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, RowNumber, Time, Uint, Uuid4, Uuid7};
5
6use crate::{
7	BitVec,
8	value::{
9		column::ColumnData,
10		container::{
11			AnyContainer, BlobContainer, BoolContainer, IdentityIdContainer, NumberContainer,
12			RowNumberContainer, 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<'a>(
348		data: impl IntoIterator<Item = impl Into<String>>,
349		bitvec: impl Into<BitVec>,
350	) -> Self {
351		use reifydb_type::value::constraint::bytes::MaxBytes;
352		let data = data.into_iter().map(Into::into).collect::<Vec<_>>();
353		let bitvec = bitvec.into();
354		assert_eq!(bitvec.len(), data.len());
355		ColumnData::Utf8 {
356			container: Utf8Container::new(data, bitvec),
357			max_bytes: MaxBytes::MAX,
358		}
359	}
360
361	pub fn uint1(data: impl IntoIterator<Item = u8>) -> Self {
362		let data = data.into_iter().collect::<Vec<_>>();
363		ColumnData::Uint1(NumberContainer::from_vec(data))
364	}
365
366	pub fn uint1_optional(data: impl IntoIterator<Item = Option<u8>>) -> Self {
367		let mut values = Vec::new();
368		let mut bitvec = Vec::new();
369
370		for opt in data {
371			match opt {
372				Some(value) => {
373					values.push(value);
374					bitvec.push(true);
375				}
376				None => {
377					values.push(0);
378					bitvec.push(false);
379				}
380			}
381		}
382
383		ColumnData::Uint1(NumberContainer::new(values, BitVec::from(bitvec)))
384	}
385
386	pub fn uint1_with_capacity(capacity: usize) -> Self {
387		ColumnData::Uint1(NumberContainer::with_capacity(capacity))
388	}
389
390	pub fn uint1_with_bitvec(data: impl IntoIterator<Item = u8>, bitvec: impl Into<BitVec>) -> Self {
391		let data = data.into_iter().collect::<Vec<_>>();
392		let bitvec = bitvec.into();
393		assert_eq!(bitvec.len(), data.len());
394		ColumnData::Uint1(NumberContainer::new(data, bitvec))
395	}
396
397	pub fn uint2(data: impl IntoIterator<Item = u16>) -> Self {
398		let data = data.into_iter().collect::<Vec<_>>();
399		ColumnData::Uint2(NumberContainer::from_vec(data))
400	}
401
402	pub fn uint2_optional(data: impl IntoIterator<Item = Option<u16>>) -> Self {
403		let mut values = Vec::new();
404		let mut bitvec = Vec::new();
405
406		for opt in data {
407			match opt {
408				Some(value) => {
409					values.push(value);
410					bitvec.push(true);
411				}
412				None => {
413					values.push(0);
414					bitvec.push(false);
415				}
416			}
417		}
418
419		ColumnData::Uint2(NumberContainer::new(values, BitVec::from(bitvec)))
420	}
421
422	pub fn uint2_with_capacity(capacity: usize) -> Self {
423		ColumnData::Uint2(NumberContainer::with_capacity(capacity))
424	}
425
426	pub fn uint2_with_bitvec(data: impl IntoIterator<Item = u16>, bitvec: impl Into<BitVec>) -> Self {
427		let data = data.into_iter().collect::<Vec<_>>();
428		let bitvec = bitvec.into();
429		assert_eq!(bitvec.len(), data.len());
430		ColumnData::Uint2(NumberContainer::new(data, bitvec))
431	}
432
433	pub fn uint4(data: impl IntoIterator<Item = u32>) -> Self {
434		let data = data.into_iter().collect::<Vec<_>>();
435		ColumnData::Uint4(NumberContainer::from_vec(data))
436	}
437
438	pub fn uint4_optional(data: impl IntoIterator<Item = Option<u32>>) -> Self {
439		let mut values = Vec::new();
440		let mut bitvec = Vec::new();
441
442		for opt in data {
443			match opt {
444				Some(value) => {
445					values.push(value);
446					bitvec.push(true);
447				}
448				None => {
449					values.push(0);
450					bitvec.push(false);
451				}
452			}
453		}
454
455		ColumnData::Uint4(NumberContainer::new(values, BitVec::from(bitvec)))
456	}
457
458	pub fn uint4_with_capacity(capacity: usize) -> Self {
459		ColumnData::Uint4(NumberContainer::with_capacity(capacity))
460	}
461
462	pub fn uint4_with_bitvec(data: impl IntoIterator<Item = u32>, bitvec: impl Into<BitVec>) -> Self {
463		let data = data.into_iter().collect::<Vec<_>>();
464		let bitvec = bitvec.into();
465		assert_eq!(bitvec.len(), data.len());
466		ColumnData::Uint4(NumberContainer::new(data, bitvec))
467	}
468
469	pub fn uint8(data: impl IntoIterator<Item = u64>) -> Self {
470		let data = data.into_iter().collect::<Vec<_>>();
471		ColumnData::Uint8(NumberContainer::from_vec(data))
472	}
473
474	pub fn uint8_optional(data: impl IntoIterator<Item = Option<u64>>) -> Self {
475		let mut values = Vec::new();
476		let mut bitvec = Vec::new();
477
478		for opt in data {
479			match opt {
480				Some(value) => {
481					values.push(value);
482					bitvec.push(true);
483				}
484				None => {
485					values.push(0);
486					bitvec.push(false);
487				}
488			}
489		}
490
491		ColumnData::Uint8(NumberContainer::new(values, BitVec::from(bitvec)))
492	}
493
494	pub fn uint8_with_capacity(capacity: usize) -> Self {
495		ColumnData::Uint8(NumberContainer::with_capacity(capacity))
496	}
497
498	pub fn uint8_with_bitvec(data: impl IntoIterator<Item = u64>, bitvec: impl Into<BitVec>) -> Self {
499		let data = data.into_iter().collect::<Vec<_>>();
500		let bitvec = bitvec.into();
501		assert_eq!(bitvec.len(), data.len());
502		ColumnData::Uint8(NumberContainer::new(data, bitvec))
503	}
504
505	pub fn uint16(data: impl IntoIterator<Item = u128>) -> Self {
506		let data = data.into_iter().collect::<Vec<_>>();
507		ColumnData::Uint16(NumberContainer::from_vec(data))
508	}
509
510	pub fn uint16_optional(data: impl IntoIterator<Item = Option<u128>>) -> Self {
511		let mut values = Vec::new();
512		let mut bitvec = Vec::new();
513
514		for opt in data {
515			match opt {
516				Some(value) => {
517					values.push(value);
518					bitvec.push(true);
519				}
520				None => {
521					values.push(0);
522					bitvec.push(false);
523				}
524			}
525		}
526
527		ColumnData::Uint16(NumberContainer::new(values, BitVec::from(bitvec)))
528	}
529
530	pub fn uint16_with_capacity(capacity: usize) -> Self {
531		ColumnData::Uint16(NumberContainer::with_capacity(capacity))
532	}
533
534	pub fn uint16_with_bitvec(data: impl IntoIterator<Item = u128>, bitvec: impl Into<BitVec>) -> Self {
535		let data = data.into_iter().collect::<Vec<_>>();
536		let bitvec = bitvec.into();
537		assert_eq!(bitvec.len(), data.len());
538		ColumnData::Uint16(NumberContainer::new(data, bitvec))
539	}
540
541	pub fn date(data: impl IntoIterator<Item = Date>) -> Self {
542		let data = data.into_iter().collect::<Vec<_>>();
543		ColumnData::Date(TemporalContainer::from_vec(data))
544	}
545
546	pub fn date_optional(data: impl IntoIterator<Item = Option<Date>>) -> Self {
547		let mut values = Vec::new();
548		let mut bitvec = Vec::new();
549
550		for opt in data {
551			match opt {
552				Some(value) => {
553					values.push(value);
554					bitvec.push(true);
555				}
556				None => {
557					values.push(Date::default());
558					bitvec.push(false);
559				}
560			}
561		}
562
563		ColumnData::Date(TemporalContainer::new(values, BitVec::from(bitvec)))
564	}
565
566	pub fn date_with_capacity(capacity: usize) -> Self {
567		ColumnData::Date(TemporalContainer::with_capacity(capacity))
568	}
569
570	pub fn date_with_bitvec(data: impl IntoIterator<Item = Date>, bitvec: impl Into<BitVec>) -> Self {
571		let data = data.into_iter().collect::<Vec<_>>();
572		let bitvec = bitvec.into();
573		assert_eq!(bitvec.len(), data.len());
574		ColumnData::Date(TemporalContainer::new(data, bitvec))
575	}
576
577	pub fn datetime(data: impl IntoIterator<Item = DateTime>) -> Self {
578		let data = data.into_iter().collect::<Vec<_>>();
579		ColumnData::DateTime(TemporalContainer::from_vec(data))
580	}
581
582	pub fn datetime_optional(data: impl IntoIterator<Item = Option<DateTime>>) -> Self {
583		let mut values = Vec::new();
584		let mut bitvec = Vec::new();
585
586		for opt in data {
587			match opt {
588				Some(value) => {
589					values.push(value);
590					bitvec.push(true);
591				}
592				None => {
593					values.push(DateTime::default());
594					bitvec.push(false);
595				}
596			}
597		}
598
599		ColumnData::DateTime(TemporalContainer::new(values, BitVec::from(bitvec)))
600	}
601
602	pub fn datetime_with_capacity(capacity: usize) -> Self {
603		ColumnData::DateTime(TemporalContainer::with_capacity(capacity))
604	}
605
606	pub fn datetime_with_bitvec(data: impl IntoIterator<Item = DateTime>, bitvec: impl Into<BitVec>) -> Self {
607		let data = data.into_iter().collect::<Vec<_>>();
608		let bitvec = bitvec.into();
609		assert_eq!(bitvec.len(), data.len());
610		ColumnData::DateTime(TemporalContainer::new(data, bitvec))
611	}
612
613	pub fn time(data: impl IntoIterator<Item = Time>) -> Self {
614		let data = data.into_iter().collect::<Vec<_>>();
615		ColumnData::Time(TemporalContainer::from_vec(data))
616	}
617
618	pub fn time_optional(data: impl IntoIterator<Item = Option<Time>>) -> Self {
619		let mut values = Vec::new();
620		let mut bitvec = Vec::new();
621
622		for opt in data {
623			match opt {
624				Some(value) => {
625					values.push(value);
626					bitvec.push(true);
627				}
628				None => {
629					values.push(Time::default());
630					bitvec.push(false);
631				}
632			}
633		}
634
635		ColumnData::Time(TemporalContainer::new(values, BitVec::from(bitvec)))
636	}
637
638	pub fn time_with_capacity(capacity: usize) -> Self {
639		ColumnData::Time(TemporalContainer::with_capacity(capacity))
640	}
641
642	pub fn time_with_bitvec(data: impl IntoIterator<Item = Time>, bitvec: impl Into<BitVec>) -> Self {
643		let data = data.into_iter().collect::<Vec<_>>();
644		let bitvec = bitvec.into();
645		assert_eq!(bitvec.len(), data.len());
646		ColumnData::Time(TemporalContainer::new(data, bitvec))
647	}
648
649	pub fn duration(data: impl IntoIterator<Item = Duration>) -> Self {
650		let data = data.into_iter().collect::<Vec<_>>();
651		ColumnData::Duration(TemporalContainer::from_vec(data))
652	}
653
654	pub fn duration_optional(data: impl IntoIterator<Item = Option<Duration>>) -> Self {
655		let mut values = Vec::new();
656		let mut bitvec = Vec::new();
657
658		for opt in data {
659			match opt {
660				Some(value) => {
661					values.push(value);
662					bitvec.push(true);
663				}
664				None => {
665					values.push(Duration::default());
666					bitvec.push(false);
667				}
668			}
669		}
670
671		ColumnData::Duration(TemporalContainer::new(values, BitVec::from(bitvec)))
672	}
673
674	pub fn duration_with_capacity(capacity: usize) -> Self {
675		ColumnData::Duration(TemporalContainer::with_capacity(capacity))
676	}
677
678	pub fn duration_with_bitvec(data: impl IntoIterator<Item = Duration>, bitvec: impl Into<BitVec>) -> Self {
679		let data = data.into_iter().collect::<Vec<_>>();
680		let bitvec = bitvec.into();
681		assert_eq!(bitvec.len(), data.len());
682		ColumnData::Duration(TemporalContainer::new(data, bitvec))
683	}
684
685	pub fn uuid4(data: impl IntoIterator<Item = Uuid4>) -> Self {
686		let data = data.into_iter().collect::<Vec<_>>();
687		ColumnData::Uuid4(UuidContainer::from_vec(data))
688	}
689
690	pub fn uuid4_optional(data: impl IntoIterator<Item = Option<Uuid4>>) -> Self {
691		let mut values = Vec::new();
692		let mut bitvec = Vec::new();
693
694		for opt in data {
695			match opt {
696				Some(value) => {
697					values.push(value);
698					bitvec.push(true);
699				}
700				None => {
701					values.push(Uuid4::default());
702					bitvec.push(false);
703				}
704			}
705		}
706
707		ColumnData::Uuid4(UuidContainer::new(values, BitVec::from(bitvec)))
708	}
709
710	pub fn uuid4_with_capacity(capacity: usize) -> Self {
711		ColumnData::Uuid4(UuidContainer::with_capacity(capacity))
712	}
713
714	pub fn uuid4_with_bitvec(data: impl IntoIterator<Item = Uuid4>, bitvec: impl Into<BitVec>) -> Self {
715		let data = data.into_iter().collect::<Vec<_>>();
716		let bitvec = bitvec.into();
717		assert_eq!(bitvec.len(), data.len());
718		ColumnData::Uuid4(UuidContainer::new(data, bitvec))
719	}
720
721	pub fn uuid7(data: impl IntoIterator<Item = Uuid7>) -> Self {
722		let data = data.into_iter().collect::<Vec<_>>();
723		ColumnData::Uuid7(UuidContainer::from_vec(data))
724	}
725
726	pub fn uuid7_optional(data: impl IntoIterator<Item = Option<Uuid7>>) -> Self {
727		let mut values = Vec::new();
728		let mut bitvec = Vec::new();
729
730		for opt in data {
731			match opt {
732				Some(value) => {
733					values.push(value);
734					bitvec.push(true);
735				}
736				None => {
737					values.push(Uuid7::default());
738					bitvec.push(false);
739				}
740			}
741		}
742
743		ColumnData::Uuid7(UuidContainer::new(values, BitVec::from(bitvec)))
744	}
745
746	pub fn uuid7_with_capacity(capacity: usize) -> Self {
747		ColumnData::Uuid7(UuidContainer::with_capacity(capacity))
748	}
749
750	pub fn uuid7_with_bitvec(data: impl IntoIterator<Item = Uuid7>, bitvec: impl Into<BitVec>) -> Self {
751		let data = data.into_iter().collect::<Vec<_>>();
752		let bitvec = bitvec.into();
753		assert_eq!(bitvec.len(), data.len());
754		ColumnData::Uuid7(UuidContainer::new(data, bitvec))
755	}
756
757	pub fn blob(data: impl IntoIterator<Item = Blob>) -> Self {
758		use reifydb_type::value::constraint::bytes::MaxBytes;
759		let data = data.into_iter().collect::<Vec<_>>();
760		ColumnData::Blob {
761			container: BlobContainer::from_vec(data),
762			max_bytes: MaxBytes::MAX,
763		}
764	}
765
766	pub fn blob_optional(data: impl IntoIterator<Item = Option<Blob>>) -> Self {
767		use reifydb_type::value::constraint::bytes::MaxBytes;
768		let mut values = Vec::new();
769		let mut bitvec = Vec::new();
770
771		for opt in data {
772			match opt {
773				Some(value) => {
774					values.push(value);
775					bitvec.push(true);
776				}
777				None => {
778					values.push(Blob::default());
779					bitvec.push(false);
780				}
781			}
782		}
783
784		ColumnData::Blob {
785			container: BlobContainer::new(values, BitVec::from(bitvec)),
786			max_bytes: MaxBytes::MAX,
787		}
788	}
789
790	pub fn blob_with_capacity(capacity: usize) -> Self {
791		use reifydb_type::value::constraint::bytes::MaxBytes;
792		ColumnData::Blob {
793			container: BlobContainer::with_capacity(capacity),
794			max_bytes: MaxBytes::MAX,
795		}
796	}
797
798	pub fn blob_with_bitvec(data: impl IntoIterator<Item = Blob>, bitvec: impl Into<BitVec>) -> Self {
799		use reifydb_type::value::constraint::bytes::MaxBytes;
800		let data = data.into_iter().collect::<Vec<_>>();
801		let bitvec = bitvec.into();
802		assert_eq!(bitvec.len(), data.len());
803		ColumnData::Blob {
804			container: BlobContainer::new(data, bitvec),
805			max_bytes: MaxBytes::MAX,
806		}
807	}
808
809	pub fn row_number(row_numbers: impl IntoIterator<Item = RowNumber>) -> Self {
810		let data = row_numbers.into_iter().collect::<Vec<_>>();
811		ColumnData::RowNumber(RowNumberContainer::from_vec(data))
812	}
813
814	pub fn row_number_optional(row_numbers: impl IntoIterator<Item = Option<RowNumber>>) -> Self {
815		let mut values = Vec::new();
816		let mut bitvec = Vec::new();
817
818		for opt in row_numbers {
819			match opt {
820				Some(value) => {
821					values.push(value);
822					bitvec.push(true);
823				}
824				None => {
825					values.push(RowNumber::default());
826					bitvec.push(false);
827				}
828			}
829		}
830
831		ColumnData::RowNumber(RowNumberContainer::new(values, BitVec::from(bitvec)))
832	}
833
834	pub fn row_number_with_capacity(capacity: usize) -> Self {
835		ColumnData::RowNumber(RowNumberContainer::with_capacity(capacity))
836	}
837
838	pub fn row_number_with_bitvec(
839		row_numbers: impl IntoIterator<Item = RowNumber>,
840		bitvec: impl Into<BitVec>,
841	) -> Self {
842		let data = row_numbers.into_iter().collect::<Vec<_>>();
843		let bitvec = bitvec.into();
844		assert_eq!(bitvec.len(), data.len());
845		ColumnData::RowNumber(RowNumberContainer::new(data, bitvec))
846	}
847
848	pub fn identity_id(identity_ids: impl IntoIterator<Item = IdentityId>) -> Self {
849		let data = identity_ids.into_iter().collect::<Vec<_>>();
850		ColumnData::IdentityId(IdentityIdContainer::from_vec(data))
851	}
852
853	pub fn identity_id_optional(identity_ids: impl IntoIterator<Item = Option<IdentityId>>) -> Self {
854		let mut values = Vec::new();
855		let mut bitvec = Vec::new();
856
857		for opt in identity_ids {
858			match opt {
859				Some(value) => {
860					values.push(value);
861					bitvec.push(true);
862				}
863				None => {
864					values.push(IdentityId::default());
865					bitvec.push(false);
866				}
867			}
868		}
869
870		ColumnData::IdentityId(IdentityIdContainer::new(values, BitVec::from(bitvec)))
871	}
872
873	pub fn identity_id_with_capacity(capacity: usize) -> Self {
874		ColumnData::IdentityId(IdentityIdContainer::with_capacity(capacity))
875	}
876
877	pub fn identity_id_with_bitvec(
878		identity_ids: impl IntoIterator<Item = IdentityId>,
879		bitvec: impl Into<BitVec>,
880	) -> Self {
881		let data = identity_ids.into_iter().collect::<Vec<_>>();
882		let bitvec = bitvec.into();
883		assert_eq!(bitvec.len(), data.len());
884		ColumnData::IdentityId(IdentityIdContainer::new(data, bitvec))
885	}
886
887	pub fn int(data: impl IntoIterator<Item = Int>) -> Self {
888		use reifydb_type::value::constraint::bytes::MaxBytes;
889		let data = data.into_iter().collect::<Vec<_>>();
890		ColumnData::Int {
891			container: NumberContainer::from_vec(data),
892			max_bytes: MaxBytes::MAX,
893		}
894	}
895
896	pub fn int_optional(data: impl IntoIterator<Item = Option<Int>>) -> Self {
897		use reifydb_type::value::constraint::bytes::MaxBytes;
898		let mut values = Vec::new();
899		let mut bitvec = Vec::new();
900
901		for opt in data {
902			match opt {
903				Some(value) => {
904					values.push(value);
905					bitvec.push(true);
906				}
907				None => {
908					values.push(Int::default());
909					bitvec.push(false);
910				}
911			}
912		}
913
914		ColumnData::Int {
915			container: NumberContainer::new(values, BitVec::from(bitvec)),
916			max_bytes: MaxBytes::MAX,
917		}
918	}
919
920	pub fn uint(data: impl IntoIterator<Item = Uint>) -> Self {
921		use reifydb_type::value::constraint::bytes::MaxBytes;
922		let data = data.into_iter().collect::<Vec<_>>();
923		ColumnData::Uint {
924			container: NumberContainer::from_vec(data),
925			max_bytes: MaxBytes::MAX,
926		}
927	}
928
929	pub fn uint_optional(data: impl IntoIterator<Item = Option<Uint>>) -> Self {
930		use reifydb_type::value::constraint::bytes::MaxBytes;
931		let mut values = Vec::new();
932		let mut bitvec = Vec::new();
933
934		for opt in data {
935			match opt {
936				Some(value) => {
937					values.push(value);
938					bitvec.push(true);
939				}
940				None => {
941					values.push(Uint::default());
942					bitvec.push(false);
943				}
944			}
945		}
946
947		ColumnData::Uint {
948			container: NumberContainer::new(values, BitVec::from(bitvec)),
949			max_bytes: MaxBytes::MAX,
950		}
951	}
952
953	pub fn int_with_capacity(capacity: usize) -> Self {
954		use reifydb_type::value::constraint::bytes::MaxBytes;
955		ColumnData::Int {
956			container: NumberContainer::with_capacity(capacity),
957			max_bytes: MaxBytes::MAX,
958		}
959	}
960
961	pub fn uint_with_capacity(capacity: usize) -> Self {
962		use reifydb_type::value::constraint::bytes::MaxBytes;
963		ColumnData::Uint {
964			container: NumberContainer::with_capacity(capacity),
965			max_bytes: MaxBytes::MAX,
966		}
967	}
968
969	pub fn int_with_bitvec(data: impl IntoIterator<Item = Int>, bitvec: impl Into<BitVec>) -> Self {
970		use reifydb_type::value::constraint::bytes::MaxBytes;
971		let data = data.into_iter().collect::<Vec<_>>();
972		let bitvec = bitvec.into();
973		assert_eq!(bitvec.len(), data.len());
974		ColumnData::Int {
975			container: NumberContainer::new(data, bitvec),
976			max_bytes: MaxBytes::MAX,
977		}
978	}
979
980	pub fn uint_with_bitvec(data: impl IntoIterator<Item = Uint>, bitvec: impl Into<BitVec>) -> Self {
981		use reifydb_type::value::constraint::bytes::MaxBytes;
982		let data = data.into_iter().collect::<Vec<_>>();
983		let bitvec = bitvec.into();
984		assert_eq!(bitvec.len(), data.len());
985		ColumnData::Uint {
986			container: NumberContainer::new(data, bitvec),
987			max_bytes: MaxBytes::MAX,
988		}
989	}
990
991	pub fn decimal(data: impl IntoIterator<Item = Decimal>) -> Self {
992		use reifydb_type::value::constraint::{precision::Precision, scale::Scale};
993		let data = data.into_iter().collect::<Vec<_>>();
994		ColumnData::Decimal {
995			container: NumberContainer::from_vec(data),
996			precision: Precision::MAX,
997			scale: Scale::new(0),
998		}
999	}
1000
1001	pub fn decimal_optional(data: impl IntoIterator<Item = Option<Decimal>>) -> Self {
1002		use reifydb_type::value::constraint::{precision::Precision, scale::Scale};
1003		let mut values = Vec::new();
1004		let mut bitvec = Vec::new();
1005
1006		for opt in data {
1007			match opt {
1008				Some(value) => {
1009					values.push(value);
1010					bitvec.push(true);
1011				}
1012				None => {
1013					values.push(Decimal::default());
1014					bitvec.push(false);
1015				}
1016			}
1017		}
1018
1019		ColumnData::Decimal {
1020			container: NumberContainer::new(values, BitVec::from(bitvec)),
1021			precision: Precision::MAX,
1022			scale: Scale::new(0),
1023		}
1024	}
1025
1026	pub fn decimal_with_capacity(capacity: usize) -> Self {
1027		use reifydb_type::value::constraint::{precision::Precision, scale::Scale};
1028		ColumnData::Decimal {
1029			container: NumberContainer::with_capacity(capacity),
1030			precision: Precision::MAX,
1031			scale: Scale::new(0),
1032		}
1033	}
1034
1035	pub fn decimal_with_bitvec(data: impl IntoIterator<Item = Decimal>, bitvec: impl Into<BitVec>) -> Self {
1036		use reifydb_type::value::constraint::{precision::Precision, scale::Scale};
1037		let data = data.into_iter().collect::<Vec<_>>();
1038		let bitvec = bitvec.into();
1039		assert_eq!(bitvec.len(), data.len());
1040		ColumnData::Decimal {
1041			container: NumberContainer::new(data, bitvec),
1042			precision: Precision::MAX,
1043			scale: Scale::new(0),
1044		}
1045	}
1046
1047	pub fn any(data: impl IntoIterator<Item = Box<reifydb_type::Value>>) -> Self {
1048		let data = data.into_iter().collect::<Vec<_>>();
1049		ColumnData::Any(AnyContainer::from_vec(data))
1050	}
1051
1052	pub fn any_optional(data: impl IntoIterator<Item = Option<Box<reifydb_type::Value>>>) -> Self {
1053		let mut values = Vec::new();
1054		let mut bitvec = Vec::new();
1055
1056		for opt in data {
1057			match opt {
1058				Some(value) => {
1059					values.push(value);
1060					bitvec.push(true);
1061				}
1062				None => {
1063					values.push(Box::new(reifydb_type::Value::Undefined));
1064					bitvec.push(false);
1065				}
1066			}
1067		}
1068
1069		ColumnData::Any(AnyContainer::new(values, BitVec::from(bitvec)))
1070	}
1071
1072	pub fn any_with_capacity(capacity: usize) -> Self {
1073		ColumnData::Any(AnyContainer::with_capacity(capacity))
1074	}
1075
1076	pub fn any_with_bitvec(
1077		data: impl IntoIterator<Item = Box<reifydb_type::Value>>,
1078		bitvec: impl Into<BitVec>,
1079	) -> Self {
1080		let data = data.into_iter().collect::<Vec<_>>();
1081		let bitvec = bitvec.into();
1082		assert_eq!(bitvec.len(), data.len());
1083		ColumnData::Any(AnyContainer::new(data, bitvec))
1084	}
1085
1086	pub fn undefined(len: usize) -> Self {
1087		ColumnData::Undefined(UndefinedContainer::new(len))
1088	}
1089}
reifydb_core/value/column/data/factory.rs

reifydb_core/value/column/data/
factory.rs
