static int
suggest_result(struct evbuffer *res_buf, const char *types, const char *query,
const char *target_name, int threshold, int limit,
grn_obj *cmd_buf, grn_ctx *ctx)
{
if (target_name && types && query) {
GRN_BULK_REWIND(cmd_buf);
GRN_TEXT_PUTS(ctx, cmd_buf, "/d/suggest?table=item_");
grn_text_urlenc(ctx, cmd_buf, target_name, strlen(target_name));
GRN_TEXT_PUTS(ctx, cmd_buf, "&column=kana&types=");
grn_text_urlenc(ctx, cmd_buf, types, strlen(types));
GRN_TEXT_PUTS(ctx, cmd_buf, "&query=");
grn_text_urlenc(ctx, cmd_buf, query, strlen(query));
GRN_TEXT_PUTS(ctx, cmd_buf, "&threshold=");
grn_text_itoa(ctx, cmd_buf, threshold);
GRN_TEXT_PUTS(ctx, cmd_buf, "&limit=");
grn_text_itoa(ctx, cmd_buf, limit);
{
char *res;
int flags;
unsigned int res_len;
grn_ctx_send(ctx, GRN_TEXT_VALUE(cmd_buf), GRN_TEXT_LEN(cmd_buf), 0);
grn_ctx_recv(ctx, &res, &res_len, &flags);
evbuffer_add(res_buf, res, res_len);
return res_len;
}
} else {
evbuffer_add(res_buf, "{}", 2);
return 2;
}
}
grn_rc
grn_expr_code_inspect_indented(grn_ctx *ctx,
grn_obj *buffer,
grn_expr_code *code,
const char *indent)
{
if (!code) {
GRN_TEXT_PUTS(ctx, buffer, "(NULL)");
return GRN_SUCCESS;
}
GRN_TEXT_PUTS(ctx, buffer, "<");
GRN_TEXT_PUTS(ctx, buffer, grn_operator_to_string(code->op));
GRN_TEXT_PUTS(ctx, buffer, " ");
GRN_TEXT_PUTS(ctx, buffer, "n_args:");
grn_text_itoa(ctx, buffer, code->nargs);
GRN_TEXT_PUTS(ctx, buffer, ", ");
GRN_TEXT_PUTS(ctx, buffer, "flags:");
grn_text_itoh(ctx, buffer, code->flags, 1);
GRN_TEXT_PUTS(ctx, buffer, ", ");
GRN_TEXT_PUTS(ctx, buffer, "modify:");
grn_text_itoa(ctx, buffer, code->modify);
GRN_TEXT_PUTS(ctx, buffer, ", ");
GRN_TEXT_PUTS(ctx, buffer, "value:");
grn_inspect_indented(ctx, buffer, code->value, " ");
GRN_TEXT_PUTS(ctx, buffer, ">");
return GRN_SUCCESS;
}
static grn_obj *
proc_status(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_obj *outbuf = args[0];
grn_expr_var *vars;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
if (nvars == 1) {
grn_timeval now;
grn_content_type otype = GET_OTYPE(&vars[0].value);
grn_timeval_now(ctx, &now);
switch (otype) {
case GRN_CONTENT_TSV:
/* TODO: implement */
break;
case GRN_CONTENT_JSON:
GRN_TEXT_PUTS(ctx, outbuf, "{\"starttime\":");
grn_text_itoa(ctx, outbuf, grn_starttime.tv_sec);
GRN_TEXT_PUTS(ctx, outbuf, ",\"uptime\":");
grn_text_itoa(ctx, outbuf, now.tv_sec - grn_starttime.tv_sec);
GRN_TEXT_PUTC(ctx, outbuf, '}');
break;
}
}
return outbuf;
}
void
grn_output_int32(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type, int value)
{
put_delimiter(ctx, outbuf, output_type);
switch (output_type) {
case GRN_CONTENT_JSON:
grn_text_itoa(ctx, outbuf, value);
break;
case GRN_CONTENT_TSV:
grn_text_itoa(ctx, outbuf, value);
break;
case GRN_CONTENT_XML:
GRN_TEXT_PUTS(ctx, outbuf, "<INT>");
grn_text_itoa(ctx, outbuf, value);
GRN_TEXT_PUTS(ctx, outbuf, "</INT>");
break;
case GRN_CONTENT_MSGPACK :
#ifdef HAVE_MESSAGE_PACK
msgpack_pack_int32(&ctx->impl->msgpacker, value);
#endif
break;
case GRN_CONTENT_NONE:
break;
}
INCR_LENGTH;
}
grn_rc
grn_string_inspect(grn_ctx *ctx, grn_obj *buffer, grn_obj *string)
{
grn_string *string_ = (grn_string *)string;
GRN_TEXT_PUTS(ctx, buffer, "#<string:");
GRN_TEXT_PUTS(ctx, buffer, " original:<");
GRN_TEXT_PUT(ctx, buffer,
string_->original,
string_->original_length_in_bytes);
GRN_TEXT_PUTS(ctx, buffer, ">");
GRN_TEXT_PUTS(ctx, buffer, "(");
grn_text_itoa(ctx, buffer, string_->original_length_in_bytes);
GRN_TEXT_PUTS(ctx, buffer, ")");
GRN_TEXT_PUTS(ctx, buffer, " normalized:<");
GRN_TEXT_PUT(ctx, buffer,
string_->normalized,
string_->normalized_length_in_bytes);
GRN_TEXT_PUTS(ctx, buffer, ">");
GRN_TEXT_PUTS(ctx, buffer, "(");
grn_text_itoa(ctx, buffer, string_->normalized_length_in_bytes);
GRN_TEXT_PUTS(ctx, buffer, ")");
GRN_TEXT_PUTS(ctx, buffer, " n_characters:");
grn_text_itoa(ctx, buffer, string_->n_characters);
GRN_TEXT_PUTS(ctx, buffer, " encoding:");
grn_inspect_encoding(ctx, buffer, string_->encoding);
GRN_TEXT_PUTS(ctx, buffer, " flags:");
if (string_->flags & GRN_STRING_REMOVE_BLANK) {
GRN_TEXT_PUTS(ctx, buffer, "REMOVE_BLANK|");
}
if (string_->flags & GRN_STRING_WITH_TYPES) {
GRN_TEXT_PUTS(ctx, buffer, "WITH_TYPES|");
}
if (string_->flags & GRN_STRING_WITH_CHECKS) {
GRN_TEXT_PUTS(ctx, buffer, "WITH_CHECKS|");
}
if (string_->flags & GRN_STRING_REMOVE_TOKENIZED_DELIMITER) {
GRN_TEXT_PUTS(ctx, buffer, "REMOVE_TOKENIZED_DELIMITER|");
}
if (GRN_TEXT_VALUE(buffer)[GRN_TEXT_LEN(buffer) - 1] == '|') {
grn_bulk_truncate(ctx, buffer, GRN_TEXT_LEN(buffer) - 1);
}
GRN_TEXT_PUTS(ctx, buffer, ">");
return GRN_SUCCESS;
}
void
grn_output_geo_point(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
grn_geo_point *value)
{
put_delimiter(ctx, outbuf, output_type);
switch (output_type) {
case GRN_CONTENT_JSON:
if (value) {
GRN_TEXT_PUTC(ctx, outbuf, '"');
grn_text_itoa(ctx, outbuf, value->latitude);
GRN_TEXT_PUTC(ctx, outbuf, 'x');
grn_text_itoa(ctx, outbuf, value->longitude);
GRN_TEXT_PUTC(ctx, outbuf, '"');
} else {
GRN_TEXT_PUTS(ctx, outbuf, "null");
}
break;
case GRN_CONTENT_TSV:
if (value) {
GRN_TEXT_PUTC(ctx, outbuf, '"');
grn_text_itoa(ctx, outbuf, value->latitude);
GRN_TEXT_PUTC(ctx, outbuf, 'x');
grn_text_itoa(ctx, outbuf, value->longitude);
GRN_TEXT_PUTC(ctx, outbuf, '"');
} else {
GRN_TEXT_PUTS(ctx, outbuf, "\"\"");
}
break;
case GRN_CONTENT_XML:
GRN_TEXT_PUTS(ctx, outbuf, "<GEO_POINT>");
if (value) {
grn_text_itoa(ctx, outbuf, value->latitude);
GRN_TEXT_PUTC(ctx, outbuf, 'x');
grn_text_itoa(ctx, outbuf, value->longitude);
}
GRN_TEXT_PUTS(ctx, outbuf, "</GEO_POINT>");
break;
case GRN_CONTENT_MSGPACK :
#ifdef HAVE_MESSAGE_PACK
if (value) {
grn_obj buf;
GRN_TEXT_INIT(&buf, 0);
grn_text_itoa(ctx, &buf, value->latitude);
GRN_TEXT_PUTC(ctx, &buf, 'x');
grn_text_itoa(ctx, &buf, value->longitude);
msgpack_pack_raw(&ctx->impl->msgpacker, GRN_TEXT_LEN(&buf));
msgpack_pack_raw_body(&ctx->impl->msgpacker,
GRN_TEXT_VALUE(&buf),
GRN_TEXT_LEN(&buf));
grn_obj_close(ctx, &buf);
} else {
msgpack_pack_nil(&ctx->impl->msgpacker);
}
#endif
break;
case GRN_CONTENT_NONE:
break;
}
INCR_LENGTH;
}
static grn_rc
grn_vector_inspect(grn_ctx *ctx, grn_obj *buffer, grn_obj *vector)
{
int i;
grn_obj *body = vector->u.v.body;
GRN_TEXT_PUTS(ctx, buffer, "[");
for (i = 0; i < vector->u.v.n_sections; i++) {
grn_section *section = &(vector->u.v.sections[i]);
const char *value_raw;
if (i > 0) {
GRN_TEXT_PUTS(ctx, buffer, ", ");
}
value_raw = GRN_BULK_HEAD(body) + section->offset;
GRN_TEXT_PUTS(ctx, buffer, "{");
GRN_TEXT_PUTS(ctx, buffer, "\"value\":");
{
grn_obj value_object;
GRN_OBJ_INIT(&value_object, GRN_BULK, GRN_OBJ_DO_SHALLOW_COPY,
section->domain);
grn_bulk_write(ctx, &value_object, value_raw, section->length);
grn_inspect(ctx, buffer, &value_object);
GRN_OBJ_FIN(ctx, &value_object);
}
GRN_TEXT_PUTS(ctx, buffer, ", \"weight\":");
grn_text_itoa(ctx, buffer, section->weight);
GRN_TEXT_PUTS(ctx, buffer, "}");
}
GRN_TEXT_PUTS(ctx, buffer, "]");
return GRN_SUCCESS;
}
VALUE
rb_grn_context_to_exception (grn_ctx *context, VALUE related_object)
{
VALUE exception, exception_class;
const char *message;
grn_obj bulk;
if (context->rc == GRN_SUCCESS)
return Qnil;
exception_class = rb_grn_rc_to_exception(context->rc);
message = rb_grn_rc_to_message(context->rc);
GRN_OBJ_INIT(&bulk, GRN_BULK, 0, GRN_ID_NIL);
GRN_TEXT_PUTS(context, &bulk, message);
GRN_TEXT_PUTS(context, &bulk, ": ");
GRN_TEXT_PUTS(context, &bulk, context->errbuf);
if (!NIL_P(related_object)) {
GRN_TEXT_PUTS(context, &bulk, ": ");
GRN_TEXT_PUTS(context, &bulk, rb_grn_inspect(related_object));
}
GRN_TEXT_PUTS(context, &bulk, "\n");
GRN_TEXT_PUTS(context, &bulk, context->errfile);
GRN_TEXT_PUTS(context, &bulk, ":");
grn_text_itoa(context, &bulk, context->errline);
GRN_TEXT_PUTS(context, &bulk, ": ");
GRN_TEXT_PUTS(context, &bulk, context->errfunc);
GRN_TEXT_PUTS(context, &bulk, "()");
exception = rb_funcall(exception_class, rb_intern("new"), 1,
rb_str_new(GRN_BULK_HEAD(&bulk),
GRN_BULK_VSIZE(&bulk)));
grn_obj_unlink(context, &bulk);
return exception;
}
/* grn_ts_geo_output() outputs a value. */
static grn_rc
grn_ts_geo_output(grn_ctx *ctx, grn_ts_geo value)
{
grn_rc rc = grn_bulk_write(ctx, ctx->impl->output.buf, "\"", 1);
if (rc != GRN_SUCCESS) {
return rc;
}
rc = grn_text_itoa(ctx, ctx->impl->output.buf, value.latitude);
if (rc != GRN_SUCCESS) {
return rc;
}
rc = grn_bulk_write(ctx, ctx->impl->output.buf, "x", 1);
if (rc != GRN_SUCCESS) {
return rc;
}
rc = grn_text_itoa(ctx, ctx->impl->output.buf, value.longitude);
if (rc != GRN_SUCCESS) {
return rc;
}
return grn_bulk_write(ctx, ctx->impl->output.buf, "\"", 1);
}
static int
print_tableinfo(grn_ctx *ctx, grn_obj *table, grn_obj *buf, grn_content_type otype)
{
grn_id id;
char name[GRN_TABLE_MAX_KEY_SIZE];
const char *path;
int name_len;
switch (table->header.type) {
case GRN_TABLE_HASH_KEY:
case GRN_TABLE_PAT_KEY:
case GRN_TABLE_NO_KEY:
case GRN_TABLE_VIEW:
break;
default:
return 0;
}
id = grn_obj_id(ctx, table);
name_len = grn_obj_name(ctx, table, name, GRN_TABLE_MAX_KEY_SIZE);
path = grn_obj_path(ctx, table);
switch (otype) {
case GRN_CONTENT_TSV:
grn_text_itoa(ctx, buf, id);
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_esc(ctx, buf, name, name_len);
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_esc(ctx, buf, path, GRN_STRLEN(path));
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_itoa(ctx, buf, table->header.flags);
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_itoa(ctx, buf, table->header.domain);
/* TODO: domain to str */
break;
case GRN_CONTENT_JSON:
GRN_TEXT_PUTC(ctx, buf, '[');
grn_text_itoa(ctx, buf, id);
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_esc(ctx, buf, name, name_len);
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_esc(ctx, buf, path, GRN_STRLEN(path));
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_itoa(ctx, buf, table->header.flags);
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_itoa(ctx, buf, table->header.domain);
/* TODO: domain to str */
GRN_TEXT_PUTC(ctx, buf, ']');
break;
}
return 1;
}
static grn_obj *
proc_load(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_obj *outbuf = args[0];
grn_expr_var *vars;
grn_obj *proc = grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
if (nvars == 5) {
grn_load(ctx, GET_OTYPE(&vars[4].value),
GRN_TEXT_VALUE(&vars[1].value), GRN_TEXT_LEN(&vars[1].value),
GRN_TEXT_VALUE(&vars[2].value), GRN_TEXT_LEN(&vars[2].value),
GRN_TEXT_VALUE(&vars[0].value), GRN_TEXT_LEN(&vars[0].value),
GRN_TEXT_VALUE(&vars[3].value), GRN_TEXT_LEN(&vars[3].value));
if (ctx->impl->loader.stat == GRN_LOADER_BEGIN) {
grn_text_itoa(ctx, outbuf, ctx->impl->loader.nrecords);
} else {
grn_ctx_set_next_expr(ctx, proc);
}
}
return outbuf;
}
grn_obj *
grn_inspect_encoding(grn_ctx *ctx, grn_obj *buf, grn_encoding encoding)
{
switch (encoding) {
case GRN_ENC_DEFAULT :
GRN_TEXT_PUTS(ctx, buf, "default(");
grn_inspect_encoding(ctx, buf, grn_get_default_encoding());
GRN_TEXT_PUTS(ctx, buf, ")");
break;
case GRN_ENC_NONE :
GRN_TEXT_PUTS(ctx, buf, "none");
break;
case GRN_ENC_EUC_JP :
GRN_TEXT_PUTS(ctx, buf, "EUC-JP");
break;
case GRN_ENC_UTF8 :
GRN_TEXT_PUTS(ctx, buf, "UTF-8");
break;
case GRN_ENC_SJIS :
GRN_TEXT_PUTS(ctx, buf, "Shift_JIS");
break;
case GRN_ENC_LATIN1 :
GRN_TEXT_PUTS(ctx, buf, "Latin-1");
break;
case GRN_ENC_KOI8R :
GRN_TEXT_PUTS(ctx, buf, "KOI8-R");
break;
default :
GRN_TEXT_PUTS(ctx, buf, "unknown(");
grn_text_itoa(ctx, buf, encoding);
GRN_TEXT_PUTS(ctx, buf, ")");
break;
}
return buf;
}
static int
print_columninfo(grn_ctx *ctx, grn_obj *column, grn_obj *buf, grn_content_type otype)
{
grn_id id;
char *type, name[GRN_TABLE_MAX_KEY_SIZE];
const char *path;
int name_len;
switch (column->header.type) {
case GRN_COLUMN_FIX_SIZE:
type = "\"fix\"";
break;
case GRN_COLUMN_VAR_SIZE:
type = "\"var\"";
break;
case GRN_COLUMN_INDEX:
type = "\"index\"";
break;
default:
GRN_LOG(ctx, GRN_LOG_NOTICE, "invalid header type %d\n", column->header.type);
return 0;
}
id = grn_obj_id(ctx, column);
name_len = grn_column_name(ctx, column, name, GRN_TABLE_MAX_KEY_SIZE);
path = grn_obj_path(ctx, column);
switch (otype) {
case GRN_CONTENT_TSV:
grn_text_itoa(ctx, buf, id);
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_esc(ctx, buf, name, name_len);
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_esc(ctx, buf, path, GRN_STRLEN(path));
GRN_TEXT_PUTC(ctx, buf, '\t');
GRN_TEXT_PUTS(ctx, buf, type);
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_itoa(ctx, buf, column->header.flags);
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_itoa(ctx, buf, column->header.domain);
/* TODO: flags to str, domain to str */
break;
case GRN_CONTENT_JSON:
GRN_TEXT_PUTC(ctx, buf, '[');
grn_text_itoa(ctx, buf, id);
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_esc(ctx, buf, name, name_len);
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_esc(ctx, buf, path, GRN_STRLEN(path));
GRN_TEXT_PUTC(ctx, buf, ',');
GRN_TEXT_PUTS(ctx, buf, type);
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_itoa(ctx, buf, column->header.flags);
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_itoa(ctx, buf, column->header.domain);
/* TODO: flags to str, domain to str */
GRN_TEXT_PUTC(ctx, buf, ']');
break;
}
return 1;
}
void
grn_output_obj(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
grn_obj *obj, grn_obj_format *format)
{
grn_obj buf;
GRN_TEXT_INIT(&buf, 0);
switch (obj->header.type) {
case GRN_BULK :
switch (obj->header.domain) {
case GRN_DB_VOID :
grn_output_void(ctx, outbuf, output_type, GRN_BULK_HEAD(obj), GRN_BULK_VSIZE(obj));
break;
case GRN_DB_SHORT_TEXT :
case GRN_DB_TEXT :
case GRN_DB_LONG_TEXT :
grn_output_str(ctx, outbuf, output_type, GRN_BULK_HEAD(obj), GRN_BULK_VSIZE(obj));
break;
case GRN_DB_BOOL :
grn_output_bool(ctx, outbuf, output_type,
GRN_BULK_VSIZE(obj) ? GRN_UINT8_VALUE(obj) : 0);
break;
case GRN_DB_INT8 :
grn_output_int32(ctx, outbuf, output_type,
GRN_BULK_VSIZE(obj) ? GRN_INT8_VALUE(obj) : 0);
break;
case GRN_DB_UINT8 :
grn_output_int32(ctx, outbuf, output_type,
GRN_BULK_VSIZE(obj) ? GRN_UINT8_VALUE(obj) : 0);
break;
case GRN_DB_INT16 :
grn_output_int32(ctx, outbuf, output_type,
GRN_BULK_VSIZE(obj) ? GRN_INT16_VALUE(obj) : 0);
break;
case GRN_DB_UINT16 :
grn_output_int32(ctx, outbuf, output_type,
GRN_BULK_VSIZE(obj) ? GRN_UINT16_VALUE(obj) : 0);
break;
case GRN_DB_INT32 :
grn_output_int32(ctx, outbuf, output_type,
GRN_BULK_VSIZE(obj) ? GRN_INT32_VALUE(obj) : 0);
break;
case GRN_DB_UINT32 :
grn_output_int64(ctx, outbuf, output_type,
GRN_BULK_VSIZE(obj) ? GRN_UINT32_VALUE(obj) : 0);
break;
case GRN_DB_INT64 :
grn_output_int64(ctx, outbuf, output_type,
GRN_BULK_VSIZE(obj) ? GRN_INT64_VALUE(obj) : 0);
break;
case GRN_DB_UINT64 :
grn_output_uint64(ctx, outbuf, output_type,
GRN_BULK_VSIZE(obj) ? GRN_UINT64_VALUE(obj) : 0);
break;
case GRN_DB_FLOAT :
grn_output_float(ctx, outbuf, output_type,
GRN_BULK_VSIZE(obj) ? GRN_FLOAT_VALUE(obj) : 0);
break;
case GRN_DB_TIME :
grn_output_time(ctx, outbuf, output_type,
GRN_BULK_VSIZE(obj) ? GRN_INT64_VALUE(obj) : 0);
break;
case GRN_DB_TOKYO_GEO_POINT :
case GRN_DB_WGS84_GEO_POINT :
grn_output_geo_point(ctx, outbuf, output_type,
GRN_BULK_VSIZE(obj) ? (grn_geo_point *)GRN_BULK_HEAD(obj) : NULL);
break;
default :
if (format) {
int j;
int ncolumns = GRN_BULK_VSIZE(&format->columns)/sizeof(grn_obj *);
grn_obj **columns = (grn_obj **)GRN_BULK_HEAD(&format->columns);
if (format->flags & GRN_OBJ_FORMAT_WITH_COLUMN_NAMES) {
grn_output_array_open(ctx, outbuf, output_type, "COLUMNS", ncolumns);
for (j = 0; j < ncolumns; j++) {
grn_id range_id;
grn_output_array_open(ctx, outbuf, output_type, "COLUMN", 2);
GRN_BULK_REWIND(&buf);
grn_column_name_(ctx, columns[j], &buf);
grn_output_obj(ctx, outbuf, output_type, &buf, NULL);
/* column range */
range_id = grn_obj_get_range(ctx, columns[j]);
if (range_id == GRN_ID_NIL) {
GRN_TEXT_PUTS(ctx, outbuf, "null");
} else {
int name_len;
grn_obj *range_obj;
char name_buf[GRN_TABLE_MAX_KEY_SIZE];
range_obj = grn_ctx_at(ctx, range_id);
name_len = grn_obj_name(ctx, range_obj, name_buf,
GRN_TABLE_MAX_KEY_SIZE);
GRN_BULK_REWIND(&buf);
GRN_TEXT_PUT(ctx, &buf, name_buf, name_len);
grn_output_obj(ctx, outbuf, output_type, &buf, NULL);
}
grn_output_array_close(ctx, outbuf, output_type);
}
grn_output_array_close(ctx, outbuf, output_type);
}
grn_output_array_open(ctx, outbuf, output_type, "HIT", ncolumns);
for (j = 0; j < ncolumns; j++) {
grn_text_atoj_o(ctx, outbuf, output_type, columns[j], obj);
}
grn_output_array_close(ctx, outbuf, output_type);
} else {
grn_obj *table = grn_ctx_at(ctx, obj->header.domain);
grn_id id = *((grn_id *)GRN_BULK_HEAD(obj));
if (table && table->header.type != GRN_TABLE_NO_KEY) {
grn_obj *accessor = grn_obj_column(ctx, table, "_key", 4);
if (accessor) {
grn_obj_get_value(ctx, accessor, id, &buf);
grn_obj_unlink(ctx, accessor);
}
grn_output_obj(ctx, outbuf, output_type, &buf, format);
} else {
grn_output_int64(ctx, outbuf, output_type, id);
}
}
break;
}
break;
case GRN_UVECTOR :
if (format) {
int i, j;
grn_id *v = (grn_id *)GRN_BULK_HEAD(obj), *ve = (grn_id *)GRN_BULK_CURR(obj);
int ncolumns = GRN_BULK_VSIZE(&format->columns) / sizeof(grn_obj *);
grn_obj **columns = (grn_obj **)GRN_BULK_HEAD(&format->columns);
grn_output_array_open(ctx, outbuf, output_type, "RESULTSET", -1);
grn_output_array_open(ctx, outbuf, output_type, "NHITS", 1);
grn_text_itoa(ctx, outbuf, ve - v);
grn_output_array_close(ctx, outbuf, output_type);
if (v < ve) {
if (format->flags & GRN_OBJ_FORMAT_WITH_COLUMN_NAMES) {
grn_output_array_open(ctx, outbuf, output_type, "COLUMNS", -1);
for (j = 0; j < ncolumns; j++) {
grn_id range_id;
grn_output_array_open(ctx, outbuf, output_type, "COLUMN", -1);
GRN_BULK_REWIND(&buf);
grn_column_name_(ctx, columns[j], &buf);
grn_output_obj(ctx, outbuf, output_type, &buf, NULL);
/* column range */
range_id = grn_obj_get_range(ctx, columns[j]);
if (range_id == GRN_ID_NIL) {
GRN_TEXT_PUTS(ctx, outbuf, "null");
} else {
int name_len;
grn_obj *range_obj;
char name_buf[GRN_TABLE_MAX_KEY_SIZE];
range_obj = grn_ctx_at(ctx, range_id);
name_len = grn_obj_name(ctx, range_obj, name_buf,
GRN_TABLE_MAX_KEY_SIZE);
GRN_BULK_REWIND(&buf);
GRN_TEXT_PUT(ctx, &buf, name_buf, name_len);
grn_output_obj(ctx, outbuf, output_type, &buf, NULL);
}
grn_output_array_close(ctx, outbuf, output_type);
}
grn_output_array_close(ctx, outbuf, output_type);
}
for (i = 0;; i++) {
grn_output_array_open(ctx, outbuf, output_type, "HITS", -1);
for (j = 0; j < ncolumns; j++) {
GRN_BULK_REWIND(&buf);
grn_obj_get_value(ctx, columns[j], *v, &buf);
grn_output_obj(ctx, outbuf, output_type, &buf, NULL);
}
grn_output_array_close(ctx, outbuf, output_type);
v++;
if (v < ve) {
} else {
break;
}
}
}
grn_output_array_close(ctx, outbuf, output_type);
} else {
grn_obj *range = grn_ctx_at(ctx, obj->header.domain);
if (range && range->header.type == GRN_TYPE) {
int value_size = ((struct _grn_type *)range)->obj.range;
char *v = (char *)GRN_BULK_HEAD(obj),
*ve = (char *)GRN_BULK_CURR(obj);
grn_output_array_open(ctx, outbuf, output_type, "VECTOR", -1);
if (v < ve) {
for (;;) {
grn_obj value;
GRN_OBJ_INIT(&value, GRN_BULK, 0, obj->header.domain);
grn_bulk_write_from(ctx, &value, v, 0, value_size);
grn_output_obj(ctx, outbuf, output_type, &value, NULL);
v += value_size;
if (v < ve) {
} else {
break;
}
}
}
grn_output_array_close(ctx, outbuf, output_type);
} else {
grn_id *v = (grn_id *)GRN_BULK_HEAD(obj),
*ve = (grn_id *)GRN_BULK_CURR(obj);
grn_output_array_open(ctx, outbuf, output_type, "VECTOR", ve - v);
if (v < ve) {
grn_obj key;
GRN_OBJ_INIT(&key, GRN_BULK, 0, range->header.domain);
for (;;) {
if (range->header.type != GRN_TABLE_NO_KEY) {
grn_table_get_key2(ctx, range, *v, &key);
grn_output_obj(ctx, outbuf, output_type, &key, NULL);
GRN_BULK_REWIND(&key);
} else {
grn_obj id;
GRN_UINT32_INIT(&id, 0);
GRN_UINT32_SET(ctx, &id, *v);
grn_output_obj(ctx, outbuf, output_type, &id, NULL);
GRN_OBJ_FIN(ctx, &id);
}
v++;
if (v < ve) {
} else {
break;
}
}
GRN_OBJ_FIN(ctx, &key);
}
grn_output_array_close(ctx, outbuf, output_type);
}
}
break;
case GRN_VECTOR :
if (obj->header.domain == GRN_DB_VOID) {
ERR(GRN_INVALID_ARGUMENT, "invalid obj->header.domain");
}
if (format) {
ERR(GRN_FUNCTION_NOT_IMPLEMENTED,
"cannot print GRN_VECTOR using grn_obj_format");
} else {
unsigned int i, n;
grn_obj value;
GRN_VOID_INIT(&value);
n = grn_vector_size(ctx, obj);
grn_output_array_open(ctx, outbuf, output_type, "VECTOR", -1);
for (i = 0; i < n; i++) {
const char *_value;
unsigned int weight, length;
grn_id domain;
length = grn_vector_get_element(ctx, obj, i,
&_value, &weight, &domain);
if (domain != GRN_DB_VOID) {
grn_obj_reinit(ctx, &value, domain, 0);
} else {
grn_obj_reinit(ctx, &value, obj->header.domain, 0);
}
grn_bulk_write(ctx, &value, _value, length);
grn_output_obj(ctx, outbuf, output_type, &value, NULL);
}
grn_output_array_close(ctx, outbuf, output_type);
GRN_OBJ_FIN(ctx, &value);
}
break;
case GRN_PVECTOR :
if (format) {
ERR(GRN_FUNCTION_NOT_IMPLEMENTED,
"cannot print GRN_PVECTOR using grn_obj_format");
} else {
unsigned int i, n;
grn_output_array_open(ctx, outbuf, output_type, "VECTOR", -1);
n = GRN_BULK_VSIZE(obj) / sizeof(grn_obj *);
for (i = 0; i < n; i++) {
grn_obj *value;
value = GRN_PTR_VALUE_AT(obj, i);
grn_output_obj(ctx, outbuf, output_type, value, NULL);
}
grn_output_array_close(ctx, outbuf, output_type);
}
break;
case GRN_TABLE_HASH_KEY :
case GRN_TABLE_PAT_KEY :
case GRN_TABLE_NO_KEY :
case GRN_TABLE_VIEW :
if (format) {
int i, j;
int ncolumns = GRN_BULK_VSIZE(&format->columns)/sizeof(grn_obj *);
grn_obj **columns = (grn_obj **)GRN_BULK_HEAD(&format->columns);
grn_table_cursor *tc = grn_table_cursor_open(ctx, obj, NULL, 0, NULL, 0,
format->offset, format->limit,
GRN_CURSOR_ASCENDING);
int resultset_size = -1;
if (!tc) { ERRCLR(ctx); }
#ifdef HAVE_MESSAGE_PACK
resultset_size = 1; /* [NHITS, (COLUMNS), (HITS)] */
if (format->flags & GRN_OBJ_FORMAT_WITH_COLUMN_NAMES) {
resultset_size++;
}
resultset_size += format->limit;
#endif
grn_output_array_open(ctx, outbuf, output_type, "RESULTSET", resultset_size);
grn_output_array_open(ctx, outbuf, output_type, "NHITS", 1);
if (output_type == GRN_CONTENT_XML) {
grn_text_itoa(ctx, outbuf, format->nhits);
} else {
grn_output_int32(ctx, outbuf, output_type, format->nhits);
}
grn_output_array_close(ctx, outbuf, output_type);
if (format->flags & GRN_OBJ_FORMAT_WITH_COLUMN_NAMES) {
grn_output_array_open(ctx, outbuf, output_type, "COLUMNS", ncolumns);
for (j = 0; j < ncolumns; j++) {
grn_id range_id;
grn_output_array_open(ctx, outbuf, output_type, "COLUMN", 2);
GRN_BULK_REWIND(&buf);
grn_column_name_(ctx, columns[j], &buf);
grn_output_obj(ctx, outbuf, output_type, &buf, NULL);
/* column range */
range_id = grn_obj_get_range(ctx, columns[j]);
if (range_id == GRN_ID_NIL) {
GRN_TEXT_PUTS(ctx, outbuf, "null");
} else {
int name_len;
grn_obj *range_obj;
char name_buf[GRN_TABLE_MAX_KEY_SIZE];
range_obj = grn_ctx_at(ctx, range_id);
name_len = grn_obj_name(ctx, range_obj, name_buf,
GRN_TABLE_MAX_KEY_SIZE);
GRN_BULK_REWIND(&buf);
GRN_TEXT_PUT(ctx, &buf, name_buf, name_len);
grn_output_obj(ctx, outbuf, output_type, &buf, NULL);
}
grn_output_array_close(ctx, outbuf, output_type);
}
grn_output_array_close(ctx, outbuf, output_type);
}
if (tc) {
grn_obj id;
GRN_TEXT_INIT(&id, 0);
for (i = 0; !grn_table_cursor_next_o(ctx, tc, &id); i++) {
grn_output_array_open(ctx, outbuf, output_type, "HIT", ncolumns);
for (j = 0; j < ncolumns; j++) {
grn_text_atoj_o(ctx, outbuf, output_type, columns[j], &id);
}
grn_output_array_close(ctx, outbuf, output_type);
}
GRN_OBJ_FIN(ctx, &id);
grn_table_cursor_close(ctx, tc);
}
grn_output_array_close(ctx, outbuf, output_type);
} else {
int i;
grn_obj *column = grn_obj_column(ctx, obj, "_key", 4);
grn_table_cursor *tc = grn_table_cursor_open(ctx, obj, NULL, 0, NULL, 0,
0, -1, GRN_CURSOR_ASCENDING);
grn_output_array_open(ctx, outbuf, output_type, "HIT", -1);
if (tc) {
grn_obj id;
GRN_TEXT_INIT(&id, 0);
for (i = 0; !grn_table_cursor_next_o(ctx, tc, &id); i++) {
/* todo:
grn_text_atoj_o(ctx, outbuf, output_type, column, &id);
*/
GRN_BULK_REWIND(&buf);
grn_obj_get_value_o(ctx, column, &id, &buf);
grn_text_esc(ctx, outbuf, GRN_BULK_HEAD(&buf), GRN_BULK_VSIZE(&buf));
}
GRN_OBJ_FIN(ctx, &id);
grn_table_cursor_close(ctx, tc);
}
grn_output_array_close(ctx, outbuf, output_type);
grn_obj_unlink(ctx, column);
}
break;
}
GRN_OBJ_FIN(ctx, &buf);
}
