void
test_accessor(void)
{
int i;
grn_obj *t1, *t2, *c1, *c2, r1, r2;
t1 = grn_table_create(context, "t1", 2, NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, NULL);
cut_assert_not_null(t1);
t2 = grn_table_create(context, "t2", 2, NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, NULL);
cut_assert_not_null(t2);
c1 = grn_column_create(context, t1, "c1", 2, NULL,
GRN_OBJ_PERSISTENT, t2);
cut_assert_not_null(c1);
c2 = grn_column_create(context, t2, "c2", 2, NULL,
GRN_OBJ_PERSISTENT, t1);
cut_assert_not_null(c2);
GRN_RECORD_INIT(&r1, 0, grn_obj_id(context, t1));
GRN_RECORD_INIT(&r2, 0, grn_obj_id(context, t2));
for (i = 0; i < NRECORDS; i++) {
grn_id i1, i2;
i1 = grn_table_add(context, t1, NULL, 0, NULL);
i2 = grn_table_add(context, t2, NULL, 0, NULL);
GRN_RECORD_SET(context, &r1, i1);
GRN_RECORD_SET(context, &r2, i2);
grn_obj_set_value(context, c1, i1, &r2, GRN_OBJ_SET);
grn_obj_set_value(context, c2, i2, &r1, GRN_OBJ_SET);
}
{
grn_id id;
uint64_t et;
int nerr = 0;
struct timeval tvb, tve;
grn_obj *a = grn_obj_column(context, t1, "c1.c2.c1", 8);
grn_table_cursor *tc = grn_table_cursor_open(context, t1, NULL, 0, NULL, 0, 0, -1, 0);
cut_assert_not_null(a);
cut_assert_not_null(tc);
gettimeofday(&tvb, NULL);
while ((id = grn_table_cursor_next(context, tc))) {
GRN_BULK_REWIND(&r2);
grn_obj_get_value(context, a, id, &r2);
if (GRN_RECORD_VALUE(&r2) != id) {
nerr++;
}
}
gettimeofday(&tve, NULL);
et = (tve.tv_sec - tvb.tv_sec) * 1000000 + (tve.tv_usec - tvb.tv_usec);
// printf("et=%zu\n", et);
cut_assert_equal_uint(0, nerr);
grn_test_assert(grn_table_cursor_close(context, tc));
grn_test_assert(grn_obj_close(context, a));
}
grn_test_assert(grn_obj_close(context, &r1));
grn_test_assert(grn_obj_close(context, &r2));
}
void
test_columns(void)
{
assert_send_command("table_create Users TABLE_HASH_KEY ShortText");
assert_send_command("column_create Users age COLUMN_SCALAR UInt32");
assert_send_command("column_create Users comment COLUMN_SCALAR Text");
cut_assert_equal_string(
cut_take_printf("["
"["
"[\"id\",\"UInt32\"],"
"[\"name\",\"ShortText\"],"
"[\"path\",\"ShortText\"],"
"[\"type\",\"ShortText\"],"
"[\"flags\",\"ShortText\"],"
"[\"domain\",\"ShortText\"],"
"[\"range\",\"ShortText\"],"
"[\"source\",\"ShortText\"]"
"],"
"[%d,"
"\"_key\","
"\"\","
"\"\","
"\"COLUMN_SCALAR\","
"\"Users\","
"\"ShortText\","
"[]"
"],"
"[%d,"
"\"comment\","
"\"%s.0000102\","
"\"var\","
"\"COLUMN_SCALAR|PERSISTENT\","
"\"Users\","
"\"Text\","
"[]"
"],"
"[%d,"
"\"age\","
"\"%s.0000101\","
"\"fix\","
"\"COLUMN_SCALAR|PERSISTENT\","
"\"Users\","
"\"UInt32\","
"[]"
"]"
"]",
grn_obj_id(context, get("Users")),
grn_obj_id(context, get("Users.comment")), database_path,
grn_obj_id(context, get("Users.age")), database_path),
send_command("column_list Users"));
}
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_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));
}
static grn_rc
set_index_source(grn_obj *index, grn_obj *source)
{
grn_rc rc;
grn_obj buf;
grn_id id = grn_obj_id(context, source);
GRN_TEXT_INIT(&buf, 0);
grn_bulk_write(context, &buf, (void *)&id, sizeof(grn_id));
cut_assert_equal_int(grn_obj_get_nhooks(context, source, GRN_HOOK_SET), 0);
rc = grn_obj_set_info(context, index, GRN_INFO_SOURCE, &buf);
cut_assert_equal_int(grn_obj_get_nhooks(context, source, GRN_HOOK_SET), 1);
GRN_BULK_REWIND(&buf);
cut_assert_null(grn_obj_get_hook(context, source, GRN_HOOK_SET, 0, &buf));
cut_assert_equal_int(*((grn_id *)GRN_BULK_HEAD(&buf)), grn_obj_id(context, index));
grn_obj_close(context, &buf);
return rc;
}
grn_bool
grn_obj_is_text_family_type(grn_ctx *ctx, grn_obj *obj)
{
if (!grn_obj_is_type(ctx, obj)) {
return GRN_FALSE;
}
return GRN_TYPE_IS_TEXT_FAMILY(grn_obj_id(ctx, obj));
}
VALUE
rb_grn_value_to_ruby_object (grn_ctx *context,
grn_obj *value,
grn_obj *range,
VALUE related_object)
{
if (!value)
return Qnil;
switch (value->header.type) {
case GRN_VOID:
return Qnil;
break;
case GRN_BULK:
if (GRN_BULK_EMPTYP(value))
return Qnil;
if (value->header.domain == GRN_ID_NIL && range)
value->header.domain = grn_obj_id(context, range);
return GRNBULK2RVAL(context, value, range, related_object);
break;
case GRN_UVECTOR:
{
VALUE rb_value, rb_range = Qnil;
grn_id *uvector, *uvector_end;
rb_value = rb_ary_new();
if (range)
rb_range = GRNTABLE2RVAL(context, range, GRN_FALSE);
uvector = (grn_id *)GRN_BULK_HEAD(value);
uvector_end = (grn_id *)GRN_BULK_CURR(value);
for (; uvector < uvector_end; uvector++) {
VALUE record = Qnil;
if (*uvector != GRN_ID_NIL)
record = rb_grn_record_new(rb_range, *uvector, Qnil);
rb_ary_push(rb_value, record);
}
return rb_value;
}
break;
case GRN_VECTOR:
return GRNVECTOR2RVAL(context, value);
break;
default:
rb_raise(rb_eGrnError,
"unsupported value type: %s(%#x): %s",
rb_grn_inspect_type(value->header.type),
value->header.type,
rb_grn_inspect(related_object));
break;
}
if (!range)
return GRNOBJECT2RVAL(Qnil, context, value, GRN_FALSE);
return Qnil;
}
void
test_index_columns(void)
{
assert_send_command("table_create Sites TABLE_HASH_KEY ShortText");
assert_send_command("table_create Terms TABLE_PAT_KEY ShortText");
assert_send_command("column_create Terms Sites_key "
"COLUMN_INDEX|WITH_POSITION Sites _key");
assert_send_command("load '[[\"_key\"],[\"groonga.org\"]]' Sites");
cut_assert_equal_string(
cut_take_printf("["
"["
"[\"id\",\"UInt32\"],"
"[\"name\",\"ShortText\"],"
"[\"path\",\"ShortText\"],"
"[\"type\",\"ShortText\"],"
"[\"flags\",\"ShortText\"],"
"[\"domain\",\"ShortText\"],"
"[\"range\",\"ShortText\"],"
"[\"source\",\"ShortText\"]"
"],"
"[%d,"
"\"_key\","
"\"\","
"\"\","
"\"COLUMN_SCALAR\","
"\"Terms\","
"\"ShortText\","
"[]"
"],"
"[%d,"
"\"Sites_key\","
"\"%s.0000102\","
"\"index\",\"COLUMN_INDEX|WITH_POSITION|PERSISTENT\","
"\"Terms\","
"\"Sites\","
"[\"Sites\"]"
"]"
"]",
grn_obj_id(context, get("Terms")),
grn_obj_id(context, get("Terms.Sites_key")),
database_path),
send_command("column_list Terms"));
}
grn_bool
grn_obj_is_builtin(grn_ctx *ctx, grn_obj *obj)
{
grn_id id;
if (!obj) { return GRN_FALSE; }
id = grn_obj_id(ctx, obj);
return grn_id_is_builtin(ctx, id);
}
static int
print_tableinfo(grn_ctx *ctx, grn_obj *table, grn_obj *buf, grn_content_type otype)
{
grn_id id;
char name[GRN_TABLE_MAX_KEY_SIZE];
const char *path;
int name_len;
switch (table->header.type) {
case GRN_TABLE_HASH_KEY:
case GRN_TABLE_PAT_KEY:
case GRN_TABLE_NO_KEY:
case GRN_TABLE_VIEW:
break;
default:
return 0;
}
id = grn_obj_id(ctx, table);
name_len = grn_obj_name(ctx, table, name, GRN_TABLE_MAX_KEY_SIZE);
path = grn_obj_path(ctx, table);
switch (otype) {
case GRN_CONTENT_TSV:
grn_text_itoa(ctx, buf, id);
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_esc(ctx, buf, name, name_len);
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_esc(ctx, buf, path, GRN_STRLEN(path));
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_itoa(ctx, buf, table->header.flags);
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_itoa(ctx, buf, table->header.domain);
/* TODO: domain to str */
break;
case GRN_CONTENT_JSON:
GRN_TEXT_PUTC(ctx, buf, '[');
grn_text_itoa(ctx, buf, id);
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_esc(ctx, buf, name, name_len);
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_esc(ctx, buf, path, GRN_STRLEN(path));
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_itoa(ctx, buf, table->header.flags);
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_itoa(ctx, buf, table->header.domain);
/* TODO: domain to str */
GRN_TEXT_PUTC(ctx, buf, ']');
break;
}
return 1;
}
static grn_obj *
proc_column_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_flags flags = grn_atoi(GRN_TEXT_VALUE(&vars[2].value),
GRN_BULK_CURR(&vars[2].value), NULL);
grn_obj *column, *table = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[0].value),
GRN_TEXT_LEN(&vars[0].value));
grn_obj *type = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[3].value),
GRN_TEXT_LEN(&vars[3].value));
if (GRN_TEXT_LEN(&vars[1].value)) {
flags |= GRN_OBJ_PERSISTENT;
}
column = grn_column_create(ctx, table,
GRN_TEXT_VALUE(&vars[1].value),
GRN_TEXT_LEN(&vars[1].value),
NULL, flags, type);
if (column) {
if (GRN_TEXT_LEN(&vars[4].value)) {
grn_obj sources, source_ids, **p, **pe;
GRN_PTR_INIT(&sources, GRN_OBJ_VECTOR, GRN_ID_NIL);
GRN_UINT32_INIT(&source_ids, GRN_OBJ_VECTOR);
grn_obj_columns(ctx, type,
GRN_TEXT_VALUE(&vars[4].value),
GRN_TEXT_LEN(&vars[4].value),
&sources);
p = (grn_obj **)GRN_BULK_HEAD(&sources);
pe = (grn_obj **)GRN_BULK_CURR(&sources);
while (p < pe) {
grn_id source_id = grn_obj_id(ctx, *p++);
if (source_id) {
GRN_UINT32_PUT(ctx, &source_ids, source_id);
}
}
if (GRN_BULK_VSIZE(&source_ids)) {
grn_obj_set_info(ctx, column, GRN_INFO_SOURCE, &source_ids);
}
GRN_OBJ_FIN(ctx, &source_ids);
GRN_OBJ_FIN(ctx, &sources);
}
grn_obj_unlink(ctx, column);
}
GRN_TEXT_PUTS(ctx, buf, ctx->rc ? "false" : "true");
}
return buf;
}
void
test_id_is_text_family(gconstpointer data)
{
const gchar *name;
grn_obj *object;
grn_id id;
name = gcut_data_get_string(data, "name");
object = grn_ctx_get(context, name, strlen(name));
id = grn_obj_id(context, object);
if (gcut_data_get_string(data, "expected")) {
cut_assert_true(grn_type_id_is_text_family(context, id));
} else {
cut_assert_false(grn_type_id_is_text_family(context, id));
}
}
void
test_vector_column(gconstpointer data)
{
const gchar *expected;
grn_id id, type_id;
grn_obj vector;
grn_obj *elements;
grn_obj *table, *column;
const gchar *type_name;
type_name = gcut_data_get_string(data, "type_name");
type_id = grn_obj_id(context, get_object(type_name));
table = table_create("Table", GRN_OBJ_TABLE_NO_KEY, NULL, NULL);
grn_test_assert_context(context);
column = column_create("Table", "Column", GRN_OBJ_COLUMN_VECTOR,
type_name, NULL);
grn_test_assert_context(context);
id = grn_table_add(context, table, NULL, 0, NULL);
grn_test_assert_context(context);
cut_assert_equal_int(1, id);
elements = construct_elements(data);
GRN_TEXT_INIT(&vector, GRN_OBJ_VECTOR);
grn_vector_add_element(context, &vector,
GRN_TEXT_VALUE(&elements[0]),
GRN_TEXT_LEN(&elements[0]), 0, type_id);
grn_vector_add_element(context, &vector,
GRN_TEXT_VALUE(&elements[1]),
GRN_TEXT_LEN(&elements[1]), 0, type_id);
grn_vector_add_element(context, &vector,
GRN_TEXT_VALUE(&elements[2]),
GRN_TEXT_LEN(&elements[2]), 0, type_id);
grn_obj_set_value(context, column, id, &vector, GRN_OBJ_SET);
expected = cut_take_printf("table_create Table TABLE_NO_KEY\n"
"column_create Table Column COLUMN_VECTOR %s\n"
"load --table Table\n"
"[\n"
"[\"_id\",\"Column\"],\n"
"[1,%s]\n"
"]",
type_name,
gcut_data_get_string(data, "expected"));
cut_assert_equal_string(expected, send_command("dump"));
GRN_OBJ_FIN(context, &vector);
}
static grn_id
resolve_source_id (grn_ctx *context, grn_obj *column, VALUE rb_source)
{
grn_id source_id;
if (CBOOL2RVAL(rb_obj_is_kind_of(rb_source, rb_cInteger))) {
source_id = NUM2UINT(rb_source);
} else {
grn_obj *source;
if (TYPE(rb_source) == T_STRING) {
grn_obj *table;
const char *name;
const char *dot_point;
int length;
table = grn_ctx_at(context, grn_obj_get_range(context, column));
name = StringValueCStr(rb_source);
length = RSTRING_LEN(rb_source);
dot_point = strstr(name, ".");
if (dot_point) {
char table_name[4096];
int table_name_length;
table_name_length = grn_obj_name(context, table,
table_name, sizeof(table_name));
table_name[table_name_length] = '\0';
if (strncmp(table_name, name, dot_point - name) != 0) {
rb_raise(rb_eArgError,
"wrong table's column: <%s>: "
"expected table: <%s>",
name, table_name);
}
length -= (dot_point - name) + 1;
name = dot_point + 1;
}
source = grn_obj_column(context, table, name, length);
} else {
source = RVAL2GRNOBJECT(rb_source, &context);
}
rb_grn_context_check(context, rb_source);
source_id = grn_obj_id(context, source);
}
return source_id;
}
static grn_id
create_table(const gchar *name, grn_obj_flags flags, const gchar *key_type_name)
{
grn_obj *key_type = NULL;
grn_obj *table;
if (key_type_name) {
key_type = grn_ctx_get(&context, key_type_name, strlen(key_type_name));
}
table = grn_table_create(&context, name, strlen(name),
NULL, GRN_OBJ_PERSISTENT | flags,
key_type, NULL);
if (key_type) {
grn_obj_unlink(&context, key_type);
}
return grn_obj_id(&context, table);
}
static void
create_terms_table(void)
{
terms = grn_table_create(&context, "terms", 5, NULL,
GRN_OBJ_TABLE_PAT_KEY|GRN_OBJ_PERSISTENT,
grn_ctx_at(&context, GRN_DB_SHORT_TEXT), NULL);
cut_assert_not_null(terms);
grn_test_assert(grn_obj_set_info(&context, terms, GRN_INFO_DEFAULT_TOKENIZER,
grn_ctx_at(&context, GRN_DB_BIGRAM)));
index_body = grn_column_create(&context, terms, "docs_body", 4, NULL,
GRN_OBJ_COLUMN_INDEX|GRN_OBJ_PERSISTENT|GRN_OBJ_WITH_POSITION,
docs);
cut_assert_not_null(index_body);
GRN_UINT32_SET(&context, &int_buf, grn_obj_id(&context, body));
grn_obj_set_info(&context, index_body, GRN_INFO_SOURCE, &int_buf);
}
void
test_id_is_number_family(gconstpointer data)
{
const gchar *name;
grn_obj *object;
grn_id id;
assert_send_command("table_create Users TABLE_HASH_KEY ShortText");
name = gcut_data_get_string(data, "name");
object = grn_ctx_get(context, name, strlen(name));
id = grn_obj_id(context, object);
if (gcut_data_get_string(data, "expected")) {
cut_assert_true(grn_type_id_is_number_family(context, id));
} else {
cut_assert_false(grn_type_id_is_number_family(context, id));
}
}
/*
This function registers a plugin to a database.
*/
grn_rc
GRN_PLUGIN_REGISTER(grn_ctx *ctx)
{
grn_rc rc;
rc = grn_tokenizer_register(ctx, "TokenMecab", 10,
mecab_init, mecab_next, mecab_fin);
if (rc == GRN_SUCCESS) {
grn_obj *token_mecab;
token_mecab = grn_ctx_get(ctx, "TokenMecab", 10);
/* Just for backward compatibility. TokenMecab was built-in not plugin. */
if (token_mecab && grn_obj_id(ctx, token_mecab) != GRN_DB_MECAB) {
rc = GRN_FILE_CORRUPT;
}
}
return rc;
}
static void
prepare_data(grn_obj *textbuf, grn_obj *intbuf)
{
docs = grn_table_create(&context, "docs", 4, NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, 0);
cut_assert_not_null(docs);
terms = grn_table_create(&context, "terms", 5, NULL,
GRN_OBJ_TABLE_PAT_KEY|GRN_OBJ_PERSISTENT,
grn_ctx_at(&context, GRN_DB_SHORTTEXT), 0);
cut_assert_not_null(terms);
grn_test_assert(grn_obj_set_info(&context, terms, GRN_INFO_DEFAULT_TOKENIZER,
grn_ctx_at(&context, GRN_DB_BIGRAM)));
size = grn_column_create(&context, docs, "size", 4, NULL,
GRN_OBJ_COLUMN_SCALAR|GRN_OBJ_PERSISTENT,
grn_ctx_at(&context, GRN_DB_UINT32));
cut_assert_not_null(size);
body = grn_column_create(&context, docs, "body", 4, NULL,
GRN_OBJ_COLUMN_SCALAR|GRN_OBJ_PERSISTENT,
grn_ctx_at(&context, GRN_DB_TEXT));
cut_assert_not_null(body);
index_body = grn_column_create(&context, terms, "docs_body", 4, NULL,
GRN_OBJ_COLUMN_INDEX|GRN_OBJ_PERSISTENT|GRN_OBJ_WITH_POSITION,
docs);
cut_assert_not_null(index_body);
GRN_UINT32_SET(&context, intbuf, grn_obj_id(&context, body));
grn_obj_set_info(&context, index_body, GRN_INFO_SOURCE, intbuf);
INSERT_DATA("hoge");
INSERT_DATA("fuga fuga");
INSERT_DATA("moge moge moge");
INSERT_DATA("hoge hoge");
INSERT_DATA("hoge fuga fuga");
INSERT_DATA("hoge moge moge moge");
INSERT_DATA("moge hoge hoge");
INSERT_DATA("moge hoge fuga fuga");
INSERT_DATA("moge hoge moge moge moge");
INSERT_DATA("poyo moge hoge moge moge moge");
}
/*
* Tokenize a string using the table as lexicon.
*
* @overload tokenize(string, options={})
* @param [String] string The string to be tokenized.
* @param [::Hash] options
* @option options [Bool] :add (true) Adds a new token to the table if true.
* Returned tokens include the new token. Otherwise, a new token is
* just ignored.
* @return [::Array<Groonga::Record>] Tokenized tokens.
*/
static VALUE
rb_grn_table_key_support_tokenize (int argc, VALUE *argv, VALUE self)
{
VALUE rb_string, rb_add_p;
VALUE rb_options;
VALUE rb_tokens = Qnil;
grn_ctx *context;
grn_obj *table;
char *string;
int string_size;
grn_bool add_p;
grn_obj tokens;
rb_scan_args(argc, argv, "11", &rb_string, &rb_options);
rb_grn_scan_options(rb_options,
"add", &rb_add_p,
NULL);
if (NIL_P(rb_add_p)) {
rb_add_p = Qtrue;
}
rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
NULL, NULL, NULL,
NULL, NULL, NULL,
NULL);
string = StringValueCStr(rb_string);
string_size = RSTRING_LEN(rb_string);
add_p = RVAL2CBOOL(rb_add_p);
GRN_RECORD_INIT(&tokens, GRN_OBJ_VECTOR, grn_obj_id(context, table));
grn_table_tokenize(context, table, string, string_size, &tokens, add_p);
if (context->rc == GRN_SUCCESS) {
rb_tokens = GRNUVECTOR2RVAL(context, &tokens, table, self);
}
grn_obj_unlink(context, &tokens);
rb_grn_context_check(context, self);
return rb_tokens;
}
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");
}
static void
insert_and_search(grn_obj *users, grn_obj *items, grn_obj *checks, grn_obj *checked)
{
grn_id user1 = grn_table_add(context, users, NULL, 0, NULL);
grn_id user2 = grn_table_add(context, users, NULL, 0, NULL);
grn_id item = grn_table_add(context, items, NULL, 0, NULL);
grn_obj value, *res;
GRN_TEXT_INIT(&value, 0);
res = grn_table_create(context, NULL, 0, NULL, GRN_TABLE_HASH_KEY, users, 0);
cut_assert_not_null(res);
grn_bulk_write(context, &value, (void *)&item, sizeof(grn_id));
value.header.domain = grn_obj_id(context, items);
grn_test_assert(grn_obj_set_value(context, checks, user1, &value, GRN_OBJ_SET));
grn_test_assert(grn_obj_search(context, checked, &value, res, GRN_OP_OR, NULL));
cut_assert_equal_int(grn_table_size(context, res), 1);
grn_test_assert(grn_obj_set_value(context, checks, user2, &value, GRN_OBJ_SET));
grn_test_assert(grn_obj_search(context, checked, &value, res, GRN_OP_OR, NULL));
cut_assert_equal_int(grn_table_size(context, res), 2);
grn_obj_close(context, &value);
grn_obj_close(context, res);
}
VALUE
rb_grn_value_to_ruby_object (grn_ctx *context,
grn_obj *value,
grn_obj *range,
VALUE related_object)
{
if (!value)
return Qnil;
switch (value->header.type) {
case GRN_VOID:
return Qnil;
break;
case GRN_BULK:
if (GRN_BULK_EMPTYP(value))
return Qnil;
if (value->header.domain == GRN_ID_NIL && range)
value->header.domain = grn_obj_id(context, range);
return GRNBULK2RVAL(context, value, range, related_object);
break;
case GRN_UVECTOR:
return GRNUVECTOR2RVAL(context, value, range, related_object);
break;
case GRN_VECTOR:
return GRNVECTOR2RVAL(context, value);
break;
default:
rb_raise(rb_eGrnError,
"unsupported value type: %s(%#x): %s",
rb_grn_inspect_type(value->header.type),
value->header.type,
rb_grn_inspect(related_object));
break;
}
if (!range)
return GRNOBJECT2RVAL(Qnil, context, value, GRN_FALSE);
return Qnil;
}
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");
}
grn_obj *
grn_inspect_name(grn_ctx *ctx, grn_obj *buf, grn_obj *obj)
{
int name_size;
name_size = grn_obj_name(ctx, obj, NULL, 0);
if (name_size > 0) {
grn_bulk_space(ctx, buf, name_size);
grn_obj_name(ctx, obj, GRN_BULK_CURR(buf) - name_size, name_size);
} else {
grn_id id;
id = grn_obj_id(ctx, obj);
if (id == GRN_ID_NIL) {
GRN_TEXT_PUTS(ctx, buf, "(nil)");
} else {
GRN_TEXT_PUTS(ctx, buf, "(anonymous:");
grn_text_lltoa(ctx, buf, id);
GRN_TEXT_PUTS(ctx, buf, ")");
}
}
return buf;
}
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));
}
VALUE
rb_grn_uvector_to_ruby_object (grn_ctx *context, grn_obj *uvector,
grn_obj *range, VALUE related_object)
{
VALUE array = Qnil;
if (!uvector)
return Qnil;
if (!range) {
rb_raise(rb_eTypeError,
"unknown range uvector can't be converted: <%s>",
rb_grn_inspect(related_object));
}
switch (range->header.type) {
case GRN_TYPE: {
const char *current, *end;
grn_id range_id;
grn_obj value;
int value_size;
value_size = grn_obj_get_range(context, range);
array = rb_ary_new();
current = GRN_BULK_HEAD(uvector);
end = GRN_BULK_CURR(uvector);
range_id = grn_obj_id(context, range);
GRN_OBJ_INIT(&value, GRN_BULK, GRN_OBJ_DO_SHALLOW_COPY, range_id);
while (current < end) {
VALUE rb_value;
GRN_TEXT_SET(context, &value, current, value_size);
rb_value = GRNBULK2RVAL(context, &value, range, related_object);
rb_ary_push(array, rb_value);
current += value_size;
}
GRN_OBJ_FIN(context, &value);
break;
}
case GRN_TABLE_HASH_KEY:
case GRN_TABLE_PAT_KEY:
case GRN_TABLE_DAT_KEY:
case GRN_TABLE_NO_KEY: {
grn_id *current, *end;
VALUE rb_range = Qnil;
array = rb_ary_new();
rb_range = GRNTABLE2RVAL(context, range, GRN_FALSE);
current = (grn_id *)GRN_BULK_HEAD(uvector);
end = (grn_id *)GRN_BULK_CURR(uvector);
while (current < end) {
VALUE record = Qnil;
if (*current != GRN_ID_NIL) {
record = rb_grn_record_new(rb_range, *current, Qnil);
}
rb_ary_push(array, record);
current++;
}
break;
}
default:
rb_raise(rb_eTypeError,
"unknown range uvector can't be converted: %s(%#x): <%s>",
rb_grn_inspect_type(range->header.type),
range->header.type,
rb_grn_inspect(related_object));
break;
}
return array;
}
grn_obj *
rb_grn_bulk_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *bulk)
{
if (bulk && bulk->header.domain == GRN_DB_TIME)
return RVAL2GRNBULK_WITH_TYPE(object, context, bulk,
bulk->header.domain,
grn_ctx_at(context, bulk->header.domain));
if (!bulk) {
bulk = grn_obj_open(context, GRN_BULK, 0, GRN_ID_NIL);
rb_grn_context_check(context, object);
}
switch (TYPE(object)) {
case T_NIL:
grn_obj_reinit(context, bulk, GRN_DB_VOID, 0);
break;
case T_SYMBOL:
object = rb_funcall(object, rb_intern("to_s"), 0);
case T_STRING:
grn_obj_reinit(context, bulk, GRN_DB_TEXT, 0);
rb_grn_context_text_set(context, bulk, object);
break;
case T_FIXNUM:
case T_BIGNUM: {
int64_t int64_value;
int64_value = NUM2LL(object);
if (int64_value <= INT32_MAX) {
grn_obj_reinit(context, bulk, GRN_DB_INT32, 0);
GRN_INT32_SET(context, bulk, int64_value);
} else {
grn_obj_reinit(context, bulk, GRN_DB_INT64, 0);
GRN_INT64_SET(context, bulk, int64_value);
}
break;
}
case T_FLOAT:
grn_obj_reinit(context, bulk, GRN_DB_FLOAT, 0);
GRN_FLOAT_SET(context, bulk, NUM2DBL(object));
break;
case T_TRUE:
grn_obj_reinit(context, bulk, GRN_DB_BOOL, 0);
GRN_BOOL_SET(context, bulk, GRN_TRUE);
break;
case T_FALSE:
grn_obj_reinit(context, bulk, GRN_DB_BOOL, 0);
GRN_BOOL_SET(context, bulk, GRN_FALSE);
break;
default:
if (RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cTime))) {
VALUE sec, usec;
int64_t time_value;
sec = rb_funcall(object, rb_intern("to_i"), 0);
usec = rb_funcall(object, rb_intern("usec"), 0);
time_value = GRN_TIME_PACK(NUM2LL(sec), NUM2LL(usec));
grn_obj_reinit(context, bulk, GRN_DB_TIME, 0);
GRN_TIME_SET(context, bulk, time_value);
} else if (RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnObject))) {
grn_obj *grn_object;
grn_id id_value;
grn_object = RVAL2GRNOBJECT(object, &context);
grn_obj_reinit(context, bulk, grn_object->header.domain, 0);
id_value = grn_obj_id(context, grn_object);
GRN_RECORD_SET(context, bulk, id_value);
} else if (RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnRecord))) {
grn_obj *table;
grn_id id_value;
table = RVAL2GRNOBJECT(rb_funcall(object, rb_intern("table"), 0),
&context);
id_value = NUM2UINT(rb_funcall(object, rb_intern("id"), 0));
grn_obj_reinit(context, bulk, grn_obj_id(context, table), 0);
GRN_RECORD_SET(context, bulk, id_value);
} else {
rb_raise(rb_eTypeError,
"bulked object should be one of "
"[nil, true, false, String, Symbol, Integer, Float, Time, "
"Groonga::Object, Groonga::Record]: %s",
rb_grn_inspect(object));
}
break;
}
return bulk;
}
void
test_xml(void)
{
assert_send_command("table_create Users TABLE_HASH_KEY ShortText");
assert_send_command("column_create Users age COLUMN_SCALAR UInt32");
assert_send_command("column_create Users comment COLUMN_SCALAR Text");
cut_assert_equal_string(
cut_take_printf("<COLUMN_LIST>\n"
"<HEADER>\n"
"<PROPERTY>\n"
"<TEXT>id</TEXT>\n"
"<TEXT>UInt32</TEXT></PROPERTY>\n"
"<PROPERTY>\n"
"<TEXT>name</TEXT>\n"
"<TEXT>ShortText</TEXT></PROPERTY>\n"
"<PROPERTY>\n"
"<TEXT>path</TEXT>\n"
"<TEXT>ShortText</TEXT></PROPERTY>\n"
"<PROPERTY>\n"
"<TEXT>type</TEXT>\n"
"<TEXT>ShortText</TEXT></PROPERTY>\n"
"<PROPERTY>\n"
"<TEXT>flags</TEXT>\n"
"<TEXT>ShortText</TEXT></PROPERTY>\n"
"<PROPERTY>\n"
"<TEXT>domain</TEXT>\n"
"<TEXT>ShortText</TEXT></PROPERTY>\n"
"<PROPERTY>\n"
"<TEXT>range</TEXT>\n"
"<TEXT>ShortText</TEXT></PROPERTY>\n"
"<PROPERTY>\n"
"<TEXT>source</TEXT>\n"
"<TEXT>ShortText</TEXT></PROPERTY></HEADER>\n"
"<COLUMN>\n"
"<INT>%u</INT>\n"
"<TEXT>_key</TEXT>\n"
"<TEXT></TEXT>\n"
"<TEXT></TEXT>\n"
"<TEXT>COLUMN_SCALAR</TEXT>\n"
"<TEXT>Users</TEXT>\n"
"<TEXT>ShortText</TEXT>\n"
"<SOURCES></SOURCES></COLUMN>\n"
"<COLUMN>\n"
"<INT>%u</INT>\n"
"<TEXT>comment</TEXT>\n"
"<TEXT>%s.0000102</TEXT>\n"
"<TEXT>var</TEXT>\n"
"<TEXT>COLUMN_SCALAR|PERSISTENT</TEXT>\n"
"<TEXT>Users</TEXT>\n"
"<TEXT>Text</TEXT>\n"
"<SOURCES></SOURCES></COLUMN>\n"
"<COLUMN>\n"
"<INT>%u</INT>\n"
"<TEXT>age</TEXT>\n"
"<TEXT>%s.0000101</TEXT>\n"
"<TEXT>fix</TEXT>\n"
"<TEXT>COLUMN_SCALAR|PERSISTENT</TEXT>\n"
"<TEXT>Users</TEXT>\n"
"<TEXT>UInt32</TEXT>\n"
"<SOURCES></SOURCES></COLUMN></COLUMN_LIST>",
grn_obj_id(context, get("Users")),
grn_obj_id(context, get("Users.comment")), database_path,
grn_obj_id(context, get("Users.age")), database_path),
send_command("column_list Users --output_type xml"));
}
