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; }