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