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);
}
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);
}
}
bool
_mongoc_convert_int64_positive (mongoc_client_t *client,
const bson_iter_t *iter,
int64_t *num,
bson_error_t *error)
{
int64_t i;
if (!BSON_ITER_HOLDS_NUMBER (iter)) {
CONVERSION_ERR ("Invalid field \"%s\" in opts, should contain number,"
" not %s",
bson_iter_key (iter),
_mongoc_bson_type_to_str (bson_iter_type (iter)));
}
i = bson_iter_as_int64 (iter);
if (i <= 0) {
CONVERSION_ERR ("Invalid field \"%s\" in opts, should be greater than 0,"
" not %" PRId64,
bson_iter_key (iter),
i);
}
*num = bson_iter_as_int64 (iter);
return true;
}
static void
test_bson_iter_find_descendant (void)
{
bson_iter_t iter;
bson_iter_t desc;
bson_t *b;
b = get_bson(BINARY_DIR"/dotkey.bson");
assert(bson_iter_init(&iter, b));
assert(bson_iter_find_descendant(&iter, "a.b.c.0", &desc));
assert(BSON_ITER_HOLDS_INT32(&desc));
assert(bson_iter_int32(&desc) == 1);
bson_destroy(b);
b = BCON_NEW ("foo", "{", "bar", "[", "{", "baz", BCON_INT32 (1), "}", "]", "}");
assert (bson_iter_init (&iter, b));
assert (bson_iter_find_descendant (&iter, "foo.bar.0.baz", &desc));
assert (BSON_ITER_HOLDS_INT32 (&desc));
assert (bson_iter_int32 (&desc) == 1);
bson_destroy (b);
b = BCON_NEW ("nModified", BCON_INT32 (1), "n", BCON_INT32 (2));
assert (bson_iter_init (&iter, b));
assert (bson_iter_find_descendant (&iter, "n", &desc));
assert (!strcmp (bson_iter_key (&desc), "n"));
bson_destroy (b);
b = BCON_NEW ("", BCON_INT32 (1), "n", BCON_INT32 (2));
assert (bson_iter_init (&iter, b));
assert (bson_iter_find_descendant (&iter, "n", &desc));
assert (!strcmp (bson_iter_key (&desc), "n"));
bson_destroy (b);
}
bool
_mongoc_convert_validate_flags (mongoc_client_t *client,
const bson_iter_t *iter,
bson_validate_flags_t *flags,
bson_error_t *error)
{
if (BSON_ITER_HOLDS_BOOL (iter)) {
if (!bson_iter_as_bool (iter)) {
*flags = BSON_VALIDATE_NONE;
return true;
} else {
/* validate: false is ok but validate: true is prohibited */
CONVERSION_ERR ("Invalid option \"%s\": true, must be a bitwise-OR of"
" bson_validate_flags_t values.",
bson_iter_key (iter));
}
} else if (BSON_ITER_HOLDS_INT32 (iter)) {
if (bson_iter_int32 (iter) <= 0x1F) {
*flags = (bson_validate_flags_t) bson_iter_int32 (iter);
return true;
} else {
CONVERSION_ERR ("Invalid field \"%s\" in opts, must be a bitwise-OR of"
" bson_validate_flags_t values.",
bson_iter_key (iter));
}
}
CONVERSION_ERR ("Invalid type for option \"%s\": \"%s\"."
" \"%s\" must be a boolean or a bitwise-OR of"
" bson_validate_flags_t values.",
bson_iter_key (iter),
_mongoc_bson_type_to_str (bson_iter_type (iter)),
bson_iter_key (iter));
}
bool
_mongoc_convert_document (mongoc_client_t *client,
const bson_iter_t *iter,
bson_t *doc,
bson_error_t *error)
{
uint32_t len;
const uint8_t *data;
bson_t value;
if (!BSON_ITER_HOLDS_DOCUMENT (iter)) {
CONVERSION_ERR ("Invalid field \"%s\" in opts, should contain document,"
" not %s",
bson_iter_key (iter),
_mongoc_bson_type_to_str (bson_iter_type (iter)));
}
bson_iter_document (iter, &len, &data);
if (!bson_init_static (&value, data, len)) {
BSON_ERR ("Corrupt BSON in field \"%s\" in opts", bson_iter_key (iter));
}
bson_destroy (doc);
bson_copy_to (&value, doc);
return true;
}
/*
*-----------------------------------------------------------------------
*
* 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 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);
}
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));
}
}
}
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 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;
}
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();
}
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;
}
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;
}
int main(int argc, char *argv[]) {
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_t *query;
char *str;
mongoc_init();
client = mongoc_client_new("mongodb://localhost:27017/");
collection = mongoc_client_get_collection(client, "stockopedia",
"instruments");
query = bson_new();
bson_t *fields = bson_new();
BSON_APPEND_INT32(fields, "RIC", 1);
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0,
query, fields, NULL);
bson_iter_t iter;
const bson_value_t *value;
while (mongoc_cursor_next(cursor, &doc)) {
str = bson_as_json(doc, NULL);
printf("%s\n", str);
if (bson_iter_init(&iter, doc)) {
while (bson_iter_next(&iter)) {
printf("Found a field named: %s\n", bson_iter_key(&iter));
value = bson_iter_value(&iter);
if (value->value_type == BSON_TYPE_UTF8) {
printf("It's a UTF8 : '%s'\n", value->value.v_utf8.str);
}
}
}
//printf("Found element key : '%s'\n", bson_iter_key(&iter));
// if (bson_iter_init(&iter, doc)) {
//
// }
bson_free(str);
}
//Now fetch quotes for each RIC
bson_destroy(query);
mongoc_cursor_destroy(cursor);
mongoc_collection_destroy(collection);
mongoc_client_destroy(client);
return 0;
}
static void bsonToObject(
bson_iter_t* iter, Array* output,
const StaticString* className, Array params
) {
output->add(
String(bson_iter_key(iter)),
Variant(instanceNewObject(className, params))
);
}
/* {{{ proto void BulkWrite::update(array|object $query, array|object $newObj[, array $updateOptions = array()])
Adds an update operation to bulk */
PHP_METHOD(BulkWrite, update)
{
php_phongo_bulkwrite_t *intern;
zval *query;
zval *newObj;
zval *updateOptions = NULL;
mongoc_update_flags_t flags = MONGOC_UPDATE_NONE;
bson_t *bquery;
bson_t *bupdate;
SUPPRESS_UNUSED_WARNING(return_value_ptr) SUPPRESS_UNUSED_WARNING(return_value) SUPPRESS_UNUSED_WARNING(return_value_used)
intern = Z_BULKWRITE_OBJ_P(getThis());
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "AA|a!", &query, &newObj, &updateOptions) == FAILURE) {
return;
}
bquery = bson_new();
bupdate = bson_new();
phongo_zval_to_bson(query, PHONGO_BSON_NONE, bquery, NULL TSRMLS_CC);
phongo_zval_to_bson(newObj, PHONGO_BSON_NONE, bupdate, NULL TSRMLS_CC);
if (updateOptions) {
flags |= php_array_fetch_bool(updateOptions, "multi") ? MONGOC_UPDATE_MULTI_UPDATE : 0;
flags |= php_array_fetch_bool(updateOptions, "upsert") ? MONGOC_UPDATE_UPSERT : 0;
}
if (flags & MONGOC_UPDATE_MULTI_UPDATE) {
mongoc_bulk_operation_update(intern->bulk, bquery, bupdate, !!(flags & MONGOC_UPDATE_UPSERT));
} else {
bson_iter_t iter;
zend_bool replaced = 0;
if (bson_iter_init(&iter, bupdate)) {
while (bson_iter_next (&iter)) {
if (!strchr (bson_iter_key (&iter), '$')) {
mongoc_bulk_operation_replace_one(intern->bulk, bquery, bupdate, !!(flags & MONGOC_UPDATE_UPSERT));
replaced = 1;
break;
}
}
}
if (!replaced) {
mongoc_bulk_operation_update_one(intern->bulk, bquery, bupdate, !!(flags & MONGOC_UPDATE_UPSERT));
}
}
intern->num_ops++;
bson_clear(&bquery);
bson_clear(&bupdate);
}
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;
}
string_or_literal element::key() const {
if (_raw == nullptr) {
return string_or_literal{""};
}
CITER;
const char* key = bson_iter_key(&iter);
return string_or_literal{key, std::strlen(key)};
}
stdx::string_view element::key() const {
if (_raw == nullptr) {
throw bsoncxx::exception{error_code::k_unset_element};
}
BSONCXX_CITER;
const char* key = bson_iter_key(&iter);
return stdx::string_view{key};
}
bson_bool_t
_mongoc_cursor_cursorid_next (mongoc_cursor_t *cursor,
const bson_t **bson)
{
bson_bool_t ret;
mongoc_cursor_cursorid_t *cid;
bson_iter_t iter;
bson_iter_t child;
const char *ns;
ENTRY;
cid = cursor->interface_data;
ret = _mongoc_cursor_next (cursor, bson);
if (!cid->has_cursor) {
cid->has_cursor = TRUE;
if (ret &&
bson_iter_init_find (&iter, *bson, "cursor") &&
BSON_ITER_HOLDS_DOCUMENT (&iter) &&
bson_iter_recurse (&iter, &child)) {
while (bson_iter_next (&child)) {
if (strcmp (bson_iter_key (&child), "id") == 0) {
cursor->rpc.reply.cursor_id = bson_iter_int64 (&child);
} else if (strcmp (bson_iter_key (&child), "ns") == 0) {
ns = bson_iter_utf8 (&child, &cursor->nslen);
strncpy (cursor->ns, ns, sizeof cursor->ns - 1);
}
}
cursor->is_command = FALSE;
ret = _mongoc_cursor_next (cursor, bson);
}
}
RETURN (ret);
}
/**
* _mongoc_gridfs_file_new_from_bson:
*
* creates a gridfs file from a bson object
*
* This is only really useful for instantiating a gridfs file from a server
* side object
*/
mongoc_gridfs_file_t *
_mongoc_gridfs_file_new_from_bson (mongoc_gridfs_t *gridfs,
const bson_t *data)
{
mongoc_gridfs_file_t *file;
const char *key;
bson_iter_t iter;
const uint8_t *buf;
uint32_t buf_len;
ENTRY;
BSON_ASSERT (gridfs);
BSON_ASSERT (data);
file = bson_malloc0 (sizeof *file);
file->gridfs = gridfs;
bson_copy_to (data, &file->bson);
bson_iter_init (&iter, &file->bson);
while (bson_iter_next (&iter)) {
key = bson_iter_key (&iter);
if (0 == strcmp (key, "_id")) {
bson_oid_copy (bson_iter_oid (&iter), &file->files_id);
} else if (0 == strcmp (key, "length")) {
file->length = bson_iter_int64 (&iter);
} else if (0 == strcmp (key, "chunkSize")) {
file->chunk_size = bson_iter_int32 (&iter);
} else if (0 == strcmp (key, "uploadDate")) {
file->upload_date = bson_iter_date_time (&iter);
} else if (0 == strcmp (key, "md5")) {
file->bson_md5 = bson_iter_utf8 (&iter, NULL);
} else if (0 == strcmp (key, "filename")) {
file->bson_filename = bson_iter_utf8 (&iter, NULL);
} else if (0 == strcmp (key, "contentType")) {
file->bson_content_type = bson_iter_utf8 (&iter, NULL);
} else if (0 == strcmp (key, "aliases")) {
bson_iter_array (&iter, &buf_len, &buf);
bson_init_static (&file->bson_aliases, buf, buf_len);
} else if (0 == strcmp (key, "metadata")) {
bson_iter_document (&iter, &buf_len, &buf);
bson_init_static (&file->bson_metadata, buf, buf_len);
}
}
/* TODO: is there are a minimal object we should be verifying that we
* actually have here? */
RETURN (file);
}
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);
}
const char *
_mongoc_get_command_name (const bson_t *command)
{
bson_iter_t iter;
const char *name;
bson_iter_t child;
const char *wrapper_name = NULL;
BSON_ASSERT (command);
if (!bson_iter_init (&iter, command) ||
!bson_iter_next (&iter)) {
return NULL;
}
name = bson_iter_key (&iter);
/* wrapped in "$query" or "query"?
*
* {$query: {count: "collection"}, $readPreference: {...}}
*/
if (name[0] == '$') {
wrapper_name = "$query";
} else if (!strcmp (name, "query")) {
wrapper_name = "query";
}
if (wrapper_name &&
bson_iter_init_find (&iter, command, wrapper_name) &&
BSON_ITER_HOLDS_DOCUMENT (&iter) &&
bson_iter_recurse (&iter, &child) &&
bson_iter_next (&child)) {
name = bson_iter_key (&child);
}
return name;
}
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);
}
bool
_mongoc_convert_int32_t (mongoc_client_t *client,
const bson_iter_t *iter,
int32_t *num,
bson_error_t *error)
{
int64_t i;
if (!BSON_ITER_HOLDS_NUMBER (iter)) {
CONVERSION_ERR ("Invalid field \"%s\" in opts", bson_iter_key (iter));
}
i = bson_iter_as_int64 (iter);
if (i > INT32_MAX || i < INT32_MIN) {
CONVERSION_ERR ("Invalid field \"%s\" in opts: %" PRId64
" out of range for int32",
bson_iter_key (iter),
i);
}
*num = (int32_t) i;
return true;
}
bool
_mongoc_convert_bool (mongoc_client_t *client,
const bson_iter_t *iter,
bool *flag,
bson_error_t *error)
{
if (BSON_ITER_HOLDS_BOOL (iter)) {
*flag = bson_iter_bool (iter);
return true;
}
CONVERSION_ERR ("Invalid field \"%s\" in opts, should contain bool,"
" not %s",
bson_iter_key (iter),
_mongoc_bson_type_to_str (bson_iter_type (iter)));
}
bool
_mongoc_convert_utf8 (mongoc_client_t *client,
const bson_iter_t *iter,
const char **str,
bson_error_t *error)
{
if (BSON_ITER_HOLDS_UTF8 (iter)) {
*str = bson_iter_utf8 (iter, NULL);
return true;
}
CONVERSION_ERR ("Invalid field \"%s\" in opts, should contain string,"
" not %s",
bson_iter_key (iter),
_mongoc_bson_type_to_str (bson_iter_type (iter)));
}
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;
}
static mongoc_matcher_op_t *
_mongoc_matcher_parse (bson_iter_t *iter, /* IN */
bson_error_t *error) /* OUT */
{
bson_iter_t child;
const char *key;
BSON_ASSERT (iter);
key = bson_iter_key (iter);
if (*key != '$') {
return _mongoc_matcher_parse_compare (iter, key, error);
} else {
BSON_ASSERT (bson_iter_type(iter) == BSON_TYPE_ARRAY);
if (!bson_iter_recurse (iter, &child)) {
bson_set_error (error,
MONGOC_ERROR_MATCHER,
MONGOC_ERROR_MATCHER_INVALID,
"Invalid value for operator \"%s\"",
key);
return NULL;
}
if (strcmp (key, "$or") == 0) {
return _mongoc_matcher_parse_logical (MONGOC_MATCHER_OPCODE_OR,
&child, false, error);
} else if (strcmp(key, "$and") == 0) {
return _mongoc_matcher_parse_logical (MONGOC_MATCHER_OPCODE_AND,
&child, false, error);
} else if (strcmp(key, "$nor") == 0) {
return _mongoc_matcher_parse_logical (MONGOC_MATCHER_OPCODE_NOR,
&child, false, error);
}
}
bson_set_error (error,
MONGOC_ERROR_MATCHER,
MONGOC_ERROR_MATCHER_INVALID,
"Invalid operator \"%s\"",
key);
return NULL;
}
