bool
_mongoc_convert_server_id (mongoc_client_t *client,
const bson_iter_t *iter,
uint32_t *server_id,
bson_error_t *error)
{
int64_t tmp;
if (!BSON_ITER_HOLDS_INT (iter)) {
CONVERSION_ERR ("The serverId option must be an integer");
}
tmp = bson_iter_as_int64 (iter);
if (tmp <= 0) {
CONVERSION_ERR ("The serverId option must be >= 1");
}
*server_id = (uint32_t) tmp;
return true;
}
void
_mongoc_write_command_delete_legacy (
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)
{
int64_t started;
int32_t max_bson_obj_size;
const uint8_t *data;
mongoc_rpc_t rpc;
uint32_t request_id;
bson_iter_t q_iter;
uint32_t len;
int64_t limit = 0;
bson_t *gle = NULL;
char ns[MONGOC_NAMESPACE_MAX + 1];
bool r;
bson_reader_t *reader;
const bson_t *bson;
bool eof;
ENTRY;
BSON_ASSERT (command);
BSON_ASSERT (client);
BSON_ASSERT (database);
BSON_ASSERT (server_stream);
BSON_ASSERT (collection);
started = bson_get_monotonic_time ();
max_bson_obj_size = mongoc_server_stream_max_bson_obj_size (server_stream);
if (!command->n_documents) {
bson_set_error (error,
MONGOC_ERROR_COLLECTION,
MONGOC_ERROR_COLLECTION_DELETE_FAILED,
"Cannot do an empty delete.");
result->failed = true;
EXIT;
}
bson_snprintf (ns, sizeof ns, "%s.%s", database, collection);
reader =
bson_reader_new_from_data (command->payload.data, command->payload.len);
while ((bson = bson_reader_read (reader, &eof))) {
/* the document is like { "q": { <selector> }, limit: <0 or 1> } */
r = (bson_iter_init (&q_iter, bson) && bson_iter_find (&q_iter, "q") &&
BSON_ITER_HOLDS_DOCUMENT (&q_iter));
BSON_ASSERT (r);
bson_iter_document (&q_iter, &len, &data);
BSON_ASSERT (data);
BSON_ASSERT (len >= 5);
if (len > max_bson_obj_size) {
_mongoc_write_command_too_large_error (
error, 0, len, max_bson_obj_size, NULL);
result->failed = true;
bson_reader_destroy (reader);
EXIT;
}
request_id = ++client->cluster.request_id;
rpc.header.msg_len = 0;
rpc.header.request_id = request_id;
rpc.header.response_to = 0;
rpc.header.opcode = MONGOC_OPCODE_DELETE;
rpc.delete_.zero = 0;
rpc.delete_.collection = ns;
if (bson_iter_find (&q_iter, "limit") &&
(BSON_ITER_HOLDS_INT (&q_iter))) {
limit = bson_iter_as_int64 (&q_iter);
}
rpc.delete_.flags =
limit ? MONGOC_DELETE_SINGLE_REMOVE : MONGOC_DELETE_NONE;
rpc.delete_.selector = data;
_mongoc_monitor_legacy_write (client,
command,
database,
collection,
write_concern,
server_stream,
request_id);
if (!mongoc_cluster_legacy_rpc_sendv_to_server (
&client->cluster, &rpc, server_stream, write_concern, error)) {
result->failed = true;
bson_reader_destroy (reader);
EXIT;
}
if (mongoc_write_concern_is_acknowledged (write_concern)) {
if (!_mongoc_client_recv_gle (client, server_stream, &gle, error)) {
result->failed = true;
bson_reader_destroy (reader);
EXIT;
}
_mongoc_write_result_merge_legacy (
result,
command,
gle,
client->error_api_version,
MONGOC_ERROR_COLLECTION_DELETE_FAILED,
offset);
offset++;
}
_mongoc_monitor_legacy_write_succeeded (client,
bson_get_monotonic_time () -
started,
command,
gle,
server_stream,
request_id);
if (gle) {
bson_destroy (gle);
gle = NULL;
}
started = bson_get_monotonic_time ();
}
bson_reader_destroy (reader);
EXIT;
}
mongoc_change_stream_t *
_mongoc_change_stream_new (const mongoc_collection_t *coll,
const bson_t *pipeline,
const bson_t *opts)
{
bool full_doc_set = false;
mongoc_change_stream_t *stream =
(mongoc_change_stream_t *) bson_malloc0 (sizeof (mongoc_change_stream_t));
BSON_ASSERT (coll);
BSON_ASSERT (pipeline);
stream->max_await_time_ms = -1;
stream->batch_size = -1;
stream->coll = mongoc_collection_copy ((mongoc_collection_t *) coll);
bson_init (&stream->pipeline_to_append);
bson_init (&stream->full_document);
bson_init (&stream->opts);
bson_init (&stream->resume_token);
bson_init (&stream->err_doc);
/*
* The passed options may consist of:
* fullDocument: 'default'|'updateLookup', passed to $changeStream stage
* resumeAfter: optional<Doc>, passed to $changeStream stage
* maxAwaitTimeMS: Optional<Int64>, set on the cursor
* batchSize: Optional<Int32>, passed as agg option, {cursor: { batchSize: }}
* standard command options like "sessionId", "maxTimeMS", or "collation"
*/
if (opts) {
bson_iter_t iter;
if (bson_iter_init_find (&iter, opts, "fullDocument")) {
SET_BSON_OR_ERR (&stream->full_document, "fullDocument");
full_doc_set = true;
}
if (bson_iter_init_find (&iter, opts, "resumeAfter")) {
SET_BSON_OR_ERR (&stream->resume_token, "resumeAfter");
}
if (bson_iter_init_find (&iter, opts, "batchSize")) {
if (BSON_ITER_HOLDS_INT32 (&iter)) {
stream->batch_size = bson_iter_int32 (&iter);
}
}
if (bson_iter_init_find (&iter, opts, "maxAwaitTimeMS") &&
BSON_ITER_HOLDS_INT (&iter)) {
stream->max_await_time_ms = bson_iter_as_int64 (&iter);
}
/* save the remaining opts for mongoc_collection_read_command_with_opts */
bson_copy_to_excluding_noinit (opts,
&stream->opts,
"fullDocument",
"resumeAfter",
"batchSize",
"maxAwaitTimeMS",
NULL);
}
if (!full_doc_set) {
if (!BSON_APPEND_UTF8 (
&stream->full_document, "fullDocument", "default")) {
CHANGE_STREAM_ERR ("fullDocument");
}
}
/* Accept two forms of user pipeline:
* 1. A document like: { "pipeline": [...] }
* 2. An array-like document: { "0": {}, "1": {}, ... }
* If the passed pipeline is invalid, we pass it along and let the server
* error instead.
*/
if (!bson_empty (pipeline)) {
bson_iter_t iter;
if (bson_iter_init_find (&iter, pipeline, "pipeline") &&
BSON_ITER_HOLDS_ARRAY (&iter)) {
SET_BSON_OR_ERR (&stream->pipeline_to_append, "pipeline");
} else {
if (!BSON_APPEND_ARRAY (
&stream->pipeline_to_append, "pipeline", pipeline)) {
CHANGE_STREAM_ERR ("pipeline");
}
}
}
if (stream->err.code == 0) {
(void) _make_cursor (stream);
}
return stream;
}
