Struct Row 

pub struct Row { /* private fields */ }

A database row containing column values

Row provides methods for accessing and manipulating column values while maintaining type safety and consistency with the schema.

Performance

• Shared storage: O(1) clone (just Arc increment)
• Owned storage: O(n) clone (copies values)
• String values use SmartString with internal Arc for efficient sharing

Implementations

impl Row

pub fn new() -> Self

Create a new empty row

pub fn with_capacity(capacity: usize) -> Self

Create a row with pre-allocated capacity

pub fn from_values(values: Vec<Value>) -> Self

Create a row from a vector of values

pub fn from_compact_vec(values: CompactVec<Value>) -> Self

Create a row from CompactVec

pub fn from_arc(values: CompactArc<[Value]>) -> Self

Create a row from an Arc slice - O(1), no copying

pub fn from_combined(left: &Row, right: &Row) -> Self

Create a row by combining two rows (for JOINs) Result uses Owned storage (optimal for intermediate results)

pub fn combine_into(&mut self, left: &Row, right: &Row)

Combine two rows into this row buffer (for JOINs) - reuses allocation

pub fn combine_into_clone_move(&mut self, left: &Row, right: Row)

Combine rows: clone left, move right (for JOINs) - reuses allocation

pub fn combine_into_owned(&mut self, left: Row, right: Row)

Combine rows: move both (for JOINs) - reuses allocation

pub fn from_combined_clone_move(left: &Row, right: Row) -> Self

Combine rows: clone left, move right (for JOINs)

pub fn from_combined_owned(left: Row, right: Row) -> Self

Combine two owned rows (for JOINs) - moves values without cloning

pub fn null_row(schema: &Schema) -> Self

Create a row with null values for a given schema

pub fn len(&self) -> usize

Get the number of values in the row

pub fn is_empty(&self) -> bool

Check if the row is empty

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

Get a value by index

pub fn get_mut(&mut self, index: usize) -> Option<&mut Value>

Get a mutable value by index (triggers copy-on-write if shared)

pub fn set(&mut self, index: usize, value: Value) -> Result<()>

Set a value at the given index (triggers copy-on-write if shared)

pub fn push(&mut self, value: Value)

Push a value to the end of the row

pub fn pop(&mut self) -> Option<Value>

Pop a value from the end of the row

pub fn truncate(&mut self, len: usize)

Truncate the row to a specific length

pub fn clear(&mut self)

Clear the row values while keeping allocated capacity

pub fn take_and_clear(&mut self) -> Row

Take the values from this row, returning them in a new Row. The original row is cleared but keeps its allocated capacity.

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

Reserve capacity for at least additional more values

pub fn extend_from_slice(&mut self, other: &[Value])

Extend the row with values from a slice

pub fn extend_into_compact_vec(self, target: &mut CompactVec<Value>)

Extend a CompactVec with this row’s values, consuming self.

OPTIMIZATION: This avoids the intermediate Vec allocation that would occur with target.extend(row) which goes through Row::into_iter().

• Owned storage: directly extends from CompactVec (moves values)
• Shared storage: clones values from Arc slice

pub fn iter(&self) -> RowIter<'_>

Get an iterator over the values

pub fn iter_mut(&mut self) -> RowIterMut<'_>

Get a mutable iterator over the values (triggers copy-on-write if shared)

pub fn into_values(self) -> Vec<Value>

Get the underlying vector of values, consuming the row

pub fn take_first_value(self) -> Option<Value>

Extract the first value, consuming the row

pub fn is_shared(&self) -> bool

Check if storage is shared (Arc-wrapped)

pub fn is_owned(&self) -> bool

Check if storage is owned

pub fn into_arc(self) -> CompactArc<[Value]>

Convert Row to CompactArc<Value>, consuming self

• Shared: returns the CompactArc directly (O(1))
• Owned: creates new Arc (O(n))

pub fn into_shared(self) -> Self

Convert to Shared storage for O(1) clone.

Use this when the row will be cloned multiple times (e.g., hash join build side). After conversion, row.clone() is just an Arc increment.

pub fn as_arc(&self) -> Option<&CompactArc<[Value]>>

Get CompactArc<Value> reference if shared, None if owned

pub fn as_slice(&self) -> &[Value]

Get slice of values

pub fn select_columns(&self, indices: &[usize]) -> Result<Row>

Extract specific columns by their indices

pub fn take_columns(self, indices: &[usize]) -> Row

Take specific columns by their indices, consuming the row Detects prefix projections (0, 1, 2, …, n-1) and truncates in-place.

pub fn validate(&self, schema: &Schema) -> Result<()>

Validate the row against a schema

pub fn clone_subset(&self, indices: &[usize]) -> Row

Clone the row, selecting only the specified column indices

pub fn concat(&self, other: &Row) -> Row

Concatenate two rows

pub fn repeat(value: Value, count: usize) -> Row

Create a row by repeating a value

pub fn is_inline(&self) -> bool

Alias for is_owned (backwards compatibility)

pub fn clear_inline(&mut self)

Clear and use as inline storage (backwards compatibility)

pub fn push_inline(&mut self, value: Value)

Push to inline storage (backwards compatibility)

pub fn reserve_inline(&mut self, capacity: usize)

Reserve inline capacity (backwards compatibility)

pub fn refill_inline<I: Iterator<Item = Value>>(&mut self, values: I)

Refill with values (backwards compatibility)

Trait Implementations

impl Clone for Row

fn clone(&self) -> Row

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Row

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

Formats the value using the given formatter.

impl Default for Row

fn default() -> Row

Returns the “default value” for a type.

impl Display for Row

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

Formats the value using the given formatter.

impl From<CompactArc<[Value]>> for Row

fn from(values: CompactArc<[Value]>) -> Self

Converts to this type from the input type.

impl From<Vec<Value>> for Row

fn from(values: Vec<Value>) -> Self

Converts to this type from the input type.

impl FromIterator<Value> for Row

fn from_iter<I: IntoIterator<Item = Value>>(iter: I) -> Self

Creates a value from an iterator.

impl Index<usize> for Row

type Output = Value

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> IntoIterator for &'a Row

type Item = &'a Value

The type of the elements being iterated over.

type IntoIter = RowIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for Row

type Item = Value

The type of the elements being iterated over.

type IntoIter = IntoIter<Value>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Row

fn eq(&self, other: &Row) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Row