Get Started with Rust and MongoDB

1
cargo new --bin rust_quickstart

1
[dependencies]
2
mongodb = "2.1"
3
bson = { version = "2", features = ["chrono-0_4"] } # Needed for using chrono datetime in doc
4
tokio = "1"
5
chrono = "0.4" # Used for setting DateTimes
6
serde = "1" # Used in the Map Data into Structs section

1
cargo run

1
use mongodb::{Client, options::{ClientOptions, ResolverConfig}};
2
use std::env;
3
use std::error::Error;
4
use tokio;
5
6
#[tokio::main]
7
async fn main() -> Result<(), Box<dyn Error>> {
8
   // Load the MongoDB connection string from an environment variable:
9
   let client_uri =
10
      env::var("MONGODB_URI").expect("You must set the MONGODB_URI environment var!");
11
12
   // A Client is needed to connect to MongoDB:
13
   // An extra line of code to work around a DNS issue on Windows:
14
   let options =
15
      ClientOptions::parse_with_resolver_config(&client_uri, ResolverConfig::cloudflare())
16
         .await?;
17
   let client = Client::with_options(options)?;
18
19
   // Print the databases in our MongoDB cluster:
20
   println!("Databases:");
21
   for name in client.list_database_names(None, None).await? {
22
      println!("- {}", name);
23
   }
24
25
   Ok(())
26
}

1
# Unix (including MacOS):
2
export MONGODB_URI='mongodb+srv://yourusername:yourpasswordgoeshere@rustquickstart-123ab.mongodb.net/test?retryWrites=true&w=majority'
3
4
# Windows CMD shell:
5
set MONGODB_URI='mongodb+srv://yourusername:yourpasswordgoeshere@rustquickstart-123ab.mongodb.net/test?retryWrites=true&w=majority'
6
7
# Powershell:
8
$Env:MONGODB_URI='mongodb+srv://yourusername:yourpasswordgoeshere@rustquickstart-123ab.mongodb.net/test?retryWrites=true&w=majority'

1
$ cargo run
2
   Compiling rust_quickstart v0.0.1 (/Users/judy2k/development/rust_quickstart)
3
   Finished dev [unoptimized + debuginfo] target(s) in 3.35s
4
   Running `target/debug/rust_quickstart`
5
Databases:
6
- sample_airbnb
7
- sample_analytics
8
- sample_geospatial
9
- sample_mflix
10
- sample_supplies
11
- sample_training
12
- sample_weatherdata
13
- admin
14
- local

1
use chrono::{TimeZone, Utc};
2
use mongodb::bson::doc;
3
4
let new_doc = doc! {
5
   "title": "Parasite",
6
   "year": 2020,
7
   "plot": "A poor family, the Kims, con their way into becoming the servants of a rich family, the Parks. But their easy life gets complicated when their deception is threatened with exposure.",
8
   "released": Utc.ymd(2020, 2, 7).and_hms(0, 0, 0),
9
};

1
{ title: "Parasite", year: 2020, plot: "A poor family, the Kims, con their way into becoming the servants of a rich family, the Parks. But their easy life gets complicated when their deception is threatened with exposure.", released: Date("2020-02-07 00:00:00 UTC") }

1
// Get the 'movies' collection from the 'sample_mflix' database:
2
let movies = client.database("sample_mflix").collection("movies");

1
let insert_result = movies.insert_one(new_doc.clone(), None).await?;
2
println!("New document ID: {}", insert_result.inserted_id);

1
New document ID: ObjectId("5e835f3000415b720028b0ad")

1
// Look up one document:
2
let movie: Document = movies
3
   .find_one(
4
      doc! {
5
            "title": "Parasite"
6
      },
7
      None,
8
   ).await?
9
   .expect("Missing 'Parasite' document.");
10
println!("Movie: {}", movie);

1
Movie: { _id: ObjectId("5e835f3000415b720028b0ad"), title: "Parasite", year: 2020, plot: "A poor family, the Kims, con their way into becoming the servants of a rich family, the Parks. But their easy life gets complicated when their deception is threatened with exposure.", released: Date("2020-02-07 00:00:00 UTC") }

1
// Update the document:
2
let update_result = movies.update_one(
3
   doc! {
4
      "_id": &movie.get("_id")
5
   },
6
   doc! {
7
      "$set": { "year": 2019 }
8
   },
9
   None,
10
).await?;
11
println!("Updated {} document", update_result.modified_count);

1
// Look up the document again to confirm it's been updated:
2
let movie = movies
3
   .find_one(
4
      doc! {
5
            "_id": &movie.get("_id")
6
      },
7
      None,
8
   ).await?
9
   .expect("Missing 'Parasite' document.");
10
println!("Updated Movie: {}", &movie);

1
Updated 1 document
2
Updated Movie: { _id: ObjectId("5e835f3000415b720028b0ad"), title: "Parasite", year: 2019, plot: "A poor family, the Kims, con their way into becoming the servants of a rich family, the Parks. But their easy life gets complicated when their deception is threatened with exposure.", released: Date("2020-02-07 00:00:00 UTC") }

1
// Delete all documents for movies called "Parasite":
2
let delete_result = movies.delete_many(
3
   doc! {
4
      "title": "Parasite"
5
   },
6
   None,
7
).await?;
8
println!("Deleted {} documents", delete_result.deleted_count);

1
use serde::{Deserialize, Serialize};
2
use mongodb::bson::{Bson, oid::ObjectId};
3
4
// Working with Document can be verbose:
5
if let Ok(title) = new_doc.get_str("title") {
6
   println!("title: {}", title);
7
} else {
8
   println!("no title found");
9
}

1
// You use `serde` to create structs which can serialize & deserialize between BSON:
2
#[derive(Serialize, Deserialize, Debug)]
3
struct Movie {
4
   #[serde(rename = "_id", skip_serializing_if = "Option::is_none")]
5
   id: Option<ObjectId>,
6
   title: String,
7
   year: i32,
8
   plot: String,
9
   #[serde(with = "bson::serde_helpers::chrono_datetime_as_bson_datetime")]
10
   released: chrono::DateTime<Utc>,
11
}

1
// Initialize struct to be inserted:
2
let captain_marvel = Movie {
3
   id: None,
4
   title: "Captain Marvel".to_owned(),
5
   year: 2019,
6
};
7
8
// Convert `captain_marvel` to a Bson instance:
9
let serialized_movie = bson::to_bson(&captain_marvel)?;
10
let document = serialized_movie.as_document().unwrap();
11
12
// Insert into the collection and extract the inserted_id value:
13
let insert_result = movies.insert_one(document.to_owned(), None).await?;
14
let captain_marvel_id = insert_result
15
   .inserted_id
16
   .as_object_id()
17
   .expect("Retrieved _id should have been of type ObjectId");
18
println!("Captain Marvel document ID: {:?}", captain_marvel_id);

1
Captain Marvel document ID: ObjectId(5e835f30007760020028b0ae)

1
// Retrieve Captain Marvel from the database, into a Movie struct:
2
// Read the document from the movies collection:
3
let loaded_movie = movies
4
   .find_one(Some(doc! { "_id":  captain_marvel_id.clone() }), None)
5
   .await?
6
   .expect("Document not found");
7
8
// Deserialize the document into a Movie instance
9
let loaded_movie_struct: Movie = bson::from_bson(Bson::Document(loaded_movie))?;
10
println!("Movie loaded from collection: {:?}", loaded_movie_struct);

1
Movie loaded from collection: Movie { id: Some(ObjectId(5e835f30007760020028b0ae)), title: "Captain Marvel", year: 2019 }

1
[dependencies]
2
async-std = "1"
3
mongodb = { version = "2.1", default-features = false, features = ["async-std-runtime"] }

1
use async_std;
2
3
#[async_std::main]
4
async fn main() -> Result<(), Box<dyn Error>> {
5
   // Your code goes here.
6
}

1
[dependencies]
2
mongodb = { version = "2.1", default-features = false, features = ["sync"] }

1
use mongodb::sync::Client;
2
3
// Use mongodb::sync::Client, instead of mongodb::Client:
4
let client = Client::with_uri_str(client_uri.as_ref())?;
5
6
// .insert_one().await? becomes .insert_one()?
7
let insert_result = movies.insert_one(new_doc.clone(), None)?;