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.
AIU de usuário do MongoDBAtlas. 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. Para preencher a coleção inventory, use 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 C# 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 as seguintes funções do driver Go 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 os seguintes métodos do driver Java Reactive Streams:

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 os seguintes métodos do driver Motor:

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 do MongoDB Node.js:

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 Perl 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 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 os seguintes Métodos do driver Python PyMongo :

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 do MongoDB Ruby:

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 Scala 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:

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 as alterações, clique em Update para salvar o documento atualizado.

Clique em Cancel para reverter as 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 a classe com.mongodb.client.model.Updates 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 a classe com.mongodb.client.model.Updates 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 campo .

O driver fornece o com.mongodb. cliente.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 classe de construtor Updates :

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 em que item: paper na coleção inventory :

Observação

Este exemplo utiliza a Visualização da Tabela do Compass para modificar o documento. O processo de edição usando a Visualização de lista do Compass segue uma abordagem 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 coleção inventory 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 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 método com.mongodb.client.MongoCollection.updateOne na coleção inventory para atualizar o primeiro documento em que item é igual a "paper":

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

O exemplo a seguir usa o método update_one na coleção inventory 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 coleção inventory para atualizar o primeiro documento em que item é igual a "paper":

O exemplo a seguir usa o método 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 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 coleção inventory para atualizar o primeiro documento em que item é igual a "paper":

O exemplo a seguir usa o método updateOne() na coleção inventory 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 forma:

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 Exibição de tabela:
Use a barra de query do Compass para localizar o documento de destino.
Copie o seguinte documento de filtro na barra de consulta 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 novamente 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 aba 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 à exibição de tabela original, 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 adição:
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 oferece suporte a $currentDate ou qualquer outro operador de atualização de campo, você deve inserir manualmente o valor de 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 à implantação do MongoDB por mongosh ou um driver do MongoDB e siga os exemplos nesta seção para usar 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 coleção inventory 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 método com.mongodb.client.MongoCollection.updateMany na coleção inventory para atualizar todos os documentos em que qty é menor que 50:

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

O exemplo a seguir usa o método update_many 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 coleção inventory para atualizar todos os documentos onde qty é menor que 50:

O exemplo a seguir usa o método update_many() na coleção inventory para atualizar todos os documentos em que 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 usa o método update_many 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 coleção inventory para atualizar todos os documentos onde qty é menor que 50:

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

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 substituto deve consistir apenas em pares 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 à implantação do MongoDB por mongosh ou um driver do MongoDB e siga os exemplos nesta seção para usar o método de sua preferência.

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 substituto deve consistir apenas em pares 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 Collection.ReplaceOne.

Ao substituir um documento, o documento substituto deve consistir apenas em pares 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 substituto deve consistir apenas em pares 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.client.MongoCollection.replaceOne.

Ao substituir um documento, o documento substituto deve consistir apenas em pares 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 substituto deve consistir apenas em pares 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 substituto deve consistir apenas em pares 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 Collection.replaceOne().

Ao substituir um documento, o documento substituto deve consistir apenas em pares 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 substituto deve consistir apenas em pares 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 replaceOne().

Ao substituir um documento, o documento substituto deve consistir apenas em pares 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 substituto deve consistir apenas em pares 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 substituto deve consistir apenas em pares 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 replaceOne()

Ao substituir um documento, o documento substituto deve consistir apenas em pares 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 IU do MongoDB Atlas, acesse a Clusters página do seu projeto.<a class=\" \" href=\" \" title=\" \"><svg xmlns=\" \" width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \" role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path fill=\" \" d=\" \">

Se ainda não tiver sido exibido, selecione a organização que contém seu projeto 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 ainda não estiver exibido, clique em Clusters 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() incluir uma instância de argumento UpdateOptions com a opção IsUpsert 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 Collection.UpdateOne incluir a opção Upsert 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 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 o parâmetro com.mongodb.client.model.updateOptions 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 o com.mongodb. cliente.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 documento 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() 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.

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