Docs Menu
Docs Home
/
MongoDB 매뉴얼
/
CRUD 작업

문서 업데이트

이 페이지의 내용

  • 컬렉션의 문서 업데이트
  • MongoDB Atlas로 문서 업데이트하기
  • 행동

다음 방법을 사용하여 MongoDB에서 문서를 업데이트할 수 있습니다:

  • 프로그래밍 언어의 드라이버입니다.

  • MongoDB Atlas UI. 자세한 내용은 MongoDB Atlas로 문서 업데이트를 참조하세요.

  • MongoDB Compass

➤ 오른쪽 상단의 언어 선택 드롭다운 메뉴를 사용하여 다음 예시의 언어를 설정합니다.

이 페이지에서는 다음 mongosh 메서드를 사용합니다.

  • db.collection.updateOne(<filter>, <update>, <options>)

  • db.collection.updateMany(<filter>, <update>, <options>)

  • db.collection.replaceOne(<filter>, <update>, <options>)

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 MongoDB Compass를 사용하여 문서를 업데이트합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. inventory 컬렉션을 다음 문서로 채웁니다.

이 페이지에서는 다음 MongoDB C 드라이버 를 사용합니다. 메서드:

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 다음 MongoDB C# 드라이버 메서드를 사용합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 다음 MongoDB Go 드라이버 함수를 사용합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지는 다음 Java Reactive Streams 드라이버 메서드를 사용합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 다음 Java 동기식 드라이버 메서드를 사용합니다:

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 다음 코틀린 (Kotlin) 루틴 드라이버 메서드를 사용합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 다음 Motor 드라이버 메서드를 사용합니다:

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 다음 MongoDB Node.js 드라이버 메서드를 사용합니다:

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지는 다음과 같은 MongoDB Perl 드라이버 메서드를 사용합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 다음의 MongoDB PHP 라이브러리 메서드를 사용합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지는 다음 PyMongo Python 드라이버 메서드를 사용합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 다음 MongoDB Ruby 드라이버 메서드를 사용합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 inventory 컬렉션을 만듭니다:

이 페이지에서는 다음 MongoDB Scala 드라이버 메서드를 사용합니다.

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. MongoDB 인스턴스의 테스트 데이터베이스에 연결한 다음 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" }
]

MongoDB Compass를 사용하여 문서를 삽입하는 방법에 대한 지침은 문서 삽입을 참조하세요.

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()

컬렉션의 문서 업데이트

문서를 업데이트하기 위해 MongoDB는 필드 값을 수정하는 $set와(과) 같은 업데이트 연산자를 제공합니다.

업데이트 연산자를 사용하려면 아래 형식의 업데이트 문서를 업데이트 메서드에 전달합니다.

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

$set과 같은 일부 업데이트 연산자는 필드가 없는 경우 필드를 만듭니다. 자세한 내용은 개별 업데이트 연산자 참조를 확인하세요.

Compass에서 문서를 업데이트하려면 대상 문서 위에 마우스를 놓고 연필 아이콘을 클릭합니다.

문서 편집을 클릭합니다

연필 아이콘을 클릭하면 문서가 편집 모드로 전환됩니다.

문서 편집 모드

이제 변경하려는 항목을 클릭하고 값을 수정하여 이 문서를 변경할 수 있습니다.

Compass에서 문서를 업데이트하는 방법에 대한 자세한 지침은 Compass 설명서 를 참조하거나 아래 예시를 따르세요.

변경 사항에 만족하면 Update를 클릭하여 업데이트된 문서를 저장합니다.

Cancel을 클릭하면 문서의 수정 사항이 취소되고 편집 모드가 종료됩니다.

문서를 업데이트하기 위해 MongoDB는 필드 값을 수정하는 $set와(과) 같은 업데이트 연산자를 제공합니다.

업데이트 연산자를 사용하려면 아래 형식의 업데이트 문서를 업데이트 메서드에 전달합니다.

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

$set과 같은 일부 업데이트 연산자는 필드가 없는 경우 필드를 만듭니다. 자세한 내용은 개별 업데이트 연산자 참조를 확인하세요.

문서를 업데이트하기 위해 MongoDB는 필드 값을 수정하는 $set와(과) 같은 업데이트 연산자를 제공합니다.

$set과 같은 일부 업데이트 연산자는 필드가 없는 경우 필드를 만듭니다. 자세한 내용은 개별 업데이트 연산자 참조를 확인하세요.

문서를 업데이트하기 위해 MongoDB는 필드 값을 수정하는 $set와(과) 같은 업데이트 연산자를 제공합니다.

드라이버는 업데이트 문서를 쉽게 만들 수 있도록 com.mongodb.client.model.Updates 클래스를 제공합니다. 예시:

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

업데이트 헬퍼 목록은 com.mongodb.client.model.Updates를 참조하세요.

$set과 같은 일부 업데이트 연산자는 필드가 없는 경우 필드를 만듭니다. 자세한 내용은 개별 업데이트 연산자 참조를 확인하세요.

문서를 업데이트하기 위해 MongoDB는 필드 값을 수정하는 $set와(과) 같은 업데이트 연산자를 제공합니다.

드라이버는 업데이트 문서를 쉽게 만들 수 있도록 com.mongodb.client.model.Updates 클래스를 제공합니다. 예시:

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

업데이트 헬퍼 목록은 com.mongodb.client.model.Updates를 참조하세요.

$set과 같은 일부 업데이트 연산자는 필드가 없는 경우 필드를 만듭니다. 자세한 내용은 개별 업데이트 연산자 참조를 확인하세요.

문서 를 업데이트 하기 위해 MongoDB 는 와 같은 업데이트 연산자 를 제공하여 필드 $set 값을 수정합니다.

운전자 는 com.mongodb를 제공합니다. 클라이언트.model.Updates 클래스를 사용하여 업데이트 문서를 쉽게 만들 수 있습니다. 다음 코드는 Updates 빌더 클래스의 메서드를 사용하는 업데이트 문서 를 보여줍니다.

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

$set과 같은 일부 업데이트 연산자는 필드가 없는 경우 필드를 만듭니다. 자세한 내용은 개별 업데이트 연산자 참조를 확인하세요.

문서를 업데이트하기 위해 MongoDB는 필드 값을 수정하는 $set와(과) 같은 업데이트 연산자를 제공합니다.

업데이트 연산자를 사용하려면 아래 형식의 업데이트 문서를 업데이트 메서드에 전달합니다.

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

$set과 같은 일부 업데이트 연산자는 필드가 없는 경우 필드를 만듭니다. 자세한 내용은 개별 업데이트 연산자 참조를 확인하세요.

문서를 업데이트하기 위해 MongoDB는 필드 값을 수정하는 $set와(과) 같은 업데이트 연산자를 제공합니다.

업데이트 연산자를 사용하려면 아래 형식의 업데이트 문서를 업데이트 메서드에 전달합니다.

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

$set과 같은 일부 업데이트 연산자는 필드가 없는 경우 필드를 만듭니다. 자세한 내용은 개별 업데이트 연산자 참조를 확인하세요.

문서를 업데이트하기 위해 MongoDB는 필드 값을 수정하는 $set와(과) 같은 업데이트 연산자를 제공합니다.

업데이트 연산자를 사용하려면 아래 형식의 업데이트 문서를 업데이트 메서드에 전달합니다.

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

$set과 같은 일부 업데이트 연산자는 필드가 없는 경우 필드를 만듭니다. 자세한 내용은 개별 업데이트 연산자 참조를 확인하세요.

문서를 업데이트하기 위해 MongoDB는 필드 값을 수정하는 $set와(과) 같은 업데이트 연산자를 제공합니다.

업데이트 연산자를 사용하려면 아래 형식의 업데이트 문서를 업데이트 메서드에 전달합니다.

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

$set과 같은 일부 업데이트 연산자는 필드가 없는 경우 필드를 만듭니다. 자세한 내용은 개별 업데이트 연산자 참조를 확인하세요.

문서를 업데이트하기 위해 MongoDB는 필드 값을 수정하는 $set와(과) 같은 업데이트 연산자를 제공합니다.

업데이트 연산자를 사용하려면 아래 형식의 업데이트 문서를 업데이트 메서드에 전달합니다.

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

$set과 같은 일부 업데이트 연산자는 필드가 없는 경우 필드를 만듭니다. 자세한 내용은 개별 업데이트 연산자 참조를 확인하세요.

문서를 업데이트하기 위해 MongoDB는 필드 값을 수정하는 $set와(과) 같은 업데이트 연산자를 제공합니다.

업데이트 연산자를 사용하려면 아래 형식의 업데이트 문서를 업데이트 메서드에 전달합니다.

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

$set과 같은 일부 업데이트 연산자는 필드가 없는 경우 필드를 만듭니다. 자세한 내용은 개별 업데이트 연산자 참조를 확인하세요.

문서를 업데이트하기 위해 MongoDB는 필드 값을 수정하는 $set와(과) 같은 업데이트 연산자를 제공합니다.

업데이트 연산자를 사용하려면 아래 형식의 업데이트 문서를 업데이트 메서드에 전달합니다.

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

$set과 같은 일부 업데이트 연산자는 필드가 없는 경우 필드를 만듭니다. 자세한 내용은 개별 업데이트 연산자 참조를 확인하세요.

참고

MongoDB는 업데이트 문서 대신 수정 사항을 지정하는 집계 파이프라인을 사용할 수 있습니다. 자세한 내용은 메서드 참조 페이지를 참조하세요.

단일 문서 업데이트

다음 예시에서는 inventory 컬렉션에서 db.collection.updateOne() 메서드를 사용하여 item가 "paper"인 첫 번째 문서를 업데이트합니다.

다음 예시에서는 MongoDB Compass를 사용하여 inventory 컬렉션에서 item: paper 단일 문서를 수정하는 방법을 보여 줍니다.

참고

이 예시 에서는 Compass 테이블 뷰 를 사용하여 문서 를 수정합니다. Compass 목록 보기 를 사용한 편집 프로세스 도 비슷한 접근 방식을 따릅니다.

Compass의 테이블 보기와 목록 보기 간의 차이점에 대한 자세한 내용은 Compass 설명서를 참조하세요.

다음 예시에서는 inventory 컬렉션에서 IMongoCollection.UpdateOne() 메서드를 사용하여 item이 "paper"와 같은 첫 번째 문서를 업데이트합니다.

다음 예시에서는 inventory 컬렉션에서 Collection.UpdateOne 메서드를 사용하여 item이 "paper"와 같은 첫 번째 문서를 업데이트합니다.

다음 예시에서는 inventory 컬렉션에서 com.mongodb.reactivestreams.client.MongoCollection.updateOne을 사용하여 item이(가) "paper"와(과) 같은 첫 번째 문서를 업데이트합니다.

다음 예시에서는 inventory 컬렉션에 com.mongodb.client.MongoCollection.updateOne 메서드를 사용하여 item이 "paper"와같은 첫 번째 문서를 업데이트합니다.

다음 예시 에서는 MongoCollection.updateOne() 메서드를 사용하여 inventory 컬렉션 에서 item 가 "paper" 인 첫 번째 문서 를 업데이트 합니다.

다음 예시는 inventory 컬렉션에서 update_one 메서드를 사용하여 item이 "paper"인 첫 번째 문서를 업데이트합니다.

다음 예시에서는 Collection.updateOne() 을 inventory 컬렉션에서 사용하여 item이(가) "paper"와(과) 동일한 첫 번째 문서를 업데이트합니다.

다음 예시에서는 update_one()을 inventory 컬렉션에서 사용하여 item이 "paper"와 동일한 첫 번째 문서를 업데이트합니다.

다음 예시에서는 inventory 컬렉션에서 updateOne() 메서드를 사용하여 item "paper" 과 같은 첫 번째 문서를 업데이트합니다.

다음 예시는 inventory 컬렉션에서 update_one 메서드를 사용하여 item이 "paper"인 첫 번째 문서를 업데이트합니다.

다음 예시에서는 update_one()을 inventory 컬렉션에서 사용하여 item이 "paper"와 동일한 첫 번째 문서를 업데이트합니다.

다음 예시에서는 updateOne()을 inventory 컬렉션에서 사용하여 item이 "paper"와 동일한 첫 번째 문서를 업데이트합니다.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "cm"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

다음과 같이 대상 문서 를 수정합니다.

  • status 필드를 D에서 P로 변경합니다.

  • size.uom 필드를 in에서 cm로 변경합니다.

  • 값이 오늘 날짜가 되는 lastModified(이)라는 새 필드를 추가합니다.

  1. 상단 탐색에서 Table 버튼을 클릭하여 테이블 보기에 액세스하세요.

    테이블 뷰 액세스

  2. Compass 쿼리 막대를 사용하여 대상 문서를 찾습니다.

    다음 필터 문서를 쿼리 표시줄에 복사하고 Find를 클릭합니다.

    { item: "paper" }
    Paper 문서 찾기

  3. status 필드 위로 마우스를 가져간 다음 문서 오른쪽에 나타나는 연필 아이콘을 클릭하여 편집 모드로 들어갑니다.

    편집 버튼을 클릭합니다

  4. 필드 값을 "P"(으)로 변경합니다.

  5. 변경 사항을 저장하려면 필드 아래에 있는 Update 버튼을 클릭하세요.

  6. size 필드 위로 마우스를 가져간 후 필드 오른쪽에 나타나는 바깥쪽을 가리키는 화살표를 클릭합니다. 이렇게 하면 size 객체 내의 필드가 표시되는 새 탭이 열립니다.

    크기 객체 확장

  7. status 필드를 편집하기 위해 3-5 단계에 설명된 것과 동일한 프로세스를 사용하여 size.uom 필드의 값을 "cm"(으)로 변경합니다.

  8. inventory 레이블이 붙은 테이블 위의 맨 왼쪽 탭을 클릭하면 최상위 문서를 표시하는 원래 테이블 보기로 돌아갑니다.

    인벤토리 탭을 클릭합니다.

  9. status 필드 위로 마우스를 가져간 다음 문서 오른쪽에 나타나는 연필 아이콘을 클릭하여 편집 모드로 다시 들어갑니다.

  10. status 필드 내부를 클릭하고 편집 메뉴에 나타나는 plus button 아이콘을 클릭합니다.

    더하기 버튼 아래에 나타나는 Add Field After status 버튼을 클릭합니다.

    상태 뒤에 필드 추가

  11. 오늘 날짜 값을 갖는 lastModified라는 새 필드를 추가합니다. 필드 유형을 Date로 설정합니다.

    업데이트 제출

  12. 변경 사항을 저장하려면 필드 아래에 있는 Update 버튼을 클릭하세요.

    참고

    MongoDB Compass는 $currentDate 또는 기타 필드 업데이트 연산자를 지원하지 않으므로 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);

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "cm"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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},
		}},
	},
)

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "cm"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "cm"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "cm"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "cm"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "cm"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "cm"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

# 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 }
    }
);

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "cm"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "cm"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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 } })

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "cm"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "cm"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

여러 문서 업데이트하기

다음 예시에서는 inventory 컬렉션에 db.collection.updateMany() 메서드를 사용하여 qty가 50보다 작은 모든 문서를 업데이트합니다:

MongoDB Compass에서는 한 번에 하나의 문서만 업데이트할 수 있습니다. 여러 문서를 업데이트하려면 mongosh 또는 MongoDB 드라이버에서 MongoDB 배포에 연결하고 원하는 방법에 대한 이 섹션의 예제를 따르십시오.

다음 예시에서는 inventory 컬렉션에서 IMongoCollection.UpdateMany() 메서드를 사용해 qty이(가) 50 미만인 모든 문서를 업데이트합니다.

다음 예시에서는 Collection.UpdateMany 메서드를 inventory 컬렉션에서 사용하여 qty가 50 미만인 모든 문서를 업데이트합니다.

다음 예시에서는 inventory 컬렉션에 com.mongodb.reactivestreams.client.MongoCollection.updateMany 메서드를 사용하여 qty이(가) 50 미만인 모든 문서를 업데이트합니다.

다음 예시에서는 inventory 컬렉션에서 com.mongodb.client.MongoCollection.updateMany 메서드를 사용하여 qty가 50 미만인 모든 문서를 업데이트합니다.

다음 예시 에서는 MongoCollection.updateMany() 메서드를 사용하여 inventory 컬렉션 에서 qty 가 50 미만인 모든 문서를 업데이트 합니다.

다음 예제는 inventory 컬렉션에서 update_many 메서드를 사용하여 qty 50보다 작은 모든 문서를 업데이트합니다.

다음 예시에서는 Collection.updateMany()를 사용합니다. inventory 컬렉션에서 qty가 50 미만인 모든 문서를 업데이트하는 메서드.

다음 예제는 inventory 컬렉션에서 update_many() 메서드를 사용하여 qty가 50 미만인 모든 문서를 업데이트합니다.

다음 예시에서는 inventory 컬렉션에서 updateMany() 메서드를 사용하여 qty이(가) 50보다 작은 모든 문서를 업데이트합니다.

다음 예제는 inventory 컬렉션에서 update_many 메서드를 사용하여 qty 50보다 작은 모든 문서를 업데이트합니다.

다음 예시는 inventory 컬렉션에서 update_many() 메서드를 사용하여 qty가 50 미만인 모든 문서를 업데이트합니다.

다음 예제는 inventory 컬렉션에서 updateMany() 메서드를 사용하여 qty가 50 미만인 모든 문서를 업데이트합니다.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "in"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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);

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "in"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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},
		}},
	},
)

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "in"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "in"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "in"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "in"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "in"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "in"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

# 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 }
    }
);

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "in"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "in"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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 } })

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "in"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

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

업데이트 작업입니다:

  • $set 연산자를 사용하여 size.uom 필드 값을 "in"로, status 필드 값을 "P"로 업데이트합니다.

  • $currentDate 연산자를 사용하여 lastModified 필드의 값을 현재 날짜로 업데이트합니다. lastModified 필드가 존재하지 않으면 $currentDate에서 필드를 만듭니다. 자세한 내용은 $currentDate를 참조하세요.

문서 교체하기

_id 필드를 제외한 문서의 전체 내용을 바꾸려면 완전히 새로운 문서를 두 번째 인수로 db.collection.replaceOne()에 전달합니다.

문서를 바꿀 때 대체 문서는 필드/값 쌍으로만 구성되어야 합니다. 대체 문서에는 업데이트 연산자 표현식이 포함될 수 없습니다.

교체 문서는 원본 문서와 다른 필드를 가질 수 있습니다. 교체 문서에서 _id 필드는 변경되지 않으므로 _id 필드를 생략할 수 있습니다. 그러나 _id 필드를 포함하는 경우 현재 값과 동일한 값을 가져야 합니다.

다음 예시에서는 item: "paper"이 다음을 충족하는 inventory 컬렉션의 첫 번째 문서를 대체합니다.

MongoDB Compass에서는 문서를 바꿀 수 없습니다. 문서를 바꾸려면 mongosh 또는 MongoDB 드라이버에서 MongoDB 배포에 연결하고 이 섹션의 예제를 따라 원하는 방법으로 진행하세요.

_id 필드를 제외한 문서의 전체 내용을 바꾸려면 완전히 새로운 문서를 두 번째 인수로 IMongoCollection.ReplaceOne()에 전달합니다.

문서를 바꿀 때 대체 문서는 필드/값 쌍으로만 구성되어야 합니다. 대체 문서에는 업데이트 연산자 표현식이 포함될 수 없습니다.

교체 문서는 원본 문서와 다른 필드를 가질 수 있습니다. 교체 문서에서 _id 필드는 변경되지 않으므로 _id 필드를 생략할 수 있습니다. 그러나 _id 필드를 포함하는 경우 현재 값과 동일한 값을 가져야 합니다.

다음 예시에서는 item: "paper"이 다음을 충족하는 inventory 컬렉션의 첫 번째 문서를 대체합니다.

_id 필드를 제외한 문서의 전체 내용을 바꾸려면 완전히 새로운 문서를 Collection.ReplaceOne.의 두 번째 인수로 전달합니다.

문서를 바꿀 때 대체 문서는 필드/값 쌍으로만 구성되어야 합니다. 대체 문서에는 업데이트 연산자 표현식이 포함될 수 없습니다.

교체 문서는 원본 문서와 다른 필드를 가질 수 있습니다. 교체 문서에서 _id 필드는 변경되지 않으므로 _id 필드를 생략할 수 있습니다. 그러나 _id 필드를 포함하는 경우 현재 값과 동일한 값을 가져야 합니다.

다음 예시에서는 item: "paper"이 다음을 충족하는 inventory 컬렉션의 첫 번째 문서를 대체합니다.

_id 필드를 제외한 문서의 전체 내용을 바꾸려면 완전히 새로운 문서를 com.mongodb.reactivestreams.client.MongoCollection.replaceOne의 두 번째 인수로 전달합니다.

문서를 바꿀 때 대체 문서는 필드/값 쌍으로만 구성되어야 합니다. 대체 문서에는 업데이트 연산자 표현식이 포함될 수 없습니다.

교체 문서는 원본 문서와 다른 필드를 가질 수 있습니다. 교체 문서에서 _id 필드는 변경되지 않으므로 _id 필드를 생략할 수 있습니다. 그러나 _id 필드를 포함하는 경우 현재 값과 동일한 값을 가져야 합니다.

다음 예시에서는 item: "paper"이 다음을 충족하는 inventory 컬렉션의 첫 번째 문서를 대체합니다.

_id 필드를 제외한 문서의 전체 내용을 바꾸려면 완전히 새로운 문서를 com.mongodb.client.MongoCollection.replaceOne의 두 번째 인수로 전달합니다.

문서를 바꿀 때 대체 문서는 필드/값 쌍으로만 구성되어야 합니다. 대체 문서에는 업데이트 연산자 표현식이 포함될 수 없습니다.

교체 문서는 원본 문서와 다른 필드를 가질 수 있습니다. 교체 문서에서 _id 필드는 변경되지 않으므로 _id 필드를 생략할 수 있습니다. 그러나 _id 필드를 포함하는 경우 현재 값과 동일한 값을 가져야 합니다.

다음 예시에서는 item: "paper"이 다음을 충족하는 inventory 컬렉션의 첫 번째 문서를 대체합니다.

필드 를 제외한 문서 의 전체 내용을 바꾸려면 _id 완전히 새로운 문서 를 두 번째 인수로 MongoCollection.replaceOne() 메서드.

문서를 바꿀 때 대체 문서는 필드/값 쌍으로만 구성되어야 합니다. 대체 문서에는 업데이트 연산자 표현식이 포함될 수 없습니다.

교체 문서는 원본 문서와 다른 필드를 가질 수 있습니다. 교체 문서에서 _id 필드는 변경되지 않으므로 _id 필드를 생략할 수 있습니다. 그러나 _id 필드를 포함하는 경우 현재 값과 동일한 값을 가져야 합니다.

다음 예시에서는 item: "paper"이 다음을 충족하는 inventory 컬렉션의 첫 번째 문서를 대체합니다.

_id 필드를 제외한 문서의 전체 내용을 바꾸려면 완전히 새로운 문서를 replace_one.의 두 번째 인수로 전달합니다.

문서를 바꿀 때 대체 문서는 필드/값 쌍으로만 구성되어야 합니다. 대체 문서에는 업데이트 연산자 표현식이 포함될 수 없습니다.

교체 문서는 원본 문서와 다른 필드를 가질 수 있습니다. 교체 문서에서 _id 필드는 변경되지 않으므로 _id 필드를 생략할 수 있습니다. 그러나 _id 필드를 포함하는 경우 현재 값과 동일한 값을 가져야 합니다.

다음 예시에서는 item: "paper"이 다음을 충족하는 inventory 컬렉션의 첫 번째 문서를 대체합니다.

_id 필드를 제외한 문서의 전체 내용을 바꾸려면 완전히 새로운 문서를 Collection.replaceOne()의 두 번째 인수로 전달합니다.

문서를 바꿀 때 대체 문서는 필드/값 쌍으로만 구성되어야 합니다. 대체 문서에는 업데이트 연산자 표현식이 포함될 수 없습니다.

교체 문서는 원본 문서와 다른 필드를 가질 수 있습니다. 교체 문서에서 _id 필드는 변경되지 않으므로 _id 필드를 생략할 수 있습니다. 그러나 _id 필드를 포함하는 경우 현재 값과 동일한 값을 가져야 합니다.

다음 예시에서는 item: "paper"이 다음을 충족하는 inventory 컬렉션의 첫 번째 문서를 대체합니다.

_id 필드를 제외한 문서의 전체 내용을 바꾸려면 replace_one()의 두 번째 인수로 완전히 새로운 문서를 전달합니다.

문서를 바꿀 때 대체 문서는 필드/값 쌍으로만 구성되어야 합니다. 대체 문서에는 업데이트 연산자 표현식이 포함될 수 없습니다.

교체 문서는 원본 문서와 다른 필드를 가질 수 있습니다. 교체 문서에서 _id 필드는 변경되지 않으므로 _id 필드를 생략할 수 있습니다. 그러나 _id 필드를 포함하는 경우 현재 값과 동일한 값을 가져야 합니다.

다음 예시에서는 item: "paper"이 다음을 충족하는 inventory 컬렉션의 첫 번째 문서를 대체합니다.

_id 필드를 제외한 문서의 전체 내용을 교체하려면 replaceOne()에 완전히 새로운 문서를 두 번째 인수로 전달합니다.

문서를 바꿀 때 대체 문서는 필드/값 쌍으로만 구성되어야 합니다. 대체 문서에는 업데이트 연산자 표현식이 포함될 수 없습니다.

교체 문서는 원본 문서와 다른 필드를 가질 수 있습니다. 교체 문서에서 _id 필드는 변경되지 않으므로 _id 필드를 생략할 수 있습니다. 그러나 _id 필드를 포함하는 경우 현재 값과 동일한 값을 가져야 합니다.

다음 예시에서는 item: "paper"이 다음을 충족하는 inventory 컬렉션의 첫 번째 문서를 대체합니다.

_id 필드를 제외한 문서의 전체 내용을 바꾸려면 완전히 새로운 문서를 replace_one.의 두 번째 인수로 전달합니다.

문서를 바꿀 때 대체 문서는 필드/값 쌍으로만 구성되어야 합니다. 대체 문서에는 업데이트 연산자 표현식이 포함될 수 없습니다.

교체 문서는 원본 문서와 다른 필드를 가질 수 있습니다. 교체 문서에서 _id 필드는 변경되지 않으므로 _id 필드를 생략할 수 있습니다. 그러나 _id 필드를 포함하는 경우 현재 값과 동일한 값을 가져야 합니다.

다음 예시에서는 item: "paper"이 다음을 충족하는 inventory 컬렉션의 첫 번째 문서를 대체합니다.

_id 필드를 제외한 문서의 전체 내용을 바꾸려면 replace_one()의 두 번째 인수로 완전히 새로운 문서를 전달합니다.

문서를 바꿀 때 대체 문서는 필드/값 쌍으로만 구성되어야 합니다. 대체 문서에는 업데이트 연산자 표현식이 포함될 수 없습니다.

교체 문서는 원본 문서와 다른 필드를 가질 수 있습니다. 교체 문서에서 _id 필드는 변경되지 않으므로 _id 필드를 생략할 수 있습니다. 그러나 _id 필드를 포함하는 경우 현재 값과 동일한 값을 가져야 합니다.

다음 예시에서는 item: "paper"이 다음을 충족하는 inventory 컬렉션의 첫 번째 문서를 대체합니다.

문서의 전체 내용을 _id 필드를 제외하고 교체하려면, replaceOne()의 두 번째 인수로 완전히 새로운 문서를 전달하세요.

문서를 바꿀 때 대체 문서는 필드/값 쌍으로만 구성되어야 합니다. 대체 문서에는 업데이트 연산자 표현식이 포함될 수 없습니다.

교체 문서는 원본 문서와 다른 필드를 가질 수 있습니다. 교체 문서에서 _id 필드는 변경되지 않으므로 _id 필드를 생략할 수 있습니다. 그러나 _id 필드를 포함하는 경우 현재 값과 동일한 값을 가져야 합니다.

다음 예시에서는 item: "paper"이 다음을 충족하는 inventory 컬렉션의 첫 번째 문서를 대체합니다.

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;
}

다음 메서드를 적절히 호출하여 열려 있는 리소스도 정리해야 합니다.

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()

MongoDB Atlas로 문서 업데이트하기

참고

MongoDB Atlas UI에서는 한 번에 하나의 문서만 업데이트할 수 있습니다. 여러 문서를 업데이트하거나 전체 문서를 바꾸려면 mongosh 또는 MongoDB 드라이버에서 Atlas 배포에 연결하고 이 페이지의 예시를 따라 원하는 방법을 수행합니다.

이 섹션의 예시에서는 샘플 소모품 데이터 세트를 사용합니다. MongoDB Atlas 배포서버에 샘플 데이터세트를 로드하는 방법을 알아보려면 샘플 데이터 로드를 참조하세요.

MongoDB Atlas에서 문서를 업데이트하려면 다음 단계에 따릅니다.

1

MongoDB Atlas UI 에서 Clusters 프로젝트 의 페이지로 이동합니다.

  1. 아직 표시되지 않은 경우 탐색 표시줄의 Organizations 메뉴에서 원하는 프로젝트가 포함된 조직을 선택합니다.

  2. 아직 표시되지 않은 경우 내비게이션 바의 Projects 메뉴에서 프로젝트를 선택합니다.

  3. 아직 표시되지 않은 경우 사이드바에서 Clusters 을(를) 클릭합니다.

    Clusters(클러스터) 페이지가 표시됩니다.

2

컬렉션으로 이동합니다.

  1. 샘플 데이터가 포함된 클러스터의 경우 Browse Collections 을 클릭합니다.

  2. 왼쪽 탐색 창에서 sample_supplies 데이터베이스를 선택합니다.

  3. sales 컬렉션을 선택합니다.

3

쿼리 필터 문서를 지정합니다.

Filter 필드에 쿼리 필터 문서를 지정할 수 있습니다. 쿼리 필터 문서는 쿼리 연산자를 사용하여 검색 조건을 지정합니다.

다음 쿼리 필터 문서를 Filter 검색 바에 복사하고 Apply를 클릭합니다.

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

이 쿼리 필터는 sample_supplies.sales 컬렉션의 모든 문서 중 saleDate 이 2016년 1월 1일과 2일(UTC 기준)에 있는 문서를 반환합니다.

4

Edit a document.

쿼리 결과에 표시된 문서를 수정하려면 문서 위에 마우스를 올린 후 연필 아이콘을 클릭합니다. 문서 편집기에서 다음을 실행할 수 있습니다.

  • 새 필드를 추가합니다.

  • 기존 필드를 삭제합니다.

  • 필드의 이름, 값 또는 유형을 편집합니다.

  • 특정 변경 사항을 되돌립니다.

자세한 지침은 문서 생성, 보기, 업데이트 및 삭제를 참조하세요.

5

변경 사항을 저장하세요.

변경 사항을 확인하고 저장하려면 Update 버튼을 클릭합니다.

행동

원자성

MongoDB의 모든 쓰기 작업은 단일 문서 수준에서 원자적으로 이루어집니다. MongoDB 및 원자성에 대한 자세한 내용은 원자성 및 트랜잭션에서 확인 가능합니다.

_id 필드

설정한 후에는 _id 필드 값을 업데이트할 수 없으며 기존 문서를 _id 필드 값이 문서로 대체할 수 없습니다.

필드 순서

쓰기 조작의 경우 MongoDB는 다음과 같은 경우를 제외하고 문서 필드의 순서를 유지합니다.

  • _id 필드는 항상 문서에서 첫 번째 필드입니다.

  • renaming개의 필드 이름이 포함된 업데이트는 문서에서 필드의 순서를 변경할 수 있습니다.

업서트 옵션

updateOne(), updateMany() 또는 replaceOne()에 upsert : true가 포함되어 있고 동시에 지정된 필터와 일치하는 문서가 없는 경우, 새 문서를 만들어 삽입하는 작업을 수행합니다. 일치하는 문서가 있는 경우 작업은 일치하는 문서를 수정하거나 대체합니다.

생성된 새 문서에 대한 자세한 내용은 해당 메서드에 대한 개별 레퍼런스 페이지를 참조하세요.

업서트 옵션은 MongoDB Compass를 통해 사용할 수 없습니다.

UpdateOne(), UpdateMany() 또는 ReplaceOne() 에 IsUpsert 옵션이 true로 설정된 UpdateOptions 인수 인스턴스가 포함되어 있고 지정된 필터와 일치하는 문서가 없는 경우 작업은 새 문서를 만들고 삽입합니다. 일치하는 문서가 있는 경우 작업은 일치하는 문서를 수정하거나 대체합니다.

생성된 새 문서에 대한 자세한 내용은 해당 메서드에 대한 개별 레퍼런스 페이지를 참조하세요.

Collection.UpdateOne에 업서트 옵션이 참으로 설정되어 있고 그리고 지정한 것과 일치하는 문서가 없는 경우 필터를 적용하면 작업이 새 문서를 만들어 삽입합니다. 일치하는 문서가 있는 경우 작업은 일치하는 문서를 수정하거나 대체합니다.

생성된 새 문서에 대한 자세한 내용은 해당 메서드에 대한 개별 레퍼런스 페이지를 참조하세요.

업데이트 및 교체 메서드에 UpdateOptions.upsert(true)를 지정하는 UpdateOptions 매개변수가 포함되어 있고 동시에 지정된 필터와 일치하는 문서가 없는 경우 작업은 새 문서를 만들고 삽입합니다. 일치하는 문서가 있는 경우 작업은 일치하는 문서를 수정하거나 대체합니다.

생성된 새 문서에 대한 자세한 내용은 해당 메서드에 대한 개별 레퍼런스 페이지를 참조하세요.

업데이트 및 교체 메서드에 com.mongodb.client.model.UpdateOptions.upsert(true)를 지정하는 com.mongodb.client.model.UpdateOptions 매개변수가 포함되어 있고 동시에 지정된 필터와 일치하는 문서가 없으면 작업에서 새 문서를 만들고 삽입합니다. 일치하는 문서가 있는 경우 작업은 일치하는 문서를 수정하거나 대체합니다.

생성된 새 문서에 대한 자세한 내용은 해당 메서드에 대한 개별 레퍼런스 페이지를 참조하세요.

업데이트 및 바꾸기 메서드에 com.mongodb가 포함된 경우. 클라이언트.model.UpdateOptions 를 upsert(true)지정하는 매개 변수 이고 지정된 필터하다 와 일치하는 문서가없는 경우 작업은 새 문서 를 만들고 삽입합니다. 일치하는 문서가 있는 경우 작업은 일치하는 문서 를 수정하거나 대체합니다.

생성된 새 문서에 대한 자세한 내용은 해당 메서드에 대한 개별 레퍼런스 페이지를 참조하세요.

update_one, update_many 또는 replace_one에 upsert : true이(가) 포함되어 있고 동시에 지정된 필터와 일치하는 문서가 없는 경우, 새 문서를 만들어 삽입하는 작업을 수행합니다. 일치하는 문서가 있는 경우 작업은 일치하는 문서를 수정하거나 대체합니다.

생성된 새 문서에 대한 자세한 내용은 해당 메서드에 대한 개별 레퍼런스 페이지를 참조하세요.

options 매개변수 문서에서 updateOne(), updateMany() 또는 replaceOne()이 upsert : true을(를) 포함하고 동시에 지정된 필터와 일치하는 문서가 없는 경우 이 작업은 새 문서를 생성하여 삽입합니다. 일치하는 문서가 있는 경우 작업은 일치하는 문서를 수정하거나 대체합니다.

생성된 새 문서에 대한 자세한 내용은 해당 메서드에 대한 개별 레퍼런스 페이지를 참조하세요.

update_one(), update_many() 또는 replace_one()에 upsert => true가 포함되어 있고 지정된 필터와 일치하는 문서가 없는 경우 작업은 새 문서를 생성하여 삽입합니다. 일치하는 문서가 있는 경우 작업은 일치하는 문서를 수정하거나 대체합니다.

생성된 새 문서에 대한 자세한 내용은 해당 메서드에 대한 개별 레퍼런스 페이지를 참조하세요.

updateOne(), updateMany() 또는 replaceOne()에 upsert => true가 포함되어 있고 지정된 필터와 일치하는 문서가 없으면 이 작업은 새로운 문서를 생성하고 삽입합니다. 일치하는 문서가 있는 경우 작업은 일치하는 문서를 수정하거나 대체합니다.

생성된 새 문서에 대한 자세한 내용은 해당 메서드에 대한 개별 레퍼런스 페이지를 참조하세요.

update_one, update_many 또는 replace_one에 upsert : true이(가) 포함되어 있고 동시에 지정된 필터와 일치하는 문서가 없는 경우, 새 문서를 만들어 삽입하는 작업을 수행합니다. 일치하는 문서가 있는 경우 작업은 일치하는 문서를 수정하거나 대체합니다.

생성된 새 문서에 대한 자세한 내용은 해당 메서드에 대한 개별 레퍼런스 페이지를 참조하세요.

update_one(), update_many() 또는 replace_one()에 upsert => true가 포함되어 있고 또한 지정된 필터와 일치하는 문서가 없으면 작업은 새 문서를 생성하여 삽입합니다. 일치하는 문서가 있는 경우 작업은 일치하는 문서를 수정하거나 대체합니다.

생성된 새 문서에 대한 자세한 내용은 해당 메서드에 대한 개별 레퍼런스 페이지를 참조하세요.

updateOne(), updateMany() 또는 replaceOne()에 upsert => true가 포함되어 있고 지정된 필터와 일치하는 문서가 없는 경우 작업은 새 문서를 생성하여 삽입합니다. 일치하는 문서가 있는 경우 작업은 일치하는 문서를 수정하거나 대체합니다.

생성된 새 문서에 대한 자세한 내용은 해당 메서드에 대한 개별 레퍼런스 페이지를 참조하세요.

쓰기 승인

쓰기 고려를 사용하여 MongoDB에서 쓰기 작업에 요청한 승인 수준을 지정할 수 있습니다. 자세한 내용은 쓰기 고려를 참조하세요.

팁

다음도 참조하세요.

팁

다음도 참조하세요.

돌아가기

mongosh에서 커서 반복

다음

집계 파이프라인