Struct tc_table::TableIndex[−][src]

pub struct TableIndex<F: File<Node>, D: Dir, Txn: Transaction<D>> { /* fields omitted */ }

The base type of a Table.

Implementations

`impl<F: File<Node>, D: Dir, Txn: Transaction<D>> TableIndex<F, D, Txn>`[src]

`pub async fn create( schema: TableSchema, context: &D, txn_id: TxnId ) -> TCResult<TableIndex<F, D, Txn>> where F: TryFrom<D::File, Error = TCError>, D::FileClass: From<BTreeType>,` [src]

`pub async fn is_empty(&self, txn: &Txn) -> TCResult<bool>`[src]

`pub fn merge_bounds(&self, all_bounds: Vec<Bounds>) -> TCResult<Bounds>`[src]

`pub fn primary(&self) -> &Index<F, D, Txn>`[src]

`pub fn supporting_index(&self, bounds: &Bounds) -> TCResult<Index<F, D, Txn>>`[src]

`pub async fn get( &self, txn_id: TxnId, key: Vec<Value> ) -> TCResult<Option<Vec<Value>>>`[src]

`pub async fn insert( &self, txn_id: TxnId, key: Vec<Value>, values: Vec<Value> ) -> TCResult<()>`[src]

`pub async fn upsert( &self, txn_id: TxnId, key: Vec<Value>, values: Vec<Value> ) -> TCResult<()>`[src]

`pub async fn slice_rows<'a>( self, txn_id: TxnId, bounds: Bounds, reverse: bool ) -> TCResult<TCTryStream<'a, Vec<Value>>>`[src]

Trait Implementations

`impl<F: Clone + File<Node>, D: Clone + Dir, Txn: Clone + Transaction<D>> Clone for TableIndex<F, D, Txn>`[src]

`fn clone(&self) -> TableIndex<F, D, Txn>`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0 [src]

`impl<F: File<Node>, D: Dir, Txn: Transaction<D>> Display for TableIndex<F, D, Txn>`[src]

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

`impl<F: File<Node>, D: Dir, Txn: Transaction<D>> From<TableIndex<F, D, Txn>> for Table<F, D, Txn>`[src]

`fn from(table: TableIndex<F, D, Txn>) -> Self`[src]

`impl<F: File<Node>, D: Dir, Txn: Transaction<D>> Instance for TableIndex<F, D, Txn>`[src]

`type Class = TableType`

The Class type of this instance

`fn class(&self) -> TableType`[src]

`impl<F: File<Node>, D: Dir, Txn: Transaction<D>> Persist<D, Txn> for TableIndex<F, D, Txn> where F: TryFrom<D::File, Error = TCError>,` [src]

`type Schema = TableSchema`

`type Store = D`

`fn schema(&self) -> &Self::Schema`[src]

`fn load<'life0, 'async_trait>( txn: &'life0 Txn, schema: Self::Schema, store: Self::Store ) -> Pin<Box<dyn Future<Output = TCResult<Self>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait,` [src]

`impl<F: File<Node>, D: Dir, Txn: Transaction<D>> Restore<D, Txn> for TableIndex<F, D, Txn>`[src]

`fn restore<'life0, 'life1, 'async_trait>( &'life0 self, backup: &'life1 Self, txn_id: TxnId ) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,` [src]

`impl<F: File<Node>, D: Dir, Txn: Transaction<D>> TableInstance<F, D, Txn> for TableIndex<F, D, Txn>`[src]

`type OrderBy = Merged<F, D, Txn>`

The type of Table returned by this instance’s order_by method.

`type Reverse = Merged<F, D, Txn>`

The type of Table returned by this instance’s reversed method.

`type Slice = Merged<F, D, Txn>`

The type of Table returned by this instance’s slice method.

`fn count<'async_trait>( self, txn_id: TxnId ) -> Pin<Box<dyn Future<Output = TCResult<u64>> + Send + 'async_trait>> where Self: 'async_trait,` [src]

`fn delete<'life0, 'async_trait>( &'life0 self, txn_id: TxnId ) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait,` [src]

`fn delete_row<'life0, 'async_trait>( &'life0 self, txn_id: TxnId, row: Row ) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait,` [src]

`fn insert<'life0, 'async_trait>( &'life0 self, txn_id: TxnId, key: Vec<Value>, values: Vec<Value> ) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait,` [src]

`fn key(&self) -> &[Column]`[src]

`fn values(&self) -> &[Column]`[src]

`fn schema(&self) -> TableSchema`[src]

`fn order_by(self, columns: Vec<Id>, reverse: bool) -> TCResult<Self::OrderBy>`[src]

`fn reversed(self) -> TCResult<Self::Reverse>`[src]

`fn slice(self, bounds: Bounds) -> TCResult<Merged<F, D, Txn>>`[src]

`fn rows<'a, 'async_trait>( self, txn_id: TxnId ) -> Pin<Box<dyn Future<Output = TCResult<TCTryStream<'a, Vec<Value>>>> + Send + 'async_trait>> where 'a: 'async_trait, Self: 'async_trait,` [src]

`fn validate_bounds(&self, bounds: &Bounds) -> TCResult<()>`[src]

`fn validate_order(&self, order: &[Id]) -> TCResult<()>`[src]

`fn update<'life0, 'life1, 'async_trait>( &'life0 self, txn: &'life1 Txn, update: Row ) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where F: TryFrom<D::File, Error = TCError>, D::FileClass: From<BTreeType>, 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,` [src]

`fn update_row<'life0, 'async_trait>( &'life0 self, txn_id: TxnId, row: Row, update: Row ) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait,` [src]

`fn upsert<'life0, 'async_trait>( &'life0 self, txn_id: TxnId, key: Vec<Value>, values: Vec<Value> ) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait,` [src]

`fn group_by( self, columns: Vec<Id> ) -> TCResult<Aggregate<F, D, Txn, Self::OrderBy>>`[src]

`#[must_use] fn index<'async_trait>( self, txn: Txn, columns: Option<Vec<Id>> ) -> Pin<Box<dyn Future<Output = TCResult<ReadOnly<F, D, Txn>>> + Send + 'async_trait>> where F: TryFrom<D::File, Error = TCError>, D::FileClass: From<BTreeType>, Self: Send + 'async_trait,` [src]

`fn limit(self, limit: u64) -> Limited<F, D, Txn>`[src]

`fn select(self, columns: Vec<Id>) -> TCResult<Selection<F, D, Txn, Self>>`[src]

`impl<F: File<Node> + Transact, D: Dir, Txn: Transaction<D>> Transact for TableIndex<F, D, Txn>`[src]

`fn commit<'life0, 'life1, 'async_trait>( &'life0 self, txn_id: &'life1 TxnId ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,` [src]

`fn finalize<'life0, 'life1, 'async_trait>( &'life0 self, txn_id: &'life1 TxnId ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,` [src]

Auto Trait Implementations

`impl<F, D, Txn> RefUnwindSafe for TableIndex<F, D, Txn> where D: RefUnwindSafe, F: RefUnwindSafe, Txn: RefUnwindSafe,`

`impl<F, D, Txn> Send for TableIndex<F, D, Txn>`

`impl<F, D, Txn> Sync for TableIndex<F, D, Txn>`

`impl<F, D, Txn> Unpin for TableIndex<F, D, Txn>`

`impl<F, D, Txn> UnwindSafe for TableIndex<F, D, Txn> where D: RefUnwindSafe, F: RefUnwindSafe, Txn: RefUnwindSafe,`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<F, T> CastFrom<F> for T where T: From<F>,` [src]

`pub fn cast_from(f: F) -> T`[src]

`impl<T, F> CastInto<F> for T where F: CastFrom<T>,` [src]

`pub fn cast_into(self) -> F`[src]

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<F> Match for F`[src]

`pub fn matches<T>(&self) -> bool where T: TryCastFrom<Self>,` [src]

`impl<T> Same<T> for T`

`type Output = T`

Should always be Self

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`pub fn to_owned(&self) -> T`[src]

`pub fn clone_into(&self, target: &mut T)`[src]

`impl<T> ToString for T where T: Display + ?Sized,` [src]

`pub default fn to_string(&self) -> String`[src]

`impl<F, T> TryCastFrom<F> for T where T: CastFrom<F>,` [src]

`pub fn can_cast_from(&F) -> bool`[src]

`pub fn opt_cast_from(f: F) -> Option<T>`[src]

`pub fn try_cast_from<Err, OnErr>(value: T, on_err: OnErr) -> Result<Self, Err> where OnErr: FnOnce(&T) -> Err,` [src]

`impl<F, T> TryCastInto<T> for F where T: TryCastFrom<F>,` [src]

`pub fn can_cast_into(&self) -> bool`[src]

`pub fn opt_cast_into(self) -> Option<T>`[src]

`pub fn try_cast_into<Err, OnErr>(self, on_err: OnErr) -> Result<T, Err> where OnErr: FnOnce(&Self) -> Err,` [src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`pub fn try_into(self) -> Result<U, >::Error>`[src]

`impl<V, T> VZip<V> for T where V: MultiLane<T>,`

`pub fn vzip(self) -> V`

Struct tc_table::TableIndex⎘[−][src]

Implementations

impl<F: File<Node>, D: Dir, Txn: Transaction<D>> TableIndex<F, D, Txn>[src]

pub async fn create( schema: TableSchema, context: &D, txn_id: TxnId) -> TCResult<TableIndex<F, D, Txn>> where F: TryFrom<D::File, Error = TCError>, D::FileClass: From<BTreeType>, [src]

pub async fn is_empty(&self, txn: &Txn) -> TCResult<bool>[src]

pub fn merge_bounds(&self, all_bounds: Vec<Bounds>) -> TCResult<Bounds>[src]

pub fn primary(&self) -> &Index<F, D, Txn>[src]

pub fn supporting_index(&self, bounds: &Bounds) -> TCResult<Index<F, D, Txn>>[src]

pub async fn get( &self, txn_id: TxnId, key: Vec<Value>) -> TCResult<Option<Vec<Value>>>[src]

pub async fn insert( &self, txn_id: TxnId, key: Vec<Value>, values: Vec<Value>) -> TCResult<()>[src]

pub async fn upsert( &self, txn_id: TxnId, key: Vec<Value>, values: Vec<Value>) -> TCResult<()>[src]

pub async fn slice_rows<'a>( self, txn_id: TxnId, bounds: Bounds, reverse: bool) -> TCResult<TCTryStream<'a, Vec<Value>>>[src]

Trait Implementations

impl<F: Clone + File<Node>, D: Clone + Dir, Txn: Clone + Transaction<D>> Clone for TableIndex<F, D, Txn>[src]

fn clone(&self) -> TableIndex<F, D, Txn>[src]

pub fn clone_from(&mut self, source: &Self)1.0.0[src]

impl<F: File<Node>, D: Dir, Txn: Transaction<D>> Display for TableIndex<F, D, Txn>[src]

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

impl<F: File<Node>, D: Dir, Txn: Transaction<D>> From<TableIndex<F, D, Txn>> for Table<F, D, Txn>[src]

fn from(table: TableIndex<F, D, Txn>) -> Self[src]

impl<F: File<Node>, D: Dir, Txn: Transaction<D>> Instance for TableIndex<F, D, Txn>[src]

type Class = TableType

fn class(&self) -> TableType[src]

impl<F: File<Node>, D: Dir, Txn: Transaction<D>> Persist<D, Txn> for TableIndex<F, D, Txn> where F: TryFrom<D::File, Error = TCError>, [src]

type Schema = TableSchema

type Store = D

fn schema(&self) -> &Self::Schema[src]

fn load<'life0, 'async_trait>( txn: &'life0 Txn, schema: Self::Schema, store: Self::Store) -> Pin<Box<dyn Future<Output = TCResult<Self>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait, [src]

impl<F: File<Node>, D: Dir, Txn: Transaction<D>> Restore<D, Txn> for TableIndex<F, D, Txn>[src]

fn restore<'life0, 'life1, 'async_trait>( &'life0 self, backup: &'life1 Self, txn_id: TxnId) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait, [src]

impl<F: File<Node>, D: Dir, Txn: Transaction<D>> TableInstance<F, D, Txn> for TableIndex<F, D, Txn>[src]

type OrderBy = Merged<F, D, Txn>

type Reverse = Merged<F, D, Txn>

type Slice = Merged<F, D, Txn>

fn count<'async_trait>( self, txn_id: TxnId) -> Pin<Box<dyn Future<Output = TCResult<u64>> + Send + 'async_trait>> where Self: 'async_trait, [src]

fn delete<'life0, 'async_trait>( &'life0 self, txn_id: TxnId) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait, [src]

fn delete_row<'life0, 'async_trait>( &'life0 self, txn_id: TxnId, row: Row) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait, [src]

fn insert<'life0, 'async_trait>( &'life0 self, txn_id: TxnId, key: Vec<Value>, values: Vec<Value>) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait, [src]

fn key(&self) -> &[Column][src]

fn values(&self) -> &[Column][src]

fn schema(&self) -> TableSchema[src]

fn order_by(self, columns: Vec<Id>, reverse: bool) -> TCResult<Self::OrderBy>[src]

fn reversed(self) -> TCResult<Self::Reverse>[src]

fn slice(self, bounds: Bounds) -> TCResult<Merged<F, D, Txn>>[src]

fn rows<'a, 'async_trait>( self, txn_id: TxnId) -> Pin<Box<dyn Future<Output = TCResult<TCTryStream<'a, Vec<Value>>>> + Send + 'async_trait>> where 'a: 'async_trait, Self: 'async_trait, [src]

fn validate_bounds(&self, bounds: &Bounds) -> TCResult<()>[src]

fn validate_order(&self, order: &[Id]) -> TCResult<()>[src]

fn update<'life0, 'life1, 'async_trait>( &'life0 self, txn: &'life1 Txn, update: Row) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where F: TryFrom<D::File, Error = TCError>, D::FileClass: From<BTreeType>, 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait, [src]

fn update_row<'life0, 'async_trait>( &'life0 self, txn_id: TxnId, row: Row, update: Row) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait, [src]

fn upsert<'life0, 'async_trait>( &'life0 self, txn_id: TxnId, key: Vec<Value>, values: Vec<Value>) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait, [src]

fn group_by( self, columns: Vec<Id>) -> TCResult<Aggregate<F, D, Txn, Self::OrderBy>>[src]

#[must_use]fn index<'async_trait>( self, txn: Txn, columns: Option<Vec<Id>>) -> Pin<Box<dyn Future<Output = TCResult<ReadOnly<F, D, Txn>>> + Send + 'async_trait>> where F: TryFrom<D::File, Error = TCError>, D::FileClass: From<BTreeType>, Self: Send + 'async_trait, [src]

fn limit(self, limit: u64) -> Limited<F, D, Txn>[src]

fn select(self, columns: Vec<Id>) -> TCResult<Selection<F, D, Txn, Self>>[src]

impl<F: File<Node> + Transact, D: Dir, Txn: Transaction<D>> Transact for TableIndex<F, D, Txn>[src]

fn commit<'life0, 'life1, 'async_trait>( &'life0 self, txn_id: &'life1 TxnId) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait, [src]

fn finalize<'life0, 'life1, 'async_trait>( &'life0 self, txn_id: &'life1 TxnId) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait, [src]