Expand description
Mongo
The mongod
crate aims to provide a convenient, higher-level wrapper on top of the official
bson
& mongodb
crates.
It provides the following:
The mongod::Client
is asynchronous. For applications that need a synchronous
solution, the mongod::blocking
API can be used.
Making Collections
Defining an example collection using derive.
#[derive(Bson, Mongo)]
#[mongo(collection="users", field, filter, update)]
pub struct User {
name: String,
age: Option<u32>,
email: Option<String>,
}
Making requests
This crate is opinionated, here are some examples on how to use it for interaction with mongodb. For more complex interactions see the individual implementations:
Delete
: Delete documents from a collectionFind
: Fetch documents from a collectionInsert
: Insert documents into a collectionReplace
: Replace documents in a collectionUpdate
: Update documents in a collection
Deleting
Deleting a user from the users collection.
use mongod::{AsFilter, Comparator};
let client = mongod::Client::new();
let mut filter = User::filter();
filter.name = Some(Comparator::Eq("foo".to_owned()));
let deleted = client.delete::<User, _>(Some(filter)).await.unwrap();
println!("delete {} documents", deleted);
Fetching
Fetching users from the users collection.
use bson::Document;
use futures::stream::StreamExt;
use mongod::Collection;
let client = mongod::Client::new();
let mut cursor = client.find::<User, _>(None).await.unwrap();
while let Some(res) = cursor.next().await {
if let Ok((id, user)) = res {
println!("{} - {:?}", id, user);
}
}
T ### Inserting
Inserting a user into the users collection.
let client = mongod::Client::new();
let user = User {
name: "foo".to_owned(),
age: None,
email: None,
};
let result = client.insert(vec![user]).await.unwrap();
println!("(index: oid) {:?}", result);
Replacing
Replacing a user in the users collection.
use mongod::{AsFilter, Comparator};
let client = mongod::Client::new();
let mut filter = User::filter();
filter.name = Some(Comparator::Eq("foo".to_owned()));
let user = User {
name: "foo".to_owned(),
age: Some(0),
email: None,
};
let oid = client.replace_one(filter, user).await.unwrap();
println!("{:?}", oid);
Updating
Updating a user in the users collection.
use mongod::{AsFilter, Comparator, AsUpdate};
let client = mongod::Client::new();
let mut filter = User::filter();
filter.name = Some(Comparator::Eq("foo".to_owned()));
let mut update = User::update();
update.age = Some(Some(0));
let updates = mongod::Updates {
set: Some(update),
..Default::default()
};
let updated = client.update::<User, _, _>(filter, updates).await.unwrap();
println!("updated {} documents", updated);
Optional Features
The following are a list of Cargo Features that cna be enabled or disabled:
- blocking: Provides the blocking client API.
- chrono: Provides the chrono support for the
ext::bson
. - derive: Provides the
derive
macros from the mongo-derive crate.
Re-exports
Modules
A blocking Client API.
Extensions on the bson
& mongodb
crates.
The query operations that can be perfomed on a MongoDB.
Structs
An asynchronous Client
to query mongo with.
A ClientBuilder
can be used to create a Client
with custom configuration.
The errors that may occur when talking to mongo.
A helper type to create a typed dictionary of sorted fields.
A typed cursor.
Used for complex updates using MongoDB’s update operators.
Enums
The BSON comparators for comparison of different BSON type values
The Kind
of mongod::Error
.
The order in which to sort a field by.
Traits
Used to tie a type implementing Collection
to its companion Field
type.
Used to tie a type implementing Collection
to its companion Filter
type.
Used to tie a type implementing Collection
to its companion Update
type.
Used to create a mongo collection from a type.
Used to mark an enum
as a viable type for use in sorting.
Used to mark a type as a filter for use in queries.
Used to mark a type as an update for use in queries.