MongoDB

https://www.mongodb.com/docs/manual/
Admin
MongoDB is a document database designed for building modern applications with flexible data models,...
Tokens:376,129
Snippets:2,596
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### C Driver: Run a transaction with mongoc_client_session_with_transaction

Source: https://www.mongodb.com/docs/manual/core/transactions-in-applications

C driver example showing how to run a transaction with mongoc_client_session_with_transaction. It creates collections with majority write concern, starts a session, defines transaction options, and passes a callback that performs inserts inside the transaction. The callback must append the session to all operations.

```c
static bool
with_transaction_example(bson_error_t *error)
{
   mongoc_client_t *client = NULL;
   mongoc_write_concern_t *wc = NULL;
   mongoc_collection_t *coll = NULL;
   bool success = false;
   bool ret = false;
   bson_t *doc = NULL;
   bson_t *insert_opts = NULL;
   mongoc_client_session_t *session = NULL;
   mongoc_transaction_opt_t *txn_opts = NULL;

   /* For a replica set, include the replica set name and a seedlist of the
    * members in the URI string; e.g.
    * uri_repl = "mongodb://mongodb0.example.com:27017,mongodb1.example.com:" \
    *    "27017/?replicaSet=myRepl";
    * client = mongoc_client_new (uri_repl);
    * For a sharded cluster, connect to the mongos instances; e.g.
    * uri_sharded =
    * "mongodb://mongos0.example.com:27017,mongos1.example.com:27017/";
    * client = mongoc_client_new (uri_sharded);
    */

   client = get_client();

   /* Prereq: Create collections. Note Atlas connection strings include a majority write
    * concern by default.
    */
   wc = mongoc_write_concern_new();
   mongoc_write_concern_set_wmajority(wc, 1000);
   insert_opts = bson_new();
   mongoc_write_concern_append(wc, insert_opts);
   coll = mongoc_client_get_collection(client, "mydb1", "foo");
   doc = BCON_NEW("abc", BCON_INT32(0));
   ret = mongoc_collection_insert_one(coll, doc, insert_opts, NULL /* reply */, error);
   if (!ret) {
      goto fail;
   }
   bson_destroy(doc);
   mongoc_collection_destroy(coll);
   coll = mongoc_client_get_collection(client, "mydb2", "bar");
   doc = BCON_NEW("xyz", BCON_INT32(0));
   ret = mongoc_collection_insert_one(coll, doc, insert_opts, NULL /* reply */, error);
   if (!ret) {
      goto fail;
   }

   /* Step 1: Start a client session. */
   session = mongoc_client_start_session(client, NULL /* opts */, error);
   if (!session) {
      goto fail;
   }

   /* Step 2: Optional. Define options to use for the transaction. */
   txn_opts = mongoc_transaction_opts_new();
   mongoc_transaction_opts_set_write_concern(txn_opts, wc);

   /* Step 3: Use mongoc_client_session_with_transaction to start a transaction,
    * execute the callback, and commit (or abort on error). */
   ret = mongoc_client_session_with_transaction(session, callback, txn_opts, NULL /* ctx */, NULL /* reply */, error);
   if (!ret) {
      goto fail;
   }

   success = true;
fail:
   bson_destroy(doc);
   mongoc_collection_destroy(coll);
   bson_destroy(insert_opts);
   mongoc_write_concern_destroy(wc);
   mongoc_transaction_opts_destroy(txn_opts);
   mongoc_client_session_destroy(session);
   mongoc_client_destroy(client);
   return success;
}

/* Define the callback that specifies the sequence of operations to perform
 * inside the transactions. */
static bool
callback(mongoc_client_session_t *session, void *ctx, bson_t **reply, bson_error_t *error)
{
   mongoc_client_t *client = NULL;
   mongoc_collection_t *coll = NULL;
   bson_t *doc = NULL;
   bson_t *opts = bson_new();
   bool success = false;
   bool ret = false;

   BSON_UNUSED(ctx);
   BSON_UNUSED(reply);

   // Important::  The logical session ID MUST be applied to all associated operations.
   ret = mongoc_client_session_append(session, opts, error);
   if (!ret) {
      goto fail;
   }

   client = mongoc_client_session_get_client(session);
   coll = mongoc_client_get_collection(client, "mydb1", "foo");
   doc = BCON_NEW("abc", BCON_INT32(1));
   ret = mongoc_collection_insert_one(coll, doc, opts, NULL, error);
   if (!ret) {
      goto fail;
   }
   bson_destroy(doc);
   mongoc_collection_destroy(coll);
   coll = mongoc_client_get_collection(client, "mydb2", "bar");
   doc = BCON_NEW("xyz", BCON_INT32(999));
   ret = mongoc_collection_insert_one(coll, doc, opts, NULL, error);
   if (!ret) {
      goto fail;
   }

   success = true;
fail:
   mongoc_collection_destroy(coll);
   bson_destroy(opts);
   bson_destroy(doc);
   return success;
}
```

--------------------------------

### Create SampleApp template

Source: https://www.mongodb.com/docs/manual/core/timeseries/timeseries-quick-start

Template Java application for the time series quick start. Replace the placeholder connection string and add time series code between the start and end comments.

```java
package org.example;

// Modify imports for each tutorial as needed.
import com.mongodb.MongoException;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;

public class SampleApp {
    public static void main(String[] args) {
        // Replace the placeholder with your connection string.
        String uri = "<connection string>";

        try (MongoClient mongoClient = MongoClients.create(uri)) {
            // start example code here

            // end example code here
        } catch (MongoException me) {
            System.err.println(me.getMessage());
        }
    }
}

```

--------------------------------

### Example queryShapeHash and planCacheShapeHash output

Source: https://www.mongodb.com/docs/manual/core/query-shapes

Example hexadecimal strings for queryShapeHash and planCacheShapeHash that appear in the explain output for queries with the same query shape.

```javascript
queryShapeHash: 'AB8ECADEE8F0EB0F447A30744EB4813AE7E0BFEF523B0870CA10FCBC87F5D8F1'
planCacheShapeHash: '48E51110'
```

--------------------------------

### Install libmongocrypt on Suse

Source: https://www.mongodb.com/docs/manual/core/csfle/reference/libmongocrypt

Installs libmongocrypt on Suse by importing the GPG key, adding the repository (replace <release> with your platform release, e.g., "12" or "15"), and installing the package.

```sh
sudo rpm --import https://pgp.mongodb.com/libmongocrypt.asc
```

```sh
sudo zypper addrepo --gpgcheck "https://libmongocrypt.s3.amazonaws.com/zypper/suse/<release>/libmongocrypt/release/x86_64" libmongocrypt
```

```sh
sudo zypper -n install libmongocrypt
```

--------------------------------

### Connect to MongoDB with PyMongo template

Source: https://www.mongodb.com/docs/manual/core/timeseries/timeseries-quick-start

Template app for connecting to a MongoDB deployment. Replace the placeholder connection string with your actual one. Add time series code examples between the start and end comments.

```python
from datetime import datetime
from pymongo import MongoClient

try:
    uri = "<connection-string>"
    client = MongoClient(uri)

    # start example code here

    # end example code here

    client.close()

except Exception as e:
    raise Exception("The following error occurred: ", e)

```

--------------------------------

### Start mongod with verbose logging and logappend

Source: https://www.mongodb.com/docs/manual/administration/monitoring

Starts a mongod instance in verbose mode, appending data to the log file at /var/log/mongodb/server1.log.

```javascript
mongod -v --logpath /var/log/mongodb/server1.log --logappend

```

--------------------------------

### Install Atlas CLI with Homebrew

Source: https://www.mongodb.com/docs/manual/core/timeseries/timeseries-quick-start

Installs the Atlas CLI using Homebrew on macOS.

```text
brew install mongodb-atlas-cli

```

--------------------------------

### Install Atlas CLI with Homebrew

Source: https://www.mongodb.com/docs/manual/core/timeseries/timeseries-quick-start

Installs the Atlas CLI using Homebrew on macOS. This is a prerequisite for setting up a local Atlas deployment.

```text
brew install mongodb-atlas-cli
```

--------------------------------

### Add required imports

Source: https://www.mongodb.com/docs/manual/core/timeseries/timeseries-quick-start

Required imports for the time series quick start Java app. Add these to the top of the sample app file.

```java
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.FindIterable;
import com.mongodb.client.model.CreateCollectionOptions;
import com.mongodb.client.model.TimeSeriesGranularity;
import com.mongodb.client.model.TimeSeriesOptions;
import org.bson.Document;

import java.time.Instant;
import java.util.Arrays;
import java.util.Date;

```

--------------------------------

### Connect to MongoDB with C# driver

Source: https://www.mongodb.com/docs/manual/core/timeseries/timeseries-quick-start

Paste this code into a new .cs file, replace the placeholder with your connection string, and add time series code between the start and end comments.

```csharp
using MongoDB.Driver;

// Replace the placeholder with your connection string.
var uri = "<connection string>";

try
{
    var client = new MongoClient(uri);
    // start example code here

    // end example code here
}
catch (MongoException me)
{
    Console.Error.WriteLine(me.Message);
}

```

--------------------------------

### Connect to MongoDB with .NET/C# driver

Source: https://www.mongodb.com/docs/manual/core/timeseries/timeseries-quick-start

Template app that connects to a MongoDB deployment. Replace the placeholder with your connection string and add time series code between the start and end comments.

```csharp
using MongoDB.Driver;

// Replace the placeholder with your connection string.
var uri = "<connection string>";

try
{
    var client = new MongoClient(uri);
    // start example code here

    // end example code here
}
catch (MongoException me)
{
    Console.Error.WriteLine(me.Message);
}
```

--------------------------------

### Sample stock ticker data

Source: https://www.mongodb.com/docs/manual/core/timeseries/timeseries-quick-start

Sample stock ticker data used in the quick start. The date field stores time data and the ticker field identifies the individual stock.

```shell
{
  date: 2021-12-18T15:55:00.000Z,
  ticker: 'MDB',
  close: 254.03,
  volume: 40270
}
{
  date: 2021-12-18T15:56:00.000Z,
  ticker: 'MDB',
  close: 253.63,
  volume: 27890
}
```

--------------------------------

### Node.js connection template

Source: https://www.mongodb.com/docs/manual/core/timeseries/timeseries-quick-start

Template Node.js app that connects to MongoDB using the provided connection string. Add time series code examples between the 'start example code here' and 'end example code here' comments.

```javascript
import { MongoClient } from 'mongodb';

// Replace the placeholder with your connection string.
const uri = '<connection-string>';
const client = new MongoClient(uri);

export async function runApp() {
  try {
    // start example code here
    // end example code here
  } finally {
    await client.close();
  }
}

runApp().catch(console.dir);
```

--------------------------------

### Example output showing roles with _id, role, and db

Source: https://www.mongodb.com/docs/manual/core/views/create-view

Example output from the previous query, showing the `_id`, `role`, and `db` fields in the `myRoles` array.

```javascript
{
   _id: 0,
   myRoles: [
      { _id: 'test.Operations', role: 'Operations', db: 'test' },
      { _id: 'test.Sales', role: 'Sales', db: 'test' },
      { _id: 'test.read', role: 'read', db: 'test' }
   ]
}
```

--------------------------------

### Example output of $currentOp resharding monitor

Source: https://www.mongodb.com/docs/manual/core/sharding-reshard-a-collection

Example output from the $currentOp pipeline showing resharding operation details. remainingOperationTimeEstimatedSecs is -1 when a new resharding operation starts and is a pessimistic estimate during catch-up.

```javascript
[
  {
    shard: '<shard>',
    type: 'op',
    desc: 'ReshardingRecipientService | ReshardingDonorService | ReshardingCoordinatorService <reshardingUUID>',
    op: 'command',
    ns: '<database>.<collection>',
    originatingCommand: {
      reshardCollection: '<database>.<collection>',
      key: <shardkey>,
      unique: <boolean>,
      collation: { locale: 'simple' }
    },
    totalOperationTimeElapsedSecs: <number>,
    remainingOperationTimeEstimatedSecs: <number>,
    ...
  },
  ...
]
```

--------------------------------

### mongosh transaction example

Source: https://www.mongodb.com/docs/manual/core/transactions-in-applications

mongosh example demonstrating transactions across two databases. It creates collections, starts a session with primary read preference, starts a transaction with local read concern and majority write concern, performs inserts, aborts on error, commits, and ends the session. Omits retry logic and robust error handling for simplicity.

```javascript
// Create collections:
db.getSiblingDB("mydb1").foo.insertOne(
    {abc: 0},
    { writeConcern: { w: "majority", wtimeout: 2000 } }
)
db.getSiblingDB("mydb2").bar.insertOne(
   {xyz: 0},
   { writeConcern: { w: "majority", wtimeout: 2000 } }
)

// Start a session.
session = db.getMongo().startSession( { readPreference: { mode: "primary" } } );

coll1 = session.getDatabase("mydb1").foo;
coll2 = session.getDatabase("mydb2").bar;

// Start a transaction
session.startTransaction( { readConcern: { level: "local" }, writeConcern: { w: "majority" } } );

// Operations inside the transaction
try {
   coll1.insertOne( { abc: 1 } );
   coll2.insertOne( { xyz: 999 } );
} catch (error) {
   // Abort transaction on error
   session.abortTransaction();
   throw error;
}

// Commit the transaction using write concern set at transaction start
session.commitTransaction();

session.endSession();
```

--------------------------------

### Example of db.runCommand() with the hello command

Source: https://www.mongodb.com/docs/manual/reference/command

Shows the syntax for running a database command. The command name is the key and the value is typically 1. The value does not affect the output.

```javascript
db.runCommand( { hello: 1 } )  
---  

```

--------------------------------

### Install libmongocrypt on Ubuntu

Source: https://www.mongodb.com/docs/manual/core/csfle/reference/libmongocrypt

Configures the libmongocrypt repository on Ubuntu. Optionally use extrepo to enable the repository, or manually import the GPG key and add the repository (replace <release> with your platform release). Then update the package cache and install libmongocrypt-dev.

```sh
extrepo search libmongocrypt
sudo extrepo enable libmongocrypt
```

```sh
sudo sh -c 'curl -s --location https://pgp.mongodb.com/libmongocrypt.asc
| gpg --dearmor >/etc/apt/trusted.gpg.d/libmongocrypt.gpg'
```

```sh
echo "deb https://libmongocrypt.s3.amazonaws.com/apt/ubuntu <release>/libmongocrypt/release universe" | sudo tee /etc/apt/sources.list.d/libmongocrypt.list
```

```sh
sudo apt-get update
```

```sh
sudo apt-get install -y libmongocrypt-dev
```

--------------------------------

### Python Callback API transaction example

Source: https://www.mongodb.com/docs/manual/core/transactions-in-applications

Python example using the Callback API to run a transaction. It creates collections, defines a callback that inserts documents with the session, and uses with_transaction to start, execute, and commit (or abort) the transaction. The callback API automatically retries on TransientTransactionError and UnknownTransactionCommitResult.

```python
# For a replica set, include the replica set name and a seedlist of the members in the URI string; e.g.
# uriString = 'mongodb://mongodb0.example.com:27017,mongodb1.example.com:27017/?replicaSet=myRepl'
# For a sharded cluster, connect to the mongos instances; e.g.
# uriString = 'mongodb://mongos0.example.com:27017,mongos1.example.com:27017/'

client = MongoClient(uriString)
wc_majority = WriteConcern("majority", wtimeout=1000)

# Prereq: Create collections.
client.get_database("mydb1", write_concern=wc_majority).foo.insert_one({"abc": 0})
client.get_database("mydb2", write_concern=wc_majority).bar.insert_one({"xyz": 0})

# Step 1: Define the callback that specifies the sequence of operations to perform inside the transactions.
def callback(session):
    collection_one = session.client.mydb1.foo
    collection_two = session.client.mydb2.bar

    # Important:: You must pass the session to the operations.
    collection_one.insert_one({"abc": 1}, session=session)
    collection_two.insert_one({"xyz": 999}, session=session)

# Step 2: Start a client session.
with client.start_session() as session:
    # Step 3: Use with_transaction to start a transaction, execute the callback, and commit (or abort on error).
    session.with_transaction(callback)
```

--------------------------------

### Install libmongocrypt on Debian

Source: https://www.mongodb.com/docs/manual/core/csfle/reference/libmongocrypt

Configures the libmongocrypt repository on Debian. Optionally use extrepo to enable the repository, or manually import the GPG key and add the repository (replace <release> with your platform release). Then update the package cache and install libmongocrypt-dev.

```sh
extrepo search libmongocrypt
sudo extrepo enable libmongocrypt
```

```sh
sudo sh -c 'curl -s --location https://pgp.mongodb.com/libmongocrypt.asc | gpg --dearmor >/etc/apt/trusted.gpg.d/libmongocrypt.gpg'
```

```sh
echo "deb https://libmongocrypt.s3.amazonaws.com/apt/debian <release>/libmongocrypt/release main" | sudo tee /etc/apt/sources.list.d/libmongocrypt.list
```

```sh
sudo apt-get update
```

```sh
sudo apt-get install -y libmongocrypt-dev
```

--------------------------------

### Rust Transactions API with callback and and_run2

Source: https://www.mongodb.com/docs/manual/core/transactions

Rust example showing the MongoDB transactions callback API. It creates collections, defines a callback that performs insert operations with the session, starts a client session, and uses start_transaction().and_run2() to run the transaction. The callback API automatically starts, commits, or aborts the transaction and includes retry logic for TransientTransactionError and UnknownTransactionCommitResult.

```rust
// Prereq: Create collections. CRUD operations in transactions must be on existing collections.

client
    .database("mydb1")
    .collection::<Document>("foo")
    .insert_one(doc! { "abc": 0})
    .await?;
client
    .database("mydb2")
    .collection::<Document>("bar")
    .insert_one(doc! { "xyz": 0})
    .await?;

// Step 1: Define the callback that specifies the sequence of operations to perform inside the
// transaction.
async fn callback(session: &mut ClientSession) -> Result<()> {
    let collection_one = session
        .client()
        .database("mydb1")
        .collection::<Document>("foo");
    let collection_two = session
        .client()
        .database("mydb2")
        .collection::<Document>("bar");

    // Important: You must pass the session to the operations.
    collection_one
        .insert_one(doc! { "abc": 1 })
        .session(&mut *session)
        .await?;
    collection_two
        .insert_one(doc! { "xyz": 999 })
        .session(session)
        .await?;

    Ok(())
}

// Step 2: Start a client session.
let mut session = client.start_session().await?;

// Step 3: Use and_run2 to start a transaction, execute the callback, and commit (or
// abort on error).
session.start_transaction().and_run2(callback).await?;
```

--------------------------------

### TypeScript Schema Example for sample_mflix.movies

Source: https://www.mongodb.com/docs/manual/natural-language-to-mongodb

Annotated TypeScript schema for the sample_mflix.movies collection. Use this as a prompt template to guide an LLM in generating MongoDB queries. Each field includes a comment describing its meaning to reduce ambiguity.

```typescript
interface Movie {  
  /**  
   * Unique identifier for the movie document.  
   */  
  _id: ObjectId;  
  /**  
   * Brief description of the movie's plot.  
   */  
  plot: string;  
  /**  
   * List of genres associated with the movie.  
   */  
  genres: string[];  
  /**  
   * Duration of the movie in minutes.  
   */  
  runtime: number;  
  /**  
   * Title of the movie.  
   */  
  title: string;  
  /**  
   * Number of comments on the movie in the mflix system.  
   */  
  num_mflix_comments: number;  
  /**  
   * URL to the movie's poster image.  
   */  
  poster: string;  
  /**  
   * List of countries where the movie was produced.  
   */  
  countries: string[];  
  /**  
   * Detailed description of the movie's plot.  
   */  
  fullplot: string;  
  /**  
   * Languages spoken in the movie.  
   */  
  languages: string[];  
  /**  
   * Release date of the movie.  
   */  
  released: Date;  
  /**  
   * List of directors of the movie.  
   */  
  directors: string[];  
  /**  
   * List of writers of the movie.  
   */  
  writers: string[];  
  /**  
   * Awards received by the movie.  
   */  
  awards: {  
    /**  
     * Number of awards won by the movie.  
     */  
    wins: number;  
    /**  
     * Number of award nominations received by the movie.  
     */  
    nominations: number;  
    /**  
     * Textual description of the awards.  
     */  
    text: string;  
  };  
  /**  
   * Last updated timestamp for the movie document.  
   */  
  lastupdated: string;  
  /**  
   * Year the movie was released.  
   */  
  year: number;  
  /**  
   * IMDb information for the movie.  
   */  
  imdb: {  
    /**  
     * IMDb rating of the movie.  
     */  
    rating: number;  
    /**  
     * Number of votes the movie received on IMDb.  
     */  
    votes: number;  
    /**  
     * IMDb identifier for the movie.  
     */  
    id: number;  
  };  
  /**  
   * Type of the movie (e.g., movie, series).  
   */  
  type: string;  
  /**  
   * Rotten Tomatoes information for the movie.  
   */  
  tomatoes: {  
    /**  
     * Viewer ratings on Rotten Tomatoes.  
     */  
    viewer?: {  
      /**  
       * Viewer rating score.  
       */  
      rating: number;  
      /**  
       * Number of reviews by viewers.  
       */  
      numReviews: number;  
      /**  
       * Viewer meter score.  
       */  
      meter: number;  
    };  
    /**  
     * DVD release date.  
     */  
    dvd?: Date;  
    /**  
     * Last updated timestamp for Rotten Tomatoes data.  
     */  
    lastUpdated?: Date;  
    /**  
     * Official website for the movie.  
     */  
    website?: string;  
    /**  
     * Critic ratings on Rotten Tomatoes.  
     */  
    critic?: {  
      /**  
       * Critic rating score.  
       */  
      rating: number;  
      /**  
       * Number of reviews by critics.  
       */  
      numReviews: number;  
      /**  
       * Critic meter score.  
       */  
      meter: number;  
    };  
    /**  
     * Box office earnings.  
     */  
    boxOffice?: string;  
    /**  
     * Consensus statement from Rotten Tomatoes.  
     */  
    consensus?: string;  
    /**  
     * Number of rotten reviews.  
     */  
    rotten?: number;  
    /**  
     * Production company.  
     */  
    production?: string;  
    /**  
     * Number of fresh reviews.  
     */  
    fresh?: number;  
  };  
  /**  
   * Hash value for the movie document.  
   */  
  hash: Long;  
  /**  
   * MPAA rating of the movie.  
   */  
  rated?: string;  
  /**  
   * Metacritic score of the movie.  
   */  
  metacritic?: number;  
  /**  
   * List of main cast members in the movie.  
   */  
  cast: string[];  
}  
```

--------------------------------

### Resume a change stream with resumeAfter and process events

Source: https://www.mongodb.com/docs/manual/changestreams

Demonstrates a more complex workflow: watch a collection, obtain the resume token from the first change, kill the stream, then resume with `resumeAfter` and process events.

```swift
let inventory = db.collection("inventory")

inventory.watch(options: ChangeStreamOptions(fullDocument: .updateLookup))
    .flatMap { changeStream in
        changeStream.next().map { _ in
            changeStream.resumeToken
        }.always { _ in
            _ = changeStream.kill()
        }
    }.flatMap { resumeToken in
        inventory.watch(options: ChangeStreamOptions(resumeAfter: resumeToken)).flatMap { newStream in
            newStream.forEach { event in
                // process event
                print(event)
            }
        }
    }
```
Tokens:
Raw