static grn_obj *
proc_table_create(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_obj *buf = args[0];
grn_expr_var *vars;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
if (nvars == 6) {
grn_obj *table;
grn_obj_flags flags = grn_atoi(GRN_TEXT_VALUE(&vars[1].value),
GRN_BULK_CURR(&vars[1].value), NULL);
if (GRN_TEXT_LEN(&vars[0].value)) {
flags |= GRN_OBJ_PERSISTENT;
}
table = grn_table_create(ctx,
GRN_TEXT_VALUE(&vars[0].value),
GRN_TEXT_LEN(&vars[0].value),
NULL, flags,
grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[2].value),
GRN_TEXT_LEN(&vars[2].value)),
grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[3].value),
GRN_TEXT_LEN(&vars[3].value)));
if (table) {
grn_obj_set_info(ctx, table,
GRN_INFO_DEFAULT_TOKENIZER,
grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[4].value),
GRN_TEXT_LEN(&vars[4].value)));
grn_obj_unlink(ctx, table);
}
GRN_TEXT_PUTS(ctx, buf, ctx->rc ? "false" : "true");
}
return buf;
}
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 *
func_highlight_html(grn_ctx *ctx, int nargs, grn_obj **args,
grn_user_data *user_data)
{
grn_obj *highlighted = NULL;
grn_obj *string;
grn_obj *lexicon = NULL;
grn_obj *expression = NULL;
grn_highlighter *highlighter;
grn_obj *highlighter_ptr;
if (!(1 <= nargs && nargs <= 2)) {
GRN_PLUGIN_ERROR(ctx,
GRN_INVALID_ARGUMENT,
"highlight_html(): wrong number of arguments (%d for 1..2)",
nargs);
highlighted = grn_plugin_proc_alloc(ctx, user_data, GRN_DB_VOID, 0);
return highlighted;
}
string = args[0];
if (nargs == 2) {
lexicon = args[1];
}
grn_proc_get_info(ctx, user_data, NULL, NULL, &expression);
highlighter_ptr = grn_expr_get_var(ctx, expression,
GRN_FUNC_HIGHLIGHT_HTML_CACHE_NAME,
strlen(GRN_FUNC_HIGHLIGHT_HTML_CACHE_NAME));
if (highlighter_ptr) {
highlighter = (grn_highlighter *)GRN_PTR_VALUE(highlighter_ptr);
} else {
highlighter_ptr =
grn_expr_get_or_add_var(ctx, expression,
GRN_FUNC_HIGHLIGHT_HTML_CACHE_NAME,
strlen(GRN_FUNC_HIGHLIGHT_HTML_CACHE_NAME));
GRN_OBJ_FIN(ctx, highlighter_ptr);
GRN_PTR_INIT(highlighter_ptr, GRN_OBJ_OWN, GRN_DB_OBJECT);
highlighter = func_highlight_html_create_highlighter(ctx, expression);
grn_highlighter_set_lexicon(ctx, highlighter, lexicon);
GRN_PTR_SET(ctx, highlighter_ptr, highlighter);
}
highlighted = grn_plugin_proc_alloc(ctx, user_data, GRN_DB_TEXT, 0);
grn_highlighter_highlight(ctx,
highlighter,
GRN_TEXT_VALUE(string),
GRN_TEXT_LEN(string),
highlighted);
return highlighted;
}
static grn_obj *
proc_column_create(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_obj *buf = args[0];
grn_expr_var *vars;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
if (nvars == 6) {
grn_obj_flags flags = grn_atoi(GRN_TEXT_VALUE(&vars[2].value),
GRN_BULK_CURR(&vars[2].value), NULL);
grn_obj *column, *table = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[0].value),
GRN_TEXT_LEN(&vars[0].value));
grn_obj *type = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[3].value),
GRN_TEXT_LEN(&vars[3].value));
if (GRN_TEXT_LEN(&vars[1].value)) {
flags |= GRN_OBJ_PERSISTENT;
}
column = grn_column_create(ctx, table,
GRN_TEXT_VALUE(&vars[1].value),
GRN_TEXT_LEN(&vars[1].value),
NULL, flags, type);
if (column) {
if (GRN_TEXT_LEN(&vars[4].value)) {
grn_obj sources, source_ids, **p, **pe;
GRN_PTR_INIT(&sources, GRN_OBJ_VECTOR, GRN_ID_NIL);
GRN_UINT32_INIT(&source_ids, GRN_OBJ_VECTOR);
grn_obj_columns(ctx, type,
GRN_TEXT_VALUE(&vars[4].value),
GRN_TEXT_LEN(&vars[4].value),
&sources);
p = (grn_obj **)GRN_BULK_HEAD(&sources);
pe = (grn_obj **)GRN_BULK_CURR(&sources);
while (p < pe) {
grn_id source_id = grn_obj_id(ctx, *p++);
if (source_id) {
GRN_UINT32_PUT(ctx, &source_ids, source_id);
}
}
if (GRN_BULK_VSIZE(&source_ids)) {
grn_obj_set_info(ctx, column, GRN_INFO_SOURCE, &source_ids);
}
GRN_OBJ_FIN(ctx, &source_ids);
GRN_OBJ_FIN(ctx, &sources);
}
grn_obj_unlink(ctx, column);
}
GRN_TEXT_PUTS(ctx, buf, ctx->rc ? "false" : "true");
}
return buf;
}
static grn_obj *
proc_define_selector(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_expr_var *vars;
grn_obj *outbuf = args[0];
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
if (grn_proc_create(ctx,
GRN_TEXT_VALUE(&vars[0].value),
GRN_TEXT_LEN(&vars[0].value),
NULL, proc_select, NULL, NULL, nvars - 1, vars + 1)) {
GRN_TEXT_PUT(ctx, outbuf, GRN_TEXT_VALUE(&vars[0].value), GRN_TEXT_LEN(&vars[0].value));
}
return outbuf;
}
static grn_obj *
func_highlight_html(grn_ctx *ctx, int nargs, grn_obj **args,
grn_user_data *user_data)
{
grn_obj *highlighted = NULL;
#define N_REQUIRED_ARGS 1
if (nargs == N_REQUIRED_ARGS) {
grn_obj *string = args[0];
grn_obj *expression = NULL;
grn_obj *keywords;
grn_obj *keywords_ptr;
grn_bool use_html_escape = GRN_TRUE;
grn_proc_get_info(ctx, user_data, NULL, NULL, &expression);
keywords_ptr = grn_expr_get_var(ctx, expression,
GRN_FUNC_HIGHLIGHT_HTML_CACHE_NAME,
strlen(GRN_FUNC_HIGHLIGHT_HTML_CACHE_NAME));
if (keywords_ptr) {
keywords = GRN_PTR_VALUE(keywords_ptr);
} else {
keywords_ptr =
grn_expr_get_or_add_var(ctx, expression,
GRN_FUNC_HIGHLIGHT_HTML_CACHE_NAME,
strlen(GRN_FUNC_HIGHLIGHT_HTML_CACHE_NAME));
GRN_OBJ_FIN(ctx, keywords_ptr);
GRN_PTR_INIT(keywords_ptr, GRN_OBJ_OWN, GRN_DB_OBJECT);
keywords = func_highlight_html_create_keywords_table(ctx, expression);
GRN_PTR_SET(ctx, keywords_ptr, keywords);
}
highlighted = highlight_keywords(ctx, user_data,
string, keywords, use_html_escape,
"<span class=\"keyword\">",
strlen("<span class=\"keyword\">"),
"</span>",
strlen("</span>"));
}
#undef N_REQUIRED_ARGS
if (!highlighted) {
highlighted = grn_plugin_proc_alloc(ctx, user_data, GRN_DB_VOID, 0);
}
return highlighted;
}
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, ']');
}
}
static grn_obj *
proc_load(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_obj *proc = grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
if (nvars == 5) {
grn_load(ctx, GET_OTYPE(&vars[4].value),
GRN_TEXT_VALUE(&vars[1].value), GRN_TEXT_LEN(&vars[1].value),
GRN_TEXT_VALUE(&vars[2].value), GRN_TEXT_LEN(&vars[2].value),
GRN_TEXT_VALUE(&vars[0].value), GRN_TEXT_LEN(&vars[0].value),
GRN_TEXT_VALUE(&vars[3].value), GRN_TEXT_LEN(&vars[3].value));
if (ctx->impl->loader.stat == GRN_LOADER_BEGIN) {
grn_text_itoa(ctx, outbuf, ctx->impl->loader.nrecords);
} else {
grn_ctx_set_next_expr(ctx, proc);
}
}
return outbuf;
}
static grn_obj *
func_str_len(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
grn_obj *obj, *caller;
uint32_t nvars;
grn_expr_var *vars;
unsigned int length = 0;
grn_proc_get_info(ctx, user_data, &vars, &nvars, &caller);
if (nargs == 1) {
grn_obj *text = args[0];
size_t len = GRN_TEXT_LEN(text);
char *null_terminated_text = malloc(len + 1);
memcpy(null_terminated_text, GRN_TEXT_VALUE(text), len);
null_terminated_text[len] = '\0';
length = grn_str_len(ctx, null_terminated_text, ctx->encoding, NULL);
free(null_terminated_text);
}
if ((obj = grn_expr_alloc(ctx, caller, GRN_DB_UINT32, 0))) {
GRN_UINT32_SET(ctx, obj, length);
}
return obj;
}
static grn_obj *
proc_select(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_expr_var *vars;
grn_obj *outbuf = args[0];
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
if (nvars == 15) {
int offset = GRN_TEXT_LEN(&vars[7].value)
? grn_atoi(GRN_TEXT_VALUE(&vars[7].value), GRN_BULK_CURR(&vars[7].value), NULL)
: 0;
int limit = GRN_TEXT_LEN(&vars[8].value)
? grn_atoi(GRN_TEXT_VALUE(&vars[8].value), GRN_BULK_CURR(&vars[8].value), NULL)
: DEFAULT_LIMIT;
char *output_columns = GRN_TEXT_VALUE(&vars[6].value);
uint32_t output_columns_len = GRN_TEXT_LEN(&vars[6].value);
if (!output_columns_len) {
output_columns = DEFAULT_OUTPUT_COLUMNS;
output_columns_len = strlen(DEFAULT_OUTPUT_COLUMNS);
}
grn_search(ctx, outbuf, GET_OTYPE(&vars[14].value),
GRN_TEXT_VALUE(&vars[0].value), GRN_TEXT_LEN(&vars[0].value),
GRN_TEXT_VALUE(&vars[1].value), GRN_TEXT_LEN(&vars[1].value),
GRN_TEXT_VALUE(&vars[2].value), GRN_TEXT_LEN(&vars[2].value),
GRN_TEXT_VALUE(&vars[3].value), GRN_TEXT_LEN(&vars[3].value),
GRN_TEXT_VALUE(&vars[4].value), GRN_TEXT_LEN(&vars[4].value),
GRN_TEXT_VALUE(&vars[5].value), GRN_TEXT_LEN(&vars[5].value),
output_columns, output_columns_len,
offset, limit,
GRN_TEXT_VALUE(&vars[9].value), GRN_TEXT_LEN(&vars[9].value),
GRN_TEXT_VALUE(&vars[10].value), GRN_TEXT_LEN(&vars[10].value),
GRN_TEXT_VALUE(&vars[11].value), GRN_TEXT_LEN(&vars[11].value),
grn_atoi(GRN_TEXT_VALUE(&vars[12].value), GRN_BULK_CURR(&vars[12].value), NULL),
grn_atoi(GRN_TEXT_VALUE(&vars[13].value), GRN_BULK_CURR(&vars[13].value), NULL));
}
return outbuf;
}
static grn_obj *
func_snippet_html(grn_ctx *ctx, int nargs, grn_obj **args,
grn_user_data *user_data)
{
grn_obj *snippets = NULL;
/* TODO: support parameters */
if (nargs == 1) {
grn_obj *text = args[0];
grn_obj *expression = NULL;
grn_obj *condition_ptr = NULL;
grn_obj *condition = NULL;
grn_obj *snip = NULL;
int flags = GRN_SNIP_SKIP_LEADING_SPACES;
unsigned int width = 200;
unsigned int max_n_results = 3;
const char *open_tag = "<span class=\"keyword\">";
const char *close_tag = "</span>";
grn_snip_mapping *mapping = GRN_SNIP_MAPPING_HTML_ESCAPE;
grn_proc_get_info(ctx, user_data, NULL, NULL, &expression);
condition_ptr = grn_expr_get_var(ctx, expression,
GRN_SELECT_INTERNAL_VAR_CONDITION,
strlen(GRN_SELECT_INTERNAL_VAR_CONDITION));
if (condition_ptr) {
condition = GRN_PTR_VALUE(condition_ptr);
}
if (condition) {
grn_obj *snip_ptr;
snip_ptr = grn_expr_get_var(ctx, expression,
GRN_FUNC_SNIPPET_HTML_CACHE_NAME,
strlen(GRN_FUNC_SNIPPET_HTML_CACHE_NAME));
if (snip_ptr) {
snip = GRN_PTR_VALUE(snip_ptr);
} else {
snip_ptr =
grn_expr_get_or_add_var(ctx, expression,
GRN_FUNC_SNIPPET_HTML_CACHE_NAME,
strlen(GRN_FUNC_SNIPPET_HTML_CACHE_NAME));
GRN_OBJ_FIN(ctx, snip_ptr);
GRN_PTR_INIT(snip_ptr, GRN_OBJ_OWN, GRN_DB_OBJECT);
snip = grn_snip_open(ctx, flags, width, max_n_results,
open_tag, strlen(open_tag),
close_tag, strlen(close_tag),
mapping);
if (snip) {
grn_snip_set_normalizer(ctx, snip, GRN_NORMALIZER_AUTO);
grn_expr_snip_add_conditions(ctx, condition, snip,
0, NULL, NULL, NULL, NULL);
GRN_PTR_SET(ctx, snip_ptr, snip);
}
}
}
if (snip) {
snippets = snippet_exec(ctx, snip, text, user_data, NULL, 0, NULL, 0);
}
}
if (!snippets) {
snippets = grn_plugin_proc_alloc(ctx, user_data, GRN_DB_VOID, 0);
}
return snippets;
}
