Enum Query 

pub enum Query<T: ShoalTable + Debug> {
    Insert {
        key: u64,
        row: T,
    },
    Get(Get<T>),
    Delete {
        key: u64,
        sort_key: T::Sort,
    },
    Update(Update<T>),
}

The different types of queries for a single datatype

Variants

Insert

Insert a row into shoal

Fields

key: u64

row: T

Get(Get<T>)

Get some data from shoal

Delete

Delete a row from shoal

Fields

key: u64

sort_key: T::Sort

Update(Update<T>)

Update a row in a shoal

Implementations

impl<T: ShoalTable + Debug> Query<T>

pub fn find_shard<'a>(&self, ring: &'a Ring, tmp: &mut Vec<&'a ShardInfo>)

Trait Implementations

impl<T> Archive for Query<T>

where u64: Archive, T: Archive + ShoalTable + Debug, Get<T>: Archive, T::Sort: Archive, Update<T>: Archive,

type Archived = ArchivedQuery<T>

The archived representation of this type.

type Resolver = QueryResolver<T>

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl<T: Clone + ShoalTable + Debug> Clone for Query<T>

where T::Sort: Clone,

fn clone(&self) -> Query<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ShoalTable + Debug> Debug for Query<T>

where T::Sort: Debug,

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized, T> Deserialize<Query<T>, __D> for Archived<Query<T>>

where u64: Archive, <u64 as Archive>::Archived: Deserialize<u64, __D>, T: Archive + ShoalTable + Debug, <T as Archive>::Archived: Deserialize<T, __D>, Get<T>: Archive, <Get<T> as Archive>::Archived: Deserialize<Get<T>, __D>, T::Sort: Archive, <T::Sort as Archive>::Archived: Deserialize<T::Sort, __D>, Update<T>: Archive, <Update<T> as Archive>::Archived: Deserialize<Update<T>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Query<T>, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized, T> Serialize<__S> for Query<T>

where u64: Serialize<__S>, T: Serialize<__S> + ShoalTable + Debug, Get<T>: Serialize<__S>, T::Sort: Serialize<__S>, Update<T>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.