Menu Docs

Página inicial do Docs

/

Manual do MongoDB

/

Operações CRUD

Atualize documentos

Nesta página

Atualizar documentos em uma coleção

Atualizar um documento com MongoDB Atlas
Comportamento

Você pode atualizar documentos no MongoDB com os seguintes métodos:

O driver da sua linguagem de programação.
A UI do MongoDB Atlas. Para saber mais, consulte Atualizar um documento com o MongoDB Atlas.
MongoDB Compass.

➤ Use o menu suspenso Selecione a linguagem no canto superior direito para definir a linguagem dos exemplos a seguir.

Esta página usa os seguintes métodos mongosh :

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa o MongoDB Compass para atualizar os documentos.

Os exemplos nesta página utilizam a collection inventory . Preencha a coleção inventory com os seguintes documentos:

Esta página usa o seguinte MongoDB C Driver métodos:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa os seguintes métodos do driver MongoDB C# :

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página utiliza as seguintes funções do driver MongoDB Go :

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa o seguinte driver Java Reactive Streams métodos:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página utiliza os seguintes métodos Java Synchronous Driver:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa os seguintes métodos do driver Kotlin Coroutine :

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa a seguinte Motor métodos do driver:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa o seguinte driver MongoDB Node.js métodos:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa o seguinte driver MongoDB Perl métodos:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa os seguintes métodos da biblioteca PHP do MongoDB :

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa o seguinte PyMongo Métodos do driver Python:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página utiliza os seguintes métodos do driver Ruby do MongoDB :

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa o seguinte driver MongoDB Scala métodos:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

db.inventory.insertMany( [
   { item: "canvas", qty: 100, size: { h: 28, w: 35.5, uom: "cm" }, status: "A" },
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "mat", qty: 85, size: { h: 27.9, w: 35.5, uom: "cm" }, status: "A" },
   { item: "mousepad", qty: 25, size: { h: 19, w: 22.85, uom: "cm" }, status: "P" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" },
   { item: "sketchbook", qty: 80, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "sketch pad", qty: 95, size: { h: 22.85, w: 30.5, uom: "cm" }, status: "A" }
] );

[
    { "item": "canvas", "qty": 100, "size": { "h": 28, "w": 35.5, "uom": "cm" }, "status": "A" },
    { "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
    { "item": "mat", "qty": 85, "size": { "h": 27.9, "w": 35.5, "uom": "cm" }, "status": "A" },
    { "item": "mousepad", "qty": 25, "size": { "h": 19, "w": 22.85, "uom": "cm" }, "status": "P" },
    { "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "P" },
    { "item": "paper", "qty": 100, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "D" },
    { "item": "planner", "qty": 75, "size": { "h": 22.85, "w": 30, "uom": "cm" }, "status": "D" },
    { "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" },
    { "item": "sketchbook", "qty": 80, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
    { "item": "sketch pad", "qty": 95, "size": { "h": 22.85, "w": 30.5, "uom": "cm" }, "status": "A" }
]

Para obter instruções sobre como inserir documentos usando o MongoDB Compass, consulte Inserir documentos.

mongoc_collection_t *collection;
mongoc_bulk_operation_t *bulk;
bson_t *doc;
bool r;
bson_error_t error;
bson_t reply;
collection = mongoc_database_get_collection (db, "inventory");
bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
doc = BCON_NEW (
   "item", BCON_UTF8 ("canvas"),
   "qty", BCON_INT64 (100),
   "size", "{",
   "h", BCON_DOUBLE (28),
   "w", BCON_DOUBLE (35.5),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("journal"),
   "qty", BCON_INT64 (25),
   "size", "{",
   "h", BCON_DOUBLE (14),
   "w", BCON_DOUBLE (21),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("mat"),
   "qty", BCON_INT64 (85),
   "size", "{",
   "h", BCON_DOUBLE (27.9),
   "w", BCON_DOUBLE (35.5),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("mousepad"),
   "qty", BCON_INT64 (25),
   "size", "{",
   "h", BCON_DOUBLE (19),
   "w", BCON_DOUBLE (22.85),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("P"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("notebook"),
   "qty", BCON_INT64 (50),
   "size", "{",
   "h", BCON_DOUBLE (8.5),
   "w", BCON_DOUBLE (11),
   "uom", BCON_UTF8 ("in"),
   "}",
   "status", BCON_UTF8 ("P"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("paper"),
   "qty", BCON_INT64 (100),
   "size", "{",
   "h", BCON_DOUBLE (8.5),
   "w", BCON_DOUBLE (11),
   "uom", BCON_UTF8 ("in"),
   "}",
   "status", BCON_UTF8 ("D"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("planner"),
   "qty", BCON_INT64 (75),
   "size", "{",
   "h", BCON_DOUBLE (22.85),
   "w", BCON_DOUBLE (30),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("D"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("postcard"),
   "qty", BCON_INT64 (45),
   "size", "{",
   "h", BCON_DOUBLE (10),
   "w", BCON_DOUBLE (15.25),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("sketchbook"),
   "qty", BCON_INT64 (80),
   "size", "{",
   "h", BCON_DOUBLE (14),
   "w", BCON_DOUBLE (21),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("sketch pad"),
   "qty", BCON_INT64 (95),
   "size", "{",
   "h", BCON_DOUBLE (22.85),
   "w", BCON_DOUBLE (30.5),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
/* "reply" is initialized on success or error */
r = (bool) mongoc_bulk_operation_execute (bulk, &reply, &error);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
}

var documents = new[]
{
    new BsonDocument
    {
        { "item", "canvas" },
        { "qty", 100 },
        { "size", new BsonDocument { { "h", 28 }, { "w", 35.5 }, { "uom", "cm" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "journal" },
        { "qty", 25 },
        { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "mat" },
        { "qty", 85 },
        { "size", new BsonDocument { { "h", 27.9 }, { "w", 35.5 }, { "uom", "cm" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "mousepad" },
        { "qty", 25 },
        { "size", new BsonDocument { { "h", 19 }, { "w", 22.85 }, { "uom", "cm" } } },
        { "status", "P" }
    },
    new BsonDocument
    {
        { "item", "notebook" },
        { "qty", 50 },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "status", "P" } },
    new BsonDocument
    {
        { "item", "paper" },
        { "qty", 100 },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "planner" },
        { "qty", 75 },
        { "size", new BsonDocument { { "h", 22.85 }, { "w", 30 }, { "uom", "cm" } } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "postcard" },
        { "qty", 45 },
        { "size", new BsonDocument { { "h", 10 }, { "w", 15.25 }, { "uom", "cm" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "sketchbook" },
        { "qty", 80 },
        { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "sketch pad" },
        { "qty", 95 },
        { "size", new BsonDocument { { "h", 22.85 }, { "w", 30.5 }, { "uom", "cm" } } }, { "status", "A" } },
};
collection.InsertMany(documents);

docs := []interface{}{
	bson.D{
		{"item", "canvas"},
		{"qty", 100},
		{"size", bson.D{
			{"h", 28},
			{"w", 35.5},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "journal"},
		{"qty", 25},
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "mat"},
		{"qty", 85},
		{"size", bson.D{
			{"h", 27.9},
			{"w", 35.5},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "mousepad"},
		{"qty", 25},
		{"size", bson.D{
			{"h", 19},
			{"w", 22.85},
			{"uom", "in"},
		}},
		{"status", "P"},
	},
	bson.D{
		{"item", "notebook"},
		{"qty", 50},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "P"},
	},
	bson.D{
		{"item", "paper"},
		{"qty", 100},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "planner"},
		{"qty", 75},
		{"size", bson.D{
			{"h", 22.85},
			{"w", 30},
			{"uom", "cm"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "postcard"},
		{"qty", 45},
		{"size", bson.D{
			{"h", 10},
			{"w", 15.25},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "sketchbook"},
		{"qty", 80},
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "sketch pad"},
		{"qty", 95},
		{"size", bson.D{
			{"h", 22.85},
			{"w", 30.5},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)

Publisher<Success> insertManyPublisher = collection.insertMany(asList(
        Document.parse("{ item: 'canvas', qty: 100, size: { h: 28, w: 35.5, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'mat', qty: 85, size: { h: 27.9, w: 35.5, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'mousepad', qty: 25, size: { h: 19, w: 22.85, uom: 'cm' }, status: 'P' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'P' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'sketchbook', qty: 80, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'sketch pad', qty: 95, size: { h: 22.85, w: 30.5, uom: 'cm' }, status: 'A' }")
));

collection.insertMany(asList(
        Document.parse("{ item: 'canvas', qty: 100, size: { h: 28, w: 35.5, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'mat', qty: 85, size: { h: 27.9, w: 35.5, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'mousepad', qty: 25, size: { h: 19, w: 22.85, uom: 'cm' }, status: 'P' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'P' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'sketchbook', qty: 80, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'sketch pad', qty: 95, size: { h: 22.85, w: 30.5, uom: 'cm' }, status: 'A' }")
));

collection.insertMany(
    listOf(
        Document("item", "canvas")
            .append("qty", 100)
            .append("size", Document("h", 28).append("w", 35.5).append("uom", "cm"))
            .append("status", "A"),
        Document("item", "journal")
            .append("qty", 25)
            .append("size", Document("h", 14).append("w", 21).append("uom", "cm"))
            .append("status", "A"),
        Document("item", "mat")
            .append("qty", 85)
            .append("size", Document("h", 27.9).append("w", 35.5).append("uom", "cm"))
            .append("status", "A"),
        Document("item", "mousepad")
            .append("qty", 25)
            .append("size", Document("h", 19).append("w", 22.85).append("uom", "cm"))
            .append("status", "P"),
        Document("item", "notebook")
            .append("qty", 50)
            .append("size", Document("h", 8.5).append("w", 11).append("uom", "in"))
            .append("status", "P"),
        Document("item", "paper")
            .append("qty", 100)
            .append("size", Document("h", 8.5).append("w", 11).append("uom", "in"))
            .append("status", "D"),
        Document("item", "planner")
            .append("qty", 75)
            .append("size", Document("h", 22.85).append("w", 30).append("uom", "cm"))
            .append("status", "D"),
        Document("item", "postcard")
            .append("qty", 45)
            .append("size", Document("h", 10).append("w", 15.25).append("uom", "cm"))
            .append("status", "A"),
        Document("item", "sketchbook")
            .append("qty", 80)
            .append("size", Document("h", 14).append("w", 21).append("uom", "cm"))
            .append("status", "A"),
        Document("item", "sketch pad")
            .append("qty", 95)
            .append("size", Document("h", 22.85).append("w", 30.5).append("uom", "cm"))
            .append("status", "A"),
    )
)

await db.inventory.insert_many(
    [
        {
            "item": "canvas",
            "qty": 100,
            "size": {"h": 28, "w": 35.5, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "journal",
            "qty": 25,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "mat",
            "qty": 85,
            "size": {"h": 27.9, "w": 35.5, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "mousepad",
            "qty": 25,
            "size": {"h": 19, "w": 22.85, "uom": "cm"},
            "status": "P",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "P",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": {"h": 22.85, "w": 30, "uom": "cm"},
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": {"h": 10, "w": 15.25, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "sketchbook",
            "qty": 80,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "sketch pad",
            "qty": 95,
            "size": {"h": 22.85, "w": 30.5, "uom": "cm"},
            "status": "A",
        },
    ]
)

await db.collection('inventory').insertMany([
  {
    item: 'canvas',
    qty: 100,
    size: { h: 28, w: 35.5, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'journal',
    qty: 25,
    size: { h: 14, w: 21, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'mat',
    qty: 85,
    size: { h: 27.9, w: 35.5, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'mousepad',
    qty: 25,
    size: { h: 19, w: 22.85, uom: 'cm' },
    status: 'P'
  },
  {
    item: 'notebook',
    qty: 50,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'P'
  },
  {
    item: 'paper',
    qty: 100,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'D'
  },
  {
    item: 'planner',
    qty: 75,
    size: { h: 22.85, w: 30, uom: 'cm' },
    status: 'D'
  },
  {
    item: 'postcard',
    qty: 45,
    size: { h: 10, w: 15.25, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'sketchbook',
    qty: 80,
    size: { h: 14, w: 21, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'sketch pad',
    qty: 95,
    size: { h: 22.85, w: 30.5, uom: 'cm' },
    status: 'A'
  }
]);

$db->coll("inventory")->insert_many(
    [
        {
            item   => "canvas",
            qty    => 100,
            size   => { h => 28, w => 35.5, uom => "cm" },
            status => "A"
        },
        {
            item   => "journal",
            qty    => 25,
            size   => { h => 14, w => 21, uom => "cm" },
            status => "A"
        },
        {
            item   => "mat",
            qty    => 85,
            size   => { h => 27.9, w => 35.5, uom => "cm" },
            status => "A"
        },
        {
            item   => "mousepad",
            qty    => 25,
            size   => { h => 19, w => 22.85, uom => "cm" },
            status => "P"
        },
        {
            item   => "notebook",
            qty    => 50,
            size   => { h => 8.5, w => 11, uom => "in" },
            status => "P"
        },
        {
            item   => "paper",
            qty    => 100,
            size   => { h => 8.5, w => 11, uom => "in" },
            status => "D"
        },
        {
            item   => "planner",
            qty    => 75,
            size   => { h => 22.85, w => 30, uom => "cm" },
            status => "D"
        },
        {
            item   => "postcard",
            qty    => 45,
            size   => { h => 10, w => 15.25, uom => "cm" },
            status => "A"
        },
        {
            item   => "sketchbook",
            qty    => 80,
            size   => { h => 14, w => 21, uom => "cm" },
            status => "A"
        },
        {
            item   => "sketch pad",
            qty    => 95,
            size   => { h => 22.85, w => 30.5, uom => "cm" },
            status => "A"
        }
    ]
);

$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'canvas',
        'qty' => 100,
        'size' => ['h' => 28, 'w' => 35.5, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        'item' => 'journal',
        'qty' => 25,
        'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        'item' => 'mat',
        'qty' => 85,
        'size' => ['h' => 27.9, 'w' => 35.5, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        'item' => 'mousepad',
        'qty' => 25,
        'size' => ['h' => 19, 'w' => 22.85, 'uom' => 'cm'],
        'status' => 'P',
    ],
    [
        'item' => 'notebook',
        'qty' => 50,
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'status' => 'P',
    ],
    [
        'item' => 'paper',
        'qty' => 100,
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'status' => 'D',
    ],
    [
        'item' => 'planner',
        'qty' => 75,
        'size' => ['h' => 22.85, 'w' => 30, 'uom' => 'cm'],
        'status' => 'D',
    ],
    [
        'item' => 'postcard',
        'qty' => 45,
        'size' => ['h' => 10, 'w' => 15.25, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        'item' => 'sketchbook',
        'qty' => 80,
        'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        'item' => 'sketch pad',
        'qty' => 95,
        'size' => ['h' => 22.85, 'w' => 30.5, 'uom' => 'cm'],
        'status' => 'A',
    ],
]);

db.inventory.insert_many(
    [
        {
            "item": "canvas",
            "qty": 100,
            "size": {"h": 28, "w": 35.5, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "journal",
            "qty": 25,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "mat",
            "qty": 85,
            "size": {"h": 27.9, "w": 35.5, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "mousepad",
            "qty": 25,
            "size": {"h": 19, "w": 22.85, "uom": "cm"},
            "status": "P",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "P",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": {"h": 22.85, "w": 30, "uom": "cm"},
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": {"h": 10, "w": 15.25, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "sketchbook",
            "qty": 80,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "sketch pad",
            "qty": 95,
            "size": {"h": 22.85, "w": 30.5, "uom": "cm"},
            "status": "A",
        },
    ]
)

client[:inventory].insert_many([
                                { item: 'canvas',
                                  qty: 100,
                                  size: { h: 28, w: 35.5, uom: 'cm' },
                                  status: 'A' },
                                { item: 'journal',
                                  qty: 25,
                                  size: { h: 14, w: 21, uom: 'cm' },
                                  status: 'A' },
                                { item: 'mat',
                                  qty: 85,
                                  size: { h: 27.9, w: 35.5, uom: 'cm' },
                                  status: 'A' },
                                { item: 'mousepad',
                                  qty: 25,
                                  size: { h: 19, w: 22.85, uom: 'cm' },
                                  status: 'P' },
                                { item: 'notebook',
                                  qty: 50,
                                  size: { h: 8.5, w: 11, uom: 'in' },
                                  status: 'P' },
                                { item: 'paper',
                                  qty: 100,
                                  size: { h: 8.5, w: 11, uom: 'in' },
                                  status: 'D' },
                                { item: 'planner',
                                  qty: 75,
                                  size: { h: 22.85, w: 30, uom: 'cm' },
                                  status: 'D' },
                                { item: 'postcard',
                                  qty: 45,
                                  size: { h: 10, w: 15.25, uom: 'cm' },
                                  status: 'A' },
                                { item: 'sketchbook',
                                  qty: 80,
                                  size: { h: 14, w: 21, uom: 'cm' },
                                  status: 'A' },
                                { item: 'sketch pad',
                                  qty: 95,
                                  size: { h: 22.85, w: 30.5, uom: 'cm' },
                                  status: 'A' }
                              ])

collection.insertMany(Seq(
  Document("""{ item: "canvas", qty: 100, size: { h: 28, w: 35.5, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "mat", qty: 85, size: { h: 27.9, w: 35.5, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "mousepad", qty: 25, size: { h: 19, w: 22.85, uom: "cm" }, status: "P" }"""),
  Document("""{ item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" }"""),
  Document("""{ item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" }"""),
  Document("""{ item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" }"""),
  Document("""{ item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "sketchbook", qty: 80, size: { h: 14, w: 21, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "sketch pad", qty: 95, size: { h: 22.85, w: 30.5, uom: "cm" }, status: "A" }""")
)).execute()

Atualizar documentos em uma coleção

Para atualizar um documento, o MongoDB fornece operadores de atualização, como $set, para modificar os valores dos campos.

Para usar os operadores de atualização, passe para os métodos de atualização um documento de atualização do formulário:

{
  <update operator>: { <field1>: <value1>, ... },
  <update operator>: { <field2>: <value2>, ... },
  ...
}

Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.

Para atualizar um documento no Compass, passe o mouse sobre o documento de destino e clique no ícone de lápis:

Clique em editar documento

Depois de clicar no ícone de lápis, o documento entra no modo de edição:

Modo de edição de documento

Agora você pode alterar este documento clicando no item que deseja alterar e modificando o valor.

Para obter instruções detalhadas sobre a atualização de documentos no Compass, consulte a documentação do Compass ou siga o exemplo abaixo.

Quando estiver satisfeito com suas alterações, clique em Update para salvar o documento atualizado.

Clique em Cancel para reverter quaisquer modificações feitas no documento e sair do modo de edição.

Para atualizar um documento, o MongoDB fornece operadores de atualização, como $set, para modificar os valores dos campos.

Para usar os operadores de atualização, passe para os métodos de atualização um documento de atualização do formulário:

{
  <update operator> => { <field1> => <value1>, ... },
  <update operator> => { <field2> => <value2>, ... },
  ...
}

Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.

Para atualizar um documento, o MongoDB fornece operadores de atualização, como $set, para modificar os valores dos campos.

Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.

Para atualizar um documento, o MongoDB fornece operadores de atualização, como $set, para modificar os valores dos campos.

O driver fornece o com.mongodb.client.model.Updates classe para facilitar a criação de documentos de atualização. Por exemplo:

combine(set(<field1>, <value1>), set(<field2>, <value2>))

Para obter uma lista dos auxiliares de atualização, consulte com.mongodb.client.model.Updates.

Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.

Para atualizar um documento, o MongoDB fornece operadores de atualização, como $set, para modificar os valores dos campos.

O driver fornece o com.mongodb.client.model.Updates classe para facilitar a criação de documentos de atualização. Por exemplo:

combine(set(<field1>, <value1>), set(<field2>, <value2>))

Para obter uma lista dos auxiliares de atualização, consulte com.mongodb.client.model.Updates.

Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.

Para atualizar um documento, o MongoDB fornece operadores de atualização , como $set , para modificar os valores dos campos.

O driver fornece o com.mongodb.client.model.Updates classe para facilitar a criação de documentos de atualização. O código a seguir mostra um documento de atualização que usa métodos da Updates classe de construtor :

combine(set(<field1>, <value1>), set(<field2>, <value2>))

Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.

Para atualizar um documento, o MongoDB fornece operadores de atualização, como $set, para modificar os valores dos campos.

Para usar os operadores de atualização, passe para os métodos de atualização um documento de atualização do formulário:

{
  <update operator>: { <field1>: <value1>, ... },
  <update operator>: { <field2>: <value2>, ... },
  ...
}

Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.

Para atualizar um documento, o MongoDB fornece operadores de atualização, como $set, para modificar os valores dos campos.

Para usar os operadores de atualização, passe para os métodos de atualização um documento de atualização do formulário:

{
  <update operator>: { <field1>: <value1>, ... },
  <update operator>: { <field2>: <value2>, ... },
  ...
}

Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.

Para atualizar um documento, o MongoDB fornece operadores de atualização, como $set, para modificar os valores dos campos.

Para usar os operadores de atualização, passe para os métodos de atualização um documento de atualização do formulário:

{
  <update operator> => { <field1> => <value1>, ... },
  <update operator> => { <field2> => <value2>, ... },
  ...
}

Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.

Para atualizar um documento, o MongoDB fornece operadores de atualização, como $set, para modificar os valores dos campos.

Para usar os operadores de atualização, passe para os métodos de atualização um documento de atualização do formulário:

[
  <update operator> => [ <field1> => <value1>, ... ],
  <update operator> => [ <field2> => <value2>, ... ],
  ...
]

Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.

Para atualizar um documento, o MongoDB fornece operadores de atualização, como $set, para modificar os valores dos campos.

Para usar os operadores de atualização, passe para os métodos de atualização um documento de atualização do formulário:

{
  <update operator>: { <field1>: <value1>, ... },
  <update operator>: { <field2>: <value2>, ... },
  ...
}

Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.

Para atualizar um documento, o MongoDB fornece operadores de atualização, como $set, para modificar os valores dos campos.

Para usar os operadores de atualização, passe para os métodos de atualização um documento de atualização do formulário:

{
  <update operator> => { <field1> => <value1>, ... },
  <update operator> => { <field2> => <value2>, ... },
  ...
}

Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.

Para atualizar um documento, o MongoDB fornece operadores de atualização, como $set, para modificar os valores dos campos.

Para usar os operadores de atualização, passe para os métodos de atualização um documento de atualização do formulário:

(
  set (<field1>, <value1>),
  set (<field2>, <value2>),
  ...
)

Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.

Observação

O MongoDB pode aceitar um pipeline de agregação para especificar as modificações a serem feitas em vez de um documento de atualização. Para obter detalhes, consulte a página de referência do método.

Atualizar um único documento

O exemplo a seguir usa o método db.collection.updateOne() na collection inventory para atualizar o primeiro documento em que item for igual a "paper":

O exemplo a seguir demonstra o uso do MongoDB Compass para modificar um único documento onde item: paper na collection inventory :

Observação

Este exemplo usa a Visualização da Tabela do Compass para modificar o documento. O processo de edição usando a Visualização da Lista do Compass segue uma abordagem muito semelhante.

Para obter mais informações sobre as diferenças entre a Exibição de Tabela e a Exibição de Lista no Compass, consulte a documentação do Compass.

O exemplo a seguir usa o método IMongoCollection.UpdateOne () na inventory collection para atualizar o primeiro documento em que é item igual a "paper":

O exemplo a seguir usa o método Collection.UpdateOne na inventory collection para atualizar o primeiro documento em que é item igual a "paper":

O exemplo a seguir usa o com.mongodb.reactivestreams.client.MongoCollection.updateOne na coleção inventory para atualizar o primeiro documento onde item é igual a "paper":

O exemplo a seguir usa o com.mongodb.client.MongoCollection.updateOne na inventory collection para atualizar o primeiro documento em que é item igual a "paper":

O exemplo a seguir usa o método MongoCollection.updateOne () na inventory collection para atualizar o primeiro documento em que é item igual a "paper":

O exemplo a seguir utiliza o update_one na inventory collection para atualizar o primeiro documento em que é item igual a "paper":

O exemplo a seguir usa o método Collection.updateOne () na coleção inventory para atualizar o primeiro documento em que item é igual a "paper":

O exemplo a seguir usa o método update_one() na inventory collection para atualizar o primeiro documento em que é item igual a "paper":

O exemplo a seguir usa o método updateOne() na collection inventory para atualizar o primeiro documento em que item for igual a "paper":

O exemplo a seguir utiliza o update_one na inventory collection para atualizar o primeiro documento em que é item igual a "paper":

O exemplo a seguir usa o método update_one() na collection inventory para atualizar o primeiro documento em que item for igual a "paper":

O exemplo a seguir usa o método updateOne() na inventory collection para atualizar o primeiro documento em que é item igual a "paper":

db.inventory.updateOne(
   { item: "paper" },
   {
     $set: { "size.uom": "cm", status: "P" },
     $currentDate: { lastModified: true }
   }
)

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "cm" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

Modifique o documento de destino da seguinte maneira:

Altere o campo status de D para P.
Altere o campo size.uom de in para cm.
Adicione um novo campo chamado lastModified cujo valor será a data de hoje.

Clique no botão Table na navegação superior para acessar a visualização em tabela:
Use a barra de query do Compass para localizar o documento de destino.
Copie o seguinte documento de filtro na barra de query e clique em Find:
```
{ item: "paper" }
```
Passe o mouse sobre o campo status e clique no ícone de lápis que aparece no lado direito do documento para entrar no modo de edição:
Altere o valor do campo para "P".
Clique no botão Update abaixo do campo para salvar suas alterações.
Passe o mouse sobre o campo size e clique nas setas apontando para fora que aparecem no lado direito do campo. Isso abre uma nova guia que exibe os campos dentro do objeto size :
Usando o mesmo processo descrito nas etapas 3-5 para editar o campo status , altere o valor do campo size.uom para "cm".
Clique na guia mais à esquerda acima da tabela rotulada inventory para retornar à visualização original da tabela, que exibe o documento de nível superior:
Passe o mouse sobre o campo status e clique no ícone de lápis que aparece no lado direito do documento para entrar novamente no modo de edição.
Clique dentro do campo status e clique no ícone plus button que aparece no menu de edição.
Clique no botão Add Field After status que aparece abaixo do botão de "mais":
Adicione um novo campo chamado lastModified com o valor da data de hoje. Defina o tipo de campo como Date:
Clique no botão Update abaixo do campo para salvar suas alterações.
Observação
Como o MongoDB Compass não suporta $currentDate ou quaisquer outros operadores de atualização de campo, você deve inserir manualmente o valor da data no Compass.

mongoc_collection_t *collection;
bson_t *selector;
bson_t *update;
bool r;
bson_error_t error;
collection = mongoc_database_get_collection (db, "inventory");
selector = BCON_NEW ("item", BCON_UTF8 ("paper"));
update = BCON_NEW (
   "$set", "{",
   "size.uom", BCON_UTF8 ("cm"),
   "status", BCON_UTF8 ("P"),
   "}",
   "$currentDate", "{",
   "lastModified", BCON_BOOL (true),
   "}");
r = mongoc_collection_update_one(collection, selector, update, NULL, NULL, &error);
bson_destroy (selector);
bson_destroy (update);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}

var filter = Builders<BsonDocument>.Filter.Eq("item", "paper");
var update = Builders<BsonDocument>.Update.Set("size.uom", "cm").Set("status", "P").CurrentDate("lastModified");
var result = collection.UpdateOne(filter, update);

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "cm" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

result, err := coll.UpdateOne(
	context.TODO(),
	bson.D{
		{"item", "paper"},
	},
	bson.D{
		{"$set", bson.D{
			{"size.uom", "cm"},
			{"status", "P"},
		}},
		{"$currentDate", bson.D{
			{"lastModified", true},
		}},
	},
)

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "cm" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

Publisher<UpdateResult> updateOnePublisher = collection.updateOne(eq("item", "paper"),
        combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified")));

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "cm" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

collection.updateOne(eq("item", "paper"),
        combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified")));

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "cm" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

collection.updateOne(eq("item", "paper"),
    combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified")));

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "cm" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

await db.inventory.update_one(
    {"item": "paper"},
    {"$set": {"size.uom": "cm", "status": "P"}, "$currentDate": {"lastModified": True}},
)

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "cm" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

await db.collection('inventory').updateOne(
  { item: 'paper' },
  {
    $set: { 'size.uom': 'cm', status: 'P' },
    $currentDate: { lastModified: true }
  }
);

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "cm" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

# For boolean values, use boolean.pm for 'true' and 'false'
$db->coll("inventory")->update_one(
    { item => "paper" },
    {
        '$set'         => { "size.uom"   => "cm", status => "P" },
        '$currentDate' => { lastModified => true }
    }
);

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "cm" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

$updateResult = $db->inventory->updateOne(
    ['item' => 'paper'],
    [
        '$set' => ['size.uom' => 'cm', 'status' => 'P'],
        '$currentDate' => ['lastModified' => true],
    ],
);

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "cm" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

db.inventory.update_one(
    {"item": "paper"},
    {"$set": {"size.uom": "cm", "status": "P"}, "$currentDate": {"lastModified": True}},
)

client[:inventory].update_one({ item: 'paper'},
                              { '$set' => { 'size.uom' => 'cm', 'status' => 'P' },
                                '$currentDate' => { 'lastModified' => true } })

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "cm" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

collection.updateOne(equal("item", "paper"),
  combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified"))
).execute()

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "cm" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

Atualizar vários documentos

O exemplo a seguir usa o método db.collection.updateMany() na collection inventory para atualizar todos os documentos em que qty é menor que 50:

Você pode atualizar somente um documento de cada vez no MongoDB Compass. Para atualizar vários documentos, conecte-se à sua implantação do MongoDB a partir do mongosh ou de um driver do MongoDB e siga os exemplos nesta seção para o método de sua preferência.

O exemplo a seguir usa o método IMongoCollection.UpdateMany() na coleção inventory para atualizar todos os documentos onde qty é menor que 50:

O exemplo a seguir usa o método Collection.UpdateMany na inventory collection para atualizar todos os documentos onde qty é menor que 50:

O exemplo a seguir usa o método com.mongodb.reactivestreams.client.MongoCollection.updateMany na coleção inventory para atualizar todos os documento em que qty é menor que 50:

O exemplo a seguir usa o com.mongodb.client.MongoCollection.updateMany na inventory collection para atualizar todos os documentos onde qty é menor que 50:

O exemplo a seguir usa o método MongoCollection.updateMany() na inventory collection para atualizar todos os documentos onde qty é menor que 50:

O exemplo a seguir utiliza o update_many na inventory collection para atualizar todos os documentos onde qty é menor que 50:

O exemplo a seguir usa o método Collection.updateMany() na coleção inventory para atualizar todos os documentos onde qty é menor que 50:

O exemplo a seguir usa o método update_many() na inventory collection para atualizar todos os documentos onde qty é menor que 50:

O exemplo a seguir usa o método updateMany() na coleção inventory para atualizar todos os documentos onde qty é menor que 50:

O exemplo a seguir utiliza o update_many na inventory collection para atualizar todos os documentos onde qty é menor que 50:

O exemplo a seguir usa o método update_many() na collection inventory para atualizar todos os documentos em que qty é menor que 50:

O exemplo a seguir usa o método updateMany() na inventory collection para atualizar todos os documentos onde qty é menor que 50:

db.inventory.updateMany(
   { "qty": { $lt: 50 } },
   {
     $set: { "size.uom": "in", status: "P" },
     $currentDate: { lastModified: true }
   }
)

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "in" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

mongoc_collection_t *collection;
bson_t *selector;
bson_t *update;
bool r;
bson_error_t error;
collection = mongoc_database_get_collection (db, "inventory");
selector = BCON_NEW (
   "qty", "{",
   "$lt", BCON_INT64 (50),
   "}");
update = BCON_NEW (
   "$set", "{",
   "size.uom", BCON_UTF8 ("in"),
   "status", BCON_UTF8 ("P"),
   "}",
   "$currentDate", "{",
   "lastModified", BCON_BOOL (true),
   "}");
r = mongoc_collection_update_many(collection, selector, update, NULL, NULL, &error);
bson_destroy (selector);
bson_destroy (update);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}

var filter = Builders<BsonDocument>.Filter.Lt("qty", 50);
var update = Builders<BsonDocument>.Update.Set("size.uom", "in").Set("status", "P").CurrentDate("lastModified");
var result = collection.UpdateMany(filter, update);

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "in" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

result, err := coll.UpdateMany(
	context.TODO(),
	bson.D{
		{"qty", bson.D{
			{"$lt", 50},
		}},
	},
	bson.D{
		{"$set", bson.D{
			{"size.uom", "cm"},
			{"status", "P"},
		}},
		{"$currentDate", bson.D{
			{"lastModified", true},
		}},
	},
)

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "in" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

Publisher<UpdateResult> updateManyPublisher = collection.updateMany(lt("qty", 50),
        combine(set("size.uom", "in"), set("status", "P"), currentDate("lastModified")));

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "in" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

collection.updateMany(lt("qty", 50),
        combine(set("size.uom", "in"), set("status", "P"), currentDate("lastModified")));

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "in" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

collection.updateOne(eq("item", "paper"),
    combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified")));

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "in" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

await db.inventory.update_many(
    {"qty": {"$lt": 50}},
    {"$set": {"size.uom": "in", "status": "P"}, "$currentDate": {"lastModified": True}},
)

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "in" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

await db.collection('inventory').updateMany(
  { qty: { $lt: 50 } },
  {
    $set: { 'size.uom': 'in', status: 'P' },
    $currentDate: { lastModified: true }
  }
);

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "in" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

# For boolean values, use boolean.pm for 'true' and 'false'
$db->coll("inventory")->update_many(
    { qty => { '$lt' => 50 } },
    {
        '$set'         => { "size.uom"   => "in", status => "P" },
        '$currentDate' => { lastModified => true }
    }
);

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "in" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

$updateResult = $db->inventory->updateMany(
    ['qty' => ['$lt' => 50]],
    [
        '$set' => ['size.uom' => 'cm', 'status' => 'P'],
        '$currentDate' => ['lastModified' => true],
    ],
);

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "in" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

db.inventory.update_many(
    {"qty": {"$lt": 50}},
    {"$set": {"size.uom": "in", "status": "P"}, "$currentDate": {"lastModified": True}},
)

client[:inventory].update_many({ qty: { '$lt' => 50 } },
                              { '$set' => { 'size.uom' => 'in', 'status' => 'P' },
                                '$currentDate' => { 'lastModified' => true } })

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "in" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

collection.updateMany(lt("qty", 50),
  combine(set("size.uom", "in"), set("status", "P"), currentDate("lastModified"))
).execute()

A operação de atualização:

usa o operador $set para atualizar o valor do campo size.uom para "in" e o valor do campo status para "P",
usa o operador $currentDate para atualizar o valor do campo lastModified para a data atual. Se o campo lastModified não existir, $currentDate criará o campo. Consulte $currentDate para obter detalhes.

Substituir um documento

Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como segundo argumento para db.collection.replaceOne().

Ao substituir um documento, o documento de substituição deve consistir apenas em pares de campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização .

O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id , pois o campo _id é imutável. No entanto, se você incluir o campo _id , ele deverá ter o mesmo valor que o valor atual.

O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":

Você não pode substituir um documento no MongoDB Compass. Para substituir um documento, conecte-se à sua implantação do MongoDB a partir do mongosh ou de um driver do MongoDB e siga os exemplos nesta seção para obter seu método preferido.

Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como o segundo argumento para IMongoCollection.ReplaceOne().

Ao substituir um documento, o documento de substituição deve consistir apenas em pares de campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização .

O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id , pois o campo _id é imutável. No entanto, se você incluir o campo _id , ele deverá ter o mesmo valor que o valor atual.

O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":

Para substituir todo o conteúdo de um documento, exceto o _id campo , passe um documento totalmente novo como o segundo argumento para Collection.ReplaceOne.

Ao substituir um documento, o documento de substituição deve consistir apenas em pares de campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização .

O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id , pois o campo _id é imutável. No entanto, se você incluir o campo _id , ele deverá ter o mesmo valor que o valor atual.

O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":

Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como o segundo argumento para com.mongodb.reactivestreams.client.MongoCollection.replaceOne.

Ao substituir um documento, o documento de substituição deve consistir apenas em pares de campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização .

O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id , pois o campo _id é imutável. No entanto, se você incluir o campo _id , ele deverá ter o mesmo valor que o valor atual.

O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":

Para substituir todo o conteúdo de um documento, exceto o _id campo , passe um documento totalmente novo como o segundo argumento para com.mongodb.client.MongoCollection.replaceOne.

Ao substituir um documento, o documento de substituição deve consistir apenas em pares de campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização .

O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id , pois o campo _id é imutável. No entanto, se você incluir o campo _id , ele deverá ter o mesmo valor que o valor atual.

O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":

Para substituir todo o conteúdo de um documento, exceto o _id campo , passe um documento totalmente novo como o segundo argumento para o MongoCollection.replaceOne() método.

Ao substituir um documento, o documento de substituição deve consistir apenas em pares de campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização .

O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id , pois o campo _id é imutável. No entanto, se você incluir o campo _id , ele deverá ter o mesmo valor que o valor atual.

O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":

Para substituir todo o conteúdo de um documento, exceto o _id campo , passe um documento totalmente novo como segundo argumento para replace_one.

Ao substituir um documento, o documento de substituição deve consistir apenas em pares de campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização .

O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id , pois o campo _id é imutável. No entanto, se você incluir o campo _id , ele deverá ter o mesmo valor que o valor atual.

O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":

Para substituir todo o conteúdo de um documento, exceto o _id campo , passe um documento totalmente novo como o segundo argumento para Collection.replaceOne().

Ao substituir um documento, o documento de substituição deve consistir apenas em pares de campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização .

O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id , pois o campo _id é imutável. No entanto, se você incluir o campo _id , ele deverá ter o mesmo valor que o valor atual.

O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":

Para substituir todo o conteúdo de um documento, exceto o _id campo , passe um documento totalmente novo como o segundo argumento para replace_one().

Ao substituir um documento, o documento de substituição deve consistir apenas em pares de campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização .

O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id , pois o campo _id é imutável. No entanto, se você incluir o campo _id , ele deverá ter o mesmo valor que o valor atual.

O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":

Para substituir todo o conteúdo de um documento, exceto o campo _id , passe um documento totalmente novo como segundo argumento para replaceOne().

Ao substituir um documento, o documento de substituição deve consistir apenas em pares de campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização .

O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id , pois o campo _id é imutável. No entanto, se você incluir o campo _id , ele deverá ter o mesmo valor que o valor atual.

O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":

Para substituir todo o conteúdo de um documento, exceto o _id campo , passe um documento totalmente novo como segundo argumento para replace_one.

Ao substituir um documento, o documento de substituição deve consistir apenas em pares de campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização .

O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id , pois o campo _id é imutável. No entanto, se você incluir o campo _id , ele deverá ter o mesmo valor que o valor atual.

O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":

Para substituir todo o conteúdo de um documento, exceto o campo _id , passe um documento totalmente novo como o segundo argumento para replace_one().

Ao substituir um documento, o documento de substituição deve consistir apenas em pares de campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização .

O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id , pois o campo _id é imutável. No entanto, se você incluir o campo _id , ele deverá ter o mesmo valor que o valor atual.

O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":

Para substituir todo o conteúdo de um documento, exceto o _id campo , passe um documento totalmente novo como o segundo argumento para replaceOne()

Ao substituir um documento, o documento de substituição deve consistir apenas em pares de campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização .

O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id , pois o campo _id é imutável. No entanto, se você incluir o campo _id , ele deverá ter o mesmo valor que o valor atual.

O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":

db.inventory.replaceOne(
   { item: "paper" },
   { item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 40 } ] }
)

mongoc_collection_t *collection;
bson_t *selector;
bson_t *replacement;
bool r;
bson_error_t error;
collection = mongoc_database_get_collection (db, "inventory");
selector = BCON_NEW ("item", BCON_UTF8 ("paper"));
replacement = BCON_NEW (
   "item", BCON_UTF8 ("paper"),
   "instock", "[",
   "{",
   "warehouse", BCON_UTF8 ("A"),
   "qty", BCON_INT64 (60),
   "}","{",
   "warehouse", BCON_UTF8 ("B"),
   "qty", BCON_INT64 (40),
   "}",
   "]");
/* MONGOC_UPDATE_NONE means "no special options" */
r = mongoc_collection_replace_one(collection, selector, replacement, NULL, NULL, &error);
bson_destroy (selector);
bson_destroy (replacement);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}

Certifique-se também de limpar quaisquer recursos abertos ligando para os seguintes métodos, conforme apropriado:

var filter = Builders<BsonDocument>.Filter.Eq("item", "paper");
var replacement = new BsonDocument
{
    { "item", "paper" },
    { "instock", new BsonArray
        {
            new BsonDocument { { "warehouse", "A" }, { "qty", 60 } },
            new BsonDocument { { "warehouse", "B" }, { "qty", 40 } } }
        }
};
var result = collection.ReplaceOne(filter, replacement);

result, err := coll.ReplaceOne(
	context.TODO(),
	bson.D{
		{"item", "paper"},
	},
	bson.D{
		{"item", "paper"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 60},
			},
			bson.D{
				{"warehouse", "B"},
				{"qty", 40},
			},
		}},
	},
)

Publisher<UpdateResult> replaceOnePublisher = collection.replaceOne(eq("item", "paper"),
        Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 40 } ] }"));

collection.replaceOne(eq("item", "paper"),
        Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 40 } ] }"));

collection.replaceOne(eq("item", "paper"),
    Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 40 } ] }"));

await db.inventory.replace_one(
    {"item": "paper"},
    {
        "item": "paper",
        "instock": [{"warehouse": "A", "qty": 60}, {"warehouse": "B", "qty": 40}],
    },
)

await db.collection('inventory').replaceOne(
  { item: 'paper' },
  {
    item: 'paper',
    instock: [
      { warehouse: 'A', qty: 60 },
      { warehouse: 'B', qty: 40 }
    ]
  }
);

$db->coll("inventory")->replace_one(
    { item => "paper" },
    {
        item    => "paper",
        instock => [ { warehouse => "A", qty => 60 }, { warehouse => "B", qty => 40 } ]
    }
);

$updateResult = $db->inventory->replaceOne(
    ['item' => 'paper'],
    [
        'item' => 'paper',
        'instock' => [
            ['warehouse' => 'A', 'qty' => 60],
            ['warehouse' => 'B', 'qty' => 40],
        ],
    ],
);

db.inventory.replace_one(
    {"item": "paper"},
    {
        "item": "paper",
        "instock": [{"warehouse": "A", "qty": 60}, {"warehouse": "B", "qty": 40}],
    },
)

client[:inventory].replace_one({ item: 'paper' },
                               { item: 'paper',
                                 instock: [ { warehouse: 'A', qty: 60 },
                                            { warehouse: 'B', qty: 40 } ] })

collection.replaceOne(equal("item", "paper"),
  Document("""{ item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 40 } ] }""")
).execute()

Atualizar um documento com MongoDB Atlas

Observação

Você pode atualizar somente um documento de cada vez na IU do MongoDB Atlas. Para atualizar vários documentos ou substituir um documento inteiro, conecte-se à sua implantação do Atlas a partir de mongosh ou de um driver do MongoDB e siga os exemplos desta página para o método de sua preferência.

O exemplo desta seção usa o conjunto de dados de suprimentos de amostra. Para saber como carregar o conjunto de dados de amostra em sua implantação do MongoDB Atlas, consulte Carregar Dados de Amostra.

Para atualizar um documento no MongoDB Atlas, siga estas etapas:

1

Na interface do usuário do Atlas MongoDB, vá para a Clusters página para seu projeto.

Se ainda não estiver exibido, selecione a organização que contém o projeto desejado no menu Organizations na barra de navegação.
Se ainda não estiver exibido, selecione seu projeto no menu Projects na barra de navegação.
Se a página Clusters ainda não estiver exibida, clique em Database na barra lateral.
A página Clusters é exibida.

2

Navegue até a coleção.

Para o cluster que contém os dados de amostra, clique em Browse Collections.
No painel de navegação esquerdo, selecione o banco de dados sample_supplies.
Selecione a collection sales.

3

Especifique um documento de filtro de consulta.

Você pode especificar um documento de filtro de query no campo Filter. Um documento de filtro de query usa operadores de query para especificar as condições de pesquisa.

Copie o seguinte documento de filtro de query na barra de pesquisa do Filter e clique em Apply:

{ saleDate: { $gte: { $date: "2016-01-01T00:00-00:00" }, $lte: { $date: "2016-01-02T00:00-00:00" } } }

Esse filtro de query retorna todos os documentos na coleção sample_supplies.sales em que saleDate é em ou entre 1 e 2 de janeiro de 2016, horário UTC.

4

Edit a document.

Para editar um documento exibido nos resultados da query, passe o mouse sobre o documento e clique no ícone de lápis. No editor de documentos, você pode:

Adicionar um novo campo.
Excluir um campo existente.
Editar o nome, valor ou tipo de um campo.
Reverter uma alteração específica.

Para obter instruções detalhadas, consulte Criar, exibir, atualizar e excluir documentos.

5

Salvar suas alterações.

Para confirmar e guardar as suas alterações, clique no botão Update.

Comportamento

Atomicidade

Todas as operações de gravação no MongoDB são atômicas no nível de um único documento. Para obter mais informações sobre MongoDB e atomicidade, consulte Atomicidade e transações.

`_id` Campo

Uma vez definido, não é possível atualizar o valor do campo _id nem substituir um documento existente por um documento de substituição que tenha um valor de campo _id diferente.

Ordem do campo

Para operações de gravação, o MongoDB preserva a ordem dos campos do documento,exceto para os seguintes casos:

O campo _id é sempre o primeiro campo do documento.
As atualizações que incluem renaming dos nomes de campos podem resultar na reordenação de campos no documento.

Opção Upsert

Se updateOne(), updateMany() ou replaceOne() incluir upsert : true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.

Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.

A opção upsert não está disponível no MongoDB Compass.

Se UpdateOne(), UpdateMany(), ou ReplaceOne() inclui um UpdateOptions instância de argumento com a IsUpsert opção definida como true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.

Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.

Se coleção.UpdateOne inclui a opção Upsert definida como verdadeira e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.

Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.

Se os métodos update e replace incluírem o parâmetro UpdateOptions que especifica UpdateOptions.upsert(true) e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.

Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.

Se os métodos de atualização e substituição incluírem com.mongodb.client.model.UpdateOptions parâmetro que especifica com.mongodb.client.model.updateOptions.upsert (true) e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.

Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.

Se os métodos de atualização e substituição incluírem com.mongodb.client.model.UpdateOptions que especifica upsert(true), e nenhum documento corresponde ao filtro especificado, a operação cria um novo documento e o insere. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.

Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.

Se update_one, update_many ou replace_one incluir upsert : true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.

Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.

Se updateOne(), updateMany() ou replaceOne() incluírem upsert : true no parâmetro de documento options e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.

Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.

Se update_one(), update_many() ou replace_one() incluir upsert => true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.

Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.

Se updateOne(), updateMany() ou replaceOne() incluir upsert => true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.

Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.

Se update_one, update_many ou replace_one incluir upsert : true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.

Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.

Se update_one(), update_many() ou replace_one() incluírem upsert => true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.

Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.

Se updateOne(), updateMany() ou replaceOne() incluir upsert => true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.

Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.

Escrever confirmação

Com preocupações de gravação, você pode especificar o nível de confirmação solicitado do MongoDB para operações de gravação. Para mais informações, consulte preocupação de gravação.

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Voltar

Iteração de um cursor no mongosh

Próximo

Pipeline de agregação

Selecione a linguagem

Nesta página

Atualizar documentos em uma coleção
Atualizar um documento com MongoDB Atlas
Comportamento