void
mongoc_bulk_operation_destroy (mongoc_bulk_operation_t *bulk) /* IN */
{
mongoc_write_command_t *command;
int i;
if (bulk) {
for (i = 0; i < bulk->commands.len; i++) {
command = &_mongoc_array_index (&bulk->commands,
mongoc_write_command_t, i);
_mongoc_write_command_destroy (command);
}
bson_free (bulk->database);
bson_free (bulk->collection);
mongoc_write_concern_destroy (bulk->write_concern);
_mongoc_array_destroy (&bulk->commands);
if (bulk->executed) {
_mongoc_write_result_destroy (&bulk->result);
}
bson_free (bulk);
}
}
static void
test_split_insert (void)
{
mongoc_write_command_t command;
mongoc_write_result_t result;
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_oid_t oid;
bson_t **docs;
bson_t reply = BSON_INITIALIZER;
bson_error_t error;
int i;
bool r;
client = test_framework_client_new (NULL);
assert (client);
collection = get_test_collection (client, "test_split_insert");
assert (collection);
docs = bson_malloc (sizeof(bson_t*) * 3000);
for (i = 0; i < 3000; i++) {
docs [i] = bson_new ();
bson_oid_init (&oid, NULL);
BSON_APPEND_OID (docs [i], "_id", &oid);
}
_mongoc_write_result_init (&result);
_mongoc_write_command_init_insert (&command,
(const bson_t * const *)docs,
3000, true, true);
_mongoc_write_command_execute (&command, client, 0, collection->db,
collection->collection, NULL, 0, &result);
r = _mongoc_write_result_complete (&result, &reply, &error);
assert (r);
assert (result.nInserted == 3000);
_mongoc_write_command_destroy (&command);
_mongoc_write_result_destroy (&result);
r = mongoc_collection_drop (collection, &error);
assert (r);
for (i = 0; i < 3000; i++) {
bson_destroy (docs [i]);
}
bson_free (docs);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
}
static void
test_invalid_write_concern (void)
{
mongoc_bulk_write_flags_t write_flags = MONGOC_BULK_WRITE_FLAGS_INIT;
mongoc_write_command_t command;
mongoc_write_result_t result;
mongoc_collection_t *collection;
mongoc_client_t *client;
mongoc_write_concern_t *write_concern;
mongoc_server_stream_t *server_stream;
bson_t *doc;
bson_t reply = BSON_INITIALIZER;
bson_error_t error;
bool r;
client = test_framework_client_new ();
assert(client);
collection = get_test_collection(client, "test_invalid_write_concern");
assert(collection);
write_concern = mongoc_write_concern_new();
assert(write_concern);
mongoc_write_concern_set_w(write_concern, 0);
mongoc_write_concern_set_journal(write_concern, true);
assert(!mongoc_write_concern_is_valid (write_concern));
doc = BCON_NEW("_id", BCON_INT32(0));
_mongoc_write_command_init_insert(&command, doc, write_flags,
++client->cluster.operation_id, true);
_mongoc_write_result_init (&result);
server_stream = mongoc_cluster_stream_for_writes (&client->cluster, &error);
ASSERT_OR_PRINT (server_stream, error);
_mongoc_write_command_execute (&command, client, server_stream,
collection->db, collection->collection,
write_concern, 0, &result);
r = _mongoc_write_result_complete (&result, 2, collection->write_concern,
&reply, &error);
assert(!r);
ASSERT_CMPINT(error.domain, ==, MONGOC_ERROR_COMMAND);
ASSERT_CMPINT(error.code, ==, MONGOC_ERROR_COMMAND_INVALID_ARG);
_mongoc_write_command_destroy (&command);
_mongoc_write_result_destroy (&result);
bson_destroy(doc);
mongoc_server_stream_cleanup (server_stream);
mongoc_collection_destroy(collection);
mongoc_client_destroy(client);
mongoc_write_concern_destroy(write_concern);
}
static void
test_invalid_write_concern (void)
{
mongoc_write_command_t command;
mongoc_write_result_t result;
mongoc_collection_t *collection;
mongoc_client_t *client;
mongoc_write_concern_t *write_concern;
bson_t **docs;
bson_t reply = BSON_INITIALIZER;
bson_error_t error;
bool r;
client = test_framework_client_new (NULL);
assert(client);
collection = get_test_collection(client, "test_invalid_write_concern");
assert(collection);
write_concern = mongoc_write_concern_new();
assert(write_concern);
mongoc_write_concern_set_w(write_concern, 0);
mongoc_write_concern_set_journal(write_concern, true);
assert(!_mongoc_write_concern_is_valid(write_concern));
docs = bson_malloc(sizeof(bson_t*));
docs[0] = BCON_NEW("_id", BCON_INT32(0));
_mongoc_write_command_init_insert(&command, (const bson_t * const *)docs, 1, true, true);
_mongoc_write_result_init (&result);
_mongoc_write_command_execute (&command, client, 0, collection->db,
collection->collection, write_concern, 0,
&result);
r = _mongoc_write_result_complete (&result, &reply, &error);
assert(!r);
assert(error.domain = MONGOC_ERROR_COMMAND);
assert(error.code = MONGOC_ERROR_COMMAND_INVALID_ARG);
_mongoc_write_command_destroy (&command);
_mongoc_write_result_destroy (&result);
bson_destroy(docs[0]);
bson_free(docs);
mongoc_collection_destroy(collection);
mongoc_client_destroy(client);
mongoc_write_concern_destroy(write_concern);
}
uint32_t
mongoc_bulk_operation_execute (mongoc_bulk_operation_t *bulk, /* IN */
bson_t *reply, /* OUT */
bson_error_t *error) /* OUT */
{
mongoc_cluster_t *cluster;
mongoc_write_command_t *command;
mongoc_server_stream_t *server_stream;
bool ret;
uint32_t offset = 0;
int i;
ENTRY;
BSON_ASSERT (bulk);
if (reply) {
bson_init (reply);
}
if (!bulk->client) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"mongoc_bulk_operation_execute() requires a client "
"and one has not been set.");
RETURN (false);
}
cluster = &bulk->client->cluster;
if (bulk->executed) {
_mongoc_write_result_destroy (&bulk->result);
_mongoc_write_result_init (&bulk->result);
}
bulk->executed = true;
if (!bulk->database) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"mongoc_bulk_operation_execute() requires a database "
"and one has not been set.");
RETURN (false);
} else if (!bulk->collection) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"mongoc_bulk_operation_execute() requires a collection "
"and one has not been set.");
RETURN (false);
}
/* error stored by functions like mongoc_bulk_operation_insert that
* can't report errors immediately */
if (bulk->result.error.domain) {
if (error) {
memcpy (error, &bulk->result.error, sizeof (bson_error_t));
}
RETURN (false);
}
if (!bulk->commands.len) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"Cannot do an empty bulk write");
RETURN (false);
}
for (i = 0; i < bulk->commands.len; i++) {
if (bulk->server_id) {
server_stream = mongoc_cluster_stream_for_server (
cluster, bulk->server_id, true /* reconnect_ok */, error);
} else {
server_stream = mongoc_cluster_stream_for_writes (cluster, error);
}
if (!server_stream) {
RETURN (false);
}
command =
&_mongoc_array_index (&bulk->commands, mongoc_write_command_t, i);
_mongoc_write_command_execute (command,
bulk->client,
server_stream,
bulk->database,
bulk->collection,
bulk->write_concern,
offset,
bulk->session,
&bulk->result);
bulk->server_id = server_stream->sd->id;
if (bulk->result.failed &&
(bulk->flags.ordered || bulk->result.must_stop)) {
mongoc_server_stream_cleanup (server_stream);
GOTO (cleanup);
}
offset += command->n_documents;
mongoc_server_stream_cleanup (server_stream);
}
cleanup:
ret = MONGOC_WRITE_RESULT_COMPLETE (&bulk->result,
bulk->client->error_api_version,
bulk->write_concern,
MONGOC_ERROR_COMMAND /* err domain */,
reply,
error);
RETURN (ret ? bulk->server_id : 0);
}
uint32_t
mongoc_bulk_operation_execute (mongoc_bulk_operation_t *bulk, /* IN */
bson_t *reply, /* OUT */
bson_error_t *error) /* OUT */
{
mongoc_write_command_t *command;
uint32_t hint = 0;
bool ret;
int i;
ENTRY;
bson_return_val_if_fail (bulk, false);
if (bulk->executed) {
_mongoc_write_result_destroy (&bulk->result);
}
_mongoc_write_result_init (&bulk->result);
bulk->executed = true;
if (!bulk->client) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"mongoc_bulk_operation_execute() requires a client "
"and one has not been set.");
RETURN (false);
} else if (!bulk->database) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"mongoc_bulk_operation_execute() requires a database "
"and one has not been set.");
RETURN (false);
} else if (!bulk->collection) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"mongoc_bulk_operation_execute() requires a collection "
"and one has not been set.");
RETURN (false);
}
if (reply) {
bson_init (reply);
}
if (!bulk->commands.len) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"Cannot do an empty bulk write");
RETURN (false);
}
for (i = 0; i < bulk->commands.len; i++) {
command = &_mongoc_array_index (&bulk->commands,
mongoc_write_command_t, i);
_mongoc_write_command_execute (command, bulk->client, hint,
bulk->database, bulk->collection,
bulk->write_concern, &bulk->result);
hint = command->hint;
if (bulk->result.failed && bulk->ordered) {
GOTO (cleanup);
}
}
cleanup:
ret = _mongoc_write_result_complete (&bulk->result, reply, error);
RETURN (ret ? hint : 0);
}
static void
test_split_insert (void)
{
mongoc_bulk_write_flags_t write_flags = MONGOC_BULK_WRITE_FLAGS_INIT;
mongoc_write_command_t command;
mongoc_write_result_t result;
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_oid_t oid;
bson_t **docs;
bson_t reply = BSON_INITIALIZER;
bson_error_t error;
mongoc_server_stream_t *server_stream;
int i;
bool r;
client = test_framework_client_new ();
assert (client);
collection = get_test_collection (client, "test_split_insert");
assert (collection);
docs = (bson_t **)bson_malloc (sizeof(bson_t*) * 3000);
for (i = 0; i < 3000; i++) {
docs [i] = bson_new ();
bson_oid_init (&oid, NULL);
BSON_APPEND_OID (docs [i], "_id", &oid);
}
_mongoc_write_result_init (&result);
_mongoc_write_command_init_insert (&command,
docs[0],
write_flags,
++client->cluster.operation_id,
true);
for (i = 1; i < 3000; i++) {
_mongoc_write_command_insert_append (&command, docs[i]);
}
server_stream = mongoc_cluster_stream_for_writes (&client->cluster, &error);
ASSERT_OR_PRINT (server_stream, error);
_mongoc_write_command_execute (&command, client, server_stream, collection->db,
collection->collection, NULL, 0, &result);
r = _mongoc_write_result_complete (&result, 2, collection->write_concern,
&reply, &error);
ASSERT_OR_PRINT (r, error);
assert (result.nInserted == 3000);
_mongoc_write_command_destroy (&command);
_mongoc_write_result_destroy (&result);
ASSERT_OR_PRINT (mongoc_collection_drop (collection, &error), error);
for (i = 0; i < 3000; i++) {
bson_destroy (docs [i]);
}
bson_free (docs);
mongoc_server_stream_cleanup (server_stream);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
}
uint32_t
mongoc_bulk_operation_execute (mongoc_bulk_operation_t *bulk, /* IN */
bson_t *reply, /* OUT */
bson_error_t *error) /* OUT */
{
mongoc_cluster_t *cluster;
mongoc_write_command_t *command;
mongoc_server_stream_t *server_stream;
bool ret;
uint32_t offset = 0;
int i;
ENTRY;
BSON_ASSERT (bulk);
cluster = &bulk->client->cluster;
if (bulk->executed) {
_mongoc_write_result_destroy (&bulk->result);
}
_mongoc_write_result_init (&bulk->result);
bulk->executed = true;
if (!bulk->client) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"mongoc_bulk_operation_execute() requires a client "
"and one has not been set.");
RETURN (false);
} else if (!bulk->database) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"mongoc_bulk_operation_execute() requires a database "
"and one has not been set.");
RETURN (false);
} else if (!bulk->collection) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"mongoc_bulk_operation_execute() requires a collection "
"and one has not been set.");
RETURN (false);
}
if (reply) {
bson_init (reply);
}
if (!bulk->commands.len) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"Cannot do an empty bulk write");
RETURN (false);
}
if (bulk->server_id) {
server_stream = mongoc_cluster_stream_for_server (cluster,
bulk->server_id,
true /* reconnect_ok */,
error);
} else {
server_stream = mongoc_cluster_stream_for_writes (cluster, error);
}
if (!server_stream) {
RETURN (false);
}
for (i = 0; i < bulk->commands.len; i++) {
command = &_mongoc_array_index (&bulk->commands,
mongoc_write_command_t, i);
_mongoc_write_command_execute (command, bulk->client, server_stream,
bulk->database, bulk->collection,
bulk->write_concern, offset,
&bulk->result);
bulk->server_id = command->server_id;
if (bulk->result.failed && bulk->flags.ordered) {
GOTO (cleanup);
}
offset += command->n_documents;
}
cleanup:
ret = _mongoc_write_result_complete (&bulk->result, reply, error);
mongoc_server_stream_cleanup (server_stream);
RETURN (ret ? bulk->server_id : 0);
}