const GList * grn_test_table_collect_string(grn_ctx *context, grn_obj *table, const gchar *text_column_name) { GList *records = NULL; grn_table_cursor *cursor; grn_id id; grn_obj *text_column; grn_obj value; cursor = grn_table_cursor_open(context, table, NULL, 0, NULL, 0, 0, -1, GRN_CURSOR_ASCENDING); grn_test_assert_context(context); text_column = grn_obj_column(context, table, text_column_name, strlen(text_column_name)); GRN_TEXT_INIT(&value, 0); while ((id = grn_table_cursor_next(context, cursor)) != GRN_ID_NIL) { GRN_BULK_REWIND(&value); grn_obj_get_value(context, text_column, id, &value); records = g_list_append(records, g_strndup(GRN_TEXT_VALUE(&value), GRN_TEXT_LEN(&value))); } grn_obj_unlink(context, &value); grn_obj_unlink(context, text_column); gcut_take_list(records, g_free); grn_test_assert(grn_table_cursor_close(context, cursor)); grn_test_assert_context(context); return records; }
void test_array_set_data(void) { grn_obj *table; grn_id record_id; gchar value[] = "sample value"; grn_obj *record_value; grn_obj *retrieved_record_value; const gchar *dupped_retrieved_record_value; const gchar *value_type_name = "value_type"; grn_obj *value_type; value_type = grn_type_create(context, value_type_name, strlen(value_type_name), 0, sizeof(value)); table = grn_table_create(context, NULL, 0, NULL, GRN_OBJ_TABLE_NO_KEY, NULL, value_type); record_id = grn_table_add(context, table, NULL, 0, NULL); record_value = grn_obj_open(context, GRN_BULK, 0, GRN_DB_TEXT); grn_bulk_write(context, record_value, value, sizeof(value)); grn_test_assert(grn_obj_set_value(context, table, record_id, record_value, GRN_OBJ_SET)); grn_obj_unlink(context, record_value); retrieved_record_value = grn_obj_get_value(context, table, record_id, NULL); dupped_retrieved_record_value = cut_take_strdup(GRN_BULK_HEAD(retrieved_record_value)); grn_obj_unlink(context, retrieved_record_value); cut_assert_equal_string(value, dupped_retrieved_record_value); }
const GList * grn_test_view_collect_string(grn_ctx *context, grn_obj *view, const gchar *text_column_name) { GList *records = NULL; grn_table_cursor *cursor; grn_obj id, value; grn_obj *text_column; cursor = grn_table_cursor_open(context, view, NULL, 0, NULL, 0, 0, -1, GRN_CURSOR_ASCENDING); cut_assert_not_null(cursor); GRN_TEXT_INIT(&id, 0); GRN_TEXT_INIT(&value, 0); text_column = grn_obj_column(context, view, text_column_name, strlen(text_column_name)); while (grn_table_cursor_next_o(context, cursor, &id) == GRN_SUCCESS) { GRN_BULK_REWIND(&value); grn_obj_get_value_o(context, text_column, &id, &value); records = g_list_append(records, g_strndup(GRN_TEXT_VALUE(&value), GRN_TEXT_LEN(&value))); } grn_obj_unlink(context, &id); grn_obj_unlink(context, &value); grn_obj_unlink(context, text_column); gcut_take_list(records, g_free); grn_test_assert(grn_table_cursor_close(context, cursor)); grn_test_assert_context(context); return records; }
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); } }
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; }
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(); }
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; }
static grn_rc grn_table_inspect(grn_ctx *ctx, grn_obj *buf, grn_obj *obj) { grn_hash *cols; grn_id range_id; grn_obj *range; GRN_TEXT_PUTS(ctx, buf, "#<table:"); grn_table_type_inspect(ctx, buf, obj); GRN_TEXT_PUTS(ctx, buf, " "); grn_inspect_name(ctx, buf, obj); if (obj->header.type != GRN_TABLE_NO_KEY) { grn_obj *domain; grn_id domain_id; GRN_TEXT_PUTS(ctx, buf, " key:"); domain_id = obj->header.domain; domain = grn_ctx_at(ctx, domain_id); if (domain) { grn_inspect_name(ctx, buf, domain); grn_obj_unlink(ctx, domain); } else if (domain_id) { grn_text_lltoa(ctx, buf, domain_id); } else { GRN_TEXT_PUTS(ctx, buf, "(nil)"); } } GRN_TEXT_PUTS(ctx, buf, " value:"); range_id = grn_obj_get_range(ctx, obj); range = grn_ctx_at(ctx, range_id); if (range) { grn_inspect_name(ctx, buf, range); } else if (range_id) { grn_text_lltoa(ctx, buf, range_id); } else { GRN_TEXT_PUTS(ctx, buf, "(nil)"); } GRN_TEXT_PUTS(ctx, buf, " size:"); grn_text_lltoa(ctx, buf, grn_table_size(ctx, obj)); GRN_TEXT_PUTS(ctx, buf, " columns:["); if ((cols = grn_hash_create(ctx, NULL, sizeof(grn_id), 0, GRN_OBJ_TABLE_HASH_KEY|GRN_HASH_TINY))) { if (grn_table_columns(ctx, obj, "", 0, (grn_obj *)cols)) { int i = 0; grn_id *key; GRN_HASH_EACH(ctx, cols, id, &key, NULL, NULL, { grn_obj *col = grn_ctx_at(ctx, *key); if (col) { if (i++ > 0) { GRN_TEXT_PUTS(ctx, buf, ", "); } grn_column_name_(ctx, col, buf); grn_obj_unlink(ctx, col); } }); }
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); } }
static grn_obj * command_tag_synonym_delete(grn_ctx *ctx, GNUC_UNUSED int nargs, GNUC_UNUSED grn_obj **args, grn_user_data *user_data) { grn_obj *var, *table, *column; unsigned int nhooks = 0; char *table_name = NULL; unsigned int table_len = 0; char *column_name = NULL; unsigned int column_len = 0; var = grn_plugin_proc_get_var(ctx, user_data, "table", -1); if (GRN_TEXT_LEN(var) != 0) { table_name = GRN_TEXT_VALUE(var); table_len = GRN_TEXT_LEN(var); } var = grn_plugin_proc_get_var(ctx, user_data, "column", -1); if (GRN_TEXT_LEN(var) != 0) { column_name = GRN_TEXT_VALUE(var); column_len = GRN_TEXT_LEN(var); } table = grn_ctx_get(ctx, table_name, table_len); column = grn_obj_column(ctx, table, column_name, column_len); nhooks = grn_obj_get_nhooks(ctx, column, GRN_HOOK_SET); if (nhooks) { grn_obj *hook; unsigned int i; grn_obj data; grn_obj buf; GRN_TEXT_INIT(&buf, 0); GRN_TEXT_INIT(&data, 0); for (i=0; i < nhooks; i++) { GRN_BULK_REWIND(&buf); GRN_BULK_REWIND(&data); hook = grn_obj_get_hook(ctx, column, GRN_HOOK_SET, i, &data); grn_inspect_name(ctx, &buf, hook); if (GRN_TEXT_LEN(&buf) == strlen("tag_synonym") && strncmp(GRN_TEXT_VALUE(&buf), "tag_synonym", GRN_TEXT_LEN(&buf)) == 0) { grn_obj_delete_hook(ctx, column, GRN_HOOK_SET, i); break; } } grn_obj_unlink(ctx, &data); grn_obj_unlink(ctx, &buf); } nhooks = grn_obj_get_nhooks(ctx, column, GRN_HOOK_SET); //grn_ctx_output_array_open(ctx, "RESULT", 1); grn_ctx_output_int32(ctx, nhooks); //grn_ctx_output_array_close(ctx); return NULL; }
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(); }
void rb_grn_index_column_finalizer (grn_ctx *context, grn_obj *object, RbGrnIndexColumn *rb_grn_index_column) { if (!context) return; grn_obj_unlink(context, rb_grn_index_column->id_query); grn_obj_unlink(context, rb_grn_index_column->string_query); grn_obj_unlink(context, rb_grn_index_column->old_value); rb_grn_column_finalizer(context, object, RB_GRN_COLUMN(rb_grn_index_column)); }
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(); }
/* * Document-method: reference? * * call-seq: * column.reference? -> true/false * * _column_ の値がテーブルのレコードとなる場合は +true+ を返し、 * そうでない場合は +false+ を返す。 * * @since 1.0.5 */ static VALUE rb_grn_column_reference_p (VALUE self) { grn_ctx *context; grn_obj *column; grn_id range_id; grn_obj *range; unsigned short int type; rb_grn_column_deconstruct(SELF(self), &column, &context, NULL, NULL, NULL, NULL, NULL); range_id = grn_obj_get_range(context, column); range = grn_ctx_at(context, range_id); type = range->header.type; grn_obj_unlink(context, range); switch (type) { case GRN_TABLE_HASH_KEY: case GRN_TABLE_PAT_KEY: case GRN_TABLE_NO_KEY: return Qtrue; default: return Qfalse; } }
void cut_teardown(void) { if (cursor) { grn_obj_unlink(context, cursor); } if (table) { grn_obj_unlink(context, table); } if (context) { grn_ctx_fin(context); g_free(context); } }
void test_remove_tokenized_delimiter(gconstpointer data) { grn_obj *string; grn_obj *normalizer = NULL; const gchar *expected; const gchar *input; const gchar *normalized; unsigned int length_in_bytes; int flags = GRN_STRING_REMOVE_TOKENIZED_DELIMITER; GRN_CTX_SET_ENCODING(&context, GRN_ENC_UTF8); input = gcut_data_get_string(data, "input"); flags |= gcut_data_get_int(data, "flags"); if (flags & GRN_OBJ_KEY_NORMALIZE) { normalizer = GRN_NORMALIZER_AUTO; } string = grn_string_open(&context, input, strlen(input), normalizer, flags); grn_string_get_normalized(&context, string, &normalized, &length_in_bytes, NULL); normalized = cut_take_strndup(normalized, length_in_bytes); grn_obj_unlink(&context, string); expected = gcut_data_get_string(data, "expected"); cut_assert_equal_string(expected, normalized); }
void test_normalize_broken(gconstpointer data) { grn_obj *string; const gchar *input, *encoded_input; const gchar *normalized_text; grn_encoding input_encoding, context_encoding; gint input_length; guint normalized_text_length, normalized_text_n_characters; int flags = GRN_STRING_WITH_CHECKS | GRN_STRING_WITH_TYPES; context_encoding = gcut_data_get_int(data, "context-encoding"); GRN_CTX_SET_ENCODING(&context, context_encoding); input = gcut_data_get_string(data, "input"); input_encoding = gcut_data_get_int(data, "input-encoding"); input_length = gcut_data_get_int(data, "input-length"); encoded_input = convert_encoding(input, input_encoding); if (input_length < 0) { input_length = strlen(encoded_input); } string = grn_string_open(&context, encoded_input, input_length, GRN_NORMALIZER_AUTO, flags); grn_string_get_normalized(&context, string, &normalized_text, &normalized_text_length, &normalized_text_n_characters); normalized_text = cut_take_strndup(normalized_text, normalized_text_length); grn_obj_unlink(&context, string); cut_assert_equal_string("", normalized_text); cut_assert_equal_int(0, normalized_text_length); cut_assert_equal_int(0, normalized_text_n_characters); }
static grn_obj * proc_table_create(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data) { uint32_t nvars; grn_obj *buf = args[0]; grn_expr_var *vars; grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL); if (nvars == 6) { grn_obj *table; grn_obj_flags flags = grn_atoi(GRN_TEXT_VALUE(&vars[1].value), GRN_BULK_CURR(&vars[1].value), NULL); if (GRN_TEXT_LEN(&vars[0].value)) { flags |= GRN_OBJ_PERSISTENT; } table = grn_table_create(ctx, GRN_TEXT_VALUE(&vars[0].value), GRN_TEXT_LEN(&vars[0].value), NULL, flags, grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[2].value), GRN_TEXT_LEN(&vars[2].value)), grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[3].value), GRN_TEXT_LEN(&vars[3].value))); if (table) { grn_obj_set_info(ctx, table, GRN_INFO_DEFAULT_TOKENIZER, grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[4].value), GRN_TEXT_LEN(&vars[4].value))); grn_obj_unlink(ctx, table); } GRN_TEXT_PUTS(ctx, buf, ctx->rc ? "false" : "true"); } return buf; }
VALUE rb_grn_context_to_exception (grn_ctx *context, VALUE related_object) { VALUE exception, exception_class; const char *message; grn_obj bulk; if (context->rc == GRN_SUCCESS) return Qnil; exception_class = rb_grn_rc_to_exception(context->rc); message = rb_grn_rc_to_message(context->rc); GRN_OBJ_INIT(&bulk, GRN_BULK, 0, GRN_ID_NIL); GRN_TEXT_PUTS(context, &bulk, message); GRN_TEXT_PUTS(context, &bulk, ": "); GRN_TEXT_PUTS(context, &bulk, context->errbuf); if (!NIL_P(related_object)) { GRN_TEXT_PUTS(context, &bulk, ": "); GRN_TEXT_PUTS(context, &bulk, rb_grn_inspect(related_object)); } GRN_TEXT_PUTS(context, &bulk, "\n"); GRN_TEXT_PUTS(context, &bulk, context->errfile); GRN_TEXT_PUTS(context, &bulk, ":"); grn_text_itoa(context, &bulk, context->errline); GRN_TEXT_PUTS(context, &bulk, ": "); GRN_TEXT_PUTS(context, &bulk, context->errfunc); GRN_TEXT_PUTS(context, &bulk, "()"); exception = rb_funcall(exception_class, rb_intern("new"), 1, rb_str_new(GRN_BULK_HEAD(&bulk), GRN_BULK_VSIZE(&bulk))); grn_obj_unlink(context, &bulk); return exception; }
void cut_shutdown() { grn_obj_unlink(ctx, db); grn_ctx_fin(ctx); grn_fin(); free(ctx); }
/* * call-seq: * column.sources -> Groonga::Columnの配列 * * インデックス対象となっているカラムの配列を返す。 */ static VALUE rb_grn_index_column_get_sources (VALUE self) { grn_ctx *context = NULL; grn_obj *column; grn_obj sources; grn_id *source_ids; VALUE rb_sources; int i, n; rb_grn_index_column_deconstruct(SELF(self), &column, &context, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); GRN_OBJ_INIT(&sources, GRN_BULK, 0, GRN_ID_NIL); grn_obj_get_info(context, column, GRN_INFO_SOURCE, &sources); rb_grn_context_check(context, self); n = GRN_BULK_VSIZE(&sources) / sizeof(grn_id); source_ids = (grn_id *)GRN_BULK_HEAD(&sources); rb_sources = rb_ary_new2(n); for (i = 0; i < n; i++) { grn_obj *source; VALUE rb_source; source = grn_ctx_at(context, *source_ids); rb_source = GRNOBJECT2RVAL(Qnil, context, source, RB_GRN_FALSE); rb_ary_push(rb_sources, rb_source); source_ids++; } grn_obj_unlink(context, &sources); return rb_sources; }
/* * Document-method: column_value * * call-seq: * view.column_value(id, name) -> 値 * * _view_の_id_に対応するカラム_name_の値を返す。 */ static VALUE rb_grn_view_get_column_value (VALUE self, VALUE rb_id, VALUE rb_name) { VALUE rb_value = Qnil; #ifdef WIN32 rb_raise(rb_eNotImpError, "grn_obj_get_value_o() isn't available on Windows."); #else RbGrnTable *rb_view; grn_ctx *context = NULL; grn_obj *view, *value, *accessor; grn_obj id; rb_view = SELF(self); rb_grn_table_deconstruct(rb_view, &view, &context, NULL, NULL, &value, NULL, NULL, NULL); GRN_BULK_REWIND(value); GRN_TEXT_INIT(&id, 0); GRN_TEXT_PUT(context, &id, RSTRING_PTR(rb_id), RSTRING_LEN(rb_id)); accessor = grn_obj_column(context, view, RSTRING_PTR(rb_name), RSTRING_LEN(rb_name)); grn_obj_get_value_o(context, accessor, &id, value); grn_obj_unlink(context, accessor); rb_value = GRNOBJ2RVAL(Qnil, context, value, self); GRN_OBJ_FIN(context, &id); #endif return rb_value; }
/* * 既存のデータベースを開く。ブロックを指定した場合はブロッ * クに開いたデータベースを渡し、ブロックを抜けるときに閉じ * る。 * * @overload new(path, options=nil) * @!macro [new] database.new.arguments * @param options [::Hash] The name and value * pairs. Omitted names are initialized as the default value. * @option options :context (Groonga::Context.default) * データベースを結びつけるコンテキスト。省略すると * {Groonga::Context.default} を利用する。 * @!macro database.new.arguments * @return [Groonga::Database] * @overload new(path, options=nil) * @!macro database.new.arguments * @yield [database] * @yieldparam [Groonga::Database] database 開いたデータベース */ static VALUE rb_grn_database_initialize (int argc, VALUE *argv, VALUE self) { grn_ctx *context; grn_obj *old_database, *database; const char *path; VALUE rb_path, options, rb_context; rb_scan_args(argc, argv, "11", &rb_path, &options); path = StringValuePtr(rb_path); rb_grn_scan_options(options, "context", &rb_context, NULL); context = rb_grn_context_ensure(&rb_context); old_database = grn_ctx_db(context); if (old_database) grn_obj_unlink(context, old_database); reset_floating_objects(rb_context); database = grn_db_open(context, path); rb_grn_object_assign(Qnil, self, rb_context, context, database); rb_grn_context_check(context, self); rb_iv_set(self, "@context", rb_context); if (!NIL_P(rb_context)) rb_iv_set(rb_context, "database", self); return Qnil; }
void test_cursor(gconstpointer data) { GList *expected, *records = NULL; gint offset, limit; grn_obj *geo_cursor; grn_posting *posting; offset = gcut_data_get_int(data, "offset"); limit = gcut_data_get_int(data, "limit"); geo_cursor = grn_geo_cursor_open_in_rectangle(context, location_index, nerima_wgs84, tokyo_wgs84, offset, limit); while ((posting = grn_geo_cursor_next(context, geo_cursor))) { grn_id shop_id = posting->rid; gchar key[GRN_TABLE_MAX_KEY_SIZE]; gint key_size; key_size = grn_table_get_key(context, shops, shop_id, &key, GRN_TABLE_MAX_KEY_SIZE); records = g_list_append(records, g_strndup(key, key_size)); } grn_obj_unlink(context, geo_cursor); expected = (GList *)gcut_data_get_pointer(data, "expected"); gcut_take_list(records, g_free); gcut_assert_equal_list_string(expected, records); }
/* * _constant_ を追加し、 _n_arguments_ 個の引数を取る _operation_ を追加する。 * * @overload append_constant(constant, operation=Groonga::Operator::PUSH, n_arguments=1) * @param [Object] constant 追加する _constant_ * @param [Groonga::Operator::XXX] operation 追加する _operation_ * @param [Integer] n_arguments _operation_ の取る引数 * @return [Self] self */ static VALUE rb_grn_expression_append_constant (int argc, VALUE *argv, VALUE self) { VALUE rb_constant, rb_operator, rb_n_arguments; VALUE exception; grn_ctx *context = NULL; grn_obj *expression, *constant = NULL; grn_operator operator = GRN_OP_PUSH; int n_arguments = 1; rb_scan_args(argc, argv, "12", &rb_constant, &rb_operator, &rb_n_arguments); if (!NIL_P(rb_operator)) operator = RVAL2GRNOPERATOR(rb_operator); if (!NIL_P(rb_n_arguments)) n_arguments = NUM2INT(rb_n_arguments); rb_grn_expression_deconstruct(SELF(self), &expression, &context, NULL, NULL, NULL, NULL, NULL); RVAL2GRNOBJ(rb_constant, context, &constant); grn_expr_append_const(context, expression, constant, operator, n_arguments); exception = rb_grn_context_to_exception(context, self); grn_obj_unlink(context, constant); if (!NIL_P(exception)) rb_exc_raise(exception); return self; }
void grn_ctx_loader_clear(grn_ctx *ctx) { grn_loader *loader = &ctx->impl->loader; grn_obj *v = (grn_obj *)(GRN_BULK_HEAD(&loader->values)); grn_obj *ve = (grn_obj *)(GRN_BULK_CURR(&loader->values)); grn_obj **p = (grn_obj **)GRN_BULK_HEAD(&loader->columns); uint32_t i = GRN_BULK_VSIZE(&loader->columns) / sizeof(grn_obj *); if (ctx->impl->db) { while (i--) { grn_obj_unlink(ctx, *p++); } } if (loader->ifexists) { grn_obj_unlink(ctx, loader->ifexists); } if (loader->each) { grn_obj_unlink(ctx, loader->each); } while (v < ve) { GRN_OBJ_FIN(ctx, v++); } GRN_OBJ_FIN(ctx, &loader->values); GRN_OBJ_FIN(ctx, &loader->level); GRN_OBJ_FIN(ctx, &loader->columns); grn_loader_init(loader); }
static grn_obj * func_highlight_html_create_keywords_table(grn_ctx *ctx, grn_obj *expression) { grn_obj *keywords; grn_obj *condition_ptr = NULL; grn_obj *condition = NULL; keywords = grn_table_create(ctx, NULL, 0, NULL, GRN_OBJ_TABLE_PAT_KEY, grn_ctx_at(ctx, GRN_DB_SHORT_TEXT), NULL); { grn_obj *normalizer; normalizer = grn_ctx_get(ctx, "NormalizerAuto", -1); grn_obj_set_info(ctx, keywords, GRN_INFO_NORMALIZER, normalizer); grn_obj_unlink(ctx, normalizer); } condition_ptr = grn_expr_get_var(ctx, expression, GRN_SELECT_INTERNAL_VAR_CONDITION, strlen(GRN_SELECT_INTERNAL_VAR_CONDITION)); if (condition_ptr) { condition = GRN_PTR_VALUE(condition_ptr); } if (condition) { size_t i, n_keywords; grn_obj current_keywords; GRN_PTR_INIT(¤t_keywords, GRN_OBJ_VECTOR, GRN_ID_NIL); grn_expr_get_keywords(ctx, condition, ¤t_keywords); n_keywords = GRN_BULK_VSIZE(¤t_keywords) / sizeof(grn_obj *); for (i = 0; i < n_keywords; i++) { grn_obj *keyword; keyword = GRN_PTR_VALUE_AT(¤t_keywords, i); grn_table_add(ctx, keywords, GRN_TEXT_VALUE(keyword), GRN_TEXT_LEN(keyword), NULL); } grn_obj_unlink(ctx, ¤t_keywords); } return keywords; }
void rb_grn_expression_finalizer (grn_ctx *context, grn_obj *object, RbGrnExpression *rb_grn_expression) { if (context && rb_grn_expression->value) grn_obj_unlink(context, rb_grn_expression->value); rb_grn_expression->value = NULL; }
void cut_teardown(void) { grn_obj_unlink(context, &buffer); 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); teardown_grn_logger(logger); cut_remove_path(tmp_directory, NULL); }
void test_cursor(gconstpointer data) { GList *expected, *records = NULL; gint offset = 0; gint limit = -1; grn_obj top_left, bottom_right; grn_obj *geo_cursor; grn_posting *posting; grn_obj short_degree; set_geo_point(&top_left, gcut_data_get_int(data, "top"), gcut_data_get_int(data, "left")); set_geo_point(&bottom_right, gcut_data_get_int(data, "bottom"), gcut_data_get_int(data, "right")); geo_cursor = grn_geo_cursor_open_in_rectangle(context, location_index_column, &top_left, &bottom_right, offset, limit); grn_obj_unlink(context, &top_left); grn_obj_unlink(context, &bottom_right); GRN_TEXT_INIT(&short_degree, 0); while ((posting = grn_geo_cursor_next(context, geo_cursor))) { grn_id point_id = posting->rid; GRN_BULK_REWIND(&short_degree); grn_obj_get_value(context, short_degree_column, point_id, &short_degree); records = g_list_append(records, g_strndup(GRN_TEXT_VALUE(&short_degree), GRN_TEXT_LEN(&short_degree))); } grn_obj_unlink(context, &short_degree); grn_obj_unlink(context, geo_cursor); records = g_list_sort(records, (GCompareFunc)strcmp); gcut_take_list(records, g_free); expected = (GList *)gcut_data_get_pointer(data, "expected"); gcut_assert_equal_list_string(expected, records); }