Databases and Collections

Overview

In this guide, you can learn how to use the Rust driver to access and manage MongoDB databases and collections.

MongoDB organizes data in a hierarchical structure. A MongoDB deployment contains one or more databases, and each database contains one or more collections. In each collection, MongoDB stores data as documents that contain field-and-value pairs.

To learn more about the document data format, see Documents in the Server manual.

Access a Database

You can access a database by retrieving a Database instance from your client. You can use a Database instance to perform database-level operations and access collections that the database contains.

Call one of the following methods on a Client instance to create a Database:

• database(): retrieve a database by its name

• database_with_options(): set options (DatabaseOptions) while retrieving a database by its name

• default_database(): access the default database specified for your Client instance

If you pass the name of a nonexistent database to the database() or database_with_options() methods, the driver still returns a Database instance. When you insert any data into collection in this database, the server creates it.

The following example uses the database() method to access a database called test_db:

let db = client.database("test_db");

List Databases

To see a list of your deployment's databases, call the list_database_names() method on your Client instance. This method returns a Vec<String> type, a vector containing the database names as strings.

To see detailed information about each database, call the list_databases() method on your Client instance. This method returns a Vec<DatabaseSpecification> type. The DatabaseSpecification type contains fields describing each database, such as its size and whether it contains data.

The following example shows how to print a list of databases by using the list_database_names() method:

let db_list = client.list_database_names().await?;
println!("{:?}", db_list);

["admin", "local", "test_db", ...]

Drop a Database

Dropping a database permanently deletes all the data in that database's collections. To drop a database, call the drop() method on your Database instance. The following code shows how to drop a database referenced by the db variable:

db.drop().await?;

Access a Collection

You can access a collection by retrieving a Collection instance from your database. You can use a Collection instance to perform data operations, create aggregations, and manage indexes. Call one of the following methods on a Database instance to retrieve a Collection:

• collection(): retrieve a collection by its name

• collection_with_options(): set options (CollectionOptions) while accessing a collection by its name

If you pass the name of a nonexistent collection to the collection() or collection_with_options() methods, the driver still returns a Collection instance. When you insert any data into this collection, the server creates it. To learn how to explicitly create a collection, see the Create a Collection section of this guide.

This example uses the collection_with_options() method to perform the following actions:

• Access a collection called coll_xyz from a database referenced by the db variable

• Set a write preference on the collection in the CollectionOptions type

let wc = WriteConcern::builder().journal(true).build();
let coll_opts = CollectionOptions::builder().write_concern(wc).build();
let my_coll: Collection<Document> = db.collection_with_options("coll_xyz", coll_opts);

To learn more about write concerns, see Write Concern in the Server manual.

let my_coll: Collection<Document> = client.database("test_db").collection("coll_xyz");
let my_coll = client.database("test_db").collection::<Document>("coll_xyz");

Create a Collection

You can explicitly create a collection by calling the create_collection() method on a Database instance. This method takes the collection name as a parameter. You can use a Collection instance to perform data operations, create aggregations, and manage indexes.

The following code shows how to create a collection called coll_abc within a database referenced by the db variable:

db.create_collection("coll_abc").await?;

When creating a collection, you can implement schema validation to maintain a consistent document schema and control whether any write operations can bypass the validation rules. To learn how to enable this feature, see the guide on Schema Validation.

List Collections

To see the names of the collections in a database, call the list_collection_names() method on your Database instance. This method returns a Vec<String> type, a vector containing the collection names as strings.

To see detailed information about each collection, call the list_collections() method on your Database instance. This method returns a Vec<CollectionSpecification> type. The CollectionSpecification type contains fields describing each collection, such as its type and settings.

The following example shows how to print the names of the collections in a database referenced by the db variable by using the list_collection_names() method:

let coll_list = db.list_collection_names().await?;
println!("{:?}", coll_list);

["my_coll", "coll_xyz", ...]

Drop a Collection

Dropping a collection permanently deletes all the data in that collection. To drop a collection, call the drop() method on your Collection instance. The following code shows how to drop a collection referenced by the my_coll variable:

my_coll.drop().await?;

Additional Information

For more information about the concepts in this guide, see the following documentation:

• Insert Documents guide

• Databases and Collections in the Server manual

• Documents in the Server manual