示例#1
0
int
QueryElemMatch(char* key,BSONElem* objElem,BSONElem* query) {
   bson_iterator oItr;
   char* k = key;
   bson obj;
   bson so; 
   BSONElem tmpVal;
   BSONElem valElem;
   BSONElemItr it1;
   bson_iterator_init(&oItr,&obj);

   if (!objElem) {
      BSONElemInit(&tmpVal,BSON_EOO,NULL,0,NULL);
      return CompareValue(&tmpVal,query);
   }
   BSONElemItrInit(&it1,objElem);
   if (*k) {
      BSONElem soElem;
      BSONElem* elemPtr = NULL;
      bson_iterator sItr;
      bson b;

      char* keyEnd = strchr(key,'.');
      //printf("Key in new elem '%s','%s'\n",key,keyEnd);
      if (keyEnd) {
         *keyEnd = '\0';
         keyEnd ++;
      } else {
         //printf("No dot \n");
         keyEnd = key+strlen(key);
      }
      while (BSONElemItrNext(&it1,&tmpVal)) {
         if (tmpVal.type != BSON_OBJECT) {
            continue;
         }
         bson_iterator_subobject(tmpVal.itr,&b);
         bson_iterator_init(&sItr,&b);
         if (bson_find(&sItr,&b,key)) {
            BSONElemInitFromItr(&soElem,&sItr);
            elemPtr = &soElem;
         }
         if (QueryElemMatch(keyEnd,elemPtr,query)) {
            return True;
         }
      }
   } else {
      // end of the string
      if (query->type == BSON_ARRAY || query->type == BSON_OBJECT) {
         return CompareValue(objElem,query);
      }
      while (BSONElemItrNext(&it1,&tmpVal)) {
         if (CompareValue(&tmpVal,query)) {
            return True;
         }
      }
      return False;
   }

   return False;
}
void test_index_helper( mongo *conn ) {
    int ret;

    bson b, out;
    bson_iterator it;

    bson_init( &b );
    bson_append_int( &b, "foo", -1 );
    bson_finish( &b );

    mongo_create_index( conn, "test.bar", &b, NULL, MONGO_INDEX_SPARSE | MONGO_INDEX_UNIQUE, &out );

    bson_destroy( &b );
    bson_destroy( &out );

    bson_init( &b );
    bson_append_start_object( &b, "key" );
    bson_append_int( &b, "foo", -1 );
    bson_append_finish_object( &b );

    bson_finish( &b );

    ret = mongo_find_one( conn, "test.system.indexes", &b, NULL, &out );
    ASSERT( ret == MONGO_OK );

    bson_print( &out );

    bson_iterator_init( &it, &out );

    ASSERT( bson_find( &it, &out, "unique" ) );
    ASSERT( bson_find( &it, &out, "sparse" ) );

    bson_destroy( &b );
    bson_destroy( &out );
}
示例#3
0
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" );
    }
}
示例#4
0
SEXP mongo_get_databases(SEXP mongo_conn) {
    mongo* conn = _checkMongo(mongo_conn);
    bson out;
    if (mongo_simple_int_command(conn, "admin", "listDatabases", 1, &out) != MONGO_OK) {
        bson_destroy(&out);
        return R_NilValue;
    }
    bson_iterator it, databases, database;
    bson_iterator_init(&it, &out);
    bson_iterator_next(&it);
    bson_iterator_subiterator(&it, &databases);
    int count = 0;
    while (bson_iterator_next(&databases)) {
        bson_iterator_subiterator(&databases, &database);
        bson_iterator_next(&database);
        const char* name = bson_iterator_string(&database);
        if (strcmp(name, "admin") != 0 && strcmp(name, "local") != 0)
            count++;
    }
    SEXP ret;
    PROTECT(ret = allocVector(STRSXP, count));
    bson_iterator_subiterator(&it, &databases);
    int i = 0;
    while (bson_iterator_next(&databases)) {
        bson_iterator_subiterator(&databases, &database);
        bson_iterator_next(&database);
        const char* name = bson_iterator_string(&database);
        if (strcmp(name, "admin") != 0 && strcmp(name, "local") != 0)
            SET_STRING_ELT(ret, i++, mkChar(name));
    }
    bson_destroy(&out);
    UNPROTECT(1);
    return ret;
}
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"))
bool MongodbObject::GetSubObject(MongodbObject *subObject, const String &fieldname, bool needFinished)
{
    bool found = false;
    
    if(0 != objectData->object->finished)
    {
        bson_iterator it;
        bson_iterator_init(&it, objectData->object);
        
        bson_type foundType = bson_find(&it, objectData->object, fieldname.c_str());
        if(BSON_OBJECT == foundType)
        {
            found = true;
            
            bson sub;
            bson_iterator_subobject(&it, &sub);

            if(needFinished)
            {
                subObject->objectData->InitFinished(&sub);
            }
            else 
            {
                
                subObject->objectData->InitWith(&sub);
            }
        }
    }
    
    return found;
}
示例#7
0
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);
}
示例#8
0
int main(int argc, char *argv[])
{
    const char * test_server = (argc > 1 ? argv[1] : TEST_SERVER);

    bson_iterator it[1], it2[1];
    bson b[1];
    bson sub[1];
    bson copy[1];
    bson_type type;

    bson_init( b );
    bson_append_string( b, "foo", "hello" );

    {
        bson_append_start_object( b, "o" );
          bson_append_string( b, "bar", "goodbye" );
        bson_append_finish_object( b );
    }

    bson_iterator_init( it, b );

    bson_iterator_next( it );
    type = bson_iterator_next( it );

    ASSERT( BSON_OBJECT == type );

    bson_iterator_subobject_init( it, sub, 0 );
    ASSERT( sub->finished == 1 );

    bson_iterator_init( it2, sub );

    type = bson_iterator_next( it2 );
    ASSERT( BSON_STRING == type );
    type = bson_iterator_next( it2 );
    ASSERT( BSON_EOO == type );

    bson_copy( copy, sub );

    ASSERT( 1 == copy->finished );
    ASSERT( 0 == copy->stackPos );
    ASSERT( 0 == copy->err );

    bson_destroy( copy );
    bson_destroy( b );

    return 0;
}
示例#9
0
文件: bson.c 项目: halayudha/kdengine
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;
        }
    }
}
示例#11
0
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;
}
示例#12
0
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 );
}
示例#13
0
//------------------------------------------------------------------------------
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;
}
示例#14
0
int test_bson_iterator( void ) {
    bson b[1];
    bson_iterator i[1];

    bson_iterator_init( i, bson_empty( b ) );
    bson_iterator_next( i );
    bson_iterator_type( i );

    bson_find( i, bson_empty( b ), "foo" );

    return 0;
}
示例#15
0
yajl_gen bson_to_yajl(bson *b)
{
    bson_iterator it[1];
    bson_iterator_init( it, b );

    yajl_gen g = yajl_gen_alloc( NULL );
    yajl_gen_config( g, yajl_gen_beautify, 1 );

    json_from_bson_object( &g, it );

    return g;
}
示例#16
0
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;
}
示例#17
0
文件: t1.c 项目: CowanSM/ejdb
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);
}
示例#18
0
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;
}
示例#19
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;
         }
     }
 }
示例#20
0
文件: core.c 项目: jayridge/seriald
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;
}
示例#21
0
size_t bson_keypars_count( const bson *a )
{
    assert( a );

    size_t i;
    bson_iterator *a_it;

    a_it = malloc( sizeof( bson_iterator ) );
    bson_iterator_init( a_it, a );

    for( i = 0; bson_iterator_next( a_it ); i++ );

    free( a_it );
    return i;
}
示例#22
0
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;
}
示例#23
0
String MongodbObject::GetString(const String &fieldname)
{
    String retValue = String("");
    
    bson_iterator it;
    bson_iterator_init(&it, objectData->object);
    
    bson_iterator foundIt;
    bool found = objectData->FindField(&it, &foundIt, fieldname, true);
    if(found)
    {
        retValue = bson_iterator_string(&foundIt);
    }
    
    return retValue;
}
示例#24
0
bool MongodbObject::GetData(const String &fieldname, uint8 *outData, int32 dataSize)
{
    bson_iterator it;
    bson_iterator_init(&it, objectData->object);
    
    bson_iterator foundIt;
    bool found = objectData->FindField(&it, &foundIt, fieldname, true);
    if(found)
    {
        uint8 *binaryData = (uint8 *)bson_iterator_bin_data(&foundIt);
        Memcpy(outData, binaryData, dataSize);
        found = true;
    }
    
    return found;
}
示例#25
0
double MongodbObject::GetDouble(const String &fieldname)
{
    double retValue = 0;
    
    bson_iterator it;
    bson_iterator_init(&it, objectData->object);
    
    bson_iterator foundIt;
    bool found = objectData->FindField(&it, &foundIt, fieldname, true);
    if(found)
    {
        retValue = bson_iterator_double(&foundIt);
    }
    
    return retValue;
}
示例#26
0
static void mongo_replset_check_seed( mongo_connection* conn ) {
    bson out;
    bson hosts;
    const char* data;
    bson_iterator it;
    bson_iterator it_sub;
    const char* host_string;
    mongo_host_port *host_port = NULL;

    out.data = NULL;
    out.owned = 1;

    hosts.data = NULL;
    hosts.owned = 1;

    if( mongo_simple_int_command(conn, "admin", "ismaster", 1, &out) == MONGO_OK ) {

        if( bson_find( &it, &out, "hosts" ) ) {
            data = bson_iterator_value( &it );
            bson_iterator_init( &it_sub, data );

            /* Iterate over host list, adding each host to the
             * connection's host list. */
            while( bson_iterator_next( &it_sub ) ) {
                host_string = bson_iterator_string( &it_sub );

                host_port = bson_malloc( sizeof( mongo_host_port ) );
                mongo_parse_host( host_string, host_port );

                if( host_port ) {
                    mongo_replset_add_node( &conn->replset->hosts,
                        host_port->host, host_port->port );

                    free( host_port );
                    host_port = NULL;
                }
            }
        }
    }

    bson_destroy( &out );
    bson_destroy( &hosts );
    mongo_close_socket( conn->sock );
    conn->sock = 0;
    conn->connected = 0;

}
示例#27
0
int find_radius_options(rlm_mongo_t *data, char *username, char *mac, char *password) 
{
	bson_buffer bb;
	
	bson query;
	bson field;
	bson result;
	
	bson_buffer_init(&bb);
	
	bson_append_string(&bb, data->search_field, username);
	
	if (strcmp(data->mac_field, "") != 0) {
		bson_append_string(&bb, data->mac_field, mac);
	}
	
	if (strcmp(data->enable_field, "") != 0) {
		bson_append_bool(&bb, data->enable_field, 1);
	}	
	
	bson_from_buffer(&query, &bb);
	bson_buffer_destroy(&bb);

	bson_empty(&field);

	bson_empty(&result);

	MONGO_TRY{
		if (mongo_find_one(conn, data->base, &query, &field, &result) == 0) {
			return 0;
		}
	}MONGO_CATCH{
		mongo_start(data);
		return 0;
	}
	
	bson_iterator it;
	bson_iterator_init(&it, result.data);
	
	find_in_array(&it, data->username_field, username, data->password_field, password);
	bson_destroy(&result);
	return 1;
}
示例#28
0
void json_from_bson_type(bson_type t, yajl_gen *g, bson_iterator *it)
{
    switch( t )
    {
    case BSON_ARRAY:
    {
        bson_iterator subi[1];
        bson_iterator_subiterator( it, subi );
        json_from_bson_array( g, subi );
        break;
    }
    case BSON_OBJECT:
    {
        bson sub[1];
        bson_iterator_subobject( it, sub );
        bson_iterator subi[1];
        bson_iterator_init( subi, sub );
        json_from_bson_object( g, subi );
        break;
    }
    case BSON_DOUBLE:
        json_from_bson_double( g, it );
        break;
    case BSON_STRING:
        json_from_bson_string( g, it );
        break;
    case BSON_BOOL:
        json_from_bson_bool( g, it );
        break;
    case BSON_NULL:
        json_from_bson_null( g );
        break;
    case BSON_INT:
        json_from_bson_int( g, it );
        break;
    case BSON_LONG:
        json_from_bson_long( g, it );
        break;
    default:
        break;
    }
}
示例#29
0
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);
}
示例#30
0
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);
    }
}