Exemple #1
0
int database_create_transaction_indexes(struct database* db)
{
    bson_t* keys;
    mongoc_index_opt_t opt;
    bson_error_t error;

    mongoc_collection_t* collection = mongoc_client_get_collection(db->client, database_name(db), "transactions");

    // transactions.hash
    {
        keys = bson_new();
        BSON_APPEND_INT32(keys, "hash", 1);

        mongoc_index_opt_init(&opt);
        opt.unique = 1;

        if(mongoc_collection_create_index(collection, keys, &opt, &error) == 0) {
            printf("index creation error (transaction.hash)\n");
        }

        bson_destroy(keys);
    }

    // (transaction.inputs.output_reference.hash, transaction.inputs.output_reference.index) [non-unique]
    {
        keys = bson_new();
        BSON_APPEND_INT32(keys, "inputs.output_reference.hash", 1);
        BSON_APPEND_INT32(keys, "inputs.output_reference.index", 1);

        mongoc_index_opt_init(&opt);
        opt.unique = 0;

        if(mongoc_collection_create_index(collection, keys, &opt, &error) == 0) {
            printf("index creation error (inputs.output_reference)\n");
        }

        bson_destroy(keys);
    }

    mongoc_collection_destroy(collection);
    return 0;
}
static void
test_index (void)
{
   mongoc_collection_t *collection;
   mongoc_database_t *database;
   mongoc_client_t *client;
   mongoc_index_opt_t opt;
   bson_error_t error;
   bool r;
   bson_t keys;

   mongoc_index_opt_init(&opt);

   client = mongoc_client_new(gTestUri);
   ASSERT (client);

   database = get_test_database (client);
   ASSERT (database);

   collection = get_test_collection (client, "test_index");
   ASSERT (collection);

   bson_init(&keys);
   bson_append_int32(&keys, "hello", -1, 1);
   r = mongoc_collection_create_index(collection, &keys, &opt, &error);
   ASSERT (r);

   r = mongoc_collection_create_index(collection, &keys, &opt, &error);
   ASSERT (r);

   r = mongoc_collection_drop_index(collection, "hello_1", &error);
   ASSERT (r);

   bson_destroy(&keys);

   r = mongoc_collection_drop (collection, &error);
   ASSERT (r);

   mongoc_collection_destroy(collection);
   mongoc_database_destroy(database);
   mongoc_client_destroy(client);
}
SEXP R_mongo_collection_create_index(SEXP ptr_col, SEXP ptr_bson) {
  mongoc_collection_t *col = r2col(ptr_col);
  bson_t *b = r2bson(ptr_bson);
  const mongoc_index_opt_t *options = mongoc_index_opt_get_default();
  bson_error_t err;

  if(!mongoc_collection_create_index(col, b, options, &err))
    stop(err.message);

  return ScalarLogical(1);
}
void Collection::CollectionImpl::CreateIndex( tlib::bson::object key, bool unique )
{
	bson_error_t error;
	mongoc_index_opt_t opt;
	mongoc_index_opt_init(&opt);
	opt.unique = unique;

	bool res = mongoc_collection_create_index( m_collection.get(), key.get(), &opt, &error );
	if(!res)
		throw MongoError( std::string(error.message).append(" in Collection::CreateIndex") );
}
/**
 * _mongoc_gridfs_ensure_index:
 *
 * ensure gridfs indexes
 *
 * Ensure fast searches for chunks via [ files_id, n ]
 * Ensure fast searches for files via [ filename ]
 */
static bool
_mongoc_gridfs_ensure_index (mongoc_gridfs_t *gridfs,
                             bson_error_t    *error)
{
   bson_t keys;
   mongoc_index_opt_t opt;
   bool r;

   ENTRY;

   bson_init (&keys);

   bson_append_int32 (&keys, "files_id", -1, 1);
   bson_append_int32 (&keys, "n", -1, 1);

   mongoc_index_opt_init (&opt);
   opt.unique = 1;

   r = mongoc_collection_create_index (gridfs->chunks, &keys, &opt, error);

   bson_destroy (&keys);

   if (!r) { RETURN (r); }

   bson_init (&keys);

   bson_append_int32 (&keys, "filename", -1, 1);
   bson_append_int32 (&keys, "uploadDate", -1, 1);
   opt.unique = 0;

   r = mongoc_collection_create_index (gridfs->files, &keys, &opt, error);

   bson_destroy (&keys);

   if (!r) { RETURN (r); }

   RETURN (1);
}
Exemple #6
0
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;
}
Exemple #7
0
bool dbproxy::create_index(std::string collection_name, const bson_t * keys, const mongoc_index_opt_t *opt, bson_error_t * error) {
    mongoc_collection_t * _c = get_collection(collection_name);
    return mongoc_collection_create_index(_c, keys, opt, error);
}