v8::Handle<v8::Value> find(const v8::Arguments& args) {
if (args.Length() < 2) {
return v8::ThrowException(v8::String::New("usage: db.find(db, namespace)\ndb.find(db, namespace, filter)\ndb.find(db, namespace, select, filter)"));
}
if (__djonConnection == NULL) {
return v8::ThrowException(v8::String::New("You're not connected to any db, please use: connect(server, [port])"));
}
v8::HandleScope handle_scope;
v8::String::Utf8Value strDB(args[0]);
std::string db = ToCString(strDB);
v8::String::Utf8Value str(args[1]);
std::string ns = ToCString(str);
std::string select = "*";
std::string filter = "";
if (args.Length() == 3) {
v8::String::Utf8Value strFilter(args[2]);
filter = ToCString(strFilter);
}
if (args.Length() == 4) {
v8::String::Utf8Value strSelect(args[2]);
select = ToCString(strSelect);
v8::String::Utf8Value strFilter(args[3]);
filter = ToCString(strFilter);
}
/*
std::string json;
if (args[2]->IsObject()) {
json = toJson(args[2]->ToObject());
} else {
json = ToCString(v8::String::Utf8Value(args[2]));
}
*/
try {
BSONArrayObj* result = __djonConnection->find(db, ns, select, filter);
char* str = result->toChar();
v8::Handle<v8::Value> jsonValue = parseJSON(v8::String::New(str));
free(str);
delete result;
return jsonValue;
} catch (ParseException e) {
return v8::ThrowException(v8::String::New("the filter expression contains an error\n"));
}
/*
v8::Handle<v8::Context> context = v8::Context::GetCurrent();
v8::Handle<v8::Object> global = context->Global();
v8::Handle<v8::Object> objresult = global->Get(v8::String::New(sresult.c_str()))->ToObject();
return objresult;
//return v8::String::New(sresult.c_str());
*/
}
char* BSONObj::toChar() {
// if the toChar was already calculated before use it
if (_cBSON != NULL) {
return strcpy(_cBSON);
}
Logger* log = getLogger(NULL);
char* result = (char*)malloc(MAX_BSONOBJ_BUFFER);
memset(result, 0, MAX_BSONOBJ_BUFFER);
__int32 pos = 0;
result[0] = '{';
pos += 1;
bool first = true;
for (std::map<std::string, BSONContent* >::const_iterator i = _elements.begin(); i != _elements.end(); i++) {
if (!first) {
result[pos] = ',';
pos++;
}
first = false;
BSONContent* content = i->second;
std::string key = i->first;
sprintf(result + pos, " \"%s\" : ", key.c_str());
pos += key.length() + 6;
//ss << "\"" << key << "\" :";
char* chr;
const char* cstr;
switch (content->type()) {
case BSON_TYPE: {
BSONContentBSON* bbson = (BSONContentBSON*)content;
BSONObj* bson = (BSONObj*)*bbson;
char* chrbson = bson->toChar();
sprintf(result + pos, "%s", chrbson);
free(chrbson);
break;
}
case BSONARRAY_TYPE: {
BSONContentBSONArray* bbsonarray = (BSONContentBSONArray*)content;
BSONArrayObj* bsonarray = (BSONArrayObj*)*bbsonarray;
char* chrbsonarray = bsonarray->toChar();
sprintf(result + pos, "%s", chrbsonarray);
free(chrbsonarray);
break;
}
case BOOL_TYPE: {
BSONContentBoolean* bb = (BSONContentBoolean*)content;
sprintf(result + pos, "%s", ((bool)*bb?"true": "false"));
break;
}
case INT_TYPE: {
BSONContentInt* bint = (BSONContentInt*)content;
sprintf(result + pos, "%d", (__int32)*bint);
break;
}
case LONG_TYPE: {
BSONContentLong* blong = (BSONContentLong*)content;
sprintf(result + pos, "%ld", (__int64)*blong);
break;
}
case DOUBLE_TYPE: {
BSONContentDouble* bdouble = (BSONContentDouble*)content;
sprintf(result + pos, "%f", (double)*bdouble);
break;
}
case STRING_TYPE:
case PTRCHAR_TYPE: {
BSONContentString* bstring = (BSONContentString*)content;
djondb::string s = *bstring;
sprintf(result + pos, "\"%.*s\"", s.length(), s.c_str());
break;
}
}
pos = strlen(result);
assert(pos < MAX_BSONOBJ_BUFFER);
}
result[pos] = '}';
result[pos+1] = 0;
pos++;
__int32 len = strlen(result);
// Saves the value to cache the calculated value
_cBSON = result;
char* cresult = strcpy(result);
if (log->isDebug()) log->debug("toChar result: %s", cresult);
return cresult;
}
