static ngx_int_t
ngx_http_groonga_send_lines(grn_ctx *context,
ngx_http_request_t *r,
u_char *current,
u_char *last)
{
ngx_int_t rc;
u_char *line_start;
for (line_start = current; current < last; current++) {
if (*current != '\n') {
continue;
}
grn_ctx_send(context, (const char *)line_start, current - line_start,
GRN_NO_FLAGS);
rc = ngx_http_groonga_context_check_error(r->connection->log, context);
if (rc != NGX_OK) {
return rc;
}
line_start = current + 1;
}
if (line_start < current) {
grn_ctx_send(context, (const char *)line_start, current - line_start,
GRN_NO_FLAGS);
rc = ngx_http_groonga_context_check_error(r->connection->log, context);
if (rc != NGX_OK) {
return rc;
}
}
return NGX_OK;
}
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;
}
}
const gchar *
grn_test_send_command(grn_ctx *context, const gchar *command)
{
unsigned int send_id, receive_id;
GString *result;
const gchar **lines;
result = g_string_new(NULL);
lines = cut_take_string_array(g_strsplit(command, "\n", 0));
for (; *lines; lines++) {
gchar *command_result;
unsigned int command_result_length;
int flags = 0;
send_id = grn_ctx_send(context, *lines, strlen(*lines), 0);
receive_id = grn_ctx_recv(context, &command_result, &command_result_length,
&flags);
cut_assert_equal_uint(send_id, receive_id);
g_string_append_len(result, command_result, command_result_length);
grn_test_assert_context(context,
cut_message("<%s>:<%s>", command, result->str));
}
return cut_take_strdup(g_string_free(result, FALSE));
}
static void
load_from_learner(msgpack_object *o, grn_ctx *ctx, grn_obj *cmd_buf)
{
if (o->type == MSGPACK_OBJECT_MAP && o->via.map.size) {
msgpack_object_kv *kv;
kv = &(o->via.map.ptr[0]);
if (kv->key.type == MSGPACK_OBJECT_RAW && kv->key.via.raw.size == 6 &&
!memcmp(kv->key.via.raw.ptr, CONST_STR_LEN("target"))) {
if (kv->val.type == MSGPACK_OBJECT_RAW) {
int i;
GRN_BULK_REWIND(cmd_buf);
GRN_TEXT_PUTS(ctx, cmd_buf, "load --table ");
GRN_TEXT_PUT(ctx, cmd_buf, kv->val.via.raw.ptr, kv->val.via.raw.size);
grn_ctx_send(ctx, GRN_TEXT_VALUE(cmd_buf), GRN_TEXT_LEN(cmd_buf), GRN_CTX_MORE);
grn_ctx_send(ctx, CONST_STR_LEN("["), GRN_CTX_MORE);
if (kv->val.via.raw.size > 5) {
if (!memcmp(kv->val.via.raw.ptr, CONST_STR_LEN("item_")) ||
!memcmp(kv->val.via.raw.ptr, CONST_STR_LEN("pair_"))) {
char delim = '{';
GRN_BULK_REWIND(cmd_buf);
for (i = 1; i < o->via.map.size; i++) {
GRN_TEXT_PUTC(ctx, cmd_buf, delim);
kv = &(o->via.map.ptr[i]);
msgpack2json(&(kv->key), ctx, cmd_buf);
GRN_TEXT_PUTC(ctx, cmd_buf, ':');
msgpack2json(&(kv->val), ctx, cmd_buf);
delim = ',';
}
GRN_TEXT_PUTC(ctx, cmd_buf, '}');
/* printf("msg: %.*s\n", GRN_TEXT_LEN(cmd_buf), GRN_TEXT_VALUE(cmd_buf)); */
grn_ctx_send(ctx, GRN_TEXT_VALUE(cmd_buf), GRN_TEXT_LEN(cmd_buf), GRN_CTX_MORE);
}
}
grn_ctx_send(ctx, CONST_STR_LEN("]"), 0);
{
char *res;
int flags;
unsigned int res_len;
grn_ctx_recv(ctx, &res, &res_len, &flags);
}
}
}
}
}
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 *line_start, *current;
context = &(data->context);
body = r->request_body->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;
}
for (line_start = current = body->pos; current < body->last; current++) {
if (*current != '\n') {
continue;
}
grn_ctx_send(context, (const char *)line_start, current - line_start,
GRN_NO_FLAGS);
rc = ngx_http_groonga_context_check_error(r->connection->log, context);
if (rc != NGX_OK) {
return rc;
}
line_start = current + 1;
}
if (line_start < current) {
grn_ctx_send(context, (const char *)line_start, current - line_start,
GRN_NO_FLAGS);
rc = ngx_http_groonga_context_check_error(r->connection->log, context);
if (rc != NGX_OK) {
return rc;
}
}
return NGX_OK;
}
void
test_nonexistent_table(void)
{
const gchar *command = "select nonexistent";
grn_ctx_send(context, command, strlen(command), 0);
grn_test_assert_error(GRN_INVALID_ARGUMENT,
"invalid table name: <nonexistent>",
context);
}
static void
run_command(grn_ctx *context, const gchar *command)
{
gchar *response;
unsigned int response_length;
int flags;
grn_ctx_send(context, command, strlen(command), 0);
grn_ctx_recv(context, &response, &response_length, &flags);
}
MRN_API char *mroonga_command(UDF_INIT *initid, UDF_ARGS *args, char *result,
unsigned long *length, char *is_null, char *error)
{
CommandInfo *info = (CommandInfo *)initid->ptr;
grn_ctx *ctx = &(info->ctx);
char *command;
unsigned int command_length;
int flags = 0;
if (!args->args[0]) {
*is_null = 1;
return NULL;
}
*is_null = 0;
command = args->args[0];
command_length = args->lengths[0];
grn_ctx_send(ctx, command, command_length, 0);
if (ctx->rc) {
my_message(ER_ERROR_ON_WRITE, ctx->errbuf, MYF(0));
goto error;
}
info->result.length(0);
do {
char *buffer;
unsigned int buffer_length;
grn_ctx_recv(ctx, &buffer, &buffer_length, &flags);
if (ctx->rc) {
my_message(ER_ERROR_ON_READ, ctx->errbuf, MYF(0));
goto error;
}
if (buffer_length > 0) {
if (info->result.reserve(buffer_length)) {
my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
goto error;
}
info->result.q_append(buffer, buffer_length);
}
} while (flags & GRN_CTX_MORE);
*length = info->result.length();
return (char *)(info->result.ptr());
error:
*error = 1;
return NULL;
}
static ngx_int_t
ngx_http_groonga_handler_process_command_path(ngx_http_request_t *r,
ngx_str_t *command_path,
ngx_http_groonga_handler_data_t *data)
{
grn_obj uri;
GRN_TEXT_INIT(&uri, 0);
GRN_TEXT_PUTS(context, &uri, "/d/");
GRN_TEXT_PUT(context, &uri, command_path->data, command_path->len);
grn_ctx_send(context, GRN_TEXT_VALUE(&uri), GRN_TEXT_LEN(&uri),
GRN_NO_FLAGS);
ngx_http_groonga_context_log_error(r->connection->log);
GRN_OBJ_FIN(context, &uri);
return NGX_OK;
}
/*
* call-seq:
* context.send(string) -> ID
*
* groongaサーバにクエリ文字列を送信する。
*/
static VALUE
rb_grn_context_send (VALUE self, VALUE rb_string)
{
grn_ctx *context;
char *string;
unsigned int string_size;
int flags = 0;
unsigned int query_id;
context = SELF(self);
string = StringValuePtr(rb_string);
string_size = RSTRING_LEN(rb_string);
query_id = grn_ctx_send(context, string, string_size, flags);
rb_grn_context_check(context, self);
return UINT2NUM(query_id);
}
void
grn_test_assert_send_command_error_helper (grn_ctx *context,
grn_rc expected_rc,
const gchar *expected_message,
const gchar *command,
const gchar *expected_rc_expression,
const gchar *expected_message_expression,
const gchar *command_expression)
{
const gchar **lines;
lines = cut_take_string_array(g_strsplit(command, "\n", 0));
for (; *lines; lines++) {
grn_ctx_send(context, *lines, strlen(*lines), 0);
if (context->rc) {
break;
}
}
if (context->rc == expected_rc &&
cut_equal_string(expected_message, context->errbuf)) {
gchar *command_result;
unsigned int command_result_length;
int flags = 0;
cut_test_pass();
grn_ctx_recv(context, &command_result, &command_result_length, &flags);
} else {
cut_set_expected(cut_take_printf("<%s>(%s)",
expected_message,
grn_rc_to_string(expected_rc)));
cut_set_actual(cut_take_printf("<%s>(%s)",
context->errbuf,
grn_rc_to_string(context->rc)));
cut_test_fail(cut_take_printf("<send(\"%s\")>\n"
"%s:%d: %s():",
command_expression,
context->errfile, context->errline,
context->errfunc));
}
}
static void
send_command(grn_ctx *ctx, grn_obj *buffer, const char *command,
const char *dataset_name)
{
const char *p = command;
const char *dataset_place_holder = "${DATASET}";
char *dataset_place_holder_position;
if (ctx->rc != GRN_SUCCESS) {
return;
}
GRN_BULK_REWIND(buffer);
while ((dataset_place_holder_position = strstr(p, dataset_place_holder))) {
GRN_TEXT_PUT(ctx, buffer, p, dataset_place_holder_position - p);
GRN_TEXT_PUTS(ctx, buffer, dataset_name);
p = dataset_place_holder_position + strlen(dataset_place_holder);
}
GRN_TEXT_PUTS(ctx, buffer, p);
printf("> %.*s\n", (int)GRN_TEXT_LEN(buffer), GRN_TEXT_VALUE(buffer));
grn_ctx_send(ctx, GRN_TEXT_VALUE(buffer), GRN_TEXT_LEN(buffer), 0);
output(ctx);
}
