1MONGOC_BULK(3) libmongoc MONGOC_BULK(3)
2
6 mongoc_bulk - Bulk Write Operations
7 This tutorial explains how to take advantage of MongoDB C driver bulk
9 write operation features. Executing write operations in batches reduces
10 the number of network round trips, increasing write throughput.
11
13 First we need to fetch a bulk operation handle from the
14 mongoc_collection_t.
15 mongoc_bulk_operation_t *bulk =
17 mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
18 We can now start inserting documents to the bulk operation. These will
20 be buffered until we execute the operation.
21 The bulk operation will coalesce insertions as a single batch for each
23 consecutive call to mongoc_bulk_operation_insert(). This creates a
24 pipelined effect when possible.
25 To execute the bulk operation and receive the result we call
27 mongoc_bulk_operation_execute().
28 bulk1.c
30 #include <assert.h>
32 #include <mongoc/mongoc.h>
33 #include <stdio.h>
34 static void
36 bulk1 (mongoc_collection_t *collection)
37 {
38 mongoc_bulk_operation_t *bulk;
39 bson_error_t error;
40 bson_t *doc;
41 bson_t reply;
42 char *str;
43 bool ret;
44 int i;
45 bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
47 for (i = 0; i < 10000; i++) {
49 doc = BCON_NEW ("i", BCON_INT32 (i));
50 mongoc_bulk_operation_insert (bulk, doc);
51 bson_destroy (doc);
52 }
53 ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
55 str = bson_as_canonical_extended_json (&reply, NULL);
57 printf ("%s\n", str);
58 bson_free (str);
59 if (!ret) {
61 fprintf (stderr, "Error: %s\n", error.message);
62 }
63 bson_destroy (&reply);
65 mongoc_bulk_operation_destroy (bulk);
66 }
67 int
69 main (void)
70 {
71 mongoc_client_t *client;
72 mongoc_collection_t *collection;
73 const char *uri_string = "mongodb://localhost/?appname=bulk1-example";
74 mongoc_uri_t *uri;
75 bson_error_t error;
76 mongoc_init ();
78 uri = mongoc_uri_new_with_error (uri_string, &error);
80 if (!uri) {
81 fprintf (stderr,
82 "failed to parse URI: %s\n"
83 "error message: %s\n",
84 uri_string,
85 error.message);
86 return EXIT_FAILURE;
87 }
88 client = mongoc_client_new_from_uri (uri);
90 if (!client) {
91 return EXIT_FAILURE;
92 }
93 mongoc_client_set_error_api (client, 2);
95 collection = mongoc_client_get_collection (client, "test", "test");
96 bulk1 (collection);
98 mongoc_uri_destroy (uri);
100 mongoc_collection_destroy (collection);
101 mongoc_client_destroy (client);
102 mongoc_cleanup ();
104 return EXIT_SUCCESS;
106 }
107 Example reply document:
110 {"nInserted" : 10000,
112 "nMatched" : 0,
113 "nModified" : 0,
114 "nRemoved" : 0,
115 "nUpserted" : 0,
116 "writeErrors" : []
117 "writeConcernErrors" : [] }
118
120 MongoDB C driver also supports executing mixed bulk write operations. A
121 batch of insert, update, and remove operations can be executed together
122 using the bulk write operations API.
123
125 Ordered bulk write operations are batched and sent to the server in the
126 order provided for serial execution. The reply document describes the
127 type and count of operations performed.
128 bulk2.c
130 #include <assert.h>
132 #include <mongoc/mongoc.h>
133 #include <stdio.h>
134 static void
136 bulk2 (mongoc_collection_t *collection)
137 {
138 mongoc_bulk_operation_t *bulk;
139 bson_error_t error;
140 bson_t *query;
141 bson_t *doc;
142 bson_t *opts;
143 bson_t reply;
144 char *str;
145 bool ret;
146 int i;
147 bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
149 /* Remove everything */
151 query = bson_new ();
152 mongoc_bulk_operation_remove (bulk, query);
153 bson_destroy (query);
154 /* Add a few documents */
156 for (i = 1; i < 4; i++) {
157 doc = BCON_NEW ("_id", BCON_INT32 (i));
158 mongoc_bulk_operation_insert (bulk, doc);
159 bson_destroy (doc);
160 }
161 /* {_id: 1} => {$set: {foo: "bar"}} */
163 query = BCON_NEW ("_id", BCON_INT32 (1));
164 doc = BCON_NEW ("$set", "{", "foo", BCON_UTF8 ("bar"), "}");
165 mongoc_bulk_operation_update_many_with_opts (bulk, query, doc, NULL, &error);
166 bson_destroy (query);
167 bson_destroy (doc);
168 /* {_id: 4} => {'$inc': {'j': 1}} (upsert) */
170 opts = BCON_NEW ("upsert", BCON_BOOL (true));
171 query = BCON_NEW ("_id", BCON_INT32 (4));
172 doc = BCON_NEW ("$inc", "{", "j", BCON_INT32 (1), "}");
173 mongoc_bulk_operation_update_many_with_opts (bulk, query, doc, opts, &error);
174 bson_destroy (query);
175 bson_destroy (doc);
176 bson_destroy (opts);
177 /* replace {j:1} with {j:2} */
179 query = BCON_NEW ("j", BCON_INT32 (1));
180 doc = BCON_NEW ("j", BCON_INT32 (2));
181 mongoc_bulk_operation_replace_one_with_opts (bulk, query, doc, NULL, &error);
182 bson_destroy (query);
183 bson_destroy (doc);
184 ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
186 str = bson_as_canonical_extended_json (&reply, NULL);
188 printf ("%s\n", str);
189 bson_free (str);
190 if (!ret) {
192 printf ("Error: %s\n", error.message);
193 }
194 bson_destroy (&reply);
196 mongoc_bulk_operation_destroy (bulk);
197 }
198 int
200 main (void)
201 {
202 mongoc_client_t *client;
203 mongoc_collection_t *collection;
204 const char *uri_string = "mongodb://localhost/?appname=bulk2-example";
205 mongoc_uri_t *uri;
206 bson_error_t error;
207 mongoc_init ();
209 uri = mongoc_uri_new_with_error (uri_string, &error);
211 if (!uri) {
212 fprintf (stderr,
213 "failed to parse URI: %s\n"
214 "error message: %s\n",
215 uri_string,
216 error.message);
217 return EXIT_FAILURE;
218 }
219 client = mongoc_client_new_from_uri (uri);
221 if (!client) {
222 return EXIT_FAILURE;
223 }
224 mongoc_client_set_error_api (client, 2);
226 collection = mongoc_client_get_collection (client, "test", "test");
227 bulk2 (collection);
229 mongoc_uri_destroy (uri);
231 mongoc_collection_destroy (collection);
232 mongoc_client_destroy (client);
233 mongoc_cleanup ();
235 return EXIT_SUCCESS;
237 }
238 Example reply document:
241 { "nInserted" : 3,
243 "nMatched" : 2,
244 "nModified" : 2,
245 "nRemoved" : 10000,
246 "nUpserted" : 1,
247 "upserted" : [{"index" : 5, "_id" : 4}],
248 "writeErrors" : []
249 "writeConcernErrors" : [] }
250 The index field in the upserted array is the 0-based index of the up‐
252 sert operation; in this example, the sixth operation of the overall
253 bulk operation was an upsert, so its index is 5.
254
256 Unordered bulk write operations are batched and sent to the server in
257 arbitrary order where they may be executed in parallel. Any errors that
258 occur are reported after all operations are attempted.
259 In the next example the first and third operations fail due to the
261 unique constraint on _id. Since we are doing unordered execution the
262 second and fourth operations succeed.
263 bulk3.c
265 #include <assert.h>
267 #include <mongoc/mongoc.h>
268 #include <stdio.h>
269 static void
271 bulk3 (mongoc_collection_t *collection)
272 {
273 bson_t opts = BSON_INITIALIZER;
274 mongoc_bulk_operation_t *bulk;
275 bson_error_t error;
276 bson_t *query;
277 bson_t *doc;
278 bson_t reply;
279 char *str;
280 bool ret;
281 /* false indicates unordered */
283 BSON_APPEND_BOOL (&opts, "ordered", false);
284 bulk = mongoc_collection_create_bulk_operation_with_opts (collection, &opts);
285 bson_destroy (&opts);
286 /* Add a document */
288 doc = BCON_NEW ("_id", BCON_INT32 (1));
289 mongoc_bulk_operation_insert (bulk, doc);
290 bson_destroy (doc);
291 /* remove {_id: 2} */
293 query = BCON_NEW ("_id", BCON_INT32 (2));
294 mongoc_bulk_operation_remove_one (bulk, query);
295 bson_destroy (query);
296 /* insert {_id: 3} */
298 doc = BCON_NEW ("_id", BCON_INT32 (3));
299 mongoc_bulk_operation_insert (bulk, doc);
300 bson_destroy (doc);
301 /* replace {_id:4} {'i': 1} */
303 query = BCON_NEW ("_id", BCON_INT32 (4));
304 doc = BCON_NEW ("i", BCON_INT32 (1));
305 mongoc_bulk_operation_replace_one (bulk, query, doc, false);
306 bson_destroy (query);
307 bson_destroy (doc);
308 ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
310 str = bson_as_canonical_extended_json (&reply, NULL);
312 printf ("%s\n", str);
313 bson_free (str);
314 if (!ret) {
316 printf ("Error: %s\n", error.message);
317 }
318 bson_destroy (&reply);
320 mongoc_bulk_operation_destroy (bulk);
321 bson_destroy (&opts);
322 }
323 int
325 main (void)
326 {
327 mongoc_client_t *client;
328 mongoc_collection_t *collection;
329 const char *uri_string = "mongodb://localhost/?appname=bulk3-example";
330 mongoc_uri_t *uri;
331 bson_error_t error;
332 mongoc_init ();
334 uri = mongoc_uri_new_with_error (uri_string, &error);
336 if (!uri) {
337 fprintf (stderr,
338 "failed to parse URI: %s\n"
339 "error message: %s\n",
340 uri_string,
341 error.message);
342 return EXIT_FAILURE;
343 }
344 client = mongoc_client_new_from_uri (uri);
346 if (!client) {
347 return EXIT_FAILURE;
348 }
349 mongoc_client_set_error_api (client, 2);
351 collection = mongoc_client_get_collection (client, "test", "test");
352 bulk3 (collection);
354 mongoc_uri_destroy (uri);
356 mongoc_collection_destroy (collection);
357 mongoc_client_destroy (client);
358 mongoc_cleanup ();
360 return EXIT_SUCCESS;
362 }
363 Example reply document:
366 { "nInserted" : 0,
368 "nMatched" : 1,
369 "nModified" : 1,
370 "nRemoved" : 1,
371 "nUpserted" : 0,
372 "writeErrors" : [
373 { "index" : 0,
374 "code" : 11000,
375 "errmsg" : "E11000 duplicate key error index: test.test.$_id_ dup key: { : 1 }" },
376 { "index" : 2,
377 "code" : 11000,
378 "errmsg" : "E11000 duplicate key error index: test.test.$_id_ dup key: { : 3 }" } ],
379 "writeConcernErrors" : [] }
380 Error: E11000 duplicate key error index: test.test.$_id_ dup key: { : 1 }
382 The bson_error_t domain is MONGOC_ERROR_COMMAND and its code is 11000.
384
386 This feature is only available when using MongoDB 3.2 and later.
387 By default bulk operations are validated against the schema, if any is
389 defined. In certain cases however it may be necessary to bypass the
390 document validation.
391 bulk5.c
393 #include <assert.h>
395 #include <mongoc/mongoc.h>
396 #include <stdio.h>
397 static void
399 bulk5_fail (mongoc_collection_t *collection)
400 {
401 mongoc_bulk_operation_t *bulk;
402 bson_error_t error;
403 bson_t *doc;
404 bson_t reply;
405 char *str;
406 bool ret;
407 bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
409 /* Two inserts */
411 doc = BCON_NEW ("_id", BCON_INT32 (31));
412 mongoc_bulk_operation_insert (bulk, doc);
413 bson_destroy (doc);
414 doc = BCON_NEW ("_id", BCON_INT32 (32));
416 mongoc_bulk_operation_insert (bulk, doc);
417 bson_destroy (doc);
418 /* The above documents do not comply to the schema validation rules
420 * we created previously, so this will result in an error */
421 ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
422 str = bson_as_canonical_extended_json (&reply, NULL);
424 printf ("%s\n", str);
425 bson_free (str);
426 if (!ret) {
428 printf ("Error: %s\n", error.message);
429 }
430 bson_destroy (&reply);
432 mongoc_bulk_operation_destroy (bulk);
433 }
434 static void
436 bulk5_success (mongoc_collection_t *collection)
437 {
438 mongoc_bulk_operation_t *bulk;
439 bson_error_t error;
440 bson_t *doc;
441 bson_t reply;
442 char *str;
443 bool ret;
444 bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
446 /* Allow this document to bypass document validation.
448 * NOTE: When authentication is enabled, the authenticated user must have
449 * either the "dbadmin" or "restore" roles to bypass document validation */
450 mongoc_bulk_operation_set_bypass_document_validation (bulk, true);
451 /* Two inserts */
453 doc = BCON_NEW ("_id", BCON_INT32 (31));
454 mongoc_bulk_operation_insert (bulk, doc);
455 bson_destroy (doc);
456 doc = BCON_NEW ("_id", BCON_INT32 (32));
458 mongoc_bulk_operation_insert (bulk, doc);
459 bson_destroy (doc);
460 ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
462 str = bson_as_canonical_extended_json (&reply, NULL);
464 printf ("%s\n", str);
465 bson_free (str);
466 if (!ret) {
468 printf ("Error: %s\n", error.message);
469 }
470 bson_destroy (&reply);
472 mongoc_bulk_operation_destroy (bulk);
473 }
474 int
476 main (void)
477 {
478 bson_t *options;
479 bson_error_t error;
480 mongoc_client_t *client;
481 mongoc_collection_t *collection;
482 mongoc_database_t *database;
483 const char *uri_string = "mongodb://localhost/?appname=bulk5-example";
484 mongoc_uri_t *uri;
485 mongoc_init ();
487 uri = mongoc_uri_new_with_error (uri_string, &error);
489 if (!uri) {
490 fprintf (stderr,
491 "failed to parse URI: %s\n"
492 "error message: %s\n",
493 uri_string,
494 error.message);
495 return EXIT_FAILURE;
496 }
497 client = mongoc_client_new_from_uri (uri);
499 if (!client) {
500 return EXIT_FAILURE;
501 }
502 mongoc_client_set_error_api (client, 2);
504 database = mongoc_client_get_database (client, "testasdf");
505 /* Create schema validator */
507 options = BCON_NEW (
508 "validator", "{", "number", "{", "$gte", BCON_INT32 (5), "}", "}");
509 collection =
510 mongoc_database_create_collection (database, "collname", options, &error);
511 if (collection) {
513 bulk5_fail (collection);
514 bulk5_success (collection);
515 mongoc_collection_destroy (collection);
516 } else {
517 fprintf (stderr, "Couldn't create collection: '%s'\n", error.message);
518 }
519 bson_free (options);
521 mongoc_uri_destroy (uri);
522 mongoc_database_destroy (database);
523 mongoc_client_destroy (client);
524 mongoc_cleanup ();
526 return EXIT_SUCCESS;
528 }
529 Running the above example will result in:
532 { "nInserted" : 0,
534 "nMatched" : 0,
535 "nModified" : 0,
536 "nRemoved" : 0,
537 "nUpserted" : 0,
538 "writeErrors" : [
539 { "index" : 0,
540 "code" : 121,
541 "errmsg" : "Document failed validation" } ] }
542 Error: Document failed validation
544 { "nInserted" : 2,
546 "nMatched" : 0,
547 "nModified" : 0,
548 "nRemoved" : 0,
549 "nUpserted" : 0,
550 "writeErrors" : [] }
551 The bson_error_t domain is MONGOC_ERROR_COMMAND.
553
555 By default bulk operations are executed with the write_concern of the
556 collection they are executed against. A custom write concern can be
557 passed to the mongoc_collection_create_bulk_operation_with_opts()
558 method. Write concern errors (e.g. wtimeout) will be reported after all
559 operations are attempted, regardless of execution order.
560 bulk4.c
562 #include <assert.h>
564 #include <mongoc/mongoc.h>
565 #include <stdio.h>
566 static void
568 bulk4 (mongoc_collection_t *collection)
569 {
570 bson_t opts = BSON_INITIALIZER;
571 mongoc_write_concern_t *wc;
572 mongoc_bulk_operation_t *bulk;
573 bson_error_t error;
574 bson_t *doc;
575 bson_t reply;
576 char *str;
577 bool ret;
578 wc = mongoc_write_concern_new ();
580 mongoc_write_concern_set_w (wc, 4);
581 mongoc_write_concern_set_wtimeout_int64 (wc, 100); /* milliseconds */
582 mongoc_write_concern_append (wc, &opts);
583 bulk = mongoc_collection_create_bulk_operation_with_opts (collection, &opts);
585 /* Two inserts */
587 doc = BCON_NEW ("_id", BCON_INT32 (10));
588 mongoc_bulk_operation_insert (bulk, doc);
589 bson_destroy (doc);
590 doc = BCON_NEW ("_id", BCON_INT32 (11));
592 mongoc_bulk_operation_insert (bulk, doc);
593 bson_destroy (doc);
594 ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
596 str = bson_as_canonical_extended_json (&reply, NULL);
598 printf ("%s\n", str);
599 bson_free (str);
600 if (!ret) {
602 printf ("Error: %s\n", error.message);
603 }
604 bson_destroy (&reply);
606 mongoc_bulk_operation_destroy (bulk);
607 mongoc_write_concern_destroy (wc);
608 bson_destroy (&opts);
609 }
610 int
612 main (void)
613 {
614 mongoc_client_t *client;
615 mongoc_collection_t *collection;
616 const char *uri_string = "mongodb://localhost/?appname=bulk4-example";
617 mongoc_uri_t *uri;
618 bson_error_t error;
619 mongoc_init ();
621 uri = mongoc_uri_new_with_error (uri_string, &error);
623 if (!uri) {
624 fprintf (stderr,
625 "failed to parse URI: %s\n"
626 "error message: %s\n",
627 uri_string,
628 error.message);
629 return EXIT_FAILURE;
630 }
631 client = mongoc_client_new_from_uri (uri);
633 if (!client) {
634 return EXIT_FAILURE;
635 }
636 mongoc_client_set_error_api (client, 2);
638 collection = mongoc_client_get_collection (client, "test", "test");
639 bulk4 (collection);
641 mongoc_uri_destroy (uri);
643 mongoc_collection_destroy (collection);
644 mongoc_client_destroy (client);
645 mongoc_cleanup ();
647 return EXIT_SUCCESS;
649 }
650 Example reply document and error message:
653 { "nInserted" : 2,
655 "nMatched" : 0,
656 "nModified" : 0,
657 "nRemoved" : 0,
658 "nUpserted" : 0,
659 "writeErrors" : [],
660 "writeConcernErrors" : [
661 { "code" : 64,
662 "errmsg" : "waiting for replication timed out" }
663 ] }
664 Error: waiting for replication timed out
666 The bson_error_t domain is MONGOC_ERROR_WRITE_CONCERN if there are
668 write concern errors and no write errors. Write errors indicate failed
669 operations, so they take precedence over write concern errors, which
670 mean merely that the write concern is not satisfied yet.
671
673 This feature is only available when using MongoDB 3.4 and later.
674 bulk-collation.c
676 #include <mongoc/mongoc.h>
678 #include <stdio.h>
679 static void
681 bulk_collation (mongoc_collection_t *collection)
682 {
683 mongoc_bulk_operation_t *bulk;
684 bson_t *opts;
685 bson_t *doc;
686 bson_t *selector;
687 bson_t *update;
688 bson_error_t error;
689 bson_t reply;
690 char *str;
691 uint32_t ret;
692 /* insert {_id: "one"} and {_id: "One"} */
694 bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
695 doc = BCON_NEW ("_id", BCON_UTF8 ("one"));
696 mongoc_bulk_operation_insert (bulk, doc);
697 bson_destroy (doc);
698 doc = BCON_NEW ("_id", BCON_UTF8 ("One"));
700 mongoc_bulk_operation_insert (bulk, doc);
701 bson_destroy (doc);
702 /* "One" normally sorts before "one"; make "one" come first */
704 opts = BCON_NEW ("collation",
705 "{",
706 "locale",
707 BCON_UTF8 ("en_US"),
708 "caseFirst",
709 BCON_UTF8 ("lower"),
710 "}");
711 /* set x=1 on the document with _id "One", which now sorts after "one" */
713 update = BCON_NEW ("$set", "{", "x", BCON_INT64 (1), "}");
714 selector = BCON_NEW ("_id", "{", "$gt", BCON_UTF8 ("one"), "}");
715 mongoc_bulk_operation_update_one_with_opts (
716 bulk, selector, update, opts, &error);
717 ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
719 str = bson_as_canonical_extended_json (&reply, NULL);
721 printf ("%s\n", str);
722 bson_free (str);
723 if (!ret) {
725 printf ("Error: %s\n", error.message);
726 }
727 bson_destroy (&reply);
729 bson_destroy (update);
730 bson_destroy (selector);
731 bson_destroy (opts);
732 mongoc_bulk_operation_destroy (bulk);
733 }
734 int
736 main (void)
737 {
738 mongoc_client_t *client;
739 mongoc_collection_t *collection;
740 const char *uri_string = "mongodb://localhost/?appname=bulk-collation";
741 mongoc_uri_t *uri;
742 bson_error_t error;
743 mongoc_init ();
745 uri = mongoc_uri_new_with_error (uri_string, &error);
747 if (!uri) {
748 fprintf (stderr,
749 "failed to parse URI: %s\n"
750 "error message: %s\n",
751 uri_string,
752 error.message);
753 return EXIT_FAILURE;
754 }
755 client = mongoc_client_new_from_uri (uri);
757 if (!client) {
758 return EXIT_FAILURE;
759 }
760 mongoc_client_set_error_api (client, 2);
762 collection = mongoc_client_get_collection (client, "db", "collection");
763 bulk_collation (collection);
764 mongoc_uri_destroy (uri);
766 mongoc_collection_destroy (collection);
767 mongoc_client_destroy (client);
768 mongoc_cleanup ();
770 return EXIT_SUCCESS;
772 }
773 Running the above example will result in:
776 { "nInserted" : 2,
778 "nMatched" : 1,
779 "nModified" : 1,
780 "nRemoved" : 0,
781 "nUpserted" : 0,
782 "writeErrors" : [ ]
783 }
784
786 Set "w" to zero for an unacknowledged write. The driver sends unac‐
787 knowledged writes using the legacy opcodes OP_INSERT, OP_UPDATE, and
788 OP_DELETE.
789 bulk6.c
791 #include <mongoc/mongoc.h>
793 #include <stdio.h>
794 static void
796 bulk6 (mongoc_collection_t *collection)
797 {
798 bson_t opts = BSON_INITIALIZER;
799 mongoc_write_concern_t *wc;
800 mongoc_bulk_operation_t *bulk;
801 bson_error_t error;
802 bson_t *doc;
803 bson_t *selector;
804 bson_t reply;
805 char *str;
806 bool ret;
807 wc = mongoc_write_concern_new ();
809 mongoc_write_concern_set_w (wc, 0);
810 mongoc_write_concern_append (wc, &opts);
811 bulk = mongoc_collection_create_bulk_operation_with_opts (collection, &opts);
813 doc = BCON_NEW ("_id", BCON_INT32 (10));
815 mongoc_bulk_operation_insert (bulk, doc);
816 bson_destroy (doc);
817 selector = BCON_NEW ("_id", BCON_INT32 (11));
819 mongoc_bulk_operation_remove_one (bulk, selector);
820 bson_destroy (selector);
821 ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
823 str = bson_as_canonical_extended_json (&reply, NULL);
825 printf ("%s\n", str);
826 bson_free (str);
827 if (!ret) {
829 printf ("Error: %s\n", error.message);
830 }
831 bson_destroy (&reply);
833 mongoc_bulk_operation_destroy (bulk);
834 mongoc_write_concern_destroy (wc);
835 bson_destroy (&opts);
836 }
837 int
839 main (void)
840 {
841 mongoc_client_t *client;
842 mongoc_collection_t *collection;
843 const char *uri_string = "mongodb://localhost/?appname=bulk6-example";
844 mongoc_uri_t *uri;
845 bson_error_t error;
846 mongoc_init ();
848 uri = mongoc_uri_new_with_error (uri_string, &error);
850 if (!uri) {
851 fprintf (stderr,
852 "failed to parse URI: %s\n"
853 "error message: %s\n",
854 uri_string,
855 error.message);
856 return EXIT_FAILURE;
857 }
858 client = mongoc_client_new_from_uri (uri);
860 if (!client) {
861 return EXIT_FAILURE;
862 }
863 mongoc_client_set_error_api (client, 2);
865 collection = mongoc_client_get_collection (client, "test", "test");
866 bulk6 (collection);
868 mongoc_uri_destroy (uri);
870 mongoc_collection_destroy (collection);
871 mongoc_client_destroy (client);
872 mongoc_cleanup ();
874 return EXIT_SUCCESS;
876 }
877 The reply document is empty:
880 { }
882
884 See the Driver Bulk API Spec, which describes bulk write operations for
885 all MongoDB drivers.
886
888 MongoDB, Inc
889
891 2017-present, MongoDB, Inc
8921.24.3 Aug 17, 2023 MONGOC_BULK(3)