Insira documentos

Visão geral

Neste guia, você pode aprender como inserir documentos em uma coleção MongoDB.

Antes de localizar, atualizar e excluir documentos no MongoDB, você deve inserir esses documentos. Você pode inserir um documento usando o método InsertOne() ou inserir vários documentos usando o método InsertMany() ou BulkWrite().

As seções a seguir concentram-se em InsertOne() e InsertMany(). Para saber como usar o método BulkWrite(), consulte o guia de operações em massa.

O campo _id

No MongoDB, cada documento deve conter um campo _id exclusivo.

As duas opções para gerenciar este campo são:

Gerenciando você mesmo esse campo, garantindo que cada valor usado seja único.
Permitir que o driver gere automaticamente valores ObjectId exclusivos. O driver gera valores ObjectId exclusivos para documentos que você não especifica explicitamente como _id.

A menos que você ofereça garantias rubustas de exclusividade, o MongoDB recomenda que você deixe o driver gerar automaticamente os valores de _id.

Observação

Os valores duplicados de _id violam restrições de índice único, o que faz com que o driver retorne um WriteError.

Para saber mais sobre o campo _id, consulte a Entrada manual do servidor sobre Índices únicos.

Para saber mais sobre a estrutura e as regras dos documentos, consulte a Entrada do Manual do Servidor sobre Documentos.

Insira um documento

Use o método InsertOne() para inserir um único documento em uma coleção.

Após a inserção bem-sucedida, o método retorna uma instância InsertOneResult que contém o _id do novo documento.

Exemplo

Este exemplo utiliza a seguinte estrutura Book como um modelo para documentos na collection books:

type Book struct {	Title  string	Author string}

O exemplo seguinte cria e insere um documento na coleção books utilizando o método InsertOne():

coll := client.Database("db").Collection("books")doc := Book{Title: "Atonement", Author: "Ian McEwan"}
result, err := coll.InsertOne(context.TODO(), doc)
fmt.Printf("Inserted document with _id: %v\n", result.InsertedID)

Modificar o comportamento InsertOne()

Você pode modificar o comportamento de InsertOne() construindo e passando uma estrutura InsertOneOptions opcional. As opções disponíveis para configurar com InsertOneOptions são:

Opção	Descrição
`BypassDocumentValidation`	Se `true`, permite que a gravação desative a validação em nível de documento. Padrão: `false`

Crie InsertOneOptions da seguinte forma:

opts := options.InsertOne().SetBypassDocumentValidation(true)

Inserir um Exemplo de Documento: Arquivo Completo

Observação

Exemplo de configuração

Esse exemplo se conecta a uma instância do MongoDB usando um URI de conexão. Para saber mais sobre como se conectar à sua instância do MongoDB, consulte Criar um MongoClient. Este exemplo também usa a coleção restaurants no banco de dados sample_restaurants incluído nos conjuntos de dados de amostra do Atlas. Você pode carregá-los em seu banco de dados em um cluster gratuito no MongoDB Atlas seguindo as etapas em Introdução ao Atlas.

O exemplo a seguir insere um novo documento na collection restaurants. Selecione a aba Struct ou bson.D para ver o código correspondente:

O código a seguir usa uma estrutura para inserir um novo documento na coleção restaurants:

// Inserts a single document describing a restaurant by using the Go driverpackage 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 documenttype 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/pt-br/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("...")
}

O código a seguir usa um tipo bson.D para inserir um novo documento na coleção restaurants:

// Inserts a single document describing a restaurant by using the Go driver with bson.Dpackage 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")
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/pt-br/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 using bson.D	coll := client.Database("sample_restaurants").Collection("restaurants")	newRestaurant := bson.D{		bson.E{Key: "name", Value: "8282"},		bson.E{Key: "cuisine", Value: "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("...")}

Insira vários documentos

Use o método InsertMany() para inserir vários documentos em uma coleção.

Após a inserção bem-sucedida, o método InsertMany() retorna uma instância InsertManyResult que contém os campos _id dos documentos inseridos.

Exemplo

O exemplo seguinte cria e insere vários documentos na coleção books utilizando o método InsertMany():

coll := client.Database("myDB").Collection("favorite_books")docs := []any{    Book{Title: "Cat's Cradle", Author: "Kurt Vonnegut Jr."},    Book{Title: "In Memory of Memory", Author: "Maria Stepanova"},    Book{Title: "Pride and Prejudice", Author: "Jane Austen"},}
result, err := coll.InsertMany(context.TODO(), docs)fmt.Printf("Documents inserted: %v\n", len(result.InsertedIDs))
for _, id := range result.InsertedIDs {    fmt.Printf("Inserted document with _id: %v\n", id)}

Depois de executar o código anterior, seu resultado será semelhante ao seguinte:

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

Modificar o comportamento InsertMany()

Você pode modificar o comportamento de InsertMany() construindo e passando uma estrutura InsertManyOptions opcional. As opções disponíveis para configurar com InsertManyOptions são:

Opção	Descrição
`BypassDocumentValidation`	Se `true`, permite que a gravação desative a validação em nível de documento. Padrão: `false`
`Ordered`	Se `true`, o driver envia documentos para o servidor na ordem fornecida. Se ocorrer um erro, o driver e o servidor encerram todas as operações de inserção restantes. Para aprender mais, consulte Comportamento ordenado. Padrão: `false`

Crie InsertManyOptions da seguinte forma:

opts := options.InsertMany().SetBypassDocumentValidation(true).SetOrdered(false)

Comportamento ordenado

Suponha que você queira inserir os seguintes documentos:

{ "_id": 1, "title": "Where the Wild Things Are" }{ "_id": 2, "title": "The Very Hungry Caterpillar" }{ "_id": 1, "title": "Blueberries for Sal" }{ "_id": 3, "title": "Goodnight Moon" }

Se você tentar inserir esses documentos com InsertManyOptions padrão, ocorrerá uma BulkWriteException no terceiro documento devido ao valor de _id repetido, mas os documentos antes do documento de produção de erro ainda serão inseridos em sua coleção.

Observação

Você pode obter um reconhecimento da inserção bem-sucedida do documento, mesmo que ocorra uma BulkWriteException:

type Book struct {    ID    int `bson:"_id"`    Title string}
...
docs := []any{    Book{ID: 1, Title: "Where the Wild Things Are"},    Book{ID: 2, Title: "The Very Hungry Caterpillar"},    Book{ID: 1, Title: "Blueberries for Sal"},    Book{ID: 3, Title: "Goodnight Moon"},}
result, err := coll.InsertMany(context.TODO(), docs)if err != nil {    fmt.Printf("A bulk write error occurred, but %v documents were still inserted.\n", len(result.InsertedIDs))}
for _, id := range result.InsertedIDs {    fmt.Printf("Inserted document with _id: %v\n", id)}

A bulk write error occurred, but 2 documents were still inserted.Inserted document with _id: 1Inserted document with _id: 2

Depois de executar o código anterior, sua coleção contém os seguintes documentos:

{ "_id": 1, "title": "Where the Wild Things Are" }{ "_id": 2, "title": "The Very Hungry Caterpillar" }

Inserir muitos exemplo: arquivo completo

Observação

Exemplo de configuração

O exemplo a seguir insere vários novos documentos na collection restaurants. Selecione a aba Struct ou bson.D para ver o código correspondente:

O seguinte código utiliza uma estrutura para inserir vários novos documentos na coleção restaurants:

// Inserts sample documents describing restaurants by using the Go driverpackage 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 documenttype 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/pt-br/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 two sample documents describing restaurants	newRestaurants := []any{		Restaurant{Name: "Rule of Thirds", Cuisine: "Japanese"},		Restaurant{Name: "Madame Vo", Cuisine: "Vietnamese"},	}
	// Inserts sample documents into the collection	result, err := coll.InsertMany(context.TODO(), newRestaurants)	if err != nil {		panic(err)	}
	// Prints the IDs of the inserted documents	fmt.Printf("%d documents inserted with IDs:\n", len(result.InsertedIDs))	for _, id := range result.InsertedIDs {		fmt.Printf("\t%s\n", id)	}
	// When you run this file for the first time, it should print output similar	// to the following:	// 2 documents inserted with IDs:	// ObjectID("...")	// ObjectID("...")}

2 documents inserted with IDs:        ObjectID("...")        ObjectID("...")

O código a seguir usa um tipo bson.D para inserir vários novos documentos na coleção restaurants:

// Inserts sample documents describing restaurants by using the Go driver with bson.Dpackage 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")
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/pt-br/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 two sample documents describing restaurants using bson.D	newRestaurants := []interface{}{		bson.D{			bson.E{Key: "name", Value: "Rule of Thirds"},			bson.E{Key: "cuisine", Value: "Japanese"},		},		bson.D{			bson.E{Key: "name", Value: "Madame Vo"},			bson.E{Key: "cuisine", Value: "Vietnamese"},		},	}
	// Inserts sample documents into the collection	result, err := coll.InsertMany(context.TODO(), newRestaurants)	if err != nil {		panic(err)	}
	// Prints the IDs of the inserted documents	fmt.Printf("%d documents inserted with IDs:\n", len(result.InsertedIDs))	for _, id := range result.InsertedIDs {		fmt.Printf("\t%s\n", id)	}
	// When you run this file for the first time, it should print output similar	// to the following:	// 2 documents inserted with IDs:	// ObjectID("...")	// ObjectID("...")}

2 documents inserted with IDs:        ObjectID("...")        ObjectID("...")

Informações adicionais

Para saber mais sobre como executar as operações mencionadas, consulte os seguintes guias:

Documentação da API

Para saber mais sobre qualquer um dos métodos ou tipos discutidos neste guia, consulte a seguinte documentação da API:

Voltar

reconhecimento de data center e collection

Especificar uma query