Docs Menu
Docs Home
/
言語
/
C ドライバー
/
C ドライバー
/
libmongoc
/
ガイド

一括書き込み操作

項目一覧

  • Bulk Insert
  • 混合一括書込み (write) 操作
  • 順序付き一括書き込み操作
  • 順序付けなし一括書き込み操作
  • ドキュメント検証をバイパスする一括操作
  • 一括操作書込み保証 (write concern)
  • 照合順序の設定
  • 未確認の一括書込み
  • bulkWrite サーバー コマンド
  • 例
  • さらに読む

このチュートリアルでは、MongoDB C ドライバーの一括書込み (write) 操作機能を利用する方法について説明します。 書込み (write) 操作をバッチで実行すると、ネットワーク ラウンド トリップの回数が減り、書込みスループットが向上します。

Tip

MongoDB Server8.0バージョン および C ドライバー バージョン1.28 以降では、 mongoc_bulkWrite_t 型。このタイプでは、 bulkWriteサーバーコマンドを使用して、1 回のリクエストで混合名前空間に対して複数の種類の書込み操作を実行します。 詳細については、このガイドのbulkWriteサーバー コマンドセクションを参照してください。

Bulk Insert

まず、 mongoc_collection_t から一括操作ハンドルを取得する必要があります。

mongoc_bulk_operation_t *bulk =
   mongoc_collection_create_bulk_operation_with_opts (collection, NULL);

一括操作へのドキュメントの挿入を開始できるようになりました。 これらは操作を実行するまでバッファされます。

一括操作では、 mongoc_bulk_operation_insert への連続した呼び出しごとに、挿入が単一のバッチとして統合されます 。これにより、可能な場合はパイプライン効果が生じます。

一括操作を実行し結果を受け取るには、 mongoc_bulk_operation_execute を呼び出します。

一括1 .c
#include <assert.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
static void
bulk1 (mongoc_collection_t *collection)
{
   mongoc_bulk_operation_t *bulk;
   bson_error_t error;
   bson_t *doc;
   bson_t reply;
   char *str;
   bool ret;
   int i;
   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
   for (i = 0; i < 10000; i++) {
      doc = BCON_NEW ("i", BCON_INT32 (i));
      mongoc_bulk_operation_insert (bulk, doc);
      bson_destroy (doc);
   }
   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
   str = bson_as_canonical_extended_json (&reply, NULL);
   printf ("%s\n", str);
   bson_free (str);
   if (!ret) {
      fprintf (stderr, "Error: %s\n", error.message);
   }
   bson_destroy (&reply);
   mongoc_bulk_operation_destroy (bulk);
}
int
main (void)
{
   mongoc_client_t *client;
   mongoc_collection_t *collection;
   const char *uri_string = "mongodb://localhost/?appname=bulk1-example";
   mongoc_uri_t *uri;
   bson_error_t error;
   mongoc_init ();
   uri = mongoc_uri_new_with_error (uri_string, &error);
   if (!uri) {
      fprintf (stderr,
               "failed to parse URI: %s\n"
               "error message:       %s\n",
               uri_string,
               error.message);
      return EXIT_FAILURE;
   }
   client = mongoc_client_new_from_uri (uri);
   if (!client) {
      return EXIT_FAILURE;
   }
   mongoc_client_set_error_api (client, 2);
   collection = mongoc_client_get_collection (client, "test", "test");
   bulk1 (collection);
   mongoc_uri_destroy (uri);
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
   mongoc_cleanup ();
   return EXIT_SUCCESS;
}

replyドキュメントの例:

{"nInserted"   : 10000,
 "nMatched"    : 0,
 "nModified"   : 0,
 "nRemoved"    : 0,
 "nUpserted"   : 0,
 "writeErrors" : []
 "writeConcernErrors" : [] }

混合一括書込み (write) 操作

MongoDB C ドライバーは、混合一括書込み操作の実行もサポートしています。 一括書き込み操作 API を使用して、挿入、アップデート、削除操作のバッチをまとめて実行できます。

順序付き一括書き込み操作

順序付き一括書き込み操作はバッチ化され、直列実行用の順序でサーバーに送信されます。 replyドキュメントでは、実行された操作の種類と数を説明します。

一括2 .c
#include <assert.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
static void
bulk2 (mongoc_collection_t *collection)
{
   mongoc_bulk_operation_t *bulk;
   bson_error_t error;
   bson_t *query;
   bson_t *doc;
   bson_t *opts;
   bson_t reply;
   char *str;
   bool ret;
   int i;
   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
   /* Remove everything */
   query = bson_new ();
   mongoc_bulk_operation_remove (bulk, query);
   bson_destroy (query);
   /* Add a few documents */
   for (i = 1; i < 4; i++) {
      doc = BCON_NEW ("_id", BCON_INT32 (i));
      mongoc_bulk_operation_insert (bulk, doc);
      bson_destroy (doc);
   }
   /* {_id: 1} => {$set: {foo: "bar"}} */
   query = BCON_NEW ("_id", BCON_INT32 (1));
   doc = BCON_NEW ("$set", "{", "foo", BCON_UTF8 ("bar"), "}");
   mongoc_bulk_operation_update_many_with_opts (bulk, query, doc, NULL, &error);
   bson_destroy (query);
   bson_destroy (doc);
   /* {_id: 4} => {'$inc': {'j': 1}} (upsert) */
   opts = BCON_NEW ("upsert", BCON_BOOL (true));
   query = BCON_NEW ("_id", BCON_INT32 (4));
   doc = BCON_NEW ("$inc", "{", "j", BCON_INT32 (1), "}");
   mongoc_bulk_operation_update_many_with_opts (bulk, query, doc, opts, &error);
   bson_destroy (query);
   bson_destroy (doc);
   bson_destroy (opts);
   /* replace {j:1} with {j:2} */
   query = BCON_NEW ("j", BCON_INT32 (1));
   doc = BCON_NEW ("j", BCON_INT32 (2));
   mongoc_bulk_operation_replace_one_with_opts (bulk, query, doc, NULL, &error);
   bson_destroy (query);
   bson_destroy (doc);
   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
   str = bson_as_canonical_extended_json (&reply, NULL);
   printf ("%s\n", str);
   bson_free (str);
   if (!ret) {
      printf ("Error: %s\n", error.message);
   }
   bson_destroy (&reply);
   mongoc_bulk_operation_destroy (bulk);
}
int
main (void)
{
   mongoc_client_t *client;
   mongoc_collection_t *collection;
   const char *uri_string = "mongodb://localhost/?appname=bulk2-example";
   mongoc_uri_t *uri;
   bson_error_t error;
   mongoc_init ();
   uri = mongoc_uri_new_with_error (uri_string, &error);
   if (!uri) {
      fprintf (stderr,
               "failed to parse URI: %s\n"
               "error message:       %s\n",
               uri_string,
               error.message);
      return EXIT_FAILURE;
   }
   client = mongoc_client_new_from_uri (uri);
   if (!client) {
      return EXIT_FAILURE;
   }
   mongoc_client_set_error_api (client, 2);
   collection = mongoc_client_get_collection (client, "test", "test");
   bulk2 (collection);
   mongoc_uri_destroy (uri);
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
   mongoc_cleanup ();
   return EXIT_SUCCESS;
}

replyドキュメントの例:

{ "nInserted"   : 3,
  "nMatched"    : 2,
  "nModified"   : 2,
  "nRemoved"    : 10000,
  "nUpserted"   : 1,
  "upserted"    : [{"index" : 5, "_id" : 4}],
  "writeErrors" : []
  "writeConcernErrors" : [] }

upserted配列のindexフィールドは、アップサート操作の0ベースのインデックスです。この例では、全体的な一括操作の 6 番目の操作がアップサートであったため、そのインデックスは5です。

順序付けなし一括書き込み操作

順序なしの一括書き込み操作はバッチ化され、任意の順序でサーバーに送信され、並行して実行される可能性があります。 発生するエラーは、すべての操作が試行された後に報告されます。

次の例では、 _idに一意の制約があるため、1 番目と 3 番目の操作は失敗します。 順序なし実行を行っているため、2 番目と 4 番目の操作は成功します。

一括3 .c
#include <assert.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
static void
bulk3 (mongoc_collection_t *collection)
{
   bson_t opts = BSON_INITIALIZER;
   mongoc_bulk_operation_t *bulk;
   bson_error_t error;
   bson_t *query;
   bson_t *doc;
   bson_t reply;
   char *str;
   bool ret;
   /* false indicates unordered */
   BSON_APPEND_BOOL (&opts, "ordered", false);
   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, &opts);
   bson_destroy (&opts);
   /* Add a document */
   doc = BCON_NEW ("_id", BCON_INT32 (1));
   mongoc_bulk_operation_insert (bulk, doc);
   bson_destroy (doc);
   /* remove {_id: 2} */
   query = BCON_NEW ("_id", BCON_INT32 (2));
   mongoc_bulk_operation_remove_one (bulk, query);
   bson_destroy (query);
   /* insert {_id: 3} */
   doc = BCON_NEW ("_id", BCON_INT32 (3));
   mongoc_bulk_operation_insert (bulk, doc);
   bson_destroy (doc);
   /* replace {_id:4} {'i': 1} */
   query = BCON_NEW ("_id", BCON_INT32 (4));
   doc = BCON_NEW ("i", BCON_INT32 (1));
   mongoc_bulk_operation_replace_one (bulk, query, doc, false);
   bson_destroy (query);
   bson_destroy (doc);
   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
   str = bson_as_canonical_extended_json (&reply, NULL);
   printf ("%s\n", str);
   bson_free (str);
   if (!ret) {
      printf ("Error: %s\n", error.message);
   }
   bson_destroy (&reply);
   mongoc_bulk_operation_destroy (bulk);
   bson_destroy (&opts);
}
int
main (void)
{
   mongoc_client_t *client;
   mongoc_collection_t *collection;
   const char *uri_string = "mongodb://localhost/?appname=bulk3-example";
   mongoc_uri_t *uri;
   bson_error_t error;
   mongoc_init ();
   uri = mongoc_uri_new_with_error (uri_string, &error);
   if (!uri) {
      fprintf (stderr,
               "failed to parse URI: %s\n"
               "error message:       %s\n",
               uri_string,
               error.message);
      return EXIT_FAILURE;
   }
   client = mongoc_client_new_from_uri (uri);
   if (!client) {
      return EXIT_FAILURE;
   }
   mongoc_client_set_error_api (client, 2);
   collection = mongoc_client_get_collection (client, "test", "test");
   bulk3 (collection);
   mongoc_uri_destroy (uri);
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
   mongoc_cleanup ();
   return EXIT_SUCCESS;
}

replyドキュメントの例:

{ "nInserted"    : 0,
  "nMatched"     : 1,
  "nModified"    : 1,
  "nRemoved"     : 1,
  "nUpserted"    : 0,
  "writeErrors"  : [
    { "index"  : 0,
      "code"   : 11000,
      "errmsg" : "E11000 duplicate key error index: test.test.$_id_ dup key: { : 1 }" },
    { "index"  : 2,
      "code"   : 11000,
      "errmsg" : "E11000 duplicate key error index: test.test.$_id_ dup key: { : 3 }" } ],
  "writeConcernErrors" : [] }
Error: E11000 duplicate key error index: test.test.$_id_ dup key: { : 1 }

bson_error_t ドメインはMONGOC_ERROR_COMMAND で、そのコードは11000 です。

ドキュメント検証をバイパスする一括操作

この機能は MongoDB 3.2以降を使用している場合にのみ使用できます。

デフォルトでは、一括操作は、定義されている場合、スキーマに対して検証されます。 ただし、ドキュメント検証をバイパスする必要がある場合もあります。

一括5 .c
#include <assert.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
static void
bulk5_fail (mongoc_collection_t *collection)
{
   mongoc_bulk_operation_t *bulk;
   bson_error_t error;
   bson_t *doc;
   bson_t reply;
   char *str;
   bool ret;
   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
   /* Two inserts */
   doc = BCON_NEW ("_id", BCON_INT32 (31));
   mongoc_bulk_operation_insert (bulk, doc);
   bson_destroy (doc);
   doc = BCON_NEW ("_id", BCON_INT32 (32));
   mongoc_bulk_operation_insert (bulk, doc);
   bson_destroy (doc);
   /* The above documents do not comply to the schema validation rules
    * we created previously, so this will result in an error */
   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
   str = bson_as_canonical_extended_json (&reply, NULL);
   printf ("%s\n", str);
   bson_free (str);
   if (!ret) {
      printf ("Error: %s\n", error.message);
   }
   bson_destroy (&reply);
   mongoc_bulk_operation_destroy (bulk);
}
static void
bulk5_success (mongoc_collection_t *collection)
{
   mongoc_bulk_operation_t *bulk;
   bson_error_t error;
   bson_t *doc;
   bson_t reply;
   char *str;
   bool ret;
   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
   /* Allow this document to bypass document validation.
    * NOTE: When authentication is enabled, the authenticated user must have
    * either the "dbadmin" or "restore" roles to bypass document validation */
   mongoc_bulk_operation_set_bypass_document_validation (bulk, true);
   /* Two inserts */
   doc = BCON_NEW ("_id", BCON_INT32 (31));
   mongoc_bulk_operation_insert (bulk, doc);
   bson_destroy (doc);
   doc = BCON_NEW ("_id", BCON_INT32 (32));
   mongoc_bulk_operation_insert (bulk, doc);
   bson_destroy (doc);
   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
   str = bson_as_canonical_extended_json (&reply, NULL);
   printf ("%s\n", str);
   bson_free (str);
   if (!ret) {
      printf ("Error: %s\n", error.message);
   }
   bson_destroy (&reply);
   mongoc_bulk_operation_destroy (bulk);
}
int
main (void)
{
   bson_t *options;
   bson_error_t error;
   mongoc_client_t *client;
   mongoc_collection_t *collection;
   mongoc_database_t *database;
   const char *uri_string = "mongodb://localhost/?appname=bulk5-example";
   mongoc_uri_t *uri;
   mongoc_init ();
   uri = mongoc_uri_new_with_error (uri_string, &error);
   if (!uri) {
      fprintf (stderr,
               "failed to parse URI: %s\n"
               "error message:       %s\n",
               uri_string,
               error.message);
      return EXIT_FAILURE;
   }
   client = mongoc_client_new_from_uri (uri);
   if (!client) {
      return EXIT_FAILURE;
   }
   mongoc_client_set_error_api (client, 2);
   database = mongoc_client_get_database (client, "testasdf");
   /* Create schema validator */
   options = BCON_NEW ("validator", "{", "number", "{", "$gte", BCON_INT32 (5), "}", "}");
   collection = mongoc_database_create_collection (database, "collname", options, &error);
   if (collection) {
      bulk5_fail (collection);
      bulk5_success (collection);
      mongoc_collection_destroy (collection);
   } else {
      fprintf (stderr, "Couldn't create collection: '%s'\n", error.message);
   }
   bson_free (options);
   mongoc_uri_destroy (uri);
   mongoc_database_destroy (database);
   mongoc_client_destroy (client);
   mongoc_cleanup ();
   return EXIT_SUCCESS;
}

上記の例を実行すると、次の結果が得られます。

{ "nInserted" : 0,
  "nMatched" : 0,
  "nModified" : 0,
  "nRemoved" : 0,
  "nUpserted" : 0,
  "writeErrors" : [
    { "index" : 0,
      "code" : 121,
      "errmsg" : "Document failed validation" } ] }
Error: Document failed validation
{ "nInserted" : 2,
  "nMatched" : 0,
  "nModified" : 0,
  "nRemoved" : 0,
  "nUpserted" : 0,
  "writeErrors" : [] }

bson_error_t ドメインはMONGOC_ERROR_COMMAND です。

一括操作書込み保証 (write concern)

デフォルトでは、一括操作は mongoc_write_concern_t で実行されます コレクションのカスタム書込み保証 (write concern) は、 mongoc_collection_create_bulk_operation_with_ops に渡すことができます 使用して複数のドキュメントを挿入できます。書込み保証 (write concern) エラー（例: wtimeout）は、実行順序に関係なく、すべての操作が試行された後に報告されます。

一括4 .c
#include <assert.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
static void
bulk4 (mongoc_collection_t *collection)
{
   bson_t opts = BSON_INITIALIZER;
   mongoc_write_concern_t *wc;
   mongoc_bulk_operation_t *bulk;
   bson_error_t error;
   bson_t *doc;
   bson_t reply;
   char *str;
   bool ret;
   wc = mongoc_write_concern_new ();
   mongoc_write_concern_set_w (wc, 4);
   mongoc_write_concern_set_wtimeout_int64 (wc, 100); /* milliseconds */
   mongoc_write_concern_append (wc, &opts);
   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, &opts);
   /* Two inserts */
   doc = BCON_NEW ("_id", BCON_INT32 (10));
   mongoc_bulk_operation_insert (bulk, doc);
   bson_destroy (doc);
   doc = BCON_NEW ("_id", BCON_INT32 (11));
   mongoc_bulk_operation_insert (bulk, doc);
   bson_destroy (doc);
   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
   str = bson_as_canonical_extended_json (&reply, NULL);
   printf ("%s\n", str);
   bson_free (str);
   if (!ret) {
      printf ("Error: %s\n", error.message);
   }
   bson_destroy (&reply);
   mongoc_bulk_operation_destroy (bulk);
   mongoc_write_concern_destroy (wc);
   bson_destroy (&opts);
}
int
main (void)
{
   mongoc_client_t *client;
   mongoc_collection_t *collection;
   const char *uri_string = "mongodb://localhost/?appname=bulk4-example";
   mongoc_uri_t *uri;
   bson_error_t error;
   mongoc_init ();
   uri = mongoc_uri_new_with_error (uri_string, &error);
   if (!uri) {
      fprintf (stderr,
               "failed to parse URI: %s\n"
               "error message:       %s\n",
               uri_string,
               error.message);
      return EXIT_FAILURE;
   }
   client = mongoc_client_new_from_uri (uri);
   if (!client) {
      return EXIT_FAILURE;
   }
   mongoc_client_set_error_api (client, 2);
   collection = mongoc_client_get_collection (client, "test", "test");
   bulk4 (collection);
   mongoc_uri_destroy (uri);
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
   mongoc_cleanup ();
   return EXIT_SUCCESS;
}

replyドキュメントとエラー メッセージの例

{ "nInserted"    : 2,
  "nMatched"     : 0,
  "nModified"    : 0,
  "nRemoved"     : 0,
  "nUpserted"    : 0,
  "writeErrors"  : [],
  "writeConcernErrors" : [
    { "code"   : 64,
      "errmsg" : "waiting for replication timed out" }
] }
Error: waiting for replication timed out

bson_error_t MONGOC_ERROR_WRITE_CONCERNドメインは、書込み保証（write concern）エラーがあり、書込みエラーがない場合、 です。書込み (write) エラーは失敗した操作を示すため、書込み保証 (write concern) エラーよりも優先されます。これは、書込み保証 (write concern) がまだ満たされていないことを意味します。

照合順序の設定

この機能は MongoDB 3.4以降を使用している場合にのみ使用できます。

bulk-collation.c
#include <mongoc/mongoc.h>
#include <stdio.h>
static void
bulk_collation (mongoc_collection_t *collection)
{
   mongoc_bulk_operation_t *bulk;
   bson_t *opts;
   bson_t *doc;
   bson_t *selector;
   bson_t *update;
   bson_error_t error;
   bson_t reply;
   char *str;
   uint32_t ret;
   /* insert {_id: "one"} and {_id: "One"} */
   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
   doc = BCON_NEW ("_id", BCON_UTF8 ("one"));
   mongoc_bulk_operation_insert (bulk, doc);
   bson_destroy (doc);
   doc = BCON_NEW ("_id", BCON_UTF8 ("One"));
   mongoc_bulk_operation_insert (bulk, doc);
   bson_destroy (doc);
   /* "One" normally sorts before "one"; make "one" come first */
   opts = BCON_NEW ("collation", "{", "locale", BCON_UTF8 ("en_US"), "caseFirst", BCON_UTF8 ("lower"), "}");
   /* set x=1 on the document with _id "One", which now sorts after "one" */
   update = BCON_NEW ("$set", "{", "x", BCON_INT64 (1), "}");
   selector = BCON_NEW ("_id", "{", "$gt", BCON_UTF8 ("one"), "}");
   mongoc_bulk_operation_update_one_with_opts (bulk, selector, update, opts, &error);
   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
   str = bson_as_canonical_extended_json (&reply, NULL);
   printf ("%s\n", str);
   bson_free (str);
   if (!ret) {
      printf ("Error: %s\n", error.message);
   }
   bson_destroy (&reply);
   bson_destroy (update);
   bson_destroy (selector);
   bson_destroy (opts);
   mongoc_bulk_operation_destroy (bulk);
}
int
main (void)
{
   mongoc_client_t *client;
   mongoc_collection_t *collection;
   const char *uri_string = "mongodb://localhost/?appname=bulk-collation";
   mongoc_uri_t *uri;
   bson_error_t error;
   mongoc_init ();
   uri = mongoc_uri_new_with_error (uri_string, &error);
   if (!uri) {
      fprintf (stderr,
               "failed to parse URI: %s\n"
               "error message:       %s\n",
               uri_string,
               error.message);
      return EXIT_FAILURE;
   }
   client = mongoc_client_new_from_uri (uri);
   if (!client) {
      return EXIT_FAILURE;
   }
   mongoc_client_set_error_api (client, 2);
   collection = mongoc_client_get_collection (client, "db", "collection");
   bulk_collation (collection);
   mongoc_uri_destroy (uri);
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
   mongoc_cleanup ();
   return EXIT_SUCCESS;
}

上記の例を実行すると、次の結果が得られます。

{ "nInserted" : 2,
   "nMatched" : 1,
   "nModified" : 1,
   "nRemoved" : 0,
   "nUpserted" : 0,
   "writeErrors" : [  ]
}

未確認の一括書込み

確認されていない書込みの場合は、"w" を 0 に設定します。 ドライバーは、レガシー命令コードOP_INSERT 、 OP_UPDATE 、 OP_DELETEを使用して、確認されていない書き込みを送信します。

一括6 .c
#include <mongoc/mongoc.h>
#include <stdio.h>
static void
bulk6 (mongoc_collection_t *collection)
{
   bson_t opts = BSON_INITIALIZER;
   mongoc_write_concern_t *wc;
   mongoc_bulk_operation_t *bulk;
   bson_error_t error;
   bson_t *doc;
   bson_t *selector;
   bson_t reply;
   char *str;
   bool ret;
   wc = mongoc_write_concern_new ();
   mongoc_write_concern_set_w (wc, 0);
   mongoc_write_concern_append (wc, &opts);
   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, &opts);
   doc = BCON_NEW ("_id", BCON_INT32 (10));
   mongoc_bulk_operation_insert (bulk, doc);
   bson_destroy (doc);
   selector = BCON_NEW ("_id", BCON_INT32 (11));
   mongoc_bulk_operation_remove_one (bulk, selector);
   bson_destroy (selector);
   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
   str = bson_as_canonical_extended_json (&reply, NULL);
   printf ("%s\n", str);
   bson_free (str);
   if (!ret) {
      printf ("Error: %s\n", error.message);
   }
   bson_destroy (&reply);
   mongoc_bulk_operation_destroy (bulk);
   mongoc_write_concern_destroy (wc);
   bson_destroy (&opts);
}
int
main (void)
{
   mongoc_client_t *client;
   mongoc_collection_t *collection;
   const char *uri_string = "mongodb://localhost/?appname=bulk6-example";
   mongoc_uri_t *uri;
   bson_error_t error;
   mongoc_init ();
   uri = mongoc_uri_new_with_error (uri_string, &error);
   if (!uri) {
      fprintf (stderr,
               "failed to parse URI: %s\n"
               "error message:       %s\n",
               uri_string,
               error.message);
      return EXIT_FAILURE;
   }
   client = mongoc_client_new_from_uri (uri);
   if (!client) {
      return EXIT_FAILURE;
   }
   mongoc_client_set_error_api (client, 2);
   collection = mongoc_client_get_collection (client, "test", "test");
   bulk6 (collection);
   mongoc_uri_destroy (uri);
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
   mongoc_cleanup ();
   return EXIT_SUCCESS;
}

replyドキュメントは空です。

{ }

bulkWrite サーバー コマンド

このページの前の例では、 mongoc_bulk_operation_t 一括書き込み操作を実行するための タイプ。mongoc_bulk_operation_tは、 insert 、 update 、 deleteサーバーコマンドを実行します。 mongoc_bulk_operation_tを使用する一括書き込み操作では、操作をタイプ別にグループ化し、別々のコマンドで送信します。 一括書き込みごとに指定できるコレクションは 1 つだけです。

あるいは、 mongoc_bulkWrite_t を使用して一括書込みを実行することもできますbulkWrite タイプ。これは サーバーコマンドを実行します。bulkWriteコマンドは MongoDB Server 8で導入されました。 0と は、同じペイロード内の複数の名前空間に対する挿入、更新、削除操作をサポートしています。

MongoDB Server バージョン8.0以降に接続する場合は、ネットワーク ラウンド トリップを減らすために、 mongoc_bulk_operation_tよりもmongoc_bulkwrite_tを使用することをお勧めします。

例

次の例では、 mongoc_bulkwrite_tとmongoc_bulkwrite_execute()を使用して 2 つの異なるコレクションにドキュメントを挿入する方法を示しています。

bulkwrite.c
// example-bulkwrite shows use of `mongoc_client_bulkwrite`.
#include <mongoc/mongoc.h>
#define HANDLE_ERROR(...)            \
   if (1) {                          \
      fprintf (stderr, __VA_ARGS__); \
      fprintf (stderr, "\n");        \
      goto fail;                     \
   } else                            \
      (void) 0
int
main (int argc, char *argv[])
{
   bool ok = false;
   mongoc_init ();
   bson_error_t error;
   mongoc_client_t *client = mongoc_client_new ("mongodb://localhost:27017");
   mongoc_bulkwriteopts_t *bwo = mongoc_bulkwriteopts_new ();
   mongoc_bulkwriteopts_set_verboseresults (bwo, true);
   mongoc_bulkwrite_t *bw = mongoc_client_bulkwrite_new (client);
   // Insert a document to `db.coll1`
   {
      bson_t *doc = BCON_NEW ("foo", "bar");
      if (!mongoc_bulkwrite_append_insertone (bw, "db.coll1", doc, NULL, &error)) {
         HANDLE_ERROR ("Error appending insert one: %s", error.message);
      }
      bson_destroy (doc);
   }
   // Insert a document to `db.coll2`
   {
      bson_t *doc = BCON_NEW ("foo", "baz");
      if (!mongoc_bulkwrite_append_insertone (bw, "db.coll2", doc, NULL, &error)) {
         HANDLE_ERROR ("Error appending insert one: %s", error.message);
      }
      bson_destroy (doc);
   }
   mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (bw, bwo);
   // Print results.
   {
      BSON_ASSERT (bwr.res); // Has results. NULL only returned for unacknowledged writes.
      printf ("Insert count          : %" PRId64 "\n", mongoc_bulkwriteresult_insertedcount (bwr.res));
      const bson_t *ir = mongoc_bulkwriteresult_insertresults (bwr.res);
      BSON_ASSERT (ir); // Has verbose results. NULL only returned if verbose results not requested.
      char *ir_str = bson_as_relaxed_extended_json (ir, NULL);
      printf ("Insert results        : %s\n", ir_str);
      bson_free (ir_str);
   }
   // Print all error information. To observe: try setting the `_id` fields to cause a duplicate key error.
   if (bwr.exc) {
      const char *msg = "(none)";
      if (mongoc_bulkwriteexception_error (bwr.exc, &error)) {
         msg = error.message;
      }
      const bson_t *we = mongoc_bulkwriteexception_writeerrors (bwr.exc);
      char *we_str = bson_as_relaxed_extended_json (we, NULL);
      const bson_t *wce = mongoc_bulkwriteexception_writeconcernerrors (bwr.exc);
      char *wce_str = bson_as_relaxed_extended_json (wce, NULL);
      const bson_t *er = mongoc_bulkwriteexception_errorreply (bwr.exc);
      char *er_str = bson_as_relaxed_extended_json (er, NULL);
      printf ("Top-level error       : %s\n", msg);
      printf ("Write errors          : %s\n", we_str);
      printf ("Write concern errors  : %s\n", wce_str);
      printf ("Error reply           : %s\n", er_str);
      bson_free (er_str);
      bson_free (wce_str);
      bson_free (we_str);
   }
   mongoc_bulkwriteresult_destroy (bwr.res);
   mongoc_bulkwriteexception_destroy (bwr.exc);
   mongoc_bulkwrite_destroy (bw);
   ok = true;
fail:
   mongoc_client_destroy (client);
   mongoc_bulkwriteopts_destroy (bwo);
   mongoc_cleanup ();
   return ok ? EXIT_SUCCESS : EXIT_FAILURE;
}

さらに読む

一括書き込み操作の詳細については、次の一括 API 仕様を参照してください。

戻る

Cursors