mrb_value mrb_mongo_collection_init(mrb_state *mrb, mrb_value self) { mrb_value database, collection_name; mrb_mongo_database_data *db_data; mrb_mongo_collection_data *data; mongoc_collection_t *collection; //parse args mrb_get_args(mrb, "oS", &database, &collection_name); //prepare data structure data = (mrb_mongo_collection_data*)DATA_PTR(self); if (data) { mrb_free(mrb, data); } DATA_TYPE(self) = &mrb_mongo_collection_data_type; DATA_PTR(self) = NULL; data = (mrb_mongo_collection_data*)mrb_malloc(mrb, sizeof(mrb_mongo_collection_data)); //get db data db_data = (mrb_mongo_database_data *)DATA_PTR(database); collection = mongoc_database_get_collection(db_data->db, mrb_str_to_cstr(mrb, collection_name)); mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "database"), database); mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "name"), collection_name); //set data structure data->collection = collection; DATA_PTR(self) = data; return self; }
int main (int argc, char *argv[]) { const char *default_uristr = "mongodb://localhost/test"; char *uristr; const char *database_name; mongoc_uri_t *uri; mongoc_client_t *client; mongoc_database_t *db; mongoc_collection_t *collection; mongoc_init (); uristr = getenv ("MONGODB_URI"); uristr = uristr ? uristr : (char*)default_uristr; uri = mongoc_uri_new (uristr); client = mongoc_client_new_from_uri (uri); database_name = mongoc_uri_get_database (uri); db = mongoc_client_get_database (client, database_name); collection = mongoc_database_get_collection (db, "test"); test_suite (db, collection); mongoc_collection_destroy (collection); mongoc_database_destroy (db); mongoc_client_destroy (client); mongoc_uri_destroy (uri); mongoc_cleanup (); return 0; }
mongoc_collection_t * dbproxy::get_collection(std::string collection_name) { auto it = collectiondict.find(collection_name); if (it != collectiondict.end()) { return it->second; } return mongoc_database_get_collection(_db, collection_name.c_str()); }
static void dump_message(ullong number, str_t type, msg_content_array_t* content) { bson_t document; bson_error_t error; time_t t; mongoc_collection_t* collection = mongoc_database_get_collection(robot.mongoc_database, "message"); char* json = msg_content_array_to_json_object_string(content, "content"); time(&t); if (!bson_init_from_json(&document, json, strlen(json), &error)) MONGOC_WARNING("%s\n", error.message); BSON_APPEND_INT64(&document, "from", number); BSON_APPEND_UTF8(&document, "type", type.ptr); BSON_APPEND_TIME_T(&document, "time", t); if (!mongoc_collection_insert(collection, MONGOC_INSERT_NONE, &document, NULL, &error)) MONGOC_WARNING("%s\n", error.message); bson_destroy(&document); free(json); }
int lua_mongo_collection_new(lua_State *L) { const char* collection_name; database_t *database; collection_t *collection; database = (database_t *)luaL_checkudata(L, 1, "lua_mongoc_database"); collection_name = luaL_checkstring(L, 2); if (collection_name == NULL) { luaL_error(L, "collection name cannot be empty"); } collection = (collection_t *)lua_newuserdata(L, sizeof(*collection)); collection->c_collection = mongoc_database_get_collection(database->c_database, collection_name); collection->c_database = database->c_database; luaL_getmetatable(L, "lua_mongoc_collection"); lua_setmetatable(L, -2); return 1; }
int main (int argc, char *argv[]) { mongoc_database_t *database = NULL; mongoc_client_t *client = NULL; mongoc_collection_t *collection = NULL; char *host_and_port; int res = 0; char* other_host_and_port = NULL; if (argc < 2 || argc > 3) { fprintf (stderr, "usage: %s MONGOD-1-CONNECTION-STRING " "[MONGOD-2-HOST-NAME:MONGOD-2-PORT]\n", argv[0]); fprintf (stderr, "MONGOD-1-CONNECTION-STRING can be " "of the following forms:\n"); fprintf (stderr, "localhost\t\t\t\tlocal machine\n"); fprintf (stderr, "localhost:27018\t\t\t\tlocal machine on port 27018\n"); fprintf (stderr, "mongodb://*****:*****@localhost:27017\t" "local machine on port 27017, and authenticate with username " "user and password pass\n"); return 1; } mongoc_init (); if (strncmp (argv[1], "mongodb://", 10) == 0) { host_and_port = bson_strdup (argv [1]); } else { host_and_port = bson_strdup_printf ("mongodb://%s", argv[1]); } other_host_and_port = argc > 2 ? argv[2] : NULL; client = mongoc_client_new (host_and_port); if (!client) { fprintf(stderr, "Invalid hostname or port: %s\n", host_and_port); res = 2; goto cleanup; } database = mongoc_client_get_database (client, "test"); collection = mongoc_database_get_collection (database, COLLECTION_NAME); printf ("Inserting data\n"); if (!insert_data (collection)) { res = 3; goto cleanup; } printf ("explain\n"); if (!explain (collection)) { res = 4; goto cleanup; } if (other_host_and_port) { printf ("copydb\n"); if (!copydb (client, other_host_and_port)) { res = 5; goto cleanup; } printf ("clone collection\n"); if (!clone_collection (database, other_host_and_port)) { res = 6; goto cleanup; } } cleanup: if (collection) { mongoc_collection_destroy (collection); } if (database) { mongoc_database_destroy (database); } if (client) { mongoc_client_destroy (client); } bson_free (host_and_port); mongoc_cleanup (); return res; }
static void test_bypass_validation (void *context) { mongoc_collection_t *collection; bson_t reply = BSON_INITIALIZER; mongoc_bulk_operation_t *bulk; mongoc_database_t *database; mongoc_write_concern_t *wr; mongoc_client_t *client; bson_error_t error; bson_t *options; char *collname; char *dbname; int r; int i; client = test_framework_client_new (); assert (client); dbname = gen_collection_name ("dbtest"); collname = gen_collection_name ("bypass"); database = mongoc_client_get_database (client, dbname); collection = mongoc_database_get_collection (database, collname); assert (collection); options = tmp_bson ("{'validator': {'number': {'$gte': 5}}, 'validationAction': 'error'}"); ASSERT_OR_PRINT (mongoc_database_create_collection (database, collname, options, &error), error); /* {{{ Default fails validation */ bulk = mongoc_collection_create_bulk_operation(collection, true, NULL); for (i = 0; i < 3; i++) { bson_t *doc = tmp_bson (bson_strdup_printf ("{'number': 3, 'high': %d }", i)); mongoc_bulk_operation_insert (bulk, doc); } r = mongoc_bulk_operation_execute (bulk, &reply, &error); ASSERT(!r); ASSERT_ERROR_CONTAINS (error, MONGOC_ERROR_COMMAND, 121, "Document failed validation"); mongoc_bulk_operation_destroy (bulk); /* }}} */ /* {{{ bypass_document_validation=false Fails validation */ bulk = mongoc_collection_create_bulk_operation(collection, true, NULL); mongoc_bulk_operation_set_bypass_document_validation (bulk, false); for (i = 0; i < 3; i++) { bson_t *doc = tmp_bson (bson_strdup_printf ("{'number': 3, 'high': %d }", i)); mongoc_bulk_operation_insert (bulk, doc); } r = mongoc_bulk_operation_execute (bulk, &reply, &error); ASSERT(!r); ASSERT_ERROR_CONTAINS (error, MONGOC_ERROR_COMMAND, 121, "Document failed validation"); mongoc_bulk_operation_destroy (bulk); /* }}} */ /* {{{ bypass_document_validation=true ignores validation */ bulk = mongoc_collection_create_bulk_operation(collection, true, NULL); mongoc_bulk_operation_set_bypass_document_validation (bulk, true); for (i = 0; i < 3; i++) { bson_t *doc = tmp_bson (bson_strdup_printf ("{'number': 3, 'high': %d }", i)); mongoc_bulk_operation_insert (bulk, doc); } r = mongoc_bulk_operation_execute (bulk, &reply, &error); ASSERT_OR_PRINT(r, error); mongoc_bulk_operation_destroy (bulk); /* }}} */ /* {{{ w=0 and bypass_document_validation=set fails */ bulk = mongoc_collection_create_bulk_operation(collection, true, NULL); wr = mongoc_write_concern_new (); mongoc_write_concern_set_w (wr, 0); mongoc_bulk_operation_set_write_concern (bulk, wr); mongoc_bulk_operation_set_bypass_document_validation (bulk, true); for (i = 0; i < 3; i++) { bson_t *doc = tmp_bson (bson_strdup_printf ("{'number': 3, 'high': %d }", i)); mongoc_bulk_operation_insert (bulk, doc); } r = mongoc_bulk_operation_execute (bulk, &reply, &error); ASSERT_OR_PRINT(!r, error); ASSERT_ERROR_CONTAINS (error, MONGOC_ERROR_COMMAND, MONGOC_ERROR_COMMAND_INVALID_ARG, "Cannot set bypassDocumentValidation for unacknowledged writes"); mongoc_bulk_operation_destroy (bulk); mongoc_write_concern_destroy (wr); /* }}} */ ASSERT_OR_PRINT (mongoc_collection_drop (collection, &error), error); mongoc_collection_destroy (collection); mongoc_client_destroy (client); }
static void route_result(cJSON* result) { cJSON* cjson_current; size_t i; for (cjson_current = result->child; cjson_current; cjson_current = cjson_current->next) { if (strcmp(cJSON_GetObjectItem(cjson_current, "poll_type")->valuestring, "message") == 0) { cJSON* cjson_value = cJSON_GetObjectItem(cjson_current, "value"); ullong from_uin = cJSON_GetObjectItem(cjson_value, "from_uin")->valuedouble; ullong number = get_friend_number(from_uin); msg_content_array_t content = fetch_content(cJSON_GetObjectItem(cjson_value, "content")); dump_message(number, str_from("friend_message"), &content); #ifdef _DEBUG { char* str = msg_content_array_to_json_object_string(&content, "content"); fprintf(stdout, "Received message from: %llu\nContent: %s\n", number, str); fflush(stdout); free(str); } #endif for (i = 0; i < robot.received_message_funcs_count; ++i) robot.received_message_funcs[i](from_uin, number, &content); msg_content_array_free(&content); } else if (strcmp(cJSON_GetObjectItem(cjson_current, "poll_type")->valuestring, "group_message") == 0) { cJSON* cjson_value = cJSON_GetObjectItem(cjson_current, "value"); ullong from_uin = cJSON_GetObjectItem(cjson_value, "from_uin")->valuedouble; ullong number = get_group_number(cJSON_GetObjectItem(cjson_value, "group_code")->valuedouble); msg_content_array_t content = fetch_content(cJSON_GetObjectItem(cjson_value, "content")); dump_message(number, str_from("group_message"), &content); #ifdef _DEBUG { char* str = msg_content_array_to_json_object_string(&content, "content"); fprintf(stdout, "Received group_message from: %llu\nContent: %s\n", number, str); fflush(stdout); free(str); } #endif for (i = 0; i < robot.received_group_message_funcs_count; ++i) robot.received_group_message_funcs[i](from_uin, number, &content); msg_content_array_free(&content); } else { bson_t document; bson_t content; bson_error_t error; time_t t; char* ptr = cJSON_PrintUnformatted(cjson_current); mongoc_collection_t* collection = mongoc_database_get_collection(robot.mongoc_database, "unprocessed"); time(&t); if (!bson_init_from_json(&content, ptr, strlen(ptr), &error)) { MONGOC_WARNING("%s\n", error.message); return; } bson_init(&document); BSON_APPEND_TIME_T(&document, "time", t); BSON_APPEND_DOCUMENT(&document, "content", &content); if (!mongoc_collection_insert(collection, MONGOC_INSERT_NONE, &document, NULL, &error)) MONGOC_WARNING("%s\n", error.message); bson_destroy(&document); bson_destroy(&content); } } }
static int init() { str_t tmp = empty_str; str_t host = conf_lookup(&robot.conf, str_from("DB_HOST")).string; str_t name = conf_lookup(&robot.conf, str_from("DB_NAME")).string; size_t i; int rc = 1; str_cat(&tmp, "mongodb://"); str_ncat(&tmp, host.ptr, host.len); robot.mongoc_client = mongoc_client_new(tmp.ptr); if (robot.mongoc_client == NULL) { rc = 0; fprintf(stderr, "mongoc_client_new(\"%s\") error!!!!\n", tmp.ptr); goto end; } robot.mongoc_database = mongoc_client_get_database(robot.mongoc_client, name.ptr); if (robot.mongoc_database == NULL) { rc = 0; fprintf(stderr, "mongoc_client_get_database(\"%s\") error!!!!\n", name.ptr); goto end; } { mongoc_collection_t* message_collection; mongoc_index_opt_t opt; bson_error_t error; bson_t keys; message_collection = mongoc_database_get_collection(robot.mongoc_database, "message"); if (message_collection == NULL) { rc = 0; fprintf(stderr, "mongoc_database_get_collection(\"message\") error!!!!\n"); goto end; } mongoc_index_opt_init(&opt); // from+type 做联合索引 bson_init(&keys); BSON_APPEND_INT32(&keys, "from", 1); BSON_APPEND_INT32(&keys, "type", 1); if (!mongoc_collection_create_index(message_collection, &keys, &opt, &error)) MONGOC_WARNING("%s\n", error.message); bson_destroy(&keys); // time 做逆序索引 bson_init(&keys); BSON_APPEND_INT32(&keys, "time", -1); if (!mongoc_collection_create_index(message_collection, &keys, &opt, &error)) MONGOC_WARNING("%s\n", error.message); bson_destroy(&keys); // content 做全文索引 bson_init(&keys); BSON_APPEND_UTF8(&keys, "content", "text"); if (!mongoc_collection_create_index(message_collection, &keys, &opt, &error)) MONGOC_WARNING("%s\n", error.message); bson_destroy(&keys); } { mongoc_collection_t* unprocessed_collection; mongoc_index_opt_t opt; bson_error_t error; bson_t keys; unprocessed_collection = mongoc_database_get_collection(robot.mongoc_database, "unprocessed"); if (unprocessed_collection == NULL) { rc = 0; fprintf(stderr, "mongoc_database_get_collection(\"unprocessed\") error!!!!\n"); goto end; } mongoc_index_opt_init(&opt); // time 做逆序索引 bson_init(&keys); BSON_APPEND_INT32(&keys, "time", -1); if (!mongoc_collection_create_index(unprocessed_collection, &keys, &opt, &error)) MONGOC_WARNING("%s\n", error.message); bson_destroy(&keys); } for (i = 0; modules[i]; ++i) { if (modules[i]->module_init) { rc = modules[i]->module_init(); if (!rc) goto end; } } end: str_free(tmp); return rc; }
bool map_reduce_basic (mongoc_database_t* database) { bson_t reply; bson_t* command; bool res; bson_error_t error; mongoc_cursor_t* cursor; const bson_t* doc; bool map_reduce_done = false; bool query_done = false; const char* out_collection_name = "outCollection"; mongoc_collection_t* out_collection; /* Empty find query */ bson_t find_query = BSON_INITIALIZER; /* Construct the mapReduce command */ /* Other arguments can also be specified here, like "query" or "limit" and so on */ command = BCON_NEW ("mapReduce", BCON_UTF8 (COLLECTION_NAME), "map", BCON_CODE (MAPPER), "reduce", BCON_CODE (REDUCER), "out", BCON_UTF8 (out_collection_name)); res = mongoc_database_command_simple (database, command, NULL, &reply, &error); map_reduce_done = true; if (!res) { fprintf (stderr, "MapReduce failed: %s\n", error.message); goto cleanup; } /* Do something with the reply (it doesn't contain the mapReduce results) */ print_res (&reply); /* Now we'll query outCollection to see what the results are */ out_collection = mongoc_database_get_collection (database, out_collection_name); cursor = mongoc_collection_find_with_opts (out_collection, &find_query, NULL, NULL); query_done = true; /* Do something with the results */ while (mongoc_cursor_next (cursor, &doc)) { print_res (doc); } if (mongoc_cursor_error (cursor, &error)) { fprintf (stderr, "ERROR: %s\n", error.message); res = false; goto cleanup; } cleanup: /* cleanup */ if (query_done) { mongoc_cursor_destroy (cursor); mongoc_collection_destroy (out_collection); } if (map_reduce_done) { bson_destroy (&reply); bson_destroy (command); } return res; }
int64_t load_table (mongoc_database_t *db, const char *table_name, bson_t *bson_schema) { int64_t ret = true; column_map_t *column_map, *column_map_p; int column_map_size, i; double start_time, end_time, delta_time; FILE *fp; mongoc_collection_t *collection; mongoc_bulk_operation_t *bulk; size_t n_docs = 0; char *token; bson_t bson, reply; int64_t count = 0; bson_error_t error; fprintf (stderr, "load_table table_name: \"%s\"\n", table_name); get_column_map (bson_schema, table_name, &column_map, &column_map_size) || DIE; snprintf (mbdump_file, MAXPATHLEN, "%s/%s", mbdump_dir, table_name); /* fprintf (stderr, "mbdump_file: \"%s\"\n", mbdump_file); */ start_time = dtimeofday (); fp = fopen (mbdump_file, "r"); if (!fp) DIE; collection = mongoc_database_get_collection (db, table_name); bulk = mongoc_collection_create_bulk_operation (collection, true, NULL); bson_init (&bson); while (ret && fgets (buf, BUFSIZ, fp)) { /* fputs (buf, stdout); */ chomp (buf); for (i = 0, column_map_p = column_map, token = strtok_single (buf, "\t"); i < column_map_size; i++, column_map_p++, token = strtok_single (NULL, "\t")) { bool ret; /* fprintf (stderr, "%s: \"%s\" [%d/%d](%s)\n", column_map_p->column_name, token, i, column_map_size, column_map_p->data_type); fflush (stdout); */ ret = (*column_map_p->bson_append_from_s) (&bson, column_map_p->column_name, token); ret || fprintf (stderr, "WARNING: column_map_p->bson_append_from_s failed column %s: \"%s\" [%d/%d](%s)\n", column_map_p->column_name, token, i, column_map_size, column_map_p->data_type); } /* bson_printf ("bson: %s\n", &bson); */ mongoc_bulk_operation_insert (bulk, &bson); bson_reinit (&bson); if (++n_docs == BULK_OPS_SIZE) { ret = mongoc_bulk_operation_execute (bulk, &reply, &error); if (ret) { count += n_docs; if (count % PROGRESS_SIZE == 0) { fputc('.', stdout); fflush(stdout); } } else fprintf (stderr, "mongoc_cursor_bulk_insert execute failure: %s\n", error.message); n_docs = 0; mongoc_bulk_operation_destroy (bulk); bulk = mongoc_collection_create_bulk_operation (collection, true, NULL); } } if (ret && n_docs > 0) { ret = mongoc_bulk_operation_execute (bulk, &reply, &error); if (ret) count += n_docs; else fprintf (stderr, "mongoc_cursor_bulk_insert execute failure: %s\n", error.message); } fputc('.', stdout); fputc('\n', stdout); fflush(stdout); bson_destroy (&bson); mongoc_bulk_operation_destroy (bulk); mongoc_collection_destroy (collection); fclose (fp); end_time = dtimeofday (); delta_time = end_time - start_time + 0.0000001; fprintf (stderr, "info: real: %.2f, count: %"PRId64", %"PRId64" docs/sec\n", delta_time, count, (int64_t)round (count/delta_time)); fflush (stderr); free (column_map); return ret ? count : -1; }
static void test_func_inherits_opts (void *ctx) { opt_inheritance_test_t *test = (opt_inheritance_test_t *) ctx; /* for example, test mongoc_collection_find_with_opts with no read pref, * with a read pref set on the collection (OPT_SOURCE_COLL), with an explicit * read pref (OPT_SOURCE_FUNC), or with one read pref on the collection and * a different one passed explicitly */ opt_source_t source_matrix[] = {OPT_SOURCE_NONE, test->opt_source, OPT_SOURCE_FUNC, test->opt_source | OPT_SOURCE_FUNC}; size_t i; func_ctx_t func_ctx; mock_rs_t *rs; mongoc_client_t *client; mongoc_database_t *db; mongoc_collection_t *collection; bson_t opts = BSON_INITIALIZER; mongoc_read_prefs_t *func_prefs = NULL; future_t *future; request_t *request; bson_t cmd = BSON_INITIALIZER; bool expect_secondary; bson_error_t error; /* one primary, one secondary */ rs = mock_rs_with_autoismaster (WIRE_VERSION_OP_MSG, true, 1, 0); /* we use read pref tags like "collection": "yes" to verify where the * pref was inherited from; ensure all secondaries match all tags */ mock_rs_tag_secondary (rs, 0, tmp_bson ("{'client': 'yes'," " 'database': 'yes'," " 'collection': 'yes'," " 'function': 'yes'}")); mock_rs_run (rs); /* iterate over all combinations of options sources: e.g., an option set on * collection and not function, on function not collection, both, neither */ for (i = 0; i < sizeof (source_matrix) / (sizeof (opt_source_t)); i++) { expect_secondary = false; func_prefs = NULL; bson_reinit (&cmd); bson_reinit (&opts); client = mongoc_client_new_from_uri (mock_rs_get_uri (rs)); if (source_matrix[i] & OPT_SOURCE_CLIENT) { set_client_opt (client, test->opt_type); } db = mongoc_client_get_database (client, "database"); if (source_matrix[i] & OPT_SOURCE_DB) { set_database_opt (db, test->opt_type); } collection = mongoc_database_get_collection (db, "collection"); if (source_matrix[i] & OPT_SOURCE_COLL) { set_collection_opt (collection, test->opt_type); } if (source_matrix[i] & OPT_SOURCE_FUNC) { set_func_opt (&opts, &func_prefs, test->opt_type); } func_ctx_init ( &func_ctx, test, client, db, collection, func_prefs, &opts); /* func_with_opts creates expected "cmd", like {insert: 'collection'} */ future = test->func_with_opts (&func_ctx, &cmd); if (source_matrix[i] != OPT_SOURCE_NONE) { add_expected_opt (source_matrix[i], test->opt_type, &cmd); if (test->opt_type == OPT_READ_PREFS) { expect_secondary = true; } } /* write commands send two OP_MSG sections */ if (test->n_sections == 2) { request = mock_rs_receives_msg (rs, 0, &cmd, tmp_bson ("{}")); } else { request = mock_rs_receives_msg (rs, 0, &cmd); } if (expect_secondary) { BSON_ASSERT (mock_rs_request_is_to_secondary (rs, request)); } else { BSON_ASSERT (mock_rs_request_is_to_primary (rs, request)); } if (func_ctx.cursor) { mock_server_replies_simple (request, "{'ok': 1," " 'cursor': {" " 'id': 0," " 'ns': 'db.collection'," " 'firstBatch': []}}"); BSON_ASSERT (!future_get_bool (future)); future_destroy (future); ASSERT_OR_PRINT (!mongoc_cursor_error (func_ctx.cursor, &error), error); } else { mock_server_replies_simple (request, "{'ok': 1}"); cleanup_future (future); } request_destroy (request); mongoc_read_prefs_destroy (func_prefs); func_ctx_cleanup (&func_ctx); mongoc_collection_destroy (collection); mongoc_database_destroy (db); mongoc_client_destroy (client); } bson_destroy (&cmd); bson_destroy (&opts); mock_rs_destroy (rs); }