/*
* _expression_ で使用可能な変数のうち、名前が _name_
* または _offset_ 番目に {Expression#append_object}
* された変数の値を返す。
*
* @overload [](name)
* @return [変数の値]
* @overload [](offset)
* @return [変数の値]
*/
static VALUE
rb_grn_expression_array_reference (VALUE self, VALUE rb_name_or_offset)
{
grn_ctx *context = NULL;
grn_obj *expression, *variable;
char *name = NULL;
unsigned name_size = 0;
int offset;
rb_grn_expression_deconstruct(SELF(self), &expression, &context,
NULL, NULL,
NULL, NULL, NULL);
switch (TYPE(rb_name_or_offset)) {
case T_STRING:
name = RSTRING_PTR(rb_name_or_offset);
name_size = RSTRING_LEN(rb_name_or_offset);
variable = grn_expr_get_var(context, expression, name, name_size);
break;
case T_FIXNUM:
offset = NUM2INT(rb_name_or_offset);
variable = grn_expr_get_var_by_offset(context, expression, offset);
break;
default:
rb_raise(rb_eArgError, "xxx");
break;
}
return GRNVARIABLE2RVAL(context, variable);
}
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 mrb_value
mrb_grn_expression_array_reference(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *expr;
mrb_value mrb_key;
grn_obj *var;
mrb_get_args(mrb, "o", &mrb_key);
expr = DATA_PTR(self);
switch (mrb_type(mrb_key)) {
case MRB_TT_SYMBOL :
{
const char *name;
mrb_int name_length;
name = mrb_sym2name_len(mrb, mrb_symbol(mrb_key), &name_length);
var = grn_expr_get_var(ctx, expr, name, name_length);
}
break;
case MRB_TT_STRING :
var = grn_expr_get_var(ctx, expr,
RSTRING_PTR(mrb_key), RSTRING_LEN(mrb_key));
break;
case MRB_TT_FIXNUM :
var = grn_expr_get_var_by_offset(ctx, expr, mrb_fixnum(mrb_key));
break;
default :
mrb_raisef(mrb, E_ARGUMENT_ERROR,
"key must be Symbol, String or Fixnum: %S",
mrb_key);
break;
}
return grn_mrb_value_from_grn_obj(mrb, var);
}
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 *
func_highlight_html_create_keywords_table(grn_ctx *ctx, grn_obj *expression)
{
grn_obj *keywords;
grn_obj *condition_ptr = NULL;
grn_obj *condition = NULL;
keywords = grn_table_create(ctx, NULL, 0, NULL,
GRN_OBJ_TABLE_PAT_KEY,
grn_ctx_at(ctx, GRN_DB_SHORT_TEXT),
NULL);
{
grn_obj *normalizer;
normalizer = grn_ctx_get(ctx, "NormalizerAuto", -1);
grn_obj_set_info(ctx, keywords, GRN_INFO_NORMALIZER, normalizer);
grn_obj_unlink(ctx, normalizer);
}
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) {
size_t i, n_keywords;
grn_obj current_keywords;
GRN_PTR_INIT(¤t_keywords, GRN_OBJ_VECTOR, GRN_ID_NIL);
grn_expr_get_keywords(ctx, condition, ¤t_keywords);
n_keywords = GRN_BULK_VSIZE(¤t_keywords) / sizeof(grn_obj *);
for (i = 0; i < n_keywords; i++) {
grn_obj *keyword;
keyword = GRN_PTR_VALUE_AT(¤t_keywords, i);
grn_table_add(ctx, keywords,
GRN_TEXT_VALUE(keyword),
GRN_TEXT_LEN(keyword),
NULL);
}
grn_obj_unlink(ctx, ¤t_keywords);
}
return keywords;
}
static grn_highlighter *
func_highlight_html_create_highlighter(grn_ctx *ctx, grn_obj *expression)
{
grn_highlighter *highlighter;
grn_obj *condition_ptr = NULL;
grn_obj *condition = NULL;
highlighter = grn_highlighter_open(ctx);
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) {
size_t i, n_keywords;
grn_obj current_keywords;
GRN_TEXT_INIT(¤t_keywords, GRN_OBJ_VECTOR);
grn_expr_get_keywords(ctx, condition, ¤t_keywords);
n_keywords = grn_vector_size(ctx, ¤t_keywords);
for (i = 0; i < n_keywords; i++) {
const char *keyword;
unsigned int keyword_size;
keyword_size = grn_vector_get_element(ctx,
¤t_keywords,
i,
&keyword,
NULL,
NULL);
grn_highlighter_add_keyword(ctx,
highlighter,
keyword,
keyword_size);
}
GRN_OBJ_FIN(ctx, ¤t_keywords);
}
return highlighter;
}
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;
}
void
test_persistent_expr(void)
{
int i;
grn_obj *t1, *t2, *c1, *c2, buf;
t1 = grn_table_create(&context, "t1", 2, NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, 0);
cut_assert_not_null(t1);
t2 = grn_table_create(&context, "t2", 2, NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, 0);
cut_assert_not_null(t2);
c1 = grn_column_create(&context, t1, "c1", 2, NULL,
GRN_OBJ_PERSISTENT, t2);
cut_assert_not_null(c1);
c2 = grn_column_create(&context, t2, "c2", 2, NULL,
GRN_OBJ_PERSISTENT, t1);
cut_assert_not_null(c2);
GRN_TEXT_INIT(&buf, 0);
for (i = 0; i < NRECORDS; i++) {
grn_id i1, i2;
i1 = grn_table_add(&context, t1, NULL, 0, NULL);
i2 = grn_table_add(&context, t2, NULL, 0, NULL);
GRN_BULK_REWIND(&buf);
grn_bulk_write(&context, &buf, (char *)&i2, sizeof(grn_id));
grn_obj_set_value(&context, c1, i1, &buf, GRN_OBJ_SET);
grn_obj_set_value(&context, c2, i2, &buf, GRN_OBJ_SET);
}
{
grn_obj *expr = grn_expr_create(&context, "test", 4);
grn_obj *v;
cut_assert_not_null(expr);
v = grn_expr_add_var(&context, expr, "foo", 3);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, t1));
grn_expr_append_obj(&context, expr, v);
GRN_TEXT_SETS(&context, &buf, "c1");
grn_expr_append_const(&context, expr, &buf);
grn_expr_append_op(&context, expr, GRN_OP_OBJ_GET_VALUE, 2);
GRN_TEXT_SETS(&context, &buf, "c2");
grn_expr_append_const(&context, expr, &buf);
grn_expr_append_op(&context, expr, GRN_OP_OBJ_GET_VALUE, 2);
GRN_TEXT_SETS(&context, &buf, "c1");
grn_expr_append_const(&context, expr, &buf);
/*
GRN_TEXT_SETS(&context, &buf, "c1.c2.c1");
grn_expr_append_const(&context, expr, &buf);
*/
grn_expr_append_op(&context, expr, GRN_OP_OBJ_GET_VALUE, 2);
grn_expr_compile(&context, expr);
}
cut_assert_equal_uint(0, grn_obj_close(&context, &buf));
grn_db_close(&context, database);
database = grn_db_open(&context, path);
GRN_TEXT_INIT(&buf, 0);
{
grn_id id;
uint64_t et;
int nerr = 0;
grn_obj *r, *v;
grn_table_cursor *tc;
struct timeval tvb, tve;
grn_obj *expr = grn_ctx_get(&context, "test", 4);
v = grn_expr_get_var(&context, expr, "foo", 3);
t1 = grn_ctx_get(&context, "t1", 2);
tc = grn_table_cursor_open(&context, t1, NULL, 0, NULL, 0, 0);
cut_assert_not_null(tc);
gettimeofday(&tvb, NULL);
while ((id = grn_table_cursor_next(&context, tc))) {
GRN_RECORD_SET(&context, v, id);
r = grn_expr_exec(&context, expr);
if (GRN_RECORD_VALUE(r) != id) { nerr++; }
}
gettimeofday(&tve, NULL);
et = (tve.tv_sec - tvb.tv_sec) * 1000000 + (tve.tv_usec - tvb.tv_usec);
// printf("et=%zu\n", et);
cut_assert_equal_uint(0, nerr);
cut_assert_equal_uint(0, grn_table_cursor_close(&context, tc));
}
cut_assert_equal_uint(0, grn_obj_close(&context, &buf));
}
