reifydb_core/value/column/

mod.rs

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2025 ReifyDB

//! Columnar data model used by the engine and every consumer of query results.
//!
//! A column is a typed, possibly-nullable, possibly-dictionary-encoded buffer of values plus statistics, encoding
//! metadata, and a none-bitmap.
//!
//! Invariant: a column's `RowMask` and `NoneBitmap` are always exactly aligned to its logical row count. Operations
//! that grow or shrink the buffer must update the mask and bitmap atomically with respect to consumers; an off-by-one
//! between length and mask silently produces wrong results in filter and aggregation paths.

use std::fmt;

use reifydb_type::{
	fragment::Fragment,
	util::bitvec::BitVec,
	value::{
		dictionary::DictionaryEntryId,
		r#type::Type,
		uuid::{Uuid4, Uuid7},
	},
};

use crate::value::column::{buffer::ColumnBuffer, data::Column};

pub mod buffer;
pub mod columns;
pub mod compressed;
pub mod data;
pub mod encoding;
pub mod frame;
pub mod headers;
pub mod mask;
pub mod nones;
pub mod push;
pub mod row;
pub mod row_ref;
pub mod stats;
pub mod transform;
pub mod view;

pub struct ColumnWithName {
	pub name: Fragment,
	pub data: ColumnBuffer,
}

impl Clone for ColumnWithName {
	fn clone(&self) -> Self {
		Self {
			name: self.name.clone(),
			data: self.data.clone(),
		}
	}
}

impl PartialEq for ColumnWithName {
	fn eq(&self, other: &Self) -> bool {
		self.name == other.name && self.data == other.data
	}
}

impl fmt::Debug for ColumnWithName {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		f.debug_struct("ColumnWithName").field("name", &self.name).field("data", &self.data).finish()
	}
}

impl ColumnWithName {
	pub fn new(name: impl Into<Fragment>, data: ColumnBuffer) -> Self {
		Self {
			name: name.into(),
			data,
		}
	}

	pub fn from_column(name: impl Into<Fragment>, column: Column) -> Self {
		let buffer = column
			.to_canonical()
			.map(|c| c.to_buffer())
			.unwrap_or_else(|_| panic!("ColumnWithName::from_column: to_canonical failed"));
		Self {
			name: name.into(),
			data: buffer,
		}
	}

	pub fn get_type(&self) -> Type {
		self.data.get_type()
	}

	pub fn with_new_data(&self, data: ColumnBuffer) -> ColumnWithName {
		ColumnWithName {
			name: self.name.clone(),
			data,
		}
	}

	pub fn name(&self) -> &Fragment {
		&self.name
	}

	pub fn name_owned(&self) -> Fragment {
		self.name.clone()
	}

	pub fn data(&self) -> &ColumnBuffer {
		&self.data
	}

	pub fn data_mut(&mut self) -> &mut ColumnBuffer {
		&mut self.data
	}

	pub fn column(&self) -> Column {
		Column::from_column_buffer(self.data.clone())
	}

	pub fn to_static(&self) -> ColumnWithName {
		self.clone()
	}
}

impl ColumnWithName {
	pub fn int1(name: impl Into<Fragment>, data: impl IntoIterator<Item = i8>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::int1(data),
		}
	}

	pub fn int1_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = i8>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::int1_with_bitvec(data, bitvec),
		}
	}

	pub fn int2(name: impl Into<Fragment>, data: impl IntoIterator<Item = i16>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::int2(data),
		}
	}

	pub fn int2_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = i16>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::int2_with_bitvec(data, bitvec),
		}
	}

	pub fn int4(name: impl Into<Fragment>, data: impl IntoIterator<Item = i32>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::int4(data),
		}
	}

	pub fn int4_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = i32>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::int4_with_bitvec(data, bitvec),
		}
	}

	pub fn int8(name: impl Into<Fragment>, data: impl IntoIterator<Item = i64>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::int8(data),
		}
	}

	pub fn int8_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = i64>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::int8_with_bitvec(data, bitvec),
		}
	}

	pub fn int16(name: impl Into<Fragment>, data: impl IntoIterator<Item = i128>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::int16(data),
		}
	}

	pub fn int16_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = i128>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::int16_with_bitvec(data, bitvec),
		}
	}

	pub fn uint1(name: impl Into<Fragment>, data: impl IntoIterator<Item = u8>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::uint1(data),
		}
	}

	pub fn uint1_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = u8>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::uint1_with_bitvec(data, bitvec),
		}
	}

	pub fn uint2(name: impl Into<Fragment>, data: impl IntoIterator<Item = u16>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::uint2(data),
		}
	}

	pub fn uint2_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = u16>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::uint2_with_bitvec(data, bitvec),
		}
	}

	pub fn uint4(name: impl Into<Fragment>, data: impl IntoIterator<Item = u32>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::uint4(data),
		}
	}

	pub fn uint4_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = u32>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::uint4_with_bitvec(data, bitvec),
		}
	}

	pub fn uint8(name: impl Into<Fragment>, data: impl IntoIterator<Item = u64>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::uint8(data),
		}
	}

	pub fn uint8_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = u64>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::uint8_with_bitvec(data, bitvec),
		}
	}

	pub fn uint16(name: impl Into<Fragment>, data: impl IntoIterator<Item = u128>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::uint16(data),
		}
	}

	pub fn uint16_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = u128>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::uint16_with_bitvec(data, bitvec),
		}
	}

	pub fn float4(name: impl Into<Fragment>, data: impl IntoIterator<Item = f32>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::float4(data),
		}
	}

	pub fn float4_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = f32>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::float4_with_bitvec(data, bitvec),
		}
	}

	pub fn float8(name: impl Into<Fragment>, data: impl IntoIterator<Item = f64>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::float8(data),
		}
	}

	pub fn float8_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = f64>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::float8_with_bitvec(data, bitvec),
		}
	}

	pub fn bool(name: impl Into<Fragment>, data: impl IntoIterator<Item = bool>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::bool(data),
		}
	}

	pub fn bool_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = bool>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::bool_with_bitvec(data, bitvec),
		}
	}

	pub fn utf8(name: impl Into<Fragment>, data: impl IntoIterator<Item = String>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::utf8(data),
		}
	}

	pub fn utf8_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = String>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::utf8_with_bitvec(data, bitvec),
		}
	}

	pub fn uuid4(name: impl Into<Fragment>, data: impl IntoIterator<Item = Uuid4>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::uuid4(data),
		}
	}

	pub fn uuid4_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = Uuid4>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::uuid4_with_bitvec(data, bitvec),
		}
	}

	pub fn uuid7(name: impl Into<Fragment>, data: impl IntoIterator<Item = Uuid7>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::uuid7(data),
		}
	}

	pub fn uuid7_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = Uuid7>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::uuid7_with_bitvec(data, bitvec),
		}
	}

	pub fn dictionary_id(name: impl Into<Fragment>, data: impl IntoIterator<Item = DictionaryEntryId>) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::dictionary_id(data),
		}
	}

	pub fn dictionary_id_with_bitvec(
		name: impl Into<Fragment>,
		data: impl IntoIterator<Item = DictionaryEntryId>,
		bitvec: impl Into<BitVec>,
	) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::dictionary_id_with_bitvec(data, bitvec),
		}
	}

	pub fn undefined_typed(name: impl Into<Fragment>, ty: Type, row_count: usize) -> Self {
		ColumnWithName {
			name: name.into(),
			data: ColumnBuffer::none_typed(ty, row_count),
		}
	}
}