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)

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`	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 aprender mais sobre como se conectar à sua instância do MongoDB, consulte 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 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 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/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 := []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: 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`	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 encerrarão todas as operações de inserção restantes. Para saber 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: 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      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.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

reconhecimento de data center e collection

Especificar uma query