문서 삭제

MongoDB에서 삭제 작업은 컬렉션에서 문서를 삭제하는 것으로 구성됩니다. 이 페이지에서는 예시를 제공합니다.

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

프로그래밍 언어의 드라이버입니다.
MongoDB Atlas UI. 자세한 학습 은 MongoDB Atlas 로 Null 또는 누락된 필드 쿼리를 참조하세요.
MongoDB Compass

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

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

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

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

inventory 컬렉션을 다음 문서로 채웁니다.

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

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

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

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

이 페이지에서는 다음과 같은 MongoDB 고 (Go) 드라이버 함수를 사용합니다.

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

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

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

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

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

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

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

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

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

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

이 페이지의 예시에서는 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 := []any{
	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'
  }
]);

$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 컬렉션에서 전체 문서를 삭제합니다.

컬렉션 에서 모든 문서를 삭제 하려면 Documents 탭 아래의 DELETE 버튼을 클릭합니다.

다음 예에서는 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에 전달합니다. 클라이언트.MongoCollection.deleteMany 메서드.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

다음 예에서는 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({});

$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. 클라이언트.MongoCollection.deleteMany는 com.mongodb 유형의 게시자 객체 반환합니다. 성공적인 하면 클라이언트 .result.DeleteResult 입니다. 실패하면 com.mongodb.MongoException 인스턴스 를 반환합니다.

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

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

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

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

성공적인 실행되면 delete_many() 메서드는 Mongo::Operation::Result의 인스턴스 를 반환하며, 이 인스턴스의 deleted_count 속성에는 필터하다 와 일치하는 문서 수가 포함되어 있습니다.

성공적인 으로 실행되면 컬렉션.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>);

동등 조건을 지정하려면 bson.D 유형을 사용하여 필터 문서를 만듭니다.

filter := bson.D{{"<field>", <value>}}

동등 조건을 지정하려면 com.mongodb를 사용하세요. 클라이언트.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>, ... }

동일성 조건을 지정하려면 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 동등 필터하다 외에도 필터하다 조건을 지정하는 다양한 쿼리 연산자를 제공합니다. BSON 패키지 사용하여 필터하다 문서에 대한 쿼리 연산자를 만듭니다. 예시 를 들면 다음과 같습니다.

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

MongoDB 동등 조건 외에도 필터하다 조건을 지정하는 다양한 쿼리 연산자를 제공합니다.com.mongodb를 사용합니다. 클라이언트.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> }, ... }

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

동등 조건을 지정하려면 bson.D 유형을 사용하여 필터 문서를 만듭니다.

filter := bson.D{{"<field>", <value>}}

동등 조건을 지정하려면 com.mongodb를 사용하세요. 클라이언트.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>, ... }

동일성 조건을 지정하려면 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>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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> }, ... }

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

삭제 기준과 일치하는 모든 문서를 삭제 하려면 Compass 쿼리 표시줄에 쿼리 필터하다 쓰기 (write) 다음 Documents 탭 아래의 DELETE 버튼을 클릭합니다. 다음 예시 { status: "A" }가 있는 모든 문서를 삭제합니다.

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

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

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

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

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

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

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

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

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

동등 조건을 지정하려면 bson.D 유형을 사용하여 필터 문서를 만듭니다.

filter := bson.D{{"<field>", <value>}}

동등 조건을 지정하려면 com.mongodb를 사용하세요. 클라이언트.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>, ... }

동일성 조건을 지정하려면 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>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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> }, ... }

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

동등 조건을 지정하려면 bson.D 유형을 사용하여 필터 문서를 만듭니다.

filter := bson.D{{"<field>", <value>}}

동등 조건을 지정하려면 com.mongodb를 사용하세요. 클라이언트.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>, ... }

동일성 조건을 지정하려면 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>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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> }, ... }

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

동등 조건을 지정하려면 bson.D 유형을 사용하여 필터 문서를 만듭니다.

filter := bson.D{{"<field>", <value>}}

동등 조건을 지정하려면 com.mongodb를 사용하세요. 클라이언트.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>, ... }

동일성 조건을 지정하려면 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>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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> }, ... }

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

동등 조건을 지정하려면 bson.D 유형을 사용하여 필터 문서를 만듭니다.

filter := bson.D{{"<field>", <value>}}

동등 조건을 지정하려면 com.mongodb를 사용하세요. 클라이언트.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>, ... }

동일성 조건을 지정하려면 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>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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> }, ... }

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

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

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

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

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

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

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

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

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

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

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

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

동등 조건을 지정하려면 bson.D 유형을 사용하여 필터 문서를 만듭니다.

filter := bson.D{{"<field>", <value>}}

동등 조건을 지정하려면 com.mongodb를 사용하세요. 클라이언트.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>, ... }

동일성 조건을 지정하려면 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>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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> }, ... }

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

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

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

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

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

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

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

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

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

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

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

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

동등 조건을 지정하려면 bson.D 유형을 사용하여 필터 문서를 만듭니다.

filter := bson.D{{"<field>", <value>}}

동등 조건을 지정하려면 com.mongodb를 사용하세요. 클라이언트.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>, ... }

동일성 조건을 지정하려면 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>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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> }, ... }

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

동등 조건을 지정하려면 bson.D 유형을 사용하여 필터 문서를 만듭니다.

filter := bson.D{{"<field>", <value>}}

동등 조건을 지정하려면 com.mongodb를 사용하세요. 클라이언트.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>, ... }

동일성 조건을 지정하려면 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>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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> }, ... }

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

동등 조건을 지정하려면 bson.D 유형을 사용하여 필터 문서를 만듭니다.

filter := bson.D{{"<field>", <value>}}

동등 조건을 지정하려면 com.mongodb를 사용하세요. 클라이언트.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>, ... }

동일성 조건을 지정하려면 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>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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> }, ... }

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

동등 조건을 지정하려면 bson.D 유형을 사용하여 필터 문서를 만듭니다.

filter := bson.D{{"<field>", <value>}}

동등 조건을 지정하려면 com.mongodb를 사용하세요. 클라이언트.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>, ... }

동일성 조건을 지정하려면 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>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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> }, ... }

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

동등 조건을 지정하려면 bson.D 유형을 사용하여 필터 문서를 만듭니다.

filter := bson.D{{"<field>", <value>}}

동등 조건을 지정하려면 com.mongodb를 사용하세요. 클라이언트.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>, ... }

동일성 조건을 지정하려면 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>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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> }, ... }

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

동등 조건을 지정하려면 bson.D 유형을 사용하여 필터 문서를 만듭니다.

filter := bson.D{{"<field>", <value>}}

동등 조건을 지정하려면 com.mongodb를 사용하세요. 클라이언트.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>, ... }

동일성 조건을 지정하려면 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>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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> }, ... }

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

동등 조건을 지정하려면 bson.D 유형을 사용하여 필터 문서를 만듭니다.

filter := bson.D{{"<field>", <value>}}

동등 조건을 지정하려면 com.mongodb를 사용하세요. 클라이언트.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>, ... }

동일성 조건을 지정하려면 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>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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> }, ... }

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

$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()를 참조하세요.

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

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

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

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

조건과 일치하는 문서 하나만 삭제

지정된 필터와 일치하는 문서를 하나만 삭제하려면(지정된 필터와 일치하는 문서가 여러 개인 경우에도) db.collection.deleteOne() 메서드를 사용합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터하다 와 일치하는 단일 문서 삭제 하려면 다음을 수행합니다.

Compass 쿼리 줄에 쿼리 필터를 쓰고 Find을 클릭합니다.
삭제 하려는 문서 위로 마우스를 가져갑니다.
문서 오른쪽에 있는 버튼을 클릭합니다.

다음 예시 inventory 컬렉션 에서 { status: "A" } 이 있는 문서 삭제합니다.

컬렉션 에서 단일 문서 삭제 하려면 삭제 하려는 문서 와 일치하는 mongoc_collection_t 및 bson_t를 mongoc_collection_delete_one 메서드에 전달합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터와 일치하는 문서를 하나만 삭제하려면(지정된 필터와 일치하는 문서가 여러 개일 수 있음에도 불구하고) IMongoCollection.DeleteOne() 메서드를 사용합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터하다 와 일치하는 문서 하나만 삭제 하려면(여러 문서가 지정된 필터하다 와 일치할 수 있음에도 불구하고) Collection.DeleteOne 함수를 사용합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터하다 와 일치하는 문서 하나만 삭제 하려면(여러 문서가 지정된 필터하다 와 일치할 수 있음에도 불구하고) com.mongodb.reactivestreams를 사용하세요. 클라이언트.MongoCollection.deleteMany 메서드.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터하다 와 일치하는 문서 하나만 삭제 하려면(여러 문서가 지정된 필터하다 와 일치할 수 있음에도 불구하고) com.mongodb를 사용하세요. 클라이언트.MongoCollection.deleteOne 메서드.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터하다 와 일치하는 문서 하나만 삭제 하려면(여러 문서가 지정된 필터하다 와 일치할 수 있음에도 불구하고) motor.motor_asyncio.AsyncIOMotorCollection.delete_one 메서드를 사용합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터하다 와 일치하는 문서 하나만 삭제 하려면(여러 문서가 지정된 필터하다 와 일치할 수 있음에도 불구하고) Collection.deleteOne() 메서드를 사용합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터하다 와 일치하는 문서 하나만 삭제 하려면(여러 문서가 지정된 필터하다 와 일치할 수 있음에도 불구하고) MongoDB\\Collection::deleteOne() 메서드를 사용합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터하다 와 일치하는 문서 하나만 삭제 하려면(여러 문서가 지정된 필터하다 와 일치할 수 있음에도 불구하고) pymongo.collection.Collection.delete_one 메서드를 사용합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터하다 와 일치하는 문서 하나만 삭제 하려면(여러 문서가 지정된 필터하다 와 일치할 수 있음에도 불구하고) Mongo::Collection#delete_one() 메서드를 사용합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

지정된 필터하다 와 일치하는 문서 하나만 삭제 하려면(여러 문서가 지정된 필터하다 와 일치할 수 있음에도 불구하고) 컬렉션.deleteOne() 메서드를 사용합니다.

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

db.inventory.deleteOne( { status: "D" } )

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

다음 예에서는 status이 "D"인 첫 번째 문서를 삭제합니다.

await db.inventory.delete_one({"status": "D"})

await db.collection('inventory').deleteOne({ 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 메뉴에서 프로젝트를 선택합니다.
사이드바에서 Database 제목 아래의 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

삭제 작업은 컬렉션에서 모든 문서를 삭제하더라도 인덱스를 제거하지 않습니다.

참고

원자성 및 쓰기(write) 인증

MongoDB의 쓰기 (write) 작업은 단일 문서 수준에서 원자적으로 이루어집니다. 자세한 내용은 원자성 및 트랜잭션을 참조합니다.

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

팁

돌아가기

라이프사이클 다이어그램

SQL에서 MongoDB로

문서 삭제

모든 문서 삭제

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

조건과 일치하는 문서 하나만 삭제

MongoDB Atlas로 문서 삭제하기

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

컬렉션으로 이동합니다.

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

문서를 삭제합니다.

동작 삭제

Indexes

스킬 배지 획득