문서 삭제

이 페이지의 내용

모든 문서 삭제

조건과 일치하는 모든 문서 삭제
조건과 일치하는 문서 하나만 삭제
MongoDB Atlas로 문서 삭제하기
동작 삭제

다음 방법을 사용하여 MongoDB에서 문서를 삭제할 수 있습니다.

프로그래밍 언어의 드라이버입니다.
MongoDB Atlas UI. 자세한 정보는 MongoDB Atlas로 문서 삭제하기에서 확인 가능합니다.
MongoDB Compass

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

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

이 페이지의 예시에서는 inventory 컬렉션을 사용합니다. inventory 컬렉션을 채우려면 다음을 실행하세요:

이 페이지에서는 MongoDB Compass를 사용하여 문서를 삭제합니다.

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: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { 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": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
    { "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" }
]

MongoDB Compass에서 문서를 삽입하는 방법은 문서 삽입하기를 참조하세요.

참고

MongoDB Compass에서 문서를 삽입하는 방법에 대한 자세한 내용은 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 ("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 ("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;
}
/* "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", "journal" },
        { "qty", 25 },
        { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } },
        { "status", "A" }
    },
    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" }
    }
};
collection.InsertMany(documents);

docs := []interface{}{
	bson.D{
		{"item", "journal"},
		{"qty", 25},
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	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"},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)

Publisher<Success> insertManyPublisher = collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
        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' }")
));

collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
        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' }")
));

collection.insertMany(
    listOf(
        Document("item", "journal")
            .append("qty", 25)
            .append("size", Document("h", 14).append("w", 21).append("uom", "cm"))
            .append("status", "A"),
        Document("item", "notebook")
            .append("qty", 50)
            .append("size", Document("h", 8.5).append("w", 11).append("uom", "in"))
            .append("status", "A"),
        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"),
    )
)

await db.inventory.insert_many(
    [
        {
            "item": "journal",
            "qty": 25,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "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",
        },
    ]
)

await db.collection('inventory').insertMany([
  {
    item: 'journal',
    qty: 25,
    size: { h: 14, w: 21, uom: 'cm' },
    status: 'A'
  },
  {
    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'
  }
]);

$db->coll("inventory")->insert_many(
    [
        {
            item   => "journal",
            qty    => 25,
            size   => { h => 14, w => 21, uom => "cm" },
            status => "A"
        },
        {
            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"
        }
    ]
);

$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'journal',
        'qty' => 25,
        'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        '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',
    ],
]);

db.inventory.insert_many(
    [
        {
            "item": "journal",
            "qty": 25,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "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",
        },
    ]
)

client[:inventory].insert_many([
                                { item: 'journal',
                                  qty: 25,
                                  size: { h: 14, w: 21, uom: 'cm' },
                                  status: 'A' },
                                { 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' },
                               ])

collection.insertMany(Seq(
  Document("""{ item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" }"""),
  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" }""")
)).execute()

모든 문서 삭제

컬렉션에서 모든 문서를 삭제하려면 빈 필터 문서 {}를 db.collection.deleteMany() 메서드에 전달합니다.

다음 예에서는 inventory 컬렉션에서 전체 문서를 삭제합니다.

컬렉션 에서 모든 문서를 삭제 하려면 mongoc_collection_t 및 bson_t 모든 문서를 mongoc_collection_delete_many 메서드.

다음 예에서는 inventory 컬렉션에서 전체 문서를 삭제합니다.

컬렉션에서 모든 문서를 삭제하려면 빈 필터 Builders<BsonDocument>.Filter.Empty을(를) IMongoCollection.DeleteMany() 메서드에 전달합니다.

다음 예에서는 inventory 컬렉션에서 전체 문서를 삭제합니다.

컬렉션에서 모든 문서를 삭제하려면 빈 필터 문서를 Collection.DeleteMany 함수에 전달합니다.

다음 예에서는 inventory 컬렉션에서 전체 문서를 삭제합니다.

컬렉션에서 모든 문서를 삭제하려면 빈 org.bson.Document 객체를 필터로 com.mongodb.reactivestreams.client.MongoCollection.deleteMany 메서드에 전달합니다.

다음 예에서는 inventory 컬렉션에서 전체 문서를 삭제합니다.

컬렉션에서 모든 문서를 삭제하려면 빈 org.bson.Document 객체를 필터로 com.mongodb.client.MongoCollection.deleteMany 메서드에 전달합니다.

다음 예에서는 inventory 컬렉션에서 전체 문서를 삭제합니다.

컬렉션 에서 모든 문서를 Bson 삭제 하려면 빈 객체 를 필터하다 로 전달하여 MongoCollection.deleteMany() 메서드.

다음 예에서는 inventory 컬렉션에서 전체 문서를 삭제합니다.

컬렉션에서 모든 문서를 삭제하려면 빈 필터 문서 {}를 motor.motor_asyncio.AsyncIOMotorCollection.delete_many 메서드에 전달합니다.

다음 예에서는 inventory 컬렉션에서 전체 문서를 삭제합니다.

컬렉션에서 모든 문서를 삭제하려면 빈 필터 문서 {}를 Collection.deleteMany() 메서드에 전달합니다.

다음 예에서는 inventory 컬렉션에서 전체 문서를 삭제합니다.

컬렉션에서 모든 문서를 삭제하려면 빈 필터 문서 {}를 MongoDB::Collection::delete_many() 메서드에 전달합니다.

다음 예에서는 inventory 컬렉션에서 전체 문서를 삭제합니다.

컬렉션에서 모든 문서를 삭제하려면 빈 필터 문서 []을(를) MongoDB\\Collection::deleteMany() 메서드에 전달합니다.

다음 예에서는 inventory 컬렉션에서 전체 문서를 삭제합니다.

컬렉션에서 모든 문서를 삭제하려면 빈 필터 문서 {}를 pymongo.collection.Collection.delete_many 메서드에 전달합니다.

다음 예에서는 inventory 컬렉션에서 전체 문서를 삭제합니다.

컬렉션에서 모든 문서를 삭제하려면 빈 필터 문서 {}를 Mongo::Collection#delete_many() 메서드에 전달합니다.

다음 예에서는 inventory 컬렉션에서 전체 문서를 삭제합니다.

컬렉션에서 모든 문서를 삭제하려면 collection.deleteMany() 메서드에 빈 필터 Document() 를 전달합니다.

다음 예에서는 inventory 컬렉션에서 전체 문서를 삭제합니다.

db.inventory.deleteMany({})

mongoc_collection_t *collection;
bson_t *selector;
bool r;
bson_error_t error;
collection = mongoc_database_get_collection (db, "inventory");
selector = BCON_NEW (NULL);
r = mongoc_collection_delete_many (collection, selector, NULL, NULL, &error);
bson_destroy (selector);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}

var filter = Builders<BsonDocument>.Filter.Empty;
var result = collection.DeleteMany(filter);

result, err := coll.DeleteMany(context.TODO(), bson.D{})

Publisher<DeleteResult> deleteManyPublisher = collection.deleteMany(new Document());

collection.deleteMany(new Document());

collection.deleteMany(empty())

await db.inventory.delete_many({})

await db.collection('inventory').deleteMany({});

$db->coll("inventory")->delete_many( {} );

$deleteResult = $db->inventory->deleteMany([]);

db.inventory.delete_many({})

client[:inventory].delete_many({})

collection.deleteMany(Document()).execute()

이 메서드는 작업 상태와 함께 문서를 반환합니다. 자세한 내용과 예시는 deleteMany()를 참조하세요.

mongoc_collection_delete_many 메서드는 성공적인 true 하면 false 를 반환하고, 유효하지 않은 인수가 있거나 서버 또는 네트워크 오류가 발생하면 를 반환하고 오류를 설정합니다.

성공적으로 실행되면 IMongoCollection.DeleteMany() 메서드는 DeletedCount 속성에 필터와 일치하는 문서 수가 포함된 DeleteResult 인스턴스를 반환합니다.

성공적으로 실행되면 Collection.DeleteMany 함수는 DeletedCount 속성에 필터와 일치하는 문서 수가 포함된 DeleteResult 인스턴스를 반환합니다.

com.mongodb.reactivestreams.client.MongoCollection.deleteMany는 성공 시 com.mongodb.client.result.DeleteResult 유형의 Publisher 객체를 반환합니다. 실패하면 com.mongodb.MongoException의 인스턴스를 반환합니다.

com.mongodb.client.MongoCollection.deleteMany 메서드는 com.mongodb.client.result.DeleteResult의 인스턴스를 작업 상태와 함께 반환합니다.

MongoCollection.deleteMany() 메서드는 com.mongodb 의 인스턴스 를 반환합니다. 클라이언트.result.DeleteResult 작업 상태와 삭제된 문서 수를 설명합니다.

delete_many 코루틴은 비동기식으로 pymongo.results.DeleteResult의 인스턴스를 작업 상태와 함께 반환합니다.

deleteMany()는 result을(를) 제공하는 프로미스를 반환합니다. result.deletedCount 속성에는 필터와 일치하는 문서 수가 포함되어 있습니다.

성공적으로 실행되면 delete_many() 메서드는 deleted_count 속성에 필터와 일치하는 문서 수가 포함된 MongoDB::DeleteResult의 인스턴스를 반환합니다.

성공적으로 실행되면 deleteMany() 메서드는 MongoDB\\DeleteResult의 인스턴스를 반환하고, 이 인스턴스의 getDeletedCount() 메서드는 필터와 일치하는 문서의 수를 반환합니다.

delete_many 메서드는 pymongo.results.DeleteResult의 인스턴스를 작업 상태와 함께 반환합니다.

성공적으로 실행되면 delete_many() 메서드는 deleted_count 속성에 필터와 일치하는 문서 수가 포함된 Mongo::Operation::Result 인스턴스를 반환합니다.

성공적으로 실행되면 collection.deleteMany() 메서드는 DeleteResult 유형 매개변수 또는 com.mongodb.MongoException이 포함된 단일 요소와 함께 Observable을 반환합니다.

조건과 일치하는 모든 문서 삭제

제거할 문서를 식별하는 기준 또는 필터를 지정할 수 있습니다. 필터는 읽기 작업과 동일한 구문을 사용합니다.

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동등 조건을 지정하려면 Eq 메서드를 사용하여 필터를 구성합니다.

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

동등 조건을 지정하려면 com.mongodb.Client.Model.Filters.eq 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동등 조건을 지정하려면 Filters.eq() 메서드를 사용하여 쿼리 필터하다 문서 를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

[ <field1> => <value1>, ... ]

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

MongoDB는 동등 필터 외에도 필터 조건을 지정하기 위한 다양한 쿼리 연산자를 제공합니다. FilterDefinitionBuilder 메서드를 사용하여 필터 문서를 만듭니다. 예시:

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

MongoDB는 동등 조건 외에도 필터 조건을 지정하기 위한 다양한 쿼리 연산자를 제공합니다. com.mongodb.client.model.Filters 헬퍼 메서드를 사용하여 필터 문서를 쉽게 만들 수 있습니다. 예시:

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

[ <field1> => [ <operator1> => <value1> ], ... ]

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

MongoDB는 동등 조건 외에도 필터 조건을 지정하기 위한 다양한 쿼리 연산자를 제공합니다. com.mongodb.client.model.Filters_ 헬퍼 메서드를 사용하여 필터 문서를 쉽게 만들 수 있습니다. 예시:

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

삭제 기준과 일치하는 모든 문서를 삭제하려면 필터 매개 변수를 deleteMany() 메서드에 전달하세요.

다음 예에서는 inventory컬렉션 내 status 필드가 "A"인 모든 문서를 제거합니다.

제거할 문서를 식별하는 기준 또는 필터를 지정할 수 있습니다. 필터는 읽기 작업과 동일한 구문을 사용합니다.

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동등 조건을 지정하려면 Eq 메서드를 사용하여 필터를 구성합니다.

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

동등 조건을 지정하려면 com.mongodb.Client.Model.Filters.eq 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동등 조건을 지정하려면 Filters.eq() 메서드를 사용하여 쿼리 필터하다 문서 를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

[ <field1> => <value1>, ... ]

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

[ <field1> => [ <operator1> => <value1> ], ... ]

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

삭제 기준과 일치하는 모든 문서를 삭제 하려면 mongoc_collection_t 및 bson_t 삭제할 문서와 일치하는 mongoc_collection_delete_many 메서드.

제거할 문서를 식별하는 기준 또는 필터를 지정할 수 있습니다. 필터는 읽기 작업과 동일한 구문을 사용합니다.

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동등 조건을 지정하려면 Eq 메서드를 사용하여 필터를 구성합니다.

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

동등 조건을 지정하려면 com.mongodb.Client.Model.Filters.eq 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동등 조건을 지정하려면 Filters.eq() 메서드를 사용하여 쿼리 필터하다 문서 를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

[ <field1> => <value1>, ... ]

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

[ <field1> => [ <operator1> => <value1> ], ... ]

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

삭제 기준과 일치하는 모든 문서를 삭제하려면 필터 매개변수를 IMongoCollection.DeleteMany() 메서드에 전달합니다.

다음 예에서는 inventory컬렉션 내 status 필드가 "A"인 모든 문서를 제거합니다.

제거할 문서를 식별하는 기준 또는 필터를 지정할 수 있습니다. 필터는 읽기 작업과 동일한 구문을 사용합니다.

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동등 조건을 지정하려면 Eq 메서드를 사용하여 필터를 구성합니다.

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

동등 조건을 지정하려면 com.mongodb.Client.Model.Filters.eq 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동등 조건을 지정하려면 Filters.eq() 메서드를 사용하여 쿼리 필터하다 문서 를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

[ <field1> => <value1>, ... ]

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

[ <field1> => [ <operator1> => <value1> ], ... ]

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

삭제 기준과 일치하는 모든 문서를 삭제하려면 필터 매개변수를 Collection.DeleteMany 함수에 전달하세요.

다음 예에서는 inventory컬렉션 내 status 필드가 "A"인 모든 문서를 제거합니다.

제거할 문서를 식별하는 기준 또는 필터를 지정할 수 있습니다. 필터는 읽기 작업과 동일한 구문을 사용합니다.

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동등 조건을 지정하려면 Eq 메서드를 사용하여 필터를 구성합니다.

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

동등 조건을 지정하려면 com.mongodb.Client.Model.Filters.eq 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동등 조건을 지정하려면 Filters.eq() 메서드를 사용하여 쿼리 필터하다 문서 를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

[ <field1> => <value1>, ... ]

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

[ <field1> => [ <operator1> => <value1> ], ... ]

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

삭제 기준과 일치하는 모든 문서를 삭제하려면 com.mongodb.reactivestreams.client.MongoCollection.deleteMany 메서드에 필터 매개변수를 전달합니다.

다음 예에서는 inventory컬렉션 내 status 필드가 "A"인 모든 문서를 제거합니다.

제거할 문서를 식별하는 기준 또는 필터를 지정할 수 있습니다. 필터는 읽기 작업과 동일한 구문을 사용합니다.

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동등 조건을 지정하려면 Eq 메서드를 사용하여 필터를 구성합니다.

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

동등 조건을 지정하려면 com.mongodb.Client.Model.Filters.eq 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동등 조건을 지정하려면 Filters.eq() 메서드를 사용하여 쿼리 필터하다 문서 를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

[ <field1> => <value1>, ... ]

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

[ <field1> => [ <operator1> => <value1> ], ... ]

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

삭제 기준과 일치하는 모든 문서를 삭제하려면 필터 매개변수를 com.mongodb.client.MongoCollection.deleteMany 메서드에 전달합니다.

다음 예에서는 inventory컬렉션 내 status 필드가 "A"인 모든 문서를 제거합니다.

제거할 문서를 식별하는 기준 또는 필터를 지정할 수 있습니다. 필터는 읽기 작업과 동일한 구문을 사용합니다.

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동등 조건을 지정하려면 Eq 메서드를 사용하여 필터를 구성합니다.

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

동등 조건을 지정하려면 com.mongodb.Client.Model.Filters.eq 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동등 조건을 지정하려면 Filters.eq() 메서드를 사용하여 쿼리 필터하다 문서 를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

[ <field1> => <value1>, ... ]

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

[ <field1> => [ <operator1> => <value1> ], ... ]

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

삭제 기준과 일치하는 모든 문서를 삭제 하려면 MongoCollection.deleteMany() 메서드.

다음 예에서는 inventory컬렉션 내 status 필드가 "A"인 모든 문서를 제거합니다.

제거할 문서를 식별하는 기준 또는 필터를 지정할 수 있습니다. 필터는 읽기 작업과 동일한 구문을 사용합니다.

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동등 조건을 지정하려면 Eq 메서드를 사용하여 필터를 구성합니다.

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

동등 조건을 지정하려면 com.mongodb.Client.Model.Filters.eq 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동등 조건을 지정하려면 Filters.eq() 메서드를 사용하여 쿼리 필터하다 문서 를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

[ <field1> => <value1>, ... ]

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

[ <field1> => [ <operator1> => <value1> ], ... ]

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

삭제 기준과 일치하는 모든 문서를 삭제하려면 delete_many 메서드에 필터 매개변수를 전달합니다.

다음 예에서는 inventory컬렉션 내 status 필드가 "A"인 모든 문서를 제거합니다.

제거할 문서를 식별하는 기준 또는 필터를 지정할 수 있습니다. 필터는 읽기 작업과 동일한 구문을 사용합니다.

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동등 조건을 지정하려면 Eq 메서드를 사용하여 필터를 구성합니다.

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

동등 조건을 지정하려면 com.mongodb.Client.Model.Filters.eq 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동등 조건을 지정하려면 Filters.eq() 메서드를 사용하여 쿼리 필터하다 문서 를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

[ <field1> => <value1>, ... ]

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

[ <field1> => [ <operator1> => <value1> ], ... ]

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

삭제 기준과 일치하는 모든 문서를 삭제하려면 deleteMany() 메서드에 필터 매개변수를 전달합니다.

다음 예에서는 inventory컬렉션 내 status 필드가 "A"인 모든 문서를 제거합니다.

제거할 문서를 식별하는 기준 또는 필터를 지정할 수 있습니다. 필터는 읽기 작업과 동일한 구문을 사용합니다.

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동등 조건을 지정하려면 Eq 메서드를 사용하여 필터를 구성합니다.

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

동등 조건을 지정하려면 com.mongodb.Client.Model.Filters.eq 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동등 조건을 지정하려면 Filters.eq() 메서드를 사용하여 쿼리 필터하다 문서 를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

[ <field1> => <value1>, ... ]

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

[ <field1> => [ <operator1> => <value1> ], ... ]

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

삭제 기준과 일치하는 모든 문서를 삭제하려면 delete_many() 메서드에 필터 매개변수를 전달합니다.

다음 예에서는 inventory컬렉션 내 status 필드가 "A"인 모든 문서를 제거합니다.

제거할 문서를 식별하는 기준 또는 필터를 지정할 수 있습니다. 필터는 읽기 작업과 동일한 구문을 사용합니다.

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동등 조건을 지정하려면 Eq 메서드를 사용하여 필터를 구성합니다.

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

동등 조건을 지정하려면 com.mongodb.Client.Model.Filters.eq 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동등 조건을 지정하려면 Filters.eq() 메서드를 사용하여 쿼리 필터하다 문서 를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

[ <field1> => <value1>, ... ]

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

[ <field1> => [ <operator1> => <value1> ], ... ]

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

삭제 기준과 일치하는 모든 문서를 삭제하려면 필터 매개변수를 deleteMany() 메서드에 전달합니다.

다음 예에서는 inventory컬렉션 내 status 필드가 "A"인 모든 문서를 제거합니다.

제거할 문서를 식별하는 기준 또는 필터를 지정할 수 있습니다. 필터는 읽기 작업과 동일한 구문을 사용합니다.

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동등 조건을 지정하려면 Eq 메서드를 사용하여 필터를 구성합니다.

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

동등 조건을 지정하려면 com.mongodb.Client.Model.Filters.eq 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동등 조건을 지정하려면 Filters.eq() 메서드를 사용하여 쿼리 필터하다 문서 를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

[ <field1> => <value1>, ... ]

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

[ <field1> => [ <operator1> => <value1> ], ... ]

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

삭제 기준과 일치하는 모든 문서를 삭제하려면 delete_many 메서드에 필터 매개변수를 전달합니다.

다음 예에서는 inventory컬렉션 내 status 필드가 "A"인 모든 문서를 제거합니다.

제거할 문서를 식별하는 기준 또는 필터를 지정할 수 있습니다. 필터는 읽기 작업과 동일한 구문을 사용합니다.

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동등 조건을 지정하려면 Eq 메서드를 사용하여 필터를 구성합니다.

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

동등 조건을 지정하려면 com.mongodb.Client.Model.Filters.eq 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동등 조건을 지정하려면 Filters.eq() 메서드를 사용하여 쿼리 필터하다 문서 를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

[ <field1> => <value1>, ... ]

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

[ <field1> => [ <operator1> => <value1> ], ... ]

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

삭제 기준과 일치하는 모든 문서를 삭제하려면 delete_many() 메서드에 필터 매개변수를 전달합니다.

다음 예에서는 inventory컬렉션 내 status 필드가 "A"인 모든 문서를 제거합니다.

제거할 문서를 식별하는 기준 또는 필터를 지정할 수 있습니다. 필터는 읽기 작업과 동일한 구문을 사용합니다.

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동등 조건을 지정하려면 Eq 메서드를 사용하여 필터를 구성합니다.

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

동등 조건을 지정하려면 com.mongodb.Client.Model.Filters.eq 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동등 조건을 지정하려면 Filters.eq() 메서드를 사용하여 쿼리 필터하다 문서 를 만듭니다.

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

[ <field1> => <value1>, ... ]

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field>:<value> 표현식을 사용하세요.

{ <field1>: <value1>, ... }

동일성 조건을 지정하려면 쿼리 필터 문서에서 <field> => <value> 표현식을 사용하세요.

{ <field1> => <value1>, ... }

동일성 조건을 지정하려면 com.mongodb.client.model.Filters.eq_ 메서드를 사용하여 쿼리 필터 문서를 만듭니다.

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

[ <field1> => [ <operator1> => <value1> ], ... ]

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1>: { <operator1>: <value1> }, ... }

쿼리 필터 문서에서는 쿼리 연산자를 사용하여 다음 형식의 조건을 지정할 수 있습니다.

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

삭제 기준과 일치하는 모든 문서를 삭제하려면 deleteMany() 메서드에 필터 매개변수를 전달합니다.

다음 예에서는 inventory컬렉션 내 status 필드가 "A"인 모든 문서를 제거합니다.

db.inventory.deleteMany({ status : "A" })

mongoc_collection_t *collection;
bson_t *selector;
bool r;
bson_error_t error;
collection = mongoc_database_get_collection (db, "inventory");
selector = BCON_NEW ("status", BCON_UTF8 ("A"));
r = mongoc_collection_delete_many (collection, selector, NULL, NULL, &error);
bson_destroy (selector);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var result = collection.DeleteMany(filter);

result, err := coll.DeleteMany(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
)

deleteManyPublisher = collection.deleteMany(eq("status", "A"));

collection.deleteMany(eq("status", "A"));

collection.deleteMany(eq("status", "A"));

await db.inventory.delete_many({"status": "A"})

await db.collection('inventory').deleteMany({ status: 'A' });

$db->coll("inventory")->delete_many( { status => "A" } );

$deleteResult = $db->inventory->deleteMany(['status' => 'A']);

db.inventory.delete_many({"status": "A"})

client[:inventory].delete_many(status: 'A')

collection.deleteMany(equal("status", "A")).execute()

이 메서드는 작업 상태와 함께 문서를 반환합니다. 자세한 내용과 예시는 deleteMany()를 참조하세요.

성공적으로 실행되면 IMongoCollection.DeleteMany() 메서드는 DeletedCount 속성에 필터와 일치하는 문서 수가 포함된 DeleteResult 인스턴스를 반환합니다.

성공적으로 실행되면 Collection.DeleteMany 함수는 DeletedCount 속성에 필터와 일치하는 문서 수가 포함된 DeleteResult 인스턴스를 반환합니다.

com.mongodb.client.MongoCollection.deleteMany 메서드는 com.mongodb.client.result.DeleteResult의 인스턴스를 작업 상태와 함께 반환합니다.

MongoCollection.deleteMany() 메서드는 com.mongodb 의 인스턴스 를 반환합니다. 클라이언트.result.DeleteResult 작업 상태와 삭제된 문서 수를 설명합니다.

delete_many 코루틴은 비동기식으로 pymongo.results.DeleteResult의 인스턴스를 작업 상태와 함께 반환합니다.

deleteMany()는 result을(를) 제공하는 프로미스를 반환합니다. result.deletedCount 속성에는 필터와 일치하는 문서 수가 포함되어 있습니다.

성공적으로 실행되면 delete_many() 메서드는 deleted_count 속성에 필터와 일치하는 문서 수가 포함된 MongoDB::DeleteResult의 인스턴스를 반환합니다.

delete_many 메서드는 pymongo.results.DeleteResult의 인스턴스를 작업 상태와 함께 반환합니다.

성공적으로 실행되면 delete_many() 메서드는 deleted_count 속성에 필터와 일치하는 문서 수가 포함된 Mongo::Operation::Result 인스턴스를 반환합니다.

조건과 일치하는 문서 하나만 삭제

지정된 필터와 일치하는 문서를 하나만 삭제하려면(지정된 필터와 일치하는 문서가 여러 개인 경우에도) db.collection.deleteOne() 메서드를 사용합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

MongoDB Compass는 컬렉션에서 문서를 삭제하는 간단한 방법을 제공합니다. 다음 예시에서는 inventory 컬렉션에서 item이 paper인 문서를 삭제하는 방법을 보여 줍니다.

참고

이 예시에서는 Compass 테이블 보기를 사용하여 문서를 삭제합니다. Compass 목록 보기를 사용한 삭제 프로세스도 매우 유사한 접근 방식을 따릅니다.

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

컬렉션 에서 단일 문서 를 삭제 하려면 mongoc_collection_t 및 bson_t 삭제 하려는 문서 와 일치하는 mongoc_collection_delete_one 메서드.

다음 예에서는 inventory 컬렉션에서 전체 문서를 삭제합니다.

지정된 필터와 일치하는 문서를 하나만 삭제하려면(지정된 필터와 일치하는 문서가 여러 개일 수 있음에도 불구하고) IMongoCollection.DeleteOne() 메서드를 사용합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터와 일치하는 최대 단일 문서를 삭제하려면(여러 문서가 지정된 필터와 일치하더라도)Collection.DeleteOne 함수를 사용하세요.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터와 일치하는 문서를 하나만 삭제하려면(지정된 필터와 일치하는 문서가 여러 개일 수 있음에도 불구하고) com.mongodb.reactivestreams.client.MongoCollection.deleteMany 메서드를 사용하세요.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터와 일치하는 문서를 하나만 삭제하려면(지정된 필터와 일치하는 문서가 여러 개일 수 있음에도 불구하고) com.mongodb.client.MongoCollection.deleteOne 메서드를 사용하세요.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

여러 문서가 지정된 필터하다 와 일치하더라도 지정된 필터하다 와 일치하는 문서 를 하나만 삭제 하려면 MongoCollection.deleteOne() 메서드.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터와 일치하는 문서를 하나만 삭제하려면(지정된 필터와 일치하는 문서가 여러 개인 경우에도) motor.motor_asyncio.AsyncIOMotorCollection.delete_one 메서드를 사용합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터와 일치하는 문서를 하나만 삭제하려면(여러 문서가 지정된 필터와 일치할 수 있음에도 불구하고) Collection.deleteOne() 메서드를 사용합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

여러 문서가 지정된 필터와 일치하더라도 지정된 필터와 일치하는 문서를 최대 하나만 삭제하려면 MongoDB::Collection::delete_one() 메서드를 사용하세요.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터와 일치하는 문서가 여러 개더라도 그 중 하나만 삭제하려면 MongoDB\\Collection::deleteOne() 메서드를 사용하세요.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터와 일치하는 문서를 하나만 삭제하려면(지정된 필터와 일치하는 문서가 여러 개인 경우에도) pymongo.collection.Collection.delete_one 메서드를 사용합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

여러 문서가 지정된 필터와 일치하더라도 지정된 필터와 일치하는 문서를 최대 하나만 삭제하려면 Mongo::Collection#delete_one() 메서드를 사용하세요.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터와 일치하는 문서를 하나만 삭제하려면(여러 문서가 지정된 필터와 일치할 수 있음에도 불구하고) Collection.deleteOne() 메서드에 전달합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

db.inventory.deleteOne( { status: "D" } )

상단 내비게이션의 Table 버튼을 클릭하여 테이블 보기에 액세스하세요.
Compass 쿼리 막대를 사용하여 대상 문서를 찾습니다.
다음 필터 문서를 쿼리 표시줄에 복사하고 Find를 클릭합니다.
```
{ item: "paper" }
```
문서 위로 마우스를 가져간 다음 오른쪽에 표시되는 휴지통 아이콘을 클릭합니다.
삭제 버튼을 클릭하면 문서가 삭제 플래그가 지정되고 Compass에서 문서를 제거할 것인지 묻는 확인 메시지가 표시됩니다.
Delete를 클릭하여 확인합니다. Compass는 컬렉션에서 문서를 삭제합니다.

mongoc_collection_t *collection;
bson_t *selector;
bool r;
bson_error_t error;
collection = mongoc_database_get_collection (db, "inventory");
selector = BCON_NEW ("status", BCON_UTF8 ("D"));
r = mongoc_collection_delete_one (collection, selector, NULL, NULL, &error);
bson_destroy (selector);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}

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

var filter = Builders<BsonDocument>.Filter.Eq("status", "D");
var result = collection.DeleteOne(filter);

result, err := coll.DeleteOne(
	context.TODO(),
	bson.D{
		{"status", "D"},
	},
)

Publisher<DeleteResult> deleteOnePublisher = collection.deleteOne(eq("status", "D"));

collection.deleteOne(eq("status", "D"));

await db.inventory.delete_one({"status": "D"})

await db.collection('inventory').deleteOne({ status: 'D' });

$db->coll("inventory")->delete_one( { status => "D" } );

$deleteResult = $db->inventory->deleteOne(['status' => 'D']);

db.inventory.delete_one({"status": "D"})

client[:inventory].delete_one(status: 'D')

collection.deleteOne(equal("status", "D")).execute()

MongoDB Atlas로 문서 삭제하기

참고

MongoDB Atlas UI에서는 한 번에 하나의 문서만 삭제할 수 있습니다. 여러 문서를 삭제하려면 mongosh 또는 MongoDB 드라이버에서 Atlas 배포서버에 연결하고 이 페이지의 예시에 따라 원하는 메서드를 선택하세요.

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

다음 단계를 통해 MongoDB Atlas에서 문서를 삭제할 수 있습니다.

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

아직 표시되지 않은 경우 탐색 표시줄의 Organizations 메뉴에서 원하는 프로젝트가 포함된 조직을 선택합니다.
아직 표시되지 않은 경우 내비게이션 바의 Projects 메뉴에서 프로젝트를 선택합니다.
아직 표시되지 않은 경우 사이드바에서 Clusters 을(를) 클릭합니다.
Clusters(클러스터) 페이지가 표시됩니다.

컬렉션으로 이동합니다.

샘플 데이터가 포함된 클러스터의 경우 Browse Collections 을 클릭합니다.
왼쪽 탐색 창에서 sample_mflix 데이터베이스를 선택합니다.
movies 컬렉션을 선택합니다.

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

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

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

{ genres: "Action", rated: { $in: [ "PG", "PG-13" ] } }

이 쿼리 필터는 sample_mflix.movies 컬렉션에서 genres와 Action rated가 PG 또는 PG-13에 해당하는 모든 문서를 반환합니다.

문서를 삭제합니다.

문서를 삭제하려면 문서 위로 마우스를 가져간 다음 오른쪽에 나타나는 휴지통 아이콘을 클릭합니다.
삭제 버튼을 클릭하면 MongoDB Atlas는 문서에 삭제 플래그를 지정하고 확인을 요청합니다.
Delete을 클릭하여 선택을 확인합니다.

자세한 내용은 문서 생성, 보기, 업데이트 및 삭제에서 확인할 수 있습니다.

동작 삭제

Indexes

삭제 작업은 컬렉션에서 모든 문서를 삭제하더라도 인덱스를 제거하지 않습니다.

원자성

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

쓰기 승인

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

참고

모든 문서 삭제

조건과 일치하는 모든 문서 삭제

조건과 일치하는 문서 하나만 삭제

참고

MongoDB Atlas로 문서 삭제하기

참고

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

컬렉션으로 이동합니다.

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

문서를 삭제합니다.

동작 삭제

Indexes

원자성

쓰기 승인

팁

다음도 참조하세요.

팁

다음도 참조하세요.

팁

다음도 참조하세요.

팁

다음도 참조하세요.

팁

다음도 참조하세요.

팁

다음도 참조하세요.

팁

다음도 참조하세요.

팁

다음도 참조하세요.

팁

다음도 참조하세요.

팁

다음도 참조하세요.

팁

다음도 참조하세요.

팁

다음도 참조하세요.

팁

다음도 참조하세요.

팁

다음도 참조하세요.

팁

다음도 참조하세요.