static void
test_bson_iter_utf8 (void)
{
uint32_t len = 0;
bson_iter_t iter;
bson_t *b;
char *s;
b = bson_new();
assert(bson_append_utf8(b, "foo", -1, "bar", -1));
assert(bson_append_utf8(b, "bar", -1, "baz", -1));
assert(bson_iter_init(&iter, b));
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_UTF8(&iter));
assert(!strcmp(bson_iter_key(&iter), "foo"));
assert(!strcmp(bson_iter_utf8(&iter, NULL), "bar"));
s = bson_iter_dup_utf8(&iter, &len);
assert_cmpstr("bar", s);
assert_cmpint(len, ==, 3);
bson_free(s);
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_UTF8(&iter));
assert(!strcmp(bson_iter_key(&iter), "bar"));
assert(!strcmp(bson_iter_utf8(&iter, NULL), "baz"));
assert(!bson_iter_next(&iter));
bson_destroy(b);
}
/*
* If error is not set, set code from first document in array like
* [{"code": 64, "errmsg": "duplicate"}, ...]. Format the error message
* from all errors in array.
*/
static void
_set_error_from_response (bson_t *bson_array,
mongoc_error_domain_t domain,
const char *error_type,
bson_error_t *error /* OUT */)
{
bson_iter_t array_iter;
bson_iter_t doc_iter;
bson_string_t *compound_err;
const char *errmsg = NULL;
int32_t code = 0;
uint32_t n_keys, i;
compound_err = bson_string_new (NULL);
n_keys = bson_count_keys (bson_array);
if (n_keys > 1) {
bson_string_append_printf (
compound_err, "Multiple %s errors: ", error_type);
}
if (!bson_empty0 (bson_array) && bson_iter_init (&array_iter, bson_array)) {
/* get first code and all error messages */
i = 0;
while (bson_iter_next (&array_iter)) {
if (BSON_ITER_HOLDS_DOCUMENT (&array_iter) &&
bson_iter_recurse (&array_iter, &doc_iter)) {
/* parse doc, which is like {"code": 64, "errmsg": "duplicate"} */
while (bson_iter_next (&doc_iter)) {
/* use the first error code we find */
if (BSON_ITER_IS_KEY (&doc_iter, "code") && code == 0) {
code = bson_iter_int32 (&doc_iter);
} else if (BSON_ITER_IS_KEY (&doc_iter, "errmsg")) {
errmsg = bson_iter_utf8 (&doc_iter, NULL);
/* build message like 'Multiple write errors: "foo", "bar"' */
if (n_keys > 1) {
bson_string_append_printf (compound_err, "\"%s\"", errmsg);
if (i < n_keys - 1) {
bson_string_append (compound_err, ", ");
}
} else {
/* single error message */
bson_string_append (compound_err, errmsg);
}
}
}
i++;
}
}
if (code && compound_err->len) {
bson_set_error (
error, domain, (uint32_t) code, "%s", compound_err->str);
}
}
bson_string_free (compound_err, true);
}
void _aggregate_recurse_fill(bson_iter_t *iter, bson_t* new_doc, bson_t* existing_aggregate_doc, bson_t* merged_aggregate_doc, const char *key) {
bson_iter_t child_iter;
bson_t child_doc;
while (bson_iter_next (iter)) {
int new_key_length = strlen(bson_iter_key(iter));
if (strcmp("", key) != 0) {
new_key_length += strlen(key) + 1;
}
char new_key[new_key_length];
if (strcmp("", key) == 0) {
strcpy(new_key, bson_iter_key(iter));
} else {
strcpy(new_key, key);
strcat(new_key, ".");
strcat(new_key, bson_iter_key(iter));
}
if (strcmp("_id", new_key) == 0) {
bson_value_t *existing_id = _aggregate_get_value_at_key(existing_aggregate_doc, "_id");
bson_append_value(merged_aggregate_doc, "_id", -1, existing_id);
continue;
}
if (BSON_ITER_HOLDS_DOCUMENT (iter)) {
const char *agg_key = NULL;
const bson_value_t *agg_field = NULL;
if (bson_iter_recurse (iter, &child_iter)) {
if (bson_iter_next (&child_iter) &&
_aggregate_is_agg_operator(bson_iter_key(&child_iter))) {
agg_key = bson_iter_key(&child_iter);
agg_field = bson_iter_value(&child_iter);
}
if (agg_key && !bson_iter_next (&child_iter)) {
bson_value_t *existing_value = _aggregate_get_value_at_key(existing_aggregate_doc, new_key);
bson_value_t *new_doc_value = _aggregate_get_value_at_key(new_doc, (*agg_field).value.v_utf8.str + 1);
bson_value_t * agg_result = _aggregate(existing_value, new_doc_value, agg_key);
bson_append_value(merged_aggregate_doc, bson_iter_key(iter), -1, agg_result);
continue;
}
}
bson_append_document_begin (merged_aggregate_doc, bson_iter_key(iter), -1, &child_doc);
if (bson_iter_recurse (iter, &child_iter)) {
_aggregate_recurse_fill (&child_iter, new_doc, existing_aggregate_doc, &child_doc, new_key);
}
bson_append_document_end (merged_aggregate_doc, &child_doc);
} else {
bson_append_value(merged_aggregate_doc, bson_iter_key(iter), -1, bson_iter_value(iter));
}
}
}
/*
*-----------------------------------------------------------------------
*
* Run the JSON tests from the SDAM Monitoring spec.
*
*-----------------------------------------------------------------------
*/
static void
test_sdam_monitoring_cb (bson_t *test)
{
mongoc_client_t *client;
mongoc_topology_t *topology;
bson_t phase;
bson_t phases;
bson_t outcome;
bson_iter_t phase_iter;
bson_iter_t phase_field_iter;
bson_iter_t outcome_iter;
bson_iter_t iter;
bson_t events_expected;
context_t context;
/* parse out the uri and use it to create a client */
BSON_ASSERT (bson_iter_init_find (&iter, test, "uri"));
client = mongoc_client_new (bson_iter_utf8 (&iter, NULL));
topology = client->topology;
context_init (&context);
client_set_topology_event_callbacks (client, &context);
/* for each phase, parse and validate */
BSON_ASSERT (bson_iter_init_find (&iter, test, "phases"));
bson_iter_bson (&iter, &phases);
bson_iter_init (&phase_iter, &phases);
while (bson_iter_next (&phase_iter)) {
bson_iter_bson (&phase_iter, &phase);
/* this test doesn't exercise this code path naturally, see below in
* _test_topology_events for a non-hacky test of this event */
_mongoc_topology_description_monitor_opening (&topology->description);
process_sdam_test_ismaster_responses (&phase,
&client->topology->description);
/* parse out "outcome" and validate */
BSON_ASSERT (bson_iter_init_find (&phase_field_iter, &phase, "outcome"));
bson_iter_bson (&phase_field_iter, &outcome);
bson_iter_init (&outcome_iter, &outcome);
while (bson_iter_next (&outcome_iter)) {
if (strcmp ("events", bson_iter_key (&outcome_iter)) == 0) {
bson_iter_bson (&outcome_iter, &events_expected);
check_json_apm_events (&context.events, &events_expected);
} else {
fprintf (stderr,
"ERROR: unparsed test field %s\n",
bson_iter_key (&outcome_iter));
BSON_ASSERT (false);
}
}
}
mongoc_client_destroy (client);
context_destroy (&context);
}
static int
_score_tags (const bson_t *read_tags,
const bson_t *node_tags)
{
uint32_t len;
bson_iter_t iter;
bson_iter_t sub_iter;
const char *key;
const char *str;
int count;
bool node_matches_set;
bson_return_val_if_fail(read_tags, -1);
bson_return_val_if_fail(node_tags, -1);
count = bson_count_keys(read_tags);
/* Execute this block if read tags were provided, else bail and return 0 (all nodes equal) */
if (!bson_empty(read_tags) && bson_iter_init(&iter, read_tags)) {
/*
* Iterate over array of read tag sets provided (each element is a tag set)
* Tag sets are provided in order of preference so return the count of the
* first set that matches the node or -1 if no set matched the node.
*/
while (count && bson_iter_next(&iter)) {
if (BSON_ITER_HOLDS_DOCUMENT(&iter) && bson_iter_recurse(&iter, &sub_iter)) {
node_matches_set = true;
/* Iterate over the key/value pairs (tags) in the current set */
while (bson_iter_next(&sub_iter) && BSON_ITER_HOLDS_UTF8(&sub_iter)) {
key = bson_iter_key(&sub_iter);
str = bson_iter_utf8(&sub_iter, &len);
/* If any of the tags do not match, this node cannot satisfy this tag set. */
if (!_contains_tag(node_tags, key, str, len)) {
node_matches_set = false;
break;
}
}
/* This set matched, return the count as the score */
if (node_matches_set) {
return count;
}
/* Decrement the score and try to match the next set. */
count--;
}
}
return -1;
}
return 0;
}
static void
_test_topology_events (bool pooled)
{
mongoc_client_t *client;
mongoc_client_pool_t *pool = NULL;
context_t context;
bool r;
bson_error_t error;
bson_iter_t events_iter;
bson_iter_t event_iter;
uint32_t i;
context_init (&context);
if (pooled) {
pool = test_framework_client_pool_new ();
pool_set_topology_event_callbacks (pool, &context);
client = mongoc_client_pool_pop (pool);
} else {
client = test_framework_client_new ();
client_set_topology_event_callbacks (client, &context);
}
r = mongoc_client_command_simple (client, "admin", tmp_bson ("{'ping': 1}"),
NULL, NULL, &error);
ASSERT_OR_PRINT (r, error);
if (pooled) {
mongoc_client_pool_push (pool, client);
mongoc_client_pool_destroy (pool);
} else {
mongoc_client_destroy (client);
}
/* first event is topology opening */
bson_iter_init (&events_iter, &context.events);
bson_iter_next (&events_iter);
ASSERT (bson_iter_recurse (&events_iter, &event_iter));
ASSERT (bson_iter_find (&event_iter, "topology_opening_event"));
/* last event is topology closed */
for (i = 1; i < context.n_events; i++) {
ASSERT (bson_iter_next (&events_iter));
}
ASSERT (bson_iter_recurse (&events_iter, &event_iter));
ASSERT (bson_iter_find (&event_iter, "topology_closed_event"));
/* no more events */
ASSERT (!bson_iter_next (&events_iter));
context_destroy (&context);
}
SEXP ConvertArray(bson_iter_t* iter, bson_iter_t* counter){
SEXP ret;
int count = 0;
while(bson_iter_next(counter)){
count++;
}
PROTECT(ret = allocVector(VECSXP, count));
for (int i = 0; bson_iter_next(iter); i++) {
SET_VECTOR_ELT(ret, i, ConvertValue(iter));
}
UNPROTECT(1);
return ret;
}
static void
test_bson_append_iter (void)
{
bson_iter_t iter;
bson_bool_t r;
bson_t b;
bson_t c;
bson_init(&b);
bson_append_int32(&b, "a", 1, 1);
bson_append_int32(&b, "b", 1, 2);
bson_append_int32(&b, "c", 1, 3);
bson_append_utf8(&b, "d", 1, "hello", 5);
bson_init(&c);
r = bson_iter_init_find(&iter, &b, "a");
assert(r);
r = bson_append_iter(&c, NULL, 0, &iter);
assert(r);
r = bson_iter_init_find(&iter, &b, "c");
assert(r);
r = bson_append_iter(&c, NULL, 0, &iter);
assert(r);
r = bson_iter_init_find(&iter, &b, "d");
assert(r);
r = bson_append_iter(&c, "world", -1, &iter);
assert(r);
bson_iter_init(&iter, &c);
r = bson_iter_next(&iter);
assert(r);
assert_cmpstr("a", bson_iter_key(&iter));
assert_cmpint(BSON_TYPE_INT32, ==, bson_iter_type(&iter));
assert_cmpint(1, ==, bson_iter_int32(&iter));
r = bson_iter_next(&iter);
assert(r);
assert_cmpstr("c", bson_iter_key(&iter));
assert_cmpint(BSON_TYPE_INT32, ==, bson_iter_type(&iter));
assert_cmpint(3, ==, bson_iter_int32(&iter));
r = bson_iter_next(&iter);
assert(r);
assert_cmpint(BSON_TYPE_UTF8, ==, bson_iter_type(&iter));
assert_cmpstr("world", bson_iter_key(&iter));
assert_cmpstr("hello", bson_iter_utf8(&iter, NULL));
bson_destroy(&b);
bson_destroy(&c);
}
static void
test_bson_iter_mixed (void)
{
bson_iter_t iter;
bson_decimal128_t iter_value;
bson_decimal128_t value;
bson_t *b;
bson_t *b2;
b = bson_new();
b2 = bson_new();
value.high = 0;
value.low = 1;
assert(bson_append_utf8(b2, "foo", -1, "bar", -1));
assert(bson_append_code(b, "0", -1, "var a = {};"));
assert(bson_append_code_with_scope(b, "1", -1, "var b = {};", b2));
assert(bson_append_int32(b, "2", -1, 1234));
assert(bson_append_int64(b, "3", -1, 4567));
assert(bson_append_time_t(b, "4", -1, 123456));
assert(bson_append_decimal128(b, "5", -1, &value));
assert(bson_iter_init(&iter, b));
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_CODE(&iter));
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_CODEWSCOPE(&iter));
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_INT32(&iter));
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_INT64(&iter));
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_DATE_TIME(&iter));
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_DECIMAL128(&iter));
assert(!bson_iter_next(&iter));
assert(bson_iter_init_find(&iter, b, "3"));
assert(!strcmp(bson_iter_key(&iter), "3"));
assert(bson_iter_int64(&iter) == 4567);
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_DATE_TIME(&iter));
assert(bson_iter_time_t(&iter) == 123456);
assert(bson_iter_date_time(&iter) == 123456000);
assert(bson_iter_next(&iter));
/* This test uses memcmp because libbson lacks decimal128 comparison. */
bson_iter_decimal128(&iter, &iter_value);
assert(memcmp(&iter_value, &value, sizeof(value)) == 0);
assert(!bson_iter_next(&iter));
bson_destroy(b);
bson_destroy(b2);
}
int32_t
_mongoc_write_result_merge_arrays (uint32_t offset,
mongoc_write_result_t *result, /* IN */
bson_t *dest, /* IN */
bson_iter_t *iter) /* IN */
{
const bson_value_t *value;
bson_iter_t ar;
bson_iter_t citer;
int32_t idx;
int32_t count = 0;
int32_t aridx;
bson_t child;
const char *keyptr = NULL;
char key[12];
int len;
ENTRY;
BSON_ASSERT (result);
BSON_ASSERT (dest);
BSON_ASSERT (iter);
BSON_ASSERT (BSON_ITER_HOLDS_ARRAY (iter));
aridx = bson_count_keys (dest);
if (bson_iter_recurse (iter, &ar)) {
while (bson_iter_next (&ar)) {
if (BSON_ITER_HOLDS_DOCUMENT (&ar) &&
bson_iter_recurse (&ar, &citer)) {
len =
(int) bson_uint32_to_string (aridx++, &keyptr, key, sizeof key);
bson_append_document_begin (dest, keyptr, len, &child);
while (bson_iter_next (&citer)) {
if (BSON_ITER_IS_KEY (&citer, "index")) {
idx = bson_iter_int32 (&citer) + offset;
BSON_APPEND_INT32 (&child, "index", idx);
} else {
value = bson_iter_value (&citer);
BSON_APPEND_VALUE (&child, bson_iter_key (&citer), value);
}
}
bson_append_document_end (dest, &child);
count++;
}
}
}
RETURN (count);
}
view::const_iterator& view::const_iterator::operator++() {
if (!_element) {
return *this;
}
bson_iter_t i = to_bson_iter_t(_element);
bson_iter_next(&i);
if (!bson_iter_next(&i)) {
_element = element{nullptr, 0, 0};
} else {
_element = element{i.raw, i.len, i.off};
}
return *this;
}
static void
mongoc_uri_bson_append_or_replace_key (bson_t *options, const char *option, const char *value)
{
bson_iter_t iter;
bool found = false;
if (bson_iter_init (&iter, options)) {
bson_t tmp = BSON_INITIALIZER;
while (bson_iter_next (&iter)) {
const bson_value_t *bvalue;
if (!strcasecmp(bson_iter_key (&iter), option)) {
bson_append_utf8(&tmp, option, -1, value, -1);
found = true;
continue;
}
bvalue = bson_iter_value (&iter);
BSON_APPEND_VALUE (&tmp, bson_iter_key (&iter), bvalue);
}
if (! found) {
bson_append_utf8(&tmp, option, -1, value, -1);
}
bson_destroy (options);
bson_copy_to (&tmp, options);
bson_destroy (&tmp);
}
}
/*
* Start iterating the reply to an "aggregate", "find", "getMore" etc. command:
*
* {cursor: {id: 1234, ns: "db.collection", firstBatch: [...]}}
*/
bool
_mongoc_cursor_cursorid_start_batch (mongoc_cursor_t *cursor)
{
mongoc_cursor_cursorid_t *cid;
bson_iter_t iter;
bson_iter_t child;
const char *ns;
uint32_t nslen;
cid = (mongoc_cursor_cursorid_t *)cursor->iface_data;
BSON_ASSERT (cid);
if (bson_iter_init_find (&iter, &cid->array, "cursor") &&
BSON_ITER_HOLDS_DOCUMENT (&iter) &&
bson_iter_recurse (&iter, &child)) {
while (bson_iter_next (&child)) {
if (BSON_ITER_IS_KEY (&child, "id")) {
cursor->rpc.reply.cursor_id = bson_iter_as_int64 (&child);
} else if (BSON_ITER_IS_KEY (&child, "ns")) {
ns = bson_iter_utf8 (&child, &nslen);
_mongoc_set_cursor_ns (cursor, ns, nslen);
} else if (BSON_ITER_IS_KEY (&child, "firstBatch") ||
BSON_ITER_IS_KEY (&child, "nextBatch")) {
if (BSON_ITER_HOLDS_ARRAY (&child) &&
bson_iter_recurse (&child, &cid->batch_iter)) {
cid->in_batch = true;
}
}
}
}
return cid->in_batch;
}
static void
test_reader_tell (void)
{
bson_reader_t *reader;
const bson_t *b;
bson_uint32_t i;
bson_iter_t iter;
bson_bool_t eof;
int fd;
fd = open("tests/binary/stream.bson", O_RDONLY);
assert(fd >= 0);
reader = bson_reader_new_from_fd(fd, TRUE);
for (i = 0; i < 1000; i++) {
if (i) {
assert_cmpint(5 * i, ==, bson_reader_tell(reader));
} else {
assert_cmpint(0, ==, bson_reader_tell(reader));
}
eof = FALSE;
b = bson_reader_read(reader, &eof);
assert(b);
assert(bson_iter_init(&iter, b));
assert(!bson_iter_next(&iter));
}
bool
bson_find_create_table (bson_t *bson_schema,
const char *table_name,
bson_iter_t *iter_col)
{
bson_iter_t iter_json, iter_ary, iter_sql, iter_table_prop;
bson_iter_init_find (&iter_json, bson_schema, "json") || DIE;
BSON_ITER_HOLDS_ARRAY (&iter_json) || DIE;
bson_iter_recurse (&iter_json, &iter_ary) || DIE;
while (bson_iter_next (&iter_ary)) {
(BSON_ITER_HOLDS_DOCUMENT (&iter_ary) || DIE);
bson_iter_recurse (&iter_ary, &iter_sql) || DIE;
if (bson_iter_find (&iter_sql, "create_table") &&
(BSON_ITER_HOLDS_DOCUMENT (&iter_sql) || DIE) &&
(bson_iter_recurse (&iter_sql, &iter_table_prop) || DIE) &&
(bson_iter_find (&iter_table_prop, "table_name") || DIE) &&
(BSON_ITER_HOLDS_UTF8 (&iter_table_prop) || DIE) &&
(strcmp (bson_iter_utf8 (&iter_table_prop, NULL), table_name) == 0) &&
(bson_iter_find (&iter_table_prop, "columns") || DIE) &&
(BSON_ITER_HOLDS_ARRAY (&iter_table_prop) || DIE)) {
bson_iter_recurse (&iter_table_prop, iter_col) || DIE;
return true;
}
}
return (false);
}
dir_t* dir_getDirFromBSON(const bson_t *doc) {
bson_iter_t iter;
const bson_value_t *value;
const char *key;
dir_t *dir = dir_create();
if (bson_iter_init(&iter, doc)) {
while (bson_iter_next(&iter)) {
key = bson_iter_key(&iter);
value = bson_iter_value(&iter);
if (strcmp(key, "_id") == 0) {
strcpy(dir->id, value->value.v_utf8.str);
} else if (strcmp(key, "name") == 0) {
dir->name = strdup(value->value.v_utf8.str);
} else if (strcmp(key, "parentId") == 0) {
strcpy(dir->parentId, value->value.v_utf8.str);
}
/*
if (bson_iter_find(&iter, "_id")) strcpy(dir->id, bson_iter_utf8(&iter, NULL));
if (bson_iter_find(&iter, "name")) strcpy(dir->name, bson_iter_utf8(&iter, NULL));
if (bson_iter_find(&iter, "parentId")) strcpy(dir->parentId, bson_iter_utf8(&iter, NULL));
*/
}
}
return dir;
}
view::const_iterator view::find(stdx::string_view key) const {
bson_t b;
bson_iter_t iter;
if (!bson_init_static(&b, _data, _length)) {
return cend();
}
if (!bson_iter_init(&iter, &b)) {
return cend();
}
if (key.empty()) {
return cend();
}
while (bson_iter_next(&iter)) {
const char* ikey = bson_iter_key(&iter);
if (0 == strncmp(key.data(), ikey, key.size())) {
return const_iterator(element(iter.raw, iter.len, iter.off));
}
}
return cend();
}
static void
test_reader_from_fd (void)
{
bson_reader_t *reader;
const bson_t *b;
bson_uint32_t i;
bson_iter_t iter;
bson_bool_t eof;
int fd;
fd = bson_open("tests/binary/stream.bson", BSON_O_RDONLY);
assert(fd >= 0);
reader = bson_reader_new_from_fd(fd, TRUE);
for (i = 0; i < 1000; i++) {
eof = FALSE;
b = bson_reader_read(reader, &eof);
assert(b);
assert(bson_iter_init(&iter, b));
assert(!bson_iter_next(&iter));
}
assert_cmpint(eof, ==, FALSE);
b = bson_reader_read(reader, &eof);
assert(!b);
assert_cmpint(eof, ==, TRUE);
bson_reader_destroy(reader);
}
/*
*--------------------------------------------------------------------------
*
* mongoc_server_description_has_rs_member --
*
* Return true if this address is included in server's list of rs
* members, false otherwise.
*
* Returns:
* true, false
*
* Side effects:
* None
*
*--------------------------------------------------------------------------
*/
bool
mongoc_server_description_has_rs_member(mongoc_server_description_t *server,
const char *address)
{
bson_iter_t member_iter;
const bson_t *rs_members[3];
int i;
if (server->type != MONGOC_SERVER_UNKNOWN) {
rs_members[0] = &server->hosts;
rs_members[1] = &server->arbiters;
rs_members[2] = &server->passives;
for (i = 0; i < 3; i++) {
bson_iter_init (&member_iter, rs_members[i]);
while (bson_iter_next (&member_iter)) {
if (strcasecmp (address, bson_iter_utf8 (&member_iter, NULL)) == 0) {
return true;
}
}
}
}
return false;
}
static int
_score_tags (const bson_t *read_tags,
const bson_t *node_tags)
{
uint32_t len;
bson_iter_t iter;
const char *key;
const char *str;
int count;
int i;
bson_return_val_if_fail(read_tags, -1);
bson_return_val_if_fail(node_tags, -1);
count = bson_count_keys(read_tags);
if (!bson_empty(read_tags) && bson_iter_init(&iter, read_tags)) {
for (i = count; bson_iter_next(&iter); i--) {
if (BSON_ITER_HOLDS_UTF8(&iter)) {
key = bson_iter_key(&iter);
str = bson_iter_utf8(&iter, &len);
if (_contains_tag(node_tags, key, str, len)) {
return count;
}
}
}
return -1;
}
return 0;
}
void
mongoc_bulk_operation_update_one (mongoc_bulk_operation_t *bulk,
const bson_t *selector,
const bson_t *document,
bool upsert)
{
mongoc_write_command_t command = { 0 };
bson_iter_t iter;
bson_return_if_fail (bulk);
bson_return_if_fail (selector);
bson_return_if_fail (document);
ENTRY;
if (bson_iter_init (&iter, document)) {
while (bson_iter_next (&iter)) {
if (!strchr (bson_iter_key (&iter), '$')) {
MONGOC_WARNING ("%s(): update_one only works with $ operators.",
__FUNCTION__);
EXIT;
}
}
}
_mongoc_write_command_init_update (&command, selector, document, upsert,
false, bulk->ordered);
_mongoc_array_append_val (&bulk->commands, command);
EXIT;
}
static void
test_bson_iter_next_after_finish (void)
{
bson_iter_t iter;
bson_t *b;
int i;
b = bson_new();
assert(bson_append_int32(b, "key", -1, 1234));
assert(bson_iter_init(&iter, b));
assert(bson_iter_next(&iter));
for (i = 0; i < 1000; i++) {
assert(!bson_iter_next(&iter));
}
bson_destroy(b);
}
SimCommand *
sim_parser_bson_connect(SimParser *self, bson_iter_t *piter)
{
g_return_val_if_fail (piter != NULL, NULL);
SimCommand * cmd = NULL;
gboolean error = FALSE;
//int i;
if ((cmd = sim_command_new ()) == NULL)
{
return NULL;
}
cmd->type = SIM_COMMAND_TYPE_CONNECT;
while (bson_iter_next (piter) && !error)
{
const char *key = bson_iter_key(piter);
const struct _connect_fields *connect_info;
if (( connect_info = g_hash_table_lookup (self->priv->connect_fields, (gpointer)key)) != NULL)
{
if (!connect_info->parsefunc (piter, key, cmd))
error = TRUE;
else
{
if (self->priv->connect_required[connect_info->index] != FALSE )
{
error = TRUE;
g_message ("Bad BSON connect message (duplicated required key)");
}
else
{
self->priv->connect_required[connect_info->index] = TRUE;
}
}
}
else
{
g_message ("Bad key in connect message '%s'", key);
}
}
/* Check required fields */
#if 0
i = 0;
while (!error && i < 4)
{
if (!self->priv->connect_required[i])
{
error = TRUE;
g_message ("Bad BSON connect message (missing required key)");
}
i++;
}
#endif
if (error)
{
g_message ("Can't parse connect message");
g_object_unref (cmd);
cmd = NULL;
}
return cmd;
}
static void
copy_labels_plus_unknown_commit_result (const bson_t *src, bson_t *dst)
{
bson_iter_t iter;
bson_iter_t src_label;
bson_t dst_labels;
char str[16];
uint32_t i = 0;
const char *key;
BSON_APPEND_ARRAY_BEGIN (dst, "errorLabels", &dst_labels);
BSON_APPEND_UTF8 (&dst_labels, "0", UNKNOWN_COMMIT_RESULT);
/* append any other errorLabels already in "src" */
if (bson_iter_init_find (&iter, src, "errorLabels") &&
bson_iter_recurse (&iter, &src_label)) {
while (bson_iter_next (&src_label) && BSON_ITER_HOLDS_UTF8 (&src_label)) {
if (strcmp (bson_iter_utf8 (&src_label, NULL),
UNKNOWN_COMMIT_RESULT) != 0) {
i++;
bson_uint32_to_string (i, &key, str, sizeof str);
BSON_APPEND_UTF8 (
&dst_labels, key, bson_iter_utf8 (&src_label, NULL));
}
}
}
bson_append_array_end (dst, &dst_labels);
}
static bool
_mongoc_cursor_array_next (mongoc_cursor_t *cursor,
const bson_t **bson)
{
bool ret = true;
mongoc_cursor_array_t *arr;
ENTRY;
arr = (mongoc_cursor_array_t *)cursor->iface_data;
*bson = NULL;
if (!arr->has_array) {
ret = _mongoc_cursor_array_prime(cursor);
}
if (ret) {
ret = bson_iter_next (&arr->iter);
}
if (ret) {
bson_iter_document (&arr->iter, &arr->document_len, &arr->document);
bson_init_static (&arr->bson, arr->document, arr->document_len);
*bson = &arr->bson;
}
RETURN (ret);
}
static bool hippo_cursor_next(MongoDBDriverCursorData* data)
{
invalidate_current(data);
data->next_after_rewind++;
data->current++;
if (data->is_command_cursor && bson_iter_next(&data->first_batch_iter)) {
if (BSON_ITER_HOLDS_DOCUMENT(&data->first_batch_iter)) {
const uint8_t *document = NULL;
uint32_t document_len = 0;
bson_iter_document(&data->first_batch_iter, &document_len, &document);
data->zchild_active = true;
return true;
}
}
if (hippo_cursor_load_next(data)) {
return true;
} else {
invalidate_current(data);
}
return false;
}
/* {{{ proto WriteError[] WriteResult::getWriteErrors()
Returns any write errors that occurred */
PHP_METHOD(WriteResult, getWriteErrors)
{
bson_iter_t iter, child;
php_phongo_writeresult_t *intern;
SUPPRESS_UNUSED_WARNING(return_value_ptr) SUPPRESS_UNUSED_WARNING(return_value_used)
intern = Z_WRITERESULT_OBJ_P(getThis());
if (zend_parse_parameters_none() == FAILURE) {
return;
}
array_init(return_value);
if (bson_iter_init_find(&iter, intern->reply, "writeErrors") && BSON_ITER_HOLDS_ARRAY(&iter) && bson_iter_recurse(&iter, &child)) {
while (bson_iter_next(&child)) {
bson_t cbson;
uint32_t len;
const uint8_t *data;
#if PHP_VERSION_ID >= 70000
zval writeerror;
#else
zval *writeerror = NULL;
#endif
if (!BSON_ITER_HOLDS_DOCUMENT(&child)) {
continue;
}
bson_iter_document(&child, &len, &data);
if (!bson_init_static(&cbson, data, len)) {
continue;
}
#if PHP_VERSION_ID >= 70000
object_init_ex(&writeerror, php_phongo_writeerror_ce);
if (!phongo_writeerror_init(&writeerror, &cbson TSRMLS_CC)) {
zval_ptr_dtor(&writeerror);
continue;
}
add_next_index_zval(return_value, &writeerror);
#else
MAKE_STD_ZVAL(writeerror);
object_init_ex(writeerror, php_phongo_writeerror_ce);
if (!phongo_writeerror_init(writeerror, &cbson TSRMLS_CC)) {
zval_ptr_dtor(&writeerror);
continue;
}
add_next_index_zval(return_value, writeerror);
#endif
}
}
}
static void
test_reader_tell (void)
{
bson_reader_t *reader;
const bson_t *b;
uint32_t i;
bson_iter_t iter;
bool eof;
int fd;
fd = bson_open(BINARY_DIR"/stream.bson", O_RDONLY);
assert(-1 != fd);
reader = bson_reader_new_from_handle ((void *)&fd,
&test_reader_from_handle_read,
&test_reader_from_handle_destroy);
for (i = 0; i < 1000; i++) {
if (i) {
assert_cmpint(5 * i, ==, bson_reader_tell(reader));
} else {
assert_cmpint(0, ==, bson_reader_tell(reader));
}
eof = false;
b = bson_reader_read(reader, &eof);
assert(b);
assert(bson_iter_init(&iter, b));
assert(!bson_iter_next(&iter));
}
/* {{{ proto array WriteResult::getUpsertedIds()
Returns the identifiers generated by the server for upsert operations. */
PHP_METHOD(WriteResult, getUpsertedIds)
{
bson_iter_t iter, child;
php_phongo_writeresult_t *intern;
SUPPRESS_UNUSED_WARNING(return_value_ptr) SUPPRESS_UNUSED_WARNING(return_value_used)
intern = Z_WRITERESULT_OBJ_P(getThis());
if (zend_parse_parameters_none() == FAILURE) {
return;
}
array_init(return_value);
if (bson_iter_init_find(&iter, intern->reply, "upserted") && BSON_ITER_HOLDS_ARRAY(&iter) && bson_iter_recurse(&iter, &child)) {
while (bson_iter_next(&child)) {
int32_t index;
bson_iter_t outer;
if (!BSON_ITER_HOLDS_DOCUMENT(&child) || !bson_iter_recurse(&child, &outer)) {
continue;
}
if (!bson_iter_find(&outer, "index") || !BSON_ITER_HOLDS_INT32(&outer)) {
continue;
}
index = bson_iter_int32(&outer);
if (!bson_iter_find(&outer, "_id")) {
continue;
}
if (BSON_ITER_HOLDS_OID(&outer)) {
#if PHP_VERSION_ID >= 70000
zval zid;
php_phongo_objectid_new_from_oid(&zid, bson_iter_oid(&outer) TSRMLS_CC);
add_index_zval(return_value, index, &zid);
#else
zval *zid = NULL;
MAKE_STD_ZVAL(zid);
php_phongo_objectid_new_from_oid(zid, bson_iter_oid(&outer) TSRMLS_CC);
add_index_zval(return_value, index, zid);
#endif
} else if (BSON_ITER_HOLDS_INT32(&outer)) {
int32_t val = bson_iter_int32(&outer);
add_index_long(return_value, index, val);
} else if (BSON_ITER_HOLDS_INT64(&outer)) {
int64_t val = bson_iter_int64(&outer);
ADD_INDEX_INT64(return_value, index, val);
}
}
}
}
SEXP ConvertObject(bson_iter_t* iter, bson_iter_t* counter){
SEXP names;
SEXP ret;
int count = 0;
while(bson_iter_next(counter)){
count++;
}
PROTECT(ret = allocVector(VECSXP, count));
PROTECT(names = allocVector(STRSXP, count));
for (int i = 0; bson_iter_next(iter); i++) {
SET_STRING_ELT(names, i, mkChar(bson_iter_key(iter)));
SET_VECTOR_ELT(ret, i, ConvertValue(iter));
}
setAttrib(ret, R_NamesSymbol, names);
UNPROTECT(2);
return ret;
}
