void find_in_array(bson_iterator *it, char *key_ref, char *value_ref, char *key_needed, char *value_needed)
{
char value_ref_found[MONGO_STRING_LENGTH];
char value_needed_found[MONGO_STRING_LENGTH];
bson_iterator i;
while(bson_iterator_next(it)) {
switch(bson_iterator_type(it)){
case bson_string:
if (strcmp(bson_iterator_key(it), key_ref) == 0)
strcpy(value_ref_found, bson_iterator_string(it));
if (strcmp(bson_iterator_key(it), key_needed) == 0)
strcpy(value_needed_found, bson_iterator_string(it));
break;
case bson_object:
case bson_array:
bson_iterator_init(&i, bson_iterator_value(it));
find_in_array(&i, key_ref, value_ref, key_needed, value_needed);
break;
default:
break;
}
}
if (strcmp(value_ref_found, value_ref) == 0)
strcpy(value_needed, value_needed_found);
}
void testSaveLoad() {
CU_ASSERT_PTR_NOT_NULL_FATAL(jb);
bson_oid_t oid;
EJCOLL *ccoll = ejdbcreatecoll(jb, "contacts", NULL);
CU_ASSERT_PTR_NOT_NULL(ccoll);
//Save record
bson a1;
bson_init(&a1);
bson_append_string(&a1, "name", "Петров Петр");
bson_append_string(&a1, "phone", "333-222-333");
bson_append_int(&a1, "age", 33);
bson_append_long(&a1, "longage", 0xFFFFFFFFFF01LL);
bson_append_double(&a1, "doubleage", 0.333333);
bson_finish(&a1);
ejdbsavebson(ccoll, &a1, &oid);
bson_destroy(&a1);
bson *lbson = ejdbloadbson(ccoll, &oid);
CU_ASSERT_PTR_NOT_NULL(lbson);
bson_iterator it1;
bson_iterator_init(&it1, lbson);
int btype = bson_iterator_next(&it1);
CU_ASSERT(btype == BSON_OID);
btype = bson_iterator_next(&it1);
CU_ASSERT(btype == BSON_STRING);
CU_ASSERT(!strcmp("name", bson_iterator_key(&it1)));
CU_ASSERT(!strcmp("Петров Петр", bson_iterator_string(&it1)));
btype = bson_iterator_next(&it1);
CU_ASSERT(btype == BSON_STRING);
CU_ASSERT(!strcmp("phone", bson_iterator_key(&it1)));
CU_ASSERT(!strcmp("333-222-333", bson_iterator_string(&it1)));
btype = bson_iterator_next(&it1);
CU_ASSERT(btype == BSON_INT);
CU_ASSERT(!strcmp("age", bson_iterator_key(&it1)));
CU_ASSERT(33 == bson_iterator_int(&it1));
btype = bson_iterator_next(&it1);
CU_ASSERT(btype == BSON_LONG);
CU_ASSERT(!strcmp("longage", bson_iterator_key(&it1)));
CU_ASSERT(0xFFFFFFFFFF01LL == bson_iterator_long(&it1));
btype = bson_iterator_next(&it1);
CU_ASSERT(btype == BSON_DOUBLE);
CU_ASSERT(!strcmp("doubleage", bson_iterator_key(&it1)));
CU_ASSERT_DOUBLE_EQUAL(bson_iterator_double(&it1), 0.3, 0.1);
btype = bson_iterator_next(&it1);
CU_ASSERT(btype == BSON_EOO);
bson_del(lbson);
}
int _iterator_getComplex(bson_iterator* iter, struct Rcomplex* z) {
bson_iterator sub;
if (bson_iterator_type(iter) != BSON_OBJECT)
return 0;
bson_iterator_subiterator(iter, &sub);
if (bson_iterator_next(&sub) != BSON_DOUBLE || strcmp(bson_iterator_key(&sub), "r") != 0)
return 0;
z->r = bson_iterator_double(&sub);
if (bson_iterator_next(&sub) != BSON_DOUBLE || strcmp(bson_iterator_key(&sub), "i") != 0)
return 0;
z->i = bson_iterator_double(&sub);
if (bson_iterator_next(&sub) != BSON_EOO)
return 0;
return 1;
}
void bson_print_raw( const char * data , int depth ){
bson_iterator i;
const char * key;
int temp;
char oidhex[25];
bson_iterator_init( &i , data );
while ( bson_iterator_next( &i ) ){
bson_type t = bson_iterator_type( &i );
if ( t == 0 )
break;
key = bson_iterator_key( &i );
for ( temp=0; temp<=depth; temp++ )
printf( "\t" );
printf( "%s : %d \t " , key , t );
switch ( t ){
case bson_int: printf( "%d" , bson_iterator_int( &i ) ); break;
case bson_double: printf( "%f" , bson_iterator_double( &i ) ); break;
case bson_bool: printf( "%s" , bson_iterator_bool( &i ) ? "true" : "false" ); break;
case bson_string: printf( "%s" , bson_iterator_string( &i ) ); break;
case bson_null: printf( "null" ); break;
case bson_oid: bson_oid_to_string(bson_iterator_oid(&i), oidhex); printf( "%s" , oidhex ); break;
case bson_object:
case bson_array:
printf( "\n" );
bson_print_raw( bson_iterator_value( &i ) , depth + 1 );
break;
default:
fprintf( stderr , "can't print type : %d\n" , t );
}
printf( "\n" );
}
}
int
ComputeOperator(BSONElem* val,BSONElem* query){
bson_iterator q,o;
bson_type qType,tType;
bson_iterator_from_buffer(&q, query->value);
bson_iterator_from_buffer(&o, val->value);
bson qBson,oBson;
bson_init_finished_data(&qBson,(char*)query->value);
bson_init_finished_data(&oBson,(char*)val->value);
while((qType = bson_iterator_next(&q))) {
const char* key = bson_iterator_key(&q);
BSONElem qVal;
BSONElemInitFromItr(&qVal,&q);
int cVal = 0,r;
uint8_t cont = False;
int error;
QueryOpDesc* desc = HTFind(opTable,key,strlen(key)+1);
if (desc) {
cont = desc->fn(val,&qVal,&error);
if (!cont) {
return False;
}
} else {
// no such operator
return False;
}
}
//printf("Returning true\n");
return True;
}
uint8_t
XTDBRemoveFromIndex(XTDBHandle* handle,BinaryStr* key,BinaryStr* data) {
bson_oid_t oid;
bson_iterator q;
bson_type qType;
uint8_t ret = True;
_S_FN(indexRemove);
bson_iterator_from_buffer(&q, data->data);
while((qType = bson_iterator_next(&q))) {
const char* keyVal = bson_iterator_key(&q);
//printf("%s\n",keyVal);
DataBaseBE* db;
BSONElem qVal;
BSONElemInitFromItr(&qVal,&q);
db = XTDBGetIndex(handle,keyVal);
if (db) {
bson outBson;
BinaryStr out;
ConvertToBStr(&qVal,&outBson);
BsonToBStr(&outBson,&out);
ret = DBDeleteKeyVal(db,&out,key);
if (!ret) {
handle->error = XTDB_NO_ENTRY;
bson_destroy(&outBson);
break;
}
bson_destroy(&outBson);
}
}
_E_FN(indexRemove);
return ret;
//return DBSet(handle->mainDB,&key,&val,False);
}
int MCPContentPersonAward::set_basic_info_from_bson_result(bson* bson_out, const char* aggregate_name)
{
LOGD("[GWJ] %s: start", __FUNCTION__);
const char* key;
bson_iterator it[1];
stringstream ss;
MCPContentPersonAwardRecord* detail = ObjectPoolFactory<MCPContentPersonAwardRecord>::instance().fetch_object();
bson_iterator_init(it, bson_out);
while(bson_iterator_next(it))
{
ss.clear();
key = bson_iterator_key(it);
if(0 == strcmp(key, "priority"))
{
detail->priority = bson_iterator_string(it);
LOGG("[GWJ] %s: set MCPContentPersonAwardRecord.priority[%s]",
__FUNCTION__, detail->priority.c_str());
}
else if(0 == strcmp(key, "kudou"))
{
detail->kudou = bson_iterator_int(it);
LOGG("[GWJ] %s: set MCPContentPersonAwardRecord.kudou[%d]",
__FUNCTION__, detail->kudou;
}
else if(0 == strcmp(key, "commodity_id"))
bson_type bson_find( bson_iterator *it, const bson *obj, const char *name ) {
bson_iterator_init( it, (bson *)obj );
while( bson_iterator_next( it ) ) {
if ( strcmp( name, bson_iterator_key( it ) ) == 0 )
break;
}
return bson_iterator_type( it );
}
void MongodbClient::ReadData(KeyedArchive* archive, void* bsonObj)
{
if((!archive) || (!bsonObj)) return;
bson_iterator it;
bson_iterator_init(&it, (bson*)bsonObj);
while (bson_iterator_next(&it))
{
String key = String(bson_iterator_key(&it));
bson_type type = bson_iterator_type(&it);
if(key == "_id") continue; // ignore _id
switch (type)
{
case BSON_STRING:
archive->SetString(key, String(bson_iterator_string(&it)));
break;
case BSON_INT:
archive->SetInt32(key, bson_iterator_int(&it));
break;
case BSON_LONG:
archive->SetInt32(key, (int32)bson_iterator_long(&it));
break;
case BSON_DOUBLE:
archive->SetFloat(key, (float32)bson_iterator_double(&it));
break;
case BSON_OBJECT:
{
bson sub;
bson_iterator_subobject(&it, &sub);
KeyedArchive* subArchive = new KeyedArchive();
ReadData(subArchive, &sub);
archive->SetArchive(key, subArchive);
SafeRelease(subArchive);
break;
}
case BSON_OID:
//TODO: add 12-bytes array
//bson_append_oid(object, key, bson_iterator_oid(&it));
break;
default:
DVASSERT(false);
Logger::Error("[MongodbUpdateObject::ReadData] Not implemented type: %d", type);
break;
}
}
}
void lua_push_bson_table(lua_State *L, bson_iterator *it) {
bson_type bt;
lua_push_bsontype_table(L, BSON_OBJECT);
while ((bt = bson_iterator_next(it)) != BSON_EOO) {
lua_pushstring(L, bson_iterator_key(it));
lua_push_bson_value(L, it);
lua_rawset(L, -3);
}
}
MONGO_EXPORT bson_type bson_find( bson_iterator *it, const bson *obj, const char *name ) {
check_mongo_object( (void*)obj );
check_mongo_object( it );
bson_iterator_init( it, (bson *)obj );
while( bson_iterator_next( it ) ) {
if ( strcmp( name, bson_iterator_key( it ) ) == 0 )
break;
}
return bson_iterator_type( it );
}
static void bson_decode_tree(lua_State* L, bson_iterator* b,int set_t){
const char *key;
while(bson_iterator_next(b))
{
bson_type t = bson_iterator_type(b);
if(t == 0)
{
lua_pushnil(L);
break;
}
key = bson_iterator_key(b);
if(set_t)
{
lua_pushstring(L,key);
}
LOG_MSG("type %d,key %s",t,key);
switch(t)
{
case BSON_DOUBLE:
lua_pushnumber(L,bson_iterator_double(b));
break;
case BSON_STRING:
lua_pushstring(L,bson_iterator_string(b));
break;
case BSON_BOOL:
lua_pushboolean(L,bson_iterator_bool( b ) ? true : false );
break;
case BSON_NULL:
lua_pushnil(L);
break;
case BSON_INT:
lua_pushinteger(L,bson_iterator_int(b));
break;
case BSON_OBJECT:
bson_iterator t;
bson_iterator_subiterator(b,&t);
bson_decode_tree(L,&t);
lua_settable(L,-3);
break;
case BSON_ARRAY:
lua_newtable(L);
bson_iterator s;
bson_iterator_subiterator(b,&s);
bson_decode_tree(L,&s,1);
break;
default:
break;
}
if(set_t)
{
lua_settable(L,-3);
}
}
}
//------------------------------------------------------------------------------
int main( int argc, char * argv[] ){
mongo conn;
if( mongo_client( &conn , TEST_SERVER, TEST_PORT ) != MONGO_OK ) {
std::cout << "failed to connect\n";
return EXIT_FAILURE;
}
mongo_cursor cursor;
mongo_cursor_init( &cursor, &conn, "test.test" );
char hex_oid[25];
while( mongo_cursor_next( &cursor ) == MONGO_OK ) {
std::cout << "row:\n";
bson_iterator it;
bson_iterator_init( &it, mongo_cursor_bson( &cursor ) );
while( bson_iterator_next( &it ) ) {
std::cout << " " << bson_iterator_key( &it ) << " = ";
switch( bson_iterator_type( &it ) ) {
case BSON_DOUBLE:
std::cout << "(double) " << bson_iterator_double( &it ) << std::endl;
break;
case BSON_INT:
std::cout << "(int) " << bson_iterator_int( &it ) << std::endl;
break;
case BSON_STRING:
std::cout << "(string) \"" << bson_iterator_string( &it ) << "\"\n";
break;
case BSON_OID:
bson_oid_to_string( bson_iterator_oid( &it ), hex_oid );
std::cout << "(oid) \"" << hex_oid << "\"\n";
break;
case BSON_OBJECT:
std::cout << "(subobject) {...}\n";
break;
case BSON_ARRAY:
std::cout << "(array) [...]\n";
break;
case BSON_TIMESTAMP:
std::cout << "(timestamp) [...]\n";
break;
default:
std::cout << "(type " << bson_iterator_type( &it ) << std::endl;
break;
}
}
std::cout << std::endl;
}
mongo_disconnect( &conn );
return EXIT_SUCCESS;
}
void MongodbObject::EnableForEdit()
{
bson *newObject = new bson();
bson_init(newObject);
bson_iterator it;
bson_iterator_init(&it, objectData->object);
while (bson_iterator_next(&it))
{
const char * key = bson_iterator_key(&it);
bson_type type = bson_iterator_type(&it);
switch (type)
{
case BSON_STRING:
bson_append_string(newObject, key, bson_iterator_string(&it));
break;
case BSON_INT:
bson_append_int(newObject, key, bson_iterator_int(&it));
break;
case BSON_LONG:
bson_append_long(newObject, key, bson_iterator_long(&it));
break;
case BSON_DOUBLE:
bson_append_double(newObject, key, bson_iterator_double(&it));
break;
case BSON_OBJECT:
bson sub;
bson_iterator_subobject(&it, &sub);
bson_append_bson(newObject, key, &sub);
break;
case BSON_OID:
bson_append_oid(newObject, key, bson_iterator_oid(&it));
break;
default:
break;
}
}
bson_destroy(objectData->object);
SafeDelete(objectData->object);
objectData->object = newObject;
}
int mongo_create_index(mongo_connection * conn, const char * ns, bson * key, int options, bson * out){
bson_buffer bb;
bson b;
bson_iterator it;
char name[255] = {'_'};
int i = 1;
char idxns[1024];
bson_iterator_init(&it, key->data);
while(i < 255 && bson_iterator_next(&it)){
strncpy(name + i, bson_iterator_key(&it), 255 - i);
i += strlen(bson_iterator_key(&it));
}
name[254] = '\0';
bson_buffer_init(&bb);
bson_append_bson(&bb, "key", key);
bson_append_string(&bb, "ns", ns);
bson_append_string(&bb, "name", name);
if (options & MONGO_INDEX_UNIQUE)
bson_append_bool(&bb, "unique", 1);
if (options & MONGO_INDEX_DROP_DUPS)
bson_append_bool(&bb, "dropDups", 1);
if (options & MONGO_INDEX_BACKGROUND)
bson_append_bool(&bb, "background", 1);
if (options & MONGO_INDEX_SPARSE)
bson_append_bool(&bb, "sparse", 1);
bson_from_buffer(&b, &bb);
strncpy(idxns, ns, 1024-16);
strcpy(strchr(idxns, '.'), ".system.indexes");
mongo_insert(conn, idxns, &b);
bson_destroy(&b);
*strchr(idxns, '.') = '\0'; /* just db not ns */
return mongo_cmd_get_last_error(conn, idxns, out);
}
int read_inode(const bson * doc, struct inode * out) {
bson_iterator i, sub;
bson_type bt;
const char * key;
bson_iterator_init(&i, doc);
while((bt = bson_iterator_next(&i)) > 0) {
key = bson_iterator_key(&i);
if(strcmp(key, "_id") == 0)
memcpy(&out->oid, bson_iterator_oid(&i), sizeof(bson_oid_t));
else if(strcmp(key, "mode") == 0)
out->mode = bson_iterator_int(&i);
else if(strcmp(key, "owner") == 0)
out->owner = bson_iterator_long(&i);
else if(strcmp(key, "group") == 0)
out->group = bson_iterator_long(&i);
else if(strcmp(key, "size") == 0)
out->size = bson_iterator_long(&i);
else if(strcmp(key, "created") == 0)
out->created = bson_iterator_time_t(&i);
else if(strcmp(key, "modified") == 0)
out->modified = bson_iterator_time_t(&i);
else if(strcmp(key, "data") == 0) {
out->datalen = bson_iterator_string_len(&i);
out->data = malloc(out->datalen + 1);
strcpy(out->data, bson_iterator_string(&i));
}
else if(strcmp(key, "dirents") == 0) {
while(out->dirents) {
struct dirent * next = out->dirents->next;
free(out->dirents);
out->dirents = next;
}
bson_iterator_subiterator(&i, &sub);
while((bt = bson_iterator_next(&sub)) > 0) {
int len = bson_iterator_string_len(&sub);
struct dirent * cde = malloc(sizeof(struct dirent) + len);
if(!cde)
return -ENOMEM;
strcpy(cde->path, bson_iterator_string(&sub));
cde->len = bson_iterator_string_len(&sub);
cde->next = out->dirents;
out->dirents = cde;
out->direntcount++;
}
}
}
return 0;
}
void InitWith(bson *obj)
{
bson_iterator it;
bson_iterator_init(&it, obj);
while (bson_iterator_next(&it))
{
const char * key = bson_iterator_key(&it);
bson_type type = bson_iterator_type(&it);
switch (type)
{
case BSON_STRING:
bson_append_string(object, key, bson_iterator_string(&it));
break;
case BSON_INT:
bson_append_int(object, key, bson_iterator_int(&it));
break;
case BSON_LONG:
bson_append_long(object, key, bson_iterator_long(&it));
break;
case BSON_DOUBLE:
bson_append_double(object, key, bson_iterator_double(&it));
break;
case BSON_OBJECT:
{
bson sub;
bson_iterator_subobject(&it, &sub);
bson_append_bson(object, key, &sub);
break;
}
case BSON_OID:
bson_append_oid(object, key, bson_iterator_oid(&it));
break;
default:
DVASSERT(false);
Logger::Error("[MongodbObjectInternalData::InitWith] Not implemented type: %d", type);
break;
}
}
}
int srld_find(bson_iterator *i, int keyc, char **keyv, char *data, int depth)
{
bson_iterator_init(i, data);
while(bson_iterator_next(i)){
if (strcmp(keyv[depth], bson_iterator_key(i)) == 0) {
//printf("%s == %s, depth %d\n", keyv[depth], bson_iterator_key(i), depth);
if (depth == keyc-1) {
return 1;
} else {
return srld_find(i, keyc, keyv, (char *)bson_iterator_value(i), depth+1);
}
}
}
return 0;
}
/**
* \brief This function tries to load tag group data from MongoDB
*/
static void vs_mongo_taggroup_load_data(struct VSTagGroup *tg,
bson *bson_version)
{
bson_iterator version_data_iter;
/* Try to get tags of tag group */
if( bson_find(&version_data_iter, bson_version, "tags") == BSON_OBJECT ) {
struct VSTag *tag;
bson bson_tag;
bson_iterator tags_iter, tag_iter;
const char *key;
int tag_id, data_type = -1, count = -1, tag_custom_type = -1;
bson_iterator_subiterator(&version_data_iter, &tags_iter);
while( bson_iterator_next(&tags_iter) == BSON_OBJECT ) {
key = bson_iterator_key(&tags_iter);
sscanf(key, "%d", &tag_id);
bson_iterator_subobject_init(&tags_iter, &bson_tag, 0);
if( bson_find(&tag_iter, &bson_tag, "data_type") == BSON_INT) {
data_type = bson_iterator_int(&tag_iter);
}
if( bson_find(&tag_iter, &bson_tag, "count") == BSON_INT) {
count = bson_iterator_int(&tag_iter);
}
if( bson_find(&tag_iter, &bson_tag, "custom_type") == BSON_INT) {
tag_custom_type = bson_iterator_int(&tag_iter);
}
if(data_type != -1 && count != -1 && tag_custom_type != -1) {
/* Create tag with specific ID */
tag = vs_tag_create(tg, tag_id, data_type, count, tag_custom_type);
if(tag != NULL) {
tag->state = ENTITY_CREATED;
vs_mongo_tag_load_data(tag, &bson_tag);
tag->flag = TAG_INITIALIZED;
}
}
}
}
}
void json_from_bson_object(yajl_gen *g, bson_iterator *it)
{
yajl_gen_map_open( *g );
while( bson_iterator_next( it ) )
{
bson_type t = bson_iterator_type( it );
const char* key = bson_iterator_key( it );
yajl_gen_string( *g, (const unsigned char*)key, strlen(key) );
json_from_bson_type( t, g, it );
}
yajl_gen_map_close( *g );
}
int
QueryGetIndexesToUse(BinaryStr* query,ListNode* head){
LIST_INIT(head);
bson_iterator q,o;
bson_type qType,tType;
bson_iterator_from_buffer(&q, query->data);
while((qType =bson_iterator_next(&q))) {
const char* key = bson_iterator_key(&q);
if (qType != BSON_ARRAY && qType != BSON_OBJECT ) {
ListNode* node2 = (ListNode*) malloc(sizeof(*node2));
node2->data = strdup(key);
LIST_ADD_AFTER(node2,LIST_LAST(head));
}
}
return 0;
}
int
QueryMatch(BinaryStr* query, BinaryStr* obj ) {
bson_iterator q,o;
bson_type qType,tType;
bson qBson,oBson;
BSONElem objElem;
bson_iterator_from_buffer(&q, query->data);
bson_iterator_from_buffer(&o, obj->data);
bson_init_finished_data(&qBson,(char*)query->data);
bson_init_finished_data(&oBson,(char*)obj->data);
while((qType = bson_iterator_next(&q))) {
// for all keys in query
char *newKey;
const char* key = bson_iterator_key(&q);
char* keyEnd;
BSONElem qVal,oVal;
newKey = strdup(key);
if (!newKey) {
return False;
}
keyEnd = strchr(newKey,'.');
if (keyEnd) {
*keyEnd = '\0';
keyEnd ++;
} else {
//printf("No dot \n");
keyEnd = newKey+strlen(newKey);
}
BSONElemInitFromItr(&qVal,&q);
tType = bson_find(&o,&oBson,newKey) ;
if (!tType) {
return False;
}
BSONElemInitFromItr(&oVal,&o);
if (!QueryElemMatch(keyEnd,&oVal,&qVal)) {
free(newKey);
return False;
}
free(newKey);
}
return True;
}
bson_buffer * bson_append_element( bson_buffer * b, const char * name_or_null, const bson_iterator* elem){
bson_iterator next = *elem;
int size;
bson_iterator_next(&next);
size = next.cur - elem->cur;
if (name_or_null == NULL){
bson_ensure_space(b, size);
bson_append(b, elem->cur, size);
}else{
int data_size = size - 2 - strlen(bson_iterator_key(elem));
bson_append_estart(b, elem->cur[0], name_or_null, data_size);
bson_append(b, bson_iterator_value(elem), data_size);
}
return b;
}
bool bson_cmp( const bson *a, const bson *b )
{
assert( a );
assert( b );
bson_iterator *a_it, *b_it;
bool equal;
size_t a_keys_count, b_keys_count;
equal = true;
a_it = malloc( sizeof( bson_iterator ) );
b_it = malloc( sizeof( bson_iterator ) );
bson_iterator_init( a_it, a );
bson_iterator_init( b_it, b );
a_keys_count = bson_keypars_count( a );
b_keys_count = bson_keypars_count( b );
if( a_keys_count == b_keys_count )
{
while( bson_iterator_next( a_it ) )
{
bson_type a_key_type = bson_iterator_type( a_it );
const char *a_key = bson_iterator_key( a_it );
bson_type b_key_type = bson_find( b_it, b, a_key );
if( b_key_type == BSON_EOO ||
a_key_type != b_key_type ||
!bson_values_are_equal( a_key_type, a_it, b_it ) )
{
equal = false;
break;
}
}
}
else
{
equal = false;
}
free( a_it );
free( b_it );
return equal;
}
MONGO_EXPORT int bson_append_element( bson *b, const char *name_or_null, const bson_iterator *elem ) {
bson_iterator next = *elem;
size_t size;
bson_iterator_next( &next );
size = next.cur - elem->cur;
if ( name_or_null == NULL ) {
if( bson_ensure_space( b, size ) == BSON_ERROR )
return BSON_ERROR;
bson_append( b, elem->cur, size );
}
else {
size_t data_size = size - 2 - strlen( bson_iterator_key( elem ) );
bson_append_estart( b, elem->cur[0], name_or_null, data_size );
bson_append( b, bson_iterator_value( elem ), data_size );
}
return BSON_OK;
}
bool FindField(bson_iterator *itIn, bson_iterator *itOut, const String &fieldname, bool recursive)
{
bool found = false;
while(!found && bson_iterator_next(itIn))
{
String itKey = String(bson_iterator_key(itIn));
if(fieldname == itKey)
{
*itOut = *itIn;
found = true;
}
else if( (recursive && (BSON_OBJECT == bson_iterator_type(itIn)))
|| (recursive && (BSON_ARRAY == bson_iterator_type(itIn))))
{
bson_iterator subIt;
bson_iterator_subiterator(itIn, &subIt);
found = FindField(&subIt, itOut, fieldname, recursive);
}
}
return found;
}
uint8_t
QueryObjMatch(bson* obj,bson* query) {
bson_iterator oItr,qItr;
bson_type o,q;
bson_iterator_init(&oItr,obj);
bson_iterator_init(&qItr,query);
while ((o=bson_iterator_next(&oItr))) {
BSONElem oVal,qVal;
int cVal;
q = bson_find(&qItr,query,bson_iterator_key(&oItr));
if (!q) {
return False;
}
if ( (o == BSON_OBJECT && q != BSON_OBJECT ) ||
(q == BSON_OBJECT && o != BSON_OBJECT ) ) {
return False;
}
if ( o == q && o == BSON_OBJECT) {
bson o1,q1;
bson_iterator_subobject(&oItr,&o1);
bson_iterator_subobject(&qItr,&q1);
return QueryObjMatch(&o1,&q1);
}
BSONElemInitFromItr(&oVal,&oItr);
BSONElemInitFromItr(&qVal,&qItr);
if (CompareElem(&oVal,&qVal,&cVal)) {
return False;
}
if (cVal) {
return False;
}
}
return True;
}
clsSiteData::clsSiteData(int id, const bson *info)
{
m_ID = id;
bson_iterator it[1];
bson_iterator_init(it, info);
while (bson_iterator_next(it))
{
if (strcmp("Name", bson_iterator_key(it)) == 0)
m_Name = bson_iterator_string(it);
//else if(strcmp("AREA", bson_iterator_key(it)) == 0)
// m_Area = (float)bson_iterator_double(it);
else if (strcmp("LocalX", bson_iterator_key(it)) == 0)
m_XPR = (float) bson_iterator_double(it);
else if (strcmp("LocalY", bson_iterator_key(it)) == 0)
m_YPR = (float) bson_iterator_double(it);
else if (strcmp("Lat", bson_iterator_key(it)) == 0)
m_Latitude = (float) bson_iterator_double(it);
else if (strcmp("Long", bson_iterator_key(it)) == 0)
m_Longitude = (float) bson_iterator_double(it);
else if (strcmp("Elevation", bson_iterator_key(it)) == 0)
m_Elevation = (float) bson_iterator_double(it);
}
}
void bson_print_raw( const char *data , int depth ) {
bson_iterator i;
const char *key;
int temp;
bson_timestamp_t ts;
char oidhex[25];
bson scope;
bson_iterator_from_buffer( &i, data );
while ( bson_iterator_next( &i ) ) {
bson_type t = bson_iterator_type( &i );
if ( t == 0 )
break;
key = bson_iterator_key( &i );
for ( temp=0; temp<=depth; temp++ )
printf( "\t" );
bson_printf( "%s : %d \t " , key , t );
switch ( t ) {
case BSON_DOUBLE:
printf( "%f" , bson_iterator_double( &i ) );
break;
case BSON_STRING:
printf( "%s" , bson_iterator_string( &i ) );
break;
case BSON_SYMBOL:
printf( "SYMBOL: %s" , bson_iterator_string( &i ) );
break;
case BSON_OID:
bson_oid_to_string( bson_iterator_oid( &i ), oidhex );
printf( "%s" , oidhex );
break;
case BSON_BOOL:
printf( "%s" , bson_iterator_bool( &i ) ? "true" : "false" );
break;
case BSON_DATE:
printf( "%ld" , ( long int )bson_iterator_date( &i ) );
break;
case BSON_BINDATA:
printf( "BSON_BINDATA" );
break;
case BSON_UNDEFINED:
printf( "BSON_UNDEFINED" );
break;
case BSON_NULL:
printf( "BSON_NULL" );
break;
case BSON_REGEX:
printf( "BSON_REGEX: %s", bson_iterator_regex( &i ) );
break;
case BSON_CODE:
printf( "BSON_CODE: %s", bson_iterator_code( &i ) );
break;
case BSON_CODEWSCOPE:
printf( "BSON_CODE_W_SCOPE: %s", bson_iterator_code( &i ) );
bson_init( &scope );
bson_iterator_code_scope( &i, &scope );
printf( "\n\t SCOPE: " );
bson_print( &scope );
break;
case BSON_INT:
printf( "%d" , bson_iterator_int( &i ) );
break;
case BSON_LONG:
printf( "%lld" , ( long long int )bson_iterator_long( &i ) );
break;
case BSON_TIMESTAMP:
ts = bson_iterator_timestamp( &i );
printf( "i: %d, t: %d", ts.i, ts.t );
break;
case BSON_OBJECT:
case BSON_ARRAY:
printf( "\n" );
bson_print_raw( bson_iterator_value( &i ) , depth + 1 );
break;
default:
bson_errprintf( "can't print type : %d\n" , t );
}
printf( "\n" );
}
}
// Checked
uint8_t
XTDBInsertToIndex(XTDBHandle* handle,BinaryStr* key,BinaryStr* data) {
bson_oid_t oid;
bson_iterator q;
bson_type qType;
uint8_t ret = True;
_S_FN(indexInsert);
if (!tcmaprnum(handle->indexes)) {
_E_FN(indexInsert);
return True;
}
bson_iterator_from_buffer(&q, data->data);
while((qType = bson_iterator_next(&q))) {
const char* keyVal = bson_iterator_key(&q);
//printf("keyval %s\n",keyVal);
DataBaseBE* db;
BSONElem qVal;
BSONElemInitFromItr(&qVal,&q);
db = XTDBGetIndex(handle,keyVal);
if (db) {
bson outBson;
BinaryStr out;
if (qType == BSON_ARRAY) {
assert(0);
bson_iterator si;
bson_type t;
bson_iterator_subiterator(&q,&si);
while ((t=bson_iterator_next(&si))) {
if (ConvertToBStr(&qVal,&outBson)) {
handle->error = XTDB_NO_MEM;
return False;
}
BsonToBStr(&outBson,&out);
ret = DBSet(db,&out,key,True);
bson_destroy(&outBson);
if (ret) {
handle->error = XTDB_IO_ERR;
goto error;
}
}
} else {
if (ConvertToBStr(&qVal,&outBson)) {
handle->error = XTDB_NO_MEM;
return False;
}
BsonToBStr(&outBson,&out);
ret = DBSet(db,&out,key,True);
bson_destroy(&outBson);
if (!ret) {
handle->error = XTDB_IO_ERR;
goto error;
}
}
}
}
_E_FN(indexInsert);
return ret;
error:
// roll back is required?
// can simply return error unnecessarily inserted elements will be eventually corrected when index is accessed
return ret;
//return DBSet(handle->mainDB,&key,&val,False);
}
