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, GRN_DB_INT32);
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, GRN_DB_INT32);
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);
grn_obj_close(context, retrieved_record_value);
}
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));
}
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);
}
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));
}
static void
insert_document(const gchar *author_content, const gchar *body_content)
{
uint32_t s = (uint32_t)strlen(body_content);
grn_id docid = grn_table_add(&context, docs, NULL, 0, NULL);
if (author_content) {
GRN_TEXT_SET(&context, &text_buf, author_content, strlen(author_content));
grn_test_assert(grn_obj_set_value(&context, author, docid, &text_buf,
GRN_OBJ_SET));
}
GRN_TEXT_SET(&context, &text_buf, body_content, s);
grn_test_assert(grn_obj_set_value(&context, body, docid, &text_buf,
GRN_OBJ_SET));
GRN_UINT32_SET(&context, &int_buf, s);
grn_test_assert(grn_obj_set_value(&context, size, docid, &int_buf,
GRN_OBJ_SET));
}
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);
}
static void
insert_document(const gchar *body_content)
{
uint32_t s = (uint32_t)strlen(body_content);
grn_id docid = grn_table_add(&context, docs, NULL, 0, NULL);
const gchar *size_string;
struct tm time;
GRN_TEXT_SET(&context, &textbuf, body_content, s);
grn_test_assert(grn_obj_set_value(&context, body, docid, &textbuf,
GRN_OBJ_SET));
GRN_UINT32_SET(&context, &intbuf, s);
grn_test_assert(grn_obj_set_value(&context, size, docid, &intbuf,
GRN_OBJ_SET));
size_string = cut_take_printf("%u", s);
GRN_TEXT_SET(&context, &textbuf, size_string, strlen(size_string));
grn_test_assert(grn_obj_set_value(&context, size_in_string, docid, &textbuf,
GRN_OBJ_SET));
GRN_FLOAT_SET(&context, &floatbuf, s);
grn_test_assert(grn_obj_set_value(&context, size_in_float, docid, &floatbuf,
GRN_OBJ_SET));
time.tm_sec = s;
time.tm_min = 16;
time.tm_hour = 15;
time.tm_mday = 2;
time.tm_mon = 11;
time.tm_year = 109;
time.tm_wday = 3;
time.tm_yday = 336;
time.tm_isdst = 0;
GRN_TIME_SET(&context, &timebuf, GRN_TIME_PACK(mktime(&time), 0));
grn_test_assert(grn_obj_set_value(&context, created_at, docid, &timebuf,
GRN_OBJ_SET));
}
// <cmd> {<len> <column id>} <types> <#kvs> [{<len> <key>} {<len> <value>}]...
void put_or_set(server_t *s, grn_ctx *ctx, int set)
{
uint32_t len;
HOG_RECV(s, &len, sizeof(len), return);
len = ntohl(len);
char *buf = hog_alloc(NULL, len);
HOG_RECV(s, buf, len, goto cleanup);
grn_obj *col, *table;
col = grn_ctx_get(ctx, buf, len);
if(grn_obj_is_table(ctx, col)) table = col;
else table = grn_column_table(ctx, col);
// get key and value types
char types[2];
HOG_RECV(s, types, 2, goto cleanup);
// receive keys and values
uint32_t nkeys;
HOG_RECV(s, &nkeys, sizeof(nkeys), goto cleanup);
nkeys = ntohl(nkeys);
grn_obj value;
GRN_OBJ_INIT(&value, GRN_BULK, 0, types[1]);
for(uint32_t i = 0; i < nkeys; ++i){
HOG_RECV(s, &len, sizeof(len), goto value_fin);
len = ntohl(len);
buf = hog_alloc(buf, len);
HOG_RECV(s, buf, len, goto value_fin);
ntoh_buf(buf, len, types[0]);
grn_id id;
if(set){
id = grn_table_get(ctx, table, buf, len);
}else{
id = grn_table_add(ctx, table, buf, len, NULL);
}
HOG_RECV(s, &len, sizeof(len), goto value_fin);
len = ntohl(len);
buf = hog_alloc(buf, len);
HOG_RECV(s, buf, len, goto value_fin);
if(id == GRN_ID_NIL) continue;
ntoh_buf(buf, len, types[1]);
GRN_BULK_REWIND(&value);
grn_bulk_write(ctx, &value, buf, len);
grn_obj_set_value(ctx, col, id, &value, GRN_OBJ_SET);
}
submit_one(s->socket);
value_fin:
GRN_OBJ_FIN(ctx, &value);
cleanup:
free(buf);
}
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);
}
void
test_fix_size_set_value_set(void)
{
gint32 count = 29;
gint32 retrieved_count;
grn_obj record_value;
grn_obj retrieved_record_value;
GRN_INT32_INIT(&record_value, 0);
GRN_INT32_SET(context, &record_value, count);
grn_test_assert(grn_obj_set_value(context, count_column, groonga_bookmark_id,
&record_value, GRN_OBJ_SET));
GRN_INT32_INIT(&retrieved_record_value, 0);
grn_obj_get_value(context, count_column, groonga_bookmark_id, &retrieved_record_value);
retrieved_count = GRN_INT32_VALUE(&retrieved_record_value);
cut_assert_equal_int(count, retrieved_count);
GRN_OBJ_FIN(context, &record_value);
GRN_OBJ_FIN(context, &retrieved_record_value);
}
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 void
set_weight_vector(grn_ctx *ctx, grn_obj *column, grn_id id, grn_obj *value)
{
if (!grn_obj_is_weight_vector_column(ctx, column)) {
char column_name[GRN_TABLE_MAX_KEY_SIZE];
int column_name_size;
column_name_size = grn_obj_name(ctx, column, column_name,
GRN_TABLE_MAX_KEY_SIZE);
ERR(GRN_INVALID_ARGUMENT,
"<%.*s>: columns except weight vector column don't support object value",
column_name_size, column_name);
return;
}
{
grn_obj vector;
GRN_TEXT_INIT(&vector, GRN_OBJ_VECTOR);
add_weight_vector(ctx, column, value, &vector);
grn_obj_set_value(ctx, column, id, &vector, GRN_OBJ_SET);
GRN_OBJ_FIN(ctx, &vector);
}
}
static VALUE
rb_grn_table_key_support_set_value_by_key (VALUE self,
VALUE rb_key, VALUE rb_value)
{
grn_ctx *context;
grn_obj *table;
grn_id id;
grn_obj *value;
grn_rc rc;
if (NIL_P(rb_key)) {
rb_raise(rb_eArgError, "key should not be nil: <%s>",
rb_grn_inspect(self));
}
rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
NULL, NULL, NULL,
&value, NULL, NULL,
NULL);
id = rb_grn_table_key_support_add_raw(self, rb_key, NULL);
if (GRN_ID_NIL == id) {
rb_raise(rb_eGrnError,
"failed to add new record with key: <%s>: <%s>",
rb_grn_inspect(rb_key),
rb_grn_inspect(self));
}
GRN_BULK_REWIND(value);
RVAL2GRNBULK(rb_value, context, value);
rc = grn_obj_set_value(context, table, id, value, GRN_OBJ_SET);
rb_grn_context_check(context, self);
rb_grn_rc_check(rc, self);
return rb_value;
}
static void
bracket_close(grn_ctx *ctx, grn_loader *loader)
{
grn_id id = GRN_ID_NIL;
grn_obj *value, *value_end, *id_value = NULL, *key_value = NULL;
grn_obj *col, **cols; /* Columns except _id and _key. */
uint32_t i, begin;
uint32_t ncols; /* Number of columns except _id and _key. */
uint32_t nvalues; /* Number of values in brackets. */
uint32_t depth;
grn_bool is_record_load = GRN_FALSE;
cols = (grn_obj **)GRN_BULK_HEAD(&loader->columns);
ncols = GRN_BULK_VSIZE(&loader->columns) / sizeof(grn_obj *);
GRN_UINT32_POP(&loader->level, begin);
value = (grn_obj *)GRN_TEXT_VALUE(&loader->values) + begin;
value_end = (grn_obj *)GRN_TEXT_VALUE(&loader->values) + loader->values_size;
GRN_ASSERT(value->header.domain == GRN_JSON_LOAD_OPEN_BRACKET);
GRN_UINT32_SET(ctx, value, loader->values_size - begin - 1);
value++;
depth = GRN_BULK_VSIZE(&loader->level);
if (depth > sizeof(uint32_t) * loader->emit_level) {
return;
}
if (depth == 0 || !loader->table ||
loader->columns_status == GRN_LOADER_COLUMNS_BROKEN) {
goto exit;
}
nvalues = values_len(ctx, value, value_end);
if (loader->columns_status == GRN_LOADER_COLUMNS_UNSET) {
/*
* Target columns and _id or _key are not specified yet and values are
* handled as column names and "_id" or "_key".
*/
for (i = 0; i < nvalues; i++) {
const char *col_name;
unsigned int col_name_size;
if (value->header.domain != GRN_DB_TEXT) {
grn_obj buffer;
GRN_TEXT_INIT(&buffer, 0);
grn_inspect(ctx, &buffer, value);
ERR(GRN_INVALID_ARGUMENT,
"column name must be string: <%.*s>",
(int)GRN_TEXT_LEN(&buffer), GRN_TEXT_VALUE(&buffer));
grn_loader_save_error(ctx, loader);
GRN_OBJ_FIN(ctx, &buffer);
loader->columns_status = GRN_LOADER_COLUMNS_BROKEN;
goto exit;
}
col_name = GRN_TEXT_VALUE(value);
col_name_size = GRN_TEXT_LEN(value);
col = grn_obj_column(ctx, loader->table, col_name, col_name_size);
if (!col) {
ERR(GRN_INVALID_ARGUMENT, "nonexistent column: <%.*s>",
col_name_size, col_name);
grn_loader_save_error(ctx, loader);
loader->columns_status = GRN_LOADER_COLUMNS_BROKEN;
goto exit;
}
if (name_equal(col_name, col_name_size, GRN_COLUMN_NAME_ID)) {
grn_obj_unlink(ctx, col);
if (loader->id_offset != -1 || loader->key_offset != -1) {
/* _id and _key must not appear more than once. */
if (loader->id_offset != -1) {
ERR(GRN_INVALID_ARGUMENT,
"duplicated id and key columns: <%s> at %d and <%s> at %d",
GRN_COLUMN_NAME_ID, i,
GRN_COLUMN_NAME_ID, loader->id_offset);
} else {
ERR(GRN_INVALID_ARGUMENT,
"duplicated id and key columns: <%s> at %d and <%s> at %d",
GRN_COLUMN_NAME_ID, i,
GRN_COLUMN_NAME_KEY, loader->key_offset);
}
grn_loader_save_error(ctx, loader);
loader->columns_status = GRN_LOADER_COLUMNS_BROKEN;
goto exit;
}
loader->id_offset = i;
} else if (name_equal(col_name, col_name_size, GRN_COLUMN_NAME_KEY)) {
grn_obj_unlink(ctx, col);
if (loader->id_offset != -1 || loader->key_offset != -1) {
/* _id and _key must not appear more than once. */
if (loader->id_offset != -1) {
ERR(GRN_INVALID_ARGUMENT,
"duplicated id and key columns: <%s> at %d and <%s> at %d",
GRN_COLUMN_NAME_KEY, i,
GRN_COLUMN_NAME_ID, loader->id_offset);
} else {
ERR(GRN_INVALID_ARGUMENT,
"duplicated id and key columns: <%s> at %d and <%s> at %d",
GRN_COLUMN_NAME_KEY, i,
GRN_COLUMN_NAME_KEY, loader->key_offset);
}
grn_loader_save_error(ctx, loader);
loader->columns_status = GRN_LOADER_COLUMNS_BROKEN;
goto exit;
}
loader->key_offset = i;
} else {
GRN_PTR_PUT(ctx, &loader->columns, col);
}
value++;
}
switch (loader->table->header.type) {
case GRN_TABLE_HASH_KEY :
case GRN_TABLE_PAT_KEY :
case GRN_TABLE_DAT_KEY :
if (loader->id_offset == -1 && loader->key_offset == -1) {
ERR(GRN_INVALID_ARGUMENT, "missing id or key column");
grn_loader_save_error(ctx, loader);
loader->columns_status = GRN_LOADER_COLUMNS_BROKEN;
goto exit;
}
break;
}
loader->columns_status = GRN_LOADER_COLUMNS_SET;
goto exit;
}
is_record_load = GRN_TRUE;
/* Target columns and _id or _key are already specified. */
if (!nvalues) {
/*
* Accept empty arrays because a dump command may output a load command
* which contains empty arrays for a table with deleted records.
*/
id = grn_table_add(ctx, loader->table, NULL, 0, NULL);
} else {
uint32_t expected_nvalues = ncols;
if (loader->id_offset != -1 || loader->key_offset != -1) {
expected_nvalues++;
}
if (nvalues != expected_nvalues) {
ERR(GRN_INVALID_ARGUMENT,
"unexpected #values: expected:%u, actual:%u",
expected_nvalues, nvalues);
grn_loader_save_error(ctx, loader);
goto exit;
}
if (loader->id_offset != -1) {
id_value = value + loader->id_offset;
id = parse_id_value(ctx, id_value);
if (grn_table_at(ctx, loader->table, id) == GRN_ID_NIL) {
id = grn_table_add(ctx, loader->table, NULL, 0, NULL);
}
} else if (loader->key_offset != -1) {
key_value = value + loader->key_offset;
id = loader_add(ctx, key_value);
} else {
id = grn_table_add(ctx, loader->table, NULL, 0, NULL);
}
}
if (id == GRN_ID_NIL) {
/* Target record is not available. */
goto exit;
}
for (i = 0; i < nvalues; i++, value = values_next(ctx, value)) {
if (i == loader->id_offset || i == loader->key_offset) {
/* Skip _id and _key, because it's already used to get id. */
continue;
}
col = *cols;
if (value->header.domain == GRN_JSON_LOAD_OPEN_BRACKET) {
set_vector(ctx, col, id, value);
} else if (value->header.domain == GRN_JSON_LOAD_OPEN_BRACE) {
set_weight_vector(ctx, col, id, value);
} else {
grn_obj_set_value(ctx, col, id, value, GRN_OBJ_SET);
}
if (ctx->rc != GRN_SUCCESS) {
char column_name[GRN_TABLE_MAX_KEY_SIZE];
unsigned int column_name_size;
grn_loader_save_error(ctx, loader);
column_name_size = grn_obj_name(ctx, col, column_name,
GRN_TABLE_MAX_KEY_SIZE);
report_set_column_value_failure(ctx, key_value,
column_name, column_name_size,
value);
loader->n_column_errors++;
ERRCLR(ctx);
}
cols++;
}
if (loader->each) {
grn_obj *v = grn_expr_get_var_by_offset(ctx, loader->each, 0);
GRN_RECORD_SET(ctx, v, id);
grn_expr_exec(ctx, loader->each, 0);
}
loader->nrecords++;
exit:
if (is_record_load) {
if (ctx->rc != GRN_SUCCESS) {
loader->n_record_errors++;
}
if (loader->output_ids) {
GRN_UINT32_PUT(ctx, &(loader->ids), id);
}
if (loader->output_errors) {
GRN_INT32_PUT(ctx, &(loader->return_codes), ctx->rc);
grn_vector_add_element(ctx,
&(loader->error_messages),
ctx->errbuf,
strlen(ctx->errbuf),
0,
GRN_DB_TEXT);
}
}
loader->values_size = begin;
ERRCLR(ctx);
}
void
test_mroonga_index_score(void)
{
grn_obj *t1,*c1,*lc,*ft;
grn_obj buff;
grn_id r1,r2,r3,r4;
remove_tmp_directory();
g_mkdir_with_parents(tmp_directory,0700);
g_chdir(tmp_directory);
g_mkdir_with_parents("mrn",0700);
db = grn_db_create(context,"mroonga.grn",NULL);
cut_assert_not_null(db);
/* actual table */
t1 = grn_table_create(context,"t1",2,"mrn/t1.grn",
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT,NULL,0);
cut_assert_not_null(t1);
/* lexicon table */
lc = grn_table_create(context,"lc",2,"mrn/lc.grn",
GRN_OBJ_TABLE_PAT_KEY|GRN_OBJ_PERSISTENT,
grn_ctx_at(context, GRN_DB_SHORT_TEXT), 0);
cut_assert_not_null(lc);
grn_test_assert(grn_obj_set_info(context, lc, GRN_INFO_DEFAULT_TOKENIZER,
grn_ctx_at(context, GRN_DB_BIGRAM)));
/* actual column */
c1 = grn_column_create(context,t1,"c1",2,"mrn/t1.c1.grn",
GRN_OBJ_COLUMN_SCALAR|GRN_OBJ_PERSISTENT,
grn_ctx_at(context, GRN_DB_TEXT));
cut_assert_not_null(c1);
/* fulltext index */
ft = grn_column_create(context,lc,"ft",2,"mrn/lc.ft.grn",
GRN_OBJ_COLUMN_INDEX|GRN_OBJ_PERSISTENT,t1);
cut_assert_not_null(ft);
GRN_TEXT_INIT(&buff,0);
/* link between actual column and fulltext index */
GRN_UINT32_SET(context, &buff, grn_obj_id(context, c1));
grn_obj_set_info(context, ft, GRN_INFO_SOURCE, &buff); /* need to use grn_id */
/* insert row */
r1 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(1,r1);
GRN_TEXT_SETS(context, &buff, "abcde");
grn_test_assert(grn_obj_set_value(context, c1, r1, &buff, GRN_OBJ_SET));
r2 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(2,r2);
GRN_TEXT_SETS(context, &buff, "fghij");
grn_test_assert(grn_obj_set_value(context, c1, r2, &buff, GRN_OBJ_SET));
r3 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(3,r3);
GRN_TEXT_SETS(context, &buff, "11 22 33");
grn_test_assert(grn_obj_set_value(context, c1, r3, &buff, GRN_OBJ_SET));
r4 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(4,r4);
GRN_TEXT_SETS(context, &buff, "44 22 55");
grn_test_assert(grn_obj_set_value(context, c1, r4, &buff, GRN_OBJ_SET));
/* confirm record are inserted in both column and index */
cut_assert_equal_int(4,grn_table_size(context,t1));
cut_assert_equal_int(23,grn_table_size(context,lc));
/* nlq search */
{
grn_id id, docid;
grn_obj *res;
grn_table_cursor *tc;
grn_obj score, *score_column;
res = grn_table_create(context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, t1, 0);
GRN_UINT32_INIT(&score, 0);
GRN_BULK_REWIND(&buff);
GRN_TEXT_SETS(context, &buff, "hij");
grn_obj_search(context, ft, &buff, res, GRN_OP_OR, NULL);
cut_assert_equal_int(1, grn_table_size(context, res));
score_column = grn_obj_column(context, res, ".:score", 7);
tc = grn_table_cursor_open(context, res, NULL, 0, NULL, 0, 0, 0, 0);
while ((id = grn_table_cursor_next(context, tc))) {
GRN_BULK_REWIND(&buff);
grn_table_get_key(context, res, id, &docid, sizeof(grn_id));
cut_assert_equal_int(2, docid);
cut_assert_not_null(grn_obj_get_value(context, c1, docid, &buff));
cut_assert_equal_int(5 ,GRN_TEXT_LEN(&buff));
cut_assert_equal_substring("fghij", (char*) GRN_BULK_HEAD(&buff),GRN_TEXT_LEN(&buff));
grn_obj_get_value(context, score_column, id, &score);
cut_assert_equal_uint(1, GRN_UINT32_VALUE(&score));
}
grn_table_cursor_close(context, tc);
grn_obj_close(context, score_column);
grn_obj_close(context, res);
}
/* boolean search */
{
grn_id id, docid;
grn_obj *res;
grn_query *query;
grn_table_cursor *tc;
grn_obj score, *score_column;
const char *qstr = "+22 -55";
res = grn_table_create(context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, t1, 0);
GRN_UINT32_INIT(&score, 0);
query = grn_query_open(context, qstr, strlen(qstr), GRN_OP_OR, 32);
grn_obj_search(context, ft, (grn_obj*) query, res, GRN_OP_OR, NULL);
cut_assert_equal_int(1, grn_table_size(context, res));
score_column = grn_obj_column(context, res, ".:score", 7);
tc = grn_table_cursor_open(context, res, NULL, 0, NULL, 0, 0, 0, 0);
while ((id = grn_table_cursor_next(context, tc))) {
GRN_BULK_REWIND(&buff);
grn_table_get_key(context, res, id, &docid, sizeof(grn_id));
cut_assert_equal_int(3, docid);
cut_assert_not_null(grn_obj_get_value(context, c1, docid, &buff));
cut_assert_equal_int(8 ,GRN_TEXT_LEN(&buff));
cut_assert_equal_substring("11 22 33", (char*) GRN_BULK_HEAD(&buff),GRN_TEXT_LEN(&buff));
grn_obj_get_value(context, score_column, id, &score);
cut_assert_equal_uint(5, GRN_UINT32_VALUE(&score));
}
grn_query_close(context, query);
grn_table_cursor_close(context ,tc);
grn_obj_close(context, score_column);
grn_obj_close(context, res);
}
grn_obj_close(context, &buff);
grn_obj_close(context, ft);
grn_obj_close(context, c1);
grn_obj_close(context, lc);
grn_obj_close(context, t1);
}
void
test_int_index(void)
{
gchar *db_path, *name;
grn_obj *users, *items, *checks, *checked, *int_type;
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);
int_type = grn_ctx_at(context, GRN_DB_INT32);
cut_assert_not_null(int_type);
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_PAT_KEY|GRN_OBJ_PERSISTENT, int_type, 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));
{
int32_t key = 1;
grn_obj value, query, *res;
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, &key, sizeof(int32_t), NULL);
GRN_TEXT_INIT(&value, 0);
GRN_TEXT_INIT(&query, 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_bulk_write(context, &query, (void *)&key, sizeof(int32_t));
query.header.domain = GRN_DB_INT32;
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, &query, res, GRN_OP_OR, NULL));
cut_assert_equal_int(grn_table_size(context, res), 2);
grn_obj_close(context, &query);
grn_obj_close(context, &value);
grn_obj_close(context, res);
}
grn_obj_close(context, checks);
grn_obj_close(context, checked);
grn_obj_close(context, items);
grn_obj_close(context, users);
}
void
test_expr_query(void)
{
grn_obj *t1, *c1, *lc, *ft, *v, *expr;
grn_obj textbuf, intbuf;
grn_id r1, r2, r3, r4;
/* actual table */
t1 = grn_table_create(&context, "t1", 2, NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, 0);
cut_assert_not_null(t1);
/* lexicon table */
lc = grn_table_create(&context, "lc", 2, NULL,
GRN_OBJ_TABLE_PAT_KEY|GRN_OBJ_PERSISTENT,
grn_ctx_at(&context, GRN_DB_SHORTTEXT), 0);
cut_assert_not_null(lc);
grn_test_assert(grn_obj_set_info(&context, lc, GRN_INFO_DEFAULT_TOKENIZER,
grn_ctx_at(&context, GRN_DB_BIGRAM)));
/* actual column */
c1 = grn_column_create(&context, t1, "c1", 2, NULL,
GRN_OBJ_COLUMN_SCALAR|GRN_OBJ_PERSISTENT,
grn_ctx_at(&context, GRN_DB_TEXT));
cut_assert_not_null(c1);
/* fulltext index */
ft = grn_column_create(&context, lc, "ft", 2, NULL,
GRN_OBJ_COLUMN_INDEX|GRN_OBJ_PERSISTENT|GRN_OBJ_WITH_POSITION, t1);
cut_assert_not_null(ft);
GRN_TEXT_INIT(&textbuf, 0);
GRN_UINT32_INIT(&intbuf, 0);
/* link between actual column and fulltext index */
GRN_UINT32_SET(&context, &intbuf, grn_obj_id(&context, c1));
grn_obj_set_info(&context, ft, GRN_INFO_SOURCE, &intbuf); /* need to use grn_id */
/* insert row */
r1 = grn_table_add(&context, t1, NULL, 0, NULL);
cut_assert_equal_int(1, r1);
GRN_TEXT_SETS(&context, &textbuf, "abhij");
grn_test_assert(grn_obj_set_value(&context, c1, r1, &textbuf, GRN_OBJ_SET));
r2 = grn_table_add(&context, t1, NULL, 0, NULL);
cut_assert_equal_int(2, r2);
GRN_TEXT_SETS(&context, &textbuf, "fghij");
grn_test_assert(grn_obj_set_value(&context, c1, r2, &textbuf, GRN_OBJ_SET));
r3 = grn_table_add(&context, t1, NULL, 0, NULL);
cut_assert_equal_int(3, r3);
GRN_TEXT_SETS(&context, &textbuf, "11 22 33");
grn_test_assert(grn_obj_set_value(&context, c1, r3, &textbuf, GRN_OBJ_SET));
r4 = grn_table_add(&context, t1, NULL, 0, NULL);
cut_assert_equal_int(4, r4);
GRN_TEXT_SETS(&context, &textbuf, "44 22 55");
grn_test_assert(grn_obj_set_value(&context, c1, r4, &textbuf, GRN_OBJ_SET));
/* confirm record are inserted in both column and index */
cut_assert_equal_int(4, grn_table_size(&context, t1));
cut_assert_equal_int(17, grn_table_size(&context, lc));
cut_assert_not_null((expr = grn_expr_create(&context, NULL, 0)));
v = grn_expr_add_var(&context, expr, NULL, 0);
GRN_BULK_REWIND(&textbuf);
grn_expr_append_const(&context, expr, &textbuf);
GRN_UINT32_SET(&context, &intbuf, GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC);
grn_expr_append_const(&context, expr, &intbuf);
grn_expr_append_obj(&context, expr, t1);
GRN_UINT32_SET(&context, &intbuf, 0);
grn_expr_append_const(&context, expr, &intbuf);
grn_expr_append_op(&context, expr, GRN_OP_TABLE_CREATE, 4);
grn_expr_append_obj(&context, expr, v);
grn_expr_append_op(&context, expr, GRN_OP_VAR_SET_VALUE, 2);
grn_expr_append_obj(&context, expr, ft);
GRN_TEXT_SETS(&context, &textbuf, "hij");
grn_expr_append_const(&context, expr, &textbuf);
grn_expr_append_obj(&context, expr, v);
GRN_UINT32_SET(&context, &intbuf, GRN_SEL_OR);
grn_expr_append_const(&context, expr, &intbuf);
grn_expr_append_op(&context, expr, GRN_OP_OBJ_SEARCH, 4);
grn_expr_append_obj(&context, expr, v);
GRN_TEXT_SETS(&context, &textbuf, ".c1 .:score");
grn_expr_append_const(&context, expr, &textbuf);
GRN_BULK_REWIND(&textbuf);
grn_expr_append_obj(&context, expr, &textbuf);
grn_expr_append_op(&context, expr, GRN_OP_JSON_PUT, 3);
grn_expr_compile(&context, expr);
grn_expr_exec(&context, expr);
cut_assert_equal_uint(0, grn_obj_close(&context, expr));
cut_assert_equal_substring("[[\"abhij\", 1], [\"fghij\", 1]]",
GRN_TEXT_VALUE(&textbuf), GRN_TEXT_LEN(&textbuf));
grn_obj_close(&context, &textbuf);
grn_obj_close(&context, ft);
grn_obj_close(&context, c1);
grn_obj_close(&context, lc);
grn_obj_close(&context, t1);
}
/*
* It updates a value of variable size column value for the record
* that ID is _id_.
*
* Weight vector column is a special variable size column. This
* description describes only weight vector column. Other variable
* size column works what you think.
*
* @example Use weight vector as matrix search result weight
* Groonga::Schema.define do |schema|
* schema.create_table("Products",
* :type => :patricia_trie,
* :key_type => "ShortText") do |table|
* # This is weight vector.
* # ":with_weight => true" is important for matrix search result weight.
* table.short_text("tags",
* :type => :vector,
* :with_weight => true)
* end
*
* schema.create_table("Tags",
* :type => :hash,
* :key_type => "ShortText") do |table|
* # This is inverted index. It also needs ":with_weight => true".
* table.index("Products.tags", :with_weight => true)
* end
* end
*
* products = Groonga["Products"]
* groonga = products.add("Groonga")
* groonga.tags = [
* {
* :value => "groonga",
* :weight => 100,
* },
* ]
* rroonga = products.add("Rroonga")
* rroonga.tags = [
* {
* :value => "ruby",
* :weight => 100,
* },
* {
* :value => "groonga",
* :weight => 10,
* },
* ]
*
* result = products.select do |record|
* # Search by "groonga"
* record.match("groonga") do |match_target|
* match_target.tags
* end
* end
*
* result.each do |record|
* p [record.key.key, record.score]
* end
* # Matches all records with weight.
* # => ["Groonga", 101]
* # ["Rroonga", 11]
*
* # Increases score for "ruby" 10 times
* products.select(# The previous search result. Required.
* :result => result,
* # It just adds score to existing records in the result. Required.
* :operator => Groonga::Operator::ADJUST) do |record|
* record.match("ruby") do |target|
* target.tags * 10 # 10 times
* end
* end
*
* result.each do |record|
* p [record.key.key, record.score]
* end
* # Weight is used for increasing score.
* # => ["Groonga", 101] <- Not changed.
* # ["Rroonga", 1021] <- 1021 (= 101 * 10 + 1) increased.
*
* @overload []=(id, elements)
* This description is for weight vector column.
*
* @param [Integer, Record] id The record ID.
* @param [Array<Hash<Symbol, String>>] elements An array of values
* for weight vector.
* Each value is a Hash like the following form:
*
* <pre>
* {
* :value => [KEY],
* :weight => [WEIGHT],
* }
* </pre>
*
* @[KEY]@ must be the same type of the key of the table that is
* specified as range on creating the weight vector.
*
* @[WEIGHT]@ must be an positive integer. Note that search
* becomes @weight + 1@. It means that You want to get 10 as
* score, you should set 9 as weight.
*
* @overload []=(id, value)
* This description is for variable size columns except weight
* vector column.
*
* @param [Integer, Record] id The record ID.
* @param [::Object] value A new value.
* @see Groonga::Object#[]=
*
* @since 4.0.1
*/
static VALUE
rb_grn_variable_size_column_array_set (VALUE self, VALUE rb_id, VALUE rb_value)
{
grn_ctx *context = NULL;
grn_obj *column, *range;
grn_rc rc;
grn_id id;
grn_obj *value, *element_value;
int flags = GRN_OBJ_SET;
rb_grn_variable_size_column_deconstruct(SELF(self), &column, &context,
NULL, NULL, &value, &element_value,
NULL, &range);
if (!(column->header.flags & GRN_OBJ_WITH_WEIGHT)) {
VALUE args[2];
args[0] = rb_id;
args[1] = rb_value;
return rb_call_super(2, args);
}
id = RVAL2GRNID(rb_id, context, range, self);
grn_obj_reinit(context, value,
value->header.domain,
value->header.flags | GRN_OBJ_VECTOR);
value->header.flags |= GRN_OBJ_WITH_WEIGHT;
if (RVAL2CBOOL(rb_obj_is_kind_of(rb_value, rb_cArray))) {
int i, n;
n = RARRAY_LEN(rb_value);
for (i = 0; i < n; i++) {
unsigned int weight = 0;
VALUE rb_element_value, rb_weight;
rb_grn_scan_options(RARRAY_PTR(rb_value)[i],
"value", &rb_element_value,
"weight", &rb_weight,
NULL);
if (!NIL_P(rb_weight)) {
weight = NUM2UINT(rb_weight);
}
if (value->header.type == GRN_UVECTOR) {
grn_id id = RVAL2GRNID(rb_element_value, context, range, self);
grn_uvector_add_element(context, value, id, weight);
} else {
GRN_BULK_REWIND(element_value);
if (!NIL_P(rb_element_value)) {
RVAL2GRNBULK(rb_element_value, context, element_value);
}
grn_vector_add_element(context, value,
GRN_BULK_HEAD(element_value),
GRN_BULK_VSIZE(element_value),
weight,
element_value->header.domain);
}
}
} else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_value, rb_cHash))) {
HashElementToVectorElementData data;
data.self = self;
data.context = context;
data.vector = value;
data.element_value = element_value;
data.range = range;
rb_hash_foreach(rb_value, hash_element_to_vector_element, (VALUE)&data);
} else {
rb_raise(rb_eArgError,
"<%s>: "
"weight vector value must be an array of index value or "
"a hash that key is vector value and value is vector weight: "
"<%s>",
rb_grn_inspect(self),
rb_grn_inspect(rb_value));
}
rc = grn_obj_set_value(context, column, id, value, flags);
rb_grn_context_check(context, self);
rb_grn_rc_check(rc, self);
return rb_value;
}
void
test_persistent_expr(void)
{
int i;
grn_obj *t1, *t2, *c1, *c2, buf;
t1 = grn_table_create(&context, "t1", 2, NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, 0);
cut_assert_not_null(t1);
t2 = grn_table_create(&context, "t2", 2, NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, 0);
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_TEXT_INIT(&buf, 0);
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_BULK_REWIND(&buf);
grn_bulk_write(&context, &buf, (char *)&i2, sizeof(grn_id));
grn_obj_set_value(&context, c1, i1, &buf, GRN_OBJ_SET);
grn_obj_set_value(&context, c2, i2, &buf, GRN_OBJ_SET);
}
{
grn_obj *expr = grn_expr_create(&context, "test", 4);
grn_obj *v;
cut_assert_not_null(expr);
v = grn_expr_add_var(&context, expr, "foo", 3);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, t1));
grn_expr_append_obj(&context, expr, v);
GRN_TEXT_SETS(&context, &buf, "c1");
grn_expr_append_const(&context, expr, &buf);
grn_expr_append_op(&context, expr, GRN_OP_OBJ_GET_VALUE, 2);
GRN_TEXT_SETS(&context, &buf, "c2");
grn_expr_append_const(&context, expr, &buf);
grn_expr_append_op(&context, expr, GRN_OP_OBJ_GET_VALUE, 2);
GRN_TEXT_SETS(&context, &buf, "c1");
grn_expr_append_const(&context, expr, &buf);
/*
GRN_TEXT_SETS(&context, &buf, "c1.c2.c1");
grn_expr_append_const(&context, expr, &buf);
*/
grn_expr_append_op(&context, expr, GRN_OP_OBJ_GET_VALUE, 2);
grn_expr_compile(&context, expr);
}
cut_assert_equal_uint(0, grn_obj_close(&context, &buf));
grn_db_close(&context, database);
database = grn_db_open(&context, path);
GRN_TEXT_INIT(&buf, 0);
{
grn_id id;
uint64_t et;
int nerr = 0;
grn_obj *r, *v;
grn_table_cursor *tc;
struct timeval tvb, tve;
grn_obj *expr = grn_ctx_get(&context, "test", 4);
v = grn_expr_get_var(&context, expr, "foo", 3);
t1 = grn_ctx_get(&context, "t1", 2);
tc = grn_table_cursor_open(&context, t1, NULL, 0, NULL, 0, 0);
cut_assert_not_null(tc);
gettimeofday(&tvb, NULL);
while ((id = grn_table_cursor_next(&context, tc))) {
GRN_RECORD_SET(&context, v, id);
r = grn_expr_exec(&context, expr);
if (GRN_RECORD_VALUE(r) != 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);
cut_assert_equal_uint(0, grn_table_cursor_close(&context, tc));
}
cut_assert_equal_uint(0, grn_obj_close(&context, &buf));
}
void
test_array_sort(gpointer data)
{
const gint32 values[] = {
5, 6, 18, 9, 0, 4, 13, 12, 8, 14, 19, 11, 7, 3, 1, 10, 15, 2, 17, 16
};
const int n_values = sizeof(values) / sizeof(values[0]);
const gchar table_name[] = "Store";
const gchar column_name[] = "sample_column";
const int n_keys = 1;
grn_table_sort_key keys[n_keys];
grn_obj *table, *column, *result;
grn_table_cursor *cursor;
int n_results;
guint i;
guint n_expected_values;
GList *expected_values, *sorted_values = NULL;
table = grn_table_create(context, table_name, strlen(table_name),
NULL,
GRN_OBJ_TABLE_NO_KEY | GRN_OBJ_PERSISTENT,
NULL,
NULL);
column = grn_column_create(context,
table,
column_name,
strlen(column_name),
NULL, 0,
get_object("Int32"));
keys[0].key = column;
keys[0].flags = GRN_TABLE_SORT_ASC;
for(i = 0; i < n_values; ++i) {
grn_obj record_value;
grn_id record_id;
record_id = grn_table_add(context, table, NULL, 0, NULL);
GRN_INT32_INIT(&record_value, 0);
GRN_INT32_SET(context, &record_value, values[i]);
grn_test_assert(grn_obj_set_value(context, column, record_id,
&record_value, GRN_OBJ_SET));
GRN_OBJ_FIN(context, &record_value);
}
cut_assert_equal_int(n_values, grn_table_size(context, table));
result = grn_table_create(context, NULL, 0, NULL, GRN_TABLE_NO_KEY,
NULL, table);
n_results = grn_table_sort(context, table,
gcut_data_get_int(data, "offset"),
gcut_data_get_int(data, "limit"),
result, keys, n_keys);
expected_values = (GList *)gcut_data_get_pointer(data, "expected_values");
n_expected_values = g_list_length(expected_values);
cut_assert_equal_int(n_expected_values, n_results);
cut_assert_equal_int(n_expected_values, grn_table_size(context, result));
cursor = grn_table_cursor_open(context, result, NULL, 0, NULL, 0,
0, -1, GRN_CURSOR_ASCENDING);
while (grn_table_cursor_next(context, cursor) != GRN_ID_NIL) {
void *value;
grn_id *id;
grn_obj record_value;
grn_table_cursor_get_value(context, cursor, &value);
id = value;
GRN_INT32_INIT(&record_value, 0);
grn_obj_get_value(context, column, *id, &record_value);
sorted_values = g_list_append(sorted_values,
GINT_TO_POINTER(GRN_INT32_VALUE(&record_value)));
GRN_OBJ_FIN(context, &record_value);
}
gcut_take_list(sorted_values, NULL);
gcut_assert_equal_list_int(expected_values, sorted_values);
grn_table_cursor_close(context, cursor);
grn_obj_close(context, result);
}
void
test_truncate_named(gconstpointer data)
{
grn_obj_flags flags;
const gchar *table_name = "SearchEngines";
const gchar *key;
grn_obj *key_type;
unsigned key_size;
const gchar *column_name = "description";
grn_obj *column_type;
const gchar *column_value = "An open-source fulltext search engine";
grn_bool array_p;
grn_id record_id;
int added;
flags = gcut_data_get_int(data, "flags");
array_p = ((flags & GRN_OBJ_TABLE_TYPE_MASK) == GRN_OBJ_TABLE_NO_KEY);
if (array_p) {
key = NULL;
key_size = 0;
key_type = NULL;
} else {
key = "groonga";
key_size = strlen(key);
key_type = grn_ctx_at(context, GRN_DB_SHORT_TEXT);
}
table = grn_table_create(context,
table_name, strlen(table_name), NULL,
flags | GRN_OBJ_PERSISTENT,
key_type, NULL);
if (key_type) {
grn_obj_unlink(context, key_type);
}
grn_test_assert_context(context);
column_type = grn_ctx_at(context, GRN_DB_SHORT_TEXT);
column = grn_column_create(context, table, column_name, strlen(column_name),
NULL,
GRN_OBJ_COLUMN_SCALAR | GRN_OBJ_PERSISTENT,
column_type);
grn_obj_unlink(context, column_type);
grn_test_assert_context(context);
record_id = grn_table_add(context, table, key, key_size, &added);
grn_test_assert_not_nil(record_id);
cut_assert_true(added);
grn_obj_reinit(context, &buffer, GRN_DB_SHORT_TEXT, 0);
GRN_TEXT_PUTS(context, &buffer, column_value);
grn_test_assert(grn_obj_set_value(context, column, record_id,
&buffer, GRN_OBJ_SET));
GRN_BULK_REWIND(&buffer);
grn_obj_get_value(context, column, record_id, &buffer);
GRN_TEXT_PUTC(context, &buffer, '\0');
cut_assert_equal_string(column_value, GRN_TEXT_VALUE(&buffer));
cut_assert_equal_uint(1, grn_table_size(context, table));
grn_test_assert(grn_table_truncate(context, table));
GRN_BULK_REWIND(&buffer);
grn_obj_get_value(context, column, record_id, &buffer);
GRN_TEXT_PUTC(context, &buffer, '\0');
cut_assert_equal_string("", GRN_TEXT_VALUE(&buffer));
cut_assert_equal_uint(0, grn_table_size(context, table));
}
static void
set_vector(grn_ctx *ctx, grn_obj *column, grn_id id, grn_obj *vector)
{
int n = GRN_UINT32_VALUE(vector);
grn_obj buf, *v = vector + 1;
grn_id range_id;
grn_obj *range;
range_id = DB_OBJ(column)->range;
range = grn_ctx_at(ctx, range_id);
if (grn_obj_is_table(ctx, range)) {
GRN_RECORD_INIT(&buf, GRN_OBJ_VECTOR, range_id);
while (n--) {
grn_bool cast_failed = GRN_FALSE;
grn_obj record, *element = v;
if (range_id != element->header.domain) {
GRN_RECORD_INIT(&record, 0, range_id);
if (grn_obj_cast(ctx, element, &record, GRN_TRUE)) {
cast_failed = GRN_TRUE;
ERR_CAST(column, range, element);
}
element = &record;
}
if (!cast_failed) {
GRN_UINT32_PUT(ctx, &buf, GRN_RECORD_VALUE(element));
}
if (element == &record) { GRN_OBJ_FIN(ctx, element); }
v = values_next(ctx, v);
}
} else {
if (((struct _grn_type *)range)->obj.header.flags & GRN_OBJ_KEY_VAR_SIZE) {
GRN_TEXT_INIT(&buf, GRN_OBJ_VECTOR);
while (n--) {
switch (v->header.domain) {
case GRN_DB_TEXT :
{
grn_bool cast_failed = GRN_FALSE;
grn_obj casted_element, *element = v;
if (range_id != element->header.domain) {
GRN_OBJ_INIT(&casted_element, GRN_BULK, 0, range_id);
if (grn_obj_cast(ctx, element, &casted_element, GRN_TRUE)) {
cast_failed = GRN_TRUE;
ERR_CAST(column, range, element);
}
element = &casted_element;
}
if (!cast_failed) {
grn_vector_add_element(ctx, &buf,
GRN_TEXT_VALUE(element),
GRN_TEXT_LEN(element),
0,
element->header.domain);
}
if (element == &casted_element) { GRN_OBJ_FIN(ctx, element); }
break;
}
case GRN_JSON_LOAD_OPEN_BRACE :
add_weight_vector(ctx, column, v, &buf);
n -= GRN_UINT32_VALUE(v);
break;
default :
ERR(GRN_INVALID_ARGUMENT, "array must contain string or object");
break;
}
v = values_next(ctx, v);
}
} else {
grn_id value_size = ((grn_db_obj *)range)->range;
GRN_VALUE_FIX_SIZE_INIT(&buf, GRN_OBJ_VECTOR, range_id);
while (n--) {
grn_bool cast_failed = GRN_FALSE;
grn_obj casted_element, *element = v;
if (range_id != element->header.domain) {
GRN_OBJ_INIT(&casted_element, GRN_BULK, 0, range_id);
if (grn_obj_cast(ctx, element, &casted_element, GRN_TRUE)) {
cast_failed = GRN_TRUE;
ERR_CAST(column, range, element);
}
element = &casted_element;
}
if (!cast_failed) {
grn_bulk_write(ctx, &buf, GRN_TEXT_VALUE(element), value_size);
}
if (element == &casted_element) { GRN_OBJ_FIN(ctx, element); }
v = values_next(ctx, v);
}
}
}
grn_obj_set_value(ctx, column, id, &buf, GRN_OBJ_SET);
GRN_OBJ_FIN(ctx, &buf);
}
void
test_expr(void)
{
int i;
grn_obj *t1, *t2, *c1, *c2, r1, r2, buf;
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_TEXT_INIT(&buf, 0);
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_obj *r, *v;
expr = grn_expr_create(context, NULL, 0);
cut_assert_not_null(expr);
v = grn_expr_add_var(context, expr, NULL, 0);
GRN_RECORD_INIT(v, 0, grn_obj_id(context, t1));
grn_expr_append_obj(context, expr, v, GRN_OP_PUSH, 1);
GRN_TEXT_SETS(context, &buf, "c1");
grn_expr_append_const(context, expr, &buf, GRN_OP_PUSH, 1);
grn_expr_append_op(context, expr, GRN_OP_GET_VALUE, 2);
GRN_TEXT_SETS(context, &buf, "c2");
grn_expr_append_const(context, expr, &buf, GRN_OP_PUSH, 1);
grn_expr_append_op(context, expr, GRN_OP_GET_VALUE, 2);
GRN_TEXT_SETS(context, &buf, "c1");
grn_expr_append_const(context, expr, &buf, GRN_OP_PUSH, 1);
// GRN_TEXT_SETS(context, &buf, "c1.c2.c1");
// grn_expr_append_const(context, expr, &buf);
grn_expr_append_op(context, expr, GRN_OP_GET_VALUE, 2);
grn_expr_compile(context, expr);
{
grn_id id;
uint64_t et;
int nerr = 0;
grn_table_cursor *tc;
struct timeval tvb, tve;
tc = grn_table_cursor_open(context, t1, NULL, 0, NULL, 0, 0, -1, 0);
cut_assert_not_null(tc);
gettimeofday(&tvb, NULL);
while ((id = grn_table_cursor_next(context, tc))) {
GRN_RECORD_SET(context, v, id);
grn_expr_exec(context, expr, 0);
r = grn_ctx_pop(context);
if (GRN_RECORD_VALUE(r) != 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, &r1));
grn_test_assert(grn_obj_close(context, &r2));
grn_test_assert(grn_obj_close(context, &buf));
}
static void
brace_close(grn_ctx *ctx, grn_loader *loader)
{
grn_id id = GRN_ID_NIL;
grn_obj *value, *value_begin, *value_end;
grn_obj *id_value = NULL, *key_value = NULL;
uint32_t begin;
GRN_UINT32_POP(&loader->level, begin);
value_begin = (grn_obj *)GRN_TEXT_VALUE(&loader->values) + begin;
value_end = (grn_obj *)GRN_TEXT_VALUE(&loader->values) + loader->values_size;
GRN_ASSERT(value->header.domain == GRN_JSON_LOAD_OPEN_BRACE);
GRN_UINT32_SET(ctx, value_begin, loader->values_size - begin - 1);
value_begin++;
if (GRN_BULK_VSIZE(&loader->level) > sizeof(uint32_t) * loader->emit_level) {
return;
}
if (!loader->table) {
goto exit;
}
/* Scan values to find _id or _key. */
for (value = value_begin; value + 1 < value_end;
value = values_next(ctx, value)) {
const char *name = GRN_TEXT_VALUE(value);
unsigned int name_size = GRN_TEXT_LEN(value);
if (value->header.domain != GRN_DB_TEXT) {
grn_obj buffer;
GRN_TEXT_INIT(&buffer, 0);
grn_inspect(ctx, &buffer, value);
GRN_LOG(ctx, GRN_LOG_ERROR,
"column name must be string: <%.*s>",
(int)GRN_TEXT_LEN(&buffer), GRN_TEXT_VALUE(&buffer));
GRN_OBJ_FIN(ctx, &buffer);
goto exit;
}
value++;
if (name_equal(name, name_size, GRN_COLUMN_NAME_ID)) {
if (id_value || key_value) {
if (loader->table->header.type == GRN_TABLE_NO_KEY) {
GRN_LOG(ctx, GRN_LOG_ERROR, "duplicated '_id' column");
goto exit;
} else {
GRN_LOG(ctx, GRN_LOG_ERROR,
"duplicated key columns: %s and %s",
id_value ? GRN_COLUMN_NAME_ID : GRN_COLUMN_NAME_KEY,
GRN_COLUMN_NAME_ID);
goto exit;
}
}
id_value = value;
} else if (name_equal(name, name_size, GRN_COLUMN_NAME_KEY)) {
if (id_value || key_value) {
GRN_LOG(ctx, GRN_LOG_ERROR,
"duplicated key columns: %s and %s",
id_value ? GRN_COLUMN_NAME_ID : GRN_COLUMN_NAME_KEY,
GRN_COLUMN_NAME_KEY);
goto exit;
}
key_value = value;
}
}
switch (loader->table->header.type) {
case GRN_TABLE_HASH_KEY :
case GRN_TABLE_PAT_KEY :
case GRN_TABLE_DAT_KEY :
/* The target table requires _id or _key. */
if (!id_value && !key_value) {
GRN_LOG(ctx, GRN_LOG_ERROR, "neither _key nor _id is assigned");
goto exit;
}
break;
default :
/* The target table does not have _key. */
if (key_value) {
GRN_LOG(ctx, GRN_LOG_ERROR, "nonexistent key value");
goto exit;
}
break;
}
if (id_value) {
id = parse_id_value(ctx, id_value);
if (grn_table_at(ctx, loader->table, id) == GRN_ID_NIL) {
if (ctx->rc == GRN_SUCCESS) {
id = grn_table_add(ctx, loader->table, NULL, 0, NULL);
}
}
} else if (key_value) {
id = loader_add(ctx, key_value);
} else {
id = grn_table_add(ctx, loader->table, NULL, 0, NULL);
}
if (id == GRN_ID_NIL) {
/* Target record is not available. */
goto exit;
}
for (value = value_begin; value + 1 < value_end;
value = values_next(ctx, value)) {
grn_obj *col;
const char *name = GRN_TEXT_VALUE(value);
unsigned int name_size = GRN_TEXT_LEN(value);
value++;
if (value == id_value || value == key_value) {
/* Skip _id and _key, because it's already used to get id. */
continue;
}
col = grn_obj_column(ctx, loader->table, name, name_size);
if (!col) {
GRN_LOG(ctx, GRN_LOG_ERROR, "invalid column('%.*s')",
(int)name_size, name);
/* Automatic column creation is disabled. */
/*
if (value->header.domain == GRN_JSON_LOAD_OPEN_BRACKET) {
grn_obj *v = value + 1;
col = grn_column_create(ctx, loader->table, name, name_size,
NULL, GRN_OBJ_PERSISTENT|GRN_OBJ_COLUMN_VECTOR,
grn_ctx_at(ctx, v->header.domain));
} else {
col = grn_column_create(ctx, loader->table, name, name_size,
NULL, GRN_OBJ_PERSISTENT,
grn_ctx_at(ctx, value->header.domain));
}
*/
} else {
if (value->header.domain == GRN_JSON_LOAD_OPEN_BRACKET) {
set_vector(ctx, col, id, value);
} else if (value->header.domain == GRN_JSON_LOAD_OPEN_BRACE) {
set_weight_vector(ctx, col, id, value);
} else {
grn_obj_set_value(ctx, col, id, value, GRN_OBJ_SET);
}
if (ctx->rc != GRN_SUCCESS) {
grn_loader_save_error(ctx, loader);
report_set_column_value_failure(ctx, key_value,
name, name_size, value);
loader->n_column_errors++;
ERRCLR(ctx);
}
grn_obj_unlink(ctx, col);
}
}
if (loader->each) {
value = grn_expr_get_var_by_offset(ctx, loader->each, 0);
GRN_RECORD_SET(ctx, value, id);
grn_expr_exec(ctx, loader->each, 0);
}
loader->nrecords++;
exit:
if (ctx->rc != GRN_SUCCESS) {
loader->n_record_errors++;
}
if (loader->output_ids) {
GRN_UINT32_PUT(ctx, &(loader->ids), id);
}
if (loader->output_errors) {
GRN_INT32_PUT(ctx, &(loader->return_codes), ctx->rc);
grn_vector_add_element(ctx,
&(loader->error_messages),
ctx->errbuf,
strlen(ctx->errbuf),
0,
GRN_DB_TEXT);
}
loader->values_size = begin;
ERRCLR(ctx);
}
void
test_mroonga_index_score(void)
{
grn_obj *t1,*c1,*lc,*ft;
grn_obj buff;
grn_id r1,r2,r3,r4;
const gchar *mrn_dir;
mrn_dir = cut_build_path(tmp_directory, "mrn", NULL);
g_mkdir_with_parents(mrn_dir, 0700);
grn_obj_close(context, db);
db = grn_db_create(context,
cut_build_path(mrn_dir, "mroonga.grn", NULL),
NULL);
cut_assert_not_null(db);
/* actual table */
t1 = grn_table_create(context, "t1", 2,
cut_build_path(mrn_dir, "t1.grn", NULL),
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, 0);
cut_assert_not_null(t1);
/* lexicon table */
lc = grn_table_create(context, "lc", 2,
cut_build_path(mrn_dir, "lc.grn", NULL),
GRN_OBJ_TABLE_PAT_KEY|GRN_OBJ_PERSISTENT,
grn_ctx_at(context, GRN_DB_SHORT_TEXT), 0);
cut_assert_not_null(lc);
grn_test_assert(grn_obj_set_info(context, lc, GRN_INFO_DEFAULT_TOKENIZER,
grn_ctx_at(context, GRN_DB_BIGRAM)));
/* actual column */
c1 = grn_column_create(context, t1, "c1", 2,
cut_build_path(mrn_dir, "t1.c1.grn", NULL),
GRN_OBJ_COLUMN_SCALAR|GRN_OBJ_PERSISTENT,
grn_ctx_at(context, GRN_DB_TEXT));
cut_assert_not_null(c1);
/* fulltext index */
ft = grn_column_create(context, lc, "ft", 2,
cut_build_path(mrn_dir, "lc.ft.grn", NULL),
GRN_OBJ_COLUMN_INDEX|GRN_OBJ_PERSISTENT, t1);
cut_assert_not_null(ft);
GRN_TEXT_INIT(&buff,0);
/* link between actual column and fulltext index */
GRN_UINT32_SET(context, &buff, grn_obj_id(context, c1));
grn_obj_set_info(context, ft, GRN_INFO_SOURCE, &buff); /* need to use grn_id */
/* insert row */
r1 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(1,r1);
GRN_TEXT_SETS(context, &buff, "abcde");
grn_test_assert(grn_obj_set_value(context, c1, r1, &buff, GRN_OBJ_SET));
r2 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(2,r2);
GRN_TEXT_SETS(context, &buff, "fghij");
grn_test_assert(grn_obj_set_value(context, c1, r2, &buff, GRN_OBJ_SET));
r3 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(3,r3);
GRN_TEXT_SETS(context, &buff, "11 22 33");
grn_test_assert(grn_obj_set_value(context, c1, r3, &buff, GRN_OBJ_SET));
r4 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(4,r4);
GRN_TEXT_SETS(context, &buff, "44 22 55");
grn_test_assert(grn_obj_set_value(context, c1, r4, &buff, GRN_OBJ_SET));
/* confirm record are inserted in both column and index */
cut_assert_equal_int(4,grn_table_size(context,t1));
cut_assert_equal_int(23,grn_table_size(context,lc));
/* nlq search */
{
grn_id id, docid;
grn_obj *res;
grn_table_cursor *tc;
grn_obj score, *score_column;
res = grn_table_create(context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, t1, 0);
GRN_FLOAT_INIT(&score, 0);
GRN_BULK_REWIND(&buff);
GRN_TEXT_SETS(context, &buff, "hij");
grn_obj_search(context, ft, &buff, res, GRN_OP_OR, NULL);
cut_assert_equal_int(1, grn_table_size(context, res));
score_column = grn_obj_column(context, res, "_score", 6);
tc = grn_table_cursor_open(context, res, NULL, 0, NULL, 0, 0, -1, 0);
while ((id = grn_table_cursor_next(context, tc))) {
GRN_BULK_REWIND(&buff);
grn_table_get_key(context, res, id, &docid, sizeof(grn_id));
cut_assert_equal_int(2, docid);
cut_assert_not_null(grn_obj_get_value(context, c1, docid, &buff));
cut_assert_equal_int(5 ,GRN_TEXT_LEN(&buff));
cut_assert_equal_substring("fghij", (char*) GRN_BULK_HEAD(&buff),GRN_TEXT_LEN(&buff));
grn_obj_get_value(context, score_column, id, &score);
cut_assert_equal_double(1.0, DBL_EPSILON, GRN_FLOAT_VALUE(&score));
}
grn_table_cursor_close(context, tc);
grn_obj_close(context, score_column);
grn_obj_close(context, res);
}
/* boolean search */
{
grn_id id, docid;
grn_obj *res;
grn_obj *match_columns, *match_columns_variable;
grn_obj *expression, *expression_variable;
grn_table_cursor *tc;
grn_obj score, *score_column;
const char *match_columns_expression = "c1 * 5";
const char *qstr = "+22 -55";
GRN_EXPR_CREATE_FOR_QUERY(context, t1,
match_columns, match_columns_variable);
grn_expr_parse(context, match_columns,
match_columns_expression,
strlen(match_columns_expression),
NULL, GRN_OP_MATCH, GRN_OP_AND,
GRN_EXPR_SYNTAX_SCRIPT);
GRN_EXPR_CREATE_FOR_QUERY(context, t1, expression, expression_variable);
res = grn_table_create(context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, t1, 0);
grn_test_assert(grn_expr_parse(context, expression,
qstr, strlen(qstr),
match_columns,
GRN_OP_MATCH, GRN_OP_OR,
GRN_EXPR_SYNTAX_QUERY));
grn_table_select(context, t1, expression, res, GRN_OP_OR);
cut_assert_equal_int(1, grn_table_size(context, res));
GRN_FLOAT_INIT(&score, 0);
score_column = grn_obj_column(context, res, "_score", 6);
tc = grn_table_cursor_open(context, res, NULL, 0, NULL, 0, 0, -1, 0);
while ((id = grn_table_cursor_next(context, tc))) {
GRN_BULK_REWIND(&buff);
grn_table_get_key(context, res, id, &docid, sizeof(grn_id));
cut_assert_equal_int(3, docid);
cut_assert_not_null(grn_obj_get_value(context, c1, docid, &buff));
cut_assert_equal_int(8, GRN_TEXT_LEN(&buff));
cut_assert_equal_substring("11 22 33", (char*) GRN_BULK_HEAD(&buff),GRN_TEXT_LEN(&buff));
grn_obj_get_value(context, score_column, id, &score);
cut_assert_equal_double(5, DBL_EPSILON, GRN_FLOAT_VALUE(&score));
}
grn_obj_close(context, expression);
grn_obj_close(context, match_columns);
grn_table_cursor_close(context ,tc);
grn_obj_close(context, score_column);
grn_obj_close(context, res);
}
grn_obj_close(context, &buff);
grn_obj_close(context, ft);
grn_obj_close(context, c1);
grn_obj_close(context, lc);
grn_obj_close(context, t1);
}
