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);
}
