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 em Í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)

Inserted document with _id: ObjectID("...")

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`	If `true`, allows the write to opt-out of document level validation. Default: `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 o guia Como criar um MongoClient. Este exemplo também utiliza a coleção do restaurants no banco de dados do sample_restaurants incluído nos conjuntos de dados de amostra do Atlas. Você pode carregá-los em seu banco de dados na camada grátis do MongoDB Atlas seguindo o Guia de 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 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      interface{}   `bson:"address,omitempty"`
	Borough      string        `bson:"borough,omitempty"`
	Grades       []interface{} `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("...")
}

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.D
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"
)
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("...")
}

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 := []interface{}{
    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: 3
Inserted 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`	If `true`, allows the write to opt-out of document level validation. Default: `false`
`Ordered`	If `true`, the driver sends documents to the server in the order provided. If an error occurs, the driver and server end all remaining insert operations. To learn more, see Ordered Behavior. Default: `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 := []interface{}{
    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: 1
Inserted 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 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      interface{}   `bson:"address,omitempty"`
	Borough      string        `bson:"borough,omitempty"`
	Grades       []interface{} `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 := []interface{}{
		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.D
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"
)
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

Operações CRUD

Consultar documentos