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_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 ConditionConverter::convert_between(const Item_func *func_item,
grn_obj *expression) {
MRN_DBUG_ENTER_METHOD();
Item **arguments = func_item->arguments();
Item *target_item = arguments[0];
Item *min_item = arguments[1];
Item *max_item = arguments[2];
grn_obj *between_func = grn_ctx_get(ctx_, "between", strlen("between"));
grn_expr_append_obj(ctx_, expression, between_func, GRN_OP_PUSH, 1);
const Item_field *field_item = static_cast<const Item_field *>(target_item);
append_field_value(field_item, expression);
grn_obj include;
mrn::SmartGrnObj smart_include(ctx_, &include);
GRN_TEXT_INIT(&include, 0);
GRN_TEXT_PUTS(ctx_, &include, "include");
append_const_item(field_item, min_item, expression);
grn_expr_append_const(ctx_, expression, &include, GRN_OP_PUSH, 1);
append_const_item(field_item, max_item, expression);
grn_expr_append_const(ctx_, expression, &include, GRN_OP_PUSH, 1);
grn_expr_append_op(ctx_, expression, GRN_OP_CALL, 5);
grn_expr_append_op(ctx_, expression, GRN_OP_AND, 2);
DBUG_VOID_RETURN;
}
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);
}
/*
* _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
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_select(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, "size");
grn_expr_append_const(&context, cond, &text_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, cond, GRN_OP_GET_VALUE, 2);
GRN_UINT32_SET(&context, &int_buf, 14);
grn_expr_append_const(&context, cond, &int_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((expr = grn_expr_create(&context, NULL, 0)));
grn_expr_append_obj(&context, expr, docs, GRN_OP_PUSH, 1);
grn_expr_append_obj(&context, expr, cond, GRN_OP_PUSH, 1);
grn_expr_append_obj(&context, expr, res, GRN_OP_PUSH, 1);
GRN_UINT32_SET(&context, &int_buf, GRN_OP_OR);
grn_expr_append_const(&context, expr, &int_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_TABLE_SELECT, 4);
grn_expr_exec(&context, expr, 0);
grn_test_assert_select(&context,
gcut_take_new_list_string("moge moge moge",
"hoge fuga fuga",
"moge hoge hoge",
NULL),
res,
"body");
}
void ConditionConverter::append_field_value(const Item_field *field_item,
grn_obj *expression) {
MRN_DBUG_ENTER_METHOD();
GRN_BULK_REWIND(&column_name_);
GRN_TEXT_PUT(ctx_, &column_name_,
MRN_ITEM_FIELD_GET_NAME(field_item),
MRN_ITEM_FIELD_GET_NAME_LENGTH(field_item));
grn_expr_append_const(ctx_, expression, &column_name_,
GRN_OP_PUSH, 1);
grn_expr_append_op(ctx_, expression, GRN_OP_GET_VALUE, 1);
DBUG_VOID_RETURN;
}
void ConditionConverter::append_const_item(const Item_field *field_item,
Item *const_item,
grn_obj *expression) {
MRN_DBUG_ENTER_METHOD();
enum_field_types field_type = field_item->field_type();
NormalizedType normalized_type = normalize_field_type(field_type);
switch (normalized_type) {
case STRING_TYPE:
grn_obj_reinit(ctx_, &value_, GRN_DB_TEXT, 0);
{
String *string;
string = const_item->val_str(NULL);
GRN_TEXT_SET(ctx_, &value_, string->ptr(), string->length());
}
break;
case INT_TYPE:
grn_obj_reinit(ctx_, &value_, GRN_DB_INT64, 0);
GRN_INT64_SET(ctx_, &value_, const_item->val_int());
break;
case TIME_TYPE:
grn_obj_reinit(ctx_, &value_, GRN_DB_TIME, 0);
{
MYSQL_TIME mysql_time;
get_time_value(field_item, const_item, &mysql_time);
bool truncated = false;
TimeConverter time_converter;
long long int time =
time_converter.mysql_time_to_grn_time(&mysql_time, &truncated);
GRN_TIME_SET(ctx_, &value_, time);
}
break;
case UNSUPPORTED_TYPE:
// Should not be occurred.
DBUG_PRINT("error",
("mroonga: append_const_item: unsupported type: <%d> "
"This case should not be occurred.",
field_type));
grn_obj_reinit(ctx_, &value_, GRN_DB_VOID, 0);
break;
}
grn_expr_append_const(ctx_, expression, &value_, GRN_OP_PUSH, 1);
DBUG_VOID_RETURN;
}
void
test_select_search(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, "size");
grn_expr_append_const(&context, cond, &text_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, cond, GRN_OP_GET_VALUE, 2);
GRN_UINT32_SET(&context, &int_buf, 14);
grn_expr_append_const(&context, cond, &int_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, cond, GRN_OP_EQUAL, 2);
grn_expr_compile(&context, cond);
cut_assert_not_null((expr = grn_expr_create(&context, NULL, 0)));
v = grn_expr_add_var(&context, expr, NULL, 0);
grn_expr_append_obj(&context, expr, v, GRN_OP_PUSH, 1);
GRN_BULK_REWIND(&text_buf);
grn_expr_append_const(&context, expr, &text_buf, GRN_OP_PUSH, 1);
GRN_UINT32_SET(&context, &int_buf, GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC);
grn_expr_append_const(&context, expr, &int_buf, GRN_OP_PUSH, 1);
grn_expr_append_obj(&context, expr, docs, GRN_OP_PUSH, 1);
GRN_PTR_SET(&context, &ptr_buf, NULL);
grn_expr_append_obj(&context, expr, &ptr_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_TABLE_CREATE, 4);
grn_expr_append_op(&context, expr, GRN_OP_ASSIGN, 2);
grn_expr_append_obj(&context, expr, docs, GRN_OP_PUSH, 1);
grn_expr_append_obj(&context, expr, cond, GRN_OP_PUSH, 1);
grn_expr_append_obj(&context, expr, v, GRN_OP_PUSH, 1);
GRN_UINT32_SET(&context, &int_buf, GRN_OP_OR);
grn_expr_append_const(&context, expr, &int_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_TABLE_SELECT, 4);
grn_expr_append_obj(&context, expr, index_body, GRN_OP_PUSH, 1);
GRN_TEXT_SETS(&context, &text_buf, "moge");
grn_expr_append_const(&context, expr, &text_buf, GRN_OP_PUSH, 1);
grn_expr_append_obj(&context, expr, v, GRN_OP_PUSH, 1);
GRN_UINT32_SET(&context, &int_buf, GRN_OP_AND);
grn_expr_append_const(&context, expr, &int_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_OBJ_SEARCH, 4);
grn_expr_append_obj(&context, expr, v, GRN_OP_PUSH, 1);
GRN_TEXT_SETS(&context, &text_buf, ".size ._score .body");
grn_expr_append_const(&context, expr, &text_buf, GRN_OP_PUSH, 1);
GRN_BULK_REWIND(&text_buf);
grn_expr_append_obj(&context, expr, &text_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_JSON_PUT, 3);
grn_expr_exec(&context, expr, 0);
cut_assert_equal_substring("[[2],[14,4,\"moge moge moge\"],[14,2,\"moge hoge hoge\"]]",
GRN_TEXT_VALUE(&text_buf), GRN_TEXT_LEN(&text_buf));
}
static mrb_value
mrb_grn_expression_append_constant(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *expr;
mrb_value mrb_constant;
mrb_value mrb_op;
grn_operator op;
int n_args;
expr = DATA_PTR(self);
mrb_get_args(mrb, "ooi", &mrb_constant, &mrb_op, &n_args);
op = grn_mrb_value_to_operator(mrb, mrb_op);
switch (mrb_type(mrb_constant)) {
case MRB_TT_FALSE :
if (mrb_nil_p(mrb_constant)) {
grn_obj constant;
GRN_VOID_INIT(&constant);
grn_expr_append_const(ctx, expr, &constant, op, n_args);
GRN_OBJ_FIN(ctx, &constant);
} else {
grn_obj constant;
GRN_BOOL_INIT(&constant, 0);
GRN_BOOL_SET(ctx, &constant, GRN_FALSE);
grn_expr_append_const(ctx, expr, &constant, op, n_args);
GRN_OBJ_FIN(ctx, &constant);
}
break;
case MRB_TT_TRUE :
{
grn_obj constant;
GRN_BOOL_INIT(&constant, 0);
GRN_BOOL_SET(ctx, &constant, GRN_TRUE);
grn_expr_append_const(ctx, expr, &constant, op, n_args);
GRN_OBJ_FIN(ctx, &constant);
}
break;
case MRB_TT_FIXNUM :
grn_expr_append_const_int(ctx, expr, mrb_fixnum(mrb_constant), op, n_args);
break;
case MRB_TT_SYMBOL :
{
const char *value;
mrb_int value_length;
value = mrb_sym2name_len(mrb, mrb_symbol(mrb_constant), &value_length);
grn_expr_append_const_str(ctx, expr, value, value_length, op, n_args);
}
break;
case MRB_TT_FLOAT :
{
grn_obj constant;
GRN_FLOAT_INIT(&constant, 0);
GRN_FLOAT_SET(ctx, &constant, mrb_float(mrb_constant));
grn_expr_append_const(ctx, expr, &constant, op, n_args);
GRN_OBJ_FIN(ctx, &constant);
}
break;
case MRB_TT_STRING :
grn_expr_append_const_str(ctx, expr,
RSTRING_PTR(mrb_constant),
RSTRING_LEN(mrb_constant),
op, n_args);
break;
default :
{
struct RClass *klass;
klass = mrb_class(mrb, mrb_constant);
if (klass == ctx->impl->mrb.builtin.time_class) {
grn_obj constant;
mrb_value mrb_sec;
mrb_value mrb_usec;
mrb_sec = mrb_funcall(mrb, mrb_constant, "to_i", 0);
mrb_usec = mrb_funcall(mrb, mrb_constant, "usec", 0);
GRN_TIME_INIT(&constant, 0);
GRN_TIME_SET(ctx, &constant,
GRN_TIME_PACK(mrb_fixnum(mrb_sec), mrb_fixnum(mrb_usec)));
grn_expr_append_const(ctx, expr, &constant, op, n_args);
GRN_OBJ_FIN(ctx, &constant);
} else {
mrb_raisef(mrb, E_ARGUMENT_ERROR,
"unsupported constant to append to expression: %S",
mrb_constant);
}
}
break;
}
grn_mrb_ctx_check(mrb);
return mrb_nil_value();
}
void
test_scan_search(void)
{
grn_obj *cond, *expr, *v, 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);
cut_assert_not_null((expr = grn_expr_create(&context, NULL, 0)));
v = grn_expr_add_var(&context, expr, NULL, 0);
GRN_BULK_REWIND(&textbuf);
grn_expr_append_const(&context, expr, &textbuf);
GRN_UINT32_SET(&context, &intbuf, GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC);
grn_expr_append_const(&context, expr, &intbuf);
grn_expr_append_obj(&context, expr, docs);
GRN_UINT32_SET(&context, &intbuf, 0);
grn_expr_append_const(&context, expr, &intbuf);
grn_expr_append_op(&context, expr, GRN_OP_TABLE_CREATE, 4);
grn_expr_append_obj(&context, expr, v);
grn_expr_append_op(&context, expr, GRN_OP_VAR_SET_VALUE, 2);
grn_expr_append_obj(&context, expr, docs);
grn_expr_append_obj(&context, expr, cond);
grn_expr_append_obj(&context, expr, v);
GRN_UINT32_SET(&context, &intbuf, GRN_SEL_OR);
grn_expr_append_const(&context, expr, &intbuf);
grn_expr_append_op(&context, expr, GRN_OP_TABLE_SCAN, 4);
grn_expr_append_obj(&context, expr, index_body);
GRN_TEXT_SETS(&context, &textbuf, "moge");
grn_expr_append_const(&context, expr, &textbuf);
grn_expr_append_obj(&context, expr, v);
GRN_UINT32_SET(&context, &intbuf, GRN_SEL_AND);
grn_expr_append_const(&context, expr, &intbuf);
grn_expr_append_op(&context, expr, GRN_OP_OBJ_SEARCH, 4);
grn_expr_append_obj(&context, expr, v);
GRN_TEXT_SETS(&context, &textbuf, ".size .:score .body");
grn_expr_append_const(&context, expr, &textbuf);
GRN_BULK_REWIND(&textbuf);
grn_expr_append_obj(&context, expr, &textbuf);
grn_expr_append_op(&context, expr, GRN_OP_JSON_PUT, 3);
grn_expr_exec(&context, expr);
cut_assert_equal_substring("[[14, 4, \"moge moge moge\"], [14, 2, \"moge hoge hoge\"]]",
GRN_TEXT_VALUE(&textbuf), GRN_TEXT_LEN(&textbuf));
grn_test_assert(grn_obj_close(&context, expr));
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_expr_query(void)
{
grn_obj *t1, *c1, *lc, *ft, *v, *expr;
grn_obj textbuf, intbuf;
grn_id r1, r2, r3, r4;
/* actual table */
t1 = grn_table_create(&context, "t1", 2, 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, NULL,
GRN_OBJ_TABLE_PAT_KEY|GRN_OBJ_PERSISTENT,
grn_ctx_at(&context, GRN_DB_SHORTTEXT), 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, 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, NULL,
GRN_OBJ_COLUMN_INDEX|GRN_OBJ_PERSISTENT|GRN_OBJ_WITH_POSITION, t1);
cut_assert_not_null(ft);
GRN_TEXT_INIT(&textbuf, 0);
GRN_UINT32_INIT(&intbuf, 0);
/* link between actual column and fulltext index */
GRN_UINT32_SET(&context, &intbuf, grn_obj_id(&context, c1));
grn_obj_set_info(&context, ft, GRN_INFO_SOURCE, &intbuf); /* 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, &textbuf, "abhij");
grn_test_assert(grn_obj_set_value(&context, c1, r1, &textbuf, GRN_OBJ_SET));
r2 = grn_table_add(&context, t1, NULL, 0, NULL);
cut_assert_equal_int(2, r2);
GRN_TEXT_SETS(&context, &textbuf, "fghij");
grn_test_assert(grn_obj_set_value(&context, c1, r2, &textbuf, GRN_OBJ_SET));
r3 = grn_table_add(&context, t1, NULL, 0, NULL);
cut_assert_equal_int(3, r3);
GRN_TEXT_SETS(&context, &textbuf, "11 22 33");
grn_test_assert(grn_obj_set_value(&context, c1, r3, &textbuf, GRN_OBJ_SET));
r4 = grn_table_add(&context, t1, NULL, 0, NULL);
cut_assert_equal_int(4, r4);
GRN_TEXT_SETS(&context, &textbuf, "44 22 55");
grn_test_assert(grn_obj_set_value(&context, c1, r4, &textbuf, 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(17, grn_table_size(&context, lc));
cut_assert_not_null((expr = grn_expr_create(&context, NULL, 0)));
v = grn_expr_add_var(&context, expr, NULL, 0);
GRN_BULK_REWIND(&textbuf);
grn_expr_append_const(&context, expr, &textbuf);
GRN_UINT32_SET(&context, &intbuf, GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC);
grn_expr_append_const(&context, expr, &intbuf);
grn_expr_append_obj(&context, expr, t1);
GRN_UINT32_SET(&context, &intbuf, 0);
grn_expr_append_const(&context, expr, &intbuf);
grn_expr_append_op(&context, expr, GRN_OP_TABLE_CREATE, 4);
grn_expr_append_obj(&context, expr, v);
grn_expr_append_op(&context, expr, GRN_OP_VAR_SET_VALUE, 2);
grn_expr_append_obj(&context, expr, ft);
GRN_TEXT_SETS(&context, &textbuf, "hij");
grn_expr_append_const(&context, expr, &textbuf);
grn_expr_append_obj(&context, expr, v);
GRN_UINT32_SET(&context, &intbuf, GRN_SEL_OR);
grn_expr_append_const(&context, expr, &intbuf);
grn_expr_append_op(&context, expr, GRN_OP_OBJ_SEARCH, 4);
grn_expr_append_obj(&context, expr, v);
GRN_TEXT_SETS(&context, &textbuf, ".c1 .:score");
grn_expr_append_const(&context, expr, &textbuf);
GRN_BULK_REWIND(&textbuf);
grn_expr_append_obj(&context, expr, &textbuf);
grn_expr_append_op(&context, expr, GRN_OP_JSON_PUT, 3);
grn_expr_compile(&context, expr);
grn_expr_exec(&context, expr);
cut_assert_equal_uint(0, grn_obj_close(&context, expr));
cut_assert_equal_substring("[[\"abhij\", 1], [\"fghij\", 1]]",
GRN_TEXT_VALUE(&textbuf), GRN_TEXT_LEN(&textbuf));
grn_obj_close(&context, &textbuf);
grn_obj_close(&context, ft);
grn_obj_close(&context, c1);
grn_obj_close(&context, lc);
grn_obj_close(&context, t1);
}
void
test_persistent_expr(void)
{
int i;
grn_obj *t1, *t2, *c1, *c2, buf;
t1 = grn_table_create(&context, "t1", 2, NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, 0);
cut_assert_not_null(t1);
t2 = grn_table_create(&context, "t2", 2, NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, 0);
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_TEXT_INIT(&buf, 0);
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_BULK_REWIND(&buf);
grn_bulk_write(&context, &buf, (char *)&i2, sizeof(grn_id));
grn_obj_set_value(&context, c1, i1, &buf, GRN_OBJ_SET);
grn_obj_set_value(&context, c2, i2, &buf, GRN_OBJ_SET);
}
{
grn_obj *expr = grn_expr_create(&context, "test", 4);
grn_obj *v;
cut_assert_not_null(expr);
v = grn_expr_add_var(&context, expr, "foo", 3);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, t1));
grn_expr_append_obj(&context, expr, v);
GRN_TEXT_SETS(&context, &buf, "c1");
grn_expr_append_const(&context, expr, &buf);
grn_expr_append_op(&context, expr, GRN_OP_OBJ_GET_VALUE, 2);
GRN_TEXT_SETS(&context, &buf, "c2");
grn_expr_append_const(&context, expr, &buf);
grn_expr_append_op(&context, expr, GRN_OP_OBJ_GET_VALUE, 2);
GRN_TEXT_SETS(&context, &buf, "c1");
grn_expr_append_const(&context, expr, &buf);
/*
GRN_TEXT_SETS(&context, &buf, "c1.c2.c1");
grn_expr_append_const(&context, expr, &buf);
*/
grn_expr_append_op(&context, expr, GRN_OP_OBJ_GET_VALUE, 2);
grn_expr_compile(&context, expr);
}
cut_assert_equal_uint(0, grn_obj_close(&context, &buf));
grn_db_close(&context, database);
database = grn_db_open(&context, path);
GRN_TEXT_INIT(&buf, 0);
{
grn_id id;
uint64_t et;
int nerr = 0;
grn_obj *r, *v;
grn_table_cursor *tc;
struct timeval tvb, tve;
grn_obj *expr = grn_ctx_get(&context, "test", 4);
v = grn_expr_get_var(&context, expr, "foo", 3);
t1 = grn_ctx_get(&context, "t1", 2);
tc = grn_table_cursor_open(&context, t1, NULL, 0, NULL, 0, 0);
cut_assert_not_null(tc);
gettimeofday(&tvb, NULL);
while ((id = grn_table_cursor_next(&context, tc))) {
GRN_RECORD_SET(&context, v, id);
r = grn_expr_exec(&context, expr);
if (GRN_RECORD_VALUE(r) != 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);
cut_assert_equal_uint(0, grn_table_cursor_close(&context, tc));
}
cut_assert_equal_uint(0, grn_obj_close(&context, &buf));
}
void
test_expr(void)
{
int i;
grn_obj *t1, *t2, *c1, *c2, r1, r2, buf;
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_TEXT_INIT(&buf, 0);
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_obj *r, *v;
expr = grn_expr_create(context, NULL, 0);
cut_assert_not_null(expr);
v = grn_expr_add_var(context, expr, NULL, 0);
GRN_RECORD_INIT(v, 0, grn_obj_id(context, t1));
grn_expr_append_obj(context, expr, v, GRN_OP_PUSH, 1);
GRN_TEXT_SETS(context, &buf, "c1");
grn_expr_append_const(context, expr, &buf, GRN_OP_PUSH, 1);
grn_expr_append_op(context, expr, GRN_OP_GET_VALUE, 2);
GRN_TEXT_SETS(context, &buf, "c2");
grn_expr_append_const(context, expr, &buf, GRN_OP_PUSH, 1);
grn_expr_append_op(context, expr, GRN_OP_GET_VALUE, 2);
GRN_TEXT_SETS(context, &buf, "c1");
grn_expr_append_const(context, expr, &buf, GRN_OP_PUSH, 1);
// GRN_TEXT_SETS(context, &buf, "c1.c2.c1");
// grn_expr_append_const(context, expr, &buf);
grn_expr_append_op(context, expr, GRN_OP_GET_VALUE, 2);
grn_expr_compile(context, expr);
{
grn_id id;
uint64_t et;
int nerr = 0;
grn_table_cursor *tc;
struct timeval tvb, tve;
tc = grn_table_cursor_open(context, t1, NULL, 0, NULL, 0, 0, -1, 0);
cut_assert_not_null(tc);
gettimeofday(&tvb, NULL);
while ((id = grn_table_cursor_next(context, tc))) {
GRN_RECORD_SET(context, v, id);
grn_expr_exec(context, expr, 0);
r = grn_ctx_pop(context);
if (GRN_RECORD_VALUE(r) != 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, &r1));
grn_test_assert(grn_obj_close(context, &r2));
grn_test_assert(grn_obj_close(context, &buf));
}
