static void make_large( bson *out, int i ) {
int num;
char numstr[4];
bson_init( out );
bson_append_new_oid( out, "_id" );
bson_append_int( out, "x", i );
bson_append_string( out, "base_url", "http://www.example.com/test-me" );
bson_append_int( out, "total_word_count", 6743 );
bson_append_int( out, "access_time", 999 ); /*TODO use date*/
bson_append_start_object( out, "meta_tags" );
bson_append_string( out, "description", "i am a long description string" );
bson_append_string( out, "author", "Holly Man" );
bson_append_string( out, "dynamically_created_meta_tag", "who know\n what" );
bson_append_finish_object( out );
bson_append_start_object( out, "page_structure" );
bson_append_int( out, "counted_tags", 3450 );
bson_append_int( out, "no_of_js_attached", 10 );
bson_append_int( out, "no_of_images", 6 );
bson_append_finish_object( out );
bson_append_start_array( out, "harvested_words" );
for ( num=0; num < 14*20; num++ ) {
bson_numstr( numstr, num );
bson_append_string( out, numstr, words[num%14] );
}
bson_append_finish_object( out );
bson_finish( out );
}
void test_example_wikipedia_bson(size_t iterations) {
bcon_error_t ret;
size_t i;
bson b[1];
for (i = 0; i < iterations; i++) {
bson_init( b );
bson_append_string( b, "firstName", "John" );
bson_append_string( b, "lastName" , "Smith" );
bson_append_int( b, "age" , 25);
bson_append_start_object( b, "address" );
bson_append_string( b, "streetAddress", "21 2nd Street" );
bson_append_string( b, "city" , "New York" );
bson_append_string( b, "state" , "NY" );
bson_append_string( b, "postalCode" , "10021" );
bson_append_finish_object( b );
bson_append_start_array( b, "phoneNumber" );
bson_append_start_object( b, "0" );
bson_append_string( b, "type" , "home" );
bson_append_string( b, "number", "212 555-1234" );
bson_append_finish_object( b );
bson_append_start_object( b, "1" );
bson_append_string( b, "type" , "fax" );
bson_append_string( b, "number", "646 555-4567" );
bson_append_finish_object( b );
bson_append_finish_array( b );
ret = bson_finish( b );
bson_destroy( b );
}
assert(ret == BSON_OK);
}
static int mongo_bson_buffer_append_complex(struct bson_buffer* b, const char* name, double r, double i) {
bson* _b = (bson*) b;
return (bson_append_start_object(_b, name) == BSON_OK) &&
(bson_append_double(_b, "r", r) == BSON_OK) &&
(bson_append_double(_b, "i", i) == BSON_OK) &&
(bson_append_finish_object(_b) == BSON_OK);
}
static void find_range( const char *ns ) {
int i;
bson bb;
mongo_cursor *cursor;
for ( i=0; i < PER_TRIAL; i++ ) {
int j=0;
bson_init( &bb );
bson_append_start_object( &bb, "x" );
bson_append_int( &bb, "$gt", PER_TRIAL/2 );
bson_append_int( &bb, "$lt", PER_TRIAL/2 + BATCH_SIZE );
bson_append_finish_object( &bb );
bson_finish( &bb );
cursor = mongo_find( conn, ns, &bb, NULL, 0,0,0 );
ASSERT( cursor );
while( mongo_cursor_next( cursor ) == MONGO_OK ) {
j++;
}
ASSERT( j == BATCH_SIZE-1 );
mongo_cursor_destroy( cursor );
bson_destroy( &bb );
}
}
/*
* 实现抽象接口：
*/
int NotEqualDecorator::custom_result_set_query(bson* query)
{
int size = this->fitler_conditions.size();
LOGD("[GWJ] %s: filter_size[%d]", __FUNCTION__, size);
if(size > 0)
{
const char* column_name = this->fitler_conditions[0].table_column;
if(column_name == NULL)
{
LOGD("[GWJ] %s: end. Error filter column name!!", __FUNCTION__);
return -1;
}
LOGD("[GWJ] %s: start. column[%s], size[%d]", __FUNCTION__, column_name, size);
bson_append_start_object(query, column_name);
bson_append_string(query, "$ne", this->fitler_conditions[0].value);
LOGD("[GWJ] %s: [%s] not equal[%s]",
__FUNCTION__, column_name, this->fitler_conditions[0].value);
bson_append_finish_object(query);
}
else if(size == 0)
{
LOGD("[GWJ] %s: BiggerThanDecorator no filter Error!", __FUNCTION__);
return -1;
}
LOGD("[GWJ] %s: BiggerThanDecorator end", __FUNCTION__);
return 0;
}
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 );
}
MONGO_EXPORT int mongo_cmd_add_user( mongo *conn, const char *db, const char *user, const char *pass ) {
bson user_obj;
bson pass_obj;
char hex_digest[33];
char *ns = bson_malloc( strlen( db ) + strlen( ".system.users" ) + 1 );
int res;
strcpy( ns, db );
strcpy( ns+strlen( db ), ".system.users" );
mongo_pass_digest( user, pass, hex_digest );
bson_init( &user_obj );
bson_append_string( &user_obj, "user", user );
bson_finish( &user_obj );
bson_init( &pass_obj );
bson_append_start_object( &pass_obj, "$set" );
bson_append_string( &pass_obj, "pwd", hex_digest );
bson_append_finish_object( &pass_obj );
bson_finish( &pass_obj );
res = mongo_update( conn, ns, &user_obj, &pass_obj, MONGO_UPDATE_UPSERT );
bson_free( ns );
bson_destroy( &user_obj );
bson_destroy( &pass_obj );
return res;
}
int update_filesize(struct inode * e, off_t newsize) {
bson cond, doc;
mongo * conn = get_conn();
int res;
if(newsize < e->size)
return 0;
e->size = newsize;
bson_init(&cond);
bson_append_oid(&cond, "_id", &e->oid);
bson_finish(&cond);
bson_init(&doc);
bson_append_start_object(&doc, "$set");
bson_append_long(&doc, "size", newsize);
bson_append_finish_object(&doc);
bson_finish(&doc);
res = mongo_update(conn, inodes_name, &cond, &doc, 0, NULL);
bson_destroy(&cond);
bson_destroy(&doc);
if(res != 0)
return -EIO;
return 0;
}
/**
* \brief This function tries to add new tag group to MongoDB
*/
int vs_mongo_taggroup_add_new(struct VS_CTX *vs_ctx,
struct VSNode *node,
struct VSTagGroup *tg)
{
bson bson_tg;
int ret;
bson_init(&bson_tg);
bson_oid_gen(&tg->oid);
bson_append_oid(&bson_tg, "_id", &tg->oid);
bson_append_int(&bson_tg, "node_id", node->id);
bson_append_int(&bson_tg, "taggroup_id", tg->id);
bson_append_int(&bson_tg, "custom_type", tg->custom_type);
bson_append_int(&bson_tg, "current_version", tg->version);
bson_append_start_object(&bson_tg, "versions");
vs_mongo_taggroup_save_version(tg, &bson_tg, UINT32_MAX);
bson_append_finish_object(&bson_tg);
bson_finish(&bson_tg);
ret = mongo_insert(vs_ctx->mongo_conn, vs_ctx->mongo_tg_ns, &bson_tg, 0);
bson_destroy(&bson_tg);
if(ret != MONGO_OK) {
v_print_log(VRS_PRINT_ERROR,
"Unable to write tag group %d of node %d to MongoDB: %s, error: %s\n",
tg->id, node->id, vs_ctx->mongo_tg_ns,
mongo_get_server_err_string(vs_ctx->mongo_conn));
return 0;
}
return 1;
}
int test_tailable( mongo *conn ) {
mongo_cursor *cursor;
bson b;
int count;
remove_sample_data( conn );
create_capped_collection( conn );
insert_sample_data( conn, 10000 );
bson_init( &b );
bson_append_start_object( &b, "$query" );
bson_append_finish_object( &b );
bson_append_start_object( &b, "$sort" );
bson_append_int( &b, "$natural", -1 );
bson_append_finish_object( &b );
bson_finish( &b );
cursor = mongo_find( conn, "test.cursors", &b, bson_shared_empty( ), 0, 0, MONGO_TAILABLE );
bson_destroy( &b );
count = 0;
while( mongo_cursor_next( cursor ) == MONGO_OK )
count++;
ASSERT( count == 10000 );
ASSERT( mongo_cursor_next( cursor ) == MONGO_ERROR );
ASSERT( cursor->err == MONGO_CURSOR_PENDING );
insert_sample_data( conn, 10 );
count = 0;
while( mongo_cursor_next( cursor ) == MONGO_OK ) {
count++;
}
ASSERT( count == 10 );
ASSERT( mongo_cursor_next( cursor ) == MONGO_ERROR );
ASSERT( cursor->err == MONGO_CURSOR_PENDING );
mongo_cursor_destroy( cursor );
remove_sample_data( conn );
return 0;
}
bool encodeObject(bson *bb, const char *name, v8::Local<v8::Value> element,
bool doJson)
{
v8::Local<v8::Object> object = element->ToObject();
if (doJson)
{
v8::Local<v8::Value> jsonFun = object->Get(
v8::String::NewFromUtf8(isolate, "toJSON",
v8::String::kNormalString, 6));
if (!IsEmpty(jsonFun) && jsonFun->IsFunction())
{
v8::Local<v8::Value> p = v8::String::NewFromUtf8(isolate, name ? name : "");
v8::Local<v8::Value> element1 = v8::Local<v8::Function>::Cast(
jsonFun)->Call(object, 1, &p);
if (name)
{
encodeValue(bb, name, element1, false);
return true;
}
if (!element1->IsObject())
return false;
object = element1->ToObject();
}
}
if (!name
&& (object->IsDate() || object->IsArray() || object->IsRegExp()
|| Buffer_base::getInstance(object)))
return false;
if (name)
bson_append_start_object(bb, name);
v8::Local<v8::Array> properties = object->GetPropertyNames();
for (int i = 0; i < (int) properties->Length(); i++)
{
v8::Local<v8::Value> prop_name = properties->Get(i);
v8::Local<v8::Value> prop_val = object->Get(prop_name);
v8::String::Utf8Value n(prop_name);
const char *pname = ToCString(n);
encodeValue(bb, pname, prop_val);
}
if (name)
bson_append_finish_object(bb);
return true;
}
int main() {
/*
* We assume objects in the form of {_id:<any_id>, list:[{a:<int>,b:<int>}, ...]}
*/
mongo conn[1];
mongo_init(conn);
if(MONGO_OK != mongo_client(conn, "127.0.0.1", 27017))
return 1;
bson b[1], b_result[1];
/*create the aggregation command in bson*/
bson_init(b);
bson_append_string(b, "aggregate", "agg");
bson_append_start_array(b, "pipeline");
bson_append_start_object(b,"0");
bson_append_string(b, "$unwind", "$list");
bson_append_finish_object(b);
bson_append_start_object(b,"1");
bson_append_start_object(b,"$group");
bson_append_string(b,"_id", "$list");
bson_append_start_object(b, "distinct_count");
bson_append_int(b, "$sum", 1);
bson_append_finish_object(b);
bson_append_finish_object(b);
bson_append_finish_object(b);
bson_append_finish_array(b);
bson_finish(b);
/*So you can see your command*/
bson_print(b);
/*run the command*/
mongo_run_command(conn, "test", b, b_result);
/*command results*/
bson_print(b_result);
bson_destroy(b_result);
bson_destroy(b);
mongo_destroy(conn);
return 0;
}
static void
jbson_object_start(void *state)
{
json_to_bson_state *_state = (json_to_bson_state *) state;
if (_state->lex->lex_level == 0)
return;
if (_state->fname == NULL)
elog(ERROR, "unsupported json structure");
bson_append_start_object(_state->bson, _state->fname);
}
void bson_from_json_type(bson *b, yajl_val value, const char* key)
{
if( YAJL_IS_STRING( value ) )
{
char* string = YAJL_GET_STRING( value );
bson_append_string( b, key, string );
}
else if( YAJL_IS_NUMBER( value ) )
{
char* string = value->u.number.r;
size_t len = strlen( string );
// Hack to detect a double, since 'flags' is always set to double.
if( memchr( string, '.', len ) ||
memchr( string, 'e', len ) ||
memchr( string, 'E', len ) )
{
double number = YAJL_GET_DOUBLE( value );
bson_append_double( b, key, number );
}
else
{
uint64_t number = YAJL_GET_INTEGER( value );
if( number <= INT_MIN && number <= INT_MAX)
bson_append_int( b, key, (int)number );
else
bson_append_long( b, key, number);
}
}
else if ( YAJL_IS_FALSE( value ) )
{
bson_append_bool( b, key, 0 );
}
else if ( YAJL_IS_TRUE( value ) )
{
bson_append_bool( b, key, 1 );
}
else if ( YAJL_IS_ARRAY( value ) )
{
bson_append_start_array( b, key );
bson_from_json_array( b, value );
bson_append_finish_array( b );
}
else if ( YAJL_IS_OBJECT( value ) )
{
bson_append_start_object( b, key );
bson_from_json_object( b, value );
bson_append_finish_object( b );
}
}
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;
}
int commit_inode(struct inode * e) {
bson cond, doc;
mongo * conn = get_conn();
char istr[4];
struct dirent * cde = e->dirents;
int res;
bson_init(&doc);
bson_append_start_object(&doc, "$set");
bson_append_start_array(&doc, "dirents");
res = 0;
while(cde) {
bson_numstr(istr, res++);
bson_append_string(&doc, istr, cde->path);
cde = cde->next;
}
bson_append_finish_array(&doc);
bson_append_int(&doc, "mode", e->mode);
bson_append_long(&doc, "owner", e->owner);
bson_append_long(&doc, "group", e->group);
bson_append_long(&doc, "size", e->size);
bson_append_time_t(&doc, "created", e->created);
bson_append_time_t(&doc, "modified", e->modified);
if(e->data && e->datalen > 0)
bson_append_string_n(&doc, "data", e->data, e->datalen);
bson_append_finish_object(&doc);
bson_finish(&doc);
bson_init(&cond);
bson_append_oid(&cond, "_id", &e->oid);
bson_finish(&cond);
res = mongo_update(conn, inodes_name, &cond, &doc,
MONGO_UPDATE_UPSERT, NULL);
bson_destroy(&cond);
bson_destroy(&doc);
if(res != MONGO_OK) {
fprintf(stderr, "Error committing inode %s\n",
mongo_get_server_err_string(conn));
return -EIO;
}
return 0;
}
static void tutorial_update( mongo *conn ) {
bson cond[1], op[1];
bson_init( cond );
bson_append_string( cond, "name", "Joe");
bson_append_int( cond, "age", 33);
bson_finish( cond );
bson_init( op );
bson_append_start_object( op, "$inc" );
bson_append_int( op, "visits", 1 );
bson_append_finish_object( op );
bson_finish( op );
mongo_update( conn, "tutorial.persons", cond, op, MONGO_UPDATE_BASIC, 0 );
bson_destroy( cond );
bson_destroy( op );
}
/* Update DLR */
static void dlr_mongodb_update(const Octstr *smsc, const Octstr *ts, const Octstr *dst, int status)
{
DBPoolConn *pconn;
bson cond, op;
bson_buffer cond_buf, op_buf;
mongo_connection *conn = NULL;
pconn = dbpool_conn_consume(pool);
if (pconn == NULL) {
return;
}
conn = (mongo_connection*)pconn->conn;
bson_buffer_init(&cond_buf);
bson_append_string(&cond_buf, octstr_get_cstr(fields->field_smsc), octstr_get_cstr(smsc));
bson_append_string(&cond_buf, octstr_get_cstr(fields->field_ts), octstr_get_cstr(ts));
if (dst) {
bson_append_string(&cond_buf, octstr_get_cstr(fields->field_dst), octstr_get_cstr(dst));
}
bson_from_buffer(&cond, &cond_buf);
bson_buffer_init(&op_buf);
{
bson_buffer *sub = bson_append_start_object(&op_buf, "$set");
bson_append_int(sub, octstr_get_cstr(fields->field_status), status);
bson_append_finish_object(sub);
}
bson_from_buffer(&op, &op_buf);
MONGO_TRY {
mongo_update(conn, mongodb_namespace, &cond, &op, 0);
} MONGO_CATCH {
mongodb_error("dlr_mongodb_update", conn->exception.type);
}
dbpool_conn_produce(pconn);
bson_destroy(&cond);
bson_destroy(&op);
}
int test_bson_deep_nesting( void ) {
int i;
bson b[1];
bson_init( b );
for ( i = 0; i < 128; ++i )
{
bson_append_start_object( b, "sub" );
bson_append_string( b, "hello", "hi" );
}
for ( i = 0; i < 128; ++i )
{
bson_append_finish_object( b );
}
bson_finish( b );
bson_destroy( b );
return 0;
}
int do_trunc(struct inode * e, off_t off) {
bson cond;
int res;
mongo * conn = get_conn();
if(off > e->size) {
e->size = off;
return 0;
}
pthread_mutex_lock(&e->wr_lock);
if(e->wr_extent) {
if(off < 0 && (res = serialize_extent(e, e->wr_extent)) != 0)
return res;
e->wr_extent->nnodes = 0;
}
e->wr_age = time(NULL);
pthread_mutex_unlock(&e->wr_lock);
bson_init(&cond);
bson_append_oid(&cond, "inode", &e->oid);
if(off > 0) {
bson_append_start_object(&cond, "start");
bson_append_long(&cond, "$gte", off);
bson_append_finish_object(&cond);
}
bson_finish(&cond);
res = mongo_remove(conn, extents_name, &cond, NULL);
bson_destroy(&cond);
if(res != 0) {
fprintf(stderr, "Error removing extents in do_truncate\n");
return -EIO;
}
e->size = off;
return 0;
}
int test_bad_query( mongo *conn ) {
mongo_cursor cursor[1];
bson b[1];
bson_init( b );
bson_append_start_object( b, "foo" );
bson_append_int( b, "$bad", 1 );
bson_append_finish_object( b );
bson_finish( b );
mongo_cursor_init( cursor, conn, "test.cursors" );
mongo_cursor_set_query( cursor, b );
ASSERT( mongo_cursor_next( cursor ) == MONGO_ERROR );
ASSERT( cursor->err == MONGO_CURSOR_QUERY_FAIL );
ASSERT( cursor->conn->lasterrcode == 10068 );
ASSERT( strlen( cursor->conn->lasterrstr ) > 0 );
mongo_cursor_destroy( cursor );
bson_destroy( b );
return 0;
}
int _tmain(int argc, _TCHAR* argv[]) {
setlocale(LC_ALL, "en_US.UTF-8");
jb = ejdbnew();
if (!ejdbopen(jb, "addressbook", JBOWRITER | JBOCREAT | JBOTRUNC)) {
return 1;
}
//Get or create collection 'contacts'
EJCOLL *coll = ejdbcreatecoll(jb, "contacts", NULL);
bson bsrec;
bson_oid_t oid;
//One record
bson_init(&bsrec);
bson_append_string(&bsrec, "name", "John Travolta");
bson_append_string(&bsrec, "phone", "333-222-333");
bson_append_int(&bsrec, "age", 58);
bson_finish(&bsrec);
ejdbsavebson(coll, &bsrec, &oid);
fprintf(stderr, "\nSaved Travolta");
bson_destroy(&bsrec);
//Another record
bson_init(&bsrec);
bson_append_string(&bsrec, "name", "Bruce Willis");
bson_append_string(&bsrec, "phone", "222-333-222");
bson_append_int(&bsrec, "age", 57);
bson_finish(&bsrec);
ejdbsavebson(coll, &bsrec, &oid);
fprintf(stderr, "\nSaved Bruce Willis");
bson_destroy(&bsrec);
//Now select one record.
//Query: {'name' : {'$begin' : 'Bru'}} //Name starts with 'Bru' string
bson bq1;
bson_init_as_query(&bq1);
bson_append_start_object(&bq1, "name");
bson_append_string(&bq1, "$begin", "Bru");
bson_append_finish_object(&bq1);
bson_finish(&bq1);
EJQ *q1 = ejdbcreatequery(jb, &bq1, NULL, 0, NULL);
uint32_t count;
TCLIST *res = ejdbqryexecute(coll, q1, &count, 0, NULL);
fprintf(stderr, "\n\nRecords found: %d\n", count);
for (int i = 0; i < TCLISTNUM(res); ++i) {
void *bsdata = TCLISTVALPTR(res, i);
bson_print_raw((char*) bsdata, 0);
}
fprintf(stderr, "\n");
//Dispose result set
tclistdel(res);
//Dispose query
ejdbquerydel(q1);
bson_destroy(&bq1);
//Close database
ejdbclose(jb);
ejdbdel(jb);
getc(stdin);
return 0;
}
static switch_status_t my_on_reporting(switch_core_session_t *session)
{
switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_channel_t *channel = switch_core_session_get_channel(session);
switch_event_header_t *hi;
switch_caller_profile_t *caller_profile;
switch_app_log_t *app_log;
bson cdr;
int is_b;
char *tmp;
if (globals.shutdown) {
return SWITCH_STATUS_SUCCESS;
}
is_b = channel && switch_channel_get_originator_caller_profile(channel);
if (!globals.log_b && is_b) {
const char *force_cdr = switch_channel_get_variable(channel, SWITCH_FORCE_PROCESS_CDR_VARIABLE);
if (!switch_true(force_cdr)) {
return SWITCH_STATUS_SUCCESS;
}
}
bson_init(&cdr);
/* Channel data */
bson_append_start_object(&cdr, "channel_data");
bson_append_string(&cdr, "state", switch_channel_state_name(switch_channel_get_state(channel)));
bson_append_string(&cdr, "direction", switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound");
bson_append_int(&cdr, "state_number", switch_channel_get_state(channel));
if ((tmp = switch_channel_get_flag_string(channel))) {
bson_append_string(&cdr, "flags", tmp);
free(tmp);
}
if ((tmp = switch_channel_get_cap_string(channel))) {
bson_append_string(&cdr, "caps", tmp);
free(tmp);
}
bson_append_finish_object(&cdr); /* channel_data */
/* Channel variables */
bson_append_start_object(&cdr, "variables");
if ((hi = switch_channel_variable_first(channel))) {
for (; hi; hi = hi->next) {
if (!zstr(hi->name) && !zstr(hi->value)) {
bson_append_string(&cdr, hi->name, hi->value);
}
}
switch_channel_variable_last(channel);
}
bson_append_finish_object(&cdr); /* variables */
/* App log */
if ((app_log = switch_core_session_get_app_log(session))) {
switch_app_log_t *ap;
bson_append_start_object(&cdr, "app_log");
for (ap = app_log; ap; ap = ap->next) {
bson_append_start_object(&cdr, "application");
bson_append_string(&cdr, "app_name", ap->app);
bson_append_string(&cdr, "app_data", ap->arg);
bson_append_long(&cdr, "app_stamp", ap->stamp);
bson_append_finish_object(&cdr); /* application */
}
bson_append_finish_object(&cdr); /* app_log */
}
/* Callflow */
caller_profile = switch_channel_get_caller_profile(channel);
while (caller_profile) {
bson_append_start_object(&cdr, "callflow");
if (!zstr(caller_profile->dialplan)) {
bson_append_string(&cdr, "dialplan", caller_profile->dialplan);
}
if (!zstr(caller_profile->profile_index)) {
bson_append_string(&cdr, "profile_index", caller_profile->profile_index);
}
if (caller_profile->caller_extension) {
switch_caller_application_t *ap;
bson_append_start_object(&cdr, "extension");
bson_append_string(&cdr, "name", caller_profile->caller_extension->extension_name);
bson_append_string(&cdr, "number", caller_profile->caller_extension->extension_number);
if (caller_profile->caller_extension->current_application) {
bson_append_string(&cdr, "current_app", caller_profile->caller_extension->current_application->application_name);
}
for (ap = caller_profile->caller_extension->applications; ap; ap = ap->next) {
bson_append_start_object(&cdr, "application");
if (ap == caller_profile->caller_extension->current_application) {
bson_append_bool(&cdr, "last_executed", 1);
}
bson_append_string(&cdr, "app_name", ap->application_name);
bson_append_string(&cdr, "app_data", ap->application_data);
bson_append_finish_object(&cdr);
}
if (caller_profile->caller_extension->children) {
switch_caller_profile_t *cp = NULL;
for (cp = caller_profile->caller_extension->children; cp; cp = cp->next) {
if (!cp->caller_extension) {
continue;
}
bson_append_start_object(&cdr, "sub_extensions");
bson_append_start_object(&cdr, "extension");
bson_append_string(&cdr, "name", cp->caller_extension->extension_name);
bson_append_string(&cdr, "number", cp->caller_extension->extension_number);
bson_append_string(&cdr, "dialplan", cp->dialplan);
if (cp->caller_extension->current_application) {
bson_append_string(&cdr, "current_app", cp->caller_extension->current_application->application_name);
}
for (ap = cp->caller_extension->applications; ap; ap = ap->next) {
bson_append_start_object(&cdr, "application");
if (ap == cp->caller_extension->current_application) {
bson_append_bool(&cdr, "last_executed", 1);
}
bson_append_string(&cdr, "app_name", ap->application_name);
bson_append_string(&cdr, "app_data", ap->application_data);
bson_append_finish_object(&cdr);
}
bson_append_finish_object(&cdr); /* extension */
bson_append_finish_object(&cdr); /* sub_extensions */
}
}
bson_append_finish_object(&cdr); /* extension */
}
bson_append_start_object(&cdr, "caller_profile");
set_bson_profile_data(&cdr, caller_profile);
if (caller_profile->origination_caller_profile) {
switch_caller_profile_t *cp = NULL;
bson_append_start_object(&cdr, "origination");
for (cp = caller_profile->origination_caller_profile; cp; cp = cp->next) {
bson_append_start_object(&cdr, "origination_caller_profile");
set_bson_profile_data(&cdr, cp);
bson_append_finish_object(&cdr);
}
bson_append_finish_object(&cdr); /* origination */
}
if (caller_profile->originator_caller_profile) {
switch_caller_profile_t *cp = NULL;
bson_append_start_object(&cdr, "originator");
for (cp = caller_profile->originator_caller_profile; cp; cp = cp->next) {
bson_append_start_object(&cdr, "originator_caller_profile");
set_bson_profile_data(&cdr, cp);
bson_append_finish_object(&cdr);
}
bson_append_finish_object(&cdr); /* originator */
}
if (caller_profile->originatee_caller_profile) {
switch_caller_profile_t *cp = NULL;
bson_append_start_object(&cdr, "originatee");
for (cp = caller_profile->originatee_caller_profile; cp; cp = cp->next) {
bson_append_start_object(&cdr, "originatee_caller_profile");
set_bson_profile_data(&cdr, cp);
bson_append_finish_object(&cdr);
}
bson_append_finish_object(&cdr); /* originatee */
}
bson_append_finish_object(&cdr); /* caller_profile */
/* Timestamps */
if (caller_profile->times) {
bson_append_start_object(&cdr, "times");
/* Insert timestamps as long ints (microseconds) to preserve accuracy */
bson_append_long(&cdr, "created_time", caller_profile->times->created);
bson_append_long(&cdr, "profile_created_time", caller_profile->times->profile_created);
bson_append_long(&cdr, "progress_time", caller_profile->times->progress);
bson_append_long(&cdr, "progress_media_time", caller_profile->times->progress_media);
bson_append_long(&cdr, "answered_time", caller_profile->times->answered);
bson_append_long(&cdr, "bridged_time", caller_profile->times->bridged);
bson_append_long(&cdr, "last_hold_time", caller_profile->times->last_hold);
bson_append_long(&cdr, "hold_accum_time", caller_profile->times->hold_accum);
bson_append_long(&cdr, "hangup_time", caller_profile->times->hungup);
bson_append_long(&cdr, "resurrect_time", caller_profile->times->resurrected);
bson_append_long(&cdr, "transfer_time", caller_profile->times->transferred);
bson_append_finish_object(&cdr); /* times */
}
bson_append_finish_object(&cdr); /* callflow */
caller_profile = caller_profile->next;
}
bson_finish(&cdr);
switch_mutex_lock(globals.mongo_mutex);
if (mongo_insert(globals.mongo_conn, globals.mongo_namespace, &cdr) != MONGO_OK) {
if (globals.mongo_conn->err == MONGO_IO_ERROR) {
mongo_error_t db_status;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "MongoDB connection failed; attempting reconnect...\n");
db_status = mongo_reconnect(globals.mongo_conn);
if (db_status != MONGO_OK) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "MongoDB reconnect failed with error code %d\n", db_status);
status = SWITCH_STATUS_FALSE;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "MongoDB connection re-established.\n");
if (mongo_insert(globals.mongo_conn, globals.mongo_namespace, &cdr) != MONGO_OK) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "mongo_insert: error code %d\n", globals.mongo_conn->err);
status = SWITCH_STATUS_FALSE;
}
}
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "mongo_insert: error code %d\n", globals.mongo_conn->err);
status = SWITCH_STATUS_FALSE;
}
}
switch_mutex_unlock(globals.mongo_mutex);
bson_destroy(&cdr);
return status;
}
void testBuildQuery1() {
CU_ASSERT_PTR_NOT_NULL_FATAL(jb);
/*
Query = {
"name" : Петров Петр,
"age" : 33,
"family" : {
"wife" : {
"name" : "Jeniffer",
"age" : {"$gt" : 25},
"phone" : "444-111"
},
"children" : [
{
"name" : "Dasha",
"age" : {"$in" : [1, 4, 10]}
}
]
}
*/
bson q1;
bson_init_as_query(&q1);
bson_append_string(&q1, "name", "Петров Петр");
bson_append_int(&q1, "age", 33);
bson q1family_wife;
bson_init_as_query(&q1family_wife);
bson_append_string(&q1family_wife, "name", "Jeniffer");
bson_append_start_object(&q1family_wife, "age");
bson_append_int(&q1family_wife, "$gt", 25);
bson_append_finish_object(&q1family_wife);
bson_append_string(&q1family_wife, "phone", "444-111");
bson_finish(&q1family_wife);
bson q1family_child;
bson_init_as_query(&q1family_child);
bson_append_string(&q1family_child, "name", "Dasha");
//"age" : {"$in" : [1, 4, 10]}
bson q1family_child_age_IN;
bson_init_as_query(&q1family_child_age_IN);
bson_append_start_array(&q1family_child_age_IN, "$in");
bson_append_int(&q1family_child_age_IN, "0", 1);
bson_append_int(&q1family_child_age_IN, "1", 4);
bson_append_int(&q1family_child_age_IN, "2", 10);
bson_append_finish_array(&q1family_child_age_IN);
bson_finish(&q1family_child_age_IN);
bson_append_bson(&q1family_child, "age", &q1family_child_age_IN);
bson_finish(&q1family_child);
bson q1family;
bson_init_as_query(&q1family);
bson_append_bson(&q1family, "wife", &q1family_wife);
bson_append_start_array(&q1family, "children");
bson_append_bson(&q1family, "0", &q1family_child);
bson_append_finish_array(&q1family);
bson_finish(&q1family);
bson_append_bson(&q1, "family", &q1family);
bson_finish(&q1);
CU_ASSERT_FALSE_FATAL(q1.err);
CU_ASSERT_FALSE_FATAL(q1family.err);
CU_ASSERT_FALSE_FATAL(q1family_wife.err);
CU_ASSERT_FALSE_FATAL(q1family_child.err);
CU_ASSERT_FALSE_FATAL(q1family_child_age_IN.err);
EJQ *ejq = ejdbcreatequery(jb, &q1, NULL, 0, NULL);
CU_ASSERT_PTR_NOT_NULL_FATAL(ejq);
bson_destroy(&q1);
bson_destroy(&q1family);
bson_destroy(&q1family_wife);
bson_destroy(&q1family_child);
bson_destroy(&q1family_child_age_IN);
CU_ASSERT_PTR_NOT_NULL_FATAL(ejq->qobjlist);
TCLIST *qmap = ejq->qobjlist;
CU_ASSERT_EQUAL(qmap->num, 7);
for (int i = 0; i < TCLISTNUM(qmap); ++i) {
const EJQF *qf = TCLISTVALPTR(qmap, i);
CU_ASSERT_PTR_NOT_NULL_FATAL(qf);
const char* key = qf->fpath;
switch (i) {
case 0:
{
CU_ASSERT_STRING_EQUAL(key, "name");
CU_ASSERT_PTR_NOT_NULL(qf);
CU_ASSERT_STRING_EQUAL(qf->expr, "Петров Петр");
CU_ASSERT_EQUAL(qf->tcop, TDBQCSTREQ);
break;
}
case 1:
{
CU_ASSERT_STRING_EQUAL(key, "age");
CU_ASSERT_PTR_NOT_NULL(qf);
CU_ASSERT_STRING_EQUAL(qf->expr, "33");
CU_ASSERT_EQUAL(qf->tcop, TDBQCNUMEQ);
break;
}
case 2:
{
CU_ASSERT_STRING_EQUAL(key, "family.wife.name");
CU_ASSERT_PTR_NOT_NULL(qf);
CU_ASSERT_STRING_EQUAL(qf->expr, "Jeniffer");
CU_ASSERT_EQUAL(qf->tcop, TDBQCSTREQ);
break;
}
case 3:
{
CU_ASSERT_STRING_EQUAL(key, "family.wife.age");
CU_ASSERT_PTR_NOT_NULL(qf);
CU_ASSERT_STRING_EQUAL(qf->expr, "25");
CU_ASSERT_EQUAL(qf->tcop, TDBQCNUMGT);
break;
}
case 4:
{
CU_ASSERT_STRING_EQUAL(key, "family.wife.phone");
CU_ASSERT_PTR_NOT_NULL(qf);
CU_ASSERT_STRING_EQUAL(qf->expr, "444-111");
CU_ASSERT_EQUAL(qf->tcop, TDBQCSTREQ);
break;
}
case 5:
{
CU_ASSERT_STRING_EQUAL(key, "family.children.0.name");
CU_ASSERT_PTR_NOT_NULL(qf);
CU_ASSERT_STRING_EQUAL(qf->expr, "Dasha");
CU_ASSERT_EQUAL(qf->tcop, TDBQCSTREQ);
break;
}
case 6:
{
CU_ASSERT_STRING_EQUAL(key, "family.children.0.age");
CU_ASSERT_PTR_NOT_NULL(qf);
CU_ASSERT_EQUAL(qf->ftype, BSON_ARRAY);
TCLIST *al = tclistload(qf->expr, qf->exprsz);
char* als = tcstrjoin(al, ',');
CU_ASSERT_STRING_EQUAL(als, "1,4,10");
TCFREE(als);
tclistdel(al);
CU_ASSERT_EQUAL(qf->tcop, TDBQCNUMOREQ);
break;
}
}
}
ejdbquerydel(ejq);
}
void testCheckDuplicates(void) {
bson bs, bs2;
bson_iterator it;
bson_type bt;
bson_init(&bs);
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "b", 2);
bson_append_null(&bs, "c");
bson_append_start_object(&bs, "d");
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "e", 0);
bson_append_int(&bs, "d", 1);
bson_append_finish_object(&bs);
bson_finish(&bs);
CU_ASSERT_FALSE_FATAL(bs.err);
CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs));
bson_destroy(&bs);
bson_init(&bs);
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "b", 2);
bson_append_null(&bs, "c");
bson_append_start_object(&bs, "d");
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "e", 0);
bson_append_int(&bs, "e", 1);
bson_append_finish_object(&bs);
bson_finish(&bs);
CU_ASSERT_FALSE_FATAL(bs.err);
CU_ASSERT_TRUE(bson_check_duplicate_keys(&bs));
bson_init(&bs2);
bson_fix_duplicate_keys(&bs, &bs2);
bson_finish(&bs2);
CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs2));
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("d.e", &it);
CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt));
CU_ASSERT_EQUAL(bson_iterator_int(&it), 1);
bson_destroy(&bs2);
bson_init(&bs);
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "b", 2);
bson_append_null(&bs, "c");
bson_append_start_object(&bs, "d");
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "e", 0);
bson_append_int(&bs, "d", 1);
bson_append_finish_object(&bs);
bson_append_start_array(&bs, "f");
bson_append_start_object(&bs, "0");
bson_append_string(&bs, "a", "a");
bson_append_string(&bs, "b", "b");
bson_append_int(&bs, "c", 1);
bson_append_finish_object(&bs);
bson_append_start_object(&bs, "1");
bson_append_string(&bs, "a", "a");
bson_append_string(&bs, "b", "b");
bson_append_int(&bs, "c", 1);
bson_append_finish_object(&bs);
bson_append_finish_array(&bs);
bson_finish(&bs);
CU_ASSERT_FALSE_FATAL(bs.err);
CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs));
bson_init(&bs);
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "b", 2);
bson_append_null(&bs, "c");
bson_append_start_object(&bs, "d");
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "e", 0);
bson_append_int(&bs, "d", 1);
bson_append_start_object(&bs, "q");
bson_append_int(&bs, "w", 0);
bson_append_finish_object(&bs);
bson_append_finish_object(&bs);
bson_append_start_array(&bs, "f");
bson_append_start_object(&bs, "0");
bson_append_string(&bs, "a", "a");
bson_append_string(&bs, "b", "b");
bson_append_int(&bs, "a", 1);
bson_append_finish_object(&bs);
bson_append_start_object(&bs, "1");
bson_append_string(&bs, "a", "a");
bson_append_string(&bs, "b", "b");
bson_append_int(&bs, "c", 1);
bson_append_finish_object(&bs);
bson_append_finish_array(&bs);
bson_append_start_object(&bs, "a");
bson_append_finish_object(&bs);
bson_append_start_object(&bs, "d");
bson_append_start_object(&bs, "q");
bson_append_int(&bs, "e", 1);
bson_append_finish_object(&bs);
bson_append_finish_object(&bs);
bson_finish(&bs);
CU_ASSERT_FALSE_FATAL(bs.err);
CU_ASSERT_TRUE(bson_check_duplicate_keys(&bs));
bson_init(&bs2);
bson_fix_duplicate_keys(&bs, &bs2);
bson_finish(&bs2);
CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs2));
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("f.0.a", &it);
CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt));
CU_ASSERT_EQUAL(bson_iterator_int(&it), 1);
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("f.1.a", &it);
CU_ASSERT_TRUE(BSON_IS_STRING_TYPE(bt));
CU_ASSERT_FALSE(strcmp(bson_iterator_string(&it), "a"));
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("a", &it);
CU_ASSERT_EQUAL(bt, BSON_OBJECT);
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("d.q.w", &it);
CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt));
CU_ASSERT_EQUAL(bson_iterator_int(&it), 0);
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("d.q.e", &it);
CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt));
CU_ASSERT_EQUAL(bson_iterator_int(&it), 1);
}
int main(){
mongo_connection conn[1];
bson_buffer bb;
bson obj;
bson cond;
int i;
bson_oid_t oid;
const char* col = "c.update_test";
const char* ns = "test.c.update_test";
INIT_SOCKETS_FOR_WINDOWS;
if (mongo_connect( conn , TEST_SERVER, 27017 )){
printf("failed to connect\n");
exit(1);
}
/* if the collection doesn't exist dropping it will fail */
if ( mongo_cmd_drop_collection(conn, "test", col, NULL) == MONGO_OK
&& mongo_find_one(conn, ns, bson_empty(&obj), bson_empty(&obj), NULL) != MONGO_OK ){
printf("failed to drop collection\n");
exit(1);
}
bson_oid_gen(&oid);
{ /* insert */
bson_buffer_init(&bb);
bson_append_oid(&bb, "_id", &oid);
bson_append_int(&bb, "a", 3 );
bson_from_buffer(&obj, &bb);
mongo_insert(conn, ns, &obj);
bson_destroy(&obj);
}
{ /* insert */
bson op;
bson_buffer_init(&bb);
bson_append_oid(&bb, "_id", &oid);
bson_from_buffer(&cond, &bb);
bson_buffer_init(&bb);
{
bson_append_start_object(&bb, "$inc");
bson_append_int(&bb, "a", 2 );
bson_append_finish_object(&bb);
}
{
bson_append_start_object(&bb, "$set");
bson_append_double(&bb, "b", -1.5 );
bson_append_finish_object(&bb);
}
bson_from_buffer(&op, &bb);
for (i=0; i<5; i++)
mongo_update(conn, ns, &cond, &op, 0);
/* cond is used later */
bson_destroy(&op);
}
if( mongo_find_one(conn, ns, &cond, 0, &obj) != MONGO_OK ){
printf("Failed to find object\n");
exit(1);
} else {
int fields = 0;
bson_iterator it;
bson_iterator_init(&it, obj.data);
bson_destroy(&cond);
while(bson_iterator_next(&it)){
switch(bson_iterator_key(&it)[0]){
case '_': /* id */
ASSERT(bson_iterator_type(&it) == BSON_OID);
ASSERT(!memcmp(bson_iterator_oid(&it)->bytes, oid.bytes, 12));
fields++;
break;
case 'a':
ASSERT(bson_iterator_type(&it) == BSON_INT);
ASSERT(bson_iterator_int(&it) == 3 + 5*2);
fields++;
break;
case 'b':
ASSERT(bson_iterator_type(&it) == BSON_DOUBLE);
ASSERT(bson_iterator_double(&it) == -1.5);
fields++;
break;
}
}
ASSERT(fields == 3);
}
bson_destroy(&obj);
mongo_cmd_drop_db(conn, "test");
mongo_destroy(conn);
return 0;
}
void testBSONExportImport2(void) {
EJDB *jb = ejdbnew();
CU_ASSERT_TRUE_FATAL(ejdbopen(jb, "dbt4_export", JBOWRITER | JBOCREAT | JBOTRUNC));
EJCOLL *coll = ejdbcreatecoll(jb, "col1", NULL);
if (!coll) {
eprint(jb, __LINE__, "testBSONExportImport2");
}
CU_ASSERT_TRUE(coll != NULL);
bson_oid_t oid;
const char *log = NULL;
bson bv1;
bson_init(&bv1);
bson_append_int(&bv1, "a", 1);
bson_append_string(&bv1, "c", "d");
bson_finish(&bv1);
ejdbsavebson(coll, &bv1, &oid);
bson_destroy(&bv1);
EJCOLLOPTS copts = {0};
copts.large = true;
copts.records = 200000;
coll = ejdbcreatecoll(jb, "col2", &copts);
if (!coll) {
eprint(jb, __LINE__, "testBSONExportImport2");
}
CU_ASSERT_TRUE(coll != NULL);
CU_ASSERT_TRUE(ejdbsetindex(coll, "f", JBIDXSTR | JBIDXNUM));
bson_init(&bv1);
bson_append_int(&bv1, "e", 1);
bson_append_string(&bv1, "f", "g");
bson_finish(&bv1);
ejdbsavebson(coll, &bv1, &oid);
bson_destroy(&bv1);
bson_init(&bv1);
bson_append_int(&bv1, "e", 2);
bson_append_string(&bv1, "f", "g2");
bson_finish(&bv1);
ejdbsavebson(coll, &bv1, &oid);
bson_destroy(&bv1);
bson cmd;
bson_init(&cmd);
bson_append_start_object(&cmd, "export");
bson_append_string(&cmd, "path", "testBSONExportImport2");
bson_append_start_array(&cmd, "cnames");
bson_append_string(&cmd, "0", "col1");
bson_append_string(&cmd, "1", "col2");
bson_append_finish_array(&cmd);
bson_append_finish_object(&cmd);
bson_finish(&cmd);
bson *bret = ejdbcommand(jb, &cmd);
CU_ASSERT_PTR_NOT_NULL_FATAL(bret);
bson_destroy(&cmd);
bson_iterator it;
bson_iterator_init(&it, bret);
CU_ASSERT_TRUE(bson_find_fieldpath_value("error", &it) == BSON_EOO);
bson_iterator_init(&it, bret);
CU_ASSERT_TRUE(bson_compare_long(0, bson_data(bret), "errorCode") == 0);
bson_iterator_init(&it, bret);
CU_ASSERT_TRUE(bson_find_fieldpath_value("log", &it) == BSON_STRING);
bson_del(bret);
bson *ometa = ejdbmeta(jb);
CU_ASSERT_TRUE_FATAL(ometa != NULL);
ejdbclose(jb);
ejdbdel(jb);
//Restore data:
jb = ejdbnew();
CU_ASSERT_TRUE_FATAL(ejdbopen(jb, "dbt4_export", JBOWRITER | JBOCREAT));
coll = ejdbgetcoll(jb, "col1");
CU_ASSERT_PTR_NOT_NULL_FATAL(coll);
bson_init(&bv1);
bson_append_int(&bv1, "e", 2);
bson_finish(&bv1);
CU_ASSERT_TRUE(ejdbsavebson(coll, &bv1, &oid));
bson_destroy(&bv1);
bson_init(&cmd);
bson_append_start_object(&cmd, "import");
bson_append_string(&cmd, "path", "testBSONExportImport2");
bson_append_int(&cmd, "mode", JBIMPORTREPLACE);
bson_append_start_array(&cmd, "cnames");
bson_append_string(&cmd, "0", "col1");
bson_append_string(&cmd, "1", "col2");
bson_append_finish_array(&cmd);
bson_append_finish_object(&cmd);
bson_finish(&cmd);
bret = ejdbcommand(jb, &cmd);
CU_ASSERT_PTR_NOT_NULL_FATAL(bret);
bson_destroy(&cmd);
bson_iterator_init(&it, bret);
CU_ASSERT_TRUE_FATAL(bson_find_fieldpath_value("log", &it) == BSON_STRING);
log = bson_iterator_string(&it);
CU_ASSERT_PTR_NOT_NULL(strstr(log, "Replacing all data in 'col1'"));
CU_ASSERT_PTR_NOT_NULL(strstr(log, "1 objects imported into 'col1'"));
CU_ASSERT_PTR_NOT_NULL(strstr(log, "2 objects imported into 'col2'"));
bson_del(bret);
log = NULL;
bson *nmeta = ejdbmeta(jb);
CU_ASSERT_TRUE_FATAL(nmeta != NULL);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.0.name", strlen("collections.0.name")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.0.records", strlen("collections.0.records")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.name", strlen("collections.1.name")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.records", strlen("collections.1.records")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.options.buckets", strlen("collections.1.options.buckets")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.options.large", strlen("collections.1.options.large")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.0.field", strlen("collections.1.indexes.0.field")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.0.type", strlen("collections.1.indexes.0.type")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.0.records", strlen("collections.1.indexes.0.records")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.1.field", strlen("collections.1.indexes.1.field")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.1.type", strlen("collections.1.indexes.1.type")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.1.records", strlen("collections.1.indexes.1.records")) == 0);
ejdbclose(jb);
ejdbdel(jb);
jb = ejdbnew();
CU_ASSERT_TRUE_FATAL(ejdbopen(jb, "dbt4_export", JBOWRITER | JBOCREAT | JBOTRUNC));
coll = ejdbcreatecoll(jb, "col1", NULL);
CU_ASSERT_PTR_NOT_NULL_FATAL(coll);
bson_init(&bv1);
bson_append_int(&bv1, "e", 2);
bson_finish(&bv1);
CU_ASSERT_TRUE(ejdbsavebson(coll, &bv1, &oid));
EJQ *q = ejdbcreatequery(jb, &bv1, NULL, 0, NULL);
CU_ASSERT_PTR_NOT_NULL_FATAL(q);
uint32_t count = 0;
ejdbqryexecute(coll, q, &count, JBQRYCOUNT, NULL);
CU_ASSERT_EQUAL(count, 1);
bson_init(&cmd);
bson_append_start_object(&cmd, "import");
bson_append_string(&cmd, "path", "testBSONExportImport2");
bson_append_int(&cmd, "mode", JBIMPORTUPDATE);
bson_append_finish_object(&cmd);
bson_finish(&cmd);
bret = ejdbcommand(jb, &cmd);
CU_ASSERT_PTR_NOT_NULL_FATAL(bret);
bson_destroy(&cmd);
bson_del(bret);
coll = ejdbcreatecoll(jb, "col1", NULL);
ejdbqryexecute(coll, q, &count, JBQRYCOUNT, NULL);
CU_ASSERT_EQUAL(count, 1);
ejdbquerydel(q);
bson_destroy(&bv1);
ejdbclose(jb);
ejdbdel(jb);
bson_del(ometa);
bson_del(nmeta);
}
void testPerf1() {
CU_ASSERT_PTR_NOT_NULL_FATAL(jb);
CU_ASSERT_PTR_NOT_NULL_FATAL(recs);
EJCOLL *coll = ejdbcreatecoll(jb, "pcoll1", NULL);
CU_ASSERT_PTR_NOT_NULL_FATAL(coll);
unsigned long st = tcmstime();
for (int i = 0; i < RS; ++i) {
bson_oid_t oid;
ejdbsavebson(coll, recs + i, &oid);
}
ejdbsyncoll(coll);
fprintf(stderr, "\ntestPerf1(): SAVED %d BSON OBJECTS, TIME %lu ms\n", RS, tcmstime() - st);
st = tcmstime();
uint32_t acount = 0;
int i;
for (i = 0; i < QRS; ++i) {
int idx = rand() % QRS;
bson *bs = recs + idx;
assert(bs);
EJQ *q = ejdbcreatequery(jb, bs, NULL, 0, NULL);
assert(q);
uint32_t count;
ejdbqryexecute(coll, q, &count, JBQRYCOUNT, NULL);
assert(count);
if (count != 1) {
fprintf(stderr, "CNT=%u\n", count);
}
acount += count;
ejdbquerydel(q);
}
CU_ASSERT_TRUE(i <= acount);
fprintf(stderr, "testPerf1(): %u QUERIES, TIME: %lu ms, PER QUERY TIME: %lu ms\n",
i, tcmstime() - st, (unsigned long) ((tcmstime() - st) / QRS));
st = tcmstime();
CU_ASSERT_TRUE(ejdbsetindex(coll, "rstring", JBIDXSTR));
fprintf(stderr, "testPerf1(): SET INDEX 'rstring' TIME: %lu ms\n", tcmstime() - st);
st = tcmstime();
acount = 0;
for (i = 0; i < QRS; ++i) {
int idx = rand() % QRS;
bson *bs = recs + idx;
assert(bs);
EJQ *q = ejdbcreatequery(jb, bs, NULL, 0, NULL);
assert(q);
uint32_t count;
ejdbqryexecute(coll, q, &count, JBQRYCOUNT, NULL);
assert(count);
acount += count;
ejdbquerydel(q);
}
CU_ASSERT_TRUE(i <= acount);
fprintf(stderr, "testPerf1(): %u QUERIES WITH 'rstring' INDEX, TIME: %lu ms, PER QUERY TIME: %lu ms\n",
i, tcmstime() - st, (unsigned long) ((tcmstime() - st) / QRS));
bson bsq1;
bson_init_as_query(&bsq1);
bson_append_start_object(&bsq1, "$set");
bson_append_int(&bsq1, "intv", 1);
bson_append_finish_object(&bsq1);
bson_finish(&bsq1);
EJQ *q = ejdbcreatequery(jb, &bsq1, NULL, JBQRYCOUNT, NULL);
CU_ASSERT_PTR_NOT_NULL_FATAL(q);
uint32_t count;
st = tcmstime(); //$set op
ejdbqryexecute(coll, q, &count, JBQRYCOUNT, NULL);
if (ejdbecode(jb) != 0) {
eprint(jb, __LINE__, "$set test");
CU_ASSERT_TRUE(false);
}
CU_ASSERT_EQUAL(count, RS);
fprintf(stderr, "testPerf1(): {'$set' : {'intv' : 1}} FOR %u OBJECTS, TIME %lu ms\n", count, tcmstime() - st);
ejdbquerydel(q);
bson_destroy(&bsq1);
bson_init_as_query(&bsq1);
bson_append_start_object(&bsq1, "$inc");
bson_append_int(&bsq1, "intv", 1);
bson_append_finish_object(&bsq1);
bson_finish(&bsq1);
q = ejdbcreatequery(jb, &bsq1, NULL, JBQRYCOUNT, NULL);
CU_ASSERT_PTR_NOT_NULL_FATAL(q);
st = tcmstime(); //$inc op
ejdbqryexecute(coll, q, &count, JBQRYCOUNT, NULL);
if (ejdbecode(jb) != 0) {
eprint(jb, __LINE__, "$inc test");
CU_ASSERT_TRUE(false);
}
CU_ASSERT_EQUAL(count, RS);
fprintf(stderr, "testPerf1(): {'$inc' : {'intv' : 1}} FOR %u OBJECTS, TIME %lu ms\n", count, tcmstime() - st);
ejdbquerydel(q);
bson_destroy(&bsq1);
bson_init_as_query(&bsq1);
bson_append_int(&bsq1, "intv", 2);
bson_finish(&bsq1);
q = ejdbcreatequery(jb, &bsq1, NULL, JBQRYCOUNT, NULL);
ejdbqryexecute(coll, q, &count, JBQRYCOUNT, NULL);
CU_ASSERT_EQUAL(count, RS);
ejdbquerydel(q);
bson_destroy(&bsq1);
ejdbrmcoll(jb, coll->cname, true);
}
int main() {
bson b, sub, out;
bson_iterator it;
mongo conn;
mongo_cursor cursor;
int result;
/* Create a rich document like this one:
*
* { _id: ObjectId("4d95ea712b752328eb2fc2cc"),
* user_id: ObjectId("4d95ea712b752328eb2fc2cd"),
*
* items: [
* { sku: "col-123",
* name: "John Coltrane: Impressions",
* price: 1099,
* },
*
* { sku: "young-456",
* name: "Larry Young: Unity",
* price: 1199
* }
* ],
*
* address: {
* street: "59 18th St.",
* zip: 10010
* },
*
* total: 2298
* }
*/
bson_init( &b );
bson_append_new_oid( &b, "_id" );
bson_append_new_oid( &b, "user_id" );
bson_append_start_array( &b, "items" );
bson_append_start_object( &b, "0" );
bson_append_string( &b, "name", "John Coltrane: Impressions" );
bson_append_int( &b, "price", 1099 );
bson_append_finish_object( &b );
bson_append_start_object( &b, "1" );
bson_append_string( &b, "name", "Larry Young: Unity" );
bson_append_int( &b, "price", 1199 );
bson_append_finish_object( &b );
bson_append_finish_object( &b );
bson_append_start_object( &b, "address" );
bson_append_string( &b, "street", "59 18th St." );
bson_append_int( &b, "zip", 10010 );
bson_append_finish_object( &b );
bson_append_int( &b, "total", 2298 );
/* Finish the BSON obj. */
bson_finish( &b );
printf("Here's the whole BSON object:\n");
bson_print( &b );
/* Advance to the 'items' array */
bson_find( &it, &b, "items" );
/* Get the subobject representing items */
bson_iterator_subobject_init( &it, &sub, 0 );
/* Now iterate that object */
printf("And here's the inner sub-object by itself.\n");
bson_print( &sub );
bson_destroy( &sub );
/* Now make a connection to MongoDB. */
if( mongo_client( &conn, "127.0.0.1", 27017 ) != MONGO_OK ) {
switch( conn.err ) {
case MONGO_CONN_SUCCESS:
break;
case MONGO_CONN_NO_SOCKET:
printf( "FAIL: Could not create a socket!\n" );
break;
case MONGO_CONN_FAIL:
printf( "FAIL: Could not connect to mongod. Make sure it's listening at 127.0.0.1:27017.\n" );
break;
default:
printf( "MongoDB connection error number %d.\n", conn.err );
break;
}
exit( 1 );
}
/* Insert the sample BSON document. */
if( mongo_insert( &conn, "test.records", &b, NULL ) != MONGO_OK ) {
printf( "FAIL: Failed to insert document with error %d\n", conn.err );
exit( 1 );
}
/* Query for the sample document. */
mongo_cursor_init( &cursor, &conn, "test.records" );
mongo_cursor_set_query( &cursor, bson_shared_empty() );
if( mongo_cursor_next( &cursor ) != MONGO_OK ) {
printf( "FAIL: Failed to find inserted document." );
exit( 1 );
}
printf( "Found saved BSON object:\n" );
bson_print( (bson *)mongo_cursor_bson( &cursor ) );
mongo_cmd_drop_collection( &conn, "test", "records", NULL );
mongo_cursor_destroy( &cursor );
bson_destroy( &b );
mongo_destroy( &conn );
return 0;
}
void log_explain(uint32_t index)
{
bson b;
char argidx[4];
bson_init_size(&b, mem_suggested_size(1024));
bson_append_int(&b, "I", index);
bson_append_string(&b, "name", sig_apiname(index));
bson_append_string(&b, "type", "info");
bson_append_string(&b, "category", sig_category(index));
bson_append_start_array(&b, "args");
bson_append_string(&b, "0", "is_success");
bson_append_string(&b, "1", "retval");
const char *fmt = sig_paramtypes(index);
for (uint32_t argnum = 2; *fmt != 0; argnum++, fmt++) {
ultostr(argnum, argidx, 10);
// Ignore buffers, they are sent over separately.
if(*fmt == '!') {
argnum--;
fmt++;
continue;
}
const char *argname = sig_param_name(index, argnum-2);
// On certain formats, we need to tell cuckoo about them for
// nicer display / matching.
if(*fmt == 'p' || *fmt == 'P') {
bson_append_start_array(&b, argidx);
bson_append_string(&b, "0", argname);
bson_append_string(&b, "1", "p");
bson_append_finish_array(&b);
}
else {
bson_append_string(&b, argidx, argname);
}
}
bson_append_finish_array(&b);
bson_append_start_object(&b, "flags_value");
for (uint32_t idx = 0; sig_flag_name(index, idx) != NULL; idx++) {
const flag_repr_t *f = flag_value(sig_flag_value(index, idx));
bson_append_start_array(&b, sig_flag_name(index, idx));
for (uint32_t idx2 = 0; f->repr != NULL; idx2++, f++) {
ultostr(idx, argidx, 10);
bson_append_start_array(&b, argidx);
bson_append_int(&b, "0", f->value);
bson_append_string(&b, "1", f->repr);
bson_append_finish_array(&b);
}
bson_append_finish_array(&b);
}
bson_append_finish_object(&b);
bson_append_start_object(&b, "flags_bitmask");
for (uint32_t idx = 0; sig_flag_name(index, idx) != NULL; idx++) {
const flag_repr_t *f = flag_bitmask(sig_flag_value(index, idx));
bson_append_start_array(&b, sig_flag_name(index, idx));
for (uint32_t idx2 = 0; f->repr != NULL; idx2++, f++) {
ultostr(idx, argidx, 10);
bson_append_start_array(&b, argidx);
bson_append_int(&b, "0", f->value);
bson_append_string(&b, "1", f->repr);
bson_append_finish_array(&b);
}
bson_append_finish_array(&b);
}
bson_append_finish_object(&b);
bson_finish(&b);
log_raw(bson_data(&b), bson_size(&b));
bson_destroy(&b);
}
