void
grn_output_array_close(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type)
{
switch (output_type) {
case GRN_CONTENT_JSON:
GRN_TEXT_PUTC(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 void
put_delimiter(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type)
{
uint32_t level = CURR_LEVEL;
switch (output_type) {
case GRN_CONTENT_JSON:
if (level < 2) { return; }
GRN_TEXT_PUTC(ctx, outbuf, ((level & 3) == 3) ? ':' : ',');
// if (DEPTH == 1 && ((level & 3) != 3)) { GRN_TEXT_PUTC(ctx, outbuf, '\n'); }
break;
case GRN_CONTENT_XML:
if (!DEPTH) { return; }
GRN_TEXT_PUTC(ctx, outbuf, '\n');
break;
case GRN_CONTENT_TSV:
if (level < 2) { return; }
if (DEPTH <= 2) {
GRN_TEXT_PUTC(ctx, outbuf, ((level & 3) == 3) ? '\t' : '\n');
} else {
GRN_TEXT_PUTC(ctx, outbuf, '\t');
}
case GRN_CONTENT_MSGPACK :
// do nothing
break;
case GRN_CONTENT_NONE:
break;
}
}
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 void
msgpack2json(msgpack_object *o, grn_ctx *ctx, grn_obj *buf)
{
switch (o->type) {
case MSGPACK_OBJECT_POSITIVE_INTEGER:
grn_text_ulltoa(ctx, buf, o->via.u64);
break;
case MSGPACK_OBJECT_RAW:
grn_text_esc(ctx, buf, o->via.raw.ptr, o->via.raw.size);
break;
case MSGPACK_OBJECT_ARRAY:
GRN_TEXT_PUTC(ctx, buf, '[');
{
int i;
for (i = 0; i < o->via.array.size; i++) {
msgpack2json(o->via.array.ptr, ctx, buf);
}
}
GRN_TEXT_PUTC(ctx, buf, ']');
break;
case MSGPACK_OBJECT_DOUBLE:
grn_text_ftoa(ctx, buf, o->via.dec);
break;
default:
print_error("cannot handle this msgpack type.");
}
}
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 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 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;
}
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_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;
}
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_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
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);
}
}
}
}
}
/*
* grn_ts_writer_output_body() evaluates expressions and outputs the results.
*/
static grn_rc
grn_ts_writer_output_body(grn_ctx *ctx, grn_ts_writer *writer,
const grn_ts_record *in, size_t n_in)
{
size_t i, j, count = 0;
writer->bufs = GRN_MALLOCN(grn_ts_buf, writer->n_exprs);
if (!writer->bufs) {
GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
"GRN_MALLOCN failed: %" GRN_FMT_SIZE " x %" GRN_FMT_SIZE,
sizeof(grn_ts_buf), writer->n_exprs);
}
for (i = 0; i < writer->n_exprs; i++) {
grn_ts_buf_init(ctx, &writer->bufs[i]);
}
while (count < n_in) {
size_t batch_size = GRN_TS_BATCH_SIZE;
if (batch_size > (n_in - count)) {
batch_size = n_in - count;
}
for (i = 0; i < writer->n_exprs; ++i) {
grn_rc rc = grn_ts_expr_evaluate_to_buf(ctx, writer->exprs[i], in + count,
batch_size, &writer->bufs[i]);
if (rc != GRN_SUCCESS) {
return rc;
}
}
for (i = 0; i < batch_size; ++i) {
GRN_OUTPUT_ARRAY_OPEN("HIT", writer->n_exprs);
for (j = 0; j < writer->n_exprs; ++j) {
if (j) {
GRN_TEXT_PUTC(ctx, ctx->impl->output.buf, ',');
}
switch (writer->exprs[j]->data_kind) {
GRN_TS_WRITER_OUTPUT_BODY_CASE(BOOL, bool);
GRN_TS_WRITER_OUTPUT_BODY_CASE(INT, int);
GRN_TS_WRITER_OUTPUT_BODY_CASE(FLOAT, float);
GRN_TS_WRITER_OUTPUT_BODY_CASE(TIME, time);
GRN_TS_WRITER_OUTPUT_BODY_CASE(TEXT, text);
GRN_TS_WRITER_OUTPUT_BODY_CASE(GEO, geo);
GRN_TS_WRITER_OUTPUT_BODY_VECTOR_CASE(BOOL, bool);
GRN_TS_WRITER_OUTPUT_BODY_VECTOR_CASE(INT, int);
GRN_TS_WRITER_OUTPUT_BODY_VECTOR_CASE(FLOAT, float);
GRN_TS_WRITER_OUTPUT_BODY_VECTOR_CASE(TIME, time);
GRN_TS_WRITER_OUTPUT_BODY_VECTOR_CASE(TEXT, text);
GRN_TS_WRITER_OUTPUT_BODY_VECTOR_CASE(GEO, geo);
default: {
break;
}
}
}
GRN_OUTPUT_ARRAY_CLOSE(); /* HITS. */
}
count += batch_size;
}
return GRN_SUCCESS;
}
int
ql_put(void)
{
int i, key;
grn_obj buf;
GRN_TEXT_INIT(&buf, 0);
EVAL(&ctx, "(ptable '<t1>)");
EVAL(&ctx, "(<t1> ::def :c1 <text>)");
EVAL(&ctx, "(<t1> ::load :c1)");
for (i = 0; i < nloops; i++) {
key = GENKEY(i);
GRN_BULK_REWIND(&buf);
grn_text_itoh(&ctx, &buf, key, key_size);
GRN_TEXT_PUTC(&ctx, &buf, '\t');
grn_text_itoh(&ctx, &buf, key, value_size);
GRN_TEXT_PUTC(&ctx, &buf, '\0');
EVAL(&ctx, GRN_BULK_HEAD(&buf));
}
grn_obj_close(&ctx, &buf);
return 0;
}
void
grn_query_logger_put(grn_ctx *ctx, unsigned int flag, const char *mark,
const char *format, ...)
{
char timestamp[TIMESTAMP_BUFFER_SIZE];
char info[INFO_BUFFER_SIZE];
grn_obj *message = &ctx->impl->query_log_buf;
if (!current_query_logger.log) {
return;
}
{
grn_timeval tv;
timestamp[0] = '\0';
grn_timeval_now(ctx, &tv);
grn_timeval2str(ctx, &tv, timestamp, TIMESTAMP_BUFFER_SIZE);
}
if (flag & (GRN_QUERY_LOG_COMMAND | GRN_QUERY_LOG_DESTINATION)) {
grn_snprintf(info, INFO_BUFFER_SIZE, INFO_BUFFER_SIZE,
"%p|%s", ctx, mark);
info[INFO_BUFFER_SIZE - 1] = '\0';
} else {
grn_timeval tv;
uint64_t elapsed_time;
grn_timeval_now(ctx, &tv);
elapsed_time =
(uint64_t)(tv.tv_sec - ctx->impl->tv.tv_sec) * GRN_TIME_NSEC_PER_SEC +
(tv.tv_nsec - ctx->impl->tv.tv_nsec);
grn_snprintf(info, INFO_BUFFER_SIZE, INFO_BUFFER_SIZE,
"%p|%s%015" GRN_FMT_INT64U " ", ctx, mark, elapsed_time);
info[INFO_BUFFER_SIZE - 1] = '\0';
}
{
va_list args;
va_start(args, format);
GRN_BULK_REWIND(message);
grn_text_vprintf(ctx, message, format, args);
va_end(args);
GRN_TEXT_PUTC(ctx, message, '\0');
}
current_query_logger.log(ctx, flag, timestamp, info, GRN_TEXT_VALUE(message),
current_query_logger.user_data);
}
static void
msg_handler(grn_ctx *ctx, grn_obj *msg)
{
uint32_t etime;
struct timeval tv;
grn_msg *m = (grn_msg *)msg;
grn_com *com = ((grn_msg *)msg)->peer;
session *s = com->opaque;
s->stat = 3;
gettimeofday(&tv, NULL);
etime = (tv.tv_sec - s->tv.tv_sec) * 1000000 + (tv.tv_usec - s->tv.tv_usec);
if (etime > etime_max) {
etime_max = etime;
}
if (etime < etime_min) {
etime_min = etime;
}
if (ctx->rc) {
m->header.proto = 0;
}
switch (m->header.proto) {
case GRN_COM_PROTO_GQTP :
if (GRN_BULK_VSIZE(msg) == 2) {
etime_amount += etime;
} else {
if (verbose) {
GRN_TEXT_PUTC(ctx, msg, '\0');
lprint(ctx, "%8d(%4d) %8d : %s", s->query_id, s->n_sessions, etime, GRN_BULK_HEAD(msg));
}
}
if ((m->header.flags & GRN_CTX_TAIL)) {
grn_com_queue_enque(ctx, &fsessions, (grn_com_queue_entry *)s);
nrecv++;
}
break;
case GRN_COM_PROTO_HTTP :
nrecv++;
/* lprint(ctx, "recv: %d, %d", (int)GRN_BULK_VSIZE(msg), nrecv); */
grn_com_close_(ctx, com);
grn_com_queue_enque(ctx, &fsessions, (grn_com_queue_entry *)s);
break;
default :
grn_com_close_(ctx, com);
grn_com_queue_enque(ctx, &fsessions, (grn_com_queue_entry *)s);
break;
}
grn_msg_close(ctx, msg);
}
void
grn_test_assert_expr_helper (grn_ctx *context,
const gchar *inspected,
grn_obj *expr,
const gchar *inspected_expression,
const gchar *expr_expression)
{
grn_obj buffer;
const gchar *actual_inspected;
GRN_TEXT_INIT(&buffer, 0);
grn_expr_inspect(context, &buffer, expr);
GRN_TEXT_PUTC(context, &buffer, '\0');
actual_inspected = cut_take_strdup(GRN_TEXT_VALUE(&buffer));
GRN_OBJ_FIN(context, &buffer);
cut_assert_equal_string(inspected, actual_inspected);
}
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_encoding
detect_coding_part(grn_ctx *ctx, const char *line, size_t line_length)
{
grn_encoding encoding = GRN_ENC_NONE;
grn_obj null_terminated_line_buffer;
const char *c_line;
const char *coding_part_keyword = "coding: ";
const char *coding_part;
const char *encoding_name;
GRN_TEXT_INIT(&null_terminated_line_buffer, 0);
GRN_TEXT_PUT(ctx, &null_terminated_line_buffer, line, line_length);
GRN_TEXT_PUTC(ctx, &null_terminated_line_buffer, '\0');
c_line = GRN_TEXT_VALUE(&null_terminated_line_buffer);
coding_part = strstr(c_line, coding_part_keyword);
if (coding_part) {
encoding_name = coding_part + strlen(coding_part_keyword);
if (grn_strncasecmp(encoding_name, "utf-8", strlen("utf-8")) == 0 ||
grn_strncasecmp(encoding_name, "utf8", strlen("utf8")) == 0) {
encoding = GRN_ENC_UTF8;
} else if (grn_strncasecmp(encoding_name, "sjis", strlen("sjis")) == 0 ||
grn_strncasecmp(encoding_name, "Shift_JIS", strlen("Shift_JIS")) == 0) {
encoding = GRN_ENC_SJIS;
} else if (grn_strncasecmp(encoding_name, "EUC-JP", strlen("EUC-JP")) == 0 ||
grn_strncasecmp(encoding_name, "euc_jp", strlen("euc_jp")) == 0) {
encoding = GRN_ENC_EUC_JP;
} else if (grn_strncasecmp(encoding_name, "latin1", strlen("latin1")) == 0) {
encoding = GRN_ENC_LATIN1;
} else if (grn_strncasecmp(encoding_name, "KOI8-R", strlen("KOI8-R")) == 0 ||
grn_strncasecmp(encoding_name, "koi8r", strlen("koi8r")) == 0) {
encoding = GRN_ENC_KOI8R;
}
} else {
encoding = ctx->encoding;
}
GRN_OBJ_FIN(ctx, &null_terminated_line_buffer);
return encoding;
}
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 escape(EscapeInfo *info, UDF_ARGS *args)
{
grn_ctx *ctx = &(info->ctx);
char *query = args->args[0];
unsigned int query_length = args->lengths[0];
GRN_BULK_REWIND(&(info->escaped_query));
if (args->arg_count == 2) {
char *target_characters = args->args[1];
unsigned int target_characters_length = args->lengths[1];
GRN_TEXT_PUT(ctx, &(info->target_characters),
target_characters,
target_characters_length);
GRN_TEXT_PUTC(ctx, &(info->target_characters), '\0');
grn_expr_syntax_escape(ctx, query, query_length,
GRN_TEXT_VALUE(&(info->target_characters)),
GRN_QUERY_ESCAPE,
&(info->escaped_query));
} else {
grn_expr_syntax_escape_query(ctx, query, query_length,
&(info->escaped_query));
}
}
static void
command_schema_table_command_collect_arguments(grn_ctx *ctx,
grn_obj *table,
grn_obj *arguments)
{
#define ADD(name_, value_) \
grn_vector_add_element(ctx, arguments, \
name_, strlen(name_), \
0, GRN_DB_TEXT); \
grn_vector_add_element(ctx, arguments, \
value_, strlen(value_), \
0, GRN_DB_TEXT)
#define ADD_OBJECT_NAME(name_, object_) do { \
char object_name[GRN_TABLE_MAX_KEY_SIZE]; \
unsigned int object_name_size; \
object_name_size = grn_obj_name(ctx, object_, \
object_name, \
GRN_TABLE_MAX_KEY_SIZE); \
object_name[object_name_size] = '\0'; \
ADD(name_, object_name); \
} while (GRN_FALSE)
ADD_OBJECT_NAME("name", table);
{
grn_obj flags;
grn_table_flags table_flags;
grn_table_flags ignored_flags = GRN_OBJ_KEY_NORMALIZE | GRN_OBJ_PERSISTENT;
GRN_TEXT_INIT(&flags, 0);
grn_table_get_info(ctx, table, &table_flags, NULL, NULL, NULL, NULL);
grn_dump_table_create_flags(ctx,
table_flags & ~ignored_flags,
&flags);
GRN_TEXT_PUTC(ctx, &flags, '\0');
ADD("flags", GRN_TEXT_VALUE(&flags));
GRN_OBJ_FIN(ctx, &flags);
}
{
grn_obj *key_type = NULL;
if (table->header.type != GRN_TABLE_NO_KEY &&
table->header.domain != GRN_ID_NIL) {
key_type = grn_ctx_at(ctx, table->header.domain);
}
if (key_type) {
ADD_OBJECT_NAME("key_type", key_type);
}
}
{
grn_obj *value_type = NULL;
grn_id range = GRN_ID_NIL;
if (table->header.type != GRN_TABLE_DAT_KEY) {
range = grn_obj_get_range(ctx, table);
}
if (range != GRN_ID_NIL) {
value_type = grn_ctx_at(ctx, range);
}
if (value_type) {
ADD_OBJECT_NAME("value_type", value_type);
}
}
{
grn_obj *tokenizer;
tokenizer = grn_obj_get_info(ctx, table, GRN_INFO_DEFAULT_TOKENIZER, NULL);
if (tokenizer) {
ADD_OBJECT_NAME("default_tokenizer", tokenizer);
}
}
{
grn_obj *normalizer;
normalizer = grn_obj_get_info(ctx, table, GRN_INFO_NORMALIZER, NULL);
if (!normalizer && (table->header.flags & GRN_OBJ_KEY_NORMALIZE)) {
normalizer = grn_ctx_get(ctx, "NormalizerAuto", -1);
}
if (normalizer) {
ADD_OBJECT_NAME("normalizer", normalizer);
}
}
if (table->header.type != GRN_TABLE_NO_KEY) {
grn_obj token_filters;
int n;
GRN_PTR_INIT(&token_filters, GRN_OBJ_VECTOR, GRN_DB_OBJECT);
grn_obj_get_info(ctx, table, GRN_INFO_TOKEN_FILTERS, &token_filters);
n = GRN_BULK_VSIZE(&token_filters) / sizeof(grn_obj *);
if (n > 0) {
grn_obj token_filter_names;
int i;
GRN_TEXT_INIT(&token_filter_names, 0);
for (i = 0; i < n; i++) {
grn_obj *token_filter;
char name[GRN_TABLE_MAX_KEY_SIZE];
int name_size;
token_filter = GRN_PTR_VALUE_AT(&token_filters, i);
name_size = grn_obj_name(ctx, token_filter,
name, GRN_TABLE_MAX_KEY_SIZE);
if (i > 0) {
GRN_TEXT_PUTC(ctx, &token_filter_names, ',');
}
GRN_TEXT_PUT(ctx, &token_filter_names, name, name_size);
}
GRN_TEXT_PUTC(ctx, &token_filter_names, '\0');
ADD("token_filters", GRN_TEXT_VALUE(&token_filter_names));
GRN_OBJ_FIN(ctx, &token_filter_names);
}
GRN_OBJ_FIN(ctx, &token_filters);
}
#undef ADD_OBJECT_NAME
#undef ADD
}
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
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
json_read(grn_ctx *ctx, grn_loader *loader, const char *str, unsigned int str_len)
{
const char *const beg = str;
char c;
int len;
const char *se = str + str_len;
while (str < se) {
c = *str;
switch (loader->stat) {
case GRN_LOADER_BEGIN :
if ((len = grn_isspace(str, ctx->encoding))) {
str += len;
continue;
}
switch (c) {
case '[' :
JSON_READ_OPEN_BRACKET();
break;
case '{' :
JSON_READ_OPEN_BRACE();
break;
default :
ERR(GRN_INVALID_ARGUMENT,
"JSON must start with '[' or '{': <%.*s>", str_len, beg);
loader->stat = GRN_LOADER_END;
break;
}
break;
case GRN_LOADER_TOKEN :
if ((len = grn_isspace(str, ctx->encoding))) {
str += len;
continue;
}
switch (c) {
case '"' :
loader->stat = GRN_LOADER_STRING;
values_add(ctx, loader);
str++;
break;
case '[' :
JSON_READ_OPEN_BRACKET();
break;
case '{' :
JSON_READ_OPEN_BRACE();
break;
case ':' :
str++;
break;
case ',' :
str++;
break;
case ']' :
bracket_close(ctx, loader);
loader->stat = GRN_BULK_VSIZE(&loader->level) ? GRN_LOADER_TOKEN : GRN_LOADER_END;
if (ctx->rc == GRN_CANCEL) {
loader->stat = GRN_LOADER_END;
}
str++;
break;
case '}' :
brace_close(ctx, loader);
loader->stat = GRN_BULK_VSIZE(&loader->level) ? GRN_LOADER_TOKEN : GRN_LOADER_END;
if (ctx->rc == GRN_CANCEL) {
loader->stat = GRN_LOADER_END;
}
str++;
break;
case '+' : case '-' : case '0' : case '1' : case '2' : case '3' :
case '4' : case '5' : case '6' : case '7' : case '8' : case '9' :
loader->stat = GRN_LOADER_NUMBER;
values_add(ctx, loader);
break;
default :
if (('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z') || ('_' == c)) {
loader->stat = GRN_LOADER_SYMBOL;
values_add(ctx, loader);
} else {
if ((len = grn_charlen(ctx, str, se))) {
GRN_LOG(ctx, GRN_LOG_ERROR, "ignored invalid char('%c') at", c);
GRN_LOG(ctx, GRN_LOG_ERROR, "%.*s", (int)(str - beg) + len, beg);
GRN_LOG(ctx, GRN_LOG_ERROR, "%*s", (int)(str - beg) + 1, "^");
str += len;
} else {
GRN_LOG(ctx, GRN_LOG_ERROR, "ignored invalid char(\\x%.2x) after", c);
GRN_LOG(ctx, GRN_LOG_ERROR, "%.*s", (int)(str - beg), beg);
str = se;
}
}
break;
}
break;
case GRN_LOADER_SYMBOL :
if (('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z') ||
('0' <= c && c <= '9') || ('_' == c)) {
GRN_TEXT_PUTC(ctx, loader->last, c);
str++;
} else {
char *v = GRN_TEXT_VALUE(loader->last);
switch (*v) {
case 'n' :
if (GRN_TEXT_LEN(loader->last) == 4 && !memcmp(v, "null", 4)) {
loader->last->header.domain = GRN_DB_VOID;
GRN_BULK_REWIND(loader->last);
}
break;
case 't' :
if (GRN_TEXT_LEN(loader->last) == 4 && !memcmp(v, "true", 4)) {
loader->last->header.domain = GRN_DB_BOOL;
GRN_BOOL_SET(ctx, loader->last, GRN_TRUE);
}
break;
case 'f' :
if (GRN_TEXT_LEN(loader->last) == 5 && !memcmp(v, "false", 5)) {
loader->last->header.domain = GRN_DB_BOOL;
GRN_BOOL_SET(ctx, loader->last, GRN_FALSE);
}
break;
default :
break;
}
loader->stat = GRN_BULK_VSIZE(&loader->level) ? GRN_LOADER_TOKEN : GRN_LOADER_END;
}
break;
case GRN_LOADER_NUMBER :
switch (c) {
case '+' : case '-' : case '.' : case 'e' : case 'E' :
case '0' : case '1' : case '2' : case '3' : case '4' :
case '5' : case '6' : case '7' : case '8' : case '9' :
GRN_TEXT_PUTC(ctx, loader->last, c);
str++;
break;
default :
{
const char *cur, *str = GRN_BULK_HEAD(loader->last);
const char *str_end = GRN_BULK_CURR(loader->last);
int64_t i = grn_atoll(str, str_end, &cur);
if (cur == str_end) {
loader->last->header.domain = GRN_DB_INT64;
GRN_INT64_SET(ctx, loader->last, i);
} else if (cur != str) {
uint64_t i = grn_atoull(str, str_end, &cur);
if (cur == str_end) {
loader->last->header.domain = GRN_DB_UINT64;
GRN_UINT64_SET(ctx, loader->last, i);
} else if (cur != str) {
double d;
char *end;
grn_obj buf;
GRN_TEXT_INIT(&buf, 0);
GRN_TEXT_PUT(ctx, &buf, str, GRN_BULK_VSIZE(loader->last));
GRN_TEXT_PUTC(ctx, &buf, '\0');
errno = 0;
d = strtod(GRN_TEXT_VALUE(&buf), &end);
if (!errno && end + 1 == GRN_BULK_CURR(&buf)) {
loader->last->header.domain = GRN_DB_FLOAT;
GRN_FLOAT_SET(ctx, loader->last, d);
}
GRN_OBJ_FIN(ctx, &buf);
}
}
}
loader->stat = GRN_BULK_VSIZE(&loader->level) ? GRN_LOADER_TOKEN : GRN_LOADER_END;
break;
}
break;
case GRN_LOADER_STRING :
switch (c) {
case '\\' :
loader->stat = GRN_LOADER_STRING_ESC;
str++;
break;
case '"' :
str++;
loader->stat = GRN_BULK_VSIZE(&loader->level) ? GRN_LOADER_TOKEN : GRN_LOADER_END;
/*
*(GRN_BULK_CURR(loader->last)) = '\0';
GRN_LOG(ctx, GRN_LOG_ALERT, "read str(%s)", GRN_TEXT_VALUE(loader->last));
*/
break;
default :
if ((len = grn_charlen(ctx, str, se))) {
GRN_TEXT_PUT(ctx, loader->last, str, len);
str += len;
} else {
GRN_LOG(ctx, GRN_LOG_ERROR, "ignored invalid char(\\x%.2x) after", c);
GRN_LOG(ctx, GRN_LOG_ERROR, "%.*s", (int)(str - beg), beg);
str = se;
}
break;
}
break;
case GRN_LOADER_STRING_ESC :
switch (c) {
case 'b' :
GRN_TEXT_PUTC(ctx, loader->last, '\b');
loader->stat = GRN_LOADER_STRING;
break;
case 'f' :
GRN_TEXT_PUTC(ctx, loader->last, '\f');
loader->stat = GRN_LOADER_STRING;
break;
case 'n' :
GRN_TEXT_PUTC(ctx, loader->last, '\n');
loader->stat = GRN_LOADER_STRING;
break;
case 'r' :
GRN_TEXT_PUTC(ctx, loader->last, '\r');
loader->stat = GRN_LOADER_STRING;
break;
case 't' :
GRN_TEXT_PUTC(ctx, loader->last, '\t');
loader->stat = GRN_LOADER_STRING;
break;
case 'u' :
loader->stat = GRN_LOADER_UNICODE0;
break;
default :
GRN_TEXT_PUTC(ctx, loader->last, c);
loader->stat = GRN_LOADER_STRING;
break;
}
str++;
break;
case GRN_LOADER_UNICODE0 :
switch (c) {
case '0' : case '1' : case '2' : case '3' : case '4' :
case '5' : case '6' : case '7' : case '8' : case '9' :
loader->unichar = (c - '0') * 0x1000;
break;
case 'a' : case 'b' : case 'c' : case 'd' : case 'e' : case 'f' :
loader->unichar = (c - 'a' + 10) * 0x1000;
break;
case 'A' : case 'B' : case 'C' : case 'D' : case 'E' : case 'F' :
loader->unichar = (c - 'A' + 10) * 0x1000;
break;
default :
;// todo : error
}
loader->stat = GRN_LOADER_UNICODE1;
str++;
break;
case GRN_LOADER_UNICODE1 :
switch (c) {
case '0' : case '1' : case '2' : case '3' : case '4' :
case '5' : case '6' : case '7' : case '8' : case '9' :
loader->unichar += (c - '0') * 0x100;
break;
case 'a' : case 'b' : case 'c' : case 'd' : case 'e' : case 'f' :
loader->unichar += (c - 'a' + 10) * 0x100;
break;
case 'A' : case 'B' : case 'C' : case 'D' : case 'E' : case 'F' :
loader->unichar += (c - 'A' + 10) * 0x100;
break;
default :
;// todo : error
}
loader->stat = GRN_LOADER_UNICODE2;
str++;
break;
case GRN_LOADER_UNICODE2 :
switch (c) {
case '0' : case '1' : case '2' : case '3' : case '4' :
case '5' : case '6' : case '7' : case '8' : case '9' :
loader->unichar += (c - '0') * 0x10;
break;
case 'a' : case 'b' : case 'c' : case 'd' : case 'e' : case 'f' :
loader->unichar += (c - 'a' + 10) * 0x10;
break;
case 'A' : case 'B' : case 'C' : case 'D' : case 'E' : case 'F' :
loader->unichar += (c - 'A' + 10) * 0x10;
break;
default :
;// todo : error
}
loader->stat = GRN_LOADER_UNICODE3;
str++;
break;
case GRN_LOADER_UNICODE3 :
switch (c) {
case '0' : case '1' : case '2' : case '3' : case '4' :
case '5' : case '6' : case '7' : case '8' : case '9' :
loader->unichar += (c - '0');
break;
case 'a' : case 'b' : case 'c' : case 'd' : case 'e' : case 'f' :
loader->unichar += (c - 'a' + 10);
break;
case 'A' : case 'B' : case 'C' : case 'D' : case 'E' : case 'F' :
loader->unichar += (c - 'A' + 10);
break;
default :
;// todo : error
}
{
uint32_t u = loader->unichar;
if (u >= 0xd800 && u <= 0xdbff) { /* High-surrogate code points */
loader->unichar_hi = u;
loader->stat = GRN_LOADER_STRING;
str++;
break;
}
if (u >= 0xdc00 && u <= 0xdfff) { /* Low-surrogate code points */
u = 0x10000 + (loader->unichar_hi - 0xd800) * 0x400 + u - 0xdc00;
}
if (u < 0x80) {
GRN_TEXT_PUTC(ctx, loader->last, u);
} else {
if (u < 0x800) {
GRN_TEXT_PUTC(ctx, loader->last, (u >> 6) | 0xc0);
} else {
if (u < 0x10000) {
GRN_TEXT_PUTC(ctx, loader->last, (u >> 12) | 0xe0);
} else {
GRN_TEXT_PUTC(ctx, loader->last, (u >> 18) | 0xf0);
GRN_TEXT_PUTC(ctx, loader->last, ((u >> 12) & 0x3f) | 0x80);
}
GRN_TEXT_PUTC(ctx, loader->last, ((u >> 6) & 0x3f) | 0x80);
}
GRN_TEXT_PUTC(ctx, loader->last, (u & 0x3f) | 0x80);
}
int
main(int argc, char **argv)
{
const char *db_path;
const char *dataset_name;
grn_ctx ctx_, *ctx;
grn_obj *db;
grn_bool success = GRN_TRUE;
int parsed_argc, rest_argc;
int flags = MODE_NONE;
const char *default_tokenizer = NULL;
static grn_str_getopt_opt opts[] = {
{'\0', "default-tokenizer", NULL, 0, GETOPT_OP_NONE},
{'h', "help", NULL, MODE_USAGE, GETOPT_OP_UPDATE}
};
opts[0].arg = &default_tokenizer;
parsed_argc = grn_str_getopt(argc, argv, opts, &flags);
if (parsed_argc < 0) {
usage(stderr, argc, argv);
return EXIT_FAILURE;
}
if (flags & MODE_USAGE) {
usage(stdout, argc, argv);
return EXIT_SUCCESS;
}
rest_argc = argc - parsed_argc;
if (rest_argc != 2) {
usage(stderr, argc, argv);
return EXIT_FAILURE;
}
db_path = argv[parsed_argc];
dataset_name = argv[parsed_argc + 1];
grn_init();
ctx = &ctx_;
grn_ctx_init(ctx, 0);
db = grn_db_open(ctx, db_path);
if (!db) {
if (ctx->rc == GRN_NO_SUCH_FILE_OR_DIRECTORY) {
db = grn_db_create(ctx, db_path, NULL);
if (!db) {
fprintf(stderr, "DB create failed (%s): %s\n", db_path, ctx->errbuf);
}
} else {
fprintf(stderr, "DB open failed (%s): %s\n", db_path, ctx->errbuf);
}
}
if (db) {
grn_obj text;
GRN_TEXT_INIT(&text, 0);
#define SEND(string) send_command(ctx, &text, string, dataset_name)
SEND("register suggest/suggest");
SEND("table_create event_type TABLE_HASH_KEY ShortText");
{
grn_obj query;
GRN_TEXT_INIT(&query, 0);
GRN_TEXT_PUTS(ctx, &query,
"table_create bigram TABLE_PAT_KEY ShortText "
"--default_tokenizer ");
if (default_tokenizer) {
GRN_TEXT_PUTS(ctx, &query, default_tokenizer);
} else {
GRN_TEXT_PUTS(ctx, &query, DEFAULT_DEFAULT_TOKENIZER);
}
GRN_TEXT_PUTS(ctx, &query, " --normalizer NormalizerAuto");
GRN_TEXT_PUTC(ctx, &query, '\0');
SEND(GRN_TEXT_VALUE(&query));
GRN_OBJ_FIN(ctx, &query);
}
SEND("table_create kana TABLE_PAT_KEY ShortText "
"--normalizer NormalizerAuto");
SEND("table_create item_${DATASET} TABLE_PAT_KEY "
"ShortText --default_tokenizer TokenDelimit "
"--normalizer NormalizerAuto");
SEND("column_create bigram item_${DATASET}_key "
"COLUMN_INDEX|WITH_POSITION item_${DATASET} _key");
SEND("column_create item_${DATASET} kana COLUMN_VECTOR kana");
SEND("column_create kana item_${DATASET}_kana COLUMN_INDEX "
"item_${DATASET} kana");
SEND("column_create item_${DATASET} freq COLUMN_SCALAR Int32");
SEND("column_create item_${DATASET} last COLUMN_SCALAR Time");
SEND("column_create item_${DATASET} boost COLUMN_SCALAR Int32");
SEND("column_create item_${DATASET} freq2 COLUMN_SCALAR Int32");
SEND("column_create item_${DATASET} buzz COLUMN_SCALAR Int32");
SEND("table_create pair_${DATASET} TABLE_HASH_KEY UInt64");
SEND("column_create pair_${DATASET} pre COLUMN_SCALAR item_${DATASET}");
SEND("column_create pair_${DATASET} post COLUMN_SCALAR item_${DATASET}");
SEND("column_create pair_${DATASET} freq0 COLUMN_SCALAR Int32");
SEND("column_create pair_${DATASET} freq1 COLUMN_SCALAR Int32");
SEND("column_create pair_${DATASET} freq2 COLUMN_SCALAR Int32");
SEND("column_create item_${DATASET} co COLUMN_INDEX pair_${DATASET} pre");
SEND("table_create sequence_${DATASET} TABLE_HASH_KEY ShortText");
SEND("table_create event_${DATASET} TABLE_NO_KEY");
SEND("column_create sequence_${DATASET} events "
"COLUMN_VECTOR|RING_BUFFER event_${DATASET}");
SEND("column_create event_${DATASET} type COLUMN_SCALAR event_type");
SEND("column_create event_${DATASET} time COLUMN_SCALAR Time");
SEND("column_create event_${DATASET} item COLUMN_SCALAR item_${DATASET}");
SEND("column_create event_${DATASET} sequence COLUMN_SCALAR "
"sequence_${DATASET}");
SEND("table_create configuration TABLE_HASH_KEY ShortText");
SEND("column_create configuration weight COLUMN_SCALAR UInt32");
SEND("load --table configuration");
SEND("[");
SEND("{\"_key\": \"${DATASET}\", \"weight\": 1}");
SEND("]");
#undef SEND
success = ctx->rc == GRN_SUCCESS;
GRN_OBJ_FIN(ctx, &text);
GRN_OBJ_FIN(ctx, db);
} else {
success = GRN_FALSE;
}
grn_ctx_fin(ctx);
grn_fin();
return success ? EXIT_SUCCESS : EXIT_FAILURE;
}
static void
command_schema_column_command_collect_arguments(grn_ctx *ctx,
grn_obj *table,
grn_obj *column,
grn_obj *arguments)
{
#define ADD(name_, value_) \
grn_vector_add_element(ctx, arguments, \
name_, strlen(name_), \
0, GRN_DB_TEXT); \
grn_vector_add_element(ctx, arguments, \
value_, strlen(value_), \
0, GRN_DB_TEXT)
#define ADD_OBJECT_NAME(name_, object_) do { \
char object_name[GRN_TABLE_MAX_KEY_SIZE]; \
unsigned int object_name_size; \
object_name_size = grn_obj_name(ctx, object_, \
object_name, \
GRN_TABLE_MAX_KEY_SIZE); \
object_name[object_name_size] = '\0'; \
ADD(name_, object_name); \
} while (GRN_FALSE)
ADD_OBJECT_NAME("table", table);
{
char column_name[GRN_TABLE_MAX_KEY_SIZE];
unsigned int column_name_size;
column_name_size = grn_column_name(ctx, column,
column_name, GRN_TABLE_MAX_KEY_SIZE);
column_name[column_name_size] = '\0';
ADD("name", column_name);
}
{
grn_obj flags;
GRN_TEXT_INIT(&flags, 0);
grn_dump_column_create_flags(ctx,
column->header.flags & ~GRN_OBJ_PERSISTENT,
&flags);
GRN_TEXT_PUTC(ctx, &flags, '\0');
ADD("flags", GRN_TEXT_VALUE(&flags));
GRN_OBJ_FIN(ctx, &flags);
}
{
grn_obj *value_type;
value_type = grn_ctx_at(ctx, grn_obj_get_range(ctx, column));
ADD_OBJECT_NAME("type", value_type);
}
if (column->header.type == GRN_COLUMN_INDEX) {
grn_obj source_ids;
unsigned int n_ids;
GRN_RECORD_INIT(&source_ids, GRN_OBJ_VECTOR, GRN_ID_NIL);
grn_obj_get_info(ctx, column, GRN_INFO_SOURCE, &source_ids);
n_ids = GRN_BULK_VSIZE(&source_ids) / sizeof(grn_id);
if (n_ids > 0) {
grn_obj sources;
unsigned int i;
GRN_TEXT_INIT(&sources, 0);
for (i = 0; i < n_ids; i++) {
grn_id source_id;
grn_obj *source;
char name[GRN_TABLE_MAX_KEY_SIZE];
unsigned int name_size;
source_id = GRN_RECORD_VALUE_AT(&source_ids, i);
source = grn_ctx_at(ctx, source_id);
if (grn_obj_is_table(ctx, source)) {
grn_strcpy(name, GRN_TABLE_MAX_KEY_SIZE, "_key");
name_size = strlen(name);
} else {
name_size = grn_column_name(ctx, source, name, GRN_TABLE_MAX_KEY_SIZE);
}
if (i > 0) {
GRN_TEXT_PUTC(ctx, &sources, ',');
}
GRN_TEXT_PUT(ctx, &sources, name, name_size);
}
GRN_TEXT_PUTC(ctx, &sources, '\0');
ADD("sources", GRN_TEXT_VALUE(&sources));
GRN_OBJ_FIN(ctx, &sources);
}
GRN_OBJ_FIN(ctx, &source_ids);
}
#undef ADD_OBJECT_NAME
#undef ADD
}
/* grn_ts_writer_output_header() outputs names and data types. */
static grn_rc
grn_ts_writer_output_header(grn_ctx *ctx, grn_ts_writer *writer)
{
grn_rc rc;
GRN_OUTPUT_ARRAY_OPEN("COLUMNS", writer->n_exprs);
for (size_t i = 0; i < writer->n_exprs; ++i) {
GRN_OUTPUT_ARRAY_OPEN("COLUMN", 2);
rc = grn_text_esc(ctx, ctx->impl->output.buf,
writer->names[i].ptr, writer->names[i].size);
if (rc != GRN_SUCCESS) {
return rc;
}
GRN_TEXT_PUT(ctx, ctx->impl->output.buf, ",\"", 2);
switch (writer->exprs[i]->data_type) {
case GRN_DB_VOID: {
if (writer->exprs[i]->data_kind == GRN_TS_GEO) {
GRN_TEXT_PUTS(ctx, ctx->impl->output.buf, "GeoPoint");
} else {
GRN_TEXT_PUTS(ctx, ctx->impl->output.buf, "Void");
}
break;
}
GRN_TS_WRITER_OUTPUT_HEADER_CASE(BOOL, "Bool")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(INT8, "Int8")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(INT16, "Int16")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(INT32, "Int32")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(INT64, "Int64")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(UINT8, "UInt8")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(UINT16, "UInt16")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(UINT32, "UInt32")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(UINT64, "UInt64")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(FLOAT, "Float")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(TIME, "Time")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(SHORT_TEXT, "ShortText")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(TEXT, "Text")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(LONG_TEXT, "LongText")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(TOKYO_GEO_POINT, "TokyoGeoPoint")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(WGS84_GEO_POINT, "WGS84GeoPoint")
default: {
char name_buf[GRN_TABLE_MAX_KEY_SIZE];
size_t name_size;
grn_obj *obj = grn_ctx_at(ctx, writer->exprs[i]->data_type);
if (!obj) {
GRN_TS_ERR_RETURN(GRN_UNKNOWN_ERROR, "grn_ctx_at failed: %d",
writer->exprs[i]->data_type);
}
if (!grn_ts_obj_is_table(ctx, obj)) {
grn_obj_unlink(ctx, obj);
GRN_TS_ERR_RETURN(GRN_UNKNOWN_ERROR, "not table: %d",
writer->exprs[i]->data_type);
}
name_size = grn_obj_name(ctx, obj, name_buf, sizeof(name_buf));
GRN_TEXT_PUT(ctx, ctx->impl->output.buf, name_buf, name_size);
grn_obj_unlink(ctx, obj);
break;
}
}
GRN_TEXT_PUTC(ctx, ctx->impl->output.buf, '"');
GRN_OUTPUT_ARRAY_CLOSE();
}
GRN_OUTPUT_ARRAY_CLOSE(); /* COLUMNS. */
return GRN_SUCCESS;
}
