Struct ColumnVector 

pub struct ColumnVector<T: FixedSize> { /* private fields */ }

Generic column for numeric types

Implementations

impl<T: FixedSize + Clone + Send + Sync + 'static> ColumnVector<T>

pub fn from_vec(type_: Type, data: Vec<T>) -> Self

Create a column from an explicit type and a pre-built vector of values.

pub fn with_data(self, data: Vec<T>) -> Self

Create a column with initial data (builder pattern)

pub fn reserve(&mut self, additional: usize)

Reserve capacity for additional elements (for benchmarking/optimization)

pub fn clear(&mut self)

Clear the column while preserving capacity (for benchmarking/optimization)

pub fn get(&self, index: usize) -> Option<&T>

Return a reference to the value at the given index, or None if out of bounds.

pub fn at(&self, index: usize) -> T

Get value at index (panics if out of bounds - for tests)

pub fn len(&self) -> usize

Get the number of elements (alias for size())

pub fn is_empty(&self) -> bool

Check if the column is empty

pub fn append(&mut self, value: T)

Append a single value to the end of the column.

pub fn iter(&self) -> impl Iterator<Item = &T>

Return an iterator over references to the column values.

pub fn data(&self) -> &[T]

Return a slice reference to the underlying data.

pub fn data_mut(&mut self) -> &mut Vec<T>

Return a mutable reference to the underlying data vector.

impl<T: FixedSize + ToType + Clone + Send + Sync + 'static> ColumnVector<T>

Type-inferred constructors for ColumnVector Implements the type map pattern from C++ Type::CreateSimple<T>()

pub fn new() -> Self

Create a new column with type inferred from T Equivalent to C++ pattern where type is determined from template parameter

Examples

use clickhouse_native_client::column::{Column, ColumnVector};
use clickhouse_native_client::types::Type;

let col = ColumnVector::<i32>::new();
assert_eq!(col.column_type(), &Type::int32());

pub fn with_capacity(capacity: usize) -> Self

Create a new column with type inferred from T and specified capacity

Examples

use clickhouse_native_client::column::ColumnVector;

let col = ColumnVector::<u64>::with_capacity(100);
assert_eq!(col.len(), 0);

Trait Implementations

impl<T: FixedSize + ToType> Column for ColumnVector<T>

fn column_type(&self) -> &Type

Get the type of this column

fn size(&self) -> usize

Get the number of rows in this column

fn clear(&mut self)

Clear all data from the column

fn reserve(&mut self, new_cap: usize)

Reserve capacity for at least new_cap elements

fn append_column(&mut self, other: ColumnRef) -> Result<()>

Append another column’s data to this column

fn load_from_buffer(&mut self, buffer: &mut &[u8], rows: usize) -> Result<()>

Load column data from byte buffer

fn save_to_buffer(&self, buffer: &mut BytesMut) -> Result<()>

Save column data to byte buffer

fn clone_empty(&self) -> ColumnRef

Create an empty clone of this column (same type, no data)

fn slice(&self, begin: usize, len: usize) -> Result<ColumnRef>

Create a slice of this column

fn as_any(&self) -> &dyn Any

Downcast to a concrete column type

fn as_any_mut(&mut self) -> &mut dyn Any

Downcast to a mutable concrete column type

fn load_prefix(&mut self, _buffer: &mut &[u8], _rows: usize) -> Result<()>

Load column prefix from byte buffer (for types that need prefix data) Default implementation is a no-op. Override for types like LowCardinality. This matches C++ clickhouse-cpp’s LoadPrefix pattern.

fn save_prefix(&self, _buffer: &mut BytesMut) -> Result<()>

Save column prefix to byte buffer (for types that need prefix data) Default implementation is a no-op. Override for types like LowCardinality, Array with special nested types. This matches C++ clickhouse-cpp’s SavePrefix pattern.

impl<T: FixedSize + ToType + Clone + Send + Sync + 'static> ColumnTyped<T> for ColumnVector<T>

fn get(&self, index: usize) -> Option<T>

Get value at index

fn append(&mut self, value: T)

Append a value to the column

impl<T: FixedSize + ToType + Clone + Send + Sync + 'static> Default for ColumnVector<T>

fn default() -> Self

Returns the “default value” for a type.