MongoDB

https://www.mongodb.com/pt-br/docs/
Admin
MongoDB is a document-oriented database that stores JSON-like documents and provides modern query...
Tokens:153,118
Snippets:890
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Setup MongoDB Atlas Local Deployment

Source: https://www.mongodb.com/pt-br/docs/get-started

Sets up a local MongoDB deployment for testing purposes. Requires Atlas CLI and prompts for Atlas account creation if none exists.

```shell
atlas deployments setup testing --type local \
--mdbVersion 8.0 --port 27017 --connectWith skip
```

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

### Initialize PHP Application and Install MongoDB Driver

Source: https://www.mongodb.com/pt-br/docs/get-started

Commands to create a new PHP project directory, set up the application file, and install the necessary MongoDB PHP driver using Composer and pie. This is the initial setup for a PHP MongoDB application.

```shell
mkdir php-get-started
cd php-get-started
touch getstarted.php
pie install mongodb/mongodb-extension
composer require mongodb/mongodb
```

```shell
mkdir php-get-started
cd php-get-started
type nul > getstarted.php
pie install mongodb/mongodb-extension
composer require mongodb/mongodb
```

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

### Initialize Go Project and Install MongoDB Driver

Source: https://www.mongodb.com/pt-br/docs/get-started

These commands set up a new Go project directory, initialize Go modules, and install the official MongoDB Go driver. This is a prerequisite for connecting to MongoDB from a Go application.

```shell
mkdir go-quickstart
cd go-quickstart
go mod init go-quickstart
go get go.mongodb.org/mongo-driver/v2/mongo
```

```shell
mkdir go-quickstart
cd go-quickstart
go mod init go-quickstart
go get go.mongodb.org/mongo-driver/v2/mongo
```

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

### MongoDB C++ Driver Quickstart Application

Source: https://www.mongodb.com/pt-br/docs/get-started

A basic C++ application demonstrating connection to MongoDB, querying a document, and printing it as JSON. Requires mongo-cxx-driver library.

```cpp
#include <cstdint>
#include <iostream>
#include <vector>

#include <bsoncxx/builder/basic/document.hpp>
#include <bsoncxx/json.hpp>
#include <mongocxx/client.hpp>
#include <mongocxx/instance.hpp>
#include <mongocxx/uri.hpp>

using bsoncxx::builder::basic::kvp;
using bsoncxx::builder::basic::make_document;

int main() {
    mongocxx::instance instance;
    mongocxx::uri uri("<connection string URI>");
    mongocxx::client client(uri);
    auto db = client["sample_mflix"];
    auto collection = db["movies"];

    auto result = collection.find_one(make_document(kvp("title", "The Shawshank Redemption")));
    if (result) {
        std::cout << bsoncxx::to_json(*result) << std::endl;
    } else {
        std::cout << "No result found" << std::endl;
    }
}
```

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

### Initialize Node.js Application on Windows

Source: https://www.mongodb.com/pt-br/docs/get-started

Creates a new directory, initializes a Node.js project with npm, and installs the MongoDB driver on Windows.

```shell
mkdir node-quickstart
cd node-quickstart
type nul > index.js
npm init -y
npm install mongodb
```

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

### Load Sample Data into Local MongoDB

Source: https://www.mongodb.com/pt-br/docs/get-started

Installs MongoDB Database Tools and loads sample data into a local MongoDB deployment using a provided archive. Replace `<port number>` with your deployment's port.

```bash
brew tap mongodb/brew
brew install mongodb-database-tools

curl https://atlas-education.s3.amazonaws.com/sampledata.archive -o sampledata.archive
mongorestore --archive=sampledata.archive --port <port number>
```

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

### Install Atlas CLI and Docker on Windows

Source: https://www.mongodb.com/pt-br/docs/get-started

Installs the MongoDB Atlas CLI and Docker Desktop using the Chocolatey package manager on Windows. Ensure Chocolatey is installed first.

```shell
choco install mongodb-atlas-cli
choco install docker-desktop
```

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

### Example MongoDB Connection String

Source: https://www.mongodb.com/pt-br/docs/get-started

This provides an example of a MongoDB connection string for connecting to a local deployment on the default port. It specifies the protocol, host, and port, and can be used to establish a connection to the MongoDB server.

```none
"mongodb://127.0.0.1:27017/myTestDb"
```

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

### Build and Install MongoDB C++ Driver (Windows)

Source: https://www.mongodb.com/pt-br/docs/get-started

Builds and installs the configured C++ driver on Windows using CMake. Uses 'RelWithDebInfo' for build type.

```bash
cmake --build . --config RelWithDebInfo
cmake --build . --target install --config RelWithDebInfo
```

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

### Load Sample Data into Local MongoDB Deployment

Source: https://www.mongodb.com/pt-br/docs/get-started

Downloads a sample data archive and restores it into a local MongoDB deployment using the mongorestore command. Requires MongoDB Database Tools to be installed.

```bash
curl https://atlas-education.s3.amazonaws.com/sampledata.archive -o sampledata.archive
mongorestore --archive=sampledata.archive --port <port number>
```

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

### Install MongoDB Database Tools and Load Sample Data (macOS)

Source: https://www.mongodb.com/pt-br/docs/get-started

This macOS shell script installs the MongoDB Database Tools using Homebrew and then downloads and restores sample data into your MongoDB deployment. It requires `curl` and `mongorestore` commands.

```bash
brew tap mongodb/brew
brew install mongodb-database-tools

curl https://atlas-education.s3.amazonaws.com/sampledata.archive -o sampledata.archive
mongorestore --archive=sampledata.archive --port <port number>

```

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

### Load sample data using MongoDB Database Tools

Source: https://www.mongodb.com/pt-br/docs/get-started

These bash commands install MongoDB Database Tools using brew and then load sample data into a local MongoDB deployment. Replace the `<port number>` placeholder with the actual port number of your MongoDB instance. The sample data is downloaded from a specified URL and restored using mongorestore.

```bash
brew tap mongodb/brew
brew install mongodb-database-tools
```

```bash
curl https://atlas-education.s3.amazonaws.com/sampledata.archive -o sampledata.archive
mongorestore --archive=sampledata.archive --port <port number>
```

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

### Load Sample Data into Cloud MongoDB

Source: https://www.mongodb.com/pt-br/docs/get-started

Loads sample data into a cloud-hosted MongoDB deployment using the Atlas CLI.

```bash
atlas clusters sampleData load myTestDb
```

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

### Setup MongoDB Atlas Cloud Deployment

Source: https://www.mongodb.com/pt-br/docs/get-started

Sets up a MongoDB deployment in the cloud (AWS) for testing. Requires Atlas CLI and prompts for Atlas account creation if none exists. Ensure to replace placeholder credentials.

```shell
atlas deployments setup testing --type atlas \
--provider AWS -r us-east-1 --skipSampleData \
--username <Your username> --password <Your password> \
--connectWith skip --force
```

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

### Load Sample Data with MongoDB Tools (Local)

Source: https://www.mongodb.com/pt-br/docs/get-started

Commands to install MongoDB Database Tools using Homebrew and then download and restore sample data to a local MongoDB deployment. Requires replacing a port number placeholder.

```shell
brew tap mongodb/brew
brew install mongodb-database-tools
curl https://atlas-education.s3.amazonaws.com/sampledata.archive -o sampledata.archive
 Lamontorestore --archive=sampledata.archive --port <port number>
```

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

### Initialize Node.js Application on macOS

Source: https://www.mongodb.com/pt-br/docs/get-started

Creates a new directory, initializes a Node.js project with npm, and installs the MongoDB driver for macOS.

```shell
mkdir node-quickstart
cd node-quickstart
touch index.js
npm init -y
npm install mongodb
```

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

### Install Atlas CLI and Docker on macOS

Source: https://www.mongodb.com/pt-br/docs/get-started

Installs the MongoDB Atlas CLI and Docker using the Homebrew package manager on macOS. Ensure Homebrew is installed first.

```shell
brew install mongodb-atlas-cli
brew install docker
```

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

### Node.js: Initialize Project and Install MongoDB Driver

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial/facet-tutorial

This Node.js example shows the initial steps to set up a project for interacting with MongoDB. It includes creating a directory, initializing an npm project, and installing the official MongoDB Node.js driver. This is a prerequisite for running MongoDB queries and managing connections in a Node.js application.

```shell
# Create a new directory and initialize the project
mkdir atlas-search-project && cd atlas-search-project
npm init -y

# Add the MongoDB Node.js Driver to your project
npm install mongodb

```

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

### Run Ruby Application

Source: https://www.mongodb.com/pt-br/docs/get-started

Command to start a Ruby application that interacts with MongoDB. Assumes 'quickstart.rb' is the main application file. Outputs details about a retrieved movie document.

```shell
ruby quickstart.rb
```

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

### Build and Install MongoDB C++ Driver (macOS)

Source: https://www.mongodb.com/pt-br/docs/get-started

Builds and installs the configured C++ driver on macOS using CMake. Requires sudo privileges for the install target.

```bash
cmake --build . 
sudo cmake --build . --target install
```

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

### Install MongoDB Database Tools (macOS)

Source: https://www.mongodb.com/pt-br/docs/get-started

Installs the MongoDB Database Tools on macOS using Homebrew. These tools are necessary for operations like loading sample data into your MongoDB deployment.

```bash
brew tap mongodb/brew
brew install mongodb-database-tools
```

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

### Initialize Python Project with PyMongo (Windows)

Source: https://www.mongodb.com/pt-br/docs/get-started

This Windows batch script sets up a new Python project directory, creates a virtual environment, and installs the PyMongo driver. It's a prerequisite for using MongoDB with Python on Windows.

```batch
mkdir pymongo-quickstart
cd pymongo-quickstart
type nul > quickstart.py
python -m venv venv
.\venv\Scripts\activate
python -m pip install pymongo

```

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

### Initialize Python Project with PyMongo (macOS)

Source: https://www.mongodb.com/pt-br/docs/get-started

This macOS shell script sets up a new Python project directory, creates a virtual environment, and installs the PyMongo driver. It's a prerequisite for using MongoDB with Python.

```shell
mkdir pymongo-quickstart
cd pymongo-quickstart
touch quickstart.py
python3 -m venv venv
source venv/bin/activate
python3 -m pip install pymongo

```

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

### Configure MongoDB C++ Driver with CMake (Windows)

Source: https://www.mongodb.com/pt-br/docs/get-started

Configures the C++ driver for installation using CMake on Windows. Requires CMake and Visual Studio. Specify your Visual Studio version and path.

```bash
'C:\<path>\cmake.exe' .. \
    -G "Visual Studio <version> <year>" -A "x64" \
    -DCMAKE_CXX_STANDARD=17 \
    -DCMAKE_INSTALL_PREFIX=C:\mongo-cxx-driver  \
```

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

### Verify MongoDB Connection

Source: https://www.mongodb.com/pt-br/docs/get-started

Tests the connection to the MongoDB deployment by listing the available databases.

```shell
show dbs
```

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

### Load Sample Data into Cloud Deployment

Source: https://www.mongodb.com/pt-br/docs/get-started

This command loads sample data directly into your MongoDB Atlas cloud deployment using the `atlas` CLI. It assumes you have the Atlas CLI configured and authenticated.

```bash
atlas clusters sampleData load myTestDb

```

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

### Configure MongoDB C++ Driver with CMake (macOS)

Source: https://www.mongodb.com/pt-br/docs/get-started

Configures the C++ driver for installation using CMake on macOS. Requires CMake v3.15 or later and a C++17 compliant compiler.

```bash
cmake .. \
    -DCMAKE_BUILD_TYPE=Release \
    -DCMAKE_CXX_STANDARD=17
```

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

### Run Go Application

Source: https://www.mongodb.com/pt-br/docs/get-started

This command executes the Go application from your project directory. Ensure your `MONGODB_URI` environment variable is set correctly before running.

```shell
go run main.go
```

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

### Initialize Node.js Project and Install MongoDB Driver

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial/facet-tutorial

These shell commands initialize a new Node.js project and install the MongoDB Node.js driver. This setup is a prerequisite for running MongoDB-related applications in Node.js. It creates a project directory, initializes npm, and adds the mongodb package.

```shell
# Create a new directory and initialize the project
mkdir atlas-search-project && cd atlas-search-project
npm init -y

# Add the MongoDB Node.js Driver to your project
npm install mongodb
```

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

### Initialize Rust Project

Source: https://www.mongodb.com/pt-br/docs/get-started

Shell commands to create a new Rust project using Cargo and navigate into the project directory. This is the first step before adding dependencies and code.

```shell
cargo new rust-get-started
cd rust-get-started
```

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

### Connect to MongoDB Cloud Deployment

Source: https://www.mongodb.com/pt-br/docs/get-started

Connects to a cloud-hosted MongoDB deployment using the MongoDB Shell (`mongosh`). Ensure to replace placeholder credentials.

```shell
atlas deployments connect myTestDb --username <Your username> \
--password <Your password> --connectWith mongosh
```

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

### Run Rust Application

Source: https://www.mongodb.com/pt-br/docs/get-started

Command to compile and run a Rust application. This is executed in the project directory after setting up dependencies and code.

```shell
cargo run
```

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

### Connect to MongoDB Local Deployment

Source: https://www.mongodb.com/pt-br/docs/get-started

Connects to a locally deployed MongoDB instance using the MongoDB Shell (`mongosh`).

```shell
atlas deployments connect myTestDb --connectWith mongosh
```

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

### Initialize Ruby Application Directory

Source: https://www.mongodb.com/pt-br/docs/get-started

Shell commands to create a new Ruby project directory and an application file (`get_started.rb`) for a MongoDB application. Supports both macOS and Windows environments.

```shell
mkdir ruby-get-started
cd ruby-get-started
touch get_started.rb
```

```shell
mkdir ruby-get-started
cd ruby-get-started
type NUL > get_started.rb
```

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

### Download MongoDB C++ Driver

Source: https://www.mongodb.com/pt-br/docs/get-started

Commands to download the latest C++ driver release from GitHub and extract it. Requires curl and tar utilities.

```bash
curl -OL https://github.com/mongodb/mongo-cxx-driver/releases/download/r4.1.1/mongo-cxx-driver-r4.1.1.tar.gz
tar -xzf mongo-cxx-driver-r4.1.1.tar.gz
cd mongo-cxx-driver-r4.1.1/build
```

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

### Initialize .NET C# Application with MongoDB Driver

Source: https://www.mongodb.com/pt-br/docs/get-started

Creates a new .NET console application directory, navigates into it, initializes a new console project, and adds the MongoDB.Driver NuGet package. This sets up the basic project structure and dependencies for a C# MongoDB application.

```shell
mkdir csharp-quickstart
cd csharp-quickstart
dotnet new console
dotnet add package MongoDB.Driver
```

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

### Compile and Run C++ Application

Source: https://www.mongodb.com/pt-br/docs/get-started

Compiles and runs a C++ application using the MongoDB driver on Linux/macOS. Uses pkg-config to find driver flags. Requires C++17 compiler.

```bash
c++ --std=c++17 quickstart.cpp $(pkg-config --cflags --libs libmongocxx) -o ./app.out
./app.out
```

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

### Create Go Application to Connect and Query MongoDB

Source: https://www.mongodb.com/pt-br/docs/get-started

This Go program connects to a MongoDB deployment using a connection string from an environment variable, queries for a specific movie by title in the 'sample_mflix' database, and prints the result as JSON. It handles connection errors and missing documents.

```go
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"os"

	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)

func main() {
	uri := os.Getenv("MONGODB_URI")
	docs := "www.mongodb.com/docs/drivers/go/current/"
	if uri == "" {
		log.Fatal("Set your 'MONGODB_URI' environment variable. " +
			"See: " + docs +
			"usage-examples/#environment-variable")
	}
	client, err := mongo.Connect(options.Client().
		ApplyURI(uri))
	if err != nil {
		panic(err)
	}

	defer func() {
		if err := client.Disconnect(context.TODO()); err != nil {
			panic(err)
		}
	}()

	coll := client.Database("sample_mflix").Collection("movies")
	title := "Back to the Future"

	var result bson.M
	err = coll.FindOne(context.TODO(), bson.D{{"title", title}})
		.Decode(&result)
	if err == mongo.ErrNoDocuments {
		fmt.Printf("No document was found with the title %s\n", title)
		return
	}
	if err != nil {
		panic(err)
	}

	jsonData, err := json.MarshalIndent(result, "", "    ")
	if err != nil {
		panic(err)
	}
	fmt.Printf("%s\n", jsonData)
}

```

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

### Compile and Run Java Code

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/manage-indexes

This snippet demonstrates how to compile and run a Java file. It is a prerequisite for executing the other Java code examples provided in this document. Ensure you have a Java Development Kit (JDK) installed.

```shell
javac EditIndex.java
java EditIndex
```

```shell
javac DeleteIndex.java
java DeleteIndex
```

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

### Initialize .NET/C# Project and Add MongoDB Driver

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial

These commands set up a new .NET console project and add the necessary MongoDB C# driver package. Ensure you have the .NET SDK installed.

```shell
mkdir atlas-search-quickstart && cd atlas-search-quickstart
dotnet new console
```

```shell
dotnet add package MongoDB.Driver
```

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

### Connect to MongoDB and Retrieve Document in C#

Source: https://www.mongodb.com/pt-br/docs/get-started

Connects to a MongoDB deployment using a connection string from an environment variable, retrieves a specific movie document from the 'movies' collection in the 'sample_mflix' database, and prints the document to the console. Requires the MONGODB_URI environment variable to be set.

```csharp
using MongoDB.Driver;
using MongoDB.Bson;

var connectionString = Environment.GetEnvironmentVariable("MONGODB_URI");
if (connectionString == null)
{
    Console.WriteLine("You must set your 'MONGODB_URI' environment variable. To learn how to set it, see https://www.mongodb.com/docs/drivers/csharp/current/get-started/create-connection-string");
    Environment.Exit(0);
}

var client = new MongoClient(connectionString);

var collection = client.GetDatabase("sample_mflix").GetCollection<BsonDocument>("movies");

var filter = Builders<BsonDocument>.Filter.Eq("title", "Back to the Future");

var document = collection.Find(filter).First();

Console.WriteLine(document);

```

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

### Add MongoDB Dependencies to Rust Project

Source: https://www.mongodb.com/pt-br/docs/get-started

Configuration for the 'Cargo.toml' file to add necessary dependencies for a Rust MongoDB application. Includes 'serde', 'futures', 'tokio', and the 'mongodb' driver.

```toml
[dependencies]
serde = "1.0.188" futures = "0.3.28"
tokio = {version = "1.32.0", features = ["full"]}

[dependencies.mongodb]
version = "3.2.4"
```

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

### Configure Maven Dependencies for MongoDB Kotlin

Source: https://www.mongodb.com/pt-br/docs/get-started

Add the MongoDB Kotlin Coroutine driver and BSON serialization dependencies to your Maven project's pom.xml. This includes importing the MongoDB JVM artifacts BOM for version management.

```xml
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongodb-driver-bom</artifactId>
            <version>5.5.1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongodb-kotlin-coroutine-driver</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>bson-kotlinx</artifactId>
    </dependency>
</dependencies>
```

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

### Create Rust Application to Query MongoDB

Source: https://www.mongodb.com/pt-br/docs/get-started

Rust code to connect to a MongoDB cluster using a provided connection string, query the 'movies' collection in the 'sample_mflix' database for a specific title, and print the retrieved document. Requires 'tokio' for async execution.

```rust
use mongodb::
	bson::{ Document, doc },
	Client,
	Collection
;

#[tokio::main]
async fn main() -> mongodb::error::Result<()> {
    // Replace the placeholder with your Atlas connection string
    let uri = "<connection string>";

    // Create a new client and connect to the server
    let client = Client::with_uri_str(uri).await?;

    // Get a handle on the movies collection
    let database = client.database("sample_mflix");
    let my_coll: Collection<Document> = database.collection("movies");

    // Find a movie based on the title value
    let my_movie = my_coll.find_one(doc! { "title": "The Perils of Pauline" }).await?;

    // Print the document
    println!("Found a movie:\n{:#?}", my_movie);
    Ok(())
}
```

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

### Connect to MongoDB and Query Data in Kotlin

Source: https://www.mongodb.com/pt-br/docs/get-started

This Kotlin code snippet demonstrates how to establish a connection to a MongoDB cluster using a connection string, query for a specific movie document by title, and print the result. It utilizes coroutines for asynchronous operations.

```kotlin
import com.mongodb.client.model.Filters.eq
import com.mongodb.kotlin.client.coroutine.MongoClient
import io.github.cdimascio.dotenv.dotenv
import kotlinx.coroutines.flow.firstOrNull
import kotlinx.coroutines.runBlocking
import org.bson.Document

fun main() {

    // Replace the placeholder with your MongoDB deployment's connection string
    val uri = <connection string URI>

    val mongoClient = MongoClient.create(uri)
    val database = mongoClient.getDatabase("sample_mflix")
    val collection = database.getCollection<Document>("movies")

    runBlocking {
        val doc = collection.find(eq("title", "Back to the Future")).firstOrNull()
        if (doc != null) {
            println(doc.toJson())
        } else {
            println("No matching documents found.")
        }
    }

    mongoClient.close()
}
```

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

### Example Output for Index Creation

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial/facet-tutorial

This shows the expected output after successfully running the Python script to create a search index. It confirms the creation by printing the name of the new index.

```text
New index name: default
```

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

### Install Atlas CLI with Homebrew

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial

Installs the MongoDB Atlas Command Line Interface (CLI) using the Homebrew package manager. This is a prerequisite for managing Atlas resources locally. Ensure Homebrew is installed before running this command.

```bash
brew install mongodb-atlas-cli
```

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

### Add MongoDB .NET/C# Driver to Project

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial/facet-tutorial

Installs the MongoDB.Driver NuGet package using the .NET CLI. This is the first step to integrating MongoDB functionality into a C# application.

```bash
dotnet add package MongoDB.Driver
```

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

### Download MongoDB Docker Images

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial

Downloads the latest MongoDB Community Server and MongoDB Community Search Docker images. Ensure Docker is installed and running.

```shell
docker pull mongodb/mongodb-community-server:latest && docker pull mongodb/mongodb-community-search:latest
```

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

### Run C# Project to Create Index

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/manage-indexes

This command compiles and runs the C# project that creates a MongoDB Search index. Ensure you have the .NET SDK installed and the `csharp-create-index.csproj` file in your current directory.

```shell
dotnet run csharp-create-index.csproj

```

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

### Connect to MongoDB and Query Data in Kotlin

Source: https://www.mongodb.com/pt-br/docs/get-started

This Kotlin code demonstrates how to establish a connection to your MongoDB cluster using a provided connection string URI. It defines a data class 'Movie' to map to MongoDB documents and then queries the 'movies' collection for a specific title, printing the result or a 'not found' message. This requires the previously configured Maven dependencies.

```kotlin
import com.mongodb.client.model.Filters.eq
import com.mongodb.kotlin.client.MongoClient

// Create data class to represent a MongoDB document
data class Movie(val title: String, val year: Int, val directors: List<String>)

fun main() {
    // Replace the placeholder with your MongoDB deployment's connection string
    val uri = "<connection string URI>"

    val mongoClient = MongoClient.create(uri)
    val database = mongoClient.getDatabase("sample_mflix")
    val collection = database.getCollection<Movie>("movies")

    // Find a document with the specified title
    val doc = collection.find(eq(Movie::title.name, "Before Sunrise")).firstOrNull()

    if (doc != null) {
        // Print the matching document
        println(doc)
    } else {
        println("No matching documents found.")
    }
}
```

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

### Add MongoDB and Reactor Dependencies to Maven pom.xml

Source: https://www.mongodb.com/pt-br/docs/get-started

This XML snippet defines the necessary dependencies for a Java project using MongoDB's reactive streams driver and Project Reactor. It includes importing the Bill of Materials (BOM) for both MongoDB JVM artifacts and Reactor, as well as the core and test dependencies for Reactor and the reactive streams driver for MongoDB.

```xml
<dependencyManagement>
    <dependencies>
       <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongodb-driver-bom</artifactId>
            <version>5.5.1</version>
            <type>pom</type>
            <scope>import</scope>
       </dependency>
        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-bom</artifactId>
            <version>2023.0.7</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>io.projectreactor</groupId>
        <artifactId>reactor-core</artifactId>
    </dependency>
    <dependency>
        <groupId>io.projectreactor</groupId>
        <artifactId>reactor-test</artifactId>
        <scope>test</scope>
    </dependency>
   <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongodb-driver-reactivestreams</artifactId>
   </dependency>
</dependencies>
```

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

### Initialize Node.js Project for MongoDB Search Index

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial

Initializes a new Node.js project and installs the MongoDB Node.js Driver. This is a prerequisite for interacting with MongoDB and creating search indexes.

```shell
mkdir atlas-search-quickstart && cd atlas-search-quickstart
npm init -y
npm install mongodb
```

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

### Install MongoDB Go Driver

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial/partial-match

Installs the MongoDB Go Driver, a necessary dependency for interacting with MongoDB from Go applications. This command adds the driver package to your project's dependencies.

```shell
# Add the MongoDB Go Driver to your project
go get go.mongodb.org/mongo-driver/mongo
```

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

### Initialize Go Module and Add MongoDB Driver

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial/facet-tutorial

This snippet shows how to create a new Go project directory, initialize a Go module, and add the MongoDB Go Driver. It requires the 'go' command-line tool to be installed.

```shell
# Create a new directory and initialize the project
mkdir atlas-search-project && cd atlas-search-project
go mod init atlas-search-project

# Add the MongoDB Go Driver to your project
go get go.mongodb.org/mongo-driver/v2/mongo
```

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

### Initialize Go Module and Install MongoDB Driver

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial

This snippet demonstrates how to create a new Go project directory, initialize it as a Go module, and then add the official MongoDB Go Driver as a dependency. This is the foundational step for interacting with MongoDB from a Go application.

```bash
# Create a new directory and initialize the project
mkdir atlas-search-quickstart && cd atlas-search-quickstart
go mod init atlas-search-quickstart
```

```bash
# Add the MongoDB Go Driver to your project
go get go.mongodb.org/mongo-driver/v2/mongo
```

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

### Add MongoDB Kotlin Dependencies to Maven Project

Source: https://www.mongodb.com/pt-br/docs/get-started

This XML snippet configures your Maven project's pom.xml file to include the necessary MongoDB JVM artifacts and the Kotlin Coroutine driver. It also adds a serialization package for Kotlin object to BSON conversion. Ensure you have JDK 1.8 or later installed.

```xml
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongodb-driver-bom</artifactId>
            <version>5.5.1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongodb-driver-sync</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongodb-kotlin-sync-driver</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>bson-kotlinx</artifactId>
    </dependency>
</dependencies>
```

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

### Load Sample Data with mongorestore

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial

Loads the downloaded sample data archive into a local MongoDB deployment using the mongorestore command. This requires the MongoDB Database Tools to be installed and a running MongoDB instance. Replace '<port-number>' with the actual port.

```bash
mongorestore --archive=sampledata.archive --port=<port-number>
```

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

### Download and Load Sample Data for MongoDB

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial

This snippet provides shell commands to download sample data from a URL and load it into a MongoDB deployment using mongorestore. Ensure mongorestore is accessible in your PATH and replace `<port-number>` with your deployment's port.

```shell
curl https://atlas-education.s3.amazonaws.com/sampledata.archive -o sampledata.archive
```

```shell
mongorestore --archive=sampledata.archive --port=<port-number>
```

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

### Connect to MongoDB and Create Search Index (C)

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial/partial-match

This C code demonstrates how to initialize the MongoDB C driver, establish a connection to a MongoDB instance using a URI, and create a search index with a specific definition. It includes functions for connecting, cleaning up resources, and the main logic for index creation. Dependencies include the MongoDB C driver and bson library.

```c
mongoc_client_t* connect_to_mongodb(void) {
    mongoc_client_t *client;
    mongoc_uri_t *uri;
    bson_error_t error;

    // Initialize MongoDB C driver
    mongoc_init();

    // Create a MongoDB URI object
    uri = mongoc_uri_new_with_error(MONGODB_URI, &error);
    if (!uri) {
        fprintf(stderr, "Failed to parse URI: %s\n", error.message);
        return NULL;
    }

    // Create a new client instance
    client = mongoc_client_new_from_uri(uri);
    if (!client) {
        fprintf(stderr, "Failed to create MongoDB client\n");
        mongoc_uri_destroy(uri);
        return NULL;
    }

    // Configure the client for server API version
    mongoc_client_set_error_api(client, 2);

    mongoc_uri_destroy(uri);
    return client;
}

void cleanup_mongodb(mongoc_client_t *client) {
    if (client) {
        mongoc_client_destroy(client);
    }
    mongoc_cleanup();
}

int main(void) {
    mongoc_client_t *client;
    mongoc_database_t *database;
    mongoc_collection_t *collection;
    bson_t *index_spec;
    bson_error_t error;
    char *index_name;
    bool result;

    // Connect to MongoDB
    client = connect_to_mongodb();
    if (!client) {
        return EXIT_FAILURE;
    }

    printf("Connected to MongoDB Atlas\n");

    // Get database and collection
    database = mongoc_client_get_database(client, DATABASE_NAME);
    collection = mongoc_client_get_collection(client, DATABASE_NAME, COLLECTION_NAME);

    // Create the search index specification
    index_spec = bson_new();

    // Build the index definition
    bson_t *definition = bson_new();
    bson_t *mappings = bson_new();
    bson_t *fields = bson_new();
    bson_t *title_field = bson_new();

    // Configure title field for string search
    BSON_APPEND_UTF8(title_field, "type", "string");

    // Add title field to fields object
    BSON_APPEND_DOCUMENT(fields, "title", title_field);

    // Build mappings object
    BSON_APPEND_BOOL(mappings, "dynamic", false);
    BSON_APPEND_DOCUMENT(mappings, "fields", fields);

    // Add mappings to definition
    BSON_APPEND_DOCUMENT(definition, "mappings", mappings);

    // Build the complete index specification
    BSON_APPEND_UTF8(index_spec, "name", "partial-match-tutorial");
    BSON_APPEND_DOCUMENT(index_spec, "definition", definition);

    printf("Creating search index...\n");

    // Create the search index
    result = mongoc_collection_create_search_index(collection, index_spec, NULL, &index_name, &error);

    if (!result) {
        fprintf(stderr, "Failed to create search index: %s\n", error.message);
        bson_destroy(index_spec);
        bson_destroy(definition);
        bson_destroy(mappings);
        bson_destroy(fields);
        bson_destroy(title_field);
        mongoc_collection_destroy(collection);
        mongoc_database_destroy(database);
        cleanup_mongodb(client);
        return EXIT_FAILURE;
    }

    printf("New index name: %s\n", index_name);

    // Cleanup
    bson_free(index_name);
    bson_destroy(index_spec);
    bson_destroy(definition);
    bson_destroy(mappings);
    bson_destroy(fields);
    bson_destroy(title_field);
    mongoc_collection_destroy(collection);
    mongoc_database_destroy(database);
    cleanup_mongodb(client);

    printf("Successfully created string search index\n");
    return EXIT_SUCCESS;
}

```

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

### Search Movie Titles Starting With 'Fast &' - C# Example Snippet

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/autocomplete

A C# code snippet demonstrating how to perform a prefix search for movie titles using MongoDB's driver. This example sets up a connection to Atlas, configures conventions for field mapping, and includes placeholders for the connection string, indicating where the search logic would be integrated.

```csharp
using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Bson.Serialization.Conventions;
using MongoDB.Driver;
using MongoDB.Driver.Search;

public class AutocompleteTokenOrderSequentialStartsWithExample
{
    private const string MongoConnectionString = "<connection-string>";

    public static void Main(string[] args)
    {
        // allow automapping of the camelCase database fields to our MovieDocument
        var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);

        // connect to your Atlas cluster
        var mongoClient = new MongoClient(MongoConnectionString);
        var mflixDatabase = mongoClient.GetDatabase("sample_mflix");

```

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

### Initialize Rust Project and Add Dependencies

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial

Sets up a new Rust project using Cargo and adds essential dependencies for MongoDB interaction and asynchronous operations. This includes `serde`, `futures`, `tokio`, and the `mongodb` driver.

```shell
cargo new atlas-search-quickstart && cd atlas-search-quickstart

[dependencies]
  serde = "1.0"
  futures = "0.3"
  tokio = {version = "1.0", features = ["full"]}

[dependencies.mongodb]
  version = "3.0"
```

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

### Compile and Run Kotlin Index Creation Script

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial/facet-tutorial

These shell commands demonstrate how to compile a Kotlin file named 'CreateIndex.kt' into an executable JAR and then run that JAR to create a MongoDB search index.

```shell
kotlinc CreateIndex.kt -include-runtime -d CreateIndex.jar
java -jar CreateIndex.jar
```

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

### Resolve macOS Library Loading Error

Source: https://www.mongodb.com/pt-br/docs/get-started

Adds the -Wl,-rpath option to the compilation command to resolve 'Library not loaded' errors on macOS when using the MongoDB C++ driver.

```bash
c++ --std=c++17 quickstart.cpp -Wl,-rpath,/usr/local/lib/ $(pkg-config --cflags --libs libmongocxx) -o ./app.out
./app.out
```

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

### Add MongoDB Ruby Driver Dependency

Source: https://www.mongodb.com/pt-br/docs/get-started

Ruby code snippet using Bundler to inline dependency management. It specifies the source for gems and adds the 'mongo' gem, which is required for interacting with MongoDB.

```ruby
require 'bundler/inline'

gemfile do
  source 'https://rubygems.org'
  gem 'mongo'
end
```

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

### Initialize C# Console Project

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/manage-indexes

This command initializes a new C# console application project within the current directory. It uses the 'dotnet' CLI and creates the necessary project files for a basic console application. No input is taken, and it outputs project files.

```shell
dotnet new console
```

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

### Retrieve MongoDB Connection String using Atlas CLI

Source: https://www.mongodb.com/pt-br/docs/get-started

This bash command demonstrates how to retrieve the connection string for a specific MongoDB Atlas cluster using the Atlas CLI. Replace 'myTestDb' with the actual name of your cluster.

```bash
atlas clusters connectionStrings describe myTestDb
```

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

### Connect to MongoDB and Query Data in PHP

Source: https://www.mongodb.com/pt-br/docs/get-started

PHP code snippet to establish a connection to a MongoDB cluster using a connection URI from environment variables, query for a specific movie document from the 'movies' collection in the 'sample_mflix' database, and display the result.

```php
<?php

require __DIR__ . '/../vendor/autoload.php';

$uri = getenv('MONGODB_URI') ?: throw new RuntimeException(
    'Set the MONGODB_URI environment variable to your Atlas URI',
);
$client = new MongoDBClient($uri);
$collection = $client->sample_mflix->movies;

$filter = ['title' => 'The Shawshank Redemption'];
$result = $collection->findOne($filter);

if ($result) {
    echo json_encode($result, JSON_PRETTY_PRINT);
} else {
    echo 'Document not found';
}


```

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

### Initialize .NET/C# Atlas Search Project

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial/facet-tutorial

Commands to set up a new .NET/C# console application project for Atlas Search. This involves creating a directory and initializing a new console project using the 'dotnet new console' command.

```shell
# Create a new directory and initialize the project
mkdir atlas-search-project && cd atlas-search-project
dotnet new console

```

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

### Create Single MongoDB Search Index using C

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/manage-indexes

This C code example demonstrates how to create a single MongoDB search index. It specifies the index definition, converts it to BSON, and executes the `createSearchIndexes` command using `mongoc_collection_command_simple()`. Ensure the MongoDB C driver is installed and linked correctly.

```c
#include <mongoc/mongoc.h>
#include <stdlib.h>

int main (void)
{
    mongoc_client_t *client = NULL;
    mongoc_collection_t *collection = NULL;
    mongoc_database_t *database = NULL;
    bson_error_t error;
    bson_t cmd = BSON_INITIALIZER;
    bool ok = true;

    mongoc_init();

    // Connect to your Atlas deployment
    client = mongoc_client_new("<connectionString>");
    if (!client) {
        fprintf(stderr, "Failed to create a MongoDB client.\n");
        ok = false;
        goto cleanup;
    }

    // Access your database and collection
    database = mongoc_client_get_database(client, "<databaseName>");
    collection = mongoc_database_get_collection(database, "<collectionName>");

    // Specify the command and the new index
    const char *cmd_str = BSON_STR({
        "createSearchIndexes" : "<collectionName>",
        "indexes" : [ { 
            "name" : "<indexName>",
            "definition" : {
                "analyzer": "<indexAnalyzer>",
                "searchAnalyzer": "<queryAnalyzer>",
                "mappings": {
                    "dynamic": <boolean>,
                    "fields": { <fieldDefinition> } 
                },
                "numPartitions": <integer>,
                "analyzers": [ <customAnalyzer> ],
                "storedSource": <boolean> | {
                    <storedSourceDefinition>
                },
                "synonyms": [
                    {
                        <synonymMappingDefinition>
                    }
                ]
            }
	    } ]
	});

    // Convert your command to BSON
    if (!bson_init_from_json(&cmd, cmd_str, -1, &error)) {
        fprintf(stderr, "Failed to parse command: %s\n", error.message);
        ok = false;
        goto cleanup;
    }

    // Create the MongoDB Search index by running the command
    if (!mongoc_collection_command_simple (collection, &cmd, NULL, NULL, &error)) {
        fprintf(stderr, "Failed to run createSearchIndexes: %s\n", error.message);
        ok = false;
        goto cleanup;
    }
    printf ("Index created!\n");

cleanup:
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
   mongoc_database_destroy (database);
   bson_destroy (&cmd);
   mongoc_cleanup ();
   return ok ? EXIT_SUCCESS : EXIT_FAILURE;
}

```

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

### Initialize Rust Project and Add Dependencies for MongoDB Search

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial

This snippet shows how to initialize a new Rust project using Cargo and lists the necessary dependencies for MongoDB interaction and search functionality. The dependencies include 'serde', 'futures', 'tokio', and the 'mongodb' driver.

```shell
# Create a new Rust project
cargo new atlas-search-quickstart && cd atlas-search-quickstart
```

```toml
[dependencies]
  serde = "1.0"
  futures = "0.3"
  tokio = {version = "1.0", features = ["full"]}

[dependencies.mongodb]
  version = "3.0"
```

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

### Connect to MongoDB and Query Data in Ruby

Source: https://www.mongodb.com/pt-br/docs/get-started

Ruby code snippet to connect to a MongoDB cluster using a provided connection string, access the 'movies' collection in the 'sample_mflix' database, find a movie document by title, print the result, and ensure the client connection is closed.

```ruby
uri = '<connection string>'

begin
  client = Mongo::Client.new(uri)

  database = client.use('sample_mflix')
  movies = database[:movies]

  # Queries for a movie that has the title 'Back to the Future'
  query = { title: 'Back to the Future' }
  movie = movies.find(query).first

  # Prints the movie document
  puts movie

ensure
  client&.close
end
```

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

### Initialize Rust Project for MongoDB Search

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial/partial-match

This snippet shows how to create a new Rust project and add the necessary dependencies for interacting with MongoDB, specifically for using MongoDB Search.

```bash
cargo new atlas-search-partial-match-tutorial && cd atlas-search-partial-match-tutorial
```

```toml
[dependencies]
serde = "1.0" futures = "0.3"
 tokio = {version = "1.0", features = ["full"]}

[dependencies.mongodb]
version = "3.0"
```

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

### Shell: Build and Run C Application

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial/facet-tutorial

These shell commands build and run a C application designed to create a MongoDB Atlas Search index. The commands first create a build directory, then compile the application using CMake, and finally execute the compiled program. The expected output is 'Index created!'.

```shell
cmake -S. -Bcmake-build
cmake --build cmake-build --target index.out
./cmake-build/index.out
```

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

### Connect and Query MongoDB with Node.js

Source: https://www.mongodb.com/pt-br/docs/get-started

This Node.js code snippet connects to a MongoDB cluster using the provided connection string URI. It then queries for a specific movie document from the 'sample_mflix' database and 'movies' collection. Ensure you replace the placeholder with your actual MongoDB connection string.

```javascript
const { MongoClient } = require('mongodb');

async function runGetStarted() {
  // Replace the uri string with your connection string
  const uri = '<connection string URI>';
  const client = new MongoClient(uri);

  try {
    const database = client.db('sample_mflix');
    const movies = database.collection('movies');

    // Queries for a movie that has a title value of 'Back to the Future'
    const query = { title: 'Back to the Future' };
    const movie = await movies.findOne(query);

    console.log(movie);
  } finally {
    await client.close();
  }
}
runGetStarted().catch(console.dir);

```

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

### Compile and Run C++ MongoDB Search Index Creation

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial/facet-tutorial

This command compiles the C++ code for creating a MongoDB Search index and then executes the compiled program. It uses pkg-config to include the necessary mongocxx library flags. Ensure the mongocxx driver is installed and accessible.

```shell
c++ --std=c++17 CreateIndex.cpp $(pkg-config --cflags --libs libmongocxx) -o ./app.out
./app.out
```

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

### Add MongoDB Driver BOM to Maven project

Source: https://www.mongodb.com/pt-br/docs/get-started

This XML snippet adds the Bill of Materials (BOM) for MongoDB JVM artifacts and the Java driver to a Maven project's `pom.xml` file. This simplifies dependency management for MongoDB drivers in Java projects, ensuring compatible versions are used.

```xml
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongodb-driver-bom</artifactId>
            <version>5.5.1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongodb-driver-sync</artifactId>
        </dependency>
    </dependencies>
</dependencyManagement>
```

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

### Initialize Rust project for MongoDB Atlas Search

Source: https://www.mongodb.com/pt-br/docs/atlas/atlas-search/tutorial/facet-tutorial

Initializes a new Rust project using Cargo and specifies the necessary dependencies for interacting with MongoDB Atlas Search, including 'serde', 'futures', 'tokio', and the 'mongodb' driver.

```shell
# Create a new Rust project
cargo new atlas-search-facet-tutorial && cd atlas-search-facet-tutorial
```

```toml
[dependencies]
serde = "1.0"utures = "0.3"
tokio = {version = "1.0", features = ["full"]}

[dependencies.mongodb]
version = "3.0"
```

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

### Connect and Query MongoDB with Python

Source: https://www.mongodb.com/pt-br/docs/get-started

This Python code snippet connects to a MongoDB database, queries for a movie with the title 'Back to the Future', and prints the result. It uses the pymongo driver and requires a valid connection string URI. Ensure the '<connection string URI>' placeholder is replaced with your actual connection string.

```python
from pymongo import MongoClient

uri = "<connection string URI>"
client = MongoClient(uri)

try:
    database = client.get_database("sample_mflix")
    movies = database.get_collection("movies")

    # Query for a movie that has the title 'Back to the Future'
    query = { "title": "Back to the Future" }
    movie = movies.find_one(query)

    print(movie)

    client.close()

except Exception as e:
    raise Exception("Unable to find the document due to the following error: ", e)

```

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

### Java: Connect to MongoDB and Query Movies

Source: https://www.mongodb.com/pt-br/docs/get-started

A Java application that connects to a MongoDB cluster using a provided connection string URI, queries for a specific movie by title ('Back to the Future'), and prints the JSON representation of the found document or a 'not found' message. It utilizes the MongoDB Java Driver and requires the `mongodb-driver-sync` dependency.

```java
import static com.mongodb.client.model.Filters.eq;

import org.bson.Document;

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;

public class QuickStart {
    public static void main( String[] args ) {

        // Replace the placeholder with your MongoDB deployment's connection string
        String uri = "<connection string uri>";

        try (MongoClient mongoClient = MongoClients.create(uri)) {
            MongoDatabase database = mongoClient.getDatabase("sample_mflix");
            MongoCollection<Document> collection = database.getCollection("movies");

            Document doc = collection.find(eq("title", "Back to the Future")).first();
            if (doc != null) {
                System.out.println(doc.toJson());
            } else {
                System.out.println("No matching documents found.");
            }
        }
    }
}
```
Tokens:
Raw