void
test_recreate_temporary_object_on_opened_database(void)
{
const gchar table_name[] = "<users>";
const gchar *path;
path = cut_build_path(tmp_directory, "database.groonga", NULL);
database = grn_db_create(context, path, NULL);
grn_test_assert_not_null(context, database);
grn_test_assert_null(context,
grn_table_create(context,
table_name,
strlen(table_name),
NULL,
GRN_OBJ_TABLE_HASH_KEY,
grn_ctx_at(context, GRN_DB_UINT32),
NULL));
database2 = grn_db_open(context2, path);
grn_test_assert_not_null(context2, database2);
grn_test_assert_null(context2,
grn_ctx_get(context2,
table_name,
strlen(table_name)));
grn_test_assert_null(context2,
grn_table_create(context,
table_name,
strlen(table_name),
NULL,
GRN_OBJ_TABLE_HASH_KEY,
grn_ctx_at(context, GRN_DB_UINT32),
NULL));
}
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));
}
static void
create_documents_table(void)
{
docs = grn_table_create(&context, "docs", 4, NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, NULL);
cut_assert_not_null(docs);
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);
size_in_string = grn_column_create(&context, docs, "size_in_string", 14, NULL,
GRN_OBJ_COLUMN_SCALAR|GRN_OBJ_PERSISTENT,
grn_ctx_at(&context, GRN_DB_TEXT));
cut_assert_not_null(size_in_string);
size_in_float = grn_column_create(&context, docs, "size_in_float", 13, NULL,
GRN_OBJ_COLUMN_SCALAR|GRN_OBJ_PERSISTENT,
grn_ctx_at(&context, GRN_DB_FLOAT));
cut_assert_not_null(size_in_float);
created_at = grn_column_create(&context, docs, "created_at", 10, NULL,
GRN_OBJ_COLUMN_SCALAR|GRN_OBJ_PERSISTENT,
grn_ctx_at(&context, GRN_DB_TIME));
cut_assert_not_null(created_at);
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);
}
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");
}
static grn_obj *
proc_table_create(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_obj *buf = args[0];
grn_expr_var *vars;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
if (nvars == 6) {
grn_obj *table;
grn_obj_flags flags = grn_atoi(GRN_TEXT_VALUE(&vars[1].value),
GRN_BULK_CURR(&vars[1].value), NULL);
if (GRN_TEXT_LEN(&vars[0].value)) {
flags |= GRN_OBJ_PERSISTENT;
}
table = grn_table_create(ctx,
GRN_TEXT_VALUE(&vars[0].value),
GRN_TEXT_LEN(&vars[0].value),
NULL, flags,
grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[2].value),
GRN_TEXT_LEN(&vars[2].value)),
grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[3].value),
GRN_TEXT_LEN(&vars[3].value)));
if (table) {
grn_obj_set_info(ctx, table,
GRN_INFO_DEFAULT_TOKENIZER,
grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[4].value),
GRN_TEXT_LEN(&vars[4].value)));
grn_obj_unlink(ctx, table);
}
GRN_TEXT_PUTS(ctx, buf, ctx->rc ? "false" : "true");
}
return buf;
}
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
cut_setup(void)
{
const gchar *database_path;
cut_set_fixture_data_dir(grn_test_get_base_dir(),
"fixtures",
"geo",
NULL);
remove_tmp_directory();
g_mkdir_with_parents(tmp_directory, 0700);
context = g_new0(grn_ctx, 1);
grn_ctx_init(context, 0);
database_path = cut_build_path(tmp_directory, "database.groonga", NULL);
database = grn_db_create(context, database_path, NULL);
load_data();
points = get("Points");
short_degree_column = get("Points.short_degree");
location_index_column = get("Locations.point");
result = grn_table_create(context,
NULL, 0,
NULL,
GRN_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
points, NULL);
}
void
cut_setup(void)
{
const gchar *database_path;
cut_set_fixture_data_dir(grn_test_get_base_dir(),
"fixtures",
"story",
"taiyaki",
NULL);
remove_tmp_directory();
g_mkdir_with_parents(tmp_directory, 0700);
context = g_new0(grn_ctx, 1);
grn_ctx_init(context, 0);
database_path = cut_build_path(tmp_directory, "database.groonga", NULL);
database = grn_db_create(context, database_path, NULL);
setup_values();
load_data();
shops = get("Shops");
location_index = get("Locations.shop");
result = grn_table_create(context,
NULL, 0,
NULL,
GRN_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
shops, NULL);
}
void
test_get_persistent_object_from_opened_database(void)
{
const gchar table_name[] = "Users";
const gchar *path;
path = cut_build_path(tmp_directory, "database.groonga", NULL);
database = grn_db_create(context, path, NULL);
grn_test_assert_not_null(context, database);
grn_test_assert_not_null(context,
grn_table_create(context,
table_name,
strlen(table_name),
NULL,
GRN_OBJ_TABLE_HASH_KEY |
GRN_OBJ_PERSISTENT,
grn_ctx_at(context, GRN_DB_UINT32),
NULL));
database2 = grn_db_open(context2, path);
grn_test_assert_not_null(context2, database2);
grn_test_assert_not_null(context2,
grn_ctx_get(context2,
table_name,
strlen(table_name)));
}
int
table_put_allocate(void)
{
int i;
grn_obj *buf;
grn_obj *key_type = grn_ctx_at(&ctx, GRN_DB_SHORT_TEXT);
grn_obj *table = grn_table_create(&ctx, "<t1>", 4, NULL,
GRN_OBJ_TABLE_HASH_KEY|GRN_OBJ_PERSISTENT,
key_type, value_type);
if (!table) { return -1; }
for (i = 0; i < nloops; i++) {
int key = GENKEY(i);
buf = grn_obj_open(&ctx, GRN_BULK, 0, 0);
grn_text_itoh(&ctx, buf, key, key_size);
{
grn_id rid = grn_table_add(&ctx, table, GRN_BULK_HEAD(buf), key_size, NULL);
if (!rid) {
fprintf(stderr, "table_lookup failed");
} else {
grn_obj *value_buf;
value_buf = grn_obj_open(&ctx, GRN_BULK, 0, 0);
grn_text_itoh(&ctx, value_buf, key, key_size);
if (grn_obj_set_value(&ctx, table, rid, value_buf, GRN_OBJ_SET)) {
fprintf(stderr, "grn_obj_set_value failed");
}
grn_obj_close(&ctx, value_buf);
}
}
grn_obj_close(&ctx, buf);
}
return 0;
}
void
test_array_set_data(void)
{
grn_obj *table;
grn_id record_id;
gchar value[] = "sample value";
grn_obj *record_value;
grn_obj *retrieved_record_value;
const gchar *dupped_retrieved_record_value;
const gchar *value_type_name = "value_type";
grn_obj *value_type;
value_type = grn_type_create(context,
value_type_name, strlen(value_type_name),
0, sizeof(value));
table = grn_table_create(context, NULL, 0, NULL,
GRN_OBJ_TABLE_NO_KEY,
NULL, value_type);
record_id = grn_table_add(context, table, NULL, 0, NULL);
record_value = grn_obj_open(context, GRN_BULK, 0, GRN_DB_TEXT);
grn_bulk_write(context, record_value, value, sizeof(value));
grn_test_assert(grn_obj_set_value(context, table, record_id,
record_value, GRN_OBJ_SET));
grn_obj_unlink(context, record_value);
retrieved_record_value = grn_obj_get_value(context, table, record_id, NULL);
dupped_retrieved_record_value =
cut_take_strdup(GRN_BULK_HEAD(retrieved_record_value));
grn_obj_unlink(context, retrieved_record_value);
cut_assert_equal_string(value, dupped_retrieved_record_value);
}
/*
* call-seq:
* patricia_trie.prefix_search(prefix) -> Groonga::Hash
*
* キーが_prefix_に前方一致するレコードのIDがキーに入っている
* Groonga::Hashを返す。マッチするレコードがない場合は空の
* Groonga::Hashが返る。
*
*/
static VALUE
rb_grn_patricia_trie_prefix_search (VALUE self, VALUE rb_prefix)
{
grn_ctx *context;
grn_obj *table, *key, *domain, *result;
grn_id domain_id;
VALUE rb_result;
rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
&key, &domain_id, &domain,
NULL, NULL, NULL,
NULL);
result = grn_table_create(context, NULL, 0, NULL,
GRN_OBJ_TABLE_HASH_KEY,
table, 0);
rb_grn_context_check(context, self);
rb_result = GRNOBJECT2RVAL(Qnil, context, result, GRN_TRUE);
GRN_BULK_REWIND(key);
RVAL2GRNKEY(rb_prefix, context, key, domain_id, domain, self);
grn_pat_prefix_search(context, (grn_pat *)table,
GRN_BULK_HEAD(key), GRN_BULK_VSIZE(key),
(grn_hash *)result);
rb_grn_context_check(context, self);
return rb_result;
}
static gboolean
run_test(const gchar **test_case_names, const grn_test_data *data)
{
const gchar *type_name, *table_name;
gchar *path;
grn_test_assert(grn_ctx_init(context, GRN_CTX_USE_QL));
GRN_CTX_SET_ENCODING(context, GRN_ENC_UTF8);
type_name = "name";
type = grn_type_create(context, type_name, strlen(type_name),
GRN_OBJ_KEY_UINT, sizeof(grn_id));
path = g_build_filename(base_dir, "table", NULL);
g_setenv(GRN_TEST_ENV_TABLE_PATH, path, TRUE);
table_name = cut_take_printf("%s: performance-read-write", data->type_name);
g_setenv(GRN_TEST_ENV_TABLE_TYPE, data->type_name, TRUE);
table = grn_table_create(context,
table_name, strlen(table_name),
path, GRN_OBJ_PERSISTENT | data->flags,
type, NULL);
g_free(path);
cut_assert_not_null(table);
return run(test_case_names, data);
}
/*
* call-seq:
* Groonga::Array.create(options={}) -> Groonga::Array
* Groonga::Array.create(options={}) {|table| ... }
*
* キーのないテーブルを生成する。ブロックを指定すると、そのブ
* ロックに生成したテーブルが渡され、ブロックを抜けると自動的
* にテーブルが破棄される。
*
* @example
* #無名一時テーブルを生成する。
* Groonga::Array.create
*
* #無名永続テーブルを生成する。
* Groonga::Array.create(:path => "/tmp/array.grn")
*
* #名前付き永続テーブルを生成する。ただし、ファイル名は気にしない。
* Groonga::Array.create(:name => "Bookmarks",
* :persistent => true)
*
* #それぞれのレコードに512バイトの値を格納できる無名一時テーブルを生成する。
* Groonga::Array.create(:value => 512)
*
* @param [::Hash] options The name and value
* pairs. Omitted names are initialized as the default value.
* @option options [Grrnga::Context] :context (Groonga::Context.default) The context
* テーブルが利用するGrrnga::Context
* @option options :name The name
* テーブルの名前。名前をつけると、Groonga::Context#[]に名
* 前を指定してテーブルを取得することができる。省略すると
* 無名テーブルになり、テーブルIDでのみ取得できる。
* @option options :path The path
* テーブルを保存するパス。パスを指定すると永続テーブルとな
* り、プロセス終了後もレコードは保持される。次回起動時に
* Groonga::Context#[]で保存されたレコードを利用することが
* できる。省略すると一時テーブルになり、プロセスが終了する
* とレコードは破棄される。
* @option options :persistent The persistent
* +true+ を指定すると永続テーブルとなる。 +path+ を省略した
* 場合は自動的にパスが付加される。 +:context+ で指定した
* Groonga::Contextに結びついているデータベースが一時デー
* タベースの場合は例外が発生する。
* @option options :value_type (nil) The value_type
* 値の型を指定する。省略すると値のための領域を確保しない。
* 値を保存したい場合は必ず指定すること。
* 参考: Groonga::Type.new
* @option options [Groonga::Record#n_sub_records] :sub_records The sub_records
* +true+ を指定すると#groupでグループ化したときに、
* Groonga::Record#n_sub_recordsでグループに含まれるレコー
* ドの件数を取得できる。
*/
static VALUE
rb_grn_array_s_create (int argc, VALUE *argv, VALUE klass)
{
grn_ctx *context = NULL;
grn_obj *value_type = NULL, *table;
const char *name = NULL, *path = NULL;
unsigned name_size = 0;
grn_obj_flags flags = GRN_OBJ_TABLE_NO_KEY;
VALUE rb_table;
VALUE options, rb_context, rb_name, rb_path, rb_persistent;
VALUE rb_value_type, rb_sub_records;
rb_scan_args(argc, argv, "01", &options);
rb_grn_scan_options(options,
"context", &rb_context,
"name", &rb_name,
"path", &rb_path,
"persistent", &rb_persistent,
"value_type", &rb_value_type,
"sub_records", &rb_sub_records,
NULL);
context = rb_grn_context_ensure(&rb_context);
if (!NIL_P(rb_name)) {
name = StringValuePtr(rb_name);
name_size = RSTRING_LEN(rb_name);
flags |= GRN_OBJ_PERSISTENT;
}
if (!NIL_P(rb_path)) {
path = StringValueCStr(rb_path);
flags |= GRN_OBJ_PERSISTENT;
}
if (RVAL2CBOOL(rb_persistent))
flags |= GRN_OBJ_PERSISTENT;
if (!NIL_P(rb_value_type))
value_type = RVAL2GRNOBJECT(rb_value_type, &context);
if (RVAL2CBOOL(rb_sub_records))
flags |= GRN_OBJ_WITH_SUBREC;
table = grn_table_create(context, name, name_size, path,
flags, NULL, value_type);
if (!table)
rb_grn_context_check(context, rb_ary_new4(argc, argv));
rb_table = GRNOBJECT2RVAL(klass, context, table, GRN_TRUE);
rb_grn_context_check(context, rb_table);
rb_iv_set(rb_table, "@context", rb_context);
if (rb_block_given_p())
return rb_ensure(rb_yield, rb_table, rb_grn_object_close, rb_table);
else
return rb_table;
}
/*
* Document-method: search
*
* call-seq:
* column.search(query, options={}) -> Groonga::Hash
*
* _object_から_query_に対応するオブジェクトを検索し、見つかっ
* たオブジェクトのIDがキーになっているGroonga::Hashを返す。
*
* 利用可能なオプションは以下の通り。
*
* [_:result_]
* 結果を格納するGroonga::Hash。指定しない場合は新しく
* Groonga::Hashを生成し、それに結果を格納して返す。
* [_:operator_]
* 以下のどれかの値を指定する。+nil+, <tt>"or"</tt>, <tt>"||"</tt>,
* <tt>"and"</tt>, <tt>"+"</tt>, <tt>"&&"</tt>, <tt>"but"</tt>,
* <tt>"not"</tt>, <tt>"-"</tt>, <tt>"adjust"</tt>, <tt>">"</tt>。
* それぞれ以下のようになる。（FIXME: 「以下」）
* [_:exact_]
* +true+を指定すると完全一致で検索する
* [_:longest_common_prefix_]
* +true+を指定すると_query_と同じ接頭辞をもつエントリのう
* ち、もっとも長いエントリを検索する
* [_:suffix_]
* +true+を指定すると_query_が後方一致するエントリを検索す
* る
* [_:prefix_]
* +true+を指定すると_query_が前方一致するレコードを検索す
* る
* [_:near_]
* +true+を指定すると_query_に指定した複数の語が近傍に含ま
* れるレコードを検索する
* [...]
* ...
*/
static VALUE
rb_grn_index_column_search (int argc, VALUE *argv, VALUE self)
{
grn_ctx *context;
grn_obj *column;
grn_obj *range;
grn_obj *query = NULL, *id_query = NULL, *string_query = NULL;
grn_obj *result;
grn_operator operator;
grn_rc rc;
VALUE rb_query, options, rb_result, rb_operator;
rb_grn_index_column_deconstruct(SELF(self), &column, &context,
NULL, NULL,
NULL, NULL, NULL, &range,
&id_query, &string_query);
rb_scan_args(argc, argv, "11", &rb_query, &options);
if (CBOOL2RVAL(rb_obj_is_kind_of(rb_query, rb_cGrnQuery))) {
grn_query *_query;
_query = RVAL2GRNQUERY(rb_query);
query = (grn_obj *)_query;
} else if (CBOOL2RVAL(rb_obj_is_kind_of(rb_query, rb_cInteger))) {
grn_id id;
id = NUM2UINT(rb_query);
GRN_TEXT_SET(context, id_query, &id, sizeof(grn_id));
query = id_query;
} else {
const char *_query;
_query = StringValuePtr(rb_query);
GRN_TEXT_SET(context, string_query, _query, RSTRING_LEN(rb_query));
query = string_query;
}
rb_grn_scan_options(options,
"result", &rb_result,
"operator", &rb_operator,
NULL);
if (NIL_P(rb_result)) {
result = grn_table_create(context, NULL, 0, NULL,
GRN_OBJ_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
range, 0);
rb_grn_context_check(context, self);
rb_result = GRNOBJECT2RVAL(Qnil, context, result, RB_GRN_TRUE);
} else {
result = RVAL2GRNOBJECT(rb_result, &context);
}
operator = RVAL2GRNOPERATOR(rb_operator);
rc = grn_obj_search(context, column, query, result, operator, NULL);
rb_grn_rc_check(rc, self);
return rb_result;
}
static void
create_properties_table(void)
{
const gchar *table_name = "properties";
properties = grn_table_create(&context, table_name, strlen(table_name), NULL,
GRN_OBJ_TABLE_HASH_KEY|GRN_OBJ_PERSISTENT,
grn_ctx_at(&context, GRN_DB_SHORT_TEXT), NULL);
cut_assert_not_null(properties);
}
void
test_scalar_index(void)
{
gchar *db_path;
const gchar *name;
grn_obj *users, *items, *checks, *checked;
grn_obj_close(context, db);
remove_tmp_directory();
g_mkdir_with_parents(tmp_directory, 0700);
db_path = g_build_filename(tmp_directory, "inverted-index", NULL);
db = grn_db_create(context, db_path, NULL);
g_free(db_path);
name = "users";
users = grn_table_create(context, name, strlen(name), NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, 0);
cut_assert_not_null(users);
name = "items";
items = grn_table_create(context, name, strlen(name), NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, 0);
cut_assert_not_null(items);
name = "checks";
checks = grn_column_create(context, users, name, strlen(name), NULL,
GRN_OBJ_COLUMN_SCALAR|GRN_OBJ_PERSISTENT, items);
cut_assert_not_null(checks);
name = "checked";
checked = grn_column_create(context, items, name, strlen(name), NULL,
GRN_OBJ_COLUMN_INDEX|GRN_OBJ_PERSISTENT, users);
cut_assert_not_null(checked);
grn_test_assert(set_index_source(checked, checks));
insert_and_search(users, items, checks, checked);
grn_obj_close(context, checks);
grn_obj_close(context, checked);
grn_obj_close(context, items);
grn_obj_close(context, users);
}
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");
}
void
test_temporary_table_no_path(gpointer data)
{
grn_obj *table;
grn_obj_flags flags = GPOINTER_TO_INT(data);
table = grn_table_create(context, NULL, 0, NULL,
flags,
NULL, NULL);
cut_assert_equal_string(NULL, grn_obj_path(context, table));
}
grn_index *
grn_index_create(grn_ctx *ctx, const char *path)
{
grn_obj *db, *keys, *key_type, *lexicon, *inv, *tokenizer;
if ((db = grn_db_create(ctx, NULL, NULL))) {
char buffer[PATH_MAX];
strcpy(buffer, path);
strcat(buffer, ".SEN");
if ((key_type = grn_ctx_at(ctx, GRN_DB_SHORTTEXT))) {
if ((keys = grn_table_create(ctx, "<keys>", 6, buffer,
GRN_OBJ_TABLE_HASH_KEY|GRN_OBJ_PERSISTENT,
key_type, 0))) {
strcpy(buffer, path);
strcat(buffer, ".SEN.l");
if ((lexicon = grn_table_create(ctx, "<lexicon>", 9, buffer,
GRN_OBJ_TABLE_PAT_KEY|GRN_OBJ_PERSISTENT,
key_type, 0))) {
if ((tokenizer = grn_ctx_at(ctx, GRN_DB_MECAB))) {
grn_obj_set_info(ctx, lexicon, GRN_INFO_DEFAULT_TOKENIZER, tokenizer);
strcpy(buffer, path);
strcat(buffer, ".SEN.i");
if ((inv = grn_column_create(ctx, lexicon, "inv", 3, buffer,
GRN_OBJ_COLUMN_INDEX|GRN_OBJ_PERSISTENT,
keys))) {
grn_index *index;
if ((index = malloc(sizeof(grn_index)))) {
index->db = db;
index->keys = keys;
index->lexicon = lexicon;
index->inv = inv;
return index;
}
}
}
}
}
}
}
return NULL;
}
void
cut_setup(void)
{
gchar *table_path, *vgram_path;
const gchar *type_name, *table_name;
cut_set_fixture_data_dir(grn_test_get_base_dir(),
"fixtures",
"inverted-index",
NULL);
logger = setup_grn_logger();
expected_messages = NULL;
record_ids = NULL;
remove_tmp_directory();
g_mkdir_with_parents(tmp_directory, 0700);
path = g_build_filename(tmp_directory, "inverted-index", NULL);
context = g_new0(grn_ctx, 1);
grn_test_assert(grn_ctx_init(context, GRN_CTX_USE_QL));
GRN_CTX_SET_ENCODING(context, GRN_ENC_UTF8);
db = grn_db_create(context, NULL, NULL);
grn_ctx_use(context, db);
type_name = "name";
type = grn_type_create(context, type_name, strlen(type_name),
GRN_OBJ_KEY_VAR_SIZE, TYPE_SIZE);
table_name = "lexicon";
table_path = g_build_filename(tmp_directory, "lexicon-table", NULL);
lexicon = grn_table_create(context,
table_name, strlen(table_name),
table_path,
GRN_OBJ_PERSISTENT | GRN_OBJ_TABLE_PAT_KEY,
type, NULL);
grn_obj_set_info(context, lexicon, GRN_INFO_DEFAULT_TOKENIZER,
grn_ctx_at(context, GRN_DB_BIGRAM));
g_free(table_path);
vgram_path = g_build_filename(tmp_directory, "vgram", NULL);
/*
vgram = grn_vgram_create(vgram_path);
*/
g_free(vgram_path);
inverted_index = NULL;
}
void
test_create_with_valid_name(gpointer data)
{
grn_obj *table;
const gchar *table_name;
table_name = gcut_data_get_string(data, "name");
table = grn_table_create(context, table_name, strlen(table_name),
NULL,
GRN_OBJ_TABLE_NO_KEY | GRN_OBJ_PERSISTENT,
NULL, NULL);
grn_test_assert_context(context);
}
void
test_temporary_table_add(gpointer data)
{
grn_obj *table;
grn_obj_flags flags = GPOINTER_TO_INT(data);
gchar key[] = "key";
if ((flags & GRN_OBJ_TABLE_TYPE_MASK) == GRN_OBJ_TABLE_NO_KEY) {
table = grn_table_create(context, NULL, 0, NULL,
flags,
NULL,
NULL);
grn_table_add(context, table, NULL, 0, NULL);
} else {
table = grn_table_create(context, NULL, 0, NULL,
flags,
get_object("ShortText"),
NULL);
grn_table_add(context, table, key, strlen(key), NULL);
}
cut_assert_equal_int(1, grn_table_size(context, table));
}
static grn_obj *
grn_table_factory_make(grn_table_factory *factory)
{
grn_obj *value_type = grn_ctx_get(factory->context, VALUE_TYPE_NAME, strlen(VALUE_TYPE_NAME));
if (!value_type) {
value_type = grn_type_create(factory->context, VALUE_TYPE_NAME, strlen(VALUE_TYPE_NAME),
0, factory->value_size);
}
GRN_CTX_SET_ENCODING(factory->context, factory->encoding);
return grn_table_create(factory->context,
factory->name, factory->name_size,
factory->path, factory->flags,
factory->key_type, value_type);
}
void
test_table(gpointer data)
{
grn_obj *table;
grn_obj_flags flags = GPOINTER_TO_INT(data);
grn_table_cursor *cursor;
table = grn_table_create(context, NULL, 0, NULL,
flags,
get_object("ShortText"),
NULL);
cursor = grn_table_cursor_open(context, table, NULL, 0, NULL, 0, 0, -1, 0);
/* FIXME: grn_test_assert_equal_object() */
cut_assert_equal_pointer(table, grn_table_cursor_table(context, cursor));
}
void
test_table(gpointer data)
{
grn_obj *table;
grn_obj_flags flags = GPOINTER_TO_INT(data);
grn_table_cursor *cursor;
table = grn_table_create(&context, NULL, 0, NULL,
flags,
OBJECT("<shorttext>"),
0);
cursor = grn_table_cursor_open(&context, table, NULL, 0, NULL, 0, 0);
/* FIXME: grn_test_assert_equal_object() */
cut_assert_equal_pointer(table, grn_table_cursor_table(&context, cursor));
}
void
test_temporary_table_no_path(gpointer data)
{
grn_obj *table;
grn_obj_flags flags = GPOINTER_TO_INT(data);
grn_obj *key_type = NULL;
if ((flags & GRN_OBJ_TABLE_TYPE_MASK) != GRN_OBJ_TABLE_NO_KEY) {
key_type = grn_ctx_at(context, GRN_DB_SHORT_TEXT);
}
table = grn_table_create(context, NULL, 0, NULL,
flags,
key_type, NULL);
cut_assert_equal_string(NULL, grn_obj_path(context, table));
}
void
test_nonexistent_column(void)
{
grn_obj *table;
char table_name[] = "users";
char nonexistent_column_name[] = "nonexistent";
table = grn_table_create(context, table_name, strlen(table_name),
NULL,
GRN_OBJ_TABLE_NO_KEY,
NULL, NULL);
grn_test_assert_null(context,
grn_obj_column(context, table,
nonexistent_column_name,
strlen(nonexistent_column_name)));
}
static void
create_bookmarks_table(void)
{
const gchar bookmarks_table_name[] = "bookmarks";
bookmarks = grn_table_create(&context,
bookmarks_table_name,
strlen(bookmarks_table_name),
NULL,
GRN_OBJ_TABLE_HASH_KEY,
LOOKUP("<shorttext>"),
1024);
grn_test_assert_context(&context);
cut_set_message("%s", cut_take_string(grn_collect_logger_to_string(logger)));
cut_assert_not_null(bookmarks);
}
static void
bench_normal(gpointer user_data)
{
BenchmarkData *data = user_data;
grn_obj *table;
grn_obj *value_type = grn_ctx_get(data->context, VALUE_TYPE_NAME, strlen(VALUE_TYPE_NAME));
if (!value_type) {
value_type = grn_type_create(data->context, VALUE_TYPE_NAME, strlen(VALUE_TYPE_NAME),
0, data->value_size);
}
table = grn_table_create(data->context,
data->name, data->name_size,
data->path, data->flags,
data->key_type, value_type);
grn_obj_close(data->context, table);
}
