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