void
test_set_value(void)
{
grn_obj *v;
prepare_data();
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, cond, v);
cut_assert_not_null(cond);
cut_assert_not_null(v);
PARSE(cond, "size:14",
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(&context,
gcut_take_new_list_string("moge moge moge",
"hoge fuga fuga",
"moge hoge hoge",
NULL),
res,
"body");
grn_test_assert(grn_obj_close(&context, res));
res = NULL;
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, expr, v);
grn_expr_append_obj(&context, expr, v, GRN_OP_PUSH, 1);
GRN_TEXT_SETS(&context, &textbuf, "size");
grn_expr_append_const(&context, expr, &textbuf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_GET_VALUE, 2);
GRN_UINT32_SET(&context, &intbuf, 14);
grn_expr_append_const(&context, expr, &intbuf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_ASSIGN, 2);
{
grn_id id;
grn_table_cursor *tc;
tc = grn_table_cursor_open(&context, docs, NULL, 0, NULL, 0, 0, -1, 0);
cut_assert_not_null(tc);
while ((id = grn_table_cursor_next(&context, tc))) {
GRN_RECORD_SET(&context, v, id);
grn_expr_exec(&context, expr, 0);
}
grn_test_assert(grn_table_cursor_close(&context, tc));
}
res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select_all(res);
}
void
test_equal_indexed(void)
{
grn_obj *v;
prepare_data();
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_OP_PUSH, 1);
GRN_TEXT_SETS(&context, &text_buf, "body");
grn_expr_append_const(&context, cond, &text_buf, GRN_OP_GET_VALUE, 1);
GRN_TEXT_SETS(&context, &text_buf, "hoge");
grn_expr_append_const(&context, cond, &text_buf, GRN_OP_PUSH, 1);
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, NULL);
cut_assert_not_null(res);
cut_assert_not_null(grn_table_select(&context, docs, cond, res, GRN_OP_OR));
grn_test_assert_select(&context,
gcut_take_new_list_string("hoge", NULL),
res,
"body");
}
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
test_proc_call(void)
{
grn_obj *v;
prepare_data();
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, cond, v);
cut_assert_not_null(cond);
cut_assert_not_null(v);
PARSE(cond, "size:>14",
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(&context,
gcut_take_new_list_string("hoge moge moge moge",
"moge hoge fuga fuga",
"moge hoge moge moge moge",
"poyo moge hoge "
"moge moge moge",
NULL),
res,
"body");
grn_test_assert(grn_obj_close(&context, res));
res = NULL;
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, expr, v);
PARSE(expr, "size = rand(14)", GRN_EXPR_SYNTAX_SCRIPT|GRN_EXPR_ALLOW_UPDATE);
{
grn_id id;
grn_table_cursor *tc;
tc = grn_table_cursor_open(&context, docs, NULL, 0, NULL, 0, 0, -1, 0);
cut_assert_not_null(tc);
while ((id = grn_table_cursor_next(&context, tc))) {
GRN_RECORD_SET(&context, v, id);
grn_expr_exec(&context, expr, 0);
}
grn_test_assert(grn_table_cursor_close(&context, tc));
}
res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select_none(res);
}
void
test_japanese_parenthesis(void)
{
cut_assert_not_null(grn_table_select(context, comments,
query("content:@）は"),
result, GRN_OP_OR));
grn_test_assert_select(context,
gcut_take_new_list_string("ボロ", NULL),
result,
"_key");
}
void
test_equal_by_nonexistent_reference_key(void)
{
grn_obj *v;
prepare_data();
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, cond, v);
cut_assert_not_null(cond);
cut_assert_not_null(v);
PARSE(cond, "author == \"nonexistent\"", GRN_EXPR_SYNTAX_SCRIPT);
res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select(&context,
NULL,
res,
"body");
}
void
test_match_without_index(void)
{
grn_obj *v;
create_properties_table();
create_documents_table();
insert_data();
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_OP_PUSH, 1);
GRN_TEXT_SETS(&context, &text_buf, "body");
grn_expr_append_const(&context, cond, &text_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, cond, GRN_OP_GET_VALUE, 1);
GRN_TEXT_SETS(&context, &text_buf, "moge");
grn_expr_append_const(&context, cond, &text_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, cond, GRN_OP_MATCH, 2);
grn_expr_compile(&context, cond);
res = grn_table_create(&context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, docs, NULL);
cut_assert_not_null(res);
cut_assert_not_null(grn_table_select(&context, docs, cond, res, GRN_OP_OR));
grn_test_assert_select(
&context,
gcut_take_new_list_string("moge moge moge",
"hoge moge moge moge",
"moge hoge hoge",
"moge hoge fuga fuga",
"moge hoge moge moge moge",
"poyo moge hoge moge moge moge",
NULL),
res,
"body");
}
void
test_equal_by_existent_reference_key(void)
{
grn_obj *v;
prepare_data();
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, cond, v);
cut_assert_not_null(cond);
cut_assert_not_null(v);
PARSE(cond, "author == \"morita\"", GRN_EXPR_SYNTAX_SCRIPT);
res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select(&context,
gcut_take_new_list_string(
"fuga fuga",
"hoge",
"poyo moge hoge moge moge moge",
NULL),
res,
"body");
}
void
test_allow_update(gconstpointer data)
{
grn_obj *v;
prepare_data();
expr = grn_expr_create(&context, NULL, 0);
cut_assert_not_null(expr);
v = grn_expr_add_var(&context, expr, NULL, 0);
cut_assert_not_null(v);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs));
PARSE(expr,
gcut_data_get_string(data, "query"),
GRN_EXPR_SYNTAX_QUERY | GRN_EXPR_ALLOW_COLUMN | GRN_EXPR_ALLOW_UPDATE);
res = grn_table_select(&context, docs, expr, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select(&context,
gcut_data_get_pointer(data, "expected_keys"),
res,
"body");
}
static mrb_value
mrb_grn_table_select(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *table;
grn_obj *expr;
grn_obj *result = NULL;
grn_operator operator = GRN_OP_OR;
mrb_value mrb_expr;
mrb_value mrb_options = mrb_nil_value();
table = DATA_PTR(self);
mrb_get_args(mrb, "o|H", &mrb_expr, &mrb_options);
expr = DATA_PTR(mrb_expr);
if (!mrb_nil_p(mrb_options)) {
mrb_value mrb_result;
mrb_value mrb_operator;
mrb_result = grn_mrb_options_get_lit(mrb, mrb_options, "result");
if (!mrb_nil_p(mrb_result)) {
result = DATA_PTR(mrb_result);
}
mrb_operator = grn_mrb_options_get_lit(mrb, mrb_options, "operator");
if (!mrb_nil_p(mrb_operator)) {
operator = mrb_fixnum(mrb_operator);
}
}
result = grn_table_select(ctx, table, expr, result, operator);
grn_mrb_ctx_check(mrb);
return grn_mrb_value_from_grn_obj(mrb, result);
}
/*
* call-seq:
* column.select(options) {|record| ...} -> Groonga::Hash
* column.select(query, options) -> Groonga::Hash
* column.select(expression, options) -> Groonga::Hash
*
* カラムが所属するテーブルからブロックまたは文字列で指定し
* た条件にマッチするレコードを返す。返されたテーブルには
* +expression+という特異メソッドがあり、指定した条件を表し
* ているGroonga::Expressionを取得できる。
* Groonga::Expression#snippetを使うことにより、指定した条件
* 用のスニペットを簡単に生成できる。
*
* results = description_column.select do |column|
* column =~ "groonga"
* end
* snippet = results.expression.snippet([["<em>", "</em>"]])
* results.each do |record|
* puts "#{record['name']}の説明文の中で「groonga」が含まれる部分"
* snippet.execute(record["description"].each do |snippet|
* puts "---"
* puts "#{snippet}..."
* puts "---"
* end
* end
*
* 出力例
* Ruby/groongaの説明文の中で「groonga」が含まれる部分
* ---
* Ruby/<em>groonga</em>は<em>groonga</em>のいわゆるDB-APIの層の...
* ---
*
* _query_には「[カラム名]:[演算子][値]」という書式で条件を
* 指定する。演算子は以下の通り。
*
* [なし]
* [カラム値] == [値]
* [<tt>!</tt>]
* [カラム値] != [値]
* [<tt><</tt>]
* [カラム値] < [値]
* [<tt>></tt>]
* [カラム値] > [値]
* [<tt><=</tt>]
* [カラム値] <= [値]
* [<tt>>=</tt>]
* [カラム値] >= [値]
* [<tt>@</tt>]
* [カラム値]が[値]を含んでいるかどうか
*
* 例:
* "groonga" # _column_カラムの値が"groonga"のレコードにマッチ
* "name:daijiro" # _column_カラムが属しているテーブルの
* # "name"カラムの値が"daijiro"のレコードにマッチ
* "description:@groonga" # _column_カラムが属しているテーブルの
* # "description"カラムが
* # "groonga"を含んでいるレコードにマッチ
*
* _expression_には既に作成済みのGroonga::Expressionを渡す
*
* ブロックで条件を指定する場合は
* Groonga::ColumnExpressionBuilderを参照。
*
* _options_に指定可能な値は以下の通り。
*
* [+:operator+]
* マッチしたレコードをどのように扱うか。指定可能な値は以
* 下の通り。省略した場合はGroonga::Operation::OR。
*
* [Groonga::Operation::OR]
* マッチしたレコードを追加。すでにレコードが追加され
* ている場合は何もしない。
* [Groonga::Operation::AND]
* マッチしたレコードのスコアを増加。マッチしなかった
* レコードを削除。
* [Groonga::Operation::BUT]
* マッチしたレコードを削除。
* [Groonga::Operation::ADJUST]
* マッチしたレコードのスコアを増加。
*
* [+:result+]
* 検索結果を格納するテーブル。マッチしたレコードが追加さ
* れていく。省略した場合は新しくテーブルを作成して返す。
*
* [+:name+]
* 条件の名前。省略した場合は名前を付けない。
*
* [+:syntax+]
* _query_の構文。省略した場合は+:query+。
*
* 参考: Groonga::Expression#parse.
*
* [+:allow_pragma+]
* query構文時にプラグマを利用するかどうか。省略した場合は
* 利用する。
*
* 参考: Groonga::Expression#parse.
*
* [+:allow_column+]
* query構文時にカラム指定を利用するかどうか。省略した場合
* は利用する。
*
* 参考: Groonga::Expression#parse.
*
* [+:allow_update+]
* script構文時に更新操作を利用するかどうか。省略した場合
* は利用する。
*
* 参考: Groonga::Expression#parse.
*/
static VALUE
rb_grn_column_select (int argc, VALUE *argv, VALUE self)
{
grn_ctx *context;
grn_obj *table, *column, *result, *expression;
grn_operator operator = GRN_OP_OR;
VALUE options;
VALUE rb_query, condition_or_options;
VALUE rb_name, rb_operator, rb_result, rb_syntax;
VALUE rb_allow_pragma, rb_allow_column, rb_allow_update;
VALUE builder;
VALUE rb_expression = Qnil;
rb_query = Qnil;
rb_scan_args(argc, argv, "02", &condition_or_options, &options);
rb_grn_column_deconstruct(SELF(self), &column, &context,
NULL, NULL,
NULL, NULL, NULL);
table = grn_column_table(context, column);
if (RVAL2CBOOL(rb_obj_is_kind_of(condition_or_options, rb_cString))) {
rb_query = condition_or_options;
} else if (RVAL2CBOOL(rb_obj_is_kind_of(condition_or_options,
rb_cGrnExpression))) {
rb_expression = condition_or_options;
} else {
if (!NIL_P(options))
rb_raise(rb_eArgError,
"should be [query_string, option_hash], "
"[expression, option_hash] "
"or [option_hash]: %s",
rb_grn_inspect(rb_ary_new4(argc, argv)));
options = condition_or_options;
}
rb_grn_scan_options(options,
"operator", &rb_operator,
"result", &rb_result,
"name", &rb_name,
"syntax", &rb_syntax,
"allow_pragma", &rb_allow_pragma,
"allow_column", &rb_allow_column,
"allow_update", &rb_allow_update,
NULL);
if (!NIL_P(rb_operator))
operator = NUM2INT(rb_operator);
if (NIL_P(rb_result)) {
result = grn_table_create(context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
table,
0);
rb_result = GRNTABLE2RVAL(context, result, RB_GRN_TRUE);
} else {
result = RVAL2GRNTABLE(rb_result, &context);
}
if (NIL_P(rb_expression)) {
builder = rb_grn_column_expression_builder_new(self, rb_name, rb_query);
rb_funcall(builder, rb_intern("syntax="), 1, rb_syntax);
rb_funcall(builder, rb_intern("allow_pragma="), 1, rb_allow_pragma);
rb_funcall(builder, rb_intern("allow_column="), 1, rb_allow_column);
rb_funcall(builder, rb_intern("allow_update="), 1, rb_allow_update);
rb_expression = rb_grn_column_expression_builder_build(builder);
}
rb_grn_object_deconstruct(RB_GRN_OBJECT(DATA_PTR(rb_expression)),
&expression, NULL,
NULL, NULL, NULL, NULL);
grn_table_select(context, table, expression, result, operator);
rb_grn_context_check(context, self);
rb_attr(rb_singleton_class(rb_result),
rb_intern("expression"),
RB_GRN_TRUE, RB_GRN_FALSE, RB_GRN_FALSE);
rb_iv_set(rb_result, "@expression", rb_expression);
return rb_result;
}
static mrb_value
mrb_grn_table_delete(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *table;
mrb_value mrb_options;
mrb_value mrb_id;
mrb_value mrb_key;
mrb_value mrb_expression;
table = DATA_PTR(self);
mrb_get_args(mrb, "H", &mrb_options);
mrb_id = grn_mrb_options_get_lit(mrb, mrb_options, "id");
if (!mrb_nil_p(mrb_id)) {
grn_table_delete_by_id(ctx, table, mrb_fixnum(mrb_id));
grn_mrb_ctx_check(mrb);
return mrb_nil_value();
}
mrb_key = grn_mrb_options_get_lit(mrb, mrb_options, "key");
if (!mrb_nil_p(mrb_key)) {
grn_id key_domain_id;
void *key;
unsigned int key_size;
grn_mrb_value_to_raw_data_buffer buffer;
key_domain_id = table->header.domain;
grn_mrb_value_to_raw_data_buffer_init(mrb, &buffer);
grn_mrb_value_to_raw_data(mrb, "key", mrb_key, key_domain_id,
&buffer, &key, &key_size);
grn_table_delete(ctx, table, key, key_size);
grn_mrb_value_to_raw_data_buffer_fin(mrb, &buffer);
grn_mrb_ctx_check(mrb);
return mrb_nil_value();
}
mrb_expression = grn_mrb_options_get_lit(mrb, mrb_options, "expression");
if (!mrb_nil_p(mrb_expression)) {
grn_obj *expression;
grn_obj *selected_records;
grn_table_cursor *cursor;
expression = DATA_PTR(mrb_expression);
selected_records = grn_table_select(ctx, table, expression, NULL, GRN_OP_OR);
grn_mrb_ctx_check(mrb);
cursor = grn_table_cursor_open(ctx, selected_records,
NULL, 0,
NULL, 0,
0, -1, 0);
if (cursor) {
while (grn_table_cursor_next(ctx, cursor) != GRN_ID_NIL) {
grn_id *id;
grn_table_cursor_get_key(ctx, cursor, (void **)&id);
grn_table_delete_by_id(ctx, table, *id);
}
grn_table_cursor_close(ctx, cursor);
}
grn_mrb_ctx_check(mrb);
return mrb_nil_value();
}
mrb_raisef(mrb, E_ARGUMENT_ERROR,
"must have :id, :key or :expression: %S",
mrb_options);
return mrb_nil_value();
}
void
test_parse(gconstpointer data)
{
grn_obj *v;
prepare_data();
cond = grn_expr_create(&context, NULL, 0);
cut_assert_not_null(cond);
v = grn_expr_add_var(&context, cond, NULL, 0);
cut_assert_not_null(v);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs));
PARSE(cond, gcut_data_get_string(data, "query_hoge_moge"),
gcut_data_get_int(data, "query_hoge_moge_parse_level"));
PARSE(cond, gcut_data_get_string(data, "query_poyo"),
gcut_data_get_int(data, "query_poyo_parse_level"));
grn_expr_append_op(&context, cond, GRN_OP_AND, 2);
grn_test_assert_expr(&context,
"noname($1:0){2body GET_VALUE,0\"hoge\",4MATCH,"
"2body GET_VALUE,0\"moge\",0MATCH,4AND,"
"2body GET_VALUE,0\"poyo\",0MATCH,0AND}",
cond);
res = grn_table_create(&context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, docs, NULL);
cut_assert_not_null(res);
cut_assert_not_null(grn_table_select(&context, docs, cond, res, GRN_OP_OR));
grn_test_assert_select(&context,
gcut_take_new_list_string("poyo moge hoge "
"moge moge moge",
NULL),
res,
"body");
grn_test_assert(grn_obj_close(&context, res));
res = NULL;
grn_test_assert(grn_obj_close(&context, cond));
cond = NULL;
cond = grn_expr_create(&context, NULL, 0);
cut_assert_not_null(cond);
v = grn_expr_add_var(&context, cond, NULL, 0);
cut_assert_not_null(v);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs));
PARSE(cond, gcut_data_get_string(data, "query_size"),
gcut_data_get_int(data, "query_size_parse_level"));
grn_test_assert_expr(&context,
"noname($1:0){2size GET_VALUE,014,0EQUAL}",
cond);
res = grn_table_create(&context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, docs, NULL);
cut_assert_not_null(res);
cut_assert_not_null(grn_table_select(&context, docs, cond, res, GRN_OP_OR));
grn_test_assert_select(&context,
gcut_take_new_list_string("moge moge moge",
"hoge fuga fuga",
"moge hoge hoge",
NULL),
res,
"body");
}
void
test_setoperation(gconstpointer data)
{
grn_operator operator;
grn_obj *entries;
grn_obj *result1;
grn_obj *result2;
const char *dump;
operator = gcut_data_get_int(data, "operator");
assert_send_command("table_create Entries TABLE_HASH_KEY ShortText");
send_command(
"load "
"--table Entries "
"--values '[{\"_key\": \"a\"}, {\"_key\": \"b\"}, {\"_key\": \"c\"}]'");
entries = grn_ctx_get(context, "Entries", -1);
{
const char *condition = "_id < 3";
grn_obj *expr;
grn_obj *variable;
GRN_EXPR_CREATE_FOR_QUERY(context, entries, expr, variable);
grn_expr_parse(context, expr,
condition, strlen(condition),
NULL, GRN_OP_AND, GRN_OP_MATCH, GRN_EXPR_SYNTAX_SCRIPT);
result1 = grn_table_select(context, entries, expr, NULL, GRN_OP_OR);
grn_obj_unlink(context, expr);
}
{
const char *condition = "_id > 1";
grn_obj *expr;
grn_obj *variable;
GRN_EXPR_CREATE_FOR_QUERY(context, entries, expr, variable);
grn_expr_parse(context, expr,
condition, strlen(condition),
NULL, GRN_OP_AND, GRN_OP_MATCH, GRN_EXPR_SYNTAX_SCRIPT);
result2 = grn_table_select(context, entries, expr, NULL, GRN_OP_OR);
grn_obj_unlink(context, expr);
}
grn_table_setoperation(context, result1, result2, result1, operator);
{
grn_bool first_record = GRN_TRUE;
grn_obj buffer;
grn_obj *score_accessor;
grn_obj score;
GRN_TEXT_INIT(&buffer, 0);
GRN_TEXT_PUTS(context, &buffer, "[");
score_accessor = grn_obj_column(context, result1,
GRN_COLUMN_NAME_SCORE,
GRN_COLUMN_NAME_SCORE_LEN);
GRN_FLOAT_INIT(&score, 0);
GRN_TABLE_EACH_BEGIN(context, result1, cursor, id) {
void *result_key;
grn_id entry_id;
char entry_key[GRN_TABLE_MAX_KEY_SIZE];
int entry_key_size;
if (first_record) {
first_record = GRN_FALSE;
} else {
GRN_TEXT_PUTS(context, &buffer, ", ");
}
GRN_TEXT_PUTS(context, &buffer, "[");
grn_table_cursor_get_key(context, cursor, &result_key);
entry_id = *((grn_id *)result_key);
entry_key_size = grn_table_get_key(context,
entries,
entry_id,
entry_key,
GRN_TABLE_MAX_KEY_SIZE);
GRN_TEXT_PUT(context, &buffer, entry_key, entry_key_size);
GRN_TEXT_PUTS(context, &buffer, ", ");
GRN_BULK_REWIND(&score);
grn_obj_get_value(context, score_accessor, id, &score);
grn_text_printf(context, &buffer, "%.1f", GRN_FLOAT_VALUE(&score));
GRN_TEXT_PUTS(context, &buffer, "]");
} GRN_TABLE_EACH_END(context, cursor);
GRN_OBJ_FIN(context, &score);
grn_obj_unlink(context, score_accessor);
GRN_TEXT_PUTS(context, &buffer, "]");
dump = cut_take_strndup(GRN_TEXT_VALUE(&buffer), GRN_TEXT_LEN(&buffer));
GRN_OBJ_FIN(context, &buffer);
}
void
test_parse(gconstpointer data)
{
grn_obj *v;
prepare_data();
cond = grn_expr_create(&context, NULL, 0);
cut_assert_not_null(cond);
v = grn_expr_add_var(&context, cond, NULL, 0);
cut_assert_not_null(v);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs));
PARSE(cond, gcut_data_get_string(data, "query_hoge_moge"),
gcut_data_get_int(data, "query_hoge_moge_parse_level"));
PARSE(cond, gcut_data_get_string(data, "query_poyo"),
gcut_data_get_int(data, "query_poyo_parse_level"));
grn_expr_append_op(&context, cond, GRN_OP_AND, 2);
grn_test_assert_expr(
&context,
"#<expr\n"
" vars:{\n"
" $1:#<record:no_key:docs id:0(nonexistent)>\n"
" },\n"
" codes:{\n"
" 0:<get_value(), modify:2, "
"value:#<column:var_size docs.body range:Text type:scalar compress:none>>,\n"
" 1:<push(), modify:0, value:\"hoge\">,\n"
" 2:<match(), modify:4, value:(NULL)>,\n"
" 3:<get_value(), modify:2, "
"value:#<column:var_size docs.body range:Text type:scalar compress:none>>,\n"
" 4:<push(), modify:0, value:\"moge\">,\n"
" 5:<match(), modify:0, value:(NULL)>,\n"
" 6:<and(), modify:4, value:(NULL)>,\n"
" 7:<get_value(), modify:2, "
"value:#<column:var_size docs.body range:Text type:scalar compress:none>>,\n"
" 8:<push(), modify:0, value:\"poyo\">,\n"
" 9:<match(), modify:0, value:(NULL)>,\n"
" 10:<and(), modify:0, value:(NULL)>\n"
" }\n"
">",
cond);
res = grn_table_create(&context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, docs, NULL);
cut_assert_not_null(res);
cut_assert_not_null(grn_table_select(&context, docs, cond, res, GRN_OP_OR));
grn_test_assert_select(&context,
gcut_take_new_list_string("poyo moge hoge "
"moge moge moge",
NULL),
res,
"body");
grn_test_assert(grn_obj_close(&context, res));
res = NULL;
grn_test_assert(grn_obj_close(&context, cond));
cond = NULL;
cond = grn_expr_create(&context, NULL, 0);
cut_assert_not_null(cond);
v = grn_expr_add_var(&context, cond, NULL, 0);
cut_assert_not_null(v);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs));
PARSE(cond, gcut_data_get_string(data, "query_size"),
gcut_data_get_int(data, "query_size_parse_level"));
grn_test_assert_expr(
&context,
"#<expr\n"
" vars:{\n"
" $1:#<record:no_key:docs id:0(nonexistent)>\n"
" },\n"
" codes:{\n"
" 0:<get_value(), modify:2, "
"value:#<column:fix_size docs.size range:UInt32 type:scalar compress:none>>,\n"
" 1:<push(), modify:0, value:14>,\n"
" 2:<equal(), modify:0, value:(NULL)>\n"
" }\n"
">",
cond);
res = grn_table_create(&context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, docs, NULL);
cut_assert_not_null(res);
cut_assert_not_null(grn_table_select(&context, docs, cond, res, GRN_OP_OR));
grn_test_assert_select(&context,
gcut_take_new_list_string("moge moge moge",
"hoge fuga fuga",
"moge hoge hoge",
NULL),
res,
"body");
}
void
test_mroonga_index_score(void)
{
grn_obj *t1,*c1,*lc,*ft;
grn_obj buff;
grn_id r1,r2,r3,r4;
const gchar *mrn_dir;
mrn_dir = cut_build_path(tmp_directory, "mrn", NULL);
g_mkdir_with_parents(mrn_dir, 0700);
grn_obj_close(context, db);
db = grn_db_create(context,
cut_build_path(mrn_dir, "mroonga.grn", NULL),
NULL);
cut_assert_not_null(db);
/* actual table */
t1 = grn_table_create(context, "t1", 2,
cut_build_path(mrn_dir, "t1.grn", NULL),
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, 0);
cut_assert_not_null(t1);
/* lexicon table */
lc = grn_table_create(context, "lc", 2,
cut_build_path(mrn_dir, "lc.grn", NULL),
GRN_OBJ_TABLE_PAT_KEY|GRN_OBJ_PERSISTENT,
grn_ctx_at(context, GRN_DB_SHORT_TEXT), 0);
cut_assert_not_null(lc);
grn_test_assert(grn_obj_set_info(context, lc, GRN_INFO_DEFAULT_TOKENIZER,
grn_ctx_at(context, GRN_DB_BIGRAM)));
/* actual column */
c1 = grn_column_create(context, t1, "c1", 2,
cut_build_path(mrn_dir, "t1.c1.grn", NULL),
GRN_OBJ_COLUMN_SCALAR|GRN_OBJ_PERSISTENT,
grn_ctx_at(context, GRN_DB_TEXT));
cut_assert_not_null(c1);
/* fulltext index */
ft = grn_column_create(context, lc, "ft", 2,
cut_build_path(mrn_dir, "lc.ft.grn", NULL),
GRN_OBJ_COLUMN_INDEX|GRN_OBJ_PERSISTENT, t1);
cut_assert_not_null(ft);
GRN_TEXT_INIT(&buff,0);
/* link between actual column and fulltext index */
GRN_UINT32_SET(context, &buff, grn_obj_id(context, c1));
grn_obj_set_info(context, ft, GRN_INFO_SOURCE, &buff); /* need to use grn_id */
/* insert row */
r1 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(1,r1);
GRN_TEXT_SETS(context, &buff, "abcde");
grn_test_assert(grn_obj_set_value(context, c1, r1, &buff, GRN_OBJ_SET));
r2 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(2,r2);
GRN_TEXT_SETS(context, &buff, "fghij");
grn_test_assert(grn_obj_set_value(context, c1, r2, &buff, GRN_OBJ_SET));
r3 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(3,r3);
GRN_TEXT_SETS(context, &buff, "11 22 33");
grn_test_assert(grn_obj_set_value(context, c1, r3, &buff, GRN_OBJ_SET));
r4 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(4,r4);
GRN_TEXT_SETS(context, &buff, "44 22 55");
grn_test_assert(grn_obj_set_value(context, c1, r4, &buff, GRN_OBJ_SET));
/* confirm record are inserted in both column and index */
cut_assert_equal_int(4,grn_table_size(context,t1));
cut_assert_equal_int(23,grn_table_size(context,lc));
/* nlq search */
{
grn_id id, docid;
grn_obj *res;
grn_table_cursor *tc;
grn_obj score, *score_column;
res = grn_table_create(context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, t1, 0);
GRN_FLOAT_INIT(&score, 0);
GRN_BULK_REWIND(&buff);
GRN_TEXT_SETS(context, &buff, "hij");
grn_obj_search(context, ft, &buff, res, GRN_OP_OR, NULL);
cut_assert_equal_int(1, grn_table_size(context, res));
score_column = grn_obj_column(context, res, "_score", 6);
tc = grn_table_cursor_open(context, res, NULL, 0, NULL, 0, 0, -1, 0);
while ((id = grn_table_cursor_next(context, tc))) {
GRN_BULK_REWIND(&buff);
grn_table_get_key(context, res, id, &docid, sizeof(grn_id));
cut_assert_equal_int(2, docid);
cut_assert_not_null(grn_obj_get_value(context, c1, docid, &buff));
cut_assert_equal_int(5 ,GRN_TEXT_LEN(&buff));
cut_assert_equal_substring("fghij", (char*) GRN_BULK_HEAD(&buff),GRN_TEXT_LEN(&buff));
grn_obj_get_value(context, score_column, id, &score);
cut_assert_equal_double(1.0, DBL_EPSILON, GRN_FLOAT_VALUE(&score));
}
grn_table_cursor_close(context, tc);
grn_obj_close(context, score_column);
grn_obj_close(context, res);
}
/* boolean search */
{
grn_id id, docid;
grn_obj *res;
grn_obj *match_columns, *match_columns_variable;
grn_obj *expression, *expression_variable;
grn_table_cursor *tc;
grn_obj score, *score_column;
const char *match_columns_expression = "c1 * 5";
const char *qstr = "+22 -55";
GRN_EXPR_CREATE_FOR_QUERY(context, t1,
match_columns, match_columns_variable);
grn_expr_parse(context, match_columns,
match_columns_expression,
strlen(match_columns_expression),
NULL, GRN_OP_MATCH, GRN_OP_AND,
GRN_EXPR_SYNTAX_SCRIPT);
GRN_EXPR_CREATE_FOR_QUERY(context, t1, expression, expression_variable);
res = grn_table_create(context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, t1, 0);
grn_test_assert(grn_expr_parse(context, expression,
qstr, strlen(qstr),
match_columns,
GRN_OP_MATCH, GRN_OP_OR,
GRN_EXPR_SYNTAX_QUERY));
grn_table_select(context, t1, expression, res, GRN_OP_OR);
cut_assert_equal_int(1, grn_table_size(context, res));
GRN_FLOAT_INIT(&score, 0);
score_column = grn_obj_column(context, res, "_score", 6);
tc = grn_table_cursor_open(context, res, NULL, 0, NULL, 0, 0, -1, 0);
while ((id = grn_table_cursor_next(context, tc))) {
GRN_BULK_REWIND(&buff);
grn_table_get_key(context, res, id, &docid, sizeof(grn_id));
cut_assert_equal_int(3, docid);
cut_assert_not_null(grn_obj_get_value(context, c1, docid, &buff));
cut_assert_equal_int(8, GRN_TEXT_LEN(&buff));
cut_assert_equal_substring("11 22 33", (char*) GRN_BULK_HEAD(&buff),GRN_TEXT_LEN(&buff));
grn_obj_get_value(context, score_column, id, &score);
cut_assert_equal_double(5, DBL_EPSILON, GRN_FLOAT_VALUE(&score));
}
grn_obj_close(context, expression);
grn_obj_close(context, match_columns);
grn_table_cursor_close(context ,tc);
grn_obj_close(context, score_column);
grn_obj_close(context, res);
}
grn_obj_close(context, &buff);
grn_obj_close(context, ft);
grn_obj_close(context, c1);
grn_obj_close(context, lc);
grn_obj_close(context, t1);
}