C++ (Cpp) grn_ctx_finの例

コード例 #1

ファイル: ngx_http_groonga_module.c プロジェクト: pombredanne/groonga

static ngx_int_t
ngx_http_groonga_context_init(grn_ctx *context,
                              ngx_http_groonga_loc_conf_t *location_conf,
                              ngx_pool_t *pool,
                              ngx_log_t *log)
{
  ngx_int_t status;

  grn_ctx_init(context, GRN_NO_FLAGS);

  status = ngx_http_groonga_context_init_logger(context,
                                                location_conf,
                                                pool,
                                                log);
  if (status == NGX_ERROR) {
    grn_ctx_fin(context);
    return status;
  }

  status = ngx_http_groonga_context_init_query_logger(context,
                                                      location_conf,
                                                      pool,
                                                      log);
  if (status == NGX_ERROR) {
    grn_ctx_fin(context);
    return status;
  }

  if (location_conf->cache) {
    grn_cache_current_set(context, location_conf->cache);
  }

  return status;
}

コード例 #2

ファイル: test-database.c プロジェクト: ryoqun/groonga

void
cut_teardown(void)
{
  if (context) {
    grn_ctx_fin(context);
    g_free(context);
  }

  if (context2) {
    grn_ctx_fin(context2);
    g_free(context2);
  }

  remove_tmp_directory();
}

コード例 #3

ファイル: test-view.c プロジェクト: bossato/groonga

static void
teardown_database(void)
{
  if (view) {
    grn_obj_unlink(context, view);
  }

  if (entries) {
    grn_obj_unlink(context, entries);
  }

  if (users) {
    grn_obj_unlink(context, users);
  }

  if (dogs) {
    grn_obj_unlink(context, dogs);
  }

  if (database) {
    grn_obj_unlink(context, database);
  }

  if (context) {
    grn_ctx_fin(context);
    g_free(context);
  }
}

コード例 #4

ファイル: test-table-sort-geo.c プロジェクト: darashi/groonga

void
cut_teardown(void)
{
  if (cursor) {
    grn_obj_unlink(context, cursor);
  }

  if (result) {
    grn_obj_unlink(context, result);
  }

  if (column) {
    grn_obj_unlink(context, column);
  }

  if (table) {
    grn_obj_unlink(context, table);
  }

  grn_obj_close(context, database);
  grn_ctx_fin(context);
  g_free(context);

  remove_tmp_directory();
}

コード例 #5

ファイル: test-stress-hash.c プロジェクト: WEIC-DEV/groonga

void
test_read_write(gconstpointer *data)
{
  gint i, key;
  int added;
  grn_ctx *context;
  grn_hash *hash;
  const gchar *path;
  const gchar *value_string;
  gint process_number = 0;
  const gchar *process_number_string;
  void *value;
  grn_id id = GRN_ID_NIL;
  grn_rc rc;

  i = GPOINTER_TO_INT(data);
  process_number_string = g_getenv(GRN_TEST_ENV_PROCESS_NUMBER);
  if (process_number_string)
    process_number = atoi(process_number_string);

  key = i + process_number * N_THREADS;

  rc = grn_ctx_init(contexts[i], GRN_CTX_USE_QL);
  grn_test_assert(rc, cut_message("context: %d (%d)", i, process_number));
  context = contexts[i];

  path = g_getenv(GRN_TEST_ENV_HASH_PATH);
  cut_assert_not_null(path);
  hashes[i] = grn_hash_open(context, path);
  cut_assert_not_null(hashes[i],
                      cut_message("hash: %d (%d)", i, process_number));
  hash = hashes[i];

  grn_test_assert_nil(
    grn_hash_get(context, hash, &key, sizeof(key), &value),
    cut_message("lookup - fail: %d (%d:%d)", key, i, process_number));

  value_string = cut_take_printf("value: %d (%d:%d)", key, i, process_number);
  rc = grn_io_lock(context, hash->io, -1);
  if (rc != GRN_SUCCESS)
    grn_test_assert(rc);
  id = grn_hash_add(context, hash, &key, sizeof(key), &value, &added);
  grn_io_unlock(hash->io);
  grn_test_assert_not_nil(id);
  cut_assert_equal_int(1, added);
  strcpy(value, value_string);

  value = NULL;
  id = grn_hash_get(context, hash, &key, sizeof(key), &value);
  grn_test_assert_not_nil(
    id,
    cut_message("lookup - success: %d (%d:%d)", key, i, process_number));
  cut_assert_equal_string(value_string, value);

  hashes[i] = NULL;
  grn_test_assert(grn_hash_close(context, hash));

  contexts[i] = NULL;
  grn_test_assert(grn_ctx_fin(context));
}

コード例 #6

ファイル: test-inverted-index.c プロジェクト: kazu/groonga

void
cut_teardown(void)
{
    if (context) {
        inverted_index_free();
        if (path)
            grn_ii_remove(context, path);
        grn_ctx_fin(context);
        g_free(context);
    }

    /*
      if (vgram)
        grn_vgram_close(vgram);
    */

    if (path) {
        g_free(path);
        path = NULL;
    }

    remove_tmp_directory();

    record_ids_free();

    expected_messages_free();

    teardown_grn_logger(logger);
}

コード例 #7

ファイル: ngx_http_groonga_module.c プロジェクト: pombredanne/groonga

static void
ngx_http_groonga_close_database_callback(ngx_http_groonga_loc_conf_t *location_conf,
                                         void *user_data)
{
  ngx_http_groonga_database_callback_data_t *data = user_data;
  grn_ctx *context;

  context = &(location_conf->context);
  ngx_http_groonga_context_init_logger(context,
                                       location_conf,
                                       data->pool,
                                       data->log);
  ngx_http_groonga_context_init_query_logger(context,
                                             location_conf,
                                             data->pool,
                                             data->log);
  grn_cache_current_set(context, location_conf->cache);

  grn_obj_close(context, grn_ctx_db(context));
  ngx_http_groonga_context_log_error(data->log, context);

  grn_cache_current_set(context, NULL);
  grn_cache_close(context, location_conf->cache);

  grn_ctx_fin(context);
}

コード例 #8

ファイル: index.c プロジェクト: ikdttr/groonga

int
main(int argc, char **argv)
{
  int r = 0;
  grn_ctx ctx;
  grn_index *index;
  if (argc < 2) {
    fprintf(stderr, "usage: %s db_pathname [target_dir]\n", argv[0]);
    return -1;
  }
  if (grn_init()) {
    fprintf(stderr, "grn_init() failed\n");
    return -1;
  }
  if (grn_ctx_init(&ctx, 0)) {
    fprintf(stderr, "grn_ctx_init() failed\n");
    return -1;
  }
  if (argc > 2) {
    index = grn_index_create(&ctx, argv[1]);
    do_index(&ctx, index, argv[2]);
  } else {
    index = grn_index_open(&ctx, argv[1]);
    do_search(&ctx, index);
  }
  if (index) { grn_index_close(&ctx, index); }
  grn_ctx_fin(&ctx);
  grn_fin();
  return r;
}

コード例 #9

ファイル: groonga_mruby.c プロジェクト: AkioKanno/groonga

int
main(int argc, char **argv)
{
  int exit_code = EXIT_SUCCESS;

  if (argc != 3) {
    fprintf(stderr, "Usage: %s DB_PATH RUBY_SCRIPT_PATH\n", argv[0]);
    return EXIT_FAILURE;
  }

  if (grn_init() != GRN_SUCCESS) {
    return EXIT_FAILURE;
  }

  {
    grn_ctx ctx;
    grn_ctx_init(&ctx, 0);
    exit_code = run(&ctx, argv[1], argv[2]);
    grn_ctx_fin(&ctx);
  }

  grn_fin();

  return exit_code;
}

コード例 #10

ファイル: test_mrn_sys.cpp プロジェクト: adzuki34/mroonga

 void cut_shutdown()
 {
   grn_obj_unlink(ctx, db);
   grn_ctx_fin(ctx);
   grn_fin();
   free(ctx);
 }

コード例 #11

ファイル: test-stress-patricia-trie.c プロジェクト: hayamiz/groonga

void
test_read_write(gconstpointer *data)
{
  gint i;
  const gchar *key;
  grn_ctx *context;
  grn_pat *trie;
  const gchar *path;
  const gchar *value_string;
  gint process_number = 0;
  const gchar *process_number_string;
  void *value;
  int added;
  grn_id id = GRN_ID_NIL;
  grn_rc rc;

  i = GPOINTER_TO_INT(data);
  process_number_string = g_getenv(GRN_TEST_ENV_PROCESS_NUMBER);
  if (process_number_string)
    process_number = atoi(process_number_string);

  key = cut_take_printf("key: %d (%d:%d)", i, process_number, N_THREADS);

  rc = grn_ctx_init(contexts[i], GRN_CTX_USE_QL);
  cut_set_message("context: %d (%d)", i, process_number);
  grn_test_assert(rc);
  context = contexts[i];

  path = g_getenv(GRN_TEST_ENV_PATRICIA_TRIE_PATH);
  cut_assert_not_null(path);
  tries[i] = grn_pat_open(context, path);
  cut_assert_not_null(tries[i], "patricia trie: %d (%d)", i, process_number);
  trie = tries[i];

  cut_set_message("lookup - fail: %s (%d:%d)", key, i, process_number);
  grn_test_assert_nil(grn_pat_get(context, trie, key, strlen(key), &value));

  value_string = cut_take_printf("value: [%s] (%d:%d)", key, i, process_number);
  rc = grn_io_lock(context, trie->io, -1);
  if (rc != GRN_SUCCESS)
    grn_test_assert(rc);
  added = 0;
  id = grn_pat_add(context, trie, key, strlen(key), &value, &added);
  grn_io_unlock(trie->io);
  grn_test_assert_not_nil(id);
  cut_assert_equal_uint(1, added);
  strcpy(value, value_string);

  value = NULL;
  id = grn_pat_get(context, trie, key, strlen(key), &value);
  cut_set_message("lookup - success: %s (%d:%d)", key, i, process_number);
  grn_test_assert_not_nil(id);
  cut_assert_equal_string(value_string, value);

  tries[i] = NULL;
  grn_test_assert(grn_pat_close(context, trie));

  contexts[i] = NULL;
  grn_test_assert(grn_ctx_fin(context));
}

コード例 #12

ファイル: test-string.c プロジェクト: WEIC-DEV/groonga

void
teardown (void)
{
  GRN_OBJ_FIN(&context, &buffer);
  grn_obj_close(&context, database);
  grn_ctx_fin(&context);
}

コード例 #13

ファイル: test-read-write.c プロジェクト: WEIC-DEV/groonga

void
test_read_write(gconstpointer *data)
{
  gint i;
  int added;
  grn_ctx *context;
  grn_obj *table;
  const gchar *path;
  const gchar *value_string;
  gint process_number = 0;
  const gchar *process_number_string;
  const gchar table_name[] = "performance-read-write";
  grn_obj value;
  grn_obj *retrieved_value;
  grn_id id;
  grn_rc rc;

  i = GPOINTER_TO_INT(data);
  process_number_string = g_getenv(GRN_TEST_ENV_PROCESS_NUMBER);
  if (process_number_string)
    process_number = atoi(process_number_string);

  rc = grn_ctx_init(&contexts[i], GRN_CTX_USE_QL);
  grn_test_assert(rc, cut_set_message("context: %d (%d)", i, process_number));
  context = &contexts[i];

  path = g_getenv(GRN_TEST_ENV_TABLE_PATH);
  cut_assert_not_null(path);
  tables[i] = grn_table_open(context, table_name, strlen(table_name),
                             path);
  cut_assert_not_null(tables[i],
                      cut_message("table: %d (%d)", i, process_number));
  table = tables[i];

  grn_test_assert_nil(grn_table_get(context, table, &i, sizeof(grn_id)),
                      cut_message("lookup - fail: (%d:%d)", i, process_number));

  value_string = cut_take_printf("value: (%d:%d)", i, process_number);
  id = grn_table_add(context, table, &i, sizeof(grn_id), &added);
  grn_test_assert_not_nil(id);
  cut_assert_equal_int(1, added);

  GRN_TEXT_INIT(&value, GRN_OBJ_DO_SHALLOW_COPY);
  GRN_TEXT_SET_REF(&value, value_string, strlen(value_string));
  grn_obj_set_value(context, table, id, &value, GRN_OBJ_SET);

  retrieved_value = grn_obj_get_value(context, table, id, NULL);
  grn_test_assert_not_nil(
    id,
    cut_message("lookup - success: (%d:%d)", i, process_number));
  GRN_TEXT_PUTC(context, retrieved_value, '\0');
  cut_assert_equal_string(value_string, GRN_BULK_HEAD(retrieved_value));

  tables[i] = NULL;
  grn_test_assert(grn_obj_close(context, table));

  //  contexts[i] = NULL;
  grn_test_assert(grn_ctx_fin(context));
}

コード例 #14

ファイル: test-database.c プロジェクト: ryoqun/groonga

void
test_expression_lifetime_over_database(void)
{
  const gchar *path;
  gint i, n_tries = 100;
  grn_obj *expression;

  cut_omit("will be SEGVed.");
  path = cut_build_path(tmp_directory, "database.groonga", NULL);
  for (i = 0; i < n_tries; i++) {
    gint j, n_records = 100;
    const gchar *query;
    grn_obj *table, *variable;
    grn_obj default_column;

    database = grn_db_create(context, path, NULL);
    grn_test_assert_context(context);

    assert_send_command("table_create Sites 0 ShortText");
    assert_send_command("column_create Sites point COLUMN_SCALAR Int32");
    for (j = 0; j < n_records; j++) {
      gchar *command;

      command = g_strdup_printf("load '"
                                "[[\"_key\", \"point\"],"
                                "[\"http://groonga.org/version/%d\",%d]]' "
                                "Sites",
                                j, j);
      assert_send_command(command);
      g_free(command);
    }

    table = get_object("Sites");
    GRN_EXPR_CREATE_FOR_QUERY(context, table, expression, variable);
    grn_obj_unlink(context, table);

    GRN_TEXT_INIT(&default_column, 0);
    GRN_TEXT_PUTS(context, &default_column, "point");
    query = "point:50";
    grn_expr_parse(context, expression,
                   query, strlen(query),
                   &default_column,
                   GRN_OP_MATCH, GRN_OP_AND,
                   GRN_EXPR_SYNTAX_QUERY | GRN_EXPR_ALLOW_COLUMN);
    grn_test_assert_context(context);
    grn_obj_unlink(context, &default_column);
    grn_expr_compile(context, expression);

    grn_obj_remove(context, database);
    database = NULL;

    remove_tmp_directory();
    g_mkdir_with_parents(tmp_directory, 0700);
  }

  grn_ctx_fin(context);
  g_free(context);
  context = NULL;
}

コード例 #15

ファイル: bench-range-select.c プロジェクト: XLPE/groonga

static void
bench_shutdown(BenchmarkData *data)
{
  grn_ctx *context = &(data->context);

  grn_obj_close(context, data->database);
  grn_ctx_fin(context);
}

コード例 #16

ファイル: test-expr.c プロジェクト: ikdttr/groonga

void
cut_teardown(void)
{
  grn_db_close(&context, database);
  grn_ctx_fin(&context);
  cut_remove_path(tmp_directory, NULL);
  g_free(path);
}

コード例 #17

ファイル: test-cast-basic.c プロジェクト: zunda/groonga

void
cut_teardown(void)
{
  grn_obj_remove(&context, &src);
  grn_obj_remove(&context, &dest);
  grn_ctx_fin(&context);
  teardown_grn_logger(logger);
}

コード例 #18

ファイル: test-column.c プロジェクト: mooz/groonga

void
cut_teardown(void)
{
  grn_obj_close(context, database);
  grn_ctx_fin(context);
  g_free(context);
  teardown_grn_logger(logger);
}

コード例 #19

ファイル: _groonga.c プロジェクト: hhatto/pyroonga

static void
GroongaContext_dealloc(GroongaContext *self)
{
    if (self->opened) {
        Py_BEGIN_ALLOW_THREADS
        grn_ctx_fin(&self->ctx);
        Py_END_ALLOW_THREADS
    }

コード例 #20

ファイル: bench-table-factory.c プロジェクト: XLPE/groonga

static void
bench_teardown(gpointer user_data)
{
  BenchmarkData *data = user_data;

  grn_obj_close(data->context, data->key_type);
  grn_ctx_fin(data->context);
  bench_utils_remove_path_recursive_force(data->base_dir);
}

コード例 #21

ファイル: test-table.c プロジェクト: temita/groonga

void
cut_teardown(void)
{
  grn_obj_close(context, database);
  grn_ctx_fin(context);
  g_free(context);
  teardown_grn_logger(logger);
  cut_remove_path(tmp_directory, NULL);
}

コード例 #22

ファイル: test-function-edit-distance.c プロジェクト: WEIC-DEV/groonga

void
cut_teardown(void)
{
  grn_obj_close(context, database);
  grn_ctx_fin(context);
  g_free(context);

  remove_tmp_directory();
}

コード例 #23

ファイル: mrn_udf_escape.cpp プロジェクト: skyformat99/mroonga

MRN_API void mroonga_escape_deinit(UDF_INIT *initid)
{
  EscapeInfo *info = (EscapeInfo *)initid->ptr;
  if (info) {
    grn_obj_unlink(&(info->ctx), &(info->target_characters));
    grn_obj_unlink(&(info->ctx), &(info->escaped_query));
    grn_ctx_fin(&(info->ctx));
    my_free(info);
  }
}

コード例 #24

ファイル: test-command-select-query.c プロジェクト: AkioKanno/groonga

void
cut_teardown(void)
{
  if (context) {
    grn_obj_unlink(context, database);
    grn_ctx_fin(context);
    g_free(context);
  }

  remove_tmp_directory();
}

コード例 #25

ファイル: ngx_http_groonga_module.c プロジェクト: bossato/groonga

static void
ngx_http_groonga_handler_cleanup(void *user_data)
{
  ngx_http_groonga_handler_data_t *data = user_data;
  grn_ctx *context;

  context = &(data->context);
  GRN_OBJ_FIN(context, &(data->head));
  GRN_OBJ_FIN(context, &(data->body));
  GRN_OBJ_FIN(context, &(data->foot));
  grn_ctx_fin(context);
}

コード例 #26

void
cut_teardown(void)
{
  if (context) {
    grn_ctx_fin(context);
    g_free(context);
  }

  teardown_grn_logger(logger);

  remove_tmp_directory();
}

コード例 #27

ファイル: test-database.c プロジェクト: darashi/groonga

void
cut_teardown(void)
{
  if (context) {
    if (database) {
      grn_obj_close(context, database);
    }
    grn_ctx_fin(context);
    g_free(context);
  }

  if (context2) {
    if (database2) {
      grn_obj_close(context2, database2);
    }
    grn_ctx_fin(context2);
    g_free(context2);
  }

  remove_tmp_directory();
}

コード例 #28

ファイル: mrn_udf_command.cpp プロジェクト: WEIC-DEV/mroonga

MRN_API void mroonga_command_deinit(UDF_INIT *initid)
{
  CommandInfo *info = (CommandInfo *)initid->ptr;
  if (info) {
    grn_obj *db = grn_ctx_db(&(info->ctx));
    if (db) {
      grn_obj_close(&(info->ctx), db);
    }
    grn_ctx_fin(&(info->ctx));
    info->result.free();
    my_free(info, MYF(0));
  }
}

コード例 #29

ファイル: test-geo-in-rectangle-border.c プロジェクト: zunda/groonga

void
cut_teardown(void)
{
  grn_obj_unlink(context, result);
  grn_obj_unlink(context, location_index_column);
  grn_obj_unlink(context, short_degree_column);
  grn_obj_unlink(context, points);
  grn_obj_close(context, database);
  grn_ctx_fin(context);
  g_free(context);

  remove_tmp_directory();
}

コード例 #30

ファイル: test-geo-in-rectangle.c プロジェクト: darashi/groonga

void
cut_teardown(void)
{
  teardown_values();

  grn_obj_unlink(context, result);
  grn_obj_unlink(context, location_index);
  grn_obj_close(context, database);
  grn_ctx_fin(context);
  g_free(context);

  remove_tmp_directory();
}