Struct TableIndex 

pub struct TableIndex {
    pub key_type: AlgebraicType,
    pub indexed_columns: ColList,
    /* private fields */
}

An index on a set of [ColId]s of a table.

Fields

key_type: AlgebraicType

The key type of this index. This is the projection of the row type to the types of the columns indexed.

indexed_columns: ColList

Given a full row, typed at some ty: ProductType, these columns are the ones that this index indexes. Projecting the ty to self.indexed_columns yields the index’s type self.key_type.

Implementations

impl TableIndex

pub fn new( row_type: &ProductType, index_algo: &IndexAlgorithm, is_unique: bool, ) -> Result<Self, InvalidFieldError>

Returns a new possibly unique index, with index_id for a choice of indexing algorithm.

pub fn clone_structure(&self) -> Self

Clones the structure of this index but not the indexed elements, so the returned index is empty.

pub fn is_unique(&self) -> bool

Returns whether this is a unique index or not.

pub unsafe fn check_and_insert( &mut self, row_ref: RowRef<'_>, ) -> Result<(), RowPointer>

Inserts ptr with the value row to this index. This index will extract the necessary values from row based on self.indexed_columns.

Returns Err(existing_row) if this insertion would violate a unique constraint.

Safety

Caller promises that projecting the row_ref’s type to the index’s columns equals the index’s key type. This is entailed by an index belonging to the table’s schema. It also follows from row_ref’s type/layout being the same as passed in on self’s construction.

pub fn delete(&mut self, row_ref: RowRef<'_>) -> Result<bool, InvalidFieldError>

Deletes row_ref with its indexed value row_ref.project(&self.indexed_columns) from this index.

Returns whether ptr was present.

pub fn contains_any(&self, value: &AlgebraicValue) -> bool

Returns whether value is in this index.

pub fn count(&self, value: &AlgebraicValue) -> Option<usize>

Returns the number of rows associated with this value. Returns None if 0. Returns Some(1) if the index is unique.

pub fn seek_point(&self, key: &AlgebraicValue) -> TableIndexPointIter<'_>

Returns an iterator that yields all the RowPointers for the given key.

pub fn seek_range( &self, range: &impl RangeBounds<AlgebraicValue>, ) -> TableIndexRangeIter<'_>

Returns an iterator over the TableIndex that yields all the RowPointers that fall within the specified range.

pub unsafe fn build_from_rows<'table>( &mut self, rows: impl IntoIterator<Item = RowRef<'table>>, ) -> Result<(), RowPointer>

Extends TableIndex with rows.

Returns the first unique constraint violation caused when adding this index, if any.

Safety

Caller promises that projecting any of the row_ref’s type to the index’s columns equals the index’s key type. This is entailed by an index belonging to the table’s schema. It also follows from row_ref’s type/layout being the same as passed in on self’s construction.

pub fn can_merge( &self, other: &Self, ignore: impl Fn(&RowPointer) -> bool, ) -> Result<(), RowPointer>

Returns an error with the first unique constraint violation that would occur if self and other were to be merged.

The closure ignore indicates whether a row in self should be ignored.

pub fn clear(&mut self)

Deletes all entries from the index, leaving it empty.

When inserting a newly-created index into the committed state, we clear the tx state’s index and insert it, rather than constructing a new TableIndex.

pub fn num_keys(&self) -> usize

The number of unique keys in this index.

pub fn num_rows(&self) -> u64

The number of rows stored in this index.

Note that, for non-unique indexes, this may be larger than Self::num_keys.

This method runs in constant time.

pub fn num_key_bytes(&self) -> u64

The number of bytes stored in keys in this index.

For non-unique indexes, duplicate keys are counted once for each row that refers to them, even though the internal storage may deduplicate them as an optimization.

This method runs in constant time.

See the KeySize trait for more details on how this method computes its result.

Trait Implementations

impl Debug for TableIndex

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

Formats the value using the given formatter.

impl MemoryUsage for TableIndex

fn heap_usage(&self) -> usize

The heap memory usage of this type. The default implementation returns 0.

impl PartialEq for TableIndex

fn eq(&self, other: &TableIndex) -> 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 Eq for TableIndex

impl StructuralPartialEq for TableIndex