static void
_mongoc_write_command(mongoc_write_command_t *command,
mongoc_client_t *client,
mongoc_server_stream_t *server_stream,
const char *database,
const char *collection,
const mongoc_write_concern_t *write_concern,
uint32_t offset,
mongoc_write_result_t *result,
bson_error_t *error)
{
const uint8_t *data;
bson_iter_t iter;
const char *key;
uint32_t len = 0;
bson_t tmp;
bson_t ar;
bson_t cmd;
bson_t reply;
char str [16];
bool has_more;
bool ret = false;
uint32_t i;
int32_t max_bson_obj_size;
int32_t max_write_batch_size;
int32_t min_wire_version;
uint32_t key_len;
ENTRY;
BSON_ASSERT (command);
BSON_ASSERT (client);
BSON_ASSERT (database);
BSON_ASSERT (server_stream);
BSON_ASSERT (collection);
max_bson_obj_size = mongoc_server_stream_max_bson_obj_size (server_stream);
max_write_batch_size = mongoc_server_stream_max_write_batch_size (server_stream);
/*
* If we have an unacknowledged write and the server supports the legacy
* opcodes, then submit the legacy opcode so we don't need to wait for
* a response from the server.
*/
min_wire_version = server_stream->sd->min_wire_version;
if ((min_wire_version == 0) &&
!_mongoc_write_concern_needs_gle (write_concern)) {
if (command->flags.bypass_document_validation != MONGOC_BYPASS_DOCUMENT_VALIDATION_DEFAULT) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"Cannot set bypassDocumentValidation for unacknowledged writes");
EXIT;
}
gLegacyWriteOps[command->type] (command, client, server_stream, database,
collection, write_concern, offset,
result, error);
EXIT;
}
if (!command->n_documents ||
!bson_iter_init (&iter, command->documents) ||
!bson_iter_next (&iter)) {
_empty_error (command, error);
result->failed = true;
EXIT;
}
again:
bson_init (&cmd);
has_more = false;
i = 0;
BSON_APPEND_UTF8 (&cmd, gCommandNames[command->type], collection);
BSON_APPEND_DOCUMENT (&cmd, "writeConcern",
WRITE_CONCERN_DOC (write_concern));
BSON_APPEND_BOOL (&cmd, "ordered", command->flags.ordered);
if (command->flags.bypass_document_validation != MONGOC_BYPASS_DOCUMENT_VALIDATION_DEFAULT) {
BSON_APPEND_BOOL (&cmd, "bypassDocumentValidation",
!!command->flags.bypass_document_validation);
}
if (!_mongoc_write_command_will_overflow (0,
command->documents->len,
command->n_documents,
max_bson_obj_size,
max_write_batch_size)) {
/* copy the whole documents buffer as e.g. "updates": [...] */
BSON_APPEND_ARRAY (&cmd,
gCommandFields[command->type],
command->documents);
i = command->n_documents;
} else {
bson_append_array_begin (&cmd, gCommandFields[command->type], -1, &ar);
do {
if (!BSON_ITER_HOLDS_DOCUMENT (&iter)) {
BSON_ASSERT (false);
}
bson_iter_document (&iter, &len, &data);
key_len = (uint32_t) bson_uint32_to_string (i, &key, str, sizeof str);
if (_mongoc_write_command_will_overflow (ar.len,
key_len + len + 2,
i,
max_bson_obj_size,
max_write_batch_size)) {
has_more = true;
break;
}
if (!bson_init_static (&tmp, data, len)) {
BSON_ASSERT (false);
}
BSON_APPEND_DOCUMENT (&ar, key, &tmp);
bson_destroy (&tmp);
i++;
} while (bson_iter_next (&iter));
bson_append_array_end (&cmd, &ar);
}
if (!i) {
too_large_error (error, i, len, max_bson_obj_size, NULL);
result->failed = true;
ret = false;
} else {
ret = mongoc_cluster_run_command (&client->cluster, server_stream->stream,
MONGOC_QUERY_NONE, database, &cmd,
&reply, error);
if (!ret) {
result->failed = true;
}
_mongoc_write_result_merge (result, command, &reply, offset);
offset += i;
bson_destroy (&reply);
}
bson_destroy (&cmd);
if (has_more && (ret || !command->flags.ordered)) {
GOTO (again);
}
EXIT;
}
void
_mongoc_write_command_execute_idl (mongoc_write_command_t *command,
mongoc_client_t *client,
mongoc_server_stream_t *server_stream,
const char *database,
const char *collection,
uint32_t offset,
const mongoc_crud_opts_t *crud,
mongoc_write_result_t *result)
{
ENTRY;
BSON_ASSERT (command);
BSON_ASSERT (client);
BSON_ASSERT (server_stream);
BSON_ASSERT (database);
BSON_ASSERT (collection);
BSON_ASSERT (result);
if (command->flags.has_collation) {
if (!mongoc_write_concern_is_acknowledged (crud->writeConcern)) {
result->failed = true;
bson_set_error (&result->error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"Cannot set collation for unacknowledged writes");
EXIT;
}
if (server_stream->sd->max_wire_version < WIRE_VERSION_COLLATION) {
bson_set_error (&result->error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_PROTOCOL_BAD_WIRE_VERSION,
"The selected server does not support collation");
result->failed = true;
EXIT;
}
}
if (command->flags.has_array_filters) {
if (!mongoc_write_concern_is_acknowledged (crud->writeConcern)) {
result->failed = true;
bson_set_error (&result->error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"Cannot use array filters with unacknowledged writes");
EXIT;
}
if (server_stream->sd->max_wire_version < WIRE_VERSION_ARRAY_FILTERS) {
bson_set_error (&result->error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_PROTOCOL_BAD_WIRE_VERSION,
"The selected server does not support array filters");
result->failed = true;
EXIT;
}
}
if (command->flags.bypass_document_validation !=
MONGOC_BYPASS_DOCUMENT_VALIDATION_DEFAULT) {
if (!mongoc_write_concern_is_acknowledged (crud->writeConcern)) {
result->failed = true;
bson_set_error (
&result->error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"Cannot set bypassDocumentValidation for unacknowledged writes");
EXIT;
}
}
if (crud->client_session &&
!mongoc_write_concern_is_acknowledged (crud->writeConcern)) {
result->failed = true;
bson_set_error (&result->error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"Cannot use client session with unacknowledged writes");
EXIT;
}
if (command->payload.len == 0) {
_empty_error (command, &result->error);
EXIT;
}
if (server_stream->sd->max_wire_version >= WIRE_VERSION_OP_MSG) {
_mongoc_write_opmsg (command,
client,
server_stream,
database,
collection,
crud->writeConcern,
offset,
crud->client_session,
result,
&result->error);
} else {
if (mongoc_write_concern_is_acknowledged (crud->writeConcern)) {
_mongoc_write_opquery (command,
client,
server_stream,
database,
collection,
crud->writeConcern,
offset,
result,
&result->error);
} else {
gLegacyWriteOps[command->type](command,
client,
server_stream,
database,
collection,
offset,
result,
&result->error);
}
}
EXIT;
}
void
_mongoc_write_command_execute (
mongoc_write_command_t *command, /* IN */
mongoc_client_t *client, /* IN */
mongoc_server_stream_t *server_stream, /* IN */
const char *database, /* IN */
const char *collection, /* IN */
const mongoc_write_concern_t *write_concern, /* IN */
uint32_t offset, /* IN */
mongoc_client_session_t *cs, /* IN */
mongoc_write_result_t *result) /* OUT */
{
ENTRY;
BSON_ASSERT (command);
BSON_ASSERT (client);
BSON_ASSERT (server_stream);
BSON_ASSERT (database);
BSON_ASSERT (collection);
BSON_ASSERT (result);
if (!write_concern) {
write_concern = client->write_concern;
}
if (!mongoc_write_concern_is_valid (write_concern)) {
bson_set_error (&result->error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"The write concern is invalid.");
result->failed = true;
EXIT;
}
if (command->flags.has_collation) {
if (!mongoc_write_concern_is_acknowledged (write_concern)) {
result->failed = true;
bson_set_error (&result->error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"Cannot set collation for unacknowledged writes");
EXIT;
}
if (server_stream->sd->max_wire_version < WIRE_VERSION_COLLATION) {
bson_set_error (&result->error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_PROTOCOL_BAD_WIRE_VERSION,
"Collation is not supported by the selected server");
result->failed = true;
EXIT;
}
}
if (command->flags.bypass_document_validation !=
MONGOC_BYPASS_DOCUMENT_VALIDATION_DEFAULT) {
if (!mongoc_write_concern_is_acknowledged (write_concern)) {
result->failed = true;
bson_set_error (
&result->error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"Cannot set bypassDocumentValidation for unacknowledged writes");
EXIT;
}
}
if (command->payload.len == 0) {
_empty_error (command, &result->error);
EXIT;
}
if (server_stream->sd->max_wire_version >= WIRE_VERSION_OP_MSG) {
if (cs && !mongoc_write_concern_is_acknowledged (write_concern)) {
bson_set_error (
&result->error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"Cannot use client session with unacknowledged writes");
EXIT;
}
_mongoc_write_opmsg (command,
client,
server_stream,
database,
collection,
write_concern,
offset,
cs,
result,
&result->error);
} else {
if (mongoc_write_concern_is_acknowledged (write_concern)) {
_mongoc_write_opquery (command,
client,
server_stream,
database,
collection,
write_concern,
offset,
result,
&result->error);
} else {
gLegacyWriteOps[command->type](command,
client,
server_stream,
database,
collection,
offset,
result,
&result->error);
}
}
EXIT;
}