Enum avocado::literal::IndexType

pub enum IndexType {
    Ordered(Order),
    Text,
    Hashed,
    Geo2D,
    Geo2DSphere,
    GeoHaystack,
}

An index type, applied to a single indexed field.

let patient_index = doc!{
    "description": IndexType::Text,
    "body.mass": IndexType::Ordered(Order::Ascending),
    "birth_date.year": IndexType::Ordered(Order::Descending),
    "address_gps_coords": IndexType::Geo2DSphere,
};
assert_eq!(patient_index, doc!{
    "description": "text",
    "body.mass": 1,
    "birth_date.year": -1,
    "address_gps_coords": "2dsphere",
});

Variants

Ordered(Order)

An ordered index field.

Text

A language-specific textual index, most useful for freetext searches.

Hashed

Hashed index for hash-based sharding.

Geo2D

2D geospatial index with planar (Euclidean) geometry.

Geo2DSphere

2D geospatial index with spherical geometry.

GeoHaystack

2D geospatial index optimized for very small areas.

Trait Implementations

impl PartialEq<IndexType> for IndexType

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

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

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

This method tests for !=.

impl Eq for IndexType

impl Clone for IndexType

fn clone(&self) -> IndexType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<IndexType> for Bson

fn from(index_type: IndexType) -> Self

Performs the conversion.

impl Copy for IndexType

impl Debug for IndexType

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

Formats the value using the given formatter.

impl Hash for IndexType

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,

Feeds a slice of this type into the given [Hasher].

impl<'a> Deserialize<'a> for IndexType

let asc_i32 = Bson::I32(1);
let desc_i64 = Bson::I64(-1);
let asc_float = Bson::FloatingPoint(1.0);
let text = Bson::from("text");
let spherical_2d = Bson::from("2dsphere");
let hashed = Bson::from("hashed");

let bad_i64 = Bson::I64(0);
let bad_float = Bson::FloatingPoint(3.14);
let bad_str = Bson::from("Ascending");
let bad_type = Bson::Boolean(true);

assert_eq!(from_bson::<IndexType>(asc_i32)?,
           IndexType::Ordered(Order::Ascending));
assert_eq!(from_bson::<IndexType>(desc_i64)?,
           IndexType::Ordered(Order::Descending));
assert_eq!(from_bson::<IndexType>(asc_float)?,
           IndexType::Ordered(Order::Ascending));
assert_eq!(from_bson::<IndexType>(text)?,
           IndexType::Text);
assert_eq!(from_bson::<IndexType>(spherical_2d)?,
           IndexType::Geo2DSphere);
assert_eq!(from_bson::<IndexType>(hashed)?,
           IndexType::Hashed);

assert!(from_bson::<IndexType>(bad_i64)
        .unwrap_err()
        .to_string()
        .contains("invalid ordering"));
assert!(from_bson::<IndexType>(bad_float)
        .unwrap_err()
        .to_string()
        .contains("invalid ordering"));
assert!(from_bson::<IndexType>(bad_str)
        .unwrap_err()
        .to_string()
        .contains("unrecognized index type"));
assert!(from_bson::<IndexType>(bad_type)
        .unwrap_err()
        .to_string()
        .contains("an ordering integer or an index type string"));

fn deserialize<D: Deserializer<'a>>(de: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Serialize for IndexType

let asc = IndexType::Ordered(Order::Ascending);
let desc = IndexType::Ordered(Order::Descending);
let haystack = IndexType::GeoHaystack;
let text = IndexType::Text;
let planar_2d = IndexType::Geo2D;
let spherical_2d = IndexType::Geo2DSphere;

assert_eq!(to_bson(&asc)?, Bson::from(asc));
assert_eq!(to_bson(&desc)?, Bson::from(desc));
assert_eq!(to_bson(&haystack)?, Bson::from(haystack));
assert_eq!(to_bson(&text)?, Bson::from(text));
assert_eq!(to_bson(&planar_2d)?, Bson::from(planar_2d));
assert_eq!(to_bson(&spherical_2d)?, Bson::from(spherical_2d));

fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.