grn_index * grn_index_open(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_open(ctx, "<keys>", 6, buffer))) { strcpy(buffer, path); strcat(buffer, ".SEN.l"); if ((lexicon = grn_table_open(ctx, "<lexicon>", 9, buffer))) { 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_open(ctx, lexicon, "inv", 3, buffer, 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 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)); }
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); }
/* * @overload initialize(column) * @param column [Groonga::Column] The column to be cached. * * @return [Groonga::ColumnCache] Create a new column cache. */ static VALUE rb_grn_column_cache_initialize (VALUE self, VALUE rb_column) { RbGrnColumnCache *rb_grn_column_cache; grn_ctx *context; grn_obj *column; grn_id range_id; rb_grn_column_cache = ALLOC(RbGrnColumnCache); rb_grn_column_cache->self = self; rb_grn_column_cache->context = NULL; rb_grn_column_cache->rb_column = rb_column; rb_grn_column_cache->column_cache = NULL; DATA_PTR(self) = rb_grn_column_cache; column = RVAL2GRNCOLUMN(rb_column, &(rb_grn_column_cache->context)); context = rb_grn_column_cache->context; rb_grn_column_cache->column_cache = grn_column_cache_open(context, column); if (!rb_grn_column_cache->column_cache) { rb_raise(rb_eArgError, "failed to create column cache: %s%s%" PRIsVALUE, context->rc == GRN_SUCCESS ? "" : context->errbuf, context->rc == GRN_SUCCESS ? "" : ": ", rb_column); } range_id = grn_obj_get_range(context, column); GRN_VALUE_FIX_SIZE_INIT(&(rb_grn_column_cache->buffer), GRN_OBJ_DO_SHALLOW_COPY, range_id); rb_grn_column_cache->range = grn_ctx_at(context, range_id); rb_grn_column_cache->table = grn_ctx_at(context, column->header.domain); return Qnil; }
static grn_rc grn_table_inspect(grn_ctx *ctx, grn_obj *buf, grn_obj *obj) { grn_hash *cols; grn_id range_id; grn_obj *range; GRN_TEXT_PUTS(ctx, buf, "#<table:"); grn_table_type_inspect(ctx, buf, obj); GRN_TEXT_PUTS(ctx, buf, " "); grn_inspect_name(ctx, buf, obj); if (obj->header.type != GRN_TABLE_NO_KEY) { grn_obj *domain; grn_id domain_id; GRN_TEXT_PUTS(ctx, buf, " key:"); domain_id = obj->header.domain; domain = grn_ctx_at(ctx, domain_id); if (domain) { grn_inspect_name(ctx, buf, domain); grn_obj_unlink(ctx, domain); } else if (domain_id) { grn_text_lltoa(ctx, buf, domain_id); } else { GRN_TEXT_PUTS(ctx, buf, "(nil)"); } } GRN_TEXT_PUTS(ctx, buf, " value:"); range_id = grn_obj_get_range(ctx, obj); range = grn_ctx_at(ctx, range_id); if (range) { grn_inspect_name(ctx, buf, range); } else if (range_id) { grn_text_lltoa(ctx, buf, range_id); } else { GRN_TEXT_PUTS(ctx, buf, "(nil)"); } GRN_TEXT_PUTS(ctx, buf, " size:"); grn_text_lltoa(ctx, buf, grn_table_size(ctx, obj)); GRN_TEXT_PUTS(ctx, buf, " columns:["); if ((cols = grn_hash_create(ctx, NULL, sizeof(grn_id), 0, GRN_OBJ_TABLE_HASH_KEY|GRN_HASH_TINY))) { if (grn_table_columns(ctx, obj, "", 0, (grn_obj *)cols)) { int i = 0; grn_id *key; GRN_HASH_EACH(ctx, cols, id, &key, NULL, NULL, { grn_obj *col = grn_ctx_at(ctx, *key); if (col) { if (i++ > 0) { GRN_TEXT_PUTS(ctx, buf, ", "); } grn_column_name_(ctx, col, buf); grn_obj_unlink(ctx, col); } }); }
static void command_schema_column_output_sources(grn_ctx *ctx, grn_obj *column) { grn_obj *source_table; grn_obj source_ids; unsigned int i, n_ids; source_table = grn_ctx_at(ctx, grn_obj_get_range(ctx, column)); GRN_RECORD_INIT(&source_ids, GRN_OBJ_VECTOR, GRN_ID_NIL); if (column->header.type == GRN_COLUMN_INDEX) { grn_obj_get_info(ctx, column, GRN_INFO_SOURCE, &source_ids); } n_ids = GRN_BULK_VSIZE(&source_ids) / sizeof(grn_id); grn_ctx_output_array_open(ctx, "sources", n_ids); for (i = 0; i < n_ids; i++) { grn_id source_id; grn_obj *source; source_id = GRN_RECORD_VALUE_AT(&source_ids, i); source = grn_ctx_at(ctx, source_id); grn_ctx_output_map_open(ctx, "source", 3); grn_ctx_output_cstr(ctx, "name"); if (grn_obj_is_table(ctx, source)) { grn_ctx_output_cstr(ctx, "_key"); } else { command_schema_output_column_name(ctx, source); } grn_ctx_output_cstr(ctx, "table"); command_schema_output_name(ctx, source_table); grn_ctx_output_cstr(ctx, "full_name"); if (grn_obj_is_table(ctx, source)) { char name[GRN_TABLE_MAX_KEY_SIZE]; unsigned int name_size; name_size = grn_obj_name(ctx, source, name, GRN_TABLE_MAX_KEY_SIZE); name[name_size] = '\0'; grn_strcat(name, GRN_TABLE_MAX_KEY_SIZE, "._key"); grn_ctx_output_cstr(ctx, name); } else { command_schema_output_name(ctx, source); } grn_ctx_output_map_close(ctx); } grn_ctx_output_array_close(ctx); GRN_OBJ_FIN(ctx, &source_ids); }
grn_obj * rb_grn_uvector_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *uvector, VALUE related_object) { UVectorFromRubyData data; if (NIL_P(object)) return NULL; data.domain = grn_ctx_at(context, uvector->header.domain); if (!data.domain) { rb_raise(rb_eArgError, "unknown domain uvector can't be converted: <%s>", rb_grn_inspect(related_object)); } GRN_OBJ_INIT(&(data.element_buffer), GRN_BULK, 0, uvector->header.domain); data.object = object; data.context = context; data.uvector = uvector; data.related_object = related_object; data.succeeded = GRN_FALSE; rb_ensure(rb_grn_uvector_from_ruby_object_body, (VALUE)(&data), rb_grn_uvector_from_ruby_object_ensure, (VALUE)(&data)); if (!data.succeeded) { return NULL; } return uvector; }
grn_dat * grn_dat_open(grn_ctx *ctx, const char *path) { if (path && (std::strlen(path) >= (PATH_MAX - (FILE_ID_LENGTH + 1)))) { ERR(GRN_FILENAME_TOO_LONG, "too long path"); return NULL; } grn_dat * const dat = static_cast<grn_dat *>(GRN_MALLOC(sizeof(grn_dat))); if (!dat) { return NULL; } grn_dat_init(ctx, dat); dat->io = grn_io_open(ctx, path, grn_io_auto); if (!dat->io) { GRN_FREE(dat); return NULL; } dat->header = (struct grn_dat_header *)grn_io_header(dat->io); if (!dat->header) { grn_io_close(ctx, dat->io); GRN_FREE(dat); return NULL; } dat->file_id = dat->header->file_id; dat->encoding = dat->header->encoding; dat->obj.header.flags = dat->header->flags; dat->tokenizer = grn_ctx_at(ctx, dat->header->tokenizer); return dat; }
static mrb_value ctx_array_reference(mrb_state *mrb, mrb_value self) { grn_ctx *ctx = (grn_ctx *)mrb->ud; mrb_value mrb_id_or_name; grn_obj *object; mrb_get_args(mrb, "o", &mrb_id_or_name); if (mrb_nil_p(mrb_id_or_name)) { return mrb_nil_value(); } if (mrb_fixnum_p(mrb_id_or_name)) { grn_id id = mrb_fixnum(mrb_id_or_name); object = grn_ctx_at(ctx, id); } else { mrb_value mrb_name; mrb_name = mrb_convert_type(mrb, mrb_id_or_name, MRB_TT_STRING, "String", "to_str"); object = grn_ctx_get(ctx, RSTRING_PTR(mrb_name), RSTRING_LEN(mrb_name)); } return grn_mrb_value_from_grn_obj(mrb, object); }
/* * call-seq: * column.sources -> Groonga::Columnの配列 * * インデックス対象となっているカラムの配列を返す。 */ static VALUE rb_grn_index_column_get_sources (VALUE self) { grn_ctx *context = NULL; grn_obj *column; grn_obj sources; grn_id *source_ids; VALUE rb_sources; int i, n; rb_grn_index_column_deconstruct(SELF(self), &column, &context, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); GRN_OBJ_INIT(&sources, GRN_BULK, 0, GRN_ID_NIL); grn_obj_get_info(context, column, GRN_INFO_SOURCE, &sources); rb_grn_context_check(context, self); n = GRN_BULK_VSIZE(&sources) / sizeof(grn_id); source_ids = (grn_id *)GRN_BULK_HEAD(&sources); rb_sources = rb_ary_new2(n); for (i = 0; i < n; i++) { grn_obj *source; VALUE rb_source; source = grn_ctx_at(context, *source_ids); rb_source = GRNOBJECT2RVAL(Qnil, context, source, RB_GRN_FALSE); rb_ary_push(rb_sources, rb_source); source_ids++; } grn_obj_unlink(context, &sources); return rb_sources; }
void grn_test_object_inspect (GString *output, grn_ctx *context, grn_obj *object) { grn_id domain; if (!object) { g_string_append(output, "<NULL>"); return; } g_string_append(output, "#<"); g_string_append_printf(output, "%s", grn_test_type_inspect(context, object->header.type)); g_string_append_printf(output, ":%p ", object); g_string_append_printf(output, "flags: 0x%x, ", object->header.flags); g_string_append(output, "domain: "); domain = object->header.domain; if (domain == GRN_ID_NIL) { g_string_append(output, "<nil>"); } else { grn_obj *domain_object = NULL; if (context) domain_object = grn_ctx_at(context, domain); if (domain_object) grn_test_object_inspect(output, context, domain_object); else g_string_append_printf(output, "%u", domain); } g_string_append(output, ">"); }
/* * データベース内のオブジェクトを順番にブロックに渡す。 * * @example すべてのオブジェクトの名前を表示する: * database.each do |object| * p object.name * end * * @example すべてのオブジェクトの名前をID順で表示する: * database.each(:order_by => :id) do |object| * p object.name * end * * @example すべてのオブジェクトの名前をキー名の降順で表示する: * database.each(:order_by => :key, :order => :desc) do |object| * p object.name * end * * @overload each(options=nil) * @macro [new] database.each.options * @param options [::Hash] * @yield [object] * @option options :order * +:asc+ または +:ascending+ を指定すると昇順にレコードを取 * り出す。(デフォルト) * +:desc+ または +:descending+ を指定すると降順にレコードを * 取り出す。 * @option options :order_by (:key) * +:id+ を指定するとID順にレコードを取り出す。 * +:key+ 指定するとキー順にレコードを取り出す。(デフォル * ト) * @macro database.each.options * * @overload each(options=nil) * @macro database.each.options * @option options :ignore_missing_object (false) * Specify +true+ to ignore missing object. Otherwise, an exception is * raised for missing object. * * @since 2.0.5 */ static VALUE rb_grn_database_each (int argc, VALUE *argv, VALUE self) { grn_ctx *context = NULL; grn_obj *database; grn_table_cursor *cursor; VALUE rb_cursor, rb_options, rb_order, rb_order_by; VALUE rb_ignore_missing_object; int flags = 0; grn_id id; VALUE exception; RETURN_ENUMERATOR(self, argc, argv); rb_grn_database_deconstruct(SELF(self), &database, &context, NULL, NULL, NULL, NULL); rb_scan_args(argc, argv, "01", &rb_options); rb_grn_scan_options(rb_options, "order", &rb_order, "order_by", &rb_order_by, "ignore_missing_object", &rb_ignore_missing_object, NULL); flags |= rb_grn_table_cursor_order_to_flag(rb_order); flags |= rb_grn_table_cursor_order_by_to_flag(GRN_TABLE_PAT_KEY, self, rb_order_by); cursor = grn_table_cursor_open(context, database, NULL, 0, NULL, 0, 0, -1, flags); rb_cursor = GRNTABLECURSOR2RVAL(Qnil, context, cursor); rb_iv_set(self, "cursor", rb_cursor); while ((id = grn_table_cursor_next(context, cursor)) != GRN_ID_NIL) { grn_obj *object; object = grn_ctx_at(context, id); if (!object && RTEST(rb_ignore_missing_object)) { context->rc = GRN_SUCCESS; continue; } exception = rb_grn_context_to_exception(context, self); if (!NIL_P(exception)) { rb_grn_object_close(rb_cursor); rb_iv_set(self, "cursor", Qnil); rb_exc_raise(exception); } if (object) { rb_yield(GRNOBJECT2RVAL(Qnil, context, object, GRN_FALSE)); } } rb_grn_object_close(rb_cursor); rb_iv_set(self, "cursor", Qnil); return Qnil; }
static void command_schema_column_output_value_type(grn_ctx *ctx, grn_obj *column) { grn_obj *value_type; value_type = grn_ctx_at(ctx, grn_obj_get_range(ctx, column)); command_schema_output_value_type(ctx, value_type); }
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_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))); }
/* * Document-method: reference? * * call-seq: * column.reference? -> true/false * * _column_ の値がテーブルのレコードとなる場合は +true+ を返し、 * そうでない場合は +false+ を返す。 * * @since 1.0.5 */ static VALUE rb_grn_column_reference_p (VALUE self) { grn_ctx *context; grn_obj *column; grn_id range_id; grn_obj *range; unsigned short int type; rb_grn_column_deconstruct(SELF(self), &column, &context, NULL, NULL, NULL, NULL, NULL); range_id = grn_obj_get_range(context, column); range = grn_ctx_at(context, range_id); type = range->header.type; grn_obj_unlink(context, range); switch (type) { case GRN_TABLE_HASH_KEY: case GRN_TABLE_PAT_KEY: case GRN_TABLE_NO_KEY: return Qtrue; default: return Qfalse; } }
static void rb_grn_database_mark_existing_ruby_object (grn_ctx *context, grn_obj *database) { grn_table_cursor *cursor; grn_id id; cursor = grn_table_cursor_open(context, database, NULL, 0, NULL, 0, 0, -1, GRN_CURSOR_ASCENDING); if (!cursor) return; while ((id = grn_table_cursor_next(context, cursor)) != GRN_ID_NIL) { grn_obj *object; grn_user_data *user_data; RbGrnObject *rb_grn_object; object = grn_ctx_at(context, id); if (!object) continue; user_data = grn_obj_user_data(context, object); if (!user_data) continue; rb_grn_object = RB_GRN_OBJECT(user_data->ptr); if (!rb_grn_object) continue; rb_gc_mark(rb_grn_object->self); } grn_table_cursor_close(context, cursor); }
static grn_table_cursor * rb_grn_patricia_trie_open_grn_near_cursor (int argc, VALUE *argv, VALUE self, grn_ctx **context, int flags) { grn_obj *table; grn_obj *key_p = NULL, casted_key; grn_table_cursor *cursor; unsigned min_size = 0; int offset = 0, limit = -1; VALUE options, rb_key, rb_min_size; VALUE rb_greater_than, rb_less_than, rb_offset, rb_limit; flags |= GRN_CURSOR_PREFIX; rb_grn_table_deconstruct((RbGrnTable *)SELF(self), &table, context, NULL, NULL, NULL, NULL, NULL, NULL); rb_scan_args(argc, argv, "11", &rb_key, &options); rb_grn_scan_options(options, "size", &rb_min_size, "offset", &rb_offset, "limit", &rb_limit, "greater_than", &rb_greater_than, "less_than", &rb_less_than, NULL); key_p = RVAL2GRNBULK_WITH_TYPE(rb_key, *context, key_p, table->header.domain, grn_ctx_at(*context, table->header.domain)); GRN_OBJ_INIT(&casted_key, GRN_BULK, 0, table->header.domain); if (key_p->header.domain != table->header.domain) { grn_obj_cast(*context, key_p, &casted_key, 0); key_p = &casted_key; } if (!NIL_P(rb_min_size)) min_size = NUM2UINT(rb_min_size); if (!NIL_P(rb_offset)) offset = NUM2INT(rb_offset); if (!NIL_P(rb_limit)) limit = NUM2INT(rb_limit); if (RVAL2CBOOL(rb_greater_than)) flags |= GRN_CURSOR_GT; if (RVAL2CBOOL(rb_less_than)) flags |= GRN_CURSOR_LT; cursor = grn_table_cursor_open(*context, table, NULL, min_size, GRN_BULK_HEAD(key_p), GRN_BULK_VSIZE(key_p), offset, limit, flags); GRN_OBJ_FIN(*context, &casted_key); rb_grn_context_check(*context, self); return cursor; }
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); }
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); }
static grn_rc grn_ii_inspect(grn_ctx *ctx, grn_obj *buf, grn_obj *obj) { grn_obj sources; int i, n, have_flags = 0; grn_id *source_ids; GRN_TEXT_PUTS(ctx, buf, "#<column:index "); grn_column_inspect_common(ctx, buf, obj); GRN_TEXT_INIT(&sources, 0); grn_obj_get_info(ctx, obj, GRN_INFO_SOURCE, &sources); source_ids = (grn_id *)GRN_BULK_HEAD(&sources); n = GRN_BULK_VSIZE(&sources) / sizeof(grn_id); GRN_TEXT_PUTS(ctx, buf, " sources:["); for (i = 0; i < n; i++) { grn_id source_id; grn_obj *source; if (i) { GRN_TEXT_PUTS(ctx, buf, ", "); } source_id = source_ids[i]; source = grn_ctx_at(ctx, source_id); if (source) { grn_inspect_name(ctx, buf, source); } else { grn_text_lltoa(ctx, buf, source_id); } } GRN_TEXT_PUTS(ctx, buf, "]"); GRN_OBJ_FIN(ctx, &sources); GRN_TEXT_PUTS(ctx, buf, " flags:"); if (obj->header.flags & GRN_OBJ_WITH_SECTION) { GRN_TEXT_PUTS(ctx, buf, "SECTION"); have_flags = 1; } if (obj->header.flags & GRN_OBJ_WITH_WEIGHT) { if (have_flags) { GRN_TEXT_PUTS(ctx, buf, "|"); } GRN_TEXT_PUTS(ctx, buf, "WEIGHT"); have_flags = 1; } if (obj->header.flags & GRN_OBJ_WITH_POSITION) { if (have_flags) { GRN_TEXT_PUTS(ctx, buf, "|"); } GRN_TEXT_PUTS(ctx, buf, "POSITION"); have_flags = 1; } if (!have_flags) { GRN_TEXT_PUTS(ctx, buf, "NONE"); } GRN_TEXT_PUTS(ctx, buf, " elements:"); grn_ii_inspect_elements(ctx, (grn_ii *)obj, buf); GRN_TEXT_PUTS(ctx, buf, ">"); return GRN_SUCCESS; }
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 grn_test_assert_equal_id_helper(grn_ctx *context, grn_id expected, grn_id actual, const gchar *expression_context, const gchar *expression_expected, const gchar *expression_actual) { if (expected == actual) { cut_test_pass(); } else { grn_obj *expected_object, *actual_object; grn_obj inspected_expected_object, inspected_actual_object; expected_object = grn_ctx_at(context, expected); actual_object = grn_ctx_at(context, actual); GRN_TEXT_INIT(&inspected_expected_object, 0); GRN_TEXT_INIT(&inspected_actual_object, 0); grn_inspect(context, &inspected_expected_object, expected_object); grn_inspect(context, &inspected_actual_object, actual_object); cut_set_expected( cut_take_printf("%d: <%.*s>", expected, (int)GRN_TEXT_LEN(&inspected_expected_object), GRN_TEXT_VALUE(&inspected_expected_object))); cut_set_actual( cut_take_printf("%d: <%.*s>", actual, (int)GRN_TEXT_LEN(&inspected_actual_object), GRN_TEXT_VALUE(&inspected_actual_object))); grn_obj_unlink(context, &inspected_expected_object); grn_obj_unlink(context, &inspected_actual_object); grn_obj_unlink(context, expected_object); grn_obj_unlink(context, actual_object); cut_test_fail(cut_take_printf("<%s> == <%s> (%s)\n" " context: <%p>", expression_expected, expression_actual, expression_context, context)); } }
static void command_schema_table_output_key_type(grn_ctx *ctx, grn_obj *table) { grn_obj *key_type = NULL; if (table->header.type != GRN_TABLE_NO_KEY && table->header.domain != GRN_ID_NIL) { key_type = grn_ctx_at(ctx, table->header.domain); } command_schema_output_key_type(ctx, key_type); }
int column_put(void) { int i, s = 0; 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, NULL); grn_obj *value_type = grn_ctx_at(&ctx, GRN_DB_TEXT); grn_obj *column = grn_column_create(&ctx, table, "c1", 2, NULL, GRN_OBJ_PERSISTENT, value_type); if (!table || !column) { return -1; } GRN_TEXT_INIT(&buf, 0); for (i = 0; i < nloops; i++) { int key = GENKEY(i); GRN_BULK_REWIND(&buf); 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 { unsigned int v = key % value_size; GRN_BULK_REWIND(&buf); if (v) { grn_bulk_space(&ctx, &buf, v -1); GRN_TEXT_PUTC(&ctx, &buf, GRN_BULK_HEAD(&buf)[0]); s += v; } if (grn_obj_set_value(&ctx, column, rid, &buf, GRN_OBJ_SET)) { fprintf(stderr, "grn_obj_set_value failed"); } } } } grn_obj_close(&ctx, &buf); printf("total size: %d\n", s); return 0; }
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; }
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); 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); author = grn_column_create(&context, docs, "author", 6, NULL, GRN_OBJ_COLUMN_SCALAR|GRN_OBJ_PERSISTENT, properties); cut_assert_not_null(author); }
static void command_schema_table_output_value_type(grn_ctx *ctx, grn_obj *table) { grn_obj *value_type = NULL; grn_id range = GRN_ID_NIL; if (table->header.type != GRN_TABLE_DAT_KEY) { range = grn_obj_get_range(ctx, table); } if (range != GRN_ID_NIL) { value_type = grn_ctx_at(ctx, range); } command_schema_output_value_type(ctx, value_type); }
static void command_schema_column_output_indexes(grn_ctx *ctx, grn_obj *column) { uint32_t i; grn_index_datum *index_data = NULL; uint32_t n_index_data = 0; if (column) { n_index_data = grn_column_get_all_index_data(ctx, column, NULL, 0); if (n_index_data > 0) { index_data = GRN_PLUGIN_MALLOC(ctx, sizeof(grn_index_datum) * n_index_data); if (!index_data) { GRN_PLUGIN_ERROR(ctx, GRN_NO_MEMORY_AVAILABLE, "[schema] failed to allocate memory for indexes"); return; } grn_column_get_all_index_data(ctx, column, index_data, n_index_data); } } grn_ctx_output_array_open(ctx, "indexes", n_index_data); for (i = 0; i < n_index_data; i++) { grn_obj *lexicon; grn_ctx_output_map_open(ctx, "index", 4); grn_ctx_output_cstr(ctx, "full_name"); command_schema_output_name(ctx, index_data[i].index); grn_ctx_output_cstr(ctx, "table"); lexicon = grn_ctx_at(ctx, index_data[i].index->header.domain); command_schema_output_name(ctx, lexicon); grn_ctx_output_cstr(ctx, "name"); command_schema_output_column_name(ctx, index_data[i].index); grn_ctx_output_cstr(ctx, "section"); grn_ctx_output_uint64(ctx, index_data[i].section); grn_ctx_output_map_close(ctx); } grn_ctx_output_array_close(ctx); if (index_data) { GRN_PLUGIN_FREE(ctx, index_data); } }
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)); }