static void update_data(grn_id record_id, unsigned int section, const gchar *old_name, const gchar *new_name) { grn_obj old_value, new_value; const gchar *old_data, *new_data; GRN_TEXT_INIT(&old_value, GRN_OBJ_DO_SHALLOW_COPY); GRN_TEXT_INIT(&new_value, GRN_OBJ_DO_SHALLOW_COPY); if (old_name) { old_data = cut_get_fixture_data_string(old_name, NULL); GRN_TEXT_SET_REF(&old_value, old_data, strlen(old_data)); } if (new_name) { new_data = cut_get_fixture_data_string(new_name, NULL); GRN_TEXT_SET_REF(&new_value, new_data, strlen(new_data)); } grn_ii_column_update(context, inverted_index, record_id, section, &old_value, &new_value, NULL); grn_obj_close(context, &old_value); grn_obj_close(context, &new_value); }
void test_fix_size_set_value_increment(void) { gint32 count = 29; gint32 increment_count = 5; gint32 retrieved_count; grn_obj *record_value; grn_obj *retrieved_record_value; record_value = grn_obj_open(context, GRN_BULK, 0, GRN_DB_INT32); grn_bulk_write(context, record_value, (const char *)&count, sizeof(count)); grn_test_assert(grn_obj_set_value(context, count_column, groonga_bookmark_id, record_value, GRN_OBJ_SET)); grn_obj_close(context, record_value); record_value = grn_obj_open(context, GRN_BULK, 0, GRN_DB_INT32); grn_bulk_write(context, record_value, (const char *)&increment_count, sizeof(increment_count)); grn_test_assert(grn_obj_set_value(context, count_column, groonga_bookmark_id, record_value, GRN_OBJ_INCR)); grn_obj_close(context, record_value); retrieved_record_value = grn_obj_get_value(context, count_column, groonga_bookmark_id, NULL); memcpy(&retrieved_count, GRN_BULK_HEAD(retrieved_record_value), GRN_BULK_VSIZE(retrieved_record_value)); cut_assert_equal_int(count + increment_count, retrieved_count); grn_obj_close(context, retrieved_record_value); }
MRN_API void mroonga_snippet_html_deinit(UDF_INIT *init) { MRN_DBUG_ENTER_FUNCTION(); mrn_snippet_html_info *info = reinterpret_cast<mrn_snippet_html_info *>(init->ptr); if (!info) { DBUG_VOID_RETURN; } if (info->snippet) { grn_obj_close(info->ctx, info->snippet); } if (info->query_mode.used) { if (info->query_mode.default_column) { grn_obj_close(info->ctx, info->query_mode.default_column); } if (info->query_mode.table) { grn_obj_close(info->ctx, info->query_mode.table); } } GRN_OBJ_FIN(info->ctx, &(info->result)); if (!info->use_shared_db) { grn_obj_close(info->ctx, info->db); } mrn_context_pool->release(info->ctx); my_free(info); DBUG_VOID_RETURN; }
int table_put_allocate(void) { int i; grn_obj *buf; grn_obj *key_type = grn_ctx_at(&ctx, GRN_DB_SHORT_TEXT); grn_obj *table = grn_table_create(&ctx, "<t1>", 4, NULL, GRN_OBJ_TABLE_HASH_KEY|GRN_OBJ_PERSISTENT, key_type, value_type); if (!table) { return -1; } for (i = 0; i < nloops; i++) { int key = GENKEY(i); buf = grn_obj_open(&ctx, GRN_BULK, 0, 0); grn_text_itoh(&ctx, buf, key, key_size); { grn_id rid = grn_table_add(&ctx, table, GRN_BULK_HEAD(buf), key_size, NULL); if (!rid) { fprintf(stderr, "table_lookup failed"); } else { grn_obj *value_buf; value_buf = grn_obj_open(&ctx, GRN_BULK, 0, 0); grn_text_itoh(&ctx, value_buf, key, key_size); if (grn_obj_set_value(&ctx, table, rid, value_buf, GRN_OBJ_SET)) { fprintf(stderr, "grn_obj_set_value failed"); } grn_obj_close(&ctx, value_buf); } } grn_obj_close(&ctx, buf); } return 0; }
int table_get(void) { int i; grn_obj buf; grn_obj *table = grn_ctx_get(&ctx, "<t1>", 4); if (!table) { return -1; } GRN_TEXT_INIT(&buf, 0); for (i = 0; i < nloops; i++) { int key = GENKEY(i); GRN_BULK_REWIND(&buf); grn_text_itoh(&ctx, &buf, key, key_size); { grn_id rid = grn_table_get(&ctx, table, GRN_BULK_HEAD(&buf), key_size); if (!rid) { fprintf(stderr, "table_lookup failed"); } else { grn_obj obj, *p; GRN_TEXT_INIT(&obj, 0); p = grn_obj_get_value(&ctx, table, rid, &obj); if (!p) { fprintf(stderr, "grn_obj_get_value failed\n"); } else { if (memcmp(GRN_BULK_HEAD(p), GRN_BULK_HEAD(&buf), value_size)) { fprintf(stderr, "value unmatch\n"); } grn_obj_close(&ctx, p); } } } } grn_obj_close(&ctx, &buf); return 0; }
void test_table_scan(void) { grn_obj *cond, *v, *res, textbuf, intbuf; GRN_TEXT_INIT(&textbuf, 0); GRN_UINT32_INIT(&intbuf, 0); prepare_data(&textbuf, &intbuf); cut_assert_not_null((cond = grn_expr_create(&context, NULL, 0))); v = grn_expr_add_var(&context, cond, NULL, 0); GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs)); grn_expr_append_obj(&context, cond, v); GRN_TEXT_SETS(&context, &textbuf, "size"); grn_expr_append_const(&context, cond, &textbuf); grn_expr_append_op(&context, cond, GRN_OP_OBJ_GET_VALUE, 2); GRN_UINT32_SET(&context, &intbuf, 14); grn_expr_append_const(&context, cond, &intbuf); grn_expr_append_op(&context, cond, GRN_OP_EQUAL, 2); grn_expr_compile(&context, cond); res = grn_table_create(&context, NULL, 0, NULL, GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, docs, 0); cut_assert_not_null(res); grn_test_assert(grn_table_scan(&context, docs, cond, res, GRN_SEL_OR)); cut_assert_equal_uint(3, grn_table_size(&context, res)); grn_test_assert(grn_obj_close(&context, res)); grn_test_assert(grn_obj_close(&context, cond)); grn_test_assert(grn_obj_close(&context, &textbuf)); grn_test_assert(grn_obj_close(&context, &intbuf)); }
void test_accessor(void) { int i; grn_obj *t1, *t2, *c1, *c2, r1, r2; t1 = grn_table_create(context, "t1", 2, NULL, GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, NULL); cut_assert_not_null(t1); t2 = grn_table_create(context, "t2", 2, NULL, GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, NULL); cut_assert_not_null(t2); c1 = grn_column_create(context, t1, "c1", 2, NULL, GRN_OBJ_PERSISTENT, t2); cut_assert_not_null(c1); c2 = grn_column_create(context, t2, "c2", 2, NULL, GRN_OBJ_PERSISTENT, t1); cut_assert_not_null(c2); GRN_RECORD_INIT(&r1, 0, grn_obj_id(context, t1)); GRN_RECORD_INIT(&r2, 0, grn_obj_id(context, t2)); for (i = 0; i < NRECORDS; i++) { grn_id i1, i2; i1 = grn_table_add(context, t1, NULL, 0, NULL); i2 = grn_table_add(context, t2, NULL, 0, NULL); GRN_RECORD_SET(context, &r1, i1); GRN_RECORD_SET(context, &r2, i2); grn_obj_set_value(context, c1, i1, &r2, GRN_OBJ_SET); grn_obj_set_value(context, c2, i2, &r1, GRN_OBJ_SET); } { grn_id id; uint64_t et; int nerr = 0; struct timeval tvb, tve; grn_obj *a = grn_obj_column(context, t1, "c1.c2.c1", 8); grn_table_cursor *tc = grn_table_cursor_open(context, t1, NULL, 0, NULL, 0, 0, -1, 0); cut_assert_not_null(a); cut_assert_not_null(tc); gettimeofday(&tvb, NULL); while ((id = grn_table_cursor_next(context, tc))) { GRN_BULK_REWIND(&r2); grn_obj_get_value(context, a, id, &r2); if (GRN_RECORD_VALUE(&r2) != id) { nerr++; } } gettimeofday(&tve, NULL); et = (tve.tv_sec - tvb.tv_sec) * 1000000 + (tve.tv_usec - tvb.tv_usec); // printf("et=%zu\n", et); cut_assert_equal_uint(0, nerr); grn_test_assert(grn_table_cursor_close(context, tc)); grn_test_assert(grn_obj_close(context, a)); } grn_test_assert(grn_obj_close(context, &r1)); grn_test_assert(grn_obj_close(context, &r2)); }
static grn_bool exec_text_operator_raw_text_raw_text(grn_ctx *ctx, grn_operator op, const char *target, unsigned int target_len, const char *query, unsigned int query_len) { grn_obj *normalizer; grn_obj *norm_target; grn_obj *norm_query; const char *norm_target_raw; const char *norm_query_raw; unsigned int norm_target_raw_length_in_bytes; unsigned int norm_query_raw_length_in_bytes; grn_bool matched = GRN_FALSE; if (target_len == 0 || query_len == 0) { return GRN_FALSE; } normalizer = grn_ctx_get(ctx, GRN_NORMALIZER_AUTO_NAME, -1); norm_target = grn_string_open(ctx, target, target_len, normalizer, 0); grn_string_get_normalized(ctx, norm_target, &norm_target_raw, &norm_target_raw_length_in_bytes, NULL); if (op == GRN_OP_REGEXP) { norm_query = NULL; norm_query_raw = query; norm_query_raw_length_in_bytes = query_len; } else { norm_query = grn_string_open(ctx, query, query_len, normalizer, 0); grn_string_get_normalized(ctx, norm_query, &norm_query_raw, &norm_query_raw_length_in_bytes, NULL); } matched = exec_text_operator(ctx, op, norm_target_raw, norm_target_raw_length_in_bytes, norm_query_raw, norm_query_raw_length_in_bytes); grn_obj_close(ctx, norm_target); if (norm_query) { grn_obj_close(ctx, norm_query); } grn_obj_unlink(ctx, normalizer); return matched; }
void cut_teardown(void) { grn_obj_close(context, &textbuf); grn_obj_close(context, &intbuf); if (expr) grn_obj_close(context, expr); grn_db_close(context, database); grn_ctx_fin(context); g_free(context); cut_remove_path(tmp_directory, NULL); g_free(path); }
void cut_teardown(void) { if (context) { inverted_index_free(); if (path) grn_ii_remove(context, path); grn_obj_close(context, db); grn_ctx_fin(context); g_free(context); } if (path) { g_free(path); path = NULL; } remove_tmp_directory(); record_ids_free(); expected_messages_free(); teardown_grn_logger(logger); }
/* It should be renamed to grn_snip_close() and marked as internal. * TODO: 3.0 */ grn_rc grn_snip_close_real(grn_ctx *ctx, grn_snip *snip) { snip_cond *cond, *cond_end; if (!snip) { return GRN_INVALID_ARGUMENT; } GRN_API_ENTER; if (snip->flags & GRN_SNIP_COPY_TAG) { int i; snip_cond *sc; const char *dot = snip->defaultopentag, *dct = snip->defaultclosetag; for (i = snip->cond_len, sc = snip->cond; i; i--, sc++) { if (sc->opentag != dot) { GRN_FREE((void *)sc->opentag); } if (sc->closetag != dct) { GRN_FREE((void *)sc->closetag); } } if (dot) { GRN_FREE((void *)dot); } if (dct) { GRN_FREE((void *)dct); } } if (snip->nstr) { grn_obj_close(ctx, snip->nstr); } for (cond = snip->cond, cond_end = cond + snip->cond_len; cond < cond_end; cond++) { grn_snip_cond_close(ctx, cond); } GRN_FREE(snip); GRN_API_RETURN(GRN_SUCCESS); }
void test_score_set(void) { grn_obj *v, *res2; prepare_data(); GRN_EXPR_CREATE_FOR_QUERY(&context, docs, cond, v); cut_assert_not_null(cond); cut_assert_not_null(v); PARSE(cond, "size:>0", GRN_EXPR_SYNTAX_QUERY|GRN_EXPR_ALLOW_PRAGMA|GRN_EXPR_ALLOW_COLUMN); res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR); cut_assert_not_null(res); grn_test_assert_select_all(res); grn_test_assert(grn_obj_close(&context, cond)); cond = NULL; GRN_EXPR_CREATE_FOR_QUERY(&context, res, expr, v); PARSE(expr, "_score = size", GRN_EXPR_SYNTAX_SCRIPT|GRN_EXPR_ALLOW_UPDATE); GRN_TABLE_EACH(&context, res, 0, 0, id, NULL, 0, NULL, { GRN_RECORD_SET(&context, v, id); grn_expr_exec(&context, expr, 0); });
void teardown (void) { GRN_OBJ_FIN(&context, &buffer); grn_obj_close(&context, database); grn_ctx_fin(&context); }
grn_obj * grn_string_open_(grn_ctx *ctx, const char *str, unsigned int str_len, grn_obj *normalizer, int flags, grn_encoding encoding) { grn_string *string; grn_obj *obj; grn_bool is_normalizer_auto; if (!str || !str_len) { return NULL; } is_normalizer_auto = (normalizer == GRN_NORMALIZER_AUTO); if (is_normalizer_auto) { normalizer = grn_ctx_get(ctx, GRN_NORMALIZER_AUTO_NAME, -1); if (!normalizer) { ERR(GRN_INVALID_ARGUMENT, "[string][open] NormalizerAuto normalizer isn't available"); return NULL; } } string = GRN_MALLOCN(grn_string, 1); if (!string) { if (is_normalizer_auto) { grn_obj_unlink(ctx, normalizer); } GRN_LOG(ctx, GRN_LOG_ALERT, "[string][open] failed to allocate memory"); return NULL; } obj = (grn_obj *)string; GRN_OBJ_INIT(obj, GRN_STRING, GRN_OBJ_ALLOCATED, GRN_ID_NIL); string->original = str; string->original_length_in_bytes = str_len; string->normalized = NULL; string->normalized_length_in_bytes = 0; string->n_characters = 0; string->checks = NULL; string->ctypes = NULL; string->encoding = encoding; string->flags = flags; if (!normalizer) { return (grn_obj *)grn_fake_string_open(ctx, string); } grn_normalizer_normalize(ctx, normalizer, (grn_obj *)string); if (ctx->rc) { grn_obj_close(ctx, obj); obj = NULL; } if (is_normalizer_auto) { grn_obj_unlink(ctx, normalizer); } return obj; }
grn_rc grn_index_close(grn_ctx *ctx, grn_index *index) { grn_obj_close(ctx, index->db); free(index); return ctx->rc; }
/* * Normalizes the @string@. * * @example * # Normalizes "ABC" with the default normalizer * Groonga::Normalizer.normalize("AbC") # => "abc" * * @overload normalize(string) * @return [String] The normalized string * @param [String] string The original string */ static VALUE rb_grn_normalizer_s_normalize (VALUE klass, VALUE rb_string) { VALUE rb_context = Qnil; VALUE rb_encoded_string; VALUE rb_normalized_string; grn_ctx *context = NULL; grn_obj *grn_string; grn_obj *normalizer = GRN_NORMALIZER_AUTO; /* TODO: make customizable */ int flags = GRN_STRING_REMOVE_BLANK; const char *normalized_string; unsigned int normalized_string_length; context = rb_grn_context_ensure(&rb_context); rb_encoded_string = rb_grn_context_rb_string_encode(context, rb_string); grn_string = grn_string_open(context, RSTRING_PTR(rb_encoded_string), RSTRING_LEN(rb_encoded_string), normalizer, flags); rb_grn_context_check(context, rb_string); grn_string_get_normalized(context, grn_string, &normalized_string, &normalized_string_length, NULL); rb_normalized_string = rb_grn_context_rb_string_new(context, normalized_string, normalized_string_length); grn_obj_close(context, grn_string); return rb_normalized_string; }
static void grn_tokenizer_query_ensure_normalized(grn_ctx *ctx, grn_tokenizer_query *query) { if (!query->need_normalize) { return; } query->need_normalize = GRN_FALSE; if (query->normalized_query) { grn_obj_close(ctx, query->normalized_query); } query->normalized_query = grn_string_open_(ctx, query->ptr, query->length, query->lexicon, query->normalize_flags, query->encoding); if (!query->normalized_query) { query->have_tokenized_delimiter = GRN_FALSE; GRN_PLUGIN_ERROR(ctx, GRN_TOKENIZER_ERROR, "[tokenizer][normalize] failed to open normalized string"); return; } query->need_delimiter_check = GRN_TRUE; }
grn_rc grn_ctx_fin(grn_ctx *ctx) { grn_rc rc = GRN_SUCCESS; if (!ctx) { return GRN_INVALID_ARGUMENT; } if (ctx->stat == GRN_CTX_FIN) { return GRN_INVALID_ARGUMENT; } if (!(ctx->flags & GRN_CTX_ALLOCATED)) { CRITICAL_SECTION_ENTER(grn_glock); ctx->next->prev = ctx->prev; ctx->prev->next = ctx->next; CRITICAL_SECTION_LEAVE(grn_glock); } if (ctx->impl) { grn_ctx_impl_clear_n_same_error_messagges(ctx); if (ctx->impl->finalizer) { ctx->impl->finalizer(ctx, 0, NULL, &(ctx->user_data)); } grn_ctx_impl_mrb_fin(ctx); grn_ctx_loader_clear(ctx); if (ctx->impl->parser) { grn_expr_parser_close(ctx); } GRN_OBJ_FIN(ctx, &ctx->impl->current_request_id); if (ctx->impl->values) { #ifndef USE_MEMORY_DEBUG grn_db_obj *o; GRN_ARRAY_EACH(ctx, ctx->impl->values, 0, 0, id, &o, { grn_obj_close(ctx, *((grn_obj **)o)); });
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(); }
static int run(grn_ctx *ctx, const char *db_path, const char *ruby_script_path) { grn_obj *db; db = grn_db_open(ctx, db_path); if (!db) { if (ctx->rc == GRN_NO_SUCH_FILE_OR_DIRECTORY) { db = grn_db_create(ctx, db_path, NULL); if (!db) { fprintf(stderr, "Failed to create database: <%s>: %s", db_path, ctx->errbuf); return EXIT_FAILURE; } } else { fprintf(stderr, "Failed to open database: <%s>: %s", db_path, ctx->errbuf); return EXIT_FAILURE; } } grn_mrb_load(ctx, ruby_script_path); if (ctx->rc != GRN_SUCCESS) { fprintf(stderr, "Failed to load Ruby script: <%s>: %s", ruby_script_path, ctx->errbuf); } grn_obj_close(ctx, db); if (ctx->rc == GRN_SUCCESS) { return EXIT_SUCCESS; } else { return EXIT_FAILURE; } }
void grn_output_geo_point(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type, grn_geo_point *value) { put_delimiter(ctx, outbuf, output_type); switch (output_type) { case GRN_CONTENT_JSON: if (value) { GRN_TEXT_PUTC(ctx, outbuf, '"'); grn_text_itoa(ctx, outbuf, value->latitude); GRN_TEXT_PUTC(ctx, outbuf, 'x'); grn_text_itoa(ctx, outbuf, value->longitude); GRN_TEXT_PUTC(ctx, outbuf, '"'); } else { GRN_TEXT_PUTS(ctx, outbuf, "null"); } break; case GRN_CONTENT_TSV: if (value) { GRN_TEXT_PUTC(ctx, outbuf, '"'); grn_text_itoa(ctx, outbuf, value->latitude); GRN_TEXT_PUTC(ctx, outbuf, 'x'); grn_text_itoa(ctx, outbuf, value->longitude); GRN_TEXT_PUTC(ctx, outbuf, '"'); } else { GRN_TEXT_PUTS(ctx, outbuf, "\"\""); } break; case GRN_CONTENT_XML: GRN_TEXT_PUTS(ctx, outbuf, "<GEO_POINT>"); if (value) { grn_text_itoa(ctx, outbuf, value->latitude); GRN_TEXT_PUTC(ctx, outbuf, 'x'); grn_text_itoa(ctx, outbuf, value->longitude); } GRN_TEXT_PUTS(ctx, outbuf, "</GEO_POINT>"); break; case GRN_CONTENT_MSGPACK : #ifdef HAVE_MESSAGE_PACK if (value) { grn_obj buf; GRN_TEXT_INIT(&buf, 0); grn_text_itoa(ctx, &buf, value->latitude); GRN_TEXT_PUTC(ctx, &buf, 'x'); grn_text_itoa(ctx, &buf, value->longitude); msgpack_pack_raw(&ctx->impl->msgpacker, GRN_TEXT_LEN(&buf)); msgpack_pack_raw_body(&ctx->impl->msgpacker, GRN_TEXT_VALUE(&buf), GRN_TEXT_LEN(&buf)); grn_obj_close(ctx, &buf); } else { msgpack_pack_nil(&ctx->impl->msgpacker); } #endif break; case GRN_CONTENT_NONE: break; } INCR_LENGTH; }
int pat_put(const char *path) { int i; grn_obj buf; grn_pat *pat = grn_pat_create(&ctx, path, key_size, value_size, GRN_OBJ_PERSISTENT|GRN_OBJ_KEY_VAR_SIZE); if (!pat) { return -1; } GRN_TEXT_INIT(&buf, 0); for (i = 0; i < nloops; i++) { int key = GENKEY(i); GRN_BULK_REWIND(&buf); grn_text_itoh(&ctx, &buf, key, key_size); { void *value; grn_id rid = grn_pat_add(&ctx, pat, GRN_BULK_HEAD(&buf), key_size, &value, NULL); if (!rid) { fprintf(stderr, "table_lookup failed"); } else { memcpy(value, GRN_BULK_HEAD(&buf), value_size); } } } grn_obj_close(&ctx, &buf); grn_pat_close(&ctx, pat); return 0; }
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); }
int pat_get(const char *path) { int i; grn_obj buf; grn_pat *pat = grn_pat_open(&ctx, path); if (!pat) { return -1; } GRN_TEXT_INIT(&buf, 0); for (i = 0; i < nloops; i++) { int key = GENKEY(i); GRN_BULK_REWIND(&buf); grn_text_itoh(&ctx, &buf, key, key_size); { void *value; grn_id rid = grn_pat_get(&ctx, pat, GRN_BULK_HEAD(&buf), key_size, &value); if (!rid) { fprintf(stderr, "table_lookup failed"); } else { if (memcmp(value, GRN_BULK_HEAD(&buf), value_size)) { fprintf(stderr, "value unmatch %d: %d != %d\n", i, *((int *)value), key); } } } } grn_obj_close(&ctx, &buf); grn_pat_close(&ctx, pat); return 0; }
grn_rc grn_msg_close(grn_ctx *ctx, grn_obj *obj) { grn_msg *msg = (grn_msg *)obj; if (ctx == msg->ctx) { return grn_obj_close(ctx, obj); } return grn_com_queue_enque(ctx, msg->old, (grn_com_queue_entry *)msg); }
static void teardown_database(void) { grn_obj_close(&context, database); cut_remove_path(tmp_directory, NULL); g_free(tmp_directory); }
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)); }
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_close(context, database); database = NULL; remove_tmp_directory(); g_mkdir_with_parents(tmp_directory, 0700); } grn_ctx_fin(context); g_free(context); context = NULL; }
static void bench_shutdown(BenchmarkData *data) { grn_ctx *context = &(data->context); grn_obj_close(context, data->database); grn_ctx_fin(context); }
void cut_teardown(void) { grn_obj_close(context, database); grn_ctx_fin(context); g_free(context); teardown_grn_logger(logger); }