/*
* テーブルの _id_ に対応する主キーを返す。
*
* @overload key(id)
* @return [主キー]
*/
static VALUE
rb_grn_table_key_support_get_key (VALUE self, VALUE rb_id)
{
grn_ctx *context;
grn_obj *table, *key;
grn_id id;
int key_size;
VALUE rb_key;
rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
&key, NULL, NULL,
NULL, NULL, NULL,
NULL);
id = NUM2UINT(rb_id);
GRN_BULK_REWIND(key);
key_size = grn_table_get_key(context, table, id,
GRN_BULK_HEAD(key), GRN_BULK_VSIZE(key));
if (key_size == 0)
return Qnil;
if (GRN_BULK_VSIZE(key) < key_size) {
grn_bulk_reserve(context, key, key_size);
grn_table_get_key(context, table, id, GRN_BULK_HEAD(key), key_size);
}
rb_key = GRNKEY2RVAL(context, GRN_BULK_HEAD(key), key_size, table, self);
return rb_key;
}
static void
load_synonyms(grn_ctx *ctx)
{
static char path_env[GRN_ENV_BUFFER_SIZE];
const char *path;
grn_file_reader *file_reader;
int number_of_lines;
grn_encoding encoding;
grn_obj line, key, value;
grn_getenv("GRN_QUERY_EXPANDER_TSV_SYNONYMS_FILE",
path_env,
GRN_ENV_BUFFER_SIZE);
if (path_env[0]) {
path = path_env;
} else {
path = get_system_synonyms_file();
}
file_reader = grn_file_reader_open(ctx, path);
if (!file_reader) {
GRN_LOG(ctx, GRN_LOG_WARNING,
"[plugin][query-expander][tsv] "
"synonyms file doesn't exist: <%s>",
path);
return;
}
GRN_TEXT_INIT(&line, 0);
GRN_TEXT_INIT(&key, 0);
GRN_TEXT_INIT(&value, 0);
grn_bulk_reserve(ctx, &value, MAX_SYNONYM_BYTES);
number_of_lines = 0;
while (grn_file_reader_read_line(ctx, file_reader, &line) == GRN_SUCCESS) {
const char *line_value = GRN_TEXT_VALUE(&line);
size_t line_length = GRN_TEXT_LEN(&line);
if (line_length > 0 && line_value[line_length - 1] == '\n') {
if (line_length > 1 && line_value[line_length - 2] == '\r') {
line_length -= 2;
} else {
line_length -= 1;
}
}
number_of_lines++;
if (number_of_lines == 1) {
encoding = guess_encoding(ctx, &line_value, &line_length);
}
GRN_BULK_REWIND(&key);
GRN_BULK_REWIND(&value);
parse_synonyms_file_line(ctx, line_value, line_length, &key, &value);
GRN_BULK_REWIND(&line);
}
GRN_OBJ_FIN(ctx, &line);
GRN_OBJ_FIN(ctx, &key);
GRN_OBJ_FIN(ctx, &value);
grn_file_reader_close(ctx, file_reader);
}
void Buffers::resize(size_t n) {
if (n_ != n) {
for (size_t i = 0; i < n_; ++i) {
grn_obj *buffer = (*this)[i];
GRN_OBJ_FIN(ctx_, buffer);
}
grn_bulk_reserve(ctx_, &buffers_, sizeof(grn_obj) * n);
n_ = n;
for (size_t i = 0; i < n_; ++i) {
grn_obj *buffer = (*this)[i];
GRN_TEXT_INIT(buffer, 0);
}
}
}
MRN_API char *mroonga_snippet_html(UDF_INIT *init,
UDF_ARGS *args,
char *result,
unsigned long *length,
char *is_null,
char *error)
{
MRN_DBUG_ENTER_FUNCTION();
mrn_snippet_html_info *info =
reinterpret_cast<mrn_snippet_html_info *>(init->ptr);
grn_ctx *ctx = info->ctx;
grn_obj *snippet = info->snippet;
grn_obj *result_buffer = &(info->result);
if (!args->args[0]) {
*is_null = 1;
DBUG_RETURN(NULL);
}
if (!snippet) {
if (mrn_snippet_html_prepare(info, args, NULL, &snippet)) {
goto error;
}
}
{
char *target = args->args[0];
unsigned int target_length = args->lengths[0];
unsigned int n_results, max_tagged_length;
{
grn_rc rc = grn_snip_exec(ctx, snippet, target, target_length,
&n_results, &max_tagged_length);
if (rc != GRN_SUCCESS) {
my_printf_error(ER_MRN_ERROR_FROM_GROONGA_NUM,
ER_MRN_ERROR_FROM_GROONGA_STR, MYF(0), ctx->errbuf);
goto error;
}
}
*is_null = 0;
GRN_BULK_REWIND(result_buffer);
{
const char *start_tag = "<div class=\"snippet\">";
const char *end_tag = "</div>";
size_t start_tag_length = strlen(start_tag);
size_t end_tag_length = strlen(end_tag);
for (unsigned int i = 0; i < n_results; ++i) {
GRN_TEXT_PUT(ctx, result_buffer, start_tag, start_tag_length);
grn_bulk_reserve(ctx, result_buffer, max_tagged_length);
unsigned int result_length;
grn_rc rc =
grn_snip_get_result(ctx, snippet, i,
GRN_BULK_CURR(result_buffer),
&result_length);
if (rc) {
my_printf_error(ER_MRN_ERROR_FROM_GROONGA_NUM,
ER_MRN_ERROR_FROM_GROONGA_STR, MYF(0), ctx->errbuf);
goto error;
}
grn_bulk_space(ctx, result_buffer, result_length);
GRN_TEXT_PUT(ctx, result_buffer, end_tag, end_tag_length);
}
}
if (!info->snippet) {
grn_rc rc = grn_obj_close(ctx, snippet);
if (rc != GRN_SUCCESS) {
my_printf_error(ER_MRN_ERROR_FROM_GROONGA_NUM,
ER_MRN_ERROR_FROM_GROONGA_STR, MYF(0), ctx->errbuf);
goto error;
}
}
}
*length = GRN_TEXT_LEN(result_buffer);
DBUG_RETURN(GRN_TEXT_VALUE(result_buffer));
error:
if (!info->snippet && snippet) {
grn_obj_close(ctx, snippet);
}
*is_null = 1;
*error = 1;
DBUG_RETURN(NULL);
}
static int
do_client()
{
int rc = -1;
grn_obj text;
grn_thread thread;
struct timeval tvb, tve;
grn_com_header sheader;
grn_ctx ctx_, *ctx = &ctx_;
grn_ctx_init(ctx, 0);
GRN_COM_QUEUE_INIT(&fsessions);
sessions = grn_hash_create(ctx, NULL, sizeof(grn_sock), sizeof(session), 0);
sheader.proto = GRN_COM_PROTO_GQTP;
sheader.qtype = 0;
sheader.keylen = 0;
sheader.level = 0;
sheader.flags = 0;
sheader.status = 0;
sheader.opaque = 0;
sheader.cas = 0;
GRN_TEXT_INIT(&text, 0);
rc = grn_bulk_reserve(ctx, &text, BUFSIZE);
if (!rc) {
char *buf = GRN_TEXT_VALUE(&text);
if (!grn_com_event_init(ctx, &ev, 1000, sizeof(grn_com))) {
ev.msg_handler = msg_handler;
if (!THREAD_CREATE(thread, receiver, NULL)) {
int cnt = 0;
gettimeofday(&tvb, NULL);
lprint(ctx, "begin: procotol=%c max_concurrency=%d max_tp=%d", proto, max_con, max_tp);
while (fgets(buf, BUFSIZE, stdin)) {
uint32_t size = strlen(buf) - 1;
session *s = session_alloc(ctx, dests + (cnt++ % dest_cnt));
if (s) {
gettimeofday(&s->tv, NULL);
s->n_query++;
s->query_id = ++nsent;
s->n_sessions = (nsent - nrecv);
switch (proto) {
case 'H' :
case 'h' :
if (grn_com_send_http(ctx, s->com, buf, size, 0)) {
fprintf(stderr, "grn_com_send_http failed\n");
}
s->stat = 2;
/*
lprint(ctx, "sent %04d %04d %d",
s->n_query, s->query_id, s->com->fd);
*/
break;
default :
if (grn_com_send(ctx, s->com, &sheader, buf, size, 0)) {
fprintf(stderr, "grn_com_send failed\n");
}
break;
}
} else {
fprintf(stderr, "grn_com_copen failed\n");
}
for (;;) {
gettimeofday(&tve, NULL);
if ((nrecv < max_tp * (tve.tv_sec - tvb.tv_sec)) &&
(nsent - nrecv) < max_con) { break; }
/* lprint(ctx, "s:%d r:%d", nsent, nrecv); */
usleep(1000);
}
if (!(nsent % 1000)) { lprint(ctx, " : %d", nsent); }
}
done = 1;
if (THREAD_JOIN(thread)) {
fprintf(stderr, "THREAD_JOIN failed\n");
}
gettimeofday(&tve, NULL);
{
double qps;
uint64_t etime = (tve.tv_sec - tvb.tv_sec);
etime *= 1000000;
etime += (tve.tv_usec - tvb.tv_usec);
qps = (double)nsent * 1000000 / etime;
lprint(ctx, "end : n=%d min=%d max=%d avg=%d qps=%f etime=%d.%06d", nsent, etime_min, etime_max, (int)(etime_amount / nsent), qps, etime / 1000000, etime % 1000000);
}
{
session *s;
GRN_HASH_EACH(ctx, sessions, id, NULL, NULL, &s, {
session_close(ctx, s);
});
}
