Struct ColumnarQueryResult 

pub struct ColumnarQueryResult {
    pub columns: Vec<String>,
    pub data: Vec<TypedColumn>,
    pub row_count: usize,
    pub bytes_read: usize,
}

Columnar query result - SIMD-friendly format for analytics

Instead of row-oriented Vec<HashMap<String, SochValue>>, this returns column-oriented Vec<TypedColumn> for efficient vectorized operations.

Memory Layout

Row-oriented (standard):

Row 0: [id=1, name="Alice", score=85]
Row 1: [id=2, name="Bob", score=92]
Row 2: [id=3, name="Carol", score=78]

Column-oriented (this format):

id:    [1, 2, 3]           ← contiguous i64 array (SIMD-friendly)
name:  ["Alice", "Bob", "Carol"] ← Arrow-style string encoding
score: [85, 92, 78]        ← contiguous i64 array

Performance Benefits

• SIMD: Column sums use vectorized instructions (~8× faster)
• Cache: Sequential access pattern maximizes L1/L2 cache hits
• Compression: Same-type data compresses better (5-10× typical)
• Filtering: Bitmap operations instead of row iteration

Usage

let result = db.query(txn, "users")
    .columns(&["id", "score"])
    .as_columnar()?;

// SIMD sum
let total_score = result.column("score")
    .map(|c| c.sum_i64())
    .unwrap_or(0);

// Stats
println!("Rows: {}, Memory: {} bytes", result.row_count(), result.memory_size());

Fields

columns: Vec<String>

Column names in order

data: Vec<TypedColumn>

Column data - each TypedColumn contains all values for one column

row_count: usize

Number of rows

bytes_read: usize

Bytes read from storage

Implementations

impl ColumnarQueryResult

pub fn empty() -> Self

Create an empty result

pub fn column(&self, name: &str) -> Option<&CoreTypedColumn>

Get column by name

pub fn column_index(&self, name: &str) -> Option<usize>

Get column index by name

pub fn row_count(&self) -> usize

Number of rows

pub fn column_count(&self) -> usize

Number of columns

pub fn memory_size(&self) -> usize

Total memory size in bytes

pub fn sum_i64(&self, column: &str) -> Option<i64>

Sum of an i64 column (SIMD-optimized)

pub fn sum_f64(&self, column: &str) -> Option<f64>

Sum of an f64 column (SIMD-optimized)

pub fn row_view(&self, index: usize) -> Option<ColumnarRowView<'_>>

Zero-allocation row access by index.

Returns a lightweight view that resolves column values on demand from the underlying columnar arrays — no HashMap per row.

let result = query.as_columnar()?;
for i in 0..result.row_count() {
    let row = result.row_view(i).unwrap();
    let name = row.get("name"); // SochValue::Text(...)
}

pub fn into_query_result(self) -> QueryResult

Convert to row-oriented QueryResult for backward compatibility.

This materialises one HashMap<String, SochValue> per row, so prefer using row_view() or direct columnar access when performance matters.

pub fn column_stats(&self, column: &str) -> Option<&ColumnStats>

Get column statistics (min, max, null count)

pub fn to_toon(&self) -> String

Convert to TOON format (token-efficient)

Trait Implementations

impl Clone for ColumnarQueryResult

fn clone(&self) -> ColumnarQueryResult

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ColumnarQueryResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.