static void
assert_bson_equal (const bson_t *a,
const bson_t *b)
{
const bson_uint8_t *data1 = bson_get_data(a);
const bson_uint8_t *data2 = bson_get_data(b);
bson_uint32_t i;
if (!bson_equal(a, b)) {
for (i = 0; i < MAX(a->len, b->len); i++) {
if (i >= a->len) {
printf("a is too short len=%u\n", a->len);
abort();
} else if (i >= b->len) {
printf("b is too short len=%u\n", b->len);
abort();
}
if (data1[i] != data2[i]) {
printf("a[%u](0x%02x,%u) != b[%u](0x%02x,%u)\n",
i, data1[i], data1[i], i, data2[i], data2[i]);
abort();
}
}
}
}
void
_mongoc_write_command_insert_append (mongoc_write_command_t *command,
const bson_t *document)
{
bson_iter_t iter;
bson_oid_t oid;
bson_t tmp;
ENTRY;
BSON_ASSERT (command);
BSON_ASSERT (command->type == MONGOC_WRITE_COMMAND_INSERT);
BSON_ASSERT (document);
BSON_ASSERT (document->len >= 5);
/*
* If the document does not contain an "_id" field, we need to generate
* a new oid for "_id".
*/
if (!bson_iter_init_find (&iter, document, "_id")) {
bson_init (&tmp);
bson_oid_init (&oid, NULL);
BSON_APPEND_OID (&tmp, "_id", &oid);
bson_concat (&tmp, document);
_mongoc_buffer_append (&command->payload, bson_get_data (&tmp), tmp.len);
bson_destroy (&tmp);
} else {
_mongoc_buffer_append (
&command->payload, bson_get_data (document), document->len);
}
command->n_documents++;
EXIT;
}
int compare_json(const char *json,
const char *jsonspec ){
bson_error_t error;
bson_error_t error2;
bson_t *spec;
bson_t *doc;
doc = bson_new_from_json (json, -1, &error);
spec = bson_new_from_json (jsonspec, -1, &error2);
const uint8_t *spec_bson = bson_get_data(spec);
const uint8_t *doc_bson = bson_get_data(doc);
int yes = compare(spec_bson, spec->len, doc_bson, doc->len);
bson_free(spec);
bson_free(doc);
return yes;
}
/* check a missing mandatory fix */
static gboolean
sim_parser_connect_test2 (void)
{
bson_t *bson_connect = bson_new ();
bson_t child;
SimParser *parser = NULL;
SimCommand *cmd = NULL;
gboolean result = FALSE;
bson_append_document_begin (bson_connect,"connect", -1, &child);
BSON_APPEND_INT32 (&child, "id", 10);
BSON_APPEND_INT32 (&child, "type", SIM_SESSION_TYPE_WEB);
BSON_APPEND_UTF8 (&child, "version", "5.0.1");
bson_append_document_end (bson_connect, &child);
do{
if ((parser = sim_parser_new()) == NULL)
{
result = FALSE;
break;
}
if ((cmd = sim_parser_bson (parser, bson_get_data (bson_connect), bson_connect->len)) != NULL)
{
result = FALSE;
break;
}
result = TRUE;
} while (0);
return result;
}
Array HHVM_METHOD(MongoDBDriverReadPreference, __debugInfo)
{
MongoDBDriverReadPreferenceData* data = Native::data<MongoDBDriverReadPreferenceData>(this_);
Array retval = Array::Create();
Variant v_tags;
const bson_t *tags = mongoc_read_prefs_get_tags(data->m_read_preference);
mongoc_read_mode_t mode = mongoc_read_prefs_get_mode(data->m_read_preference);
switch (mode) {
case MONGOC_READ_PRIMARY: retval.set(s_mode, "primary"); break;
case MONGOC_READ_PRIMARY_PREFERRED: retval.set(s_mode, "primaryPreferred"); break;
case MONGOC_READ_SECONDARY: retval.set(s_mode, "secondary"); break;
case MONGOC_READ_SECONDARY_PREFERRED: retval.set(s_mode, "secondaryPreferred"); break;
case MONGOC_READ_NEAREST: retval.set(s_mode, "nearest"); break;
default: /* Do nothing */
break;
}
if (!bson_empty(tags)) {
hippo_bson_conversion_options_t options = HIPPO_TYPEMAP_INITIALIZER;
BsonToVariantConverter convertor(bson_get_data(tags), tags->len, options);
convertor.convert(&v_tags);
retval.set(s_tags, v_tags.toArray());
}
if (mongoc_read_prefs_get_max_staleness_ms(data->m_read_preference) != 0) {
retval.set(s_maxStalenessMS, mongoc_read_prefs_get_max_staleness_ms(data->m_read_preference));
}
return retval;
}
bsoncxx::array::view core::view_array() const {
if (!_impl->is_viewable()) {
throw bsoncxx::exception{error_code::k_unmatched_key_in_builder};
}
return bsoncxx::array::view(bson_get_data(_impl->root()), _impl->root()->len);
}
void
_mongoc_write_command_delete_append (mongoc_write_command_t *command,
const bson_t *selector,
const bson_t *opts)
{
bson_t document;
ENTRY;
BSON_ASSERT (command);
BSON_ASSERT (command->type == MONGOC_WRITE_COMMAND_DELETE);
BSON_ASSERT (selector);
BSON_ASSERT (selector->len >= 5);
bson_init (&document);
BSON_APPEND_DOCUMENT (&document, "q", selector);
if (opts) {
bson_concat (&document, opts);
}
_mongoc_buffer_append (
&command->payload, bson_get_data (&document), document.len);
command->n_documents++;
bson_destroy (&document);
EXIT;
}
bool run_test(uint32_t* hash_out) {
bson_t bson = BSON_INITIALIZER;
bool ok;
if (root_object->type == type_map)
ok = append_document(&bson, root_object);
else
ok = append_array(&bson, root_object);
if (!ok) {
fprintf(stderr, "libbson error writing data!\n");
bson_destroy(&bson);
return false;
}
*hash_out = hash_str(*hash_out, (const char*)bson_get_data(&bson), bson.len);
// The documentation says that bson_destroy() should be called
// regardless of whether the bson_t was initialized via bson_init()
// bson_new() or BSON_INITIALIZER. This is because it stores a flag
// to say whether it should be freed when destroyed.
// This causes a warning under -flto about freeing a stack object
// even though the bson_t is set for static.
bson_destroy(&bson);
return true;
}
/* Check a correct CONNECT message */
static gboolean
sim_parser_connect_test1 (void)
{
bson_t *bson_connect = bson_new ();
bson_t child;
uint8_t uuid[]={0x07,0x92,0xd6,0x72,0xf4,0xce,0x11,0xe4,0x9d,0xe2,0x00,0x0c,0x29,0xd9,0x46,0xde};
SimParser *parser = NULL;
SimCommand *cmd = NULL;
gboolean result = FALSE;
bson_append_document_begin (bson_connect,"connect", -1, &child);
BSON_APPEND_INT32 (&child, "id", 10);
BSON_APPEND_INT32 (&child, "type", SIM_SESSION_TYPE_WEB);
BSON_APPEND_UTF8 (&child, "version", "5.0.1");
if (bson_append_binary (&child, "sensor_id", -1, BSON_SUBTYPE_UUID, uuid, 16) == FALSE)
return FALSE;
bson_append_document_end (bson_connect, &child);
/* Check */
bson_iter_t iter;
bson_iter_init (&iter, bson_connect);
do{
if ((parser = sim_parser_new()) == NULL)
{
result = FALSE;
break;
}
if ((cmd = sim_parser_bson (parser, bson_get_data (bson_connect), bson_connect->len)) == NULL)
{
result = FALSE;
break;
}
if (cmd->type != SIM_COMMAND_TYPE_CONNECT)
{
result = FALSE;
break;
}
if (cmd->data.connect.sensor_ver->major != 5 || cmd->data.connect.sensor_ver->minor != 0 || cmd->data.connect.sensor_ver->micro != 1)
{
result = FALSE;
break;
}
if (cmd->data.connect.sensor_id == NULL)
{
result = FALSE;
break;
}
/* Check uuid */
SimUuid * uuidbin = sim_uuid_new_from_bin (uuid);
gboolean test = sim_uuid_equal (uuidbin, cmd->data.connect.sensor_id);
g_object_unref (uuidbin);
if (!test)
{
result = FALSE;
break;
}
result = TRUE;
} while (0);
bson_destroy (bson_connect);
g_object_unref (parser);
return result;
}
static gboolean
sim_parser_connect_test3 (void)
{
bson_t *bson_connect = bson_new ();
bson_t child;
SimParser *parser = NULL;
SimCommand *cmd = NULL;
gboolean result = FALSE;
uint8_t uuid[]={0x07,0x92,0xd6,0x72,0xf4,0xce,0x11,0xe4,0x9d,0xe2,0x00,0x0c,0x29,0xd9,0x46,0xde};
bson_append_document_begin (bson_connect,"connect", -1, &child);
BSON_APPEND_INT32 (&child, "id", 10);
BSON_APPEND_INT32 (&child, "type", SIM_SESSION_TYPE_WEB);
BSON_APPEND_UTF8 (&child, "version", "x.x.x");
if (bson_append_binary (&child, "sensor_id", -1, BSON_SUBTYPE_UUID, uuid, 16) == FALSE)
return FALSE;
bson_append_document_end (bson_connect, &child);
do{
if ((parser = sim_parser_new()) == NULL)
{
result = FALSE;
break;
}
if ((cmd = sim_parser_bson (parser, bson_get_data (bson_connect), bson_connect->len)) != NULL)
{
result = FALSE;
break;
}
result = TRUE;
} while (0);
return result;
}
SEXP R_mongo_cursor_next_bsonlist (SEXP ptr, SEXP n){
mongoc_cursor_t *c = r2cursor(ptr);
int len = asInteger(n);
SEXP out = PROTECT(allocVector(VECSXP, len));
const bson_t *b = NULL;
int total = 0;
bson_error_t err;
while(total < len){
if(!mongoc_cursor_next(c, &b)){
if(mongoc_cursor_error (c, &err))
stop(err.message);
else
break; //cursor exchausted: done
} else {
SEXP bin = PROTECT(allocVector(RAWSXP, b->len));
memcpy(RAW(bin), bson_get_data(b), b->len);
SET_VECTOR_ELT(out, total, bin);
UNPROTECT(1);
total++;
}
}
if(total < len){
SEXP out2 = PROTECT(allocVector(VECSXP, total));
for(int i = 0; i < total; i++){
SET_VECTOR_ELT(out2, i, VECTOR_ELT(out, i));
}
UNPROTECT(2);
return out2;
}
UNPROTECT(1);
return out;
}
static bool mongodb_driver_add_server_debug(mongoc_server_description_t *sd, Array *retval)
{
mongoc_host_list_t *host = mongoc_server_description_host(sd);
const bson_t *is_master = mongoc_server_description_ismaster(sd);
Variant v_last_is_master;
Array a_last_is_master;
retval->set(s_MongoDriverServer_host, host->host);
retval->set(s_MongoDriverServer_port, host->port);
retval->set(s_MongoDriverServer_type, hippo_server_description_type(sd));
retval->set(s_MongoDriverServer_is_primary, strcmp(mongoc_server_description_type(sd), hippo_server_description_type_map[HIPPO_SERVER_RS_PRIMARY].name) == 0);
retval->set(s_MongoDriverServer_is_secondary, strcmp(mongoc_server_description_type(sd), hippo_server_description_type_map[HIPPO_SERVER_RS_SECONDARY].name) == 0);
retval->set(s_MongoDriverServer_is_arbiter, strcmp(mongoc_server_description_type(sd), hippo_server_description_type_map[HIPPO_SERVER_RS_ARBITER].name) == 0);
hippo_bson_conversion_options_t options = HIPPO_TYPEMAP_DEBUG_INITIALIZER;
BsonToVariantConverter convertor(bson_get_data(is_master), is_master->len, options);
convertor.convert(&v_last_is_master);
a_last_is_master = v_last_is_master.toArray();
retval->set(s_MongoDriverServer_is_hidden, a_last_is_master.exists(s_MongoDriverServer_hidden) && !!a_last_is_master[s_MongoDriverServer_hidden].toBoolean());
retval->set(s_MongoDriverServer_is_passive, a_last_is_master.exists(s_MongoDriverServer_passive) && !!a_last_is_master[s_MongoDriverServer_passive].toBoolean());
if (a_last_is_master.exists(s_MongoDriverServer_tags)) {
retval->set(s_MongoDriverServer_tags, a_last_is_master[s_MongoDriverServer_tags]);
}
retval->set(s_MongoDriverServer_last_is_master, a_last_is_master);
retval->set(s_MongoDriverServer_round_trip_time, mongoc_server_description_round_trip_time(sd));
return true;
}
Array HHVM_METHOD(MongoDBDriverServer, getInfo)
{
MongoDBDriverServerData* data = Native::data<MongoDBDriverServerData>(this_);
mongoc_server_description_t *sd;
if ((sd = mongoc_client_get_server_description(data->m_client, data->m_server_id))) {
const bson_t *is_master = mongoc_server_description_ismaster(sd);
Variant v;
hippo_bson_conversion_options_t options = HIPPO_TYPEMAP_DEBUG_INITIALIZER;
/* Yeah, this is not pretty. But, C++ doesn't have finally, and I don't
* want to bson_copy the is_master thing just because of that */
try {
BsonToVariantConverter convertor(bson_get_data(is_master), is_master->len, options);
convertor.convert(&v);
} catch (...) {
mongoc_server_description_destroy(sd);
throw;
}
return v.toArray();
}
throw MongoDriver::Utils::CreateAndConstruct(MongoDriver::s_MongoDriverExceptionRuntimeException_className, "Failed to get server description", HPHP::Variant((uint64_t) 0));
}
int
main (int argc, char *argv[])
{
bson_json_reader_t *reader;
bson_error_t error;
const char *filename;
bson_t doc = BSON_INITIALIZER;
int i;
int b;
/*
* Print program usage if no arguments are provided.
*/
if (argc == 1) {
fprintf (stderr, "usage: %s FILE...\n", argv[0]);
return 1;
}
/*
* Process command line arguments expecting each to be a filename.
*/
for (i = 1; i < argc; i++) {
filename = argv[i];
/*
* Open the filename provided in command line arguments.
*/
if (0 == strcmp (filename, "-")) {
reader = bson_json_reader_new_from_fd (STDIN_FILENO, false);
} else {
if (!(reader = bson_json_reader_new_from_file (filename, &error))) {
fprintf (
stderr, "Failed to open \"%s\": %s\n", filename, error.message);
continue;
}
}
/*
* Convert each incoming document to BSON and print to stdout.
*/
while ((b = bson_json_reader_read (reader, &doc, &error))) {
if (b < 0) {
fprintf (stderr, "Error in json parsing:\n%s\n", error.message);
abort ();
}
if (fwrite (bson_get_data (&doc), 1, doc.len, stdout) != doc.len) {
fprintf (stderr, "Failed to write to stdout, exiting.\n");
exit (1);
}
bson_reinit (&doc);
}
bson_json_reader_destroy (reader);
bson_destroy (&doc);
}
return 0;
}
stdx::optional<bsoncxx::document::view> read_preference::tags() const {
const bson_t* bson_tags = libmongoc::read_prefs_get_tags(_impl->read_preference_t);
if (bson_count_keys(bson_tags))
return bsoncxx::document::view(bson_get_data(bson_tags), bson_tags->len);
return stdx::optional<bsoncxx::document::view>{};
}
int
main (int argc,
char *argv[])
{
bson_json_reader_t *reader;
bson_error_t error;
bson_t doc = BSON_INITIALIZER;
int b;
/*
* Print program usage if no arguments are provided.
*/
if (argc == 1) {
fprintf (stderr, "usage: %s JSONFILE\n", argv[0]);
return 1;
}
printf ("%d\r\n", strlen(argv[1]));
char *filename = malloc(strlen(argv[1]) + 1);
strcpy(filename, argv[1]);
filename[strlen(argv[1])+1] = 0;
if (0 == strcmp (filename, "-")) {
reader = bson_json_reader_new_from_fd (STDIN_FILENO, false);
} else {
if (!(reader = bson_json_reader_new_from_file (filename, &error))) {
fprintf (stderr, "Failed to open \"%s\": %s\n",
filename, error.message);
exit (1);
}
}
filename[strlen(filename)-4] = 'b'; // filename.json -> filename.bson
FILE* outp = fopen(filename, "wb");
/*
* Convert the document to BSON and save it as a binary
*/
while ((b = bson_json_reader_read (reader, &doc, &error))) {
if (b < 0) {
fprintf (stderr, "Error in json parsing:\n%s\n", error.message);
abort ();
}
if (fwrite (bson_get_data(&doc), 1, doc.len, outp) != doc.len) {
fprintf (stderr, "Failed to write to output file, exiting.\n");
exit (1);
}
}
fclose(outp);
bson_json_reader_destroy (reader);
bson_destroy (&doc);
return 0;
}
int compare_rgx_good(){
bson_error_t error;
bson_error_t error2;
bson_t *spec;
bson_t *doc;
const char *json = "{\"hello\": \"world\"}";
const char *jsonspec = "{\"hello\": {\"$options\": \"\", \"$regex\": \"orl\"}}";
doc = bson_new_from_json (json, -1, &error);
spec = bson_new_from_json (jsonspec, -1, &error2);
const uint8_t *spec_bson = bson_get_data(spec);
const uint8_t *doc_bson = bson_get_data(doc);
int yes = compare(spec_bson, spec->len, doc_bson, doc->len);
bson_free(spec);
bson_free(doc);
return yes;
}
//valgrind -v --leak-check=full <this>
bool
test_bson_api(const char *json,
const char *jsonspec)
{
bool same = false;
bson_error_t error;
bson_error_t error2;
bson_t *spec;
bson_t *doc;
doc = bson_new_from_json (json, -1, &error);
spec = bson_new_from_json (jsonspec, -1, &error2);
const uint8_t *spec_bson = bson_get_data(spec);
const uint8_t *doc_bson = bson_get_data(doc);
int yes = compare(spec_bson, spec->len, doc_bson, doc->len);
bson_destroy(doc);
bson_destroy(spec);
return yes;
}
int complex_search(){
bson_error_t error;
bson_error_t error2;
bson_t *spec;
bson_t *doc;
const char *json = "{\"a\": [{\"b\": [1, 2]}, {\"b\": [3, 5]}], \"c\": {\"d\": \"56b2cd28e138237eb96ff936\"}}";
const char *jsonspec = "{\"$and\": [{\"$or\": [{\"c.d\": \"56b2cd28e138237eb96ff936\"}]}, {\"$or\": [{\"a.0.b\": {\"$in\": [5, 30, 99]}}, {\"a.1.b\": {\"$in\": [5, 30, 99]}}]}]}";
doc = bson_new_from_json (json, -1, &error);
spec = bson_new_from_json (jsonspec, -1, &error2);
const uint8_t *spec_bson = bson_get_data(spec);
const uint8_t *doc_bson = bson_get_data(doc);
int yes = compare(spec_bson, spec->len, doc_bson, doc->len);
BSON_ASSERT(yes);
bson_free(spec);
bson_free(doc);
return yes;
}
int cbson_encode(lua_State *L)
{
bson_t bson = BSON_INITIALIZER;
luaL_checktype(L, 1, LUA_TTABLE);
iterate_table(L, 1, &bson, 1, 0, NULL);
const uint8_t* data=bson_get_data(&bson);
lua_pushlstring(L, (const char*)data, bson.len);
return 1;
}
bsoncxx::document::view scoped_bson_t::view() {
// if we were initialized with a view_or_value just use that view
if (_doc) {
return _doc->view();
}
// otherwise, if we were initialized from libmongoc, construct
if (_is_initialized) {
return bsoncxx::document::view{bson_get_data(bson()), bson()->len};
}
// otherwise, return an empty view
return bsoncxx::document::view{};
}
Array HHVM_METHOD(MongoDBDriverReadPreference, getTagSets)
{
MongoDBDriverReadPreferenceData* data = Native::data<MongoDBDriverReadPreferenceData>(this_);
Variant v_tags;
const bson_t *tags = mongoc_read_prefs_get_tags(data->m_read_preference);
hippo_bson_conversion_options_t options = HIPPO_TYPEMAP_DEBUG_INITIALIZER;
BsonToVariantConverter convertor(bson_get_data(tags), tags->len, options);
convertor.convert(&v_tags);
return v_tags.toArray();
}
/* TODO: merge with mock_server_reply? */
void
mock_server_reply_simple (mock_server_t *server,
mongoc_stream_t *client,
const mongoc_rpc_t *request,
mongoc_reply_flags_t flags,
const bson_t *doc,
int64_t cursor_id)
{
mongoc_iovec_t *iov;
mongoc_array_t ar;
mongoc_rpc_t r = {{ 0 }};
size_t expected = 0;
ssize_t n_written;
int iovcnt;
int i;
BSON_ASSERT (server);
BSON_ASSERT (request);
BSON_ASSERT (client);
BSON_ASSERT (doc);
_mongoc_array_init (&ar, sizeof (mongoc_iovec_t));
mongoc_mutex_lock (&server->mutex);
r.reply.request_id = ++server->last_response_id;
mongoc_mutex_unlock (&server->mutex);
r.reply.msg_len = 0;
r.reply.response_to = request->header.request_id;
r.reply.opcode = MONGOC_OPCODE_REPLY;
r.reply.flags = flags;
r.reply.cursor_id = cursor_id;
r.reply.start_from = 0;
r.reply.n_returned = 1;
r.reply.documents = bson_get_data (doc);
r.reply.documents_len = doc->len;
_mongoc_rpc_gather (&r, &ar);
_mongoc_rpc_swab_to_le (&r);
iov = (mongoc_iovec_t *)ar.data;
iovcnt = (int) ar.len;
for (i = 0; i < iovcnt; i++) {
expected += iov[i].iov_len;
}
n_written = mongoc_stream_writev (client, iov, (size_t) iovcnt, -1);
assert (n_written == expected);
_mongoc_array_destroy (&ar);
}
static bool hippo_cursor_load_next(MongoDBDriverCursorData* data)
{
const bson_t *doc;
if (mongoc_cursor_next(data->cursor, &doc)) {
Variant v;
BsonToVariantConverter convertor(bson_get_data(doc), doc->len, data->bson_options);
convertor.convert(&v);
data->zchild_active = true;
data->zchild = v;
return true;
}
return false;
}
static void
test_bson_alloc (void)
{
static const bson_uint8_t empty_bson[] = { 5, 0, 0, 0, 0 };
bson_t *b;
b = bson_new();
assert_cmpint(b->len, ==, 5);
assert((b->flags & BSON_FLAG_INLINE));
assert(!(b->flags & BSON_FLAG_CHILD));
assert(!(b->flags & BSON_FLAG_STATIC));
assert(!(b->flags & BSON_FLAG_NO_FREE));
bson_destroy(b);
/*
* This checks that we fit in the inline buffer size.
*/
b = bson_sized_new(44);
assert_cmpint(b->len, ==, 5);
assert((b->flags & BSON_FLAG_INLINE));
bson_destroy(b);
/*
* Make sure we grow to next power of 2.
*/
b = bson_sized_new(121);
assert_cmpint(b->len, ==, 5);
assert(!(b->flags & BSON_FLAG_INLINE));
bson_destroy(b);
/*
* Make sure we grow to next power of 2.
*/
b = bson_sized_new(129);
assert_cmpint(b->len, ==, 5);
assert(!(b->flags & BSON_FLAG_INLINE));
bson_destroy(b);
b = bson_new_from_data(empty_bson, sizeof empty_bson);
assert_cmpint(b->len, ==, sizeof empty_bson);
assert((b->flags & BSON_FLAG_INLINE));
assert(!memcmp(bson_get_data(b), empty_bson, sizeof empty_bson));
bson_destroy(b);
}
static void hippo_cursor_rewind(MongoDBDriverCursorData* data)
{
if (data->next_after_rewind != 0) {
if (data->zchild_active) {
throw MongoDriver::Utils::throwLogicException("Cursors cannot rewind after starting iteration");
} else { /* If we're not active, image we're now have fully iterated */
throw MongoDriver::Utils::throwLogicException("Cursors cannot yield multiple iterators");
}
}
invalidate_current(data);
data->current = 0;
data->zchild_active = false;
if (data->first_batch) {
if (data->is_command_cursor) {
if (!bson_iter_init(&data->first_batch_iter, data->first_batch)) {
return;
}
if (bson_iter_next(&data->first_batch_iter)) {
if (BSON_ITER_HOLDS_DOCUMENT(&data->first_batch_iter)) {
const uint8_t *document = NULL;
uint32_t document_len = 0;
Variant v;
bson_iter_document(&data->first_batch_iter, &document_len, &document);
BsonToVariantConverter convertor(document, document_len, data->bson_options);
convertor.convert(&v);
data->zchild_active = true;
data->zchild = v;
}
}
} else {
Variant v;
BsonToVariantConverter convertor(bson_get_data(data->first_batch), data->first_batch->len, data->bson_options);
convertor.convert(&v);
data->zchild_active = true;
data->zchild = v;
}
}
}
/* 编码数据包
* return: <0 error
*/
int32 bson_codec::encode(
lua_State *L,int32 index,const char **buffer,const cmd_cfg_t *cfg )
{
UNUSED( cfg );
struct error_collector ec;
ec.what[0] = 0;
bson_t *_bson_doc = bson_new();
if ( 0 != lbs_do_encode_stack( L,_bson_doc,index,&ec ) )
{
finalize();
ERROR("bson encode %s",ec.what );
return -1;
}
*buffer = (const char *)bson_get_data( _bson_doc );
return _bson_doc->len;
}
int cbson_from_json(lua_State *L)
{
bson_t *bson;
size_t len;
bson_error_t error;
const uint8_t* data = (uint8_t*)luaL_checklstring(L, 1, &len);
bson = bson_new_from_json(data, len, &error);
if (bson)
{
const uint8_t* data=bson_get_data(bson);
lua_pushlstring(L, (const char*)data, bson->len);
bson_destroy(bson);
}
else
{
luaL_error(L, error.message);
}
return 1;
}
void
_mongoc_async_cmd_init_send (mongoc_async_cmd_t *acmd, const char *dbname)
{
bson_snprintf (acmd->ns, sizeof acmd->ns, "%s.$cmd", dbname);
acmd->rpc.header.msg_len = 0;
acmd->rpc.header.request_id = ++acmd->async->request_id;
acmd->rpc.header.response_to = 0;
acmd->rpc.header.opcode = MONGOC_OPCODE_QUERY;
acmd->rpc.query.flags = MONGOC_QUERY_SLAVE_OK;
acmd->rpc.query.collection = acmd->ns;
acmd->rpc.query.skip = 0;
acmd->rpc.query.n_return = -1;
acmd->rpc.query.query = bson_get_data (&acmd->cmd);
acmd->rpc.query.fields = NULL;
/* This will always be isMaster, which are not allowed to be compressed */
_mongoc_rpc_gather (&acmd->rpc, &acmd->array);
acmd->iovec = (mongoc_iovec_t *) acmd->array.data;
acmd->niovec = acmd->array.len;
_mongoc_rpc_swab_to_le (&acmd->rpc);
acmd->bytes_written = 0;
}
void
_mongoc_rpc_prep_command (mongoc_rpc_t *rpc,
const char *cmd_ns,
const bson_t *command,
mongoc_query_flags_t flags)
{
rpc->query.msg_len = 0;
rpc->query.request_id = 0;
rpc->query.response_to = 0;
rpc->query.opcode = MONGOC_OPCODE_QUERY;
rpc->query.collection = cmd_ns;
rpc->query.skip = 0;
rpc->query.n_return = -1;
rpc->query.fields = NULL;
rpc->query.query = bson_get_data (command);
/* Find, getMore And killCursors Commands Spec: "When sending a find command
* rather than a legacy OP_QUERY find, only the slaveOk flag is honored."
* For other cursor-typed commands like aggregate, only slaveOk can be set.
* Clear bits except slaveOk; leave slaveOk set only if it is already.
*/
rpc->query.flags = flags & MONGOC_QUERY_SLAVE_OK;
}