Struct QueryBuilder 

pub struct QueryBuilder<'a> { /* private fields */ }

Query builder for fluent query construction

Implementations

impl<'a> QueryBuilder<'a>

pub fn columns(self, cols: &[&str]) -> Self

Select specific columns (for I/O reduction)

pub fn limit(self, n: usize) -> Self

Limit results

pub fn offset(self, n: usize) -> Self

Skip results

pub fn execute(self) -> Result<QueryResult>

Execute the query

Scans packed rows and unpacks them. Each key is “table/row_id” pointing to a packed row.

pub fn to_toon(self) -> Result<String>

Execute and return TOON format (for LLM efficiency)

pub fn execute_iter(self) -> Result<QueryRowIterator>

Execute with lazy iteration - avoids materializing all rows

Returns an iterator over rows as Vec<SochValue> in schema column order. This is more memory-efficient than execute() for large result sets.

Performance

• No upfront materialization of all rows
• ~40% less memory for large result sets
• Ideal for streaming to network or aggregations

Example

for row_result in db.query(txn, "users").execute_iter()? {
    let row = row_result?;
    // row is Vec<SochValue> in column order
}

pub fn as_columnar(self) -> Result<ColumnarQueryResult>

Execute and return columnar (SIMD-friendly) result format

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

Performance Benefits

• SIMD: Aggregate operations (sum, avg) use vectorized instructions
• Cache: Sequential access maximizes L1/L2 hits
• Memory: ~30% less overhead than row-based format
• Analytics: Ideal for ML preprocessing and statistics

Example

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

// SIMD-optimized sum
let total = result.sum_i64("score").unwrap_or(0);

// Direct column access
if let Some(scores) = result.column("score") {
    for i in 0..scores.len() {
        if let Some(v) = scores.get_i64(i) {
            println!("Score: {}", v);
        }
    }
}