int inode_exists(const char * path) {
bson query, fields;
mongo * conn = get_conn();
mongo_cursor curs;
int res;
bson_init(&query);
bson_append_string(&query, "dirents", path);
bson_finish(&query);
bson_init(&fields);
bson_append_int(&fields, "dirents", 1);
bson_append_int(&fields, "_id", 0);
bson_finish(&fields);
mongo_cursor_init(&curs, conn, inodes_name);
mongo_cursor_set_query(&curs, &query);
mongo_cursor_set_fields(&curs, &fields);
mongo_cursor_set_limit(&curs, 1);
res = mongo_cursor_next(&curs);
bson_destroy(&query);
bson_destroy(&fields);
mongo_cursor_destroy(&curs);
if(res == 0)
return 0;
if(curs.err != MONGO_CURSOR_EXHAUSTED)
return -EIO;
return -ENOENT;
}
MongoCursor::MongoCursor(MongoDB *db, const std::string &ns,
const std::string &name, v8::Local<v8::Object> query,
v8::Local<v8::Object> projection)
{
m_state = CUR_NONE;
m_ns = ns;
m_name = name;
m_cursor = new cursor;
m_cursor->m_db = db;
mongo_cursor_init(m_cursor, &db->m_conn, ns.c_str());
v8::Local<v8::Value> _query;
util_base::clone(query, _query);
m_query.Reset(Isolate::now()->m_isolate, v8::Local<v8::Object>::Cast(_query)->Clone());
mongo_cursor_set_query(m_cursor, &m_bbq);
encodeObject(&m_bbp, projection);
mongo_cursor_set_fields(m_cursor, &m_bbp);
m_bInit = false;
m_bSpecial = false;
}
result_t MongoCursor::_initCursor(MongoDB *db, AsyncEvent *ac)
{
if (!ac)
return CHECK_ERROR(CALL_E_NOSYNC);
m_cursor = new cursor;
m_cursor->m_db = db;
mongo_cursor_init(m_cursor, &(m_cursor->m_db)->m_conn, m_ns.c_str());
mongo_cursor_set_query(m_cursor, &m_bbq);
mongo_cursor_set_fields(m_cursor, &m_bbp);
return 0;
}
/*
*----------------------------------------------------------------------
*
* mongotcl_tcllist_to_cursor_fields --
*
* Takes a Tcl list that should contain pairs of field names and
* 0/1 values and a mongotcl cursor clientdata structure.
*
* If successful, sets a bson object in the cursor client data to
* contain the equivalent, appropriate bson for passing to
* mongo_cursor_set_fields
*
* If unsuccessful, returns TCL_ERROR and sets the bson pointer
* to NULL.
*
* Results:
* A standard Tcl result.
*
*
*----------------------------------------------------------------------
*/
int
mongotcl_tcllist_to_cursor_fields (Tcl_Interp *interp, Tcl_Obj *fieldList, mongotcl_cursorClientData *mc) {
Tcl_Obj **listObjv;
int listObjc;
int i;
if (Tcl_ListObjGetElements (interp, fieldList, &listObjc, &listObjv) == TCL_ERROR) {
Tcl_AddErrorInfo (interp, "while reading field list");
return TCL_ERROR;
}
if (listObjc & 1) {
Tcl_SetObjResult (interp, Tcl_NewStringObj ("field list must have even number of elements", -1));
return TCL_ERROR;
}
if (mc->fieldsBson == NULL) {
mc->fieldsBson = (bson *)ckalloc(sizeof(bson));
}
bson_init(mc->fieldsBson);
for (i = 0; i < listObjc; i += 2) {
int want;
char *key = Tcl_GetString (listObjv[i]);
if (Tcl_GetIntFromObj (interp, listObjv[i+1], &want) == TCL_ERROR) {
bson_error:
return mongotcl_setBsonError (interp, mc->fieldsBson);
}
if (bson_append_int (mc->fieldsBson, key, want) != BSON_OK) {
goto bson_error;
}
}
if (bson_finish (mc->fieldsBson) != BSON_OK) {
goto bson_error;
}
mongo_cursor_set_fields (mc->cursor, mc->fieldsBson);
return TCL_OK;
}
MONGO_EXPORT mongo_cursor *mongo_find( mongo *conn, const char *ns, const bson *query,
const bson *fields, int limit, int skip, int options ) {
mongo_cursor *cursor = ( mongo_cursor * )bson_malloc( sizeof( mongo_cursor ) );
mongo_cursor_init( cursor, conn, ns );
cursor->flags |= MONGO_CURSOR_MUST_FREE;
mongo_cursor_set_query( cursor, query );
mongo_cursor_set_fields( cursor, fields );
mongo_cursor_set_limit( cursor, limit );
mongo_cursor_set_skip( cursor, skip );
mongo_cursor_set_options( cursor, options );
if( mongo_cursor_op_query( cursor ) == MONGO_OK )
return cursor;
else {
mongo_cursor_destroy( cursor );
return NULL;
}
}
MONGO_EXPORT int mongo_find_one( mongo *conn, const char *ns, const bson *query,
const bson *fields, bson *out ) {
mongo_cursor cursor[1];
mongo_cursor_init( cursor, conn, ns );
mongo_cursor_set_query( cursor, query );
mongo_cursor_set_fields( cursor, fields );
mongo_cursor_set_limit( cursor, 1 );
if ( mongo_cursor_next( cursor ) == MONGO_OK ) {
bson_init_size( out, bson_size( (bson *)&cursor->current ) );
memcpy( out->data, cursor->current.data,
bson_size( (bson *)&cursor->current ) );
out->finished = 1;
mongo_cursor_destroy( cursor );
return MONGO_OK;
} else {
mongo_cursor_destroy( cursor );
return MONGO_ERROR;
}
}
static void
mongo_cursor_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MongoCursor *cursor = MONGO_CURSOR(object);
switch (prop_id) {
case PROP_BATCH_SIZE:
mongo_cursor_set_batch_size(cursor, g_value_get_uint(value));
break;
case PROP_CONNECTION:
mongo_cursor_set_connection(cursor, g_value_get_object(value));
break;
case PROP_COLLECTION:
mongo_cursor_set_collection(cursor, g_value_get_string(value));
break;
case PROP_DATABASE:
mongo_cursor_set_database(cursor, g_value_get_string(value));
break;
case PROP_FIELDS:
mongo_cursor_set_fields(cursor, g_value_get_boxed(value));
break;
case PROP_FLAGS:
mongo_cursor_set_flags(cursor, g_value_get_uint(value));
break;
case PROP_LIMIT:
mongo_cursor_set_limit(cursor, g_value_get_uint(value));
break;
case PROP_QUERY:
mongo_cursor_set_query(cursor, g_value_get_boxed(value));
break;
case PROP_SKIP:
mongo_cursor_set_skip(cursor, g_value_get_uint(value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
}
}
