/*
* Returns whether the column is compressed or not. If
* @type@ is specified, it returns whether the column is
* compressed by @type@ or not.
* @overload compressed?
* @return [Boolean] whether the column is compressed or not.
* @overload compressed?(type)
* @param [:zlib, :lz4] type (nil)
* @return [Boolean] whether specified compressed type is used or not.
* @since 1.3.1
*/
static VALUE
rb_grn_variable_size_column_compressed_p (int argc, VALUE *argv, VALUE self)
{
RbGrnVariableSizeColumn *rb_grn_column;
grn_ctx *context = NULL;
grn_obj *column;
grn_obj_flags flags;
VALUE type;
grn_bool compressed_p = GRN_FALSE;
grn_bool accept_any_type = GRN_FALSE;
grn_bool need_zlib_check = GRN_FALSE;
grn_bool need_lz4_check = GRN_FALSE;
rb_scan_args(argc, argv, "01", &type);
if (NIL_P(type)) {
accept_any_type = GRN_TRUE;
} else {
if (rb_grn_equal_option(type, "zlib")) {
need_zlib_check = GRN_TRUE;
} else if (rb_grn_equal_option(type, "lzo")) {
/* TODO: for backward compatibility */
need_lz4_check = GRN_TRUE;
} else if (rb_grn_equal_option(type, "lz4")) {
need_lz4_check = GRN_TRUE;
} else {
rb_raise(rb_eArgError,
"compressed type should be <:zlib> or <:lz4>: <%s>",
rb_grn_inspect(type));
}
}
rb_grn_column = SELF(self);
rb_grn_object_deconstruct(RB_GRN_OBJECT(rb_grn_column), &column, &context,
NULL, NULL,
NULL, NULL);
flags = column->header.flags;
switch (flags & GRN_OBJ_COMPRESS_MASK) {
case GRN_OBJ_COMPRESS_ZLIB:
if (accept_any_type || need_zlib_check) {
grn_obj support_p;
GRN_BOOL_INIT(&support_p, 0);
grn_obj_get_info(context, NULL, GRN_INFO_SUPPORT_ZLIB, &support_p);
compressed_p = GRN_BOOL_VALUE(&support_p);
}
break;
case GRN_OBJ_COMPRESS_LZ4:
if (accept_any_type || need_lz4_check) {
grn_obj support_p;
GRN_BOOL_INIT(&support_p, 0);
grn_obj_get_info(context, NULL, GRN_INFO_SUPPORT_LZ4, &support_p);
compressed_p = GRN_BOOL_VALUE(&support_p);
}
break;
}
return CBOOL2RVAL(compressed_p);
}
void
test_bool_to_bool(void)
{
grn_obj_reinit(&context, &dest, GRN_DB_BOOL, 0);
cast_bool(TRUE);
cut_assert_true(GRN_BOOL_VALUE(&dest));
}
void
test_uint64_to_bool(gconstpointer data)
{
grn_obj_reinit(&context, &dest, GRN_DB_BOOL, 0);
cast_uint64(gcut_data_get_uint(data, "number"));
cut_assert_equal_boolean(gcut_data_get_uint(data, "expected"),
GRN_BOOL_VALUE(&dest));
}
static VALUE
rb_grn_bulk_to_ruby_object_by_range_id (grn_ctx *context, grn_obj *bulk,
grn_id range_id,
VALUE related_object, VALUE *rb_value)
{
grn_bool success = GRN_TRUE;
switch (range_id) {
case GRN_DB_VOID:
*rb_value = rb_str_new(GRN_TEXT_VALUE(bulk), GRN_TEXT_LEN(bulk));
break;
case GRN_DB_BOOL:
*rb_value = GRN_BOOL_VALUE(bulk) ? Qtrue : Qfalse;
break;
case GRN_DB_INT32:
*rb_value = INT2NUM(GRN_INT32_VALUE(bulk));
break;
case GRN_DB_UINT32:
*rb_value = UINT2NUM(GRN_UINT32_VALUE(bulk));
break;
case GRN_DB_INT64:
*rb_value = LL2NUM(GRN_INT64_VALUE(bulk));
break;
case GRN_DB_UINT64:
*rb_value = ULL2NUM(GRN_UINT64_VALUE(bulk));
break;
case GRN_DB_FLOAT:
*rb_value = rb_float_new(GRN_FLOAT_VALUE(bulk));
break;
case GRN_DB_TIME:
{
int64_t time_value, sec, usec;
time_value = GRN_TIME_VALUE(bulk);
GRN_TIME_UNPACK(time_value, sec, usec);
*rb_value = rb_funcall(rb_cTime, rb_intern("at"), 2,
LL2NUM(sec), LL2NUM(usec));
}
break;
case GRN_DB_SHORT_TEXT:
case GRN_DB_TEXT:
case GRN_DB_LONG_TEXT:
*rb_value = rb_grn_context_rb_string_new(context,
GRN_TEXT_VALUE(bulk),
GRN_TEXT_LEN(bulk));
break;
default:
success = GRN_FALSE;
break;
}
return success;
}
void
test_support_lzo(void)
{
int support_p;
grn_obj grn_support_p;
cut_assert_ensure_context();
GRN_BOOL_INIT(&grn_support_p, 0);
grn_obj_get_info(context, NULL, GRN_INFO_SUPPORT_LZO, &grn_support_p);
support_p = GRN_BOOL_VALUE(&grn_support_p);
GRN_OBJ_FIN(context, &grn_support_p);
#ifdef GRN_WITH_LZO
cut_assert_true(support_p);
#else
cut_assert_false(support_p);
#endif
}
grn_bool
grn_obj_is_true(grn_ctx *ctx, grn_obj *obj)
{
if (!obj) {
return GRN_FALSE;
}
switch (obj->header.type) {
case GRN_BULK :
switch (obj->header.domain) {
case GRN_DB_BOOL :
return GRN_BOOL_VALUE(obj);
break;
case GRN_DB_INT32 :
return GRN_INT32_VALUE(obj) != 0;
break;
case GRN_DB_UINT32 :
return GRN_UINT32_VALUE(obj) != 0;
break;
case GRN_DB_FLOAT : {
double float_value;
float_value = GRN_FLOAT_VALUE(obj);
return (float_value < -DBL_EPSILON ||
DBL_EPSILON < float_value);
break;
}
case GRN_DB_SHORT_TEXT :
case GRN_DB_TEXT :
case GRN_DB_LONG_TEXT :
return GRN_TEXT_LEN(obj) != 0;
break;
default :
return GRN_FALSE;
break;
}
break;
case GRN_VECTOR :
return GRN_TRUE;
break;
default :
return GRN_FALSE;
break;
}
}
static grn_obj *
func_edit_distance(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
#define N_REQUIRED_ARGS 2
#define MAX_ARGS 3
int d = 0;
int flags = 0;
grn_obj *obj;
if (nargs >= N_REQUIRED_ARGS && nargs <= MAX_ARGS) {
if (nargs == MAX_ARGS && GRN_BOOL_VALUE(args[2])) {
flags |= GRN_TABLE_FUZZY_SEARCH_WITH_TRANSPOSITION;
}
d = calc_edit_distance(ctx, GRN_TEXT_VALUE(args[0]), GRN_BULK_CURR(args[0]),
GRN_TEXT_VALUE(args[1]), GRN_BULK_CURR(args[1]), flags);
}
if ((obj = grn_plugin_proc_alloc(ctx, user_data, GRN_DB_UINT32, 0))) {
GRN_UINT32_SET(ctx, obj, d);
}
return obj;
#undef N_REQUIRED_ARGS
#undef MAX_ARGS
}
static grn_obj *
func_highlight_full(grn_ctx *ctx, int nargs, grn_obj **args,
grn_user_data *user_data)
{
grn_obj *highlighted = NULL;
#define N_REQUIRED_ARGS 3
#define KEYWORD_SET_SIZE 3
if ((nargs >= (N_REQUIRED_ARGS + KEYWORD_SET_SIZE) &&
(nargs - N_REQUIRED_ARGS) % KEYWORD_SET_SIZE == 0)) {
grn_obj *string = args[0];
grn_obj *keywords;
const char *normalizer_name = GRN_TEXT_VALUE(args[1]);
unsigned int normalizer_name_length = GRN_TEXT_LEN(args[1]);
grn_bool use_html_escape = GRN_BOOL_VALUE(args[2]);
keywords =
func_highlight_create_keywords_table(ctx, user_data,
normalizer_name,
normalizer_name_length);
if (keywords) {
highlighted = highlight_keyword_sets(ctx, user_data,
args + N_REQUIRED_ARGS,
nargs - N_REQUIRED_ARGS,
string, keywords,
use_html_escape);
grn_obj_unlink(ctx, keywords);
}
}
if (!highlighted) {
highlighted = grn_plugin_proc_alloc(ctx, user_data, GRN_DB_VOID, 0);
}
#undef KEYWORD_SET_SIZE
#undef N_REQUIRED_ARGS
return highlighted;
}
/* TODO: support caching for the same parameter. */
static grn_obj *
func_snippet(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
grn_obj *snippets = NULL;
#define N_REQUIRED_ARGS 1
#define KEYWORD_SET_SIZE 3
if (nargs > N_REQUIRED_ARGS) {
grn_obj *text = args[0];
grn_obj *end_arg = args[nargs - 1];
grn_obj *snip = NULL;
unsigned int width = 200;
unsigned int max_n_results = 3;
grn_snip_mapping *mapping = NULL;
int flags = GRN_SNIP_SKIP_LEADING_SPACES;
const char *prefix = NULL;
int prefix_length = 0;
const char *suffix = NULL;
int suffix_length = 0;
const char *normalizer_name = NULL;
int normalizer_name_length = 0;
const char *default_open_tag = NULL;
int default_open_tag_length = 0;
const char *default_close_tag = NULL;
int default_close_tag_length = 0;
int n_args_without_option = nargs;
if (end_arg->header.type == GRN_TABLE_HASH_KEY) {
grn_obj *options = end_arg;
grn_hash_cursor *cursor;
void *key;
int key_size;
grn_obj *value;
n_args_without_option--;
cursor = grn_hash_cursor_open(ctx, (grn_hash *)options,
NULL, 0, NULL, 0,
0, -1, 0);
if (!cursor) {
GRN_PLUGIN_ERROR(ctx, GRN_NO_MEMORY_AVAILABLE,
"snippet(): couldn't open cursor");
goto exit;
}
while (grn_hash_cursor_next(ctx, cursor) != GRN_ID_NIL) {
grn_hash_cursor_get_key_value(ctx, cursor,
&key, &key_size,
(void **)&value);
if (key_size == 5 && !memcmp(key, "width", 5)) {
width = GRN_UINT32_VALUE(value);
} else if (key_size == 13 && !memcmp(key, "max_n_results", 13)) {
max_n_results = GRN_UINT32_VALUE(value);
} else if (key_size == 19 && !memcmp(key, "skip_leading_spaces", 19)) {
if (GRN_BOOL_VALUE(value) == GRN_FALSE) {
flags &= ~GRN_SNIP_SKIP_LEADING_SPACES;
}
} else if (key_size == 11 && !memcmp(key, "html_escape", 11)) {
if (GRN_BOOL_VALUE(value)) {
mapping = GRN_SNIP_MAPPING_HTML_ESCAPE;
}
} else if (key_size == 6 && !memcmp(key, "prefix", 6)) {
prefix = GRN_TEXT_VALUE(value);
prefix_length = GRN_TEXT_LEN(value);
} else if (key_size == 6 && !memcmp(key, "suffix", 6)) {
suffix = GRN_TEXT_VALUE(value);
suffix_length = GRN_TEXT_LEN(value);
} else if (key_size == 10 && !memcmp(key, "normalizer", 10)) {
normalizer_name = GRN_TEXT_VALUE(value);
normalizer_name_length = GRN_TEXT_LEN(value);
} else if (key_size == 16 && !memcmp(key, "default_open_tag", 16)) {
default_open_tag = GRN_TEXT_VALUE(value);
default_open_tag_length = GRN_TEXT_LEN(value);
} else if (key_size == 17 && !memcmp(key, "default_close_tag", 17)) {
default_close_tag = GRN_TEXT_VALUE(value);
default_close_tag_length = GRN_TEXT_LEN(value);
} else {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"invalid option name: <%.*s>",
key_size, (char *)key);
grn_hash_cursor_close(ctx, cursor);
goto exit;
}
}
grn_hash_cursor_close(ctx, cursor);
}
snip = grn_snip_open(ctx, flags, width, max_n_results,
default_open_tag, default_open_tag_length,
default_close_tag, default_close_tag_length, mapping);
if (snip) {
grn_rc rc;
unsigned int i;
if (!normalizer_name) {
grn_snip_set_normalizer(ctx, snip, GRN_NORMALIZER_AUTO);
} else if (normalizer_name_length > 0) {
grn_obj *normalizer;
normalizer = grn_ctx_get(ctx, normalizer_name, normalizer_name_length);
if (!grn_obj_is_normalizer_proc(ctx, normalizer)) {
grn_obj inspected;
GRN_TEXT_INIT(&inspected, 0);
grn_inspect(ctx, &inspected, normalizer);
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"snippet(): not normalizer: <%.*s>",
(int)GRN_TEXT_LEN(&inspected),
GRN_TEXT_VALUE(&inspected));
GRN_OBJ_FIN(ctx, &inspected);
grn_obj_unlink(ctx, normalizer);
goto exit;
}
grn_snip_set_normalizer(ctx, snip, normalizer);
grn_obj_unlink(ctx, normalizer);
}
if (default_open_tag_length == 0 && default_close_tag_length == 0) {
unsigned int n_keyword_sets =
(n_args_without_option - N_REQUIRED_ARGS) / KEYWORD_SET_SIZE;
grn_obj **keyword_set_args = args + N_REQUIRED_ARGS;
for (i = 0; i < n_keyword_sets; i++) {
rc = grn_snip_add_cond(ctx, snip,
GRN_TEXT_VALUE(keyword_set_args[i * KEYWORD_SET_SIZE]),
GRN_TEXT_LEN(keyword_set_args[i * KEYWORD_SET_SIZE]),
GRN_TEXT_VALUE(keyword_set_args[i * KEYWORD_SET_SIZE + 1]),
GRN_TEXT_LEN(keyword_set_args[i * KEYWORD_SET_SIZE + 1]),
GRN_TEXT_VALUE(keyword_set_args[i * KEYWORD_SET_SIZE + 2]),
GRN_TEXT_LEN(keyword_set_args[i * KEYWORD_SET_SIZE + 2]));
}
} else {
unsigned int n_keywords = n_args_without_option - N_REQUIRED_ARGS;
grn_obj **keyword_args = args + N_REQUIRED_ARGS;
for (i = 0; i < n_keywords; i++) {
rc = grn_snip_add_cond(ctx, snip,
GRN_TEXT_VALUE(keyword_args[i]),
GRN_TEXT_LEN(keyword_args[i]),
NULL, 0,
NULL, 0);
}
}
snippets = snippet_exec(ctx, snip, text, user_data,
prefix, prefix_length,
suffix, suffix_length);
}
}
#undef KEYWORD_SET_SIZE
#undef N_REQUIRED_ARGS
exit :
if (!snippets) {
snippets = grn_plugin_proc_alloc(ctx, user_data, GRN_DB_VOID, 0);
}
return snippets;
}
static grn_rc
selector_fuzzy_search(grn_ctx *ctx, grn_obj *table, grn_obj *index,
int nargs, grn_obj **args,
grn_obj *res, grn_operator op)
{
grn_rc rc = GRN_SUCCESS;
grn_obj *target = NULL;
grn_obj *obj;
grn_obj *query;
uint32_t max_distance = 1;
uint32_t prefix_length = 0;
uint32_t prefix_match_size = 0;
uint32_t max_expansion = 0;
int flags = 0;
grn_bool use_sequential_search = GRN_FALSE;
if ((nargs - 1) < 2) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"fuzzy_search(): wrong number of arguments (%d ...)",
nargs - 1);
rc = ctx->rc;
goto exit;
}
obj = args[1];
query = args[2];
if (nargs == 4) {
grn_obj *options = args[3];
grn_hash_cursor *cursor;
void *key;
grn_obj *value;
int key_size;
if (options->header.type != GRN_TABLE_HASH_KEY) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"fuzzy_search(): "
"3rd argument must be object literal: <%.*s>",
(int)GRN_TEXT_LEN(options),
GRN_TEXT_VALUE(options));
goto exit;
}
cursor = grn_hash_cursor_open(ctx, (grn_hash *)options,
NULL, 0, NULL, 0,
0, -1, 0);
if (!cursor) {
GRN_PLUGIN_ERROR(ctx, GRN_NO_MEMORY_AVAILABLE,
"fuzzy_search(): couldn't open cursor");
goto exit;
}
while (grn_hash_cursor_next(ctx, cursor) != GRN_ID_NIL) {
grn_hash_cursor_get_key_value(ctx, cursor, &key, &key_size,
(void **)&value);
if (key_size == 12 && !memcmp(key, "max_distance", 12)) {
max_distance = GRN_UINT32_VALUE(value);
} else if (key_size == 13 && !memcmp(key, "prefix_length", 13)) {
prefix_length = GRN_UINT32_VALUE(value);
} else if (key_size == 13 && !memcmp(key, "max_expansion", 13)) {
max_expansion = GRN_UINT32_VALUE(value);
} else if (key_size == 18 && !memcmp(key, "with_transposition", 18)) {
if (GRN_BOOL_VALUE(value)) {
flags |= GRN_TABLE_FUZZY_SEARCH_WITH_TRANSPOSITION;
}
} else {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"invalid option name: <%.*s>",
key_size, (char *)key);
grn_hash_cursor_close(ctx, cursor);
goto exit;
}
}
grn_hash_cursor_close(ctx, cursor);
}
if (index) {
target = index;
} else {
if (obj->header.type == GRN_COLUMN_INDEX) {
target = obj;
} else {
grn_column_index(ctx, obj, GRN_OP_FUZZY, &target, 1, NULL);
}
}
if (target) {
grn_obj *lexicon;
use_sequential_search = GRN_TRUE;
lexicon = grn_ctx_at(ctx, target->header.domain);
if (lexicon) {
if (lexicon->header.type == GRN_TABLE_PAT_KEY) {
use_sequential_search = GRN_FALSE;
}
grn_obj_unlink(ctx, lexicon);
}
} else {
if (grn_obj_is_key_accessor(ctx, obj) &&
table->header.type == GRN_TABLE_PAT_KEY) {
target = table;
} else {
use_sequential_search = GRN_TRUE;
}
}
if (prefix_length) {
const char *s = GRN_TEXT_VALUE(query);
const char *e = GRN_BULK_CURR(query);
const char *p;
unsigned int cl = 0;
unsigned int length = 0;
for (p = s; p < e && (cl = grn_charlen(ctx, p, e)); p += cl) {
length++;
if (length > prefix_length) {
break;
}
}
prefix_match_size = p - s;
}
if (use_sequential_search) {
rc = sequential_fuzzy_search(ctx, table, obj, query,
max_distance, prefix_match_size,
max_expansion, flags, res, op);
goto exit;
}
if (!target) {
grn_obj inspected;
GRN_TEXT_INIT(&inspected, 0);
grn_inspect(ctx, &inspected, target);
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"fuzzy_search(): "
"column must be COLUMN_INDEX or TABLE_PAT_KEY: <%.*s>",
(int)GRN_TEXT_LEN(&inspected),
GRN_TEXT_VALUE(&inspected));
rc = ctx->rc;
GRN_OBJ_FIN(ctx, &inspected);
} else {
grn_search_optarg options = {0};
options.mode = GRN_OP_FUZZY;
options.fuzzy.prefix_match_size = prefix_match_size;
options.fuzzy.max_distance = max_distance;
options.fuzzy.max_expansion = max_expansion;
options.fuzzy.flags = flags;
grn_obj_search(ctx, target, query, res, op, &options);
}
exit :
return rc;
}
static grn_obj *
func_highlight(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_bool use_html_escape = GRN_FALSE;
grn_obj *keywords;
const char *normalizer_name = "NormalizerAuto";
unsigned int normalizer_name_length = 14;
const char *default_open_tag = NULL;
unsigned int default_open_tag_length = 0;
const char *default_close_tag = NULL;
unsigned int default_close_tag_length = 0;
grn_obj *end_arg = args[nargs - 1];
int n_args_without_option = nargs;
if (end_arg->header.type == GRN_TABLE_HASH_KEY) {
grn_obj *options = end_arg;
grn_hash_cursor *cursor;
void *key;
grn_obj *value;
int key_size;
n_args_without_option--;
cursor = grn_hash_cursor_open(ctx, (grn_hash *)options,
NULL, 0, NULL, 0,
0, -1, 0);
if (!cursor) {
GRN_PLUGIN_ERROR(ctx, GRN_NO_MEMORY_AVAILABLE,
"highlight(): couldn't open cursor");
goto exit;
}
while (grn_hash_cursor_next(ctx, cursor) != GRN_ID_NIL) {
grn_hash_cursor_get_key_value(ctx, cursor, &key, &key_size,
(void **)&value);
if (key_size == 10 && !memcmp(key, "normalizer", 10)) {
normalizer_name = GRN_TEXT_VALUE(value);
normalizer_name_length = GRN_TEXT_LEN(value);
} else if (key_size == 11 && !memcmp(key, "html_escape", 11)) {
if (GRN_BOOL_VALUE(value)) {
use_html_escape = GRN_TRUE;
}
} else if (key_size == 16 && !memcmp(key, "default_open_tag", 16)) {
default_open_tag = GRN_TEXT_VALUE(value);
default_open_tag_length = GRN_TEXT_LEN(value);
} else if (key_size == 17 && !memcmp(key, "default_close_tag", 17)) {
default_close_tag = GRN_TEXT_VALUE(value);
default_close_tag_length = GRN_TEXT_LEN(value);
} else {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT, "invalid option name: <%.*s>",
key_size, (char *)key);
grn_hash_cursor_close(ctx, cursor);
goto exit;
}
}
grn_hash_cursor_close(ctx, cursor);
}
keywords =
func_highlight_create_keywords_table(ctx, user_data,
normalizer_name,
normalizer_name_length);
if (keywords) {
grn_obj **keyword_args = args + N_REQUIRED_ARGS;
unsigned int n_keyword_args = n_args_without_option - N_REQUIRED_ARGS;
if (default_open_tag_length == 0 && default_close_tag_length == 0) {
highlighted = highlight_keyword_sets(ctx, user_data,
keyword_args, n_keyword_args,
string, keywords, use_html_escape);
} else {
unsigned int i;
for (i = 0; i < n_keyword_args; i++) {
grn_table_add(ctx, keywords,
GRN_TEXT_VALUE(keyword_args[i]),
GRN_TEXT_LEN(keyword_args[i]),
NULL);
}
highlighted = highlight_keywords(ctx, user_data,
string, keywords, use_html_escape,
default_open_tag, default_open_tag_length,
default_close_tag, default_close_tag_length);
}
}
}
#undef N_REQUIRED_ARGS
exit :
if (!highlighted) {
highlighted = grn_plugin_proc_alloc(ctx, user_data, GRN_DB_VOID, 0);
}
return highlighted;
}
