Enum cassandra_protocol::consistency::Consistency

#[non_exhaustive]
pub enum Consistency {
    Any,
    One,
    Two,
    Three,
    Quorum,
    All,
    LocalQuorum,
    EachQuorum,
    Serial,
    LocalSerial,
    LocalOne,
}

Consistency is an enum which represents Cassandra’s consistency levels. To find more details about each consistency level please refer to the following documentation: https://docs.datastax.com/en/cql-oss/3.x/cql/cql_reference/cqlshConsistency.html

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Any

Closest replica, as determined by the snitch. If all replica nodes are down, write succeeds after a hinted handoff. Provides low latency, guarantees writes never fail. Note: this consistency level can only be used for writes. It provides the lowest consistency and the highest availability.

One

A write must be written to the commit log and memtable of at least one replica node. Satisfies the needs of most users because consistency requirements are not stringent.

Two

A write must be written to the commit log and memtable of at least two replica nodes. Similar to ONE.

Three

A write must be written to the commit log and memtable of at least three replica nodes. Similar to TWO.

Quorum

A write must be written to the commit log and memtable on a quorum of replica nodes. Provides strong consistency if you can tolerate some level of failure.

All

A write must be written to the commit log and memtable on all replica nodes in the cluster for that partition key. Provides the highest consistency and the lowest availability of any other level.

LocalQuorum

Strong consistency. A write must be written to the commit log and memtable on a quorum of replica nodes in the same data center as thecoordinator node. Avoids latency of inter-data center communication. Used in multiple data center clusters with a rack-aware replica placement strategy, such as NetworkTopologyStrategy, and a properly configured snitch. Use to maintain consistency locally (within the single data center). Can be used with SimpleStrategy.

EachQuorum

Strong consistency. A write must be written to the commit log and memtable on a quorum of replica nodes in all data center. Used in multiple data center clusters to strictly maintain consistency at the same level in each data center. For example, choose this level if you want a read to fail when a data center is down and the QUORUM cannot be reached on that data center.

Serial

Achieves linearizable consistency for lightweight transactions by preventing unconditional updates. You cannot configure this level as a normal consistency level, configured at the driver level using the consistency level field. You configure this level using the serial consistency field as part of the native protocol operation. See failure scenarios.

LocalSerial

Same as SERIAL but confined to the data center. A write must be written conditionally to the commit log and memtable on a quorum of replica nodes in the same data center. Same as SERIAL. Used for disaster recovery. See failure scenarios.

LocalOne

A write must be sent to, and successfully acknowledged by, at least one replica node in the local data center. In a multiple data center clusters, a consistency level of ONE is often desirable, but cross-DC traffic is not. LOCAL_ONE accomplishes this. For security and quality reasons, you can use this consistency level in an offline datacenter to prevent automatic connection to online nodes in other data centers if an offline node goes down.

Implementations

impl Consistency

pub fn is_dc_local(self) -> bool

Does this consistency require local dc.

Trait Implementations

impl Clone for Consistency

fn clone(&self) -> Consistency

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Consistency

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

Formats the value using the given formatter.

impl Default for Consistency

fn default() -> Consistency

Returns the “default value” for a type.

impl Display for Consistency

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

Formats the value using the given formatter.

impl From<Consistency> for CIntShort

fn from(value: Consistency) -> Self

Converts to this type from the input type.

impl FromBytes for Consistency

fn from_bytes(bytes: &[u8]) -> Result<Consistency>

It gets and array of bytes and should return an implementor struct.

impl FromCursor for Consistency

fn from_cursor( cursor: &mut Cursor<&[u8]>, version: Version ) -> Result<Consistency>

Tries to parse Self from a cursor of bytes.

impl FromStr for Consistency

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Consistency

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Consistency

fn cmp(&self, other: &Consistency) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Consistency

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Consistency

fn partial_cmp(&self, other: &Consistency) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Consistency

fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version)

Serializes given value using the cursor.

fn serialize_to_vec(&self, version: Version) -> Vec<u8>

Wrapper for easily starting hierarchical serialization.

impl TryFrom<i16> for Consistency

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: CIntShort) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for Consistency

impl Eq for Consistency

impl StructuralPartialEq for Consistency