MongoDB Go Driver

https://www.mongodb.com/docs/drivers/go/current/
Admin
MongoDB Go Driver is the official Go driver for MongoDB that enables developers to connect, query,...
Tokens:124,031
Snippets:1,135
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Insert sample data

Source: https://www.mongodb.com/docs/drivers/go/current/crud/query/retrieve

Load documents into the tea collection in the db database to run the guide examples.

```go
coll := client.Database("db").Collection("tea")
docs := []any{
	Tea{Item: "Masala", Rating: 10, DateOrdered: time.Date(2009, 11, 17, 0, 0, 0, 0, time.Local)},
	Tea{Item: "Sencha", Rating: 7, DateOrdered: time.Date(2009, 11, 18, 0, 0, 0, 0, time.Local)},
	Tea{Item: "Masala", Rating: 9, DateOrdered: time.Date(2009, 11, 12, 0, 0, 0, 0, time.Local)},
	Tea{Item: "Masala", Rating: 8, DateOrdered: time.Date(2009, 12, 1, 0, 0, 0, 0, time.Local)},
	Tea{Item: "Sencha", Rating: 10, DateOrdered: time.Date(2009, 12, 17, 0, 0, 0, 0, time.Local)},
	Tea{Item: "Hibiscus", Rating: 4, DateOrdered: time.Date(2009, 12, 18, 0, 0, 0, 0, time.Local)},
}

result, err := coll.InsertMany(context.TODO(), docs)
```

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

### Install Dependencies

Source: https://www.mongodb.com/docs/drivers/go/current/crud/tutorial-web-application

Install the Gin framework and the MongoDB Go Driver.

```bash
go get github.com/gin-gonic/gin
go get go.mongodb.org/mongo-driver/v2/mongo
```

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

### Install Dependencies

Source: https://www.mongodb.com/docs/drivers/go/current/connect/go-lambda

Commands to install the MongoDB Go driver and the AWS Lambda SDK.

```bash
go get go.mongodb.org/mongo-driver/v2/mongo
go get github.com/aws/aws-lambda-go/lambda
```

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

### Start Application

Source: https://www.mongodb.com/docs/drivers/go/current/integrations/vector-search-bedrock

Run the application from the project directory.

```sh
go mod tidy
go run server.go
```

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

### Example output for RunCommand

Source: https://www.mongodb.com/docs/drivers/go/current/run-command

The expected output format when running the database command example.

```none
// results truncated
{
    "avgObjSize": 548.4101901854896,
    "collections": 2,
    "dataSize": 14014074,
    "db": "sample_restaurants",
    "indexSize": 286720,
    ...,
}
```

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

### Full File Example: Restaurant Insertion

Source: https://www.mongodb.com/docs/drivers/go/current/crud/insert

A complete example showing how to connect to a MongoDB instance and insert a restaurant document using a struct.

```go
// Inserts a single document describing a restaurant by using the Go driver
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/v2/mongo"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)

// Defines the structure of a restaurant document
type Restaurant struct {
	Name         string
	RestaurantId string        `bson:"restaurant_id,omitempty"`
	Cuisine      string        `bson:"cuisine,omitempty"`
	Address      any           `bson:"address,omitempty"`
	Borough      string        `bson:"borough,omitempty"`
	Grades       []any         `bson:"grades,omitempty"`
}

func main() {
	if err := godotenv.Load(); err != nil {
		log.Println("No .env file found")
	}

	var uri string
	if uri = os.Getenv("MONGODB_URI"); uri == "" {
		log.Fatal("You must set your 'MONGODB_URI' environment variable. See\n\t https://www.mongodb.com/docs/drivers/go/current/connect/mongoclient/#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)
		}
	}()

	// Inserts a sample document describing a restaurant into the collection
	coll := client.Database("sample_restaurants").Collection("restaurants")
	newRestaurant := Restaurant{Name: "8282", Cuisine: "Korean"}

	result, err := coll.InsertOne(context.TODO(), newRestaurant)
	if err != nil {
		panic(err)
	}

	// Prints the ID of the inserted document
	fmt.Printf("Document inserted with ID: %s\n", result.InsertedID)

	// When you run this file for the first time, it should print output similar
	// to the following:
	// Document inserted with ID: ObjectID("...")

}
```

```none
Document inserted with ID: ObjectID("...")
```

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

### InsertMany() Output Example

Source: https://www.mongodb.com/docs/drivers/go/current/crud/insert

The expected console output after running the InsertMany() example.

```none
Documents inserted: 3
Inserted document with _id: ObjectID("...")
Inserted document with _id: ObjectID("...")
Inserted document with _id: ObjectID("...")
```

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

### DeleteOne() Example Output

Source: https://www.mongodb.com/docs/drivers/go/current/crud/delete

The expected console output after successfully running the DeleteOne example.

```none
Documents deleted: 1
```

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

### Configure Session and Transaction Options

Source: https://www.mongodb.com/docs/drivers/go/current/crud/transactions

Demonstrates how to create TransactionOptions and SessionOptions, then apply them when starting a new session with client.StartSession().

```go
txnOpts := options.Transaction().SetReadConcern(readconcern.Majority())
sessOpts := options.Session().SetDefaultTransactionOptions(txnOpts)
session, err := client.StartSession(sessOpts)
if err != nil {
	return err
}
```

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

### Find Multiple Documents Full File Example

Source: https://www.mongodb.com/docs/drivers/go/current/crud/query/retrieve

A complete example demonstrating how to connect to a MongoDB instance and retrieve all documents from the restaurants collection where the cuisine is Italian.

```go
// Retrieves documents that match a query filter by using the Go driver
package main

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

	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)

// Creates a Restaurant struct as a model for documents in the restaurants collection
type Restaurant struct {
	ID           bson.ObjectID `bson:"_id"`
	Name         string
	RestaurantId string `bson:"restaurant_id"`
	Cuisine      string
	Address      any
	Borough      string
	Grades       any
}

func main() {
	if err := godotenv.Load(); err != nil {
		log.Println("No .env file found")
	}

	var uri string
	if uri = os.Getenv("MONGODB_URI"); uri == "" {
		log.Fatal("You must set your 'MONGODB_URI' environment variable. See\n\t https://www.mongodb.com/docs/drivers/go/current/connect/mongoclient/#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_restaurants").Collection("restaurants")

	// Creates a query filter to match documents in which the "cuisine"
	// is "Italian"
	filter := bson.D{{"cuisine", "Italian"}}

	// Retrieves documents that match the query filter
	cursor, err := coll.Find(context.TODO(), filter)
	if err != nil {
		panic(err)
	}

	// Unpacks the cursor into a slice
	var results []Restaurant
	if err = cursor.All(context.TODO(), &results); err != nil {
		panic(err)
	}

	// Prints the results of the find operation as structs
	for _, result := range results {
		output, err := json.MarshalIndent(result, "", "    ")
		if err != nil {
			panic(err)
		}
		fmt.Printf("%s\n", output)
	}
}
```

```none
// results truncated
...
{ ... , "Name" : "Epistrophy Cafe", "RestaurantId": "41117553", "Cuisine" : "Italian", ... },
{ ... , "Name" : "Remi", "RestaurantId": "41118090", "Cuisine" : "Italian", ... },
{ ... , "Name" : "Sant Ambroeus", "RestaurantId": "41120682", "Cuisine" : "Italian", ... },
...
```

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

### Install MongoDB and Environment Dependencies

Source: https://www.mongodb.com/docs/drivers/go/current/integrations/vector-search-bedrock

Commands to install the required Go packages for MongoDB and environment variable management.

```sh
go get github.com/joho/godotenv
go get go.mongodb.org/mongo-driver/v2
```

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

### Install AWS SDK Dependencies

Source: https://www.mongodb.com/docs/drivers/go/current/integrations/vector-search-bedrock

Commands to install the AWS SDK for Go v2 configuration and Bedrock runtime packages.

```sh
go get github.com/aws/aws-sdk-go-v2/config
go get github.com/aws/aws-sdk-go-v2/service/bedrockruntime
```

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

### Log Output Example

Source: https://www.mongodb.com/docs/drivers/go/current/monitoring-and-logging/logging

Example of the JSON-formatted log output generated by the driver during an insert operation.

```console
{"command":"{\"insert\": \"testColl\",\"or...","commandName":"insert","databaseName":"db","driverConnectionId":1,"message":"Command started","operationId":0,"requestId":13,"serverConnectionId":97377,"serverHost":"...","serverPort":27017,"timestamp":...}
{"commandName":"insert","driverConnectionId":1,"durationMS":19,"message":"Command succeeded","operationId":0,"reply":"{\"n\": {\"$numberInt\":\"1\"},...","requestId":13,"serverConnectionId":97377,"serverHost":"...","serverPort":27017,"timestamp":...}
```

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

### ReplaceOne Document Example

Source: https://www.mongodb.com/docs/drivers/go/current/crud/update/replace

This example connects to a MongoDB instance, filters for a document with a specific name, and replaces it with a new Restaurant struct instance.

```go
// Replaces the first document that matches a filter by using the Go driver
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)

type Restaurant struct {
	Name         string
	RestaurantId string        `bson:"restaurant_id,omitempty"`
	Cuisine      string        `bson:"cuisine,omitempty"`
	Address      any           `bson:"address,omitempty"`
	Borough      string        `bson:"borough,omitempty"`
	Grades       []any         `bson:"grades,omitempty"`
}

func main() {
	if err := godotenv.Load(); err != nil {
		log.Println("No .env file found")
	}

	var uri string
	if uri = os.Getenv("MONGODB_URI"); uri == "" {
		log.Fatal("You must set your 'MONGODB_URI' environment variable. See\n\t https://www.mongodb.com/docs/drivers/go/current/connect/mongoclient/#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_restaurants").Collection("restaurants")
	filter := bson.D{{"name", "Rizzo's Fine Pizza"}}

	// Creates a new document containing "Name" and "Cuisine" fields
	replacement := Restaurant{Name: "Rizzo's Pizza", Cuisine: "Pizza/American"}

	// Replaces the first document that matches the filter with a new document
	result, err := coll.ReplaceOne(context.TODO(), filter, replacement)
	if err != nil {
		panic(err)
	}

	// Prints the number of modified documents
	if result.MatchedCount != 0 {
		fmt.Println("Number of documents replaced:", result.ModifiedCount)
	}

	// When you run this file for the first time, it should print:
	// Number of documents replaced: 1
}
```

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

### Install Azure Identity Module

Source: https://www.mongodb.com/docs/drivers/go/current/security/authentication/oidc

Installs the azidentity module required for fetching authentication credentials in Azure environments.

```sh
go get -u github.com/Azure/azure-sdk-for-go/sdk/azidentity
```

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

### Configure BSONOptions for a Client

Source: https://www.mongodb.com/docs/drivers/go/current/data-formats/bson

This example demonstrates creating a BSONOptions instance with specific marshalling settings and applying it to a Client via ClientOptions.

```go
bsonOpts := &options.BSONOptions {
    UseJSONStructTags: true,
    NilSliceAsEmpty: true,
    OmitEmpty: true,
}

clientOpts := options.Client().
    ApplyURI("<connection string>").
    SetBSONOptions(bsonOpts)

client, err := mongo.Connect(clientOpts)
```

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

### Run a database command with RunCommand

Source: https://www.mongodb.com/docs/drivers/go/current/run-command

This example connects to a MongoDB instance and uses the RunCommand method to retrieve statistics about the sample_restaurants database.

```go
// Runs a database command by using the Go driver
package main

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

	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)

func main() {
	if err := godotenv.Load(); err != nil {
		log.Println("No .env file found")
	}

	var uri string
	if uri = os.Getenv("MONGODB_URI"); uri == "" {
		log.Fatal("You must set your 'MONGODB_URI' environment variable. See\n\t https://www.mongodb.com/docs/drivers/go/current/connect/mongoclient/#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)
		}
	}()

	{
		db := client.Database("sample_restaurants")

		// Retrieves statistics about the specified database
		command := bson.D{{"dbStats", 1}}

		var result bson.M
		// Runs the command and prints the database statistics
		err := db.RunCommand(context.TODO(), command).Decode(&result)

		// Prints a message if any errors occur during the command execution
		if err != nil {
			panic(err)
		}

		/* When you run this file, it should print something similar to the following:
		{
			"avgObjSize": 548.4101901854896,
			"collections": 2,
			"dataSize": 14014074,
			"db": "sample_restaurants",
			"fileSize": 0,
			"indexSize": 286720,
			"indexes": 2,
			"nsSizeMB": 0,
			"numExtents": 0,
			"objects": 25554,
			"ok": 1,
			"storageSize": 8257536,
			"totalFreeStorageSize": 0,
			"views": 0
		}
		*/

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

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

### Find One Document Example

Source: https://www.mongodb.com/docs/drivers/go/current/crud/query/retrieve

This example connects to a MongoDB instance, defines a Restaurant struct, and retrieves the first document from the restaurants collection that matches the name 'Bagels N Buns'. It requires the MONGODB_URI environment variable to be set.

```go
// Retrieves a document that matches a query filter by using the Go driver
package main

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

	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)

// Creates a Restaurant struct as a model for documents in the restaurants collection
type Restaurant struct {
	ID           bson.ObjectID `bson:"_id"`
	Name         string
	RestaurantId string `bson:"restaurant_id"`
	Cuisine      string
	Address      any
	Borough      string
	Grades       []any
}

func main() {
	if err := godotenv.Load(); err != nil {
		log.Println("No .env file found")
	}

	var uri string
	if uri = os.Getenv("MONGODB_URI"); uri == "" {
		log.Fatal("You must set your 'MONGODB_URI' environment variable. See\n\t https://www.mongodb.com/docs/drivers/go/current/connect/mongoclient/#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_restaurants").Collection("restaurants")

	// Creates a query filter to match documents in which the "name" is
	// "Bagels N Buns"
	filter := bson.D{{"name", "Bagels N Buns"}}

	// Retrieves the first matching document
	var result Restaurant
	err = coll.FindOne(context.TODO(), filter).Decode(&result)

	// Prints a message if no documents are matched or if any
	// other errors occur during the operation
	if err != nil {
		if err == mongo.ErrNoDocuments {
			return
		}
		panic(err)
	}

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

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

### Perform an Upsert with UpdateOne

Source: https://www.mongodb.com/docs/drivers/go/current/crud/update/upsert

This example uses a filter to find a document and the SetUpsert(true) option to insert the document if no match is found.

```go
filter := bson.D{{"species", "Ledebouria socialis"}, {"plant_id", 3}}
update := bson.D{{"$set", bson.D{{"species", "Ledebouria socialis"}, {"plant_id", 3}, {"height", 8.3}}}}

// Sets the upsert option to true
opts := options.UpdateOne().SetUpsert(true)

// Updates a documents or inserts a document if no documents are
// matched and prints the results
result, err := coll.UpdateOne(context.TODO(), filter, update, opts)
if err != nil {
	panic(err)
}

fmt.Printf("Number of documents updated: %v\n", result.ModifiedCount)
fmt.Printf("Number of documents upserted: %v\n", result.UpsertedCount)
```

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

### FindOneAndReplace operation example

Source: https://www.mongodb.com/docs/drivers/go/current/crud/compound-operations

This example demonstrates finding a document by title and replacing it with a new document. It includes the operation call and decoding the result into a struct.

```go
filter := bson.D{{"title", "Representation Theory"}}
replacement := Course{Title: "Combinatorial Theory", Enrollment: 35}

var outdatedDoc Course
err := coll.FindOneAndReplace(context.TODO(), filter, replacement).Decode(&previousDoc)
if err != nil {
    panic(err)
}

res, _ := bson.MarshalExtJSON(outdatedDoc, false, false)
fmt.Println(string(res))
```

```none
{"title":"Representation Theory","enrollment":40}
```

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

### Distinct Values Output

Source: https://www.mongodb.com/docs/drivers/go/current/crud/query/distinct

The expected output when running the Go example.

```none
Brooklyn
Manhattan
Queens
```

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

### InsertOne Output

Source: https://www.mongodb.com/docs/drivers/go/current/data-formats/struct-tagging

The expected console output after running the insertion example.

```none
Document inserted with ID: ObjectID("...")
```

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

### Configure Read Preference for Secondary Nodes

Source: https://www.mongodb.com/docs/drivers/go/current/crud/configure

This example demonstrates how to create a secondary read preference and apply it to a database instance using the options package.

```go
rp := readpref.Secondary()
opts := options.Database().SetReadPreference(rp)
database := client.Database("db", opts)
```

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

### StartTransaction()

Source: https://www.mongodb.com/docs/drivers/go/current/crud/transactions

Starts a new transaction on the session with the provided options.

```APIDOC
## StartTransaction()

### Description
Starts a new transaction, configured with the given options, on this session. Returns an error if there is already a transaction in progress for the session.

### Parameters
- **TransactionOptions** - Required - Configuration options for the transaction.

### Returns
- **error** - Returns an error if the transaction cannot be started.
```

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

### Run the Vector Search Query in Go

Source: https://www.mongodb.com/docs/drivers/go/current/atlas-vector-search

This example builds an aggregation pipeline with $vectorSearch and $project stages, executes it against a collection, and unmarshals the results into a struct.

```go
// Creates the aggregation pipeline
vectorSearchStage := bson.D{
	{"$vectorSearch", bson.D{
		{"index", "vector_index"},
		{"path", "plot_embedding"},
		{"queryVector", queryVector},
		{"numCandidates", 150},
		{"limit", 5},
	}}}}

projectStage := bson.D{
	{"$project", bson.D{
		{"_id", 0},
		{"plot", 1},
		{"title", 1},
		{"score", bson.D{{"$meta", "vectorSearchScore"}}},
	}}}}

// Runs the aggregation pipeline
cursor, err := coll.Aggregate(ctx, mongo.Pipeline{vectorSearchStage, projectStage})
if err != nil {
	log.Fatalf("failed to retrieve data from the server: %v", err)
}

// Displays the results
type ProjectedMovieResult struct {
	Title string  `bson:"title"`
	Plot  string  `bson:"plot"`
	Score float64 `bson:"score"`
}

var results []ProjectedMovieResult
if err = cursor.All(ctx, &results); err != nil {
	log.Fatalf("failed to unmarshal retrieved docs to ProjectedMovieResult objects: %v", err)
}

for _, result := range results {
	fmt.Printf("Title: %v \nPlot: %v \nScore: %v \n\n", result.Title, result.Plot, result.Score)
}
```

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

### Kitchen Item Document Example

Source: https://www.mongodb.com/docs/drivers/go/current/crud/update/replace

A sample JSON document representing a kitchen item.

```json
{
   "_id" : 2056,
   "item" : "Mug",
   "brand" : "Simply Ceramics",
   "price" : 2.99,
   "material" : "Glass"
}
```

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

### Insert sample data into courses collection

Source: https://www.mongodb.com/docs/drivers/go/current/crud/compound-operations

Use this snippet to populate the db.courses collection with sample course documents before running compound operation examples.

```go
coll := client.Database("db").Collection("courses")
docs := []any{
	Course{Title: "Representation Theory", Enrollment: 40},
	Course{Title: "Early Modern Philosophy", Enrollment: 25},
	Course{Title: "Animal Communication", Enrollment: 18},
}

result, err := coll.InsertMany(context.TODO(), docs)
```

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

### Full Runnable UpdateOne Example

Source: https://www.mongodb.com/docs/drivers/go/current/crud/update

A complete Go program that connects to MongoDB and updates the avg_rating field in the restaurants collection.

```go
// Updates the first document that matches a query filter by using the Go driver
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)

// Defines a Restaurant struct as a model for documents in the "restaurants" collection
type Restaurant struct {
	ID            bson.ObjectID `bson:"_id"`
	Name          string        `bson:"name"`
	AverageRating float64       `bson:"avg_rating,omitempty"`
}

func main() {
	if err := godotenv.Load(); err != nil {
		log.Println("No .env file found")
	}

	var uri string
	if uri = os.Getenv("MONGODB_URI"); uri == "" {
		log.Fatal("You must set your 'MONGODB_URI' environment variable. See\n\t https://www.mongodb.com/docs/drivers/go/current/connect/mongoclient/#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_restaurants").Collection("restaurants")

	id, _ := bson.ObjectIDFromHex("5eb3d668b31de5d588f4292b")
	filter := bson.D{{"_id", id}}

	// Creates instructions to add the "avg_rating" field to documents
	update := bson.D{{"$set", bson.D{{"avg_rating", 4.4}}}}

	// Updates the first document that has the specified "_id" value
	result, err := coll.UpdateOne(context.TODO(), filter, update)
	if err != nil {
		panic(err)
	}

	// Prints the number of updated documents
	fmt.Printf("Documents updated: %v\n", result.ModifiedCount)

	// When you run this file for the first time, it should print output similar to the following:
	// Documents updated: 1
}
```

```none
Documents updated: 1
```

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

### RunCommand explain operation

Source: https://www.mongodb.com/docs/drivers/go/current/run-command

This example demonstrates using RunCommand to execute an explain command on a count operation within the flowers collection.

```go
db := client.Database("db")

// Creates commands to count documents in a collection and explain
// how the count command runs
countCommand := bson.D{{"count", "flowers"}}
explainCommand := bson.D{{"explain", countCommand}, {"verbosity", "queryPlanner"}}

// Retrieves results of the explain command
var result bson.M
err = db.RunCommand(context.TODO(), explainCommand).Decode(&result)
```

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

### Configure Read Concern Majority

Source: https://www.mongodb.com/docs/drivers/go/current/crud/configure

This example demonstrates how to create a majority read concern and apply it to a collection instance.

```go
rc := readconcern.Majority()
opts := options.Collection().SetReadConcern(rc)
database := client.Database("db")
coll := database.Collection("myCollection", opts)
```

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

### Replica Set Connection String

Source: https://www.mongodb.com/docs/drivers/go/current/connect/connection-targets

Example connection string for a replica set deployment with three hosts and a specified replica set name.

```none
mongodb://host1:27017,host2:27017,host3:27017/?replicaSet=myRS
```

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

### Initialize Project Directory

Source: https://www.mongodb.com/docs/drivers/go/current/crud/tutorial-web-application

Create a new directory for the project and navigate into it.

```bash
mkdir mflix
cd mflix
```

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

### Example JSON Response for Get Movie by ID

Source: https://www.mongodb.com/docs/drivers/go/current/crud/tutorial-web-application

A sample JSON response returned when querying a specific movie by its _id field.

```json
{
   "_id": "573a1390f29313caabcd42e8",
   "awards": {
      "wins": 1,
      "nominations": 0,
      "text": "1 win."
   },
   "cast": [
      "A.C. Abadie",
      "Gilbert M. 'Broncho Billy' Anderson",
      "George Barnes",
      "Justus D. Barnes"
   ],
   "countries": [
      "USA"
   ],
   "directors": [
      "Edwin S. Porter"
   ],
   "fullplot": "Among the earliest existing films in American cinema - notable as the first film that presented a narrative story to tell - it depicts a group of cowboy outlaws who hold up a train and rob the passengers. They are then pursued by a Sheriff's posse. Several scenes have color included - all hand tinted.",
   "genres": [
      "Short",
      "Western"
   ],"
   ....
}
```

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

### Initialize a Go project

Source: https://www.mongodb.com/docs/drivers/go/current/get-started

Create a new directory and initialize a Go module for your project.

```shell
mkdir go-quickstart
cd go-quickstart
go mod init go-quickstart
```

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

### Install GJSON Dependency

Source: https://www.mongodb.com/docs/drivers/go/current/integrations/vector-search-bedrock

Command to install the GJSON library for parsing JSON responses.

```sh
go get github.com/tidwall/gjson
```

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

### Initialize AWS Configuration and App

Source: https://www.mongodb.com/docs/drivers/go/current/integrations/vector-search-bedrock

Methods to connect to AWS and initialize the App struct with a Bedrock client.

```go
func connectToAWS(ctx context.Context) (*aws.Config, error) {
        const dfltRegion string = "us-east-1"
        const credAccount string = "your-account-name"
        cfg, err := config.LoadDefaultConfig(ctx,
                config.WithSharedConfigProfile(credAccount),
                config.WithRegion(dfltRegion),
        )
        return &cfg, err
}

func NewApp(ctx context.Context) (*App, error) {
        cfg, err := connectToAWS(ctx)
        if err != nil {
                log.Println("ERR: Couldn't load default configuration. Have you set up your AWS account?", err)
                return nil, err
        }

        bedrockClient := bedrockruntime.NewFromConfig(*cfg)

        return &App{
                config:  cfg,
                bedrock: bedrockClient,
        }, nil
}
```

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

### Install Image Editing Module

Source: https://www.mongodb.com/docs/drivers/go/current/integrations/vector-search-bedrock

Command to install the required image drawing library.

```sh
go get golang.org/x/image/draw
```

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

### Create a MongoDB Client and Verify Connection

Source: https://www.mongodb.com/docs/drivers/go/current/connect/mongoclient

This example demonstrates how to initialize a client with an Atlas connection string, configure the Stable API version, and perform a ping to verify the connection.

```go
// Connects to MongoDB and sets a Stable API version
package main

import (
	"context"
	"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() {
	var uri string
	if uri = os.Getenv("MONGODB_URI"); uri == "" {
		log.Fatal("You must set your 'MONGODB_URI' environment variable. See\n\t https://docs.mongodb.com/drivers/go/current/usage-examples/")
	}

	// Uses the SetServerAPIOptions() method to set the Stable API version to 1
	serverAPI := options.ServerAPI(options.ServerAPIVersion1)

	// Defines the options for the MongoDB client
	opts := options.Client().ApplyURI(uri).SetServerAPIOptions(serverAPI)

	// Creates a new client and connects to the server
	client, err := mongo.Connect(opts)

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

	// Sends a ping to confirm a successful connection
	var result bson.M
	if err := client.Database("admin").RunCommand(context.TODO(), bson.D{{"ping", 1}}).Decode(&result); err != nil {
		panic(err)
	}
	fmt.Println("Pinged your deployment. You successfully connected to MongoDB!")
}
```

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

### Initialize Go Project

Source: https://www.mongodb.com/docs/drivers/go/current/connect/go-lambda

Commands to create a new project directory and initialize Go Modules for AWS Lambda and MongoDB dependencies.

```bash
mkdir lambdaexample
cd lambdaexample
go mod init lambdaexample
```

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

### Create main.go file

Source: https://www.mongodb.com/docs/drivers/go/current/get-started

Create the project file using the touch command in your terminal.

```shell
touch main.go
```

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

### Create main.go Application

Source: https://www.mongodb.com/docs/drivers/go/current/crud/tutorial-web-application

Create a basic Gin application in main.go.

```go
package main

import (
	"log"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()
	r.GET("/", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "Hello World",
		})
	})

	if err := r.Run(); err != nil {
		log.Fatal("Failed to start server:", err)
	}
}
```

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

### Complete Go Web Application with MongoDB

Source: https://www.mongodb.com/docs/drivers/go/current/crud/tutorial-web-application

This file demonstrates the full setup including MongoDB connection, Gin server initialization, and endpoint handlers for retrieving and aggregating movie data. Replace the 'uri' constant with your actual MongoDB connection string.

```go
package main

import (
	"context"
	"log"
	"net/http"

	"github.com/gin-gonic/gin"
	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)

// Replace with your MongoDB connection string
const uri = "YOUR-CONNECTION-STRING-HERE"

func main() {
	// Connects to MongoDB
	serverAPI := options.ServerAPI(options.ServerAPIVersion1)
	opts := options.Client().ApplyURI(uri).SetServerAPIOptions(serverAPI)

	client, err := mongo.Connect(opts)
	if err != nil {
		log.Fatal("Could not connect to MongoDB:", err)
	}

	// Ensures the client disconnects when main exits
	defer func() {
		if err := client.Disconnect(context.TODO()); err != nil {
			log.Fatal("Error disconnecting from MongoDB:", err)
		}
	}()

	// Pings the database to verify connection
	if err := client.Ping(context.TODO(), nil); err != nil {
		log.Fatal("Could not ping MongoDB:", err)
	}

	r := gin.Default()

	r.GET("/", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "Hello World",
		})
	})

	// Registers movie endpoints
	r.GET("/movies", func(c *gin.Context) {
		getMovies(c, client)
	})
	r.GET("/movies/:id", func(c *gin.Context) {
		getMovieByID(c, client)
	})
	r.POST("/movies/aggregations", func(c *gin.Context) {
		aggregateMovies(c, client)
	})

	if err := r.Run(); err != nil {
		log.Fatal("Failed to start server:", err)
	}
}

// GET /movies - Retrieves all movies
func getMovies(c *gin.Context, client *mongo.Client) {
	// Find all movies in the collection
	cursor, err := client.Database("sample_mflix").Collection("movies").Find(c.Request.Context(), bson.D{})
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	defer cursor.Close(c.Request.Context())

	// Decodes all results
	var movies []bson.D
	if err = cursor.All(c.Request.Context(), &movies); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	// Returns the movies
	c.JSON(http.StatusOK, movies)
}

// GET /movies/:id - Retrieves a movie by ID
func getMovieByID(c *gin.Context, client *mongo.Client) {
	// Gets the movie ID from the URL parameter as a string
	idStr := c.Param("id")

	// Converts string ID to MongoDB ObjectID
	id, err := bson.ObjectIDFromHex(idStr)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid movie ID format"})
		return
	}

	// Finds the movie by ObjectID
	var movie bson.D
	err = client.Database("sample_mflix").Collection("movies").FindOne(c.Request.Context(), bson.D{{"_id", id}}).Decode(&movie)
	if err != nil {
		if err == mongo.ErrNoDocuments {
			c.JSON(http.StatusNotFound, gin.H{"error": "Movie not found"})
			return
		}
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	// Returns the movie
	c.JSON(http.StatusOK, movie)
}

// POST /movies/aggregations - Runs aggregation pipeline
func aggregateMovies(c *gin.Context, client *mongo.Client) {
	// Gets aggregation pipeline from request body
	var pipeline interface{}
	if err := c.ShouldBindJSON(&pipeline); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid aggregation pipeline"})
		return
	}

	// Executes the aggregation pipeline
	cursor, err := client.Database("sample_mflix").Collection("movies").Aggregate(c.Request.Context(), pipeline)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	defer cursor.Close(c.Request.Context())

	// Decodes the results
	var result []bson.D
	if err = cursor.All(c.Request.Context(), &result); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	// Returns the aggregation result
	c.JSON(http.StatusOK, result)
}
```

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

### Load sample data into collections

Source: https://www.mongodb.com/docs/drivers/go/current/crud/bulk

Initializes collection references and inserts sample documents into the books and poems collections.

```go
bookColl := client.Database("db").Collection("books")
poemColl := client.Database("db").Collection("poems")

books := []any{
	Book{Title: "My Brilliant Friend", Author: "Elena Ferrante", Length: 331},
	Book{Title: "Lucy", Author: "Jamaica Kincaid", Length: 103},
}

poems := []any{
	Poem{Title: "Song of Myself", Author: "Walt Whitman", Year: 1855},
	Poem{Title: "The Raincoat", Author: "Ada Limon", Year: 2018},
}

bookInsert, err := bookColl.InsertMany(context.TODO(), books)
poemInsert, err := poemColl.InsertMany(context.TODO(), poems)
```

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

### Run Application

Source: https://www.mongodb.com/docs/drivers/go/current/crud/tutorial-web-application

Execute the application to verify it is working.

```bash
go run main.go
```

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

### Extended JSON Canonical Format Example

Source: https://www.mongodb.com/docs/drivers/go/current/data-formats/extended-json

This example demonstrates the Canonical format, which preserves all BSON type information for fields like ObjectId, date, and long numbers.

```json
{
  "_id": { "$oid": "573a1391f29313caabcd9637" },
  "createdAt": { "$date": { "$numberLong": "1601499609" }},
  "numViews": { "$numberLong": "36520312" }
}
```

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

### Load sample data

Source: https://www.mongodb.com/docs/drivers/go/current/crud/update/upsert

Use this snippet to populate the db.plants collection with initial sample data.

```go
coll := client.Database("db").Collection("plants")
docs := []any{
	Plant{Species: "Polyscias fruticosa", PlantID: 1, Height: 27.6},
	Plant{Species: "Polyscias fruticosa", PlantID: 2, Height: 34.9},
	Plant{Species: "Ledebouria socialis", PlantID: 1, Height: 11.4},
}

result, err := coll.InsertMany(context.TODO(), docs)
```

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

### Output of $and query

Source: https://www.mongodb.com/docs/drivers/go/current/crud/query/query-document

The resulting documents from the $and query example.

```none
{"type":"Masala","rating":10,"vendor":["A","C"]}
{"type":"Earl Grey","rating":8,"vendor":["A","B"]}
```

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

### WithTransaction()

Source: https://www.mongodb.com/docs/drivers/go/current/crud/transactions

Starts a transaction and executes a callback function.

```APIDOC
## WithTransaction()

### Description
Starts a transaction on this session and runs the provided callback function.

### Parameters
- **Context** - Required - The context for the operation.
- **fn** (func(ctx SessionContext)) - Required - The callback function to execute within the transaction.
- **TransactionOptions** - Optional - Configuration options for the transaction.

### Returns
- **any, error** - Returns the result of the callback and any error encountered.
```

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

### Insert Sample Data

Source: https://www.mongodb.com/docs/drivers/go/current/crud/query/distinct

Load sample course data into the db.courses collection.

```go
coll := client.Database("db").Collection("courses")
docs := []any{
	Course{Title: "World Fiction", Department: "English", Enrollment: 35},
	Course{Title: "Abstract Algebra", Department: "Mathematics", Enrollment: 60},
	Course{Title: "Modern Poetry", Department: "English", Enrollment: 12},
	Course{Title: "Plate Tectonics", Department: "Geology", Enrollment: 30},
}

result, err := coll.InsertMany(context.TODO(), docs)
```

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

### Configure TLS with tls.Config in Go

Source: https://www.mongodb.com/docs/drivers/go/current/security/tls

This example demonstrates creating a CA certificate pool, loading a client key pair, and applying the resulting tls.Config to the MongoDB ClientOptions.

```go
caFile := "<path to CA certificate>"
certFile := "<path to public client certificate>"
keyFile := "<path to private client key>"

// Loads CA certificate file
caCert, err := os.ReadFile(caFile)
if err != nil {
	panic(err)
}
caCertPool := x509.NewCertPool()
if ok := caCertPool.AppendCertsFromPEM(caCert); !ok {
	panic("Error: CA file must be in PEM format")
}

// Loads client certificate files
cert, err := tls.LoadX509KeyPair(certFile, keyFile)
if err != nil {
	panic(err)
}

// Instantiates a Config instance
tlsConfig := &tls.Config{
	RootCAs:      caCertPool,
	Certificates: []tls.Certificate{cert},
}

uri := "<connection string>"

// Sets TLS options in options instance
opts := options.Client().ApplyURI(uri).SetTLSConfig(tlsConfig)
```

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

### ReplaceOne Output

Source: https://www.mongodb.com/docs/drivers/go/current/crud/update/replace

The expected console output after successfully running the ReplaceOne example.

```none
Number of documents replaced: 1
```

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

### Create server.go Application Structure

Source: https://www.mongodb.com/docs/drivers/go/current/integrations/vector-search-bedrock

Define the basic application structure in server.go.

```go
package main

import (
        "context"
        "log"
        "net/http"
        "os"

        "github.com/joho/godotenv"
)

type App struct {
}

func (app App) Start() error {
        const serverAddr string = "0.0.0.0:3001"
        log.Printf("Starting HTTP server: %s\n", serverAddr)
        return http.ListenAndServe(serverAddr, nil)
}

func main() {
        app := App{}
        log.Println(app.Start())
}
```

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

### DeleteMany() Output

Source: https://www.mongodb.com/docs/drivers/go/current/crud/delete

The expected console output after successfully running the DeleteMany example.

```none
Documents deleted: 6
```

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

### Add imageSearch Endpoint

Source: https://www.mongodb.com/docs/drivers/go/current/integrations/vector-search-bedrock

Add the imageSearch handler and register it in the Start method.

```go
 func (app App) imageSearch(w http.ResponseWriter, r *http.Request) {
        log.Println("Image search invoked")
}

func (app App) Start() error {
        const serverAddr string = "0.0.0.0:3001"
        http.HandleFunc("POST /api/search", app.imageSearch)
        log.Printf("Starting HTTP server: %s\n", serverAddr)
        return http.ListenAndServe(serverAddr, nil)
}
```

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

### Create a GridFS Bucket

Source: https://www.mongodb.com/docs/drivers/go/current/crud/gridfs

Instantiate a GridFSBucket by calling the GridFSBucket() method on a Database instance.

```go
db := client.Database("myDB")
bucket := db.GridFSBucket()
```

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

### Install logrus packages

Source: https://www.mongodb.com/docs/drivers/go/current/monitoring-and-logging/logging

Run these commands in your terminal to download the necessary logrus packages.

```bash
go get github.com/bombsimon/logrusr/v4
go get github.com/sirupsen/logrus
```

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

### UpdateMany() Expected Output

Source: https://www.mongodb.com/docs/drivers/go/current/crud/update

The console output displayed after successfully running the UpdateMany() example.

```none
Documents updated: 296
```

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

### ReplaceOne Method Usage

Source: https://www.mongodb.com/docs/drivers/go/current/crud/update/replace

Example of using ReplaceOne to substitute a document with new fields.

```go
filter := bson.D{{"_id", 2056}}
replacement := bson.D{{"item", "Cup"}, {"quantity", 107}}

result, err := collection.ReplaceOne(context.TODO(), filter, replacement)
fmt.Printf("Documents matched: %v\n", result.MatchedCount)
fmt.Printf("Documents replaced: %v\n", result.ModifiedCount)
```

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

### Initialize credential cache with kinit

Source: https://www.mongodb.com/docs/drivers/go/current/security/authentication/kerberos

Use the kinit binary to initialize a credential cache for the Kerberos principal.

```sh
kinit myuser@KERBEROS.EXAMPLE.COM
```

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

### Configure Compressors via Connection String

Source: https://www.mongodb.com/docs/drivers/go/current/connect/specify-connection-options

Sets the compressors option to prioritize zlib followed by snappy for wire-protocol messages.

```go
const uri = "mongodb://localhost:27017/?compressors=zlib,snappy"
client, _ := mongo.Connect(options.Client().ApplyURI(uri))
```

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

### Search by a Phrase

Source: https://www.mongodb.com/docs/drivers/go/current/crud/query/text

Example of searching for the phrase 'serves 2' using escaped quotes.

```go
filter := bson.D{{"$text", bson.D{{"$search", "\"serves 2\""}}}}

cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}

var results []Dish
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}

for _, result := range results {
    res, _ := bson.MarshalExtJSON(result, false, false)
    fmt.Println(string(res))
}
```

```none
{"name":"Shepherd's Pie","description":"A vegetarian take on the classic dish that uses lentils as a base. Serves 2."}
{"name":"Garlic Butter Trout","description":"Baked trout seasoned with garlic, lemon, dill, and, of course, butter. Serves 2."}
```

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

### Configure Ordered Bulk Write

Source: https://www.mongodb.com/docs/drivers/go/current/crud/bulk

Demonstrates setting the ordered option to true, which is the default behavior for bulk write operations.

```go
opts := options.BulkWrite().SetOrdered(true)
```

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

### Count Documents Output

Source: https://www.mongodb.com/docs/drivers/go/current/crud/query/count

The expected console output after running the document counting example.

```none
Estimated number of documents in the restaurants collection: 25359
Number of restaurants with American cuisine: 6183
```

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

### Initialize Go Module

Source: https://www.mongodb.com/docs/drivers/go/current/crud/tutorial-web-application

Initialize a new Go module to manage project dependencies.

```bash
go mod init mflix
```

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

### Custom Logger Output

Source: https://www.mongodb.com/docs/drivers/go/current/monitoring-and-logging/logging

Example console output generated by the custom logger during an insert operation.

```console
level: 1 DEBUG, message: Connection pool created
level: 1 DEBUG, message: Connection pool ready
level: 1 DEBUG, message: Connection pool created
level: 1 DEBUG, message: Connection pool ready
level: 1 DEBUG, message: Connection pool created
level: 1 DEBUG, message: Connection pool ready
level: 1 DEBUG, message: Connection checkout started
level: 1 DEBUG, message: Connection created
level: 1 DEBUG, message: Connection ready
level: 1 DEBUG, message: Connection checked out
level: 1 DEBUG, message: Command started
level: 1 DEBUG, message: Command succeeded
level: 1 DEBUG, message: Connection checked in
```

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

### Clone and prepare the MongoDB Go driver repository

Source: https://www.mongodb.com/docs/drivers/go/current/issues-and-help

Commands to clone the repository, navigate to the directory, and create a new feature branch for development.

```bash
$ git clone https://github.com/mongodb/mongo-go-driver.git
$ cd mongo-go-driver
$ git checkout -b myNewFeature
```

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

### Aggregation Pipeline JSON

Source: https://www.mongodb.com/docs/drivers/go/current/crud/tutorial-web-application

An example aggregation pipeline used to count comedy movies by year.

```json
[
    {"$match": {"genres": "Comedy"}},
    {"$group": {
        "_id": "$year",
        "count": {"$sum": 1}
    }},
    {"$sort": {"count": -1}}
]
```

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

### ConnectionCheckOutStarted Event Output

Source: https://www.mongodb.com/docs/drivers/go/current/monitoring-and-logging/monitoring

Sample output for the ConnectionCheckOutStarted event.

```none
*event.PoolEvent
{
    "type": "ConnectionCheckOutStarted",
    "address": "...",
    "connectionId": 0,
    "options": null,
    "reason": "",
    "serviceId": null,
    "error": null
}
```

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

### Define MONGODB_URI in .env File

Source: https://www.mongodb.com/docs/drivers/go/current/connect/mongoclient

Example configuration for a .env file to store the MongoDB connection string.

```text
MONGODB_URI=mongodb+srv://<db_username>:<db_password>@<cluster-url>?retryWrites=true&w=majority
```
Tokens:
Raw