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<str> 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<Value>

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_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<S: RowSchema + ?Sized>(schema: &S) -> 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 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]) -> Result<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<S: RowSchema + ?Sized>(&self, schema: &S) -> Result<()>

Validate the row against a schema

pub fn clone_subset(&self, indices: &[usize]) -> Result<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)

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 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<'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 PartialEq for Row

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Row