grn_rc
grn_expr_inspect(grn_ctx *ctx, grn_obj *buffer, grn_obj *expr)
{
grn_expr *e = (grn_expr *)expr;
GRN_TEXT_PUTS(ctx, buffer, "#<expr\n");
{
int i = 0;
grn_obj *value;
const char *name;
uint32_t name_len;
unsigned int n_vars;
grn_hash *vars = grn_expr_get_vars(ctx, expr, &n_vars);
GRN_TEXT_PUTS(ctx, buffer, " vars:{");
GRN_HASH_EACH(ctx, vars, id, &name, &name_len, &value, {
if (i++) {
GRN_TEXT_PUTC(ctx, buffer, ',');
}
GRN_TEXT_PUTS(ctx, buffer, "\n ");
GRN_TEXT_PUT(ctx, buffer, name, name_len);
GRN_TEXT_PUTC(ctx, buffer, ':');
grn_inspect_indented(ctx, buffer, value, " ");
});
GRN_TEXT_PUTS(ctx, buffer, "\n },");
}
static ngx_int_t
ngx_http_groonga_handler_validate_post_command(ngx_http_request_t *r,
ngx_str_t *command_path,
ngx_http_groonga_handler_data_t *data)
{
grn_ctx *context;
ngx_str_t command;
command.data = command_path->data;
if (r->args.len == 0) {
command.len = command_path->len;
} else {
command.len = command_path->len - r->args.len - strlen("?");
}
if (ngx_str_equal_c_string(&command, "load")) {
return NGX_OK;
}
context = &(data->context);
ngx_http_groonga_handler_set_content_type(r, "text/plain");
GRN_TEXT_PUTS(context, &(data->body), "command for POST must be <load>: <");
GRN_TEXT_PUT(context, &(data->body), command.data, command.len);
GRN_TEXT_PUTS(context, &(data->body), ">");
return NGX_HTTP_BAD_REQUEST;
}
/*
* call-seq:
* _expression_.inspect -> String
*
* _expression_の中身を人に見やすい文字列で返す。
*/
static VALUE
rb_grn_expression_inspect (VALUE self)
{
grn_ctx *context = NULL;
grn_obj inspected;
grn_obj *expression;
VALUE rb_inspected;
rb_grn_expression_deconstruct(SELF(self), &expression, &context,
NULL, NULL,
NULL, NULL, NULL);
GRN_TEXT_INIT(&inspected, 0);
GRN_TEXT_PUTS(context, &inspected, "#<Groonga::Expression ");
#ifdef WIN32
GRN_TEXT_PUTS(context, &inspected, "(not supported on Windows)");
#else
grn_expr_inspect(context, &inspected, expression);
#endif
GRN_TEXT_PUTS(context, &inspected, ">");
rb_inspected = rb_grn_context_rb_string_new(context,
GRN_TEXT_VALUE(&inspected),
GRN_TEXT_LEN(&inspected));
GRN_OBJ_FIN(context, &inspected);
return rb_inspected;
}
void
grn_output_array_open(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
const char *name, int nelements)
{
put_delimiter(ctx, outbuf, output_type);
switch (output_type) {
case GRN_CONTENT_JSON:
GRN_TEXT_PUTC(ctx, outbuf, '[');
break;
case GRN_CONTENT_XML:
GRN_TEXT_PUTC(ctx, outbuf, '<');
GRN_TEXT_PUTS(ctx, outbuf, name);
GRN_TEXT_PUTC(ctx, outbuf, '>');
grn_vector_add_element(ctx, &ctx->impl->names, name, strlen(name), 0, GRN_DB_SHORT_TEXT);
break;
case GRN_CONTENT_TSV:
if (DEPTH > 2) { GRN_TEXT_PUTS(ctx, outbuf, "[\t"); }
break;
case GRN_CONTENT_MSGPACK :
#ifdef HAVE_MESSAGE_PACK
if (nelements < 0) {
GRN_LOG(ctx, GRN_LOG_DEBUG,
"grn_output_array_open nelements (%d) for <%s>",
nelements,
name);
}
msgpack_pack_array(&ctx->impl->msgpacker, nelements);
#endif
break;
case GRN_CONTENT_NONE:
break;
}
INCR_DEPTH(0);
}
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_time(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type, int64_t value)
{
double dv = value;
dv /= 1000000.0;
put_delimiter(ctx, outbuf, output_type);
switch (output_type) {
case GRN_CONTENT_JSON:
grn_text_ftoa(ctx, outbuf, dv);
break;
case GRN_CONTENT_TSV:
grn_text_ftoa(ctx, outbuf, dv);
break;
case GRN_CONTENT_XML:
GRN_TEXT_PUTS(ctx, outbuf, "<DATE>");
grn_text_ftoa(ctx, outbuf, dv);
GRN_TEXT_PUTS(ctx, outbuf, "</DATE>");
break;
case GRN_CONTENT_MSGPACK :
#ifdef HAVE_MESSAGE_PACK
msgpack_pack_double(&ctx->impl->msgpacker, dv);
#endif
break;
case GRN_CONTENT_NONE:
break;
}
INCR_LENGTH;
}
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;
}
void
grn_output_bool(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type, char value)
{
put_delimiter(ctx, outbuf, output_type);
switch (output_type) {
case GRN_CONTENT_JSON:
GRN_TEXT_PUTS(ctx, outbuf, value ? "true" : "false");
break;
case GRN_CONTENT_TSV:
GRN_TEXT_PUTS(ctx, outbuf, value ? "true" : "false");
break;
case GRN_CONTENT_XML:
GRN_TEXT_PUTS(ctx, outbuf, "<BOOL>");
GRN_TEXT_PUTS(ctx, outbuf, value ? "true" : "false");
GRN_TEXT_PUTS(ctx, outbuf, "</BOOL>");
break;
case GRN_CONTENT_MSGPACK :
#ifdef HAVE_MESSAGE_PACK
if (value) {
msgpack_pack_true(&ctx->impl->msgpacker);
} else {
msgpack_pack_false(&ctx->impl->msgpacker);
}
#endif
break;
case GRN_CONTENT_NONE:
break;
}
INCR_LENGTH;
}
void
grn_output_void(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
const char *value, size_t value_len)
{
if (value_len == sizeof(grn_id) && *(grn_id *)value == GRN_ID_NIL) {
put_delimiter(ctx, outbuf, output_type);
switch (output_type) {
case GRN_CONTENT_JSON:
GRN_TEXT_PUTS(ctx, outbuf, "null");
break;
case GRN_CONTENT_TSV:
break;
case GRN_CONTENT_XML:
GRN_TEXT_PUTS(ctx, outbuf, "<NULL/>");
break;
case GRN_CONTENT_MSGPACK :
#ifdef HAVE_MESSAGE_PACK
msgpack_pack_nil(&ctx->impl->msgpacker);
#endif
break;
case GRN_CONTENT_NONE:
break;
}
INCR_LENGTH;
} else {
grn_output_str(ctx, outbuf, output_type, value, value_len);
}
}
void
grn_output_str(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
const char *value, size_t value_len)
{
put_delimiter(ctx, outbuf, output_type);
switch (output_type) {
case GRN_CONTENT_JSON:
grn_text_esc(ctx, outbuf, value, value_len);
break;
case GRN_CONTENT_TSV:
grn_text_esc(ctx, outbuf, value, value_len);
break;
case GRN_CONTENT_XML:
GRN_TEXT_PUTS(ctx, outbuf, "<TEXT>");
grn_text_escape_xml(ctx, outbuf, value, value_len);
GRN_TEXT_PUTS(ctx, outbuf, "</TEXT>");
break;
case GRN_CONTENT_MSGPACK :
#ifdef HAVE_MESSAGE_PACK
msgpack_pack_raw(&ctx->impl->msgpacker, value_len);
msgpack_pack_raw_body(&ctx->impl->msgpacker, value, value_len);
#endif
break;
case GRN_CONTENT_NONE:
break;
}
INCR_LENGTH;
}
void
grn_output_float(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type, double value)
{
put_delimiter(ctx, outbuf, output_type);
switch (output_type) {
case GRN_CONTENT_JSON:
grn_text_ftoa(ctx, outbuf, value);
break;
case GRN_CONTENT_TSV:
grn_text_ftoa(ctx, outbuf, value);
break;
case GRN_CONTENT_XML:
GRN_TEXT_PUTS(ctx, outbuf, "<FLOAT>");
grn_text_ftoa(ctx, outbuf, value);
GRN_TEXT_PUTS(ctx, outbuf, "</FLOAT>");
break;
case GRN_CONTENT_MSGPACK :
#ifdef HAVE_MESSAGE_PACK
msgpack_pack_double(&ctx->impl->msgpacker, value);
#endif
break;
case GRN_CONTENT_NONE:
break;
}
INCR_LENGTH;
}
void
grn_output_map_close(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type)
{
switch (output_type) {
case GRN_CONTENT_JSON:
GRN_TEXT_PUTS(ctx, outbuf, "}");
break;
case GRN_CONTENT_TSV:
if (DEPTH > 3) {
if (CURR_LEVEL >= 2) { GRN_TEXT_PUTC(ctx, outbuf, '\t'); }
GRN_TEXT_PUTC(ctx, outbuf, '}');
}
break;
case GRN_CONTENT_XML:
{
const char *name;
unsigned int name_len = grn_vector_pop_element(ctx, &ctx->impl->names, &name, NULL, NULL);
GRN_TEXT_PUTS(ctx, outbuf, "</");
GRN_TEXT_PUT(ctx, outbuf, name, name_len);
GRN_TEXT_PUTC(ctx, outbuf, '>');
}
break;
case GRN_CONTENT_MSGPACK :
// do nothing
break;
case GRN_CONTENT_NONE:
break;
}
DECR_DEPTH;
INCR_LENGTH;
}
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;
}
}
static grn_rc
grn_ja_inspect(grn_ctx *ctx, grn_obj *buf, grn_obj *obj)
{
GRN_TEXT_PUTS(ctx, buf, "#<column:var_size ");
grn_store_inspect_body(ctx, buf, obj);
GRN_TEXT_PUTS(ctx, buf, ">");
return GRN_SUCCESS;
}
static void
parse_synonyms_file_line(grn_ctx *ctx, const char *line, size_t line_length,
grn_obj *key, grn_obj *value)
{
size_t i = 0;
if (is_comment_mark(line[i])) {
return;
}
while (i < line_length) {
char character = line[i];
i++;
if (character == '\t') {
break;
}
GRN_TEXT_PUTC(ctx, key, character);
}
if (i == line_length) {
return;
}
GRN_TEXT_PUTS(ctx, value, "((");
while (i < line_length) {
char character = line[i];
i++;
if (character == '\t') {
GRN_TEXT_PUTS(ctx, value, ") OR (");
} else {
GRN_TEXT_PUTC(ctx, value, character);
}
}
GRN_TEXT_PUTS(ctx, value, "))");
{
grn_id id;
void *value_location = NULL;
id = grn_hash_add(ctx, synonyms, GRN_TEXT_VALUE(key), GRN_TEXT_LEN(key),
&value_location, NULL);
if (id == GRN_ID_NIL) {
GRN_PLUGIN_LOG(ctx, GRN_LOG_WARNING,
"[plugin][query-expander][tsv] "
"failed to register key: <%.*s>",
(int)GRN_TEXT_LEN(key), GRN_TEXT_VALUE(key));
return;
}
if (GRN_TEXT_LEN(value) <= MAX_SYNONYM_BYTES - 1) {
GRN_TEXT_PUTC(ctx, value, '\0');
} else {
grn_bulk_truncate(ctx, value, MAX_SYNONYM_BYTES - 1);
GRN_TEXT_PUTC(ctx, value, '\0');
}
grn_memcpy(value_location, GRN_TEXT_VALUE(value), GRN_TEXT_LEN(value));
}
}
static grn_rc
grn_table_inspect(grn_ctx *ctx, grn_obj *buf, grn_obj *obj)
{
grn_hash *cols;
grn_id range_id;
grn_obj *range;
GRN_TEXT_PUTS(ctx, buf, "#<table:");
grn_table_type_inspect(ctx, buf, obj);
GRN_TEXT_PUTS(ctx, buf, " ");
grn_inspect_name(ctx, buf, obj);
if (obj->header.type != GRN_TABLE_NO_KEY) {
grn_obj *domain;
grn_id domain_id;
GRN_TEXT_PUTS(ctx, buf, " key:");
domain_id = obj->header.domain;
domain = grn_ctx_at(ctx, domain_id);
if (domain) {
grn_inspect_name(ctx, buf, domain);
grn_obj_unlink(ctx, domain);
} else if (domain_id) {
grn_text_lltoa(ctx, buf, domain_id);
} else {
GRN_TEXT_PUTS(ctx, buf, "(nil)");
}
}
GRN_TEXT_PUTS(ctx, buf, " value:");
range_id = grn_obj_get_range(ctx, obj);
range = grn_ctx_at(ctx, range_id);
if (range) {
grn_inspect_name(ctx, buf, range);
} else if (range_id) {
grn_text_lltoa(ctx, buf, range_id);
} else {
GRN_TEXT_PUTS(ctx, buf, "(nil)");
}
GRN_TEXT_PUTS(ctx, buf, " size:");
grn_text_lltoa(ctx, buf, grn_table_size(ctx, obj));
GRN_TEXT_PUTS(ctx, buf, " columns:[");
if ((cols = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
GRN_OBJ_TABLE_HASH_KEY|GRN_HASH_TINY))) {
if (grn_table_columns(ctx, obj, "", 0, (grn_obj *)cols)) {
int i = 0;
grn_id *key;
GRN_HASH_EACH(ctx, cols, id, &key, NULL, NULL, {
grn_obj *col = grn_ctx_at(ctx, *key);
if (col) {
if (i++ > 0) { GRN_TEXT_PUTS(ctx, buf, ", "); }
grn_column_name_(ctx, col, buf);
grn_obj_unlink(ctx, col);
}
});
}
static ngx_int_t
ngx_http_groonga_handler_process_body(ngx_http_request_t *r,
ngx_http_groonga_handler_data_t *data)
{
ngx_int_t rc;
grn_ctx *context;
ngx_buf_t *body;
u_char *body_data;
u_char *body_data_end;
context = &(data->context);
body = r->request_body->bufs->buf;
if (!body) {
ngx_http_groonga_handler_set_content_type(r, "text/plain");
GRN_TEXT_PUTS(context, &(data->body), "must send load data as body");
return NGX_HTTP_BAD_REQUEST;
}
rc = ngx_http_groonga_join_request_body_chain(r,
r->request_body->bufs,
&body_data,
&body_data_end);
if (rc != NGX_OK) {
return rc;
}
rc = ngx_http_groonga_send_lines(context, r, body_data, body_data_end);
ngx_pfree(r->pool, body_data);
return rc;
}
static grn_obj *
proc_table_create(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_obj *buf = args[0];
grn_expr_var *vars;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
if (nvars == 6) {
grn_obj *table;
grn_obj_flags flags = grn_atoi(GRN_TEXT_VALUE(&vars[1].value),
GRN_BULK_CURR(&vars[1].value), NULL);
if (GRN_TEXT_LEN(&vars[0].value)) {
flags |= GRN_OBJ_PERSISTENT;
}
table = grn_table_create(ctx,
GRN_TEXT_VALUE(&vars[0].value),
GRN_TEXT_LEN(&vars[0].value),
NULL, flags,
grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[2].value),
GRN_TEXT_LEN(&vars[2].value)),
grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[3].value),
GRN_TEXT_LEN(&vars[3].value)));
if (table) {
grn_obj_set_info(ctx, table,
GRN_INFO_DEFAULT_TOKENIZER,
grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[4].value),
GRN_TEXT_LEN(&vars[4].value)));
grn_obj_unlink(ctx, table);
}
GRN_TEXT_PUTS(ctx, buf, ctx->rc ? "false" : "true");
}
return buf;
}
void ConditionConverter::convert_between(const Item_func *func_item,
grn_obj *expression) {
MRN_DBUG_ENTER_METHOD();
Item **arguments = func_item->arguments();
Item *target_item = arguments[0];
Item *min_item = arguments[1];
Item *max_item = arguments[2];
grn_obj *between_func = grn_ctx_get(ctx_, "between", strlen("between"));
grn_expr_append_obj(ctx_, expression, between_func, GRN_OP_PUSH, 1);
const Item_field *field_item = static_cast<const Item_field *>(target_item);
append_field_value(field_item, expression);
grn_obj include;
mrn::SmartGrnObj smart_include(ctx_, &include);
GRN_TEXT_INIT(&include, 0);
GRN_TEXT_PUTS(ctx_, &include, "include");
append_const_item(field_item, min_item, expression);
grn_expr_append_const(ctx_, expression, &include, GRN_OP_PUSH, 1);
append_const_item(field_item, max_item, expression);
grn_expr_append_const(ctx_, expression, &include, GRN_OP_PUSH, 1);
grn_expr_append_op(ctx_, expression, GRN_OP_CALL, 5);
grn_expr_append_op(ctx_, expression, GRN_OP_AND, 2);
DBUG_VOID_RETURN;
}
grn_obj *
grn_inspect_query_log_flags(grn_ctx *ctx, grn_obj *buffer, unsigned int flags)
{
grn_bool have_content = GRN_FALSE;
if (flags == GRN_QUERY_LOG_NONE) {
GRN_TEXT_PUTS(ctx, buffer, "NONE");
return buffer;
}
#define CHECK_FLAG(NAME) do { \
if (flags & GRN_QUERY_LOG_ ## NAME) { \
if (have_content) { \
GRN_TEXT_PUTS(ctx, buffer, "|"); \
} \
GRN_TEXT_PUTS(ctx, buffer, #NAME); \
have_content = GRN_TRUE; \
} \
} while (GRN_FALSE)
CHECK_FLAG(COMMAND);
CHECK_FLAG(RESULT_CODE);
CHECK_FLAG(DESTINATION);
CHECK_FLAG(CACHE);
CHECK_FLAG(SIZE);
CHECK_FLAG(SCORE);
#undef CHECK_FALG
return buffer;
}
static grn_bool
chunked_tokenize_utf8_chunk(grn_ctx *ctx,
grn_mecab_tokenizer *tokenizer,
const char *chunk,
unsigned int chunk_bytes)
{
const char *tokenized_chunk;
size_t tokenized_chunk_length;
tokenized_chunk = mecab_sparse_tostr2(tokenizer->mecab, chunk, chunk_bytes);
if (!tokenized_chunk) {
GRN_PLUGIN_ERROR(ctx, GRN_TOKENIZER_ERROR,
"[tokenizer][mecab][chunk] "
"mecab_sparse_tostr2() failed len=%d err=%s",
chunk_bytes,
mecab_strerror(tokenizer->mecab));
return GRN_FALSE;
}
if (GRN_TEXT_LEN(&(tokenizer->buf)) > 0) {
GRN_TEXT_PUTS(ctx, &(tokenizer->buf), " ");
}
tokenized_chunk_length = strlen(tokenized_chunk);
if (tokenized_chunk_length >= 1 &&
isspace(tokenized_chunk[tokenized_chunk_length - 1])) {
GRN_TEXT_PUT(ctx, &(tokenizer->buf),
tokenized_chunk, tokenized_chunk_length - 1);
} else {
GRN_TEXT_PUT(ctx, &(tokenizer->buf),
tokenized_chunk, tokenized_chunk_length);
}
return GRN_TRUE;
}
static grn_obj *
func_query_expander_tsv(grn_ctx *ctx, int nargs, grn_obj **args,
grn_user_data *user_data)
{
grn_rc rc = GRN_END_OF_DATA;
grn_id id;
grn_obj *term, *expanded_term;
void *value;
grn_obj *rc_object;
term = args[0];
expanded_term = args[1];
id = grn_hash_get(ctx, synonyms,
GRN_TEXT_VALUE(term), GRN_TEXT_LEN(term),
&value);
if (id != GRN_ID_NIL) {
const char *query = value;
GRN_TEXT_PUTS(ctx, expanded_term, query);
rc = GRN_SUCCESS;
}
rc_object = grn_plugin_proc_alloc(ctx, user_data, GRN_DB_INT32, 0);
if (rc_object) {
GRN_INT32_SET(ctx, rc_object, rc);
}
return rc_object;
}
static grn_obj *
proc_column_list(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_obj *buf = args[0];
grn_expr_var *vars;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
if (nvars == 2) {
grn_obj *table;
grn_content_type otype = GET_OTYPE(&vars[1].value);
if ((table = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[0].value),
GRN_TEXT_LEN(&vars[0].value)))) {
grn_hash *cols;
if ((cols = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
GRN_OBJ_TABLE_HASH_KEY|GRN_HASH_TINY))) {
if (grn_table_columns(ctx, table, NULL, 0, (grn_obj *)cols) >= 0) {
grn_id *key;
char line_delimiter, column_delimiter;
switch (otype) {
case GRN_CONTENT_TSV:
line_delimiter = '\n';
column_delimiter = '\t';
GRN_TEXT_PUTS(ctx, buf, "id\tname\tpath\ttype\tflags\tdomain");
break;
case GRN_CONTENT_JSON:
line_delimiter = ',';
column_delimiter = ',';
GRN_TEXT_PUTS(ctx, buf, "[[\"id\",\"name\",\"path\",\"type\",\"flags\",\"domain\"]");
break;
}
GRN_HASH_EACH(ctx, cols, id, &key, NULL, NULL, {
grn_obj *col;
if ((col = grn_ctx_at(ctx, *key))) {
GRN_TEXT_PUTC(ctx, buf, line_delimiter);
if (!print_columninfo(ctx, col, buf, otype)) {
grn_bulk_truncate(ctx, buf, GRN_BULK_VSIZE(buf) - 1);
}
grn_obj_unlink(ctx, col);
}
});
if (otype == GRN_CONTENT_JSON) {
GRN_TEXT_PUTC(ctx, buf, ']');
}
}
void
test_expression_lifetime_over_database(void)
{
const gchar *path;
gint i, n_tries = 100;
grn_obj *expression;
cut_omit("will be SEGVed.");
path = cut_build_path(tmp_directory, "database.groonga", NULL);
for (i = 0; i < n_tries; i++) {
gint j, n_records = 100;
const gchar *query;
grn_obj *table, *variable;
grn_obj default_column;
database = grn_db_create(context, path, NULL);
grn_test_assert_context(context);
assert_send_command("table_create Sites 0 ShortText");
assert_send_command("column_create Sites point COLUMN_SCALAR Int32");
for (j = 0; j < n_records; j++) {
gchar *command;
command = g_strdup_printf("load '"
"[[\"_key\", \"point\"],"
"[\"http://groonga.org/version/%d\",%d]]' "
"Sites",
j, j);
assert_send_command(command);
g_free(command);
}
table = get_object("Sites");
GRN_EXPR_CREATE_FOR_QUERY(context, table, expression, variable);
grn_obj_unlink(context, table);
GRN_TEXT_INIT(&default_column, 0);
GRN_TEXT_PUTS(context, &default_column, "point");
query = "point:50";
grn_expr_parse(context, expression,
query, strlen(query),
&default_column,
GRN_OP_MATCH, GRN_OP_AND,
GRN_EXPR_SYNTAX_QUERY | GRN_EXPR_ALLOW_COLUMN);
grn_test_assert_context(context);
grn_obj_unlink(context, &default_column);
grn_expr_compile(context, expression);
grn_obj_remove(context, database);
database = NULL;
remove_tmp_directory();
g_mkdir_with_parents(tmp_directory, 0700);
}
grn_ctx_fin(context);
g_free(context);
context = NULL;
}
grn_rc
grn_dump_column_create_flags(grn_ctx *ctx,
grn_obj_flags flags,
grn_obj *buffer)
{
GRN_API_ENTER;
switch (flags & GRN_OBJ_COLUMN_TYPE_MASK) {
case GRN_OBJ_COLUMN_SCALAR:
GRN_TEXT_PUTS(ctx, buffer, "COLUMN_SCALAR");
break;
case GRN_OBJ_COLUMN_VECTOR:
GRN_TEXT_PUTS(ctx, buffer, "COLUMN_VECTOR");
if (flags & GRN_OBJ_WITH_WEIGHT) {
GRN_TEXT_PUTS(ctx, buffer, "|WITH_WEIGHT");
}
break;
case GRN_OBJ_COLUMN_INDEX:
GRN_TEXT_PUTS(ctx, buffer, "COLUMN_INDEX");
if (flags & GRN_OBJ_WITH_SECTION) {
GRN_TEXT_PUTS(ctx, buffer, "|WITH_SECTION");
}
if (flags & GRN_OBJ_WITH_WEIGHT) {
GRN_TEXT_PUTS(ctx, buffer, "|WITH_WEIGHT");
}
if (flags & GRN_OBJ_WITH_POSITION) {
GRN_TEXT_PUTS(ctx, buffer, "|WITH_POSITION");
}
break;
}
switch (flags & GRN_OBJ_COMPRESS_MASK) {
case GRN_OBJ_COMPRESS_NONE:
break;
case GRN_OBJ_COMPRESS_ZLIB:
GRN_TEXT_PUTS(ctx, buffer, "|COMPRESS_ZLIB");
break;
case GRN_OBJ_COMPRESS_LZ4:
GRN_TEXT_PUTS(ctx, buffer, "|COMPRESS_LZ4");
break;
}
if (flags & GRN_OBJ_PERSISTENT) {
GRN_TEXT_PUTS(ctx, buffer, "|PERSISTENT");
}
GRN_API_RETURN(ctx->rc);
}
static void
set_text(const gchar *text)
{
grn_obj_reinit(&context, &src, GRN_DB_TEXT, 0);
if (text) {
GRN_TEXT_PUTS(&context, &src, text);
}
}
static grn_rc
grn_table_type_inspect(grn_ctx *ctx, grn_obj *buf, grn_obj *obj)
{
switch (obj->header.type) {
case GRN_TABLE_HASH_KEY:
GRN_TEXT_PUTS(ctx, buf, "hash");
break;
case GRN_TABLE_PAT_KEY:
GRN_TEXT_PUTS(ctx, buf, "pat");
break;
case GRN_TABLE_NO_KEY:
GRN_TEXT_PUTS(ctx, buf, "no_key");
break;
}
return GRN_SUCCESS;
}
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;
}
int
ql_get(void)
{
int i, key;
grn_obj buf;
GRN_TEXT_INIT(&buf, 0);
for (i = 0; i < nloops; i++) {
key = GENKEY(i);
GRN_BULK_REWIND(&buf);
GRN_TEXT_PUTS(&ctx, &buf, "(<t1> : \"");
grn_text_itoh(&ctx, &buf, key, key_size);
GRN_TEXT_PUTS(&ctx, &buf, "\").c1");
GRN_TEXT_PUTC(&ctx, &buf, '\0');
EVAL(&ctx, GRN_BULK_HEAD(&buf));
}
grn_obj_close(&ctx, &buf);
return 0;
}
static grn_obj *
text_geo_point_open(double latitude, double longitude)
{
grn_obj *point;
point = grn_obj_open(context, GRN_BULK, 0, GRN_DB_SHORT_TEXT);
GRN_TEXT_PUTS(context, point, cut_take_printf("%f,%f", latitude, longitude));
return point;
}
