void
test_fix_size_set_value_increment(void)
{
gint32 count = 29;
gint32 increment_count = 5;
gint32 retrieved_count;
grn_obj *record_value;
grn_obj *retrieved_record_value;
record_value = grn_obj_open(&context, GRN_BULK, 0, 0);
grn_bulk_write(&context, record_value, (const char *)&count, sizeof(count));
grn_test_assert(grn_obj_set_value(&context, count_column, groonga_bookmark_id,
record_value, GRN_OBJ_SET));
grn_obj_close(&context, record_value);
record_value = grn_obj_open(&context, GRN_BULK, 0, 0);
grn_bulk_write(&context, record_value,
(const char *)&increment_count, sizeof(increment_count));
grn_test_assert(grn_obj_set_value(&context, count_column, groonga_bookmark_id,
record_value, GRN_OBJ_INCR));
grn_obj_close(&context, record_value);
retrieved_record_value = grn_obj_get_value(&context, count_column,
groonga_bookmark_id, NULL);
memcpy(&retrieved_count,
GRN_BULK_HEAD(retrieved_record_value),
GRN_BULK_VSIZE(retrieved_record_value));
cut_assert_equal_int(count + increment_count, retrieved_count);
}
/*
* 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;
}
/*
* 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;
}
VALUE
rb_grn_context_to_exception (grn_ctx *context, VALUE related_object)
{
VALUE exception, exception_class;
const char *message;
grn_obj bulk;
if (context->rc == GRN_SUCCESS)
return Qnil;
exception_class = rb_grn_rc_to_exception(context->rc);
message = rb_grn_rc_to_message(context->rc);
GRN_OBJ_INIT(&bulk, GRN_BULK, 0, GRN_ID_NIL);
GRN_TEXT_PUTS(context, &bulk, message);
GRN_TEXT_PUTS(context, &bulk, ": ");
GRN_TEXT_PUTS(context, &bulk, context->errbuf);
if (!NIL_P(related_object)) {
GRN_TEXT_PUTS(context, &bulk, ": ");
GRN_TEXT_PUTS(context, &bulk, rb_grn_inspect(related_object));
}
GRN_TEXT_PUTS(context, &bulk, "\n");
GRN_TEXT_PUTS(context, &bulk, context->errfile);
GRN_TEXT_PUTS(context, &bulk, ":");
grn_text_itoa(context, &bulk, context->errline);
GRN_TEXT_PUTS(context, &bulk, ": ");
GRN_TEXT_PUTS(context, &bulk, context->errfunc);
GRN_TEXT_PUTS(context, &bulk, "()");
exception = rb_funcall(exception_class, rb_intern("new"), 1,
rb_str_new(GRN_BULK_HEAD(&bulk),
GRN_BULK_VSIZE(&bulk)));
grn_obj_unlink(context, &bulk);
return exception;
}
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;
}
static grn_bool
exec_match_uvector_bulk(grn_ctx *ctx, grn_obj *uvector, grn_obj *query)
{
grn_bool matched = GRN_FALSE;
unsigned int i, size;
grn_obj element;
unsigned int element_size;
size = grn_uvector_size(ctx, uvector);
element_size = grn_uvector_element_size(ctx, uvector);
GRN_VALUE_FIX_SIZE_INIT(&element, 0, uvector->header.domain);
for (i = 0; i < size; i++) {
GRN_BULK_REWIND(&element);
grn_bulk_write(ctx, &element,
GRN_BULK_HEAD(uvector) + (element_size * i),
element_size);
if (grn_operator_exec_equal(ctx, &element, query)) {
matched = GRN_TRUE;
break;
}
}
GRN_OBJ_FIN(ctx, &element);
return matched;
}
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);
}
static int
hash_element_to_vector_element(VALUE key, VALUE value, VALUE user_data)
{
HashElementToVectorElementData *data =
(HashElementToVectorElementData *)user_data;
unsigned int weight;
weight = NUM2UINT(value);
if (data->vector->header.type == GRN_UVECTOR) {
grn_id id = RVAL2GRNID(key, data->context, data->range, data->self);
grn_uvector_add_element(data->context, data->vector, id, weight);
} else {
GRN_BULK_REWIND(data->element_value);
RVAL2GRNBULK(key, data->context, data->element_value);
grn_vector_add_element(data->context, data->vector,
GRN_BULK_HEAD(data->element_value),
GRN_BULK_VSIZE(data->element_value),
weight,
data->element_value->header.domain);
}
return ST_CONTINUE;
}
static void
grn_text_atoj_o(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
grn_obj *obj, grn_obj *id)
{
grn_id *idp = (grn_id *)GRN_BULK_HEAD(id);
uint32_t ids = GRN_BULK_VSIZE(id);
for (;;) {
if (ids < sizeof(grn_id)) {
ERR(GRN_INVALID_ARGUMENT, "invalid id.");
return;
}
if (obj->header.type == GRN_ACCESSOR_VIEW) {
uint32_t n;
grn_accessor_view *v = (grn_accessor_view *)obj;
n = *idp;
if (n >= v->naccessors) {
ERR(GRN_INVALID_ARGUMENT, "invalid id");
return;
}
if (!(obj = v->accessors[n])) { return ; }
idp++;
ids -= sizeof(grn_id);
} else {
break;
}
}
grn_text_atoj(ctx, outbuf, output_type, obj, *idp);
}
static grn_rc
grn_vector_inspect(grn_ctx *ctx, grn_obj *buffer, grn_obj *vector)
{
int i;
grn_obj *body = vector->u.v.body;
GRN_TEXT_PUTS(ctx, buffer, "[");
for (i = 0; i < vector->u.v.n_sections; i++) {
grn_section *section = &(vector->u.v.sections[i]);
const char *value_raw;
if (i > 0) {
GRN_TEXT_PUTS(ctx, buffer, ", ");
}
value_raw = GRN_BULK_HEAD(body) + section->offset;
GRN_TEXT_PUTS(ctx, buffer, "{");
GRN_TEXT_PUTS(ctx, buffer, "\"value\":");
{
grn_obj value_object;
GRN_OBJ_INIT(&value_object, GRN_BULK, GRN_OBJ_DO_SHALLOW_COPY,
section->domain);
grn_bulk_write(ctx, &value_object, value_raw, section->length);
grn_inspect(ctx, buffer, &value_object);
GRN_OBJ_FIN(ctx, &value_object);
}
GRN_TEXT_PUTS(ctx, buffer, ", \"weight\":");
grn_text_itoa(ctx, buffer, section->weight);
GRN_TEXT_PUTS(ctx, buffer, "}");
}
GRN_TEXT_PUTS(ctx, buffer, "]");
return GRN_SUCCESS;
}
void
test_read_write(gconstpointer *data)
{
gint i;
int added;
grn_ctx *context;
grn_obj *table;
const gchar *path;
const gchar *value_string;
gint process_number = 0;
const gchar *process_number_string;
const gchar table_name[] = "performance-read-write";
grn_obj value;
grn_obj *retrieved_value;
grn_id id;
grn_rc rc;
i = GPOINTER_TO_INT(data);
process_number_string = g_getenv(GRN_TEST_ENV_PROCESS_NUMBER);
if (process_number_string)
process_number = atoi(process_number_string);
rc = grn_ctx_init(&contexts[i], GRN_CTX_USE_QL);
grn_test_assert(rc, cut_set_message("context: %d (%d)", i, process_number));
context = &contexts[i];
path = g_getenv(GRN_TEST_ENV_TABLE_PATH);
cut_assert_not_null(path);
tables[i] = grn_table_open(context, table_name, strlen(table_name),
path);
cut_assert_not_null(tables[i],
cut_message("table: %d (%d)", i, process_number));
table = tables[i];
grn_test_assert_nil(grn_table_get(context, table, &i, sizeof(grn_id)),
cut_message("lookup - fail: (%d:%d)", i, process_number));
value_string = cut_take_printf("value: (%d:%d)", i, process_number);
id = grn_table_add(context, table, &i, sizeof(grn_id), &added);
grn_test_assert_not_nil(id);
cut_assert_equal_int(1, added);
GRN_TEXT_INIT(&value, GRN_OBJ_DO_SHALLOW_COPY);
GRN_TEXT_SET_REF(&value, value_string, strlen(value_string));
grn_obj_set_value(context, table, id, &value, GRN_OBJ_SET);
retrieved_value = grn_obj_get_value(context, table, id, NULL);
grn_test_assert_not_nil(
id,
cut_message("lookup - success: (%d:%d)", i, process_number));
GRN_TEXT_PUTC(context, retrieved_value, '\0');
cut_assert_equal_string(value_string, GRN_BULK_HEAD(retrieved_value));
tables[i] = NULL;
grn_test_assert(grn_obj_close(context, table));
// contexts[i] = NULL;
grn_test_assert(grn_ctx_fin(context));
}
void
grn_ctx_loader_clear(grn_ctx *ctx)
{
grn_loader *loader = &ctx->impl->loader;
grn_obj *v = (grn_obj *)(GRN_BULK_HEAD(&loader->values));
grn_obj *ve = (grn_obj *)(GRN_BULK_CURR(&loader->values));
grn_obj **p = (grn_obj **)GRN_BULK_HEAD(&loader->columns);
uint32_t i = GRN_BULK_VSIZE(&loader->columns) / sizeof(grn_obj *);
if (ctx->impl->db) { while (i--) { grn_obj_unlink(ctx, *p++); } }
if (loader->ifexists) { grn_obj_unlink(ctx, loader->ifexists); }
if (loader->each) { grn_obj_unlink(ctx, loader->each); }
while (v < ve) { GRN_OBJ_FIN(ctx, v++); }
GRN_OBJ_FIN(ctx, &loader->values);
GRN_OBJ_FIN(ctx, &loader->level);
GRN_OBJ_FIN(ctx, &loader->columns);
grn_loader_init(loader);
}
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;
}
VALUE
rb_grn_obj_to_ruby_object (VALUE klass, grn_ctx *context,
grn_obj *obj, VALUE related_object)
{
if (!obj)
return Qnil;
/* if (NIL_P(klass)) */
/* klass = GRNOBJECT2RCLASS(obj); */
switch (obj->header.type) {
case GRN_VOID:
if (GRN_BULK_VSIZE(obj) > 0)
return rb_str_new(GRN_BULK_HEAD(obj), GRN_BULK_VSIZE(obj));
else
return Qnil;
break;
case GRN_BULK:
return GRNBULK2RVAL(context, obj, NULL, related_object);
break;
/* case GRN_PTR: */
/* case GRN_UVECTOR: */
/* case GRN_PVECTOR: */
case GRN_VECTOR:
return GRNVECTOR2RVAL(context, obj);
break;
/* case GRN_MSG: */
/* case GRN_QUERY: */
/* case GRN_ACCESSOR: */
/* case GRN_SNIP: */
/* case GRN_PATSNIP: */
/* case GRN_CURSOR_TABLE_HASH_KEY: */
/* case GRN_CURSOR_TABLE_PAT_KEY: */
/* case GRN_CURSOR_TABLE_NO_KEY: */
/* case GRN_CURSOR_COLUMN_INDEX: */
/* case GRN_TYPE: */
/* case GRN_PROC: */
/* case GRN_EXPR: */
/* case GRN_TABLE_HASH_KEY: */
/* case GRN_TABLE_PAT_KEY: */
/* case GRN_TABLE_DAT_KEY: */
/* case GRN_TABLE_NO_KEY: */
/* case GRN_DB: */
/* case GRN_COLUMN_FIX_SIZE: */
/* case GRN_COLUMN_VAR_SIZE: */
/* case GRN_COLUMN_INDEX: */
default:
rb_raise(rb_eTypeError,
"unsupported groonga object: %s(%#x): <%s>",
rb_grn_inspect_type(obj->header.type),
obj->header.type,
rb_grn_inspect(related_object));
break;
}
return Qnil;
}
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;
}
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;
}
int
column_get(void)
{
int i, s = 0;
grn_obj buf;
grn_obj *table = grn_ctx_get(&ctx, "<t1>", 4);
grn_obj *column = grn_ctx_get(&ctx, "<t1>.c1", 7);
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_get(&ctx, table, GRN_BULK_HEAD(&buf), key_size);
if (!rid) {
fprintf(stderr, "table_lookup failed\n");
} else {
grn_obj obj, *p;
unsigned int v = key % value_size;
GRN_TEXT_INIT(&obj, 0);
p = grn_obj_get_value(&ctx, column, rid, &obj);
if (!p) {
fprintf(stderr, "grn_obj_get_value failed\n");
} else {
if (GRN_BULK_VSIZE(p) != v) {
fprintf(stderr, "value_size unmatch %d (%ld:%u)\n", i, GRN_BULK_VSIZE(p), v);
} else {
if (v && GRN_BULK_HEAD(p)[v-1] != GRN_BULK_HEAD(&buf)[0]) {
fprintf(stderr, "value unmatch\n");
} else {
s++;
}
}
grn_obj_close(&ctx, p);
}
}
}
}
grn_obj_close(&ctx, &buf);
if (i != s) { printf("successed: %d\n", s); }
return 0;
}
void
test_uvector_column(gconstpointer data)
{
const gchar *expected;
grn_id id, type_id;
grn_obj uvector;
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_OBJ_INIT(&uvector, GRN_UVECTOR, 0, type_id);
grn_bulk_write(context, &uvector,
GRN_BULK_HEAD(&elements[0]), GRN_BULK_VSIZE(&elements[0]));
grn_bulk_write(context, &uvector,
GRN_BULK_HEAD(&elements[1]), GRN_BULK_VSIZE(&elements[1]));
grn_bulk_write(context, &uvector,
GRN_BULK_HEAD(&elements[2]), GRN_BULK_VSIZE(&elements[2]));
grn_obj_set_value(context, column, id, &uvector, 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, &uvector);
}
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;
}
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;
}
static void
output_tokens(grn_ctx *ctx, grn_obj *tokens, grn_obj *lexicon, grn_obj *index_column)
{
int i, n_tokens, n_elements;
grn_obj estimated_size;
n_tokens = GRN_BULK_VSIZE(tokens) / sizeof(tokenize_token);
n_elements = 3;
if (index_column) {
n_elements++;
GRN_UINT32_INIT(&estimated_size, 0);
}
grn_ctx_output_array_open(ctx, "TOKENS", n_tokens);
for (i = 0; i < n_tokens; i++) {
tokenize_token *token;
char value[GRN_TABLE_MAX_KEY_SIZE];
unsigned int value_size;
token = ((tokenize_token *)(GRN_BULK_HEAD(tokens))) + i;
grn_ctx_output_map_open(ctx, "TOKEN", n_elements);
grn_ctx_output_cstr(ctx, "value");
value_size = grn_table_get_key(ctx, lexicon, token->id,
value, GRN_TABLE_MAX_KEY_SIZE);
grn_ctx_output_str(ctx, value, value_size);
grn_ctx_output_cstr(ctx, "position");
grn_ctx_output_int32(ctx, token->position);
grn_ctx_output_cstr(ctx, "force_prefix");
grn_ctx_output_bool(ctx, token->force_prefix);
if (index_column) {
GRN_BULK_REWIND(&estimated_size);
grn_obj_get_value(ctx, index_column, token->id, &estimated_size);
grn_ctx_output_cstr(ctx, "estimated_size");
grn_ctx_output_int64(ctx, GRN_UINT32_VALUE(&estimated_size));
}
grn_ctx_output_map_close(ctx);
}
if (index_column) {
GRN_OBJ_FIN(ctx, &estimated_size);
}
grn_ctx_output_array_close(ctx);
}
static void
msg_handler(grn_ctx *ctx, grn_obj *msg)
{
uint32_t etime;
struct timeval tv;
grn_msg *m = (grn_msg *)msg;
grn_com *com = ((grn_msg *)msg)->peer;
session *s = com->opaque;
s->stat = 3;
gettimeofday(&tv, NULL);
etime = (tv.tv_sec - s->tv.tv_sec) * 1000000 + (tv.tv_usec - s->tv.tv_usec);
if (etime > etime_max) {
etime_max = etime;
}
if (etime < etime_min) {
etime_min = etime;
}
if (ctx->rc) {
m->header.proto = 0;
}
switch (m->header.proto) {
case GRN_COM_PROTO_GQTP :
if (GRN_BULK_VSIZE(msg) == 2) {
etime_amount += etime;
} else {
if (verbose) {
GRN_TEXT_PUTC(ctx, msg, '\0');
lprint(ctx, "%8d(%4d) %8d : %s", s->query_id, s->n_sessions, etime, GRN_BULK_HEAD(msg));
}
}
if ((m->header.flags & GRN_CTX_TAIL)) {
grn_com_queue_enque(ctx, &fsessions, (grn_com_queue_entry *)s);
nrecv++;
}
break;
case GRN_COM_PROTO_HTTP :
nrecv++;
/* lprint(ctx, "recv: %d, %d", (int)GRN_BULK_VSIZE(msg), nrecv); */
grn_com_close_(ctx, com);
grn_com_queue_enque(ctx, &fsessions, (grn_com_queue_entry *)s);
break;
default :
grn_com_close_(ctx, com);
grn_com_queue_enque(ctx, &fsessions, (grn_com_queue_entry *)s);
break;
}
grn_msg_close(ctx, msg);
}
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;
}
/*
* テーブルに主キーが _key_ のレコードがあるならtrueを返す。
*
* @overload has_key?(key)
*/
static VALUE
rb_grn_table_key_support_has_key (VALUE self, VALUE rb_key)
{
grn_ctx *context;
grn_obj *table, *key, *domain;
grn_id id, domain_id;
rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
&key, &domain_id, &domain,
NULL, NULL, NULL,
NULL);
GRN_BULK_REWIND(key);
RVAL2GRNKEY(rb_key, context, key, domain_id, domain, self);
id = grn_table_get(context, table, GRN_BULK_HEAD(key), GRN_BULK_VSIZE(key));
return id == GRN_ID_NIL ? Qfalse : Qtrue;
}
int
ql_get(void)
{
int i, key;
grn_obj buf;
GRN_TEXT_INIT(&buf, 0);
for (i = 0; i < nloops; i++) {
key = GENKEY(i);
GRN_BULK_REWIND(&buf);
GRN_TEXT_PUTS(&ctx, &buf, "(<t1> : \"");
grn_text_itoh(&ctx, &buf, key, key_size);
GRN_TEXT_PUTS(&ctx, &buf, "\").c1");
GRN_TEXT_PUTC(&ctx, &buf, '\0');
EVAL(&ctx, GRN_BULK_HEAD(&buf));
}
grn_obj_close(&ctx, &buf);
return 0;
}
VALUE
rb_grn_uvector_to_ruby_object (grn_ctx *context, grn_obj *uvector)
{
VALUE array;
grn_id *current, *end;
if (!uvector)
return Qnil;
array = rb_ary_new();
current = (grn_id *)GRN_BULK_HEAD(uvector);
end = (grn_id *)GRN_BULK_CURR(uvector);
while (current < end) {
rb_ary_push(array, UINT2NUM(*current));
current++;
}
return array;
}
static grn_id
rb_grn_table_key_support_add_raw (VALUE self, VALUE rb_key, int *added)
{
grn_ctx *context;
grn_obj *table;
grn_id id, domain_id;
grn_obj *key, *domain;
rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
&key, &domain_id, &domain,
NULL, NULL, NULL,
NULL);
GRN_BULK_REWIND(key);
RVAL2GRNKEY(rb_key, context, key, domain_id, domain, self);
id = grn_table_add(context, table,
GRN_BULK_HEAD(key), GRN_BULK_VSIZE(key), added);
rb_grn_context_check(context, self);
return id;
}
int
ql_put(void)
{
int i, key;
grn_obj buf;
GRN_TEXT_INIT(&buf, 0);
EVAL(&ctx, "(ptable '<t1>)");
EVAL(&ctx, "(<t1> ::def :c1 <text>)");
EVAL(&ctx, "(<t1> ::load :c1)");
for (i = 0; i < nloops; i++) {
key = GENKEY(i);
GRN_BULK_REWIND(&buf);
grn_text_itoh(&ctx, &buf, key, key_size);
GRN_TEXT_PUTC(&ctx, &buf, '\t');
grn_text_itoh(&ctx, &buf, key, value_size);
GRN_TEXT_PUTC(&ctx, &buf, '\0');
EVAL(&ctx, GRN_BULK_HEAD(&buf));
}
grn_obj_close(&ctx, &buf);
return 0;
}
static VALUE
rb_grn_double_array_trie_update_by_id (VALUE self, VALUE rb_id, VALUE rb_new_key)
{
grn_ctx *context;
grn_obj *table;
grn_id id, domain_id;
grn_obj *new_key, *domain;
grn_rc rc;
rb_grn_double_array_trie_deconstruct(SELF(self), &table, &context,
NULL, &new_key, &domain_id, &domain,
NULL, NULL, NULL,
NULL);
id = NUM2UINT(rb_id);
RVAL2GRNKEY(rb_new_key, context, new_key, domain_id, domain, self);
rc = grn_table_update_by_id(context, table, id,
GRN_BULK_HEAD(new_key), GRN_BULK_VSIZE(new_key));
rb_grn_rc_check(rc, self);
return Qnil;
}
static VALUE
rb_grn_table_key_support_delete_by_key (VALUE self, VALUE rb_key)
{
grn_ctx *context;
grn_obj *table;
grn_id domain_id;
grn_obj *key, *domain;
grn_rc rc;
rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
&key, &domain_id, &domain,
NULL, NULL, NULL,
NULL);
GRN_BULK_REWIND(key);
RVAL2GRNKEY(rb_key, context, key, domain_id, domain, self);
rc = grn_table_delete(context, table,
GRN_BULK_HEAD(key), GRN_BULK_VSIZE(key));
rb_grn_context_check(context, self);
rb_grn_rc_check(rc, self);
return Qnil;
}
