diff options
Diffstat (limited to 'storage/mroonga/vendor/groonga/lib/mrb')
160 files changed, 13459 insertions, 0 deletions
diff --git a/storage/mroonga/vendor/groonga/lib/mrb/Makefile.am b/storage/mroonga/vendor/groonga/lib/mrb/Makefile.am new file mode 100644 index 00000000..0e4db634 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/Makefile.am @@ -0,0 +1,21 @@ +SUBDIRS = \ + scripts + +AM_CPPFLAGS = \ + -I$(top_builddir) \ + -I$(top_srcdir)/include \ + -I$(top_srcdir)/lib \ + $(MRUBY_CPPFLAGS) + +AM_CFLAGS = \ + $(NO_STRICT_ALIASING_CFLAGS) \ + $(COVERAGE_CFLAGS) \ + $(GRN_CFLAGS) \ + $(MESSAGE_PACK_CFLAGS) \ + $(MRUBY_CFLAGS) + +noinst_LTLIBRARIES = libgrnmrb.la + +include sources.am + +CLEANFILES = *.gcno *.gcda diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_accessor.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_accessor.c new file mode 100644 index 00000000..ef341d3a --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_accessor.c @@ -0,0 +1,121 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2013-2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/variable.h> +#include <mruby/data.h> + +#include "../grn_db.h" +#include "mrb_ctx.h" +#include "mrb_accessor.h" +#include "mrb_converter.h" + +static struct mrb_data_type mrb_grn_accessor_type = { + "Groonga::Accessor", + NULL +}; + +static mrb_value +mrb_grn_accessor_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_accessor_ptr; + + mrb_get_args(mrb, "o", &mrb_accessor_ptr); + DATA_TYPE(self) = &mrb_grn_accessor_type; + DATA_PTR(self) = mrb_cptr(mrb_accessor_ptr); + return self; +} + +static mrb_value +mrb_grn_accessor_next(mrb_state *mrb, mrb_value self) +{ + grn_accessor *accessor; + + accessor = DATA_PTR(self); + return grn_mrb_value_from_grn_obj(mrb, (grn_obj *)(accessor->next)); +} + +static mrb_value +mrb_grn_accessor_have_next_p(mrb_state *mrb, mrb_value self) +{ + grn_accessor *accessor; + + accessor = DATA_PTR(self); + return mrb_bool_value(accessor->next != NULL); +} + +static mrb_value +mrb_grn_accessor_object(mrb_state *mrb, mrb_value self) +{ + grn_accessor *accessor; + + accessor = DATA_PTR(self); + return grn_mrb_value_from_grn_obj(mrb, accessor->obj); +} + +static mrb_value +mrb_grn_accessor_name(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_rc rc; + grn_obj *accessor; + grn_obj name; + mrb_value mrb_name; + + accessor = DATA_PTR(self); + GRN_TEXT_INIT(&name, 0); + rc = grn_column_name_(ctx, accessor, &name); + if (rc == GRN_SUCCESS) { + mrb_name = mrb_str_new(mrb, GRN_TEXT_VALUE(&name), GRN_TEXT_LEN(&name)); + GRN_OBJ_FIN(ctx, &name); + } else { + mrb_name = mrb_nil_value(); + GRN_OBJ_FIN(ctx, &name); + grn_mrb_ctx_check(mrb); + } + + return mrb_name; +} + +void +grn_mrb_accessor_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "Accessor", data->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + mrb_define_method(mrb, klass, "initialize", + mrb_grn_accessor_initialize, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "next", + mrb_grn_accessor_next, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "have_next?", + mrb_grn_accessor_have_next_p, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "object", + mrb_grn_accessor_object, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "name", + mrb_grn_accessor_name, MRB_ARGS_NONE()); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_accessor.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_accessor.h new file mode 100644 index 00000000..4443f7d5 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_accessor.h @@ -0,0 +1,33 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2013-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" +#include "../grn_db.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_accessor_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_array.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_array.c new file mode 100644 index 00000000..2d1e84cc --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_array.c @@ -0,0 +1,92 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> + +#include "mrb_ctx.h" +#include "mrb_array.h" + +static struct mrb_data_type mrb_grn_array_type = { + "Groonga::Array", + NULL +}; + +static mrb_value +mrb_grn_array_class_create(mrb_state *mrb, mrb_value klass) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + char *name; + mrb_int name_length; + const char *path = NULL; + mrb_value mrb_value_type; + grn_obj *value_type = NULL; + grn_obj *array; + + mrb_get_args(mrb, "so", &name, &name_length, &mrb_value_type); + if (!mrb_nil_p(mrb_value_type)) { + value_type = DATA_PTR(mrb_value_type); + } + + array = grn_table_create(ctx, + name, name_length, + path, + GRN_TABLE_NO_KEY, + NULL, + value_type); + grn_mrb_ctx_check(mrb); + + return mrb_funcall(mrb, klass, "new", 1, mrb_cptr_value(mrb, array)); +} + +static mrb_value +mrb_grn_array_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_array_ptr; + + mrb_get_args(mrb, "o", &mrb_array_ptr); + DATA_TYPE(self) = &mrb_grn_array_type; + DATA_PTR(self) = mrb_cptr(mrb_array_ptr); + return self; +} + +void +grn_mrb_array_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *table_class; + struct RClass *klass; + + table_class = mrb_class_get_under(mrb, module, "Table"); + klass = mrb_define_class_under(mrb, module, "Array", table_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_class_method(mrb, klass, "create", + mrb_grn_array_class_create, + MRB_ARGS_REQ(2)); + + mrb_define_method(mrb, klass, "initialize", + mrb_grn_array_initialize, MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_array.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_array.h new file mode 100644 index 00000000..77ef94d5 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_array.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_array_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_bulk.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_bulk.c new file mode 100644 index 00000000..b3c47795 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_bulk.c @@ -0,0 +1,373 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" +#include <string.h> + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/variable.h> +#include <mruby/data.h> +#include <mruby/numeric.h> +#include <mruby/string.h> + +#include "../grn_db.h" +#include "mrb_bulk.h" +#include "mrb_object.h" + +static struct mrb_data_type mrb_grn_bulk_type = { + "Groonga::Bulk", + NULL +}; + +grn_obj * +grn_mrb_value_to_bulk(mrb_state *mrb, mrb_value mrb_value_, grn_obj *bulk) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + switch (mrb_type(mrb_value_)) { + case MRB_TT_FALSE : + if (mrb_nil_p(mrb_value_)) { + grn_obj_reinit(ctx, bulk, GRN_DB_VOID, 0); + } else { + grn_obj_reinit(ctx, bulk, GRN_DB_BOOL, 0); + GRN_BOOL_SET(ctx, bulk, GRN_FALSE); + } + break; + case MRB_TT_TRUE : + grn_obj_reinit(ctx, bulk, GRN_DB_BOOL, 0); + GRN_BOOL_SET(ctx, bulk, GRN_TRUE); + break; + case MRB_TT_FIXNUM : + grn_obj_reinit(ctx, bulk, GRN_DB_INT64, 0); + GRN_INT64_SET(ctx, bulk, mrb_fixnum(mrb_value_)); + break; + case MRB_TT_SYMBOL : + { + const char *name; + mrb_int name_length; + + grn_obj_reinit(ctx, bulk, GRN_DB_TEXT, 0); + name = mrb_sym2name_len(mrb, mrb_symbol(mrb_value_), &name_length); + GRN_TEXT_SET(ctx, bulk, name, name_length); + } + break; + case MRB_TT_FLOAT : + grn_obj_reinit(ctx, bulk, GRN_DB_FLOAT, 0); + GRN_FLOAT_SET(ctx, bulk, mrb_float(mrb_value_)); + break; + case MRB_TT_STRING : + grn_obj_reinit(ctx, bulk, GRN_DB_TEXT, + bulk->header.impl_flags & GRN_OBJ_DO_SHALLOW_COPY); + GRN_TEXT_SET(ctx, bulk, RSTRING_PTR(mrb_value_), RSTRING_LEN(mrb_value_)); + break; + default : + { + struct RClass *klass; + + klass = mrb_class(mrb, mrb_value_); + if (klass == ctx->impl->mrb.builtin.time_class) { + mrb_value mrb_sec; + mrb_value mrb_usec; + + mrb_sec = mrb_funcall(mrb, mrb_value_, "to_i", 0); + mrb_usec = mrb_funcall(mrb, mrb_value_, "usec", 0); + grn_obj_reinit(ctx, bulk, GRN_DB_TIME, 0); + GRN_TIME_SET(ctx, bulk, + GRN_TIME_PACK(mrb_fixnum(mrb_sec), mrb_fixnum(mrb_usec))); + } else { + mrb_raisef(mrb, E_ARGUMENT_ERROR, + "unsupported object to convert to bulk: %S", + mrb_value_); + } + } + break; + } + + return bulk; +} + +mrb_value +grn_mrb_value_from_bulk(mrb_state *mrb, grn_obj *bulk) +{ + mrb_value mrb_value_; + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + if (!bulk) { + return mrb_nil_value(); + } + + switch (bulk->header.domain) { + case GRN_DB_BOOL : + { + grn_bool value; + value = GRN_BOOL_VALUE(bulk); + mrb_value_ = mrb_bool_value(value); + } + break; + case GRN_DB_INT8 : + { + int8_t value; + value = GRN_INT8_VALUE(bulk); + mrb_value_ = mrb_fixnum_value(value); + } + break; + case GRN_DB_UINT8 : + { + uint8_t value; + value = GRN_UINT8_VALUE(bulk); + mrb_value_ = mrb_fixnum_value(value); + } + break; + case GRN_DB_INT16 : + { + int16_t value; + value = GRN_INT16_VALUE(bulk); + mrb_value_ = mrb_fixnum_value(value); + } + break; + case GRN_DB_UINT16 : + { + uint16_t value; + value = GRN_UINT16_VALUE(bulk); + mrb_value_ = mrb_fixnum_value(value); + } + break; + case GRN_DB_INT32 : + { + int32_t value; + value = GRN_INT32_VALUE(bulk); + mrb_value_ = mrb_fixnum_value(value); + } + break; + case GRN_DB_UINT32 : + { + int64_t value; + value = GRN_UINT32_VALUE(bulk); + if (FIXABLE(value)) { + mrb_value_ = mrb_fixnum_value(value); + } else { + mrb_value_ = mrb_float_value(mrb, value); + } + } + break; + case GRN_DB_INT64 : + { + int64_t value; + value = GRN_INT64_VALUE(bulk); + if (FIXABLE(value)) { + mrb_value_ = mrb_fixnum_value(value); + } else { + mrb_value_ = mrb_float_value(mrb, value); + } + } + break; + case GRN_DB_UINT64 : + { + uint64_t value; + value = GRN_UINT64_VALUE(bulk); + if (FIXABLE(value)) { + mrb_value_ = mrb_fixnum_value(value); + } else { + mrb_value_ = mrb_float_value(mrb, value); + } + } + break; + case GRN_DB_FLOAT : + { + double value; + value = GRN_FLOAT_VALUE(bulk); + mrb_value_ = mrb_float_value(mrb, value); + } + break; + case GRN_DB_TIME : + { + int64_t value; + int64_t sec; + int32_t usec; + mrb_value mrb_sec; + + value = GRN_TIME_VALUE(bulk); + GRN_TIME_UNPACK(value, sec, usec); + if (sec > MRB_INT_MAX) { + mrb_sec = mrb_float_value(mrb, sec); + } else { + mrb_sec = mrb_fixnum_value(sec); + } + mrb_value_ = mrb_funcall(mrb, + mrb_obj_value(ctx->impl->mrb.builtin.time_class), + "at", + 2, + mrb_sec, + mrb_fixnum_value(usec)); + } + break; + case GRN_DB_SHORT_TEXT : + case GRN_DB_TEXT : + case GRN_DB_LONG_TEXT : + mrb_value_ = mrb_str_new(mrb, + GRN_TEXT_VALUE(bulk), + GRN_TEXT_LEN(bulk)); + break; + default : + { + grn_obj *domain; + grn_bool is_record = GRN_FALSE; + + domain = grn_ctx_at(ctx, bulk->header.domain); + if (domain) { + switch (domain->header.type) { + case GRN_TABLE_HASH_KEY : + case GRN_TABLE_PAT_KEY : + case GRN_TABLE_DAT_KEY : + case GRN_TABLE_NO_KEY : + is_record = GRN_TRUE; + break; + default : + break; + } + } + + if (is_record) { + mrb_value_ = mrb_fixnum_value(GRN_RECORD_VALUE(bulk)); + grn_obj_unlink(ctx, domain); + } else { +#define MESSAGE_SIZE 4096 + char message[MESSAGE_SIZE]; + char domain_name[GRN_TABLE_MAX_KEY_SIZE]; + int domain_name_size; + + if (domain) { + domain_name_size = grn_obj_name(ctx, domain, + domain_name, GRN_TABLE_MAX_KEY_SIZE); + grn_obj_unlink(ctx, domain); + } else { + grn_strcpy(domain_name, GRN_TABLE_MAX_KEY_SIZE, "unknown"); + domain_name_size = strlen(domain_name); + } + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "unsupported bulk value type: <%d>(%.*s)", + bulk->header.domain, + domain_name_size, + domain_name); + mrb_raise(mrb, E_RANGE_ERROR, message); + } +#undef MESSAGE_SIZE + } + break; + } + + return mrb_value_; +} + +grn_bool +grn_mrb_bulk_cast(mrb_state *mrb, grn_obj *from, grn_obj *to, grn_id domain_id) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_rc rc; + + grn_obj_reinit(ctx, to, domain_id, 0); + rc = grn_obj_cast(ctx, from, to, GRN_FALSE); + return rc == GRN_SUCCESS; +} + +static mrb_value +mrb_grn_bulk_s_is_true(mrb_state *mrb, mrb_value klass) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_value_; + grn_obj bulk; + grn_bool is_true; + + mrb_get_args(mrb, "o", &mrb_value_); + + GRN_TEXT_INIT(&bulk, GRN_OBJ_DO_SHALLOW_COPY); + grn_mrb_value_to_bulk(mrb, mrb_value_, &bulk); + is_true = grn_obj_is_true(ctx, &bulk); + GRN_OBJ_FIN(ctx, &bulk); + + return mrb_bool_value(is_true); +} + +static mrb_value +mrb_grn_bulk_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_bulk_ptr; + + mrb_get_args(mrb, "o", &mrb_bulk_ptr); + DATA_TYPE(self) = &mrb_grn_bulk_type; + DATA_PTR(self) = mrb_cptr(mrb_bulk_ptr); + return self; +} + +static mrb_value +mrb_grn_bulk_get_domain(mrb_state *mrb, mrb_value self) +{ + grn_obj *bulk; + + bulk = DATA_PTR(self); + return mrb_fixnum_value(bulk->header.domain); +} + +static mrb_value +mrb_grn_bulk_get_value(mrb_state *mrb, mrb_value self) +{ + return grn_mrb_value_from_bulk(mrb, DATA_PTR(self)); +} + +static mrb_value +mrb_grn_bulk_equal(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_other; + + mrb_get_args(mrb, "o", &mrb_other); + + if (!mrb_obj_is_kind_of(mrb, mrb_other, mrb_class(mrb, self))) { + return mrb_false_value(); + } + + return mrb_bool_value(DATA_PTR(self) == DATA_PTR(mrb_other)); +} + +void +grn_mrb_bulk_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "Bulk", mrb->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_singleton_method(mrb, (struct RObject *)klass, "true?", + mrb_grn_bulk_s_is_true, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "initialize", + mrb_grn_bulk_initialize, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "domain", + mrb_grn_bulk_get_domain, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "value", + mrb_grn_bulk_get_value, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "==", + mrb_grn_bulk_equal, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "inspect", + grn_mrb_object_inspect, MRB_ARGS_NONE()); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_bulk.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_bulk.h new file mode 100644 index 00000000..f8f14b5f --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_bulk.h @@ -0,0 +1,41 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" +#include "../grn_db.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_bulk_init(grn_ctx *ctx); + +mrb_value grn_mrb_value_from_bulk(mrb_state *mrb, grn_obj *bulk); +grn_obj *grn_mrb_value_to_bulk(mrb_state *mrb, + mrb_value mrb_value_, + grn_obj *bulk); +grn_bool grn_mrb_bulk_cast(mrb_state *mrb, + grn_obj *from, + grn_obj *to, + grn_id domain_id); + +#ifdef __cplusplus +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_cache.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_cache.c new file mode 100644 index 00000000..843350f9 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_cache.c @@ -0,0 +1,130 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> + +#include "../grn_db.h" +#include "../grn_cache.h" +#include "mrb_bulk.h" +#include "mrb_cache.h" + +static struct mrb_data_type mrb_grn_cache_type = { + "Groonga::Cache", + NULL +}; + +static mrb_value +mrb_grn_cache_class_current(mrb_state *mrb, mrb_value klass) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_cache *cache; + mrb_value mrb_cache; + + cache = grn_cache_current_get(ctx); + mrb_cache = mrb_funcall(mrb, klass, "new", 1, mrb_cptr_value(mrb, cache)); + + return mrb_cache; +} + +static mrb_value +mrb_grn_cache_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_cache_ptr; + + mrb_get_args(mrb, "o", &mrb_cache_ptr); + DATA_TYPE(self) = &mrb_grn_cache_type; + DATA_PTR(self) = mrb_cptr(mrb_cache_ptr); + return self; +} + +static mrb_value +mrb_grn_cache_fetch(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_cache *cache; + char *key; + mrb_int key_size; + grn_rc rc; + grn_obj cache_value; + mrb_value mrb_cache_value; + + cache = DATA_PTR(self); + mrb_get_args(mrb, "s", &key, &key_size); + + GRN_TEXT_INIT(&cache_value, 0); + rc = grn_cache_fetch(ctx, cache, key, key_size, &cache_value); + if (rc == GRN_SUCCESS) { + mrb_cache_value = grn_mrb_value_from_bulk(mrb, &cache_value); + } else { + mrb_cache_value = mrb_nil_value(); + } + GRN_OBJ_FIN(ctx, &cache_value); + + return mrb_cache_value; +} + +static mrb_value +mrb_grn_cache_update(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_cache *cache; + char *key; + mrb_int key_size; + char *value; + mrb_int value_size; + grn_obj value_buffer; + + cache = DATA_PTR(self); + mrb_get_args(mrb, "ss", &key, &key_size, &value, &value_size); + + GRN_TEXT_INIT(&value_buffer, GRN_OBJ_DO_SHALLOW_COPY); + GRN_TEXT_SET(ctx, &value_buffer, value, value_size); + grn_cache_update(ctx, cache, key, key_size, &value_buffer); + GRN_OBJ_FIN(ctx, &value_buffer); + + return mrb_nil_value(); +} + +void +grn_mrb_cache_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "Cache", mrb->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_class_method(mrb, klass, "current", + mrb_grn_cache_class_current, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "initialize", + mrb_grn_cache_initialize, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "fetch", + mrb_grn_cache_fetch, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "update", + mrb_grn_cache_update, MRB_ARGS_REQ(2)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_cache.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_cache.h new file mode 100644 index 00000000..14628ba8 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_cache.h @@ -0,0 +1,33 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" +#include "../grn_db.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_cache_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_column.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_column.c new file mode 100644 index 00000000..b36a42bf --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_column.c @@ -0,0 +1,173 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2013-2017 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" +#include "../grn_proc.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> + +#include "mrb_ctx.h" +#include "mrb_column.h" +#include "mrb_bulk.h" +#include "mrb_converter.h" + +static mrb_value +mrb_grn_column_class_parse_flags(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + char *error_message_tag; + char *flags_text; + mrb_int flags_text_size; + grn_column_flags flags; + + mrb_get_args(mrb, "zs", &error_message_tag, &flags_text, &flags_text_size); + + flags = grn_proc_column_parse_flags(ctx, + error_message_tag, + flags_text, + flags_text + flags_text_size); + return mrb_fixnum_value(flags); +} + +static mrb_value +mrb_grn_column_array_reference(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *column; + mrb_int record_id; + grn_obj *column_value; + + column = DATA_PTR(self); + mrb_get_args(mrb, "i", &record_id); + + column_value = grn_obj_get_value(ctx, column, record_id, NULL); + return grn_mrb_value_from_grn_obj(mrb, column_value); +} + +static mrb_value +mrb_grn_column_is_scalar(mrb_state *mrb, mrb_value self) +{ + grn_obj *column; + grn_obj_flags column_type; + + column = DATA_PTR(self); + column_type = (column->header.flags & GRN_OBJ_COLUMN_TYPE_MASK); + + return mrb_bool_value(column_type == GRN_OBJ_COLUMN_SCALAR); +} + +static mrb_value +mrb_grn_column_is_vector(mrb_state *mrb, mrb_value self) +{ + grn_obj *column; + grn_obj_flags column_type; + + column = DATA_PTR(self); + column_type = (column->header.flags & GRN_OBJ_COLUMN_TYPE_MASK); + + return mrb_bool_value(column_type == GRN_OBJ_COLUMN_VECTOR); +} + +static mrb_value +mrb_grn_column_is_index(mrb_state *mrb, mrb_value self) +{ + grn_obj *column; + grn_obj_flags column_type; + + column = DATA_PTR(self); + column_type = (column->header.flags & GRN_OBJ_COLUMN_TYPE_MASK); + + return mrb_bool_value(column_type == GRN_OBJ_COLUMN_INDEX); +} + +static mrb_value +mrb_grn_column_is_locked(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + unsigned int is_locked; + + is_locked = grn_obj_is_locked(ctx, DATA_PTR(self)); + grn_mrb_ctx_check(mrb); + + return mrb_bool_value(is_locked != 0); +} + +static mrb_value +mrb_grn_column_get_table(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *table; + + table = grn_column_table(ctx, DATA_PTR(self)); + if (!table) { + return mrb_nil_value(); + } + + return grn_mrb_value_from_grn_obj(mrb, table); +} + +static mrb_value +mrb_grn_column_truncate(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *column; + + column = DATA_PTR(self); + grn_column_truncate(ctx, column); + grn_mrb_ctx_check(mrb); + return mrb_nil_value(); +} + +void +grn_mrb_column_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *object_class = data->object_class; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "Column", object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_class_method(mrb, klass, "parse_flags", + mrb_grn_column_class_parse_flags, MRB_ARGS_REQ(2)); + + mrb_define_method(mrb, klass, "[]", + mrb_grn_column_array_reference, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "scalar?", + mrb_grn_column_is_scalar, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "vector?", + mrb_grn_column_is_vector, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "index?", + mrb_grn_column_is_index, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "locked?", + mrb_grn_column_is_locked, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "table", + mrb_grn_column_get_table, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "truncate", + mrb_grn_column_truncate, MRB_ARGS_NONE()); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_column.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_column.h new file mode 100644 index 00000000..110b294c --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_column.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2013-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_column_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_command.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_command.c new file mode 100644 index 00000000..0c9c7481 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_command.c @@ -0,0 +1,196 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" +#include <groonga/command.h> + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> +#include <mruby/value.h> +#include <mruby/string.h> + +#include "mrb_ctx.h" +#include "mrb_command.h" + +static struct mrb_data_type mrb_grn_command_type = { + "Groonga::Command", + NULL +}; + +mrb_value +mrb_grn_command_instantiate(grn_ctx *ctx, grn_obj *command) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + char name[GRN_TABLE_MAX_KEY_SIZE]; + int name_size; + mrb_value mrb_name; + struct RClass *command_class; + struct RClass *target_command_class; + mrb_value mrb_target_command_class; + mrb_value mrb_arguments[1]; + + name_size = grn_obj_name(ctx, command, name, GRN_TABLE_MAX_KEY_SIZE); + mrb_name = mrb_str_new(mrb, name, name_size); + + command_class = mrb_class_get_under(mrb, module, "Command"); + mrb_target_command_class = mrb_funcall(mrb, + mrb_obj_value(command_class), + "find_class", 1, mrb_name); + if (mrb_nil_p(mrb_target_command_class)) { + target_command_class = command_class; + } else { + target_command_class = mrb_class_ptr(mrb_target_command_class); + } + mrb_arguments[0] = mrb_cptr_value(mrb, command); + return mrb_obj_new(mrb, target_command_class, 1, mrb_arguments); +} + +static void +mrb_grn_command_run_wrapper(grn_ctx *ctx, + grn_obj *command, + grn_command_input *input, + void *user_data) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + int arena_index; + mrb_value mrb_command; + mrb_value mrb_input; + + arena_index = mrb_gc_arena_save(mrb); + mrb_command = mrb_grn_command_instantiate(ctx, command); + { + struct RClass *command_input_class; + mrb_value mrb_arguments[1]; + command_input_class = mrb_class_get_under(mrb, module, "CommandInput"); + mrb_arguments[0] = mrb_cptr_value(mrb, input); + mrb_input = mrb_obj_new(mrb, command_input_class, 1, mrb_arguments); + } + mrb_funcall(mrb, mrb_command, "run_internal", 1, mrb_input); + if (ctx->rc == GRN_SUCCESS && mrb->exc) { + char name[GRN_TABLE_MAX_KEY_SIZE]; + int name_size; + name_size = grn_obj_name(ctx, command, name, GRN_TABLE_MAX_KEY_SIZE); + if (mrb->exc == mrb->nomem_err) { + MERR("failed to allocate memory in mruby: <%.*s>", + name_size, name); + } else { + mrb_value reason; + reason = mrb_funcall(mrb, mrb_obj_value(mrb->exc), "inspect", 0); + ERR(GRN_COMMAND_ERROR, + "failed to run command: <%*.s>: %.*s", + name_size, name, + (int)RSTRING_LEN(reason), RSTRING_PTR(reason)); + } + } + mrb_gc_arena_restore(mrb, arena_index); +} + +static mrb_value +mrb_grn_command_class_register(mrb_state *mrb, mrb_value klass) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_name; + mrb_value *mrb_arguments; + mrb_int n_arguments; + + mrb_get_args(mrb, "Sa", &mrb_name, &mrb_arguments, &n_arguments); + + { + grn_expr_var *vars; + mrb_int i; + + for (i = 0; i < n_arguments; i++) { + mrb_arguments[i] = mrb_convert_type(mrb, mrb_arguments[i], + MRB_TT_STRING, "String", "to_str"); + } + vars = GRN_MALLOCN(grn_expr_var, n_arguments); + for (i = 0; i < n_arguments; i++) { + mrb_value mrb_argument = mrb_arguments[i]; + grn_expr_var *var = &vars[i]; + var->name = RSTRING_PTR(mrb_argument); + var->name_size = RSTRING_LEN(mrb_argument); + GRN_TEXT_INIT(&(var->value), 0); + } + + grn_command_register(ctx, + RSTRING_PTR(mrb_name), + RSTRING_LEN(mrb_name), + mrb_grn_command_run_wrapper, + vars, + n_arguments, + NULL); + + for (i = 0; i < n_arguments; i++) { + grn_expr_var *var = &vars[i]; + GRN_OBJ_FIN(ctx, &(var->value)); + } + GRN_FREE(vars); + } + + grn_mrb_ctx_check(mrb); + + { + grn_mrb_data *data = &(ctx->impl->mrb); + struct RClass *command_class; + command_class = mrb_class_get_under(mrb, data->module, "Command"); + mrb_funcall(mrb, + mrb_obj_value(command_class), + "register_class", 2, mrb_name, klass); + } + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_command_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_command_ptr; + + mrb_get_args(mrb, "o", &mrb_command_ptr); + DATA_TYPE(self) = &mrb_grn_command_type; + DATA_PTR(self) = mrb_cptr(mrb_command_ptr); + return self; +} + +void +grn_mrb_command_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *procedure_class; + struct RClass *klass; + + procedure_class = mrb_class_get_under(mrb, module, "Procedure"); + klass = mrb_define_class_under(mrb, module, "Command", procedure_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_class_method(mrb, klass, "register", + mrb_grn_command_class_register, + MRB_ARGS_REQ(2)); + + mrb_define_method(mrb, klass, "initialize", + mrb_grn_command_initialize, MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_command.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_command.h new file mode 100644 index 00000000..1872ca9f --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_command.h @@ -0,0 +1,34 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_command_init(grn_ctx *ctx); + +mrb_value grn_mrb_command_instantiate(grn_ctx *ctx, grn_obj *command); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_command_input.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_command_input.c new file mode 100644 index 00000000..36570fd1 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_command_input.c @@ -0,0 +1,139 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" +#include <groonga/command.h> + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> +#include <mruby/value.h> +#include <mruby/string.h> + +#include "mrb_ctx.h" +#include "mrb_converter.h" +#include "mrb_command_input.h" + +static struct mrb_data_type mrb_grn_command_input_type = { + "Groonga::CommandInput", + NULL +}; + +static mrb_value +mrb_grn_command_input_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_command_input_ptr; + + mrb_get_args(mrb, "o", &mrb_command_input_ptr); + DATA_TYPE(self) = &mrb_grn_command_input_type; + DATA_PTR(self) = mrb_cptr(mrb_command_input_ptr); + return self; +} + +static mrb_value +mrb_grn_command_input_array_reference(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_command_input *input; + mrb_value mrb_key_or_offset; + grn_obj *argument; + + input = DATA_PTR(self); + mrb_get_args(mrb, "o", &mrb_key_or_offset); + + switch (mrb_type(mrb_key_or_offset)) { + case MRB_TT_FIXNUM : + { + mrb_int offset = mrb_fixnum(mrb_key_or_offset); + argument = grn_command_input_at(ctx, input, offset); + } + break; + case MRB_TT_SYMBOL : + { + mrb_sym mrb_key_symbol; + const char *key; + mrb_int key_length; + + mrb_key_symbol = mrb_symbol(mrb_key_or_offset); + key = mrb_sym2name_len(mrb, mrb_key_symbol, &key_length); + argument = grn_command_input_get(ctx, input, key, key_length); + } + break; + case MRB_TT_STRING : + { + mrb_value mrb_key = mrb_key_or_offset; + argument = grn_command_input_get(ctx, input, + RSTRING_PTR(mrb_key), + RSTRING_LEN(mrb_key)); + } + break; + default : + mrb_raisef(mrb, E_ARGUMENT_ERROR, + "must be offset (as integer) or key (as symbol or string): %S", + mrb_key_or_offset); + break; + } + + if (!argument) { + return mrb_nil_value(); + } + + if (GRN_TEXT_LEN(argument) == 0) { + return mrb_nil_value(); + } + + return mrb_str_new_static(mrb, + GRN_TEXT_VALUE(argument), + GRN_TEXT_LEN(argument)); +} + +static mrb_value +mrb_grn_command_input_get_arguments(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_command_input *input; + grn_obj *arguments; + + input = DATA_PTR(self); + arguments = grn_command_input_get_arguments(ctx, input); + + return grn_mrb_value_from_grn_obj(mrb, arguments); +} + +void +grn_mrb_command_input_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "CommandInput", mrb->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_method(mrb, klass, "initialize", + mrb_grn_command_input_initialize, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "[]", + mrb_grn_command_input_array_reference, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "arguments", + mrb_grn_command_input_get_arguments, MRB_ARGS_NONE()); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_command_input.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_command_input.h new file mode 100644 index 00000000..7766d819 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_command_input.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_command_input_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_command_version.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_command_version.c new file mode 100644 index 00000000..8c7c0789 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_command_version.c @@ -0,0 +1,41 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> + +#include "mrb_command_version.h" + +void +grn_mrb_command_version_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *command_version_module; + + command_version_module = mrb_define_module_under(mrb, module, + "CommandVersion"); + + mrb_define_const(mrb, command_version_module, "DEFAULT", + mrb_fixnum_value(GRN_COMMAND_VERSION_DEFAULT)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_command_version.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_command_version.h new file mode 100644 index 00000000..167b7cb9 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_command_version.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_command_version_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_config.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_config.c new file mode 100644 index 00000000..52c722a4 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_config.c @@ -0,0 +1,90 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/string.h> + +#include "../grn_mrb.h" +#include "mrb_config.h" +#include "mrb_ctx.h" + +static mrb_value +config_array_reference(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + char *key; + mrb_int key_size; + const char *value; + uint32_t value_size; + grn_rc rc; + + mrb_get_args(mrb, "s", &key, &key_size); + + rc = grn_config_get(ctx, key, key_size, &value, &value_size); + if (rc != GRN_SUCCESS) { + grn_mrb_ctx_check(mrb); + } + + if (!value) { + return mrb_nil_value(); + } else { + return mrb_str_new(mrb, value, value_size); + } +} + +static mrb_value +config_array_set(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + char *key; + mrb_int key_size; + mrb_value mrb_value_; + grn_rc rc; + + mrb_get_args(mrb, "sS", &key, &key_size, &mrb_value_); + + rc = grn_config_set(ctx, + key, key_size, + RSTRING_PTR(mrb_value_), RSTRING_LEN(mrb_value_)); + if (rc != GRN_SUCCESS) { + grn_mrb_ctx_check(mrb); + } + + return mrb_value_; +} + +void +grn_mrb_config_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module; + + module = mrb_define_module_under(mrb, data->module, "Config"); + + mrb_define_singleton_method(mrb, (struct RObject *)module, + "[]", config_array_reference, + MRB_ARGS_REQ(1)); + mrb_define_singleton_method(mrb, (struct RObject *)module, + "[]=", config_array_set, + MRB_ARGS_REQ(2)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_config.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_config.h new file mode 100644 index 00000000..a460db09 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_config.h @@ -0,0 +1,31 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_config_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_content_type.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_content_type.c new file mode 100644 index 00000000..1010a429 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_content_type.c @@ -0,0 +1,49 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> + +#include "mrb_ctx.h" +#include "mrb_content_type.h" + +void +grn_mrb_content_type_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module; + + module = mrb_define_module_under(mrb, data->module, "ContentType"); + + mrb_define_const(mrb, module, "NONE", + mrb_fixnum_value(GRN_CONTENT_NONE)); + mrb_define_const(mrb, module, "TSV", + mrb_fixnum_value(GRN_CONTENT_TSV)); + mrb_define_const(mrb, module, "JSON", + mrb_fixnum_value(GRN_CONTENT_JSON)); + mrb_define_const(mrb, module, "XML", + mrb_fixnum_value(GRN_CONTENT_XML)); + mrb_define_const(mrb, module, "MSGPACK", + mrb_fixnum_value(GRN_CONTENT_MSGPACK)); + mrb_define_const(mrb, module, "GROONGA_COMMAND_LIST", + mrb_fixnum_value(GRN_CONTENT_GROONGA_COMMAND_LIST)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_content_type.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_content_type.h new file mode 100644 index 00000000..094f3df0 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_content_type.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_content_type_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_converter.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_converter.c new file mode 100644 index 00000000..147c47a3 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_converter.c @@ -0,0 +1,350 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2013-2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" +#include "../grn_db.h" +#include <string.h> + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> +#include <mruby/string.h> + +#include "mrb_converter.h" +#include "mrb_bulk.h" + +void +grn_mrb_value_to_raw_data_buffer_init(mrb_state *mrb, + grn_mrb_value_to_raw_data_buffer *buffer) +{ + GRN_VOID_INIT(&(buffer->from)); + GRN_VOID_INIT(&(buffer->to)); +} + +void +grn_mrb_value_to_raw_data_buffer_fin(mrb_state *mrb, + grn_mrb_value_to_raw_data_buffer *buffer) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + GRN_OBJ_FIN(ctx, &(buffer->from)); + GRN_OBJ_FIN(ctx, &(buffer->to)); +} + +void +grn_mrb_value_to_raw_data(mrb_state *mrb, + const char *context, + mrb_value mrb_value_, + grn_id domain_id, + grn_mrb_value_to_raw_data_buffer *buffer, + void **raw_value, + unsigned int *raw_value_size) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + enum mrb_vtype mrb_value_type; + grn_bool try_cast = GRN_FALSE; + grn_obj *from_bulk = NULL; + + if (mrb_nil_p(mrb_value_)) { + *raw_value = NULL; + *raw_value_size = 0; + return; + } + + mrb_value_type = mrb_type(mrb_value_); + + switch (mrb_value_type) { + case MRB_TT_STRING : + switch (domain_id) { + case GRN_DB_SHORT_TEXT : + case GRN_DB_TEXT : + case GRN_DB_LONG_TEXT : + *raw_value = RSTRING_PTR(mrb_value_); + *raw_value_size = RSTRING_LEN(mrb_value_); + break; + default : + try_cast = GRN_TRUE; + break; + } + break; + default : + { + struct RClass *klass; + grn_mrb_data *data = &(ctx->impl->mrb); + + klass = mrb_class(mrb, mrb_value_); + if (domain_id == GRN_DB_TIME && + klass == data->builtin.time_class) { + mrb_value mrb_sec; + mrb_value mrb_usec; + + mrb_sec = mrb_funcall(mrb, mrb_value_, "to_i", 0); + mrb_usec = mrb_funcall(mrb, mrb_value_, "usec", 0); + buffer->value.time_value = GRN_TIME_PACK(mrb_fixnum(mrb_sec), + mrb_fixnum(mrb_usec)); + *raw_value = &(buffer->value.time_value); + *raw_value_size = sizeof(buffer->value.time_value); + } else { + try_cast = GRN_TRUE; + if (mrb_value_type == MRB_TT_DATA && + klass == mrb_class_get_under(mrb, data->module, "Bulk")) { + from_bulk = DATA_PTR(mrb_value_); + } + } + } + break; + } + + if (!try_cast) { + return; + } + + if (!from_bulk) { + from_bulk = &(buffer->from); + grn_mrb_value_to_bulk(mrb, mrb_value_, from_bulk); + } + if (!grn_mrb_bulk_cast(mrb, from_bulk, &(buffer->to), domain_id)) { + grn_obj *domain; + char domain_name[GRN_TABLE_MAX_KEY_SIZE]; + int domain_name_size; + + domain = grn_ctx_at(ctx, domain_id); + domain_name_size = grn_obj_name(ctx, domain, domain_name, + GRN_TABLE_MAX_KEY_SIZE); + mrb_raisef(mrb, E_ARGUMENT_ERROR, + "%S: failed to convert to %S: %S", + mrb_str_new_static(mrb, context, strlen(context)), + mrb_str_new_static(mrb, domain_name, domain_name_size), + mrb_funcall(mrb, mrb_value_, "inspect", 0)); + } + *raw_value = GRN_BULK_HEAD(&(buffer->to)); + *raw_value_size = GRN_BULK_VSIZE(&(buffer->to)); +} + +mrb_value +grn_mrb_value_from_raw_data(mrb_state *mrb, + grn_id domain, + void *raw_value, + unsigned int raw_value_size) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_value_; + + switch (domain) { + case GRN_DB_INT32 : + if (raw_value_size == 0) { + mrb_value_ = mrb_fixnum_value(0); + } else { + int32_t value; + value = *((int32_t *)raw_value); + mrb_value_ = mrb_fixnum_value(value); + } + break; + case GRN_DB_SHORT_TEXT : + case GRN_DB_TEXT : + case GRN_DB_LONG_TEXT : + mrb_value_ = mrb_str_new(mrb, + raw_value, + raw_value_size); + break; + default : + { + grn_obj *domain_object; +#define MESSAGE_SIZE 4096 + char message[MESSAGE_SIZE]; + char domain_name[GRN_TABLE_MAX_KEY_SIZE]; + int domain_name_size; + + domain_object = grn_ctx_at(ctx, domain); + if (domain_object) { + domain_name_size = grn_obj_name(ctx, domain_object, + domain_name, GRN_TABLE_MAX_KEY_SIZE); + grn_obj_unlink(ctx, domain_object); + } else { + grn_strcpy(domain_name, GRN_TABLE_MAX_KEY_SIZE, "unknown"); + domain_name_size = strlen(domain_name); + } + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "unsupported raw value type: <%d>(%.*s)", + domain, + domain_name_size, + domain_name); + mrb_raise(mrb, E_RANGE_ERROR, message); + } +#undef MESSAGE_SIZE + break; + } + + return mrb_value_; +} + +struct RClass * +grn_mrb_class_from_grn_obj(mrb_state *mrb, grn_obj *object) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_mrb_data *data; + struct RClass *klass = NULL; + + data = &(ctx->impl->mrb); + switch (object->header.type) { + case GRN_BULK : + klass = mrb_class_get_under(mrb, data->module, "Bulk"); + break; + case GRN_PTR : + klass = mrb_class_get_under(mrb, data->module, "Pointer"); + break; + case GRN_ACCESSOR : + klass = mrb_class_get_under(mrb, data->module, "Accessor"); + break; + case GRN_COLUMN_FIX_SIZE : + klass = mrb_class_get_under(mrb, data->module, "FixedSizeColumn"); + break; + case GRN_COLUMN_VAR_SIZE : + klass = mrb_class_get_under(mrb, data->module, "VariableSizeColumn"); + break; + case GRN_COLUMN_INDEX : + klass = mrb_class_get_under(mrb, data->module, "IndexColumn"); + break; + case GRN_TYPE : + klass = mrb_class_get_under(mrb, data->module, "Type"); + break; + case GRN_PROC : + klass = mrb_class_get_under(mrb, data->module, "Procedure"); + break; + case GRN_EXPR : + klass = mrb_class_get_under(mrb, data->module, "Expression"); + break; + case GRN_TABLE_NO_KEY : + klass = mrb_class_get_under(mrb, data->module, "Array"); + break; + case GRN_TABLE_HASH_KEY : + klass = mrb_class_get_under(mrb, data->module, "HashTable"); + break; + case GRN_TABLE_PAT_KEY : + klass = mrb_class_get_under(mrb, data->module, "PatriciaTrie"); + break; + case GRN_TABLE_DAT_KEY : + klass = mrb_class_get_under(mrb, data->module, "DoubleArrayTrie"); + break; + case GRN_DB : + klass = mrb_class_get_under(mrb, data->module, "Database"); + break; + case GRN_VOID : + klass = mrb_class_get_under(mrb, data->module, "Void"); + break; + default : + break; + } + + if (!klass) { +#define BUFFER_SIZE 1024 + char buffer[BUFFER_SIZE]; + grn_snprintf(buffer, BUFFER_SIZE, BUFFER_SIZE, + "can't find class for object type: %#x", object->header.type); + mrb_raise(mrb, E_ARGUMENT_ERROR, buffer); +#undef BUFFER_SIZE + } + + return klass; +} + +mrb_value +grn_mrb_value_from_grn_obj(mrb_state *mrb, grn_obj *object) +{ + struct RClass *mrb_class; + mrb_value mrb_new_arguments[1]; + mrb_value mrb_object; + + if (!object) { + return mrb_nil_value(); + } + + mrb_class = grn_mrb_class_from_grn_obj(mrb, object); + mrb_new_arguments[0] = mrb_cptr_value(mrb, object); + mrb_object = mrb_obj_new(mrb, mrb_class, 1, mrb_new_arguments); + return mrb_object; +} + +grn_id +grn_mrb_class_to_type(mrb_state *mrb, struct RClass *klass) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_id type = GRN_DB_VOID; + + if (klass == mrb->nil_class) { + type = GRN_DB_VOID; + } else if (klass == mrb->true_class || + klass == mrb->false_class) { + type = GRN_DB_BOOL; + } else if (klass == mrb->symbol_class) { + type = GRN_DB_TEXT; + } else if (klass == mrb->fixnum_class) { + type = GRN_DB_INT64; + } else if (klass == mrb->float_class) { + type = GRN_DB_FLOAT; + } else if (klass == mrb->string_class) { + type = GRN_DB_TEXT; + } else if (klass == ctx->impl->mrb.builtin.time_class) { + type = GRN_DB_TIME; + } else { + mrb_raisef(mrb, E_ARGUMENT_ERROR, + "unsupported class: %S", mrb_obj_value(klass)); + } + + return type; +} + +static mrb_value +mrb_grn_converter_class_convert(mrb_state *mrb, mrb_value klass) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *from = &(ctx->impl->mrb.buffer.from); + grn_obj *to = &(ctx->impl->mrb.buffer.to); + mrb_value mrb_from; + mrb_value mrb_to_class; + grn_id to_type; + + mrb_get_args(mrb, "oC", &mrb_from, &mrb_to_class); + + grn_mrb_value_to_bulk(mrb, mrb_from, from); + to_type = grn_mrb_class_to_type(mrb, mrb_class_ptr(mrb_to_class)); + if (!grn_mrb_bulk_cast(mrb, from, to, to_type)) { + mrb_raisef(mrb, E_ARGUMENT_ERROR, + "failed to convert to %S: %S", + mrb_to_class, + mrb_from); + } + + return grn_mrb_value_from_bulk(mrb, to); +} + +void +grn_mrb_converter_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module; + + module = mrb_define_module_under(mrb, data->module, "Converter"); + + mrb_define_class_method(mrb, module, "convert", + mrb_grn_converter_class_convert, + MRB_ARGS_REQ(2)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_converter.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_converter.h new file mode 100644 index 00000000..9b8546dd --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_converter.h @@ -0,0 +1,64 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2013-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define GRN_MRB_DATA_PTR(mrb_object) \ + (mrb_nil_p((mrb_object)) ? NULL : DATA_PTR((mrb_object))) + +void grn_mrb_converter_init(grn_ctx *ctx); + +typedef struct { + grn_obj from; + grn_obj to; + union { + int64_t time_value; + } value; +} grn_mrb_value_to_raw_data_buffer; + +void grn_mrb_value_to_raw_data_buffer_init(mrb_state *mrb, + grn_mrb_value_to_raw_data_buffer *buffer); +void grn_mrb_value_to_raw_data_buffer_fin(mrb_state *mrb, + grn_mrb_value_to_raw_data_buffer *buffer); +void grn_mrb_value_to_raw_data(mrb_state *mrb, + const char *context, + mrb_value mrb_value_, + grn_id domain_id, + grn_mrb_value_to_raw_data_buffer *buffer, + void **raw_value, + unsigned int *raw_value_size); +mrb_value grn_mrb_value_from_raw_data(mrb_state *mrb, + grn_id domain, + void *raw_value, + unsigned int raw_value_size); + +struct RClass *grn_mrb_class_from_grn_obj(mrb_state *mrb, grn_obj *object); +mrb_value grn_mrb_value_from_grn_obj(mrb_state *mrb, grn_obj *object); + +grn_id grn_mrb_class_to_grn_type(mrb_state *mrb, struct RClass *klass); +grn_id grn_mrb_value_to_grn_type(mrb_state *mrb, mrb_value value); + +#ifdef __cplusplus +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_ctx.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_ctx.c new file mode 100644 index 00000000..e89df53e --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_ctx.c @@ -0,0 +1,838 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2013-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> +#include <mruby/variable.h> +#include <mruby/string.h> + +#include "../grn_mrb.h" +#include "mrb_ctx.h" +#include "mrb_bulk.h" +#include "mrb_converter.h" + +static mrb_value +ctx_class_instance(mrb_state *mrb, mrb_value klass) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_ctx; + mrb_sym iv_name; + + iv_name = mrb_intern_lit(mrb, "@instance"); + mrb_ctx = mrb_iv_get(mrb, klass, iv_name); + if (mrb_nil_p(mrb_ctx)) { + struct RBasic *raw_mrb_ctx; + raw_mrb_ctx = mrb_obj_alloc(mrb, MRB_TT_DATA, mrb_class_ptr(klass)); + mrb_ctx = mrb_obj_value(raw_mrb_ctx); + DATA_PTR(mrb_ctx) = ctx; + mrb_iv_set(mrb, klass, iv_name, mrb_ctx); + } + + return mrb_ctx; +} + +static mrb_value +ctx_array_reference(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_id_or_name; + grn_obj *object; + + mrb_get_args(mrb, "o", &mrb_id_or_name); + + if (mrb_nil_p(mrb_id_or_name)) { + return mrb_nil_value(); + } + + if (mrb_fixnum_p(mrb_id_or_name)) { + grn_id id = mrb_fixnum(mrb_id_or_name); + object = grn_ctx_at(ctx, id); + } else { + mrb_value mrb_name; + mrb_name = mrb_convert_type(mrb, mrb_id_or_name, + MRB_TT_STRING, "String", "to_str"); + object = grn_ctx_get(ctx, + RSTRING_PTR(mrb_name), + RSTRING_LEN(mrb_name)); + } + + return grn_mrb_value_from_grn_obj(mrb, object); +} + +static mrb_value +ctx_get_rc(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + return mrb_fixnum_value(ctx->rc); +} + +static mrb_value +ctx_set_rc(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_int rc; + + mrb_get_args(mrb, "i", &rc); + ctx->rc = rc; + + return mrb_fixnum_value(ctx->rc); +} + +static mrb_value +ctx_get_error_level(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + return mrb_fixnum_value(ctx->errlvl); +} + +static mrb_value +ctx_set_error_level(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_int error_level; + + mrb_get_args(mrb, "i", &error_level); + ctx->errlvl = error_level; + + return mrb_fixnum_value(ctx->errlvl); +} + +static mrb_value +ctx_get_error_file(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + return mrb_str_new_cstr(mrb, ctx->errfile); +} + +static mrb_value +ctx_set_error_file(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value error_file; + + mrb_get_args(mrb, "S", &error_file); + mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "@error_file"), error_file); + ctx->errfile = mrb_string_value_cstr(mrb, &error_file); + + return error_file; +} + +static mrb_value +ctx_get_error_line(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + return mrb_fixnum_value(ctx->errline); +} + +static mrb_value +ctx_set_error_line(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_int error_line; + + mrb_get_args(mrb, "i", &error_line); + ctx->errline = error_line; + + return mrb_fixnum_value(ctx->errline); +} + +static mrb_value +ctx_get_error_method(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + return mrb_str_new_cstr(mrb, ctx->errfunc); +} + +static mrb_value +ctx_set_error_method(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value error_method; + + mrb_get_args(mrb, "S", &error_method); + mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "@error_method"), error_method); + ctx->errfunc = mrb_string_value_cstr(mrb, &error_method); + + return error_method; +} + +static mrb_value +ctx_get_error_message(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + return mrb_str_new_cstr(mrb, ctx->errbuf); +} + +static mrb_value +ctx_set_error_message(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value error_message; + + mrb_get_args(mrb, "S", &error_message); + grn_ctx_log(ctx, "%.*s", + (int)RSTRING_LEN(error_message), + RSTRING_PTR(error_message)); + + return error_message; +} + +static mrb_value +ctx_clear_error(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + ERRCLR(ctx); + + return mrb_nil_value(); +} + +static mrb_value +ctx_get_command_version(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + return mrb_fixnum_value(grn_ctx_get_command_version(ctx)); +} + +static mrb_value +ctx_set_command_version(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_int command_version; + + mrb_get_args(mrb, "i", &command_version); + grn_ctx_set_command_version(ctx, command_version); + + return mrb_fixnum_value(command_version); +} + +static mrb_value +ctx_get_output(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + return grn_mrb_value_from_bulk(mrb, ctx->impl->output.buf); +} + +static mrb_value +ctx_set_output(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_value_; + + mrb_get_args(mrb, "S", &mrb_value_); + GRN_TEXT_SET(ctx, ctx->impl->output.buf, + RSTRING_PTR(mrb_value_), + RSTRING_LEN(mrb_value_)); + + return mrb_value_; +} + +static mrb_value +ctx_get_database(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + return grn_mrb_value_from_grn_obj(mrb, grn_ctx_db(ctx)); +} + +static mrb_value +ctx_is_opened(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_int mrb_id; + + mrb_get_args(mrb, "i", &mrb_id); + + return mrb_bool_value(grn_ctx_is_opened(ctx, mrb_id)); +} + +void +grn_mrb_ctx_check(mrb_state *mrb) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_mrb_data *data = &(ctx->impl->mrb); + struct RClass *module = data->module; + struct RClass *error_class = NULL; +#define MESSAGE_SIZE 4096 + char message[MESSAGE_SIZE]; + + switch (ctx->rc) { + case GRN_SUCCESS: + return; + case GRN_END_OF_DATA: + error_class = mrb_class_get_under(mrb, module, "EndOfData"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "end of data: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_UNKNOWN_ERROR: + error_class = mrb_class_get_under(mrb, module, "UnknownError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "unknown error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_OPERATION_NOT_PERMITTED: + error_class = mrb_class_get_under(mrb, module, "OperationNotPermitted"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "operation not permitted: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_NO_SUCH_FILE_OR_DIRECTORY: + error_class = mrb_class_get_under(mrb, module, "NoSuchFileOrDirectory"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "no such file or directory: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_NO_SUCH_PROCESS: + error_class = mrb_class_get_under(mrb, module, "NoSuchProcess"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "no such process: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_INTERRUPTED_FUNCTION_CALL: + error_class = mrb_class_get_under(mrb, module, "InterruptedFunctionCall"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "interrupted function call: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_INPUT_OUTPUT_ERROR: + error_class = mrb_class_get_under(mrb, module, "InputOutputError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "input output error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_NO_SUCH_DEVICE_OR_ADDRESS: + error_class = mrb_class_get_under(mrb, module, "NoSuchDeviceOrAddress"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "no such device or address: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_ARG_LIST_TOO_LONG: + error_class = mrb_class_get_under(mrb, module, "ArgListTooLong"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "arg list too long: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_EXEC_FORMAT_ERROR: + error_class = mrb_class_get_under(mrb, module, "ExecFormatError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "exec format error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_BAD_FILE_DESCRIPTOR: + error_class = mrb_class_get_under(mrb, module, "BadFileDescriptor"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "bad file descriptor: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_NO_CHILD_PROCESSES: + error_class = mrb_class_get_under(mrb, module, "NoChildProcesses"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "no child processes: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_RESOURCE_TEMPORARILY_UNAVAILABLE: + error_class = mrb_class_get_under(mrb, module, + "ResourceTemporarilyUnavailable"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "resource temporarily unavailable: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_NOT_ENOUGH_SPACE: + error_class = mrb_class_get_under(mrb, module, "NotEnoughSpace"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "not enough space: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_PERMISSION_DENIED: + error_class = mrb_class_get_under(mrb, module, "PermissionDenied"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "permission denied: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_BAD_ADDRESS: + error_class = mrb_class_get_under(mrb, module, "BadAddress"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "bad address: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_RESOURCE_BUSY: + error_class = mrb_class_get_under(mrb, module, "ResourceBusy"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "resource busy: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_FILE_EXISTS: + error_class = mrb_class_get_under(mrb, module, "FileExists"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "file exists: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_IMPROPER_LINK: + error_class = mrb_class_get_under(mrb, module, "ImproperLink"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "improper link: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_NO_SUCH_DEVICE: + error_class = mrb_class_get_under(mrb, module, "NoSuchDevice"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "no such device: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_NOT_A_DIRECTORY: + error_class = mrb_class_get_under(mrb, module, "NotDirectory"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "not directory: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_IS_A_DIRECTORY: + error_class = mrb_class_get_under(mrb, module, "IsDirectory"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "is directory: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_INVALID_ARGUMENT: + error_class = mrb_class_get_under(mrb, module, "InvalidArgument"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "invalid argument: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM: + error_class = mrb_class_get_under(mrb, module, "TooManyOpenFilesInSystem"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "too many open files in system: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_TOO_MANY_OPEN_FILES: + error_class = mrb_class_get_under(mrb, module, "TooManyOpenFiles"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "too many open files: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION: + error_class = mrb_class_get_under(mrb, module, + "InappropriateIOControlOperation"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "inappropriate IO control operation: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_FILE_TOO_LARGE: + error_class = mrb_class_get_under(mrb, module, "FileTooLarge"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "file too large: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_NO_SPACE_LEFT_ON_DEVICE: + error_class = mrb_class_get_under(mrb, module, "NoSpaceLeftOnDevice"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "no space left on device: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_INVALID_SEEK: + error_class = mrb_class_get_under(mrb, module, "InvalidSeek"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "invalid seek: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_READ_ONLY_FILE_SYSTEM: + error_class = mrb_class_get_under(mrb, module, "ReadOnlyFileSystem"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "read only file system: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_TOO_MANY_LINKS: + error_class = mrb_class_get_under(mrb, module, "TooManyLinks"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "too many links: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_BROKEN_PIPE: + error_class = mrb_class_get_under(mrb, module, "BrokenPipe"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "broken pipe: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_DOMAIN_ERROR: + error_class = mrb_class_get_under(mrb, module, "DomainError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "domain error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_RESULT_TOO_LARGE: + error_class = mrb_class_get_under(mrb, module, "ResultTooLarge"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "result too large: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_RESOURCE_DEADLOCK_AVOIDED: + error_class = mrb_class_get_under(mrb, module, "ResourceDeadlockAvoided"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "resource deadlock avoided: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_NO_MEMORY_AVAILABLE: + error_class = mrb_class_get_under(mrb, module, "NoMemoryAvailable"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "no memory available: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_FILENAME_TOO_LONG: + error_class = mrb_class_get_under(mrb, module, "FilenameTooLong"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "filename too long: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_NO_LOCKS_AVAILABLE: + error_class = mrb_class_get_under(mrb, module, "NoLocksAvailable"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "no locks available: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_FUNCTION_NOT_IMPLEMENTED: + error_class = mrb_class_get_under(mrb, module, "FunctionNotImplemented"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "function not implemented: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_DIRECTORY_NOT_EMPTY: + error_class = mrb_class_get_under(mrb, module, "DirectoryNotEmpty"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "directory not empty: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_ILLEGAL_BYTE_SEQUENCE: + error_class = mrb_class_get_under(mrb, module, "IllegalByteSequence"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "illegal byte sequence: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_SOCKET_NOT_INITIALIZED: + error_class = mrb_class_get_under(mrb, module, "SocketNotInitialized"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "socket not initialized: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_OPERATION_WOULD_BLOCK: + error_class = mrb_class_get_under(mrb, module, "OperationWouldBlock"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "operation would block: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_ADDRESS_IS_NOT_AVAILABLE: + error_class = mrb_class_get_under(mrb, module, "AddressIsNotAvailable"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "address is not available: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_NETWORK_IS_DOWN: + error_class = mrb_class_get_under(mrb, module, "NetworkIsDown"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "network is down: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_NO_BUFFER: + error_class = mrb_class_get_under(mrb, module, "NoBuffer"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "no buffer: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_SOCKET_IS_ALREADY_CONNECTED: + error_class = mrb_class_get_under(mrb, module, "SocketIsAlreadyConnected"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "socket is already connected: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_SOCKET_IS_NOT_CONNECTED: + error_class = mrb_class_get_under(mrb, module, "SocketIsNotConnected"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "socket is not connected: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_SOCKET_IS_ALREADY_SHUTDOWNED: + error_class = mrb_class_get_under(mrb, module, "SocketIsAlreadyShutdowned"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "socket is already shutdowned: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_OPERATION_TIMEOUT: + error_class = mrb_class_get_under(mrb, module, "OperationTimeout"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "operation timeout: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_CONNECTION_REFUSED: + error_class = mrb_class_get_under(mrb, module, "ConnectionRefused"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "connection refused: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_RANGE_ERROR: + error_class = mrb_class_get_under(mrb, module, "RangeError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "range error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_TOKENIZER_ERROR: + error_class = mrb_class_get_under(mrb, module, "TokenizerError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "tokenizer error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_FILE_CORRUPT: + error_class = mrb_class_get_under(mrb, module, "FileCorrupt"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "file corrupt: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_INVALID_FORMAT: + error_class = mrb_class_get_under(mrb, module, "InvalidFormat"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "invalid format: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_OBJECT_CORRUPT: + error_class = mrb_class_get_under(mrb, module, "ObjectCorrupt"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "object corrupt: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_TOO_MANY_SYMBOLIC_LINKS: + error_class = mrb_class_get_under(mrb, module, "TooManySymbolicLinks"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "too many symbolic links: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_NOT_SOCKET: + error_class = mrb_class_get_under(mrb, module, "NotSocket"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "not socket: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_OPERATION_NOT_SUPPORTED: + error_class = mrb_class_get_under(mrb, module, "OperationNotSupported"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "operation not supported: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_ADDRESS_IS_IN_USE: + error_class = mrb_class_get_under(mrb, module, "AddressIsInUse"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "address is in use: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_ZLIB_ERROR: + error_class = mrb_class_get_under(mrb, module, "ZlibError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "zlib error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_LZ4_ERROR: + error_class = mrb_class_get_under(mrb, module, "LZ4Error"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "LZ4 error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_STACK_OVER_FLOW: + error_class = mrb_class_get_under(mrb, module, "StackOverFlow"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "stack over flow: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_SYNTAX_ERROR: + error_class = mrb_class_get_under(mrb, module, "SyntaxError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "syntax error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_RETRY_MAX: + error_class = mrb_class_get_under(mrb, module, "RetryMax"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "retry max: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_INCOMPATIBLE_FILE_FORMAT: + error_class = mrb_class_get_under(mrb, module, "IncompatibleFileFormat"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "incompatible file format: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_UPDATE_NOT_ALLOWED: + error_class = mrb_class_get_under(mrb, module, "UpdateNotAllowed"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "update not allowed: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_TOO_SMALL_OFFSET: + error_class = mrb_class_get_under(mrb, module, "TooSmallOffset"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "too small offset: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_TOO_LARGE_OFFSET: + error_class = mrb_class_get_under(mrb, module, "TooLargeOffset"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "too large offset: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_TOO_SMALL_LIMIT: + error_class = mrb_class_get_under(mrb, module, "TooSmallLimit"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "too small limit: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_CAS_ERROR: + error_class = mrb_class_get_under(mrb, module, "CASError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "CAS error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_UNSUPPORTED_COMMAND_VERSION: + error_class = mrb_class_get_under(mrb, module, "UnsupportedCommandVersion"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "unsupported command version: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_NORMALIZER_ERROR: + error_class = mrb_class_get_under(mrb, module, "NormalizerError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "normalizer error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_TOKEN_FILTER_ERROR: + error_class = mrb_class_get_under(mrb, module, "TokenFilterError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "token filter error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_COMMAND_ERROR: + error_class = mrb_class_get_under(mrb, module, "CommandError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "command error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_PLUGIN_ERROR: + error_class = mrb_class_get_under(mrb, module, "PluginError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "plugin error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_SCORER_ERROR: + error_class = mrb_class_get_under(mrb, module, "ScorerError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "scorer error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_CANCEL: + error_class = mrb_class_get_under(mrb, module, "Cancel"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "cancel: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_WINDOW_FUNCTION_ERROR: + error_class = mrb_class_get_under(mrb, module, "WindowFunctionError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "window function error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + case GRN_ZSTD_ERROR: + error_class = mrb_class_get_under(mrb, module, "ZstdError"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "Zstandard error: <%s>(%d)", + ctx->errbuf, ctx->rc); + break; + } + + if (!error_class) { + error_class = mrb_class_get_under(mrb, module, "Error"); + grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, + "unsupported error: <%s>(%d)", + ctx->errbuf, ctx->rc); + } +#undef MESSAGE_SIZE + + mrb_raise(mrb, error_class, message); +} + +void +grn_mrb_ctx_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "Context", mrb->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_class_method(mrb, klass, "instance", + ctx_class_instance, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "[]", ctx_array_reference, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "rc", ctx_get_rc, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "rc=", ctx_set_rc, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "error_level", ctx_get_error_level, + MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "error_level=", ctx_set_error_level, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "error_file", ctx_get_error_file, + MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "error_file=", ctx_set_error_file, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "error_line", ctx_get_error_line, + MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "error_line=", ctx_set_error_line, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "error_method", ctx_get_error_method, + MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "error_method=", ctx_set_error_method, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "error_message", ctx_get_error_message, + MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "error_message=", ctx_set_error_message, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "clear_error", ctx_clear_error, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "command_version", + ctx_get_command_version, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "command_version=", + ctx_set_command_version, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "output", + ctx_get_output, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "output=", + ctx_set_output, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "database", ctx_get_database, + MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "opened?", ctx_is_opened, + MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_ctx.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_ctx.h new file mode 100644 index 00000000..72519ae6 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_ctx.h @@ -0,0 +1,33 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2013-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_ctx_init(grn_ctx *ctx); +void grn_mrb_ctx_check(mrb_state *mrb); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_database.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_database.c new file mode 100644 index 00000000..5ff2bdbe --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_database.c @@ -0,0 +1,206 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> + +#include "mrb_ctx.h" +#include "mrb_database.h" +#include "mrb_converter.h" + +static struct mrb_data_type mrb_grn_database_type = { + "Groonga::Database", + NULL +}; + +static mrb_value +mrb_grn_database_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_database_ptr; + + mrb_get_args(mrb, "o", &mrb_database_ptr); + DATA_TYPE(self) = &mrb_grn_database_type; + DATA_PTR(self) = mrb_cptr(mrb_database_ptr); + return self; +} + +static mrb_value +mrb_grn_database_class_open(mrb_state *mrb, mrb_value klass) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *database; + char *path; + + mrb_get_args(mrb, "z", &path); + + database = grn_db_open(ctx, path); + grn_mrb_ctx_check(mrb); + + return mrb_funcall(mrb, klass, "new", 1, mrb_cptr_value(mrb, database)); +} + +static mrb_value +mrb_grn_database_class_create(mrb_state *mrb, mrb_value klass) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *database; + char *path; + + mrb_get_args(mrb, "z", &path); + + database = grn_db_create(ctx, path, NULL); + grn_mrb_ctx_check(mrb); + + return mrb_funcall(mrb, klass, "new", 1, mrb_cptr_value(mrb, database)); +} + +static mrb_value +mrb_grn_database_recover(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + grn_db_recover(ctx, DATA_PTR(self)); + grn_mrb_ctx_check(mrb); + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_database_is_locked(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + unsigned int is_locked; + + is_locked = grn_obj_is_locked(ctx, DATA_PTR(self)); + grn_mrb_ctx_check(mrb); + + return mrb_bool_value(is_locked != 0); +} + +static mrb_value +mrb_grn_database_get_last_modified(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + uint32_t last_modified; + struct RClass *time_class; + + last_modified = grn_db_get_last_modified(ctx, DATA_PTR(self)); + + time_class = mrb_class_get(mrb, "Time"); + return mrb_funcall(mrb, + mrb_obj_value(time_class), + "at", + 1, + mrb_float_value(mrb, last_modified)); +} + +static mrb_value +mrb_grn_database_is_dirty(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_bool is_dirty; + + is_dirty = grn_db_is_dirty(ctx, DATA_PTR(self)); + + return mrb_bool_value(is_dirty); +} + +static mrb_value +mrb_grn_database_array_reference(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *database; + mrb_value mrb_id_or_key; + + mrb_get_args(mrb, "o", &mrb_id_or_key); + + database = DATA_PTR(self); + + if (mrb_fixnum_p(mrb_id_or_key)) { + char name[GRN_TABLE_MAX_KEY_SIZE]; + int name_size; + + name_size = grn_table_get_key(ctx, + grn_ctx_db(ctx), + mrb_fixnum(mrb_id_or_key), + name, + GRN_TABLE_MAX_KEY_SIZE); + if (name_size == 0) { + return mrb_nil_value(); + } else { + return mrb_str_new(mrb, name, name_size); + } + } else { + grn_id name_domain_id = GRN_DB_SHORT_TEXT; + grn_id id; + grn_mrb_value_to_raw_data_buffer buffer; + void *name; + unsigned int name_size; + + grn_mrb_value_to_raw_data_buffer_init(mrb, &buffer); + grn_mrb_value_to_raw_data(mrb, "name", mrb_id_or_key, + name_domain_id, &buffer, + &name, &name_size); + id = grn_table_get(ctx, database, name, name_size); + grn_mrb_value_to_raw_data_buffer_fin(mrb, &buffer); + + if (id == GRN_ID_NIL) { + return mrb_nil_value(); + } else { + return mrb_fixnum_value(id); + } + } +} + +void +grn_mrb_database_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *object_class = data->object_class; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "Database", object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_class_method(mrb, klass, "open", + mrb_grn_database_class_open, + MRB_ARGS_REQ(1)); + mrb_define_class_method(mrb, klass, "create", + mrb_grn_database_class_create, + MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "initialize", + mrb_grn_database_initialize, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "recover", + mrb_grn_database_recover, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "locked?", + mrb_grn_database_is_locked, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "last_modified", + mrb_grn_database_get_last_modified, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "dirty?", + mrb_grn_database_is_dirty, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "[]", + mrb_grn_database_array_reference, MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_database.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_database.h new file mode 100644 index 00000000..512e33c9 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_database.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_database_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_double_array_trie.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_double_array_trie.c new file mode 100644 index 00000000..20007fef --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_double_array_trie.c @@ -0,0 +1,60 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> + +#include "mrb_double_array_trie.h" + +static struct mrb_data_type mrb_grn_double_array_trie_type = { + "Groonga::DoubleArrayTrie", + NULL +}; + +static mrb_value +mrb_grn_double_array_trie_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_double_array_trie_ptr; + + mrb_get_args(mrb, "o", &mrb_double_array_trie_ptr); + DATA_TYPE(self) = &mrb_grn_double_array_trie_type; + DATA_PTR(self) = mrb_cptr(mrb_double_array_trie_ptr); + return self; +} + +void +grn_mrb_double_array_trie_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *table_class; + struct RClass *klass; + + table_class = mrb_class_get_under(mrb, module, "Table"); + klass = mrb_define_class_under(mrb, module, "DoubleArrayTrie", table_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_method(mrb, klass, "initialize", + mrb_grn_double_array_trie_initialize, MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_double_array_trie.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_double_array_trie.h new file mode 100644 index 00000000..4e7bd59d --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_double_array_trie.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_double_array_trie_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_error.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_error.c new file mode 100644 index 00000000..f162d499 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_error.c @@ -0,0 +1,202 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> + +#include "../grn_mrb.h" +#include "mrb_error.h" + +void +grn_mrb_error_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *error_class; + struct RClass *groonga_error_class; + + error_class = mrb_define_class_under(mrb, module, "Error", + mrb->eStandardError_class); + groonga_error_class = mrb_define_class_under(mrb, module, "GroongaError", + error_class); + + mrb_define_class_under(mrb, module, "EndOfData", + groonga_error_class); + mrb_define_class_under(mrb, module, "UnknownError", + groonga_error_class); + mrb_define_class_under(mrb, module, "OperationNotPermitted", + groonga_error_class); + mrb_define_class_under(mrb, module, "NoSuchFileOrDirectory", + groonga_error_class); + mrb_define_class_under(mrb, module, "NoSuchProcess", + groonga_error_class); + mrb_define_class_under(mrb, module, "InterruptedFunctionCall", + groonga_error_class); + mrb_define_class_under(mrb, module, "InputOutputError", + groonga_error_class); + mrb_define_class_under(mrb, module, "NoSuchDeviceOrAddress", + groonga_error_class); + mrb_define_class_under(mrb, module, "ArgListTooLong", + groonga_error_class); + mrb_define_class_under(mrb, module, "ExecFormatError", + groonga_error_class); + mrb_define_class_under(mrb, module, "BadFileDescriptor", + groonga_error_class); + mrb_define_class_under(mrb, module, "NoChildProcesses", + groonga_error_class); + mrb_define_class_under(mrb, module, "ResourceTemporarilyUnavailable", + groonga_error_class); + mrb_define_class_under(mrb, module, "NotEnoughSpace", + groonga_error_class); + mrb_define_class_under(mrb, module, "PermissionDenied", + groonga_error_class); + mrb_define_class_under(mrb, module, "BadAddress", + groonga_error_class); + mrb_define_class_under(mrb, module, "ResourceBusy", + groonga_error_class); + mrb_define_class_under(mrb, module, "FileExists", + groonga_error_class); + mrb_define_class_under(mrb, module, "ImproperLink", + groonga_error_class); + mrb_define_class_under(mrb, module, "NoSuchDevice", + groonga_error_class); + mrb_define_class_under(mrb, module, "NotDirectory", + groonga_error_class); + mrb_define_class_under(mrb, module, "IsDirectory", + groonga_error_class); + mrb_define_class_under(mrb, module, "InvalidArgument", + groonga_error_class); + mrb_define_class_under(mrb, module, "TooManyOpenFilesInSystem", + groonga_error_class); + mrb_define_class_under(mrb, module, "TooManyOpenFiles", + groonga_error_class); + mrb_define_class_under(mrb, module, "InappropriateIOControlOperation", + groonga_error_class); + mrb_define_class_under(mrb, module, "FileTooLarge", + groonga_error_class); + mrb_define_class_under(mrb, module, "NoSpaceLeftOnDevice", + groonga_error_class); + mrb_define_class_under(mrb, module, "InvalidSeek", + groonga_error_class); + mrb_define_class_under(mrb, module, "ReadOnlyFileSystem", + groonga_error_class); + mrb_define_class_under(mrb, module, "TooManyLinks", + groonga_error_class); + mrb_define_class_under(mrb, module, "BrokenPipe", + groonga_error_class); + mrb_define_class_under(mrb, module, "DomainError", + groonga_error_class); + mrb_define_class_under(mrb, module, "ResultTooLarge", + groonga_error_class); + mrb_define_class_under(mrb, module, "ResourceDeadlockAvoided", + groonga_error_class); + mrb_define_class_under(mrb, module, "NoMemoryAvailable", + groonga_error_class); + mrb_define_class_under(mrb, module, "FilenameTooLong", + groonga_error_class); + mrb_define_class_under(mrb, module, "NoLocksAvailable", + groonga_error_class); + mrb_define_class_under(mrb, module, "FunctionNotImplemented", + groonga_error_class); + mrb_define_class_under(mrb, module, "DirectoryNotEmpty", + groonga_error_class); + mrb_define_class_under(mrb, module, "IllegalByteSequence", + groonga_error_class); + mrb_define_class_under(mrb, module, "SocketNotInitialized", + groonga_error_class); + mrb_define_class_under(mrb, module, "OperationWouldBlock", + groonga_error_class); + mrb_define_class_under(mrb, module, "AddressIsNotAvailable", + groonga_error_class); + mrb_define_class_under(mrb, module, "NetworkIsDown", + groonga_error_class); + mrb_define_class_under(mrb, module, "NoBuffer", + groonga_error_class); + mrb_define_class_under(mrb, module, "SocketIsAlreadyConnected", + groonga_error_class); + mrb_define_class_under(mrb, module, "SocketIsNotConnected", + groonga_error_class); + mrb_define_class_under(mrb, module, "SocketIsAlreadyShutdowned", + groonga_error_class); + mrb_define_class_under(mrb, module, "OperationTimeout", + groonga_error_class); + mrb_define_class_under(mrb, module, "ConnectionRefused", + groonga_error_class); + mrb_define_class_under(mrb, module, "RangeError", + groonga_error_class); + mrb_define_class_under(mrb, module, "TokenizerError", + groonga_error_class); + mrb_define_class_under(mrb, module, "FileCorrupt", + groonga_error_class); + mrb_define_class_under(mrb, module, "InvalidFormat", + groonga_error_class); + mrb_define_class_under(mrb, module, "ObjectCorrupt", + groonga_error_class); + mrb_define_class_under(mrb, module, "TooManySymbolicLinks", + groonga_error_class); + mrb_define_class_under(mrb, module, "NotSocket", + groonga_error_class); + mrb_define_class_under(mrb, module, "OperationNotSupported", + groonga_error_class); + mrb_define_class_under(mrb, module, "AddressIsInUse", + groonga_error_class); + mrb_define_class_under(mrb, module, "ZlibError", + groonga_error_class); + mrb_define_class_under(mrb, module, "LZ4Error", + groonga_error_class); + mrb_define_class_under(mrb, module, "StackOverFlow", + groonga_error_class); + mrb_define_class_under(mrb, module, "SyntaxError", + groonga_error_class); + mrb_define_class_under(mrb, module, "RetryMax", + groonga_error_class); + mrb_define_class_under(mrb, module, "IncompatibleFileFormat", + groonga_error_class); + mrb_define_class_under(mrb, module, "UpdateNotAllowed", + groonga_error_class); + mrb_define_class_under(mrb, module, "TooSmallOffset", + groonga_error_class); + mrb_define_class_under(mrb, module, "TooLargeOffset", + groonga_error_class); + mrb_define_class_under(mrb, module, "TooSmallLimit", + groonga_error_class); + mrb_define_class_under(mrb, module, "CASError", + groonga_error_class); + mrb_define_class_under(mrb, module, "UnsupportedCommandVersion", + groonga_error_class); + mrb_define_class_under(mrb, module, "NormalizerError", + groonga_error_class); + mrb_define_class_under(mrb, module, "TokenFilterError", + groonga_error_class); + mrb_define_class_under(mrb, module, "CommandError", + groonga_error_class); + mrb_define_class_under(mrb, module, "PluginError", + groonga_error_class); + mrb_define_class_under(mrb, module, "ScorerError", + groonga_error_class); + mrb_define_class_under(mrb, module, "Cancel", + groonga_error_class); + mrb_define_class_under(mrb, module, "WindowFunctionError", + groonga_error_class); + mrb_define_class_under(mrb, module, "ZstdError", + groonga_error_class); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_error.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_error.h new file mode 100644 index 00000000..917bfec5 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_error.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_error_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_eval_context.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_eval_context.c new file mode 100644 index 00000000..fd5be59c --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_eval_context.c @@ -0,0 +1,98 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/proc.h> +#include <mruby/compile.h> +#include <mruby/opcode.h> + +#include "../grn_mrb.h" +#include "mrb_ctx.h" +#include "mrb_eval_context.h" + +static mrb_value +eval_context_compile(mrb_state *mrb, mrb_value self) +{ + char *script; + mrb_int script_length; + mrbc_context* compile_ctx; + struct mrb_parser_state *parser; + struct RProc *proc; + + mrb_get_args(mrb, "s", &script, &script_length); + + compile_ctx = mrbc_context_new(mrb); + if (!compile_ctx) { + mrb_raise(mrb, E_RUNTIME_ERROR, + "[mruby][eval][compile] failed to allocate context"); + } + compile_ctx->capture_errors = TRUE; + + parser = mrb_parse_nstring(mrb, script, script_length, compile_ctx); + if (!parser) { + mrbc_context_free(mrb, compile_ctx); + mrb_raise(mrb, E_RUNTIME_ERROR, + "[mruby][eval][compile] failed to allocate parser"); + } + if (parser->nerr > 0) { + struct mrb_parser_message *error = &(parser->error_buffer[0]); + mrb_value new_args[1]; + mrb_value exception; + + new_args[0] = mrb_format(mrb, + "line %S:%S: %S", + mrb_fixnum_value(error->lineno), + mrb_fixnum_value(error->column), + mrb_str_new_cstr(mrb, error->message)); + exception = mrb_obj_new(mrb, E_SYNTAX_ERROR, 1, new_args); + mrb_parser_free(parser); + mrbc_context_free(mrb, compile_ctx); + + mrb_exc_raise(mrb, exception); + } + + proc = mrb_generate_code(mrb, parser); + { + mrb_code *iseq = proc->body.irep->iseq; + while (GET_OPCODE(*iseq) != OP_STOP) { + iseq++; + } + *iseq = MKOP_AB(OP_RETURN, 1, OP_R_NORMAL); + } + mrb_parser_free(parser); + mrbc_context_free(mrb, compile_ctx); + return mrb_obj_value(proc); +} + +void +grn_mrb_eval_context_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "EvalContext", mrb->object_class); + + mrb_define_method(mrb, klass, "compile", eval_context_compile, + MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_eval_context.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_eval_context.h new file mode 100644 index 00000000..c277ed5e --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_eval_context.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_eval_context_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_expr.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_expr.c new file mode 100644 index 00000000..2b8f6a04 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_expr.c @@ -0,0 +1,1079 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2013-2017 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/variable.h> +#include <mruby/data.h> +#include <mruby/string.h> +#include <mruby/array.h> +#include <mruby/hash.h> + +#include "../grn_expr.h" +#include "../grn_proc.h" +#include "../grn_util.h" +#include "../grn_mrb.h" +#include "mrb_accessor.h" +#include "mrb_ctx.h" +#include "mrb_expr.h" +#include "mrb_operator.h" +#include "mrb_converter.h" +#include "mrb_options.h" + +static struct mrb_data_type mrb_grn_scan_info_type = { + "Groonga::ScanInfo", + NULL +}; +static struct mrb_data_type mrb_grn_expr_code_type = { + "Groonga::ExpressionCode", + NULL +}; +static struct mrb_data_type mrb_grn_expression_type = { + "Groonga::Expression", + NULL +}; + +static mrb_value +mrb_grn_scan_info_new(mrb_state *mrb, scan_info *scan_info) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + struct RClass *module = ctx->impl->mrb.module; + struct RClass *klass; + mrb_value mrb_scan_info; + + mrb_scan_info = mrb_cptr_value(mrb, scan_info); + klass = mrb_class_get_under(mrb, module, "ScanInfo"); + return mrb_obj_new(mrb, klass, 1, &mrb_scan_info); +} + +static mrb_value +mrb_grn_expr_code_new(mrb_state *mrb, grn_expr_code *code) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + struct RClass *module = ctx->impl->mrb.module; + struct RClass *klass; + mrb_value mrb_code; + + mrb_code = mrb_cptr_value(mrb, code); + klass = mrb_class_get_under(mrb, module, "ExpressionCode"); + return mrb_obj_new(mrb, klass, 1, &mrb_code); +} + +static mrb_value +mrb_grn_scan_info_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_ptr; + + mrb_get_args(mrb, "o", &mrb_ptr); + DATA_TYPE(self) = &mrb_grn_scan_info_type; + DATA_PTR(self) = mrb_cptr(mrb_ptr); + return self; +} + +static mrb_value +mrb_grn_expr_code_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_code; + + mrb_get_args(mrb, "o", &mrb_code); + DATA_TYPE(self) = &mrb_grn_expr_code_type; + DATA_PTR(self) = mrb_cptr(mrb_code); + return self; +} + +static mrb_value +mrb_grn_scan_info_put_index(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + scan_info *si; + mrb_value mrb_index; + mrb_int sid; + mrb_int weight; + mrb_value mrb_scorer; + mrb_value mrb_scorer_args_expr; + mrb_int scorer_args_expr_offset; + grn_obj *index; + grn_obj *scorer = NULL; + grn_obj *scorer_args_expr = NULL; + + mrb_get_args(mrb, "oiiooi", + &mrb_index, &sid, &weight, + &mrb_scorer, + &mrb_scorer_args_expr, + &scorer_args_expr_offset); + si = DATA_PTR(self); + index = DATA_PTR(mrb_index); + if (!mrb_nil_p(mrb_scorer)) { + scorer = DATA_PTR(mrb_scorer); + } + if (!mrb_nil_p(mrb_scorer_args_expr)) { + scorer_args_expr = DATA_PTR(mrb_scorer_args_expr); + } + grn_scan_info_put_index(ctx, si, index, sid, weight, + scorer, + scorer_args_expr, + scorer_args_expr_offset); + return self; +} + +static mrb_value +mrb_grn_scan_info_get_op(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + grn_operator op; + + si = DATA_PTR(self); + op = grn_scan_info_get_op(si); + return grn_mrb_value_from_operator(mrb, op); +} + +static mrb_value +mrb_grn_scan_info_set_op(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + mrb_value mrb_op; + grn_operator op; + + mrb_get_args(mrb, "o", &mrb_op); + si = DATA_PTR(self); + op = grn_mrb_value_to_operator(mrb, mrb_op); + grn_scan_info_set_op(si, op); + return self; +} + +static mrb_value +mrb_grn_scan_info_set_end(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + mrb_int end; + + mrb_get_args(mrb, "i", &end); + si = DATA_PTR(self); + grn_scan_info_set_end(si, end); + return self; +} + +static mrb_value +mrb_grn_scan_info_set_query(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + mrb_value mrb_query; + + mrb_get_args(mrb, "o", &mrb_query); + si = DATA_PTR(self); + if (mrb_nil_p(mrb_query)) { + grn_scan_info_set_query(si, NULL); + } else { + grn_scan_info_set_query(si, DATA_PTR(mrb_query)); + } + return self; +} + +static mrb_value +mrb_grn_scan_info_set_flags(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + mrb_int flags; + + mrb_get_args(mrb, "i", &flags); + si = DATA_PTR(self); + grn_scan_info_set_flags(si, flags); + return self; +} + +static mrb_value +mrb_grn_scan_info_get_flags(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + int flags; + + si = DATA_PTR(self); + flags = grn_scan_info_get_flags(si); + return mrb_fixnum_value(flags); +} + +static mrb_value +mrb_grn_scan_info_set_logical_op(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + mrb_value mrb_logical_op; + grn_operator logical_op; + + mrb_get_args(mrb, "o", &mrb_logical_op); + si = DATA_PTR(self); + logical_op = grn_mrb_value_to_operator(mrb, mrb_logical_op); + grn_scan_info_set_logical_op(si, logical_op); + return self; +} + +static mrb_value +mrb_grn_scan_info_get_logical_op(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + grn_operator logical_op; + + si = DATA_PTR(self); + logical_op = grn_scan_info_get_logical_op(si); + return grn_mrb_value_from_operator(mrb, logical_op); +} + +static mrb_value +mrb_grn_scan_info_set_max_interval(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + mrb_int max_interval; + + mrb_get_args(mrb, "i", &max_interval); + si = DATA_PTR(self); + grn_scan_info_set_max_interval(si, max_interval); + return self; +} + +static mrb_value +mrb_grn_scan_info_get_max_interval(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + int max_interval; + + si = DATA_PTR(self); + max_interval = grn_scan_info_get_max_interval(si); + return mrb_fixnum_value(max_interval); +} + +static mrb_value +mrb_grn_scan_info_set_similarity_threshold(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + mrb_int similarity_threshold; + + mrb_get_args(mrb, "i", &similarity_threshold); + si = DATA_PTR(self); + grn_scan_info_set_similarity_threshold(si, similarity_threshold); + return self; +} + +static mrb_value +mrb_grn_scan_info_get_similarity_threshold(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + int similarity_threshold; + + si = DATA_PTR(self); + similarity_threshold = grn_scan_info_get_similarity_threshold(si); + return mrb_fixnum_value(similarity_threshold); +} + +static mrb_value +mrb_grn_scan_info_get_arg(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + scan_info *si; + mrb_int index; + grn_obj *arg; + + mrb_get_args(mrb, "i", &index); + + si = DATA_PTR(self); + arg = grn_scan_info_get_arg(ctx, si, index); + + return grn_mrb_value_from_grn_obj(mrb, arg); +} + +static mrb_value +mrb_grn_scan_info_push_arg(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + mrb_value mrb_arg; + grn_bool success; + + mrb_get_args(mrb, "o", &mrb_arg); + + si = DATA_PTR(self); + success = grn_scan_info_push_arg(si, DATA_PTR(mrb_arg)); + + return mrb_bool_value(success); +} + +static mrb_value +mrb_grn_scan_info_get_start_position(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + int start_position; + + si = DATA_PTR(self); + start_position = grn_scan_info_get_start_position(si); + return mrb_fixnum_value(start_position); +} + +static mrb_value +mrb_grn_scan_info_set_start_position(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + mrb_int start_position; + + mrb_get_args(mrb, "i", &start_position); + si = DATA_PTR(self); + grn_scan_info_set_start_position(si, start_position); + return self; +} + +static mrb_value +mrb_grn_scan_info_reset_position(mrb_state *mrb, mrb_value self) +{ + scan_info *si; + + si = DATA_PTR(self); + grn_scan_info_reset_position(si); + return self; +} + +static mrb_value +mrb_grn_expr_code_inspect(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_expr_code *code; + mrb_value inspected; + + code = DATA_PTR(self); + + inspected = mrb_str_buf_new(mrb, 48); + + mrb_str_cat_lit(mrb, inspected, "#<"); + mrb_str_cat_cstr(mrb, inspected, mrb_obj_classname(mrb, self)); + mrb_str_cat_lit(mrb, inspected, ":"); + mrb_str_concat(mrb, inspected, mrb_ptr_to_str(mrb, mrb_cptr(self))); + + { + int32_t weight; + uint32_t offset; + + weight = grn_expr_code_get_weight(ctx, DATA_PTR(self), &offset); + + mrb_str_cat_lit(mrb, inspected, " weight="); + mrb_str_concat(mrb, inspected, + mrb_funcall(mrb, + mrb_fixnum_value(weight), + "inspect", + 0)); + mrb_str_cat_lit(mrb, inspected, ", offset="); + mrb_str_concat(mrb, inspected, + mrb_funcall(mrb, + mrb_fixnum_value(offset), + "inspect", + 0)); + } + + mrb_str_cat_lit(mrb, inspected, ", n_args="); + mrb_str_concat(mrb, inspected, + mrb_funcall(mrb, + mrb_fixnum_value(code->nargs), + "inspect", + 0)); + + mrb_str_cat_lit(mrb, inspected, ", modify="); + mrb_str_concat(mrb, inspected, + mrb_funcall(mrb, + mrb_fixnum_value(code->modify), + "inspect", + 0)); + + mrb_str_cat_lit(mrb, inspected, ", op="); + mrb_str_concat(mrb, inspected, + mrb_funcall(mrb, + grn_mrb_value_from_operator(mrb, code->op), + "inspect", + 0)); + + mrb_str_cat_lit(mrb, inspected, ", flags="); + mrb_str_concat(mrb, inspected, + mrb_funcall(mrb, + mrb_fixnum_value(code->flags), + "inspect", + 0)); + + mrb_str_cat_lit(mrb, inspected, ", value="); + mrb_str_concat(mrb, inspected, + mrb_funcall(mrb, + grn_mrb_value_from_grn_obj(mrb, code->value), + "inspect", + 0)); + + mrb_str_cat_lit(mrb, inspected, ">"); + + return inspected; +} + +static mrb_value +mrb_grn_expr_code_get_weight(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + int32_t weight; + uint32_t offset; + mrb_value mrb_values[2]; + + weight = grn_expr_code_get_weight(ctx, DATA_PTR(self), &offset); + mrb_values[0] = mrb_fixnum_value(weight); + mrb_values[1] = mrb_fixnum_value(offset); + return mrb_ary_new_from_values(mrb, 2, mrb_values); +} + +static mrb_value +mrb_grn_expr_code_get_value(mrb_state *mrb, mrb_value self) +{ + grn_expr_code *expr_code; + + expr_code = DATA_PTR(self); + return grn_mrb_value_from_grn_obj(mrb, expr_code->value); +} + +static mrb_value +mrb_grn_expr_code_get_n_args(mrb_state *mrb, mrb_value self) +{ + grn_expr_code *expr_code; + + expr_code = DATA_PTR(self); + return mrb_fixnum_value(expr_code->nargs); +} + +static mrb_value +mrb_grn_expr_code_get_op(mrb_state *mrb, mrb_value self) +{ + grn_expr_code *expr_code; + + expr_code = DATA_PTR(self); + return grn_mrb_value_from_operator(mrb, expr_code->op); +} + +static mrb_value +mrb_grn_expr_code_get_flags(mrb_state *mrb, mrb_value self) +{ + grn_expr_code *expr_code; + + expr_code = DATA_PTR(self); + return mrb_fixnum_value(expr_code->flags); +} + +static mrb_value +mrb_grn_expr_code_get_modify(mrb_state *mrb, mrb_value self) +{ + grn_expr_code *expr_code; + + expr_code = DATA_PTR(self); + return mrb_fixnum_value(expr_code->modify); +} + +static mrb_value +mrb_grn_expression_class_create(mrb_state *mrb, mrb_value klass) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_expr; + mrb_value mrb_table; + mrb_value mrb_new_arguments[1]; + grn_obj *expr, *variable = NULL; + + mrb_get_args(mrb, "o", &mrb_table); + if (mrb_nil_p(mrb_table)) { + expr = grn_expr_create(ctx, NULL, 0); + } else { + grn_obj *table = DATA_PTR(mrb_table); + GRN_EXPR_CREATE_FOR_QUERY(ctx, table, expr, variable); + } + + if (!expr) { + grn_mrb_ctx_check(mrb); + return mrb_nil_value(); + } + + mrb_new_arguments[0] = mrb_cptr_value(mrb, expr); + mrb_expr = mrb_obj_new(mrb, mrb_class_ptr(klass), 1, mrb_new_arguments); + { + mrb_value mrb_variable = mrb_nil_value(); + if (variable) { + mrb_variable = grn_mrb_value_from_grn_obj(mrb, variable); + } + mrb_iv_set(mrb, mrb_expr, mrb_intern_lit(mrb, "@variable"), mrb_variable); + } + + return mrb_expr; +} + +static mrb_value +mrb_grn_expression_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_expression_ptr; + + mrb_get_args(mrb, "o", &mrb_expression_ptr); + DATA_TYPE(self) = &mrb_grn_expression_type; + DATA_PTR(self) = mrb_cptr(mrb_expression_ptr); + return self; +} + +static mrb_value +mrb_grn_expression_is_empty(mrb_state *mrb, mrb_value self) +{ + grn_expr *expr; + + expr = DATA_PTR(self); + return mrb_bool_value(expr->codes_curr == 0); +} + +static mrb_value +mrb_grn_expression_codes(mrb_state *mrb, mrb_value self) +{ + grn_expr *expr; + mrb_value mrb_codes; + int i; + + expr = DATA_PTR(self); + mrb_codes = mrb_ary_new_capa(mrb, expr->codes_curr); + for (i = 0; i < expr->codes_curr; i++) { + grn_expr_code *code = expr->codes + i; + mrb_ary_push(mrb, mrb_codes, mrb_grn_expr_code_new(mrb, code)); + } + + return mrb_codes; +} + +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 mrb_value +mrb_grn_expression_set_condition(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *expr; + mrb_value mrb_condition; + grn_obj *condition_ptr; + + mrb_get_args(mrb, "o", &mrb_condition); + + expr = DATA_PTR(self); + condition_ptr = grn_expr_get_or_add_var(ctx, + expr, + GRN_SELECT_INTERNAL_VAR_CONDITION, + GRN_SELECT_INTERNAL_VAR_CONDITION_LEN); + GRN_OBJ_FIN(ctx, condition_ptr); + GRN_PTR_INIT(condition_ptr, 0, GRN_DB_OBJECT); + GRN_PTR_SET(ctx, condition_ptr, GRN_MRB_DATA_PTR(mrb_condition)); + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_expression_take_object(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *expr; + mrb_value mrb_object; + grn_obj *grn_object; + + mrb_get_args(mrb, "o", &mrb_object); + expr = DATA_PTR(self); + grn_object = DATA_PTR(mrb_object); + grn_expr_take_obj(ctx, expr, grn_object); + + return mrb_object; +} + +static mrb_value +mrb_grn_expression_allocate_constant(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *expr; + mrb_value mrb_object; + grn_obj *grn_object; + + mrb_get_args(mrb, "o", &mrb_object); + expr = DATA_PTR(self); + + switch (mrb_type(mrb_object)) { + case MRB_TT_STRING: + grn_object = grn_expr_alloc_const(ctx, expr); + if (!grn_object) { + grn_mrb_ctx_check(mrb); + } + GRN_TEXT_INIT(grn_object, 0); + GRN_TEXT_SET(ctx, grn_object, + RSTRING_PTR(mrb_object), RSTRING_LEN(mrb_object)); + break; + case MRB_TT_TRUE: + grn_object = grn_expr_alloc_const(ctx, expr); + if (!grn_object) { + grn_mrb_ctx_check(mrb); + } + GRN_BOOL_INIT(grn_object, 0); + GRN_BOOL_SET(ctx, grn_object, GRN_TRUE); + break; + default: + mrb_raisef(mrb, E_ARGUMENT_ERROR, "unsupported type: %S", mrb_object); + break; + } + + return grn_mrb_value_from_grn_obj(mrb, grn_object); +} + +static mrb_value +mrb_grn_expression_parse(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *expr; + char *query; + mrb_int query_size; + grn_obj *default_column = NULL; + grn_operator default_mode = GRN_OP_MATCH; + grn_operator default_operator = GRN_OP_AND; + grn_expr_flags flags = GRN_EXPR_SYNTAX_SCRIPT; + mrb_value mrb_options = mrb_nil_value(); + + expr = DATA_PTR(self); + mrb_get_args(mrb, "s|H", &query, &query_size, &mrb_options); + + if (!mrb_nil_p(mrb_options)) { + mrb_value mrb_default_column; + mrb_value mrb_flags; + + mrb_default_column = + grn_mrb_options_get_lit(mrb, mrb_options, "default_column"); + default_column = GRN_MRB_DATA_PTR(mrb_default_column); + + mrb_flags = grn_mrb_options_get_lit(mrb, mrb_options, "flags"); + if (!mrb_nil_p(mrb_flags)) { + flags = mrb_fixnum(mrb_flags); + } + } + + grn_expr_parse(ctx, expr, query, query_size, default_column, + default_mode, default_operator, flags); + grn_mrb_ctx_check(mrb); + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_expression_append_object(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *expr; + mrb_value mrb_object; + grn_obj *object; + mrb_value mrb_op; + grn_operator op; + mrb_int n_args; + + expr = DATA_PTR(self); + mrb_get_args(mrb, "ooi", &mrb_object, &mrb_op, &n_args); + + object = DATA_PTR(mrb_object); + op = grn_mrb_value_to_operator(mrb, mrb_op); + grn_expr_append_obj(ctx, expr, object, op, n_args); + grn_mrb_ctx_check(mrb); + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_expression_append_constant(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *expr; + mrb_value mrb_constant; + mrb_value mrb_op; + grn_operator op; + mrb_int n_args; + + expr = DATA_PTR(self); + mrb_get_args(mrb, "ooi", &mrb_constant, &mrb_op, &n_args); + + op = grn_mrb_value_to_operator(mrb, mrb_op); + switch (mrb_type(mrb_constant)) { + case MRB_TT_FALSE : + if (mrb_nil_p(mrb_constant)) { + grn_obj constant; + GRN_VOID_INIT(&constant); + grn_expr_append_const(ctx, expr, &constant, op, n_args); + GRN_OBJ_FIN(ctx, &constant); + } else { + grn_obj constant; + GRN_BOOL_INIT(&constant, 0); + GRN_BOOL_SET(ctx, &constant, GRN_FALSE); + grn_expr_append_const(ctx, expr, &constant, op, n_args); + GRN_OBJ_FIN(ctx, &constant); + } + break; + case MRB_TT_TRUE : + { + grn_obj constant; + GRN_BOOL_INIT(&constant, 0); + GRN_BOOL_SET(ctx, &constant, GRN_TRUE); + grn_expr_append_const(ctx, expr, &constant, op, n_args); + GRN_OBJ_FIN(ctx, &constant); + } + break; + case MRB_TT_FIXNUM : + grn_expr_append_const_int(ctx, expr, mrb_fixnum(mrb_constant), op, n_args); + break; + case MRB_TT_SYMBOL : + { + const char *value; + mrb_int value_length; + + value = mrb_sym2name_len(mrb, mrb_symbol(mrb_constant), &value_length); + grn_expr_append_const_str(ctx, expr, value, value_length, op, n_args); + } + break; + case MRB_TT_FLOAT : + { + grn_obj constant; + GRN_FLOAT_INIT(&constant, 0); + GRN_FLOAT_SET(ctx, &constant, mrb_float(mrb_constant)); + grn_expr_append_const(ctx, expr, &constant, op, n_args); + GRN_OBJ_FIN(ctx, &constant); + } + break; + case MRB_TT_STRING : + grn_expr_append_const_str(ctx, expr, + RSTRING_PTR(mrb_constant), + RSTRING_LEN(mrb_constant), + op, n_args); + break; + default : + { + struct RClass *klass; + + klass = mrb_class(mrb, mrb_constant); + if (klass == ctx->impl->mrb.builtin.time_class) { + grn_obj constant; + mrb_value mrb_sec; + mrb_value mrb_usec; + + mrb_sec = mrb_funcall(mrb, mrb_constant, "to_i", 0); + mrb_usec = mrb_funcall(mrb, mrb_constant, "usec", 0); + GRN_TIME_INIT(&constant, 0); + GRN_TIME_SET(ctx, &constant, + GRN_TIME_PACK(mrb_fixnum(mrb_sec), mrb_fixnum(mrb_usec))); + grn_expr_append_const(ctx, expr, &constant, op, n_args); + GRN_OBJ_FIN(ctx, &constant); + } else { + mrb_raisef(mrb, E_ARGUMENT_ERROR, + "unsupported constant to append to expression: %S", + mrb_constant); + } + } + break; + } + + grn_mrb_ctx_check(mrb); + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_expression_append_operator(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *expr; + mrb_value mrb_op; + mrb_int n_args; + grn_operator op; + + expr = DATA_PTR(self); + mrb_get_args(mrb, "oi", &mrb_op, &n_args); + + op = grn_mrb_value_to_operator(mrb, mrb_op); + grn_expr_append_op(ctx, expr, op, n_args); + grn_mrb_ctx_check(mrb); + + return mrb_nil_value(); +} + +void +grn_mrb_expr_init(grn_ctx *ctx) +{ + mrb_state *mrb = ctx->impl->mrb.state; + struct RClass *module = ctx->impl->mrb.module; + struct RClass *object_class = ctx->impl->mrb.object_class; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "ScanInfo", mrb->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + mrb_define_method(mrb, klass, "initialize", + mrb_grn_scan_info_initialize, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "put_index", + mrb_grn_scan_info_put_index, MRB_ARGS_REQ(6)); + mrb_define_method(mrb, klass, "op", + mrb_grn_scan_info_get_op, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "op=", + mrb_grn_scan_info_set_op, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "end=", + mrb_grn_scan_info_set_end, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "query=", + mrb_grn_scan_info_set_query, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "flags", + mrb_grn_scan_info_get_flags, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "flags=", + mrb_grn_scan_info_set_flags, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "logical_op", + mrb_grn_scan_info_get_logical_op, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "logical_op=", + mrb_grn_scan_info_set_logical_op, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "max_interval", + mrb_grn_scan_info_get_max_interval, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "max_interval=", + mrb_grn_scan_info_set_max_interval, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "similarity_threshold", + mrb_grn_scan_info_get_similarity_threshold, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "similarity_threshold=", + mrb_grn_scan_info_set_similarity_threshold, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "get_arg", + mrb_grn_scan_info_get_arg, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "push_arg", + mrb_grn_scan_info_push_arg, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "start_position", + mrb_grn_scan_info_get_start_position, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "start_position=", + mrb_grn_scan_info_set_start_position, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "reset_position", + mrb_grn_scan_info_reset_position, MRB_ARGS_NONE()); + + klass = mrb_define_class_under(mrb, module, + "ExpressionCode", mrb->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + mrb_define_method(mrb, klass, "initialize", + mrb_grn_expr_code_initialize, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "inspect", + mrb_grn_expr_code_inspect, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "weight", + mrb_grn_expr_code_get_weight, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "value", + mrb_grn_expr_code_get_value, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "n_args", + mrb_grn_expr_code_get_n_args, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "op", + mrb_grn_expr_code_get_op, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "flags", + mrb_grn_expr_code_get_flags, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "modify", + mrb_grn_expr_code_get_modify, MRB_ARGS_NONE()); + + { + struct RClass *expression_code_class = klass; + struct RClass *flags_module; + flags_module = mrb_define_module_under(mrb, expression_code_class, "Flags"); + mrb_define_const(mrb, flags_module, "RELATIONAL_EXPRESSION", + mrb_fixnum_value(GRN_EXPR_CODE_RELATIONAL_EXPRESSION)); + } + + klass = mrb_define_class_under(mrb, module, "Expression", object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + +#define DEFINE_FLAG(name) \ + mrb_define_const(mrb, klass, \ + #name, \ + mrb_fixnum_value(GRN_EXPR_ ## name)) + + DEFINE_FLAG(SYNTAX_QUERY); + DEFINE_FLAG(SYNTAX_SCRIPT); + DEFINE_FLAG(SYNTAX_OUTPUT_COLUMNS); + DEFINE_FLAG(ALLOW_PRAGMA); + DEFINE_FLAG(ALLOW_COLUMN); + DEFINE_FLAG(ALLOW_UPDATE); + DEFINE_FLAG(ALLOW_LEADING_NOT); + +#undef DEFINE_FLAG + + mrb_define_class_method(mrb, klass, "create", + mrb_grn_expression_class_create, + MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "initialize", + mrb_grn_expression_initialize, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "empty?", + mrb_grn_expression_is_empty, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "codes", + mrb_grn_expression_codes, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "[]", + mrb_grn_expression_array_reference, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "condition=", + mrb_grn_expression_set_condition, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "take_object", + mrb_grn_expression_take_object, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "allocate_constant", + mrb_grn_expression_allocate_constant, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "parse", + mrb_grn_expression_parse, MRB_ARGS_ARG(1, 1)); + + mrb_define_method(mrb, klass, "append_object", + mrb_grn_expression_append_object, MRB_ARGS_REQ(2)); + mrb_define_method(mrb, klass, "append_constant", + mrb_grn_expression_append_constant, MRB_ARGS_REQ(3)); + mrb_define_method(mrb, klass, "append_operator", + mrb_grn_expression_append_operator, MRB_ARGS_REQ(2)); +} + +grn_obj * +grn_mrb_expr_rewrite(grn_ctx *ctx, grn_obj *expr) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + mrb_value mrb_expression; + mrb_value mrb_rewritten_expression; + grn_obj *rewritten_expression = NULL; + int arena_index; + + arena_index = mrb_gc_arena_save(mrb); + + mrb_expression = grn_mrb_value_from_grn_obj(mrb, expr); + mrb_rewritten_expression = mrb_funcall(mrb, mrb_expression, "rewrite", 0); + if (mrb_nil_p(mrb_rewritten_expression)) { + goto exit; + } + + if (mrb_type(mrb_rewritten_expression) == MRB_TT_EXCEPTION) { + mrb->exc = mrb_obj_ptr(mrb_rewritten_expression); + mrb_print_error(mrb); + goto exit; + } + + rewritten_expression = DATA_PTR(mrb_rewritten_expression); + +exit: + mrb_gc_arena_restore(mrb, arena_index); + + return rewritten_expression; +} + +scan_info ** +grn_mrb_scan_info_build(grn_ctx *ctx, + grn_obj *expr, + int *n, + grn_operator op, + grn_bool record_exist) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + mrb_value mrb_expression; + mrb_value mrb_sis; + scan_info **sis = NULL; + int i; + int arena_index; + + arena_index = mrb_gc_arena_save(mrb); + + mrb_expression = grn_mrb_value_from_grn_obj(mrb, expr); + mrb_sis = mrb_funcall(mrb, mrb_expression, "build_scan_info", 2, + grn_mrb_value_from_operator(mrb, op), + mrb_bool_value(record_exist)); + + if (mrb_nil_p(mrb_sis)) { + goto exit; + } + + if (mrb_type(mrb_sis) == MRB_TT_EXCEPTION) { + mrb->exc = mrb_obj_ptr(mrb_sis); + mrb_print_error(mrb); + goto exit; + } + + *n = RARRAY_LEN(mrb_sis); + sis = GRN_MALLOCN(scan_info *, *n); + for (i = 0; i < *n; i++) { + mrb_value mrb_si; + mrb_value mrb_si_data; + scan_info *si; + int start; + + mrb_si_data = RARRAY_PTR(mrb_sis)[i]; + start = mrb_fixnum(mrb_funcall(mrb, mrb_si_data, "start", 0)); + si = grn_scan_info_open(ctx, start); + mrb_si = mrb_grn_scan_info_new(mrb, si); + mrb_funcall(mrb, mrb_si, "apply", 1, mrb_si_data); + sis[i] = si; + } + +exit: + mrb_gc_arena_restore(mrb, arena_index); + + return sis; +} + +unsigned int +grn_mrb_expr_estimate_size(grn_ctx *ctx, grn_obj *expr, grn_obj *table) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + mrb_value mrb_expression; + mrb_value mrb_table; + mrb_value mrb_size; + unsigned int size; + int arena_index; + + arena_index = mrb_gc_arena_save(mrb); + + mrb_expression = grn_mrb_value_from_grn_obj(mrb, expr); + mrb_table = grn_mrb_value_from_grn_obj(mrb, table); + mrb_size = mrb_funcall(mrb, mrb_expression, "estimate_size", 1, mrb_table); + if (mrb->exc) { + size = grn_table_size(ctx, table); + } else { + size = mrb_fixnum(mrb_size); + } + + mrb_gc_arena_restore(mrb, arena_index); + + return size; +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_expr.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_expr.h new file mode 100644 index 00000000..22b20220 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_expr.h @@ -0,0 +1,43 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2013-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" +#include "../grn_expr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_expr_init(grn_ctx *ctx); + +grn_obj *grn_mrb_expr_rewrite(grn_ctx *ctx, grn_obj *expr); +scan_info **grn_mrb_scan_info_build(grn_ctx *ctx, + grn_obj *expr, + int *n, + grn_operator op, + grn_bool record_exist); +unsigned int grn_mrb_expr_estimate_size(grn_ctx *ctx, + grn_obj *expr, + grn_obj *table); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_fixed_size_column.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_fixed_size_column.c new file mode 100644 index 00000000..b1545dbc --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_fixed_size_column.c @@ -0,0 +1,59 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2013-2014 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> + +#include "mrb_fixed_size_column.h" + +static struct mrb_data_type mrb_grn_fixed_size_column_type = { + "Groonga::FixedSizeColumn", + NULL +}; + +static mrb_value +mrb_grn_fixed_size_column_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_fixed_size_column_ptr; + + mrb_get_args(mrb, "o", &mrb_fixed_size_column_ptr); + DATA_TYPE(self) = &mrb_grn_fixed_size_column_type; + DATA_PTR(self) = mrb_cptr(mrb_fixed_size_column_ptr); + return self; +} + +void +grn_mrb_fixed_size_column_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *column_class; + struct RClass *klass; + + column_class = mrb_class_get_under(mrb, module, "Column"); + klass = mrb_define_class_under(mrb, module, "FixedSizeColumn", column_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + mrb_define_method(mrb, klass, "initialize", + mrb_grn_fixed_size_column_initialize, MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_fixed_size_column.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_fixed_size_column.h new file mode 100644 index 00000000..9498d337 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_fixed_size_column.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2013-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_fixed_size_column_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_hash_table.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_hash_table.c new file mode 100644 index 00000000..cf9a0d91 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_hash_table.c @@ -0,0 +1,117 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> +#include <mruby/string.h> + +#include "mrb_ctx.h" +#include "mrb_hash_table.h" +#include "mrb_options.h" + +static struct mrb_data_type mrb_grn_hash_table_type = { + "Groonga::HashTable", + NULL +}; + +static mrb_value +mrb_grn_hash_table_class_create(mrb_state *mrb, mrb_value klass) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_options = mrb_nil_value(); + const char *name = NULL; + unsigned int name_size = 0; + const char *path = NULL; + grn_obj_flags flags = GRN_OBJ_TABLE_HASH_KEY; + grn_obj *key_type = NULL; + grn_obj *value_type = NULL; + grn_obj *table; + + mrb_get_args(mrb, "|H", &mrb_options); + + if (!mrb_nil_p(mrb_options)) { + mrb_value mrb_name; + mrb_value mrb_flags; + mrb_value mrb_key_type; + mrb_value mrb_value_type; + + mrb_name = grn_mrb_options_get_lit(mrb, mrb_options, "name"); + if (!mrb_nil_p(mrb_name)) { + name = RSTRING_PTR(mrb_name); + name_size = RSTRING_LEN(mrb_name); + } + + mrb_flags = grn_mrb_options_get_lit(mrb, mrb_options, "flags"); + if (!mrb_nil_p(mrb_flags)) { + flags |= mrb_fixnum(mrb_flags); + } + + mrb_key_type = grn_mrb_options_get_lit(mrb, mrb_options, "key_type"); + if (!mrb_nil_p(mrb_key_type)) { + key_type = DATA_PTR(mrb_key_type); + } + + mrb_value_type = grn_mrb_options_get_lit(mrb, mrb_options, "value_type"); + if (!mrb_nil_p(mrb_value_type)) { + key_type = DATA_PTR(mrb_value_type); + } + } + + table = grn_table_create(ctx, name, name_size, path, flags, + key_type, value_type); + grn_mrb_ctx_check(mrb); + + return mrb_funcall(mrb, klass, "new", 1, mrb_cptr_value(mrb, table)); +} + +static mrb_value +mrb_grn_hash_table_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_hash_table_ptr; + + mrb_get_args(mrb, "o", &mrb_hash_table_ptr); + DATA_TYPE(self) = &mrb_grn_hash_table_type; + DATA_PTR(self) = mrb_cptr(mrb_hash_table_ptr); + return self; +} + +void +grn_mrb_hash_table_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *table_class; + struct RClass *klass; + + table_class = mrb_class_get_under(mrb, module, "Table"); + klass = mrb_define_class_under(mrb, module, "HashTable", table_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_class_method(mrb, klass, "create", + mrb_grn_hash_table_class_create, + MRB_ARGS_OPT(1)); + + mrb_define_method(mrb, klass, "initialize", + mrb_grn_hash_table_initialize, MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_hash_table.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_hash_table.h new file mode 100644 index 00000000..d6b747f0 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_hash_table.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_hash_table_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_id.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_id.c new file mode 100644 index 00000000..d5970fee --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_id.c @@ -0,0 +1,79 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> + +#include "mrb_id.h" + +void +grn_mrb_id_init(grn_ctx *ctx) +{ + mrb_state *mrb = ctx->impl->mrb.state; + struct RClass *module = ctx->impl->mrb.module; + struct RClass *id_module; + + id_module = mrb_define_module_under(mrb, module, "ID"); + + mrb_define_const(mrb, id_module, "NIL", + mrb_fixnum_value(GRN_ID_NIL)); + mrb_define_const(mrb, id_module, "MAX", + mrb_fixnum_value(GRN_ID_MAX)); + + mrb_define_const(mrb, id_module, "VOID", + mrb_fixnum_value(GRN_DB_VOID)); + mrb_define_const(mrb, id_module, "DB", + mrb_fixnum_value(GRN_DB_DB)); + mrb_define_const(mrb, id_module, "OBJECT", + mrb_fixnum_value(GRN_DB_OBJECT)); + mrb_define_const(mrb, id_module, "BOOL", + mrb_fixnum_value(GRN_DB_BOOL)); + mrb_define_const(mrb, id_module, "INT8", + mrb_fixnum_value(GRN_DB_INT8)); + mrb_define_const(mrb, id_module, "UINT8", + mrb_fixnum_value(GRN_DB_UINT8)); + mrb_define_const(mrb, id_module, "INT16", + mrb_fixnum_value(GRN_DB_INT16)); + mrb_define_const(mrb, id_module, "UINT16", + mrb_fixnum_value(GRN_DB_UINT16)); + mrb_define_const(mrb, id_module, "INT32", + mrb_fixnum_value(GRN_DB_INT32)); + mrb_define_const(mrb, id_module, "UINT32", + mrb_fixnum_value(GRN_DB_UINT32)); + mrb_define_const(mrb, id_module, "INT64", + mrb_fixnum_value(GRN_DB_INT64)); + mrb_define_const(mrb, id_module, "UINT64", + mrb_fixnum_value(GRN_DB_UINT64)); + mrb_define_const(mrb, id_module, "FLOAT", + mrb_fixnum_value(GRN_DB_FLOAT)); + mrb_define_const(mrb, id_module, "TIME", + mrb_fixnum_value(GRN_DB_TIME)); + mrb_define_const(mrb, id_module, "SHORT_TEXT", + mrb_fixnum_value(GRN_DB_SHORT_TEXT)); + mrb_define_const(mrb, id_module, "TEXT", + mrb_fixnum_value(GRN_DB_TEXT)); + mrb_define_const(mrb, id_module, "LONG_TEXT", + mrb_fixnum_value(GRN_DB_LONG_TEXT)); + mrb_define_const(mrb, id_module, "TOKYO_GEO_POINT", + mrb_fixnum_value(GRN_DB_TOKYO_GEO_POINT)); + mrb_define_const(mrb, id_module, "WGS84_GEO_POINT", + mrb_fixnum_value(GRN_DB_WGS84_GEO_POINT)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_id.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_id.h new file mode 100644 index 00000000..b5418b73 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_id.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_id_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_index_column.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_index_column.c new file mode 100644 index 00000000..02a3901b --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_index_column.c @@ -0,0 +1,199 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" +#include "../grn_ii.h" +#include <string.h> + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/array.h> +#include <mruby/class.h> +#include <mruby/data.h> + +#include "mrb_ctx.h" +#include "mrb_converter.h" +#include "mrb_index_column.h" +#include "mrb_operator.h" +#include "mrb_options.h" + +static struct mrb_data_type mrb_grn_index_column_type = { + "Groonga::IndexColumn", + NULL +}; + +static mrb_value +mrb_grn_index_column_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_index_column_ptr; + + mrb_get_args(mrb, "o", &mrb_index_column_ptr); + DATA_TYPE(self) = &mrb_grn_index_column_type; + DATA_PTR(self) = mrb_cptr(mrb_index_column_ptr); + return self; +} + +static mrb_value +mrb_grn_index_column_get_lexicon(mrb_state *mrb, mrb_value self) +{ + grn_obj *index_column; + grn_obj *lexicon; + + index_column = DATA_PTR(self); + lexicon = ((grn_ii *)index_column)->lexicon; + + return grn_mrb_value_from_grn_obj(mrb, lexicon); +} + +static mrb_value +mrb_grn_index_column_get_source_ids(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *index_column; + grn_obj source_ids; + unsigned int i, n_ids; + mrb_value mrb_source_ids; + + index_column = DATA_PTR(self); + GRN_RECORD_INIT(&source_ids, GRN_OBJ_VECTOR, GRN_DB_VOID); + grn_obj_get_info(ctx, index_column, GRN_INFO_SOURCE, &source_ids); + n_ids = GRN_BULK_VSIZE(&source_ids) / sizeof(grn_id); + + mrb_source_ids = mrb_ary_new_capa(mrb, n_ids); + for (i = 0; i < n_ids; i++) { + grn_id source_id = GRN_RECORD_VALUE_AT(&source_ids, i); + mrb_ary_push(mrb, mrb_source_ids, mrb_fixnum_value(source_id)); + } + + GRN_OBJ_FIN(ctx, &source_ids); + + return mrb_source_ids; +} + +static mrb_value +mrb_grn_index_column_estimate_size_for_term_id(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *index_column; + mrb_int term_id; + unsigned int size; + + index_column = DATA_PTR(self); + mrb_get_args(mrb, "i", &term_id); + + size = grn_ii_estimate_size(ctx, (grn_ii *)index_column, term_id); + return mrb_fixnum_value(size); +} + +static mrb_value +mrb_grn_index_column_estimate_size_for_query(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *index_column; + grn_obj *lexicon; + mrb_value mrb_query; + void *query; + unsigned int query_size; + grn_mrb_value_to_raw_data_buffer buffer; + mrb_value mrb_options = mrb_nil_value(); + grn_search_optarg optarg; + unsigned int size; + + index_column = DATA_PTR(self); + mrb_get_args(mrb, "o|H", &mrb_query, &mrb_options); + + lexicon = grn_ctx_at(ctx, index_column->header.domain); + grn_mrb_value_to_raw_data_buffer_init(mrb, &buffer); + grn_mrb_value_to_raw_data(mrb, "query", mrb_query, lexicon->header.domain, + &buffer, &query, &query_size); + + memset(&optarg, 0, sizeof(grn_search_optarg)); + optarg.mode = GRN_OP_EXACT; + + if (!mrb_nil_p(mrb_options)) { + mrb_value mrb_mode; + + mrb_mode = grn_mrb_options_get_lit(mrb, mrb_options, "mode"); + if (!mrb_nil_p(mrb_mode)) { + optarg.mode = grn_mrb_value_to_operator(mrb, mrb_mode); + } + } + + size = grn_ii_estimate_size_for_query(ctx, (grn_ii *)index_column, + query, query_size, &optarg); + grn_mrb_value_to_raw_data_buffer_fin(mrb, &buffer); + + grn_mrb_ctx_check(mrb); + + return mrb_fixnum_value(size); +} + +static mrb_value +mrb_grn_index_column_estimate_size_for_lexicon_cursor(mrb_state *mrb, + mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *index_column; + mrb_value mrb_lexicon_cursor; + grn_table_cursor *lexicon_cursor; + unsigned int size; + + index_column = DATA_PTR(self); + mrb_get_args(mrb, "o", &mrb_lexicon_cursor); + + lexicon_cursor = DATA_PTR(mrb_lexicon_cursor); + size = grn_ii_estimate_size_for_lexicon_cursor(ctx, + (grn_ii *)index_column, + lexicon_cursor); + return mrb_fixnum_value(size); +} + +void +grn_mrb_index_column_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *column_class; + struct RClass *klass; + + column_class = mrb_class_get_under(mrb, module, "Column"); + klass = mrb_define_class_under(mrb, module, "IndexColumn", column_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + mrb_define_method(mrb, klass, "initialize", + mrb_grn_index_column_initialize, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "lexicon", + mrb_grn_index_column_get_lexicon, + MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "source_ids", + mrb_grn_index_column_get_source_ids, + MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "estimate_size_for_term_id", + mrb_grn_index_column_estimate_size_for_term_id, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "estimate_size_for_query", + mrb_grn_index_column_estimate_size_for_query, + MRB_ARGS_ARG(1, 1)); + mrb_define_method(mrb, klass, "estimate_size_for_lexicon_cursor", + mrb_grn_index_column_estimate_size_for_lexicon_cursor, + MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_index_column.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_index_column.h new file mode 100644 index 00000000..085a2d3a --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_index_column.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_index_column_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_index_cursor.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_index_cursor.c new file mode 100644 index 00000000..20f1e64f --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_index_cursor.c @@ -0,0 +1,245 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" +#include "../grn_ii.h" +#include "../grn_db.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> +#include <mruby/string.h> +#include <mruby/hash.h> +#include <mruby/variable.h> + +#include "mrb_ctx.h" +#include "mrb_index_cursor.h" +#include "mrb_converter.h" +#include "mrb_options.h" + +static struct mrb_data_type mrb_grn_index_cursor_type = { + "Groonga::IndexCursor", + NULL +}; + +static mrb_value +mrb_grn_index_cursor_class_open_raw(mrb_state *mrb, mrb_value klass) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_table_cursor; + mrb_value mrb_index; + mrb_value mrb_options = mrb_nil_value(); + grn_obj *index_cursor; + grn_table_cursor *table_cursor; + grn_obj *index; + grn_id rid_min = GRN_ID_NIL; + grn_id rid_max = GRN_ID_MAX; + int flags = 0; + mrb_value mrb_index_cursor; + + mrb_get_args(mrb, "oo|H", &mrb_table_cursor, &mrb_index, &mrb_options); + + table_cursor = DATA_PTR(mrb_table_cursor); + index = DATA_PTR(mrb_index); + if (!mrb_nil_p(mrb_options)) { + /* TODO */ + } + index_cursor = grn_index_cursor_open(ctx, table_cursor, index, + rid_min, rid_max, flags); + grn_mrb_ctx_check(mrb); + + mrb_index_cursor = mrb_funcall(mrb, klass, "new", 1, + mrb_cptr_value(mrb, index_cursor)); + mrb_iv_set(mrb, mrb_index_cursor, mrb_intern_lit(mrb, "@index"), mrb_index); + return mrb_index_cursor; +} + +static mrb_value +mrb_grn_index_cursor_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_index_cursor_ptr; + + mrb_get_args(mrb, "o", &mrb_index_cursor_ptr); + DATA_TYPE(self) = &mrb_grn_index_cursor_type; + DATA_PTR(self) = mrb_cptr(mrb_index_cursor_ptr); + + return self; +} + +static mrb_value +mrb_grn_index_cursor_close(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *index_cursor; + + index_cursor = DATA_PTR(self); + if (index_cursor) { + DATA_PTR(self) = NULL; + grn_obj_close(ctx, index_cursor); + grn_mrb_ctx_check(mrb); + } + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_index_cursor_count(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_id term_id; + int n_records = 0; + + while (grn_index_cursor_next(ctx, DATA_PTR(self), &term_id)) { + n_records++; + } + + return mrb_fixnum_value(n_records); +} + +static mrb_value +mrb_grn_index_cursor_select(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_result_set; + mrb_value mrb_options; + grn_obj *index_cursor; + grn_obj *expr = NULL; + grn_obj *expr_variable = NULL; + int offset = 0; + int limit = 10; + int max_n_unmatched_records = -1; + int n_matched_records = 0; + int n_unmatched_records = 0; + mrb_value mrb_index; + grn_obj *index; + grn_obj *lexicon; + grn_obj *data_table; + grn_hash *result_set; + grn_posting *posting; + grn_id term_id; + grn_operator op = GRN_OP_OR; + + mrb_get_args(mrb, "o|H", &mrb_result_set, &mrb_options); + + index_cursor = DATA_PTR(self); + result_set = DATA_PTR(mrb_result_set); + + if (!mrb_nil_p(mrb_options)) { + mrb_value mrb_expr; + mrb_value mrb_offset; + mrb_value mrb_limit; + mrb_value mrb_max_n_unmatched_records; + + mrb_expr = grn_mrb_options_get_lit(mrb, mrb_options, "expression"); + if (!mrb_nil_p(mrb_expr)) { + expr = DATA_PTR(mrb_expr); + expr_variable = grn_expr_get_var_by_offset(ctx, expr, 0); + } + + mrb_offset = grn_mrb_options_get_lit(mrb, mrb_options, "offset"); + if (!mrb_nil_p(mrb_offset)) { + offset = mrb_fixnum(mrb_offset); + } + + mrb_limit = grn_mrb_options_get_lit(mrb, mrb_options, "limit"); + if (!mrb_nil_p(mrb_limit)) { + limit = mrb_fixnum(mrb_limit); + } + + mrb_max_n_unmatched_records = + grn_mrb_options_get_lit(mrb, mrb_options, "max_n_unmatched_records"); + if (!mrb_nil_p(mrb_max_n_unmatched_records)) { + max_n_unmatched_records = mrb_fixnum(mrb_max_n_unmatched_records); + } + } + + if (limit <= 0) { + return mrb_fixnum_value(n_matched_records); + } + + mrb_index = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@index")); + index = DATA_PTR(mrb_index); + lexicon = ((grn_ii *)index)->lexicon; + data_table = grn_ctx_at(ctx, grn_obj_get_range(ctx, index)); + + if (max_n_unmatched_records < 0) { + max_n_unmatched_records = INT32_MAX; + } + while ((posting = grn_index_cursor_next(ctx, index_cursor, &term_id))) { + if (expr) { + grn_bool matched_raw = GRN_FALSE; + grn_obj *matched; + + GRN_RECORD_SET(ctx, expr_variable, posting->rid); + matched = grn_expr_exec(ctx, expr, 0); + if (matched) { + matched_raw = grn_obj_is_true(ctx, matched); + } else { + grn_mrb_ctx_check(mrb); + } + + if (!matched_raw) { + n_unmatched_records++; + if (n_unmatched_records > max_n_unmatched_records) { + return mrb_fixnum_value(-1); + } + continue; + } + } + n_matched_records++; + if (offset > 0) { + offset--; + continue; + } + grn_ii_posting_add(ctx, posting, result_set, op); + limit--; + if (limit == 0) { + break; + } + } + grn_ii_resolve_sel_and(ctx, result_set, op); + + return mrb_fixnum_value(n_matched_records); +} + +void +grn_mrb_index_cursor_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "IndexCursor", mrb->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_class_method(mrb, klass, "open_raw", + mrb_grn_index_cursor_class_open_raw, + MRB_ARGS_ARG(2, 1)); + + mrb_define_method(mrb, klass, "initialize", + mrb_grn_index_cursor_initialize, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "close", + mrb_grn_index_cursor_close, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "count", + mrb_grn_index_cursor_count, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "select", + mrb_grn_index_cursor_select, MRB_ARGS_ARG(1, 1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_index_cursor.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_index_cursor.h new file mode 100644 index 00000000..c1026002 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_index_cursor.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_index_cursor_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_indexable.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_indexable.c new file mode 100644 index 00000000..cd8f44ae --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_indexable.c @@ -0,0 +1,170 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2013-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" +#include "../grn_db.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/array.h> +#include <mruby/data.h> + +#include "mrb_ctx.h" +#include "mrb_indexable.h" +#include "mrb_operator.h" +#include "mrb_converter.h" + +static mrb_value +indexable_find_index(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *object; + mrb_value mrb_operator; + grn_operator operator; + grn_index_datum index_datum; + int n_index_data; + + mrb_get_args(mrb, "o", &mrb_operator); + object = DATA_PTR(self); + operator = grn_mrb_value_to_operator(mrb, mrb_operator); + n_index_data = grn_column_find_index_data(ctx, + object, + operator, + &index_datum, + 1); + if (n_index_data == 0) { + return mrb_nil_value(); + } else { + grn_mrb_data *data; + struct RClass *klass; + mrb_value args[2]; + + data = &(ctx->impl->mrb); + klass = mrb_class_get_under(mrb, data->module, "IndexInfo"); + args[0] = grn_mrb_value_from_grn_obj(mrb, index_datum.index); + args[1] = mrb_fixnum_value(index_datum.section); + return mrb_obj_new(mrb, klass, 2, args); + } +} + +static mrb_value +indexable_indexes(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *object; + grn_index_datum index_datum; + grn_index_datum *index_data; + int i, n_index_data; + mrb_value mrb_indexes; + + object = DATA_PTR(self); + n_index_data = grn_column_get_all_index_data(ctx, object, &index_datum, 1); + if (n_index_data == 0) { + return mrb_ary_new(mrb); + } + + if (n_index_data == 1) { + index_data = &index_datum; + } else { + index_data = GRN_MALLOCN(grn_index_datum, n_index_data); + n_index_data = grn_column_get_all_index_data(ctx, + object, + index_data, + n_index_data); + } + + mrb_indexes = mrb_ary_new_capa(mrb, n_index_data); + for (i = 0; i < n_index_data; i++) { + grn_mrb_data *data; + struct RClass *klass; + mrb_value args[2]; + + data = &(ctx->impl->mrb); + klass = mrb_class_get_under(mrb, data->module, "IndexInfo"); + args[0] = grn_mrb_value_from_grn_obj(mrb, index_data[i].index); + args[1] = mrb_fixnum_value(index_data[i].section); + mrb_ary_push(mrb, mrb_indexes, mrb_obj_new(mrb, klass, 2, args)); + } + + if (index_data != &index_datum) { + GRN_FREE(index_data); + } + + return mrb_indexes; +} + +static mrb_value +indexable_index_ids(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *object; + grn_hook_entry entry; + int i; + int n_indexes; + mrb_value mrb_index_ids; + grn_obj hook_data; + + object = DATA_PTR(self); + + if (grn_obj_is_key_accessor(ctx, object)) { + object = grn_ctx_at(ctx, object->header.domain); + } + if (grn_obj_is_table(ctx, object)) { + entry = GRN_HOOK_INSERT; + } else if (grn_obj_is_column(ctx, object)) { + entry = GRN_HOOK_SET; + } else { + return mrb_ary_new(mrb); + } + n_indexes = grn_obj_get_nhooks(ctx, object, entry); + + mrb_index_ids = mrb_ary_new_capa(mrb, n_indexes); + + GRN_TEXT_INIT(&hook_data, 0); + for (i = 0; i < n_indexes; i++) { + GRN_BULK_REWIND(&hook_data); + grn_obj_get_hook(ctx, object, entry, i, &hook_data); + if (GRN_BULK_VSIZE(&hook_data) == + sizeof(grn_obj_default_set_value_hook_data)) { + grn_obj_default_set_value_hook_data *data; + + data = (grn_obj_default_set_value_hook_data *)GRN_TEXT_VALUE(&hook_data); + mrb_ary_push(mrb, mrb_index_ids, mrb_fixnum_value(data->target)); + } + } + + return mrb_index_ids; +} + +void +grn_mrb_indexable_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module; + + module = mrb_define_module_under(mrb, data->module, "Indexable"); + + mrb_define_method(mrb, module, "find_index", + indexable_find_index, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, module, "indexes", + indexable_indexes, MRB_ARGS_NONE()); + mrb_define_method(mrb, module, "index_ids", + indexable_index_ids, MRB_ARGS_NONE()); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_indexable.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_indexable.h new file mode 100644 index 00000000..3b191c72 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_indexable.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_indexable_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_logger.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_logger.c new file mode 100644 index 00000000..d5ed72df --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_logger.c @@ -0,0 +1,99 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2017 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> +#include <mruby/variable.h> +#include <mruby/string.h> + +#include "../grn_mrb.h" +#include "mrb_logger.h" + +static mrb_value +logger_s_get_default_path(mrb_state *mrb, mrb_value self) +{ + return mrb_str_new_cstr(mrb, grn_default_logger_get_path()); +} + +static mrb_value +logger_s_get_default_level(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_level_class; + mrb_value mrb_level; + + mrb_level_class = mrb_const_get(mrb, self, mrb_intern_lit(mrb, "Level")); + mrb_level = mrb_fixnum_value(grn_default_logger_get_max_level()); + return mrb_funcall(mrb, mrb_level_class, "find", 1, mrb_level); +} + +static mrb_value +logger_need_log_p(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_int level; + + mrb_get_args(mrb, "i", &level); + + return mrb_bool_value(grn_logger_pass(ctx, level)); +} + +static mrb_value +logger_log(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_int level; + char *file; + mrb_int line; + char *method; + char *message; + mrb_int message_size; + + mrb_get_args(mrb, "izizs", + &level, &file, &line, &method, &message, &message_size); + grn_logger_put(ctx, level, file, line, method, + "%.*s", (int)message_size, message); + + return self; +} + +void +grn_mrb_logger_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "Logger", mrb->object_class); + + mrb_define_singleton_method(mrb, (struct RObject *)klass, "default_path", + logger_s_get_default_path, MRB_ARGS_NONE()); + mrb_define_singleton_method(mrb, (struct RObject *)klass, "default_level", + logger_s_get_default_level, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "need_log?", logger_need_log_p, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "log", logger_log, MRB_ARGS_REQ(5)); + + grn_mrb_load(ctx, "logger/level.rb"); + grn_mrb_load(ctx, "logger.rb"); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_logger.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_logger.h new file mode 100644 index 00000000..d23ddb19 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_logger.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_logger_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_object.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_object.c new file mode 100644 index 00000000..874d4add --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_object.c @@ -0,0 +1,346 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2013-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" +#include "../grn_util.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/string.h> +#include <mruby/class.h> +#include <mruby/data.h> + +#include "../grn_mrb.h" +#include "mrb_ctx.h" +#include "mrb_object.h" +#include "mrb_operator.h" +#include "mrb_options.h" +#include "mrb_converter.h" + +static mrb_value +object_remove_force(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + char *name; + mrb_int name_size; + + mrb_get_args(mrb, "s", &name, &name_size); + grn_obj_remove_force(ctx, name, name_size); + grn_mrb_ctx_check(mrb); + + return mrb_nil_value(); +} + +mrb_value +grn_mrb_object_inspect(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *object; + mrb_value inspected; + + object = DATA_PTR(self); + inspected = mrb_str_buf_new(mrb, 48); + + mrb_str_cat_lit(mrb, inspected, "#<"); + mrb_str_cat_cstr(mrb, inspected, mrb_obj_classname(mrb, self)); + mrb_str_cat_lit(mrb, inspected, ":"); + mrb_str_concat(mrb, inspected, mrb_ptr_to_str(mrb, mrb_cptr(self))); + if (object) { + grn_obj buffer; + GRN_TEXT_INIT(&buffer, 0); + grn_inspect(ctx, &buffer, object); + mrb_str_cat_lit(mrb, inspected, " "); + mrb_str_cat(mrb, inspected, GRN_TEXT_VALUE(&buffer), GRN_TEXT_LEN(&buffer)); + GRN_OBJ_FIN(ctx, &buffer); + } else { + mrb_str_cat_lit(mrb, inspected, " (closed)"); + } + mrb_str_cat_lit(mrb, inspected, ">"); + + return inspected; +} + +static mrb_value +object_get_id(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_id id; + + id = grn_obj_id(ctx, DATA_PTR(self)); + + return mrb_fixnum_value(id); +} + +static mrb_value +object_get_name(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *object; + char name[GRN_TABLE_MAX_KEY_SIZE]; + int name_length; + + object = DATA_PTR(self); + name_length = grn_obj_name(ctx, object, name, GRN_TABLE_MAX_KEY_SIZE); + + if (name_length == 0) { + return mrb_nil_value(); + } else { + return mrb_str_new(mrb, name, name_length); + } +} + +static mrb_value +object_get_path(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *object; + const char *path; + + object = DATA_PTR(self); + path = grn_obj_path(ctx, object); + + if (path) { + return mrb_str_new_cstr(mrb, path); + } else { + return mrb_nil_value(); + } +} + +static mrb_value +object_grn_inspect(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj buffer; + mrb_value inspected; + + GRN_TEXT_INIT(&buffer, 0); + grn_inspect(ctx, &buffer, DATA_PTR(self)); + inspected = mrb_str_new(mrb, GRN_TEXT_VALUE(&buffer), GRN_TEXT_LEN(&buffer)); + GRN_OBJ_FIN(ctx, &buffer); + + return inspected; +} + +static mrb_value +object_equal(mrb_state *mrb, mrb_value self) +{ + grn_obj *object, *other_object; + mrb_value mrb_other; + + mrb_get_args(mrb, "o", &mrb_other); + if (!mrb_obj_is_kind_of(mrb, mrb_other, mrb_obj_class(mrb, self))) { + return mrb_false_value(); + } + + object = DATA_PTR(self); + other_object = DATA_PTR(mrb_other); + return mrb_bool_value(object == other_object); +} + +static mrb_value +object_hash(mrb_state *mrb, mrb_value self) +{ + grn_obj *object; + + object = DATA_PTR(self); + return mrb_fixnum_value((mrb_int)((uint64_t)object)); +} + +static mrb_value +object_close(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *object; + + object = DATA_PTR(self); + if (!object) { + mrb_raise(mrb, E_ARGUMENT_ERROR, "already closed object"); + } + + grn_obj_close(ctx, object); + DATA_PTR(self) = NULL; + + return mrb_nil_value(); +} + +static mrb_value +object_remove(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_options = mrb_nil_value(); + grn_bool dependent = GRN_FALSE; + grn_obj *object; + + mrb_get_args(mrb, "|H", &mrb_options); + if (!mrb_nil_p(mrb_options)) { + mrb_value mrb_dependent; + mrb_dependent = grn_mrb_options_get_lit(mrb, mrb_options, "dependent"); + dependent = mrb_test(mrb_dependent); + } + + object = DATA_PTR(self); + if (dependent) { + grn_obj_remove_dependent(ctx, object); + } else { + grn_obj_remove(ctx, object); + } + grn_mrb_ctx_check(mrb); + + DATA_PTR(self) = NULL; + + return mrb_nil_value(); +} + +static mrb_value +object_is_closed(mrb_state *mrb, mrb_value self) +{ + grn_obj *object; + + object = DATA_PTR(self); + return mrb_bool_value(object == NULL); +} + +static mrb_value +object_get_domain_id(mrb_state *mrb, mrb_value self) +{ + grn_obj *object; + grn_id domain_id; + + object = DATA_PTR(self); + domain_id = object->header.domain; + + if (domain_id == GRN_ID_NIL) { + return mrb_nil_value(); + } else { + return mrb_fixnum_value(domain_id); + } +} + +static mrb_value +object_get_range_id(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *object; + grn_id range_id; + + object = DATA_PTR(self); + range_id = grn_obj_get_range(ctx, object); + + if (range_id == GRN_ID_NIL) { + return mrb_nil_value(); + } else { + return mrb_fixnum_value(range_id); + } +} + +static mrb_value +object_is_temporary(mrb_state *mrb, mrb_value self) +{ + grn_obj *object; + grn_obj_flags flags; + + object = DATA_PTR(self); + flags = object->header.flags; + return mrb_bool_value((flags & GRN_OBJ_PERSISTENT) != GRN_OBJ_PERSISTENT); +} + +static mrb_value +object_is_persistent(mrb_state *mrb, mrb_value self) +{ + grn_obj *object; + grn_obj_flags flags; + + object = DATA_PTR(self); + flags = object->header.flags; + return mrb_bool_value((flags & GRN_OBJ_PERSISTENT) == GRN_OBJ_PERSISTENT); +} + +static mrb_value +object_is_true(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *object; + + object = DATA_PTR(self); + return mrb_bool_value(grn_obj_is_true(ctx, object)); +} + +static mrb_value +object_check_corrupt(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *object; + grn_bool is_corrupt; + + object = DATA_PTR(self); + is_corrupt = grn_obj_is_corrupt(ctx, object); + grn_mrb_ctx_check(mrb); + return mrb_bool_value(is_corrupt); +} + +void +grn_mrb_object_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "Object", mrb->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + data->object_class = klass; + + mrb_define_class_method(mrb, + klass, + "remove_force", + object_remove_force, + MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "inspect", + grn_mrb_object_inspect, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "id", object_get_id, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "name", object_get_name, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "path", object_get_path, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "grn_inspect", + object_grn_inspect, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "==", object_equal, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "eql?", object_equal, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "hash", object_hash, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "close", object_close, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "remove", object_remove, MRB_ARGS_OPT(1)); + mrb_define_method(mrb, klass, "closed?", object_is_closed, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "domain_id", object_get_domain_id, + MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "range_id", object_get_range_id, + MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "temporary?", object_is_temporary, + MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "persistent?", object_is_persistent, + MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "true?", object_is_true, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "check_corrupt", object_check_corrupt, + MRB_ARGS_NONE()); + + grn_mrb_load(ctx, "index_info.rb"); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_object.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_object.h new file mode 100644 index 00000000..5650ba28 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_object.h @@ -0,0 +1,34 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2013-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_object_init(grn_ctx *ctx); + +mrb_value grn_mrb_object_inspect(mrb_state *mrb, mrb_value self); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_object_flags.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_object_flags.c new file mode 100644 index 00000000..1fb70299 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_object_flags.c @@ -0,0 +1,96 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +# include <mruby.h> +# include <mruby/string.h> +# include <mruby/class.h> +# include <mruby/data.h> + +# include "../grn_mrb.h" +# include "mrb_object.h" +# include "mrb_operator.h" +# include "mrb_converter.h" + +void +grn_mrb_object_flags_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *flags_module; + + flags_module = mrb_define_module_under(mrb, module, "ObjectFlags"); + +#define MRB_DEFINE_FLAG(name) \ + mrb_define_const(mrb, flags_module, #name, \ + mrb_fixnum_value(GRN_OBJ_ ## name)) + + MRB_DEFINE_FLAG(TABLE_TYPE_MASK); + MRB_DEFINE_FLAG(TABLE_HASH_KEY); + MRB_DEFINE_FLAG(TABLE_PAT_KEY); + MRB_DEFINE_FLAG(TABLE_DAT_KEY); + MRB_DEFINE_FLAG(TABLE_NO_KEY); + + MRB_DEFINE_FLAG(KEY_MASK); + MRB_DEFINE_FLAG(KEY_UINT); + MRB_DEFINE_FLAG(KEY_INT); + MRB_DEFINE_FLAG(KEY_FLOAT); + MRB_DEFINE_FLAG(KEY_GEO_POINT); + + MRB_DEFINE_FLAG(KEY_WITH_SIS); + MRB_DEFINE_FLAG(KEY_NORMALIZE); + + MRB_DEFINE_FLAG(COLUMN_TYPE_MASK); + MRB_DEFINE_FLAG(COLUMN_SCALAR); + MRB_DEFINE_FLAG(COLUMN_VECTOR); + MRB_DEFINE_FLAG(COLUMN_INDEX); + + MRB_DEFINE_FLAG(COMPRESS_MASK); + MRB_DEFINE_FLAG(COMPRESS_NONE); + MRB_DEFINE_FLAG(COMPRESS_ZLIB); + MRB_DEFINE_FLAG(COMPRESS_LZ4); + MRB_DEFINE_FLAG(COMPRESS_ZSTD); + + MRB_DEFINE_FLAG(WITH_SECTION); + MRB_DEFINE_FLAG(WITH_WEIGHT); + MRB_DEFINE_FLAG(WITH_POSITION); + MRB_DEFINE_FLAG(RING_BUFFER); + + MRB_DEFINE_FLAG(UNIT_MASK); + MRB_DEFINE_FLAG(UNIT_DOCUMENT_NONE); + MRB_DEFINE_FLAG(UNIT_DOCUMENT_SECTION); + MRB_DEFINE_FLAG(UNIT_DOCUMENT_POSITION); + MRB_DEFINE_FLAG(UNIT_SECTION_NONE); + MRB_DEFINE_FLAG(UNIT_SECTION_POSITION); + MRB_DEFINE_FLAG(UNIT_POSITION_NONE); + MRB_DEFINE_FLAG(UNIT_USERDEF_DOCUMENT); + MRB_DEFINE_FLAG(UNIT_USERDEF_SECTION); + MRB_DEFINE_FLAG(UNIT_USERDEF_POSITION); + + MRB_DEFINE_FLAG(NO_SUBREC); + MRB_DEFINE_FLAG(WITH_SUBREC); + + MRB_DEFINE_FLAG(KEY_VAR_SIZE); + + MRB_DEFINE_FLAG(TEMPORARY); + MRB_DEFINE_FLAG(PERSISTENT); +} +#endif /* GRN_WITH_MRUBY */ diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_object_flags.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_object_flags.h new file mode 100644 index 00000000..6f7bd7f7 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_object_flags.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_object_flags_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_operator.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_operator.c new file mode 100644 index 00000000..e0ef4727 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_operator.c @@ -0,0 +1,155 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> + +#include "mrb_operator.h" + +mrb_value +grn_mrb_value_from_operator(mrb_state *mrb, grn_operator op) +{ + grn_ctx *ctx = (grn_ctx *)(mrb->ud); + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_value mrb_op_raw; + mrb_value mrb_op; + + mrb_op_raw = mrb_fixnum_value(op); + mrb_op = mrb_funcall(mrb, mrb_obj_value(data->groonga.operator_class), + "find", 1, mrb_op_raw); + if (mrb_nil_p(mrb_op)) { + return mrb_op_raw; + } else { + return mrb_op; + } +} + +grn_operator +grn_mrb_value_to_operator(mrb_state *mrb, mrb_value mrb_op) +{ + if (!mrb_fixnum_p(mrb_op)) { + mrb_op = mrb_funcall(mrb, mrb_op, "value", 0); + } + + return mrb_fixnum(mrb_op); +} + +void +grn_mrb_operator_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = ctx->impl->mrb.module; + struct RClass *klass; + mrb_value klass_obj; + + klass = mrb_class_get_under(mrb, module, "Operator"); + data->groonga.operator_class = klass; + + klass_obj = mrb_obj_value(klass); +#define DEFINE_OPERATOR(name) \ + mrb_funcall(mrb, klass_obj, "register", 1, \ + mrb_funcall(mrb, klass_obj, "new", 2, \ + mrb_str_new_lit(mrb, #name), \ + mrb_fixnum_value(GRN_OP_ ## name))) + + DEFINE_OPERATOR(PUSH); + DEFINE_OPERATOR(POP); + DEFINE_OPERATOR(NOP); + DEFINE_OPERATOR(CALL); + DEFINE_OPERATOR(INTERN); + DEFINE_OPERATOR(GET_REF); + DEFINE_OPERATOR(GET_VALUE); + DEFINE_OPERATOR(AND); + DEFINE_OPERATOR(AND_NOT); + DEFINE_OPERATOR(OR); + DEFINE_OPERATOR(ASSIGN); + DEFINE_OPERATOR(STAR_ASSIGN); + DEFINE_OPERATOR(SLASH_ASSIGN); + DEFINE_OPERATOR(MOD_ASSIGN); + DEFINE_OPERATOR(PLUS_ASSIGN); + DEFINE_OPERATOR(MINUS_ASSIGN); + DEFINE_OPERATOR(SHIFTL_ASSIGN); + DEFINE_OPERATOR(SHIFTR_ASSIGN); + DEFINE_OPERATOR(SHIFTRR_ASSIGN); + DEFINE_OPERATOR(AND_ASSIGN); + DEFINE_OPERATOR(XOR_ASSIGN); + DEFINE_OPERATOR(OR_ASSIGN); + DEFINE_OPERATOR(JUMP); + DEFINE_OPERATOR(CJUMP); + DEFINE_OPERATOR(COMMA); + DEFINE_OPERATOR(BITWISE_OR); + DEFINE_OPERATOR(BITWISE_XOR); + DEFINE_OPERATOR(BITWISE_AND); + DEFINE_OPERATOR(BITWISE_NOT); + DEFINE_OPERATOR(EQUAL); + DEFINE_OPERATOR(NOT_EQUAL); + DEFINE_OPERATOR(LESS); + DEFINE_OPERATOR(GREATER); + DEFINE_OPERATOR(LESS_EQUAL); + DEFINE_OPERATOR(GREATER_EQUAL); + DEFINE_OPERATOR(IN); + DEFINE_OPERATOR(MATCH); + DEFINE_OPERATOR(NEAR); + DEFINE_OPERATOR(NEAR2); + DEFINE_OPERATOR(SIMILAR); + DEFINE_OPERATOR(TERM_EXTRACT); + DEFINE_OPERATOR(SHIFTL); + DEFINE_OPERATOR(SHIFTR); + DEFINE_OPERATOR(SHIFTRR); + DEFINE_OPERATOR(PLUS); + DEFINE_OPERATOR(MINUS); + DEFINE_OPERATOR(STAR); + DEFINE_OPERATOR(SLASH); + DEFINE_OPERATOR(MOD); + DEFINE_OPERATOR(DELETE); + DEFINE_OPERATOR(INCR); + DEFINE_OPERATOR(DECR); + DEFINE_OPERATOR(INCR_POST); + DEFINE_OPERATOR(DECR_POST); + DEFINE_OPERATOR(NOT); + DEFINE_OPERATOR(ADJUST); + DEFINE_OPERATOR(EXACT); + DEFINE_OPERATOR(LCP); + DEFINE_OPERATOR(PARTIAL); + DEFINE_OPERATOR(UNSPLIT); + DEFINE_OPERATOR(PREFIX); + DEFINE_OPERATOR(SUFFIX); + DEFINE_OPERATOR(GEO_DISTANCE1); + DEFINE_OPERATOR(GEO_DISTANCE2); + DEFINE_OPERATOR(GEO_DISTANCE3); + DEFINE_OPERATOR(GEO_DISTANCE4); + DEFINE_OPERATOR(GEO_WITHINP5); + DEFINE_OPERATOR(GEO_WITHINP6); + DEFINE_OPERATOR(GEO_WITHINP8); + DEFINE_OPERATOR(OBJ_SEARCH); + DEFINE_OPERATOR(EXPR_GET_VAR); + DEFINE_OPERATOR(TABLE_CREATE); + DEFINE_OPERATOR(TABLE_SELECT); + DEFINE_OPERATOR(TABLE_SORT); + DEFINE_OPERATOR(TABLE_GROUP); + DEFINE_OPERATOR(JSON_PUT); + DEFINE_OPERATOR(GET_MEMBER); + DEFINE_OPERATOR(REGEXP); + DEFINE_OPERATOR(FUZZY); + +#undef DEFINE_OPERATOR +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_operator.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_operator.h new file mode 100644 index 00000000..6f27e137 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_operator.h @@ -0,0 +1,34 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_operator_init(grn_ctx *ctx); +mrb_value grn_mrb_value_from_operator(mrb_state *mrb, grn_operator op); +grn_operator grn_mrb_value_to_operator(mrb_state *mrb, mrb_value mrb_op); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_options.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_options.c new file mode 100644 index 00000000..445bcaf6 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_options.c @@ -0,0 +1,39 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" +#include "../grn_db.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/hash.h> + +#include "mrb_options.h" + +mrb_value +grn_mrb_options_get_static(mrb_state *mrb, + mrb_value mrb_options, + const char *key, + size_t key_size) +{ + mrb_sym mrb_key; + + mrb_key = mrb_intern_static(mrb, key, key_size); + return mrb_hash_get(mrb, mrb_options, mrb_symbol_value(mrb_key)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_options.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_options.h new file mode 100644 index 00000000..0cbd7bb7 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_options.h @@ -0,0 +1,38 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +mrb_value grn_mrb_options_get_static(mrb_state *mrb, + mrb_value mrb_options, + const char *key, + size_t key_size); +#define grn_mrb_options_get_lit(mrb, mrb_options, literal) \ + grn_mrb_options_get_static(mrb, mrb_options, \ + (literal), mrb_strlen_lit(literal)) + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_patricia_trie.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_patricia_trie.c new file mode 100644 index 00000000..bd206b5c --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_patricia_trie.c @@ -0,0 +1,59 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> + +#include "mrb_patricia_trie.h" + +static struct mrb_data_type mrb_grn_patricia_trie_type = { + "Groonga::PatriciaTrie", + NULL +}; + +static mrb_value +mrb_grn_patricia_trie_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_patricia_trie_ptr; + + mrb_get_args(mrb, "o", &mrb_patricia_trie_ptr); + DATA_TYPE(self) = &mrb_grn_patricia_trie_type; + DATA_PTR(self) = mrb_cptr(mrb_patricia_trie_ptr); + return self; +} + +void +grn_mrb_patricia_trie_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *table_class; + struct RClass *klass; + + table_class = mrb_class_get_under(mrb, module, "Table"); + klass = mrb_define_class_under(mrb, module, "PatriciaTrie", table_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + mrb_define_method(mrb, klass, "initialize", + mrb_grn_patricia_trie_initialize, MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_patricia_trie.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_patricia_trie.h new file mode 100644 index 00000000..11da13a3 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_patricia_trie.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_patricia_trie_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_pointer.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_pointer.c new file mode 100644 index 00000000..b0d60f18 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_pointer.c @@ -0,0 +1,77 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" +#include <string.h> + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> + +#include "mrb_pointer.h" +#include "mrb_object.h" +#include "mrb_converter.h" + +static struct mrb_data_type mrb_grn_pointer_type = { + "Groonga::Pointer", + NULL +}; + +static mrb_value +mrb_grn_pointer_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_pointer_ptr; + + mrb_get_args(mrb, "o", &mrb_pointer_ptr); + DATA_TYPE(self) = &mrb_grn_pointer_type; + DATA_PTR(self) = mrb_cptr(mrb_pointer_ptr); + return self; +} + +static mrb_value +mrb_grn_pointer_get_value(mrb_state *mrb, mrb_value self) +{ + grn_obj *pointer; + + pointer = DATA_PTR(self); + if (GRN_BULK_VSIZE(pointer) == 0) { + return mrb_nil_value(); + } + + return grn_mrb_value_from_grn_obj(mrb, GRN_PTR_VALUE(pointer)); +} + +void +grn_mrb_pointer_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "Pointer", mrb->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + mrb_define_method(mrb, klass, "initialize", + mrb_grn_pointer_initialize, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "value", + mrb_grn_pointer_get_value, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "inspect", + grn_mrb_object_inspect, MRB_ARGS_NONE()); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_pointer.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_pointer.h new file mode 100644 index 00000000..5fe1dfb4 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_pointer.h @@ -0,0 +1,31 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_pointer_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_procedure.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_procedure.c new file mode 100644 index 00000000..f5045dc1 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_procedure.c @@ -0,0 +1,108 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> + +#include "mrb_procedure.h" + +#include "mrb_operator.h" + +static struct mrb_data_type mrb_grn_procedure_type = { + "Groonga::Procedure", + NULL +}; + +static mrb_value +mrb_grn_procedure_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_procedure_ptr; + + mrb_get_args(mrb, "o", &mrb_procedure_ptr); + DATA_TYPE(self) = &mrb_grn_procedure_type; + DATA_PTR(self) = mrb_cptr(mrb_procedure_ptr); + return self; +} + +static mrb_value +mrb_grn_procedure_selector_p(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *proc = DATA_PTR(self); + + return mrb_bool_value(grn_obj_is_selector_proc(ctx, proc)); +} + +static mrb_value +mrb_grn_procedure_selector_only_p(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *proc = DATA_PTR(self); + + return mrb_bool_value(grn_obj_is_selector_only_proc(ctx, proc)); +} + +static mrb_value +mrb_grn_procedure_scorer_p(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *proc = DATA_PTR(self); + + return mrb_bool_value(grn_obj_is_scorer_proc(ctx, proc)); +} + +static mrb_value +mrb_grn_procedure_get_selector_operator(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *proc = DATA_PTR(self); + grn_operator selector_op; + + selector_op = grn_proc_get_selector_operator(ctx, proc); + return grn_mrb_value_from_operator(mrb, selector_op); +} + +void +grn_mrb_procedure_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *object_class = data->object_class; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "Procedure", object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + mrb_define_method(mrb, klass, "initialize", + mrb_grn_procedure_initialize, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "selector?", + mrb_grn_procedure_selector_p, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "selector_only?", + mrb_grn_procedure_selector_only_p, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "scorer?", + mrb_grn_procedure_scorer_p, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "selector_operator", + mrb_grn_procedure_get_selector_operator, MRB_ARGS_NONE()); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_procedure.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_procedure.h new file mode 100644 index 00000000..5d64fcd0 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_procedure.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_procedure_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_query_logger.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_query_logger.c new file mode 100644 index 00000000..d19ca780 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_query_logger.c @@ -0,0 +1,76 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> +#include <mruby/variable.h> +#include <mruby/string.h> + +#include "../grn_mrb.h" +#include "mrb_query_logger.h" + +static mrb_value +query_logger_need_log_p(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_int flag; + + mrb_get_args(mrb, "i", &flag); + + return mrb_bool_value(grn_query_logger_pass(ctx, flag)); +} + +static mrb_value +query_logger_log_raw(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_int flag; + char *mark; + char *message; + mrb_int message_size; + + mrb_get_args(mrb, "izs", &flag, &mark, &message, &message_size); + grn_query_logger_put(ctx, flag, mark, + "%.*s", (int)message_size, message); + + return self; +} + +void +grn_mrb_query_logger_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "QueryLogger", mrb->object_class); + + mrb_define_method(mrb, klass, "need_log?", query_logger_need_log_p, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "log_raw", query_logger_log_raw, + MRB_ARGS_REQ(3)); + + grn_mrb_load(ctx, "query_logger/flag.rb"); + grn_mrb_load(ctx, "query_logger.rb"); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_query_logger.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_query_logger.h new file mode 100644 index 00000000..c0ea5eaf --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_query_logger.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_query_logger_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_record.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_record.c new file mode 100644 index 00000000..57411d27 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_record.c @@ -0,0 +1,162 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/variable.h> +#include <mruby/data.h> + +#include "../grn_db.h" +#include "mrb_record.h" +#include "mrb_bulk.h" + +typedef struct { + grn_obj *table; + grn_id id; + grn_obj key; +} grn_mrb_record; + +static void +mrb_grn_record_free(mrb_state *mrb, void *data) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_mrb_record *record = data; + + if (!record) { + return; + } + + GRN_OBJ_FIN(ctx, &(record->key)); + mrb_free(mrb, record); +} + +static struct mrb_data_type mrb_grn_record_type = { + "Groonga::Record", + mrb_grn_record_free +}; + +static mrb_value +mrb_grn_record_initialize(mrb_state *mrb, mrb_value self) +{ + grn_mrb_record *record; + mrb_value mrb_table; + mrb_value mrb_id; + + mrb_get_args(mrb, "oo", &mrb_table, &mrb_id); + + DATA_TYPE(self) = &mrb_grn_record_type; + + record = mrb_malloc(mrb, sizeof(grn_mrb_record)); + record->table = DATA_PTR(mrb_table); + if (mrb_nil_p(mrb_id)) { + record->id = GRN_ID_NIL; + } else { + record->id = mrb_fixnum(mrb_id); + } + + switch (record->table->header.domain) { + case GRN_ID_NIL : + case GRN_DB_SHORT_TEXT : + GRN_SHORT_TEXT_INIT(&(record->key), 0); + break; + default : + GRN_VALUE_FIX_SIZE_INIT(&(record->key), 0, record->table->header.domain); + break; + } + + DATA_PTR(self) = record; + + mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "@table"), mrb_table); + mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "@id"), mrb_id); + + return self; +} + +static mrb_value +mrb_grn_record_set_id(mrb_state *mrb, mrb_value self) +{ + grn_mrb_record *record; + mrb_value mrb_id; + + record = DATA_PTR(self); + mrb_get_args(mrb, "o", &mrb_id); + + if (mrb_nil_p(mrb_id)) { + record->id = GRN_ID_NIL; + } else { + record->id = mrb_fixnum(mrb_id); + } + mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "@id"), mrb_id); + + return mrb_id; +} + +static mrb_value +mrb_grn_record_key(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_mrb_record *record; + int key_size; + + record = DATA_PTR(self); + + if (record->id == GRN_ID_NIL) { + return mrb_nil_value(); + } + + if (record->table->header.type == GRN_TABLE_NO_KEY) { + return mrb_nil_value(); + } + + GRN_BULK_REWIND(&(record->key)); + key_size = grn_table_get_key(ctx, record->table, record->id, + GRN_BULK_HEAD(&(record->key)), + GRN_BULK_VSIZE(&(record->key))); + if (key_size > GRN_BULK_VSIZE(&(record->key))) { + grn_bulk_space(ctx, &(record->key), key_size); + key_size = grn_table_get_key(ctx, record->table, record->id, + GRN_BULK_HEAD(&(record->key)), + GRN_BULK_VSIZE(&(record->key))); + } + + return grn_mrb_value_from_bulk(mrb, &(record->key)); +} + +void +grn_mrb_record_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "Record", data->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + mrb_define_method(mrb, klass, "initialize", + mrb_grn_record_initialize, MRB_ARGS_REQ(2)); + + mrb_define_method(mrb, klass, "id=", + mrb_grn_record_set_id, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "key", + mrb_grn_record_key, MRB_ARGS_NONE()); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_record.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_record.h new file mode 100644 index 00000000..9c0e6ece --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_record.h @@ -0,0 +1,31 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_record_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_table.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table.c new file mode 100644 index 00000000..fecc6e3d --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table.c @@ -0,0 +1,493 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2017 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" +#include <string.h> + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> +#include <mruby/hash.h> +#include <mruby/array.h> +#include <mruby/string.h> + +#include "mrb_ctx.h" +#include "mrb_table.h" +#include "mrb_converter.h" +#include "mrb_options.h" + +static mrb_value +mrb_grn_table_array_reference(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *table; + grn_id key_domain_id; + mrb_value mrb_key; + grn_id record_id; + grn_mrb_value_to_raw_data_buffer buffer; + void *key; + unsigned int key_size; + + mrb_get_args(mrb, "o", &mrb_key); + + table = DATA_PTR(self); + if (table->header.type == GRN_DB) { + key_domain_id = GRN_DB_SHORT_TEXT; + } else { + key_domain_id = table->header.domain; + } + + grn_mrb_value_to_raw_data_buffer_init(mrb, &buffer); + grn_mrb_value_to_raw_data(mrb, "key", mrb_key, key_domain_id, + &buffer, &key, &key_size); + record_id = grn_table_get(ctx, table, key, key_size); + grn_mrb_value_to_raw_data_buffer_fin(mrb, &buffer); + + if (record_id == GRN_ID_NIL) { + return mrb_nil_value(); + } else { + return mrb_fixnum_value(record_id); + } +} + +static mrb_value +mrb_grn_table_is_id(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *table; + mrb_int mrb_record_id; + grn_id record_id; + grn_id real_record_id; + + mrb_get_args(mrb, "i", &mrb_record_id); + + table = DATA_PTR(self); + record_id = (grn_id)mrb_record_id; + real_record_id = grn_table_at(ctx, table, record_id); + if (real_record_id == record_id) { + return mrb_true_value(); + } else { + return mrb_false_value(); + } +} + +static mrb_value +mrb_grn_table_find_column(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *table; + mrb_value mrb_column_name; + grn_obj *column; + + mrb_get_args(mrb, "o", &mrb_column_name); + + table = DATA_PTR(self); + column = grn_obj_column(ctx, table, + RSTRING_PTR(mrb_column_name), + RSTRING_LEN(mrb_column_name)); + grn_mrb_ctx_check(mrb); + + return grn_mrb_value_from_grn_obj(mrb, column); +} + +static mrb_value +mrb_grn_table_get_column_ids(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *table; + grn_hash *columns; + int n_columns; + mrb_value mrb_column_ids; + + table = DATA_PTR(self); + columns = grn_hash_create(ctx, NULL, sizeof(grn_id), 0, + GRN_OBJ_TABLE_HASH_KEY | GRN_HASH_TINY); + if (!columns) { + grn_mrb_ctx_check(mrb); + return mrb_ary_new(mrb); + } + + n_columns = grn_table_columns(ctx, table, "", 0, (grn_obj *)columns); + mrb_column_ids = mrb_ary_new_capa(mrb, n_columns); + { + grn_id *key; + GRN_HASH_EACH(ctx, columns, id, &key, NULL, NULL, { + mrb_ary_push(mrb, mrb_column_ids, mrb_fixnum_value(*key)); + }); + } + grn_hash_close(ctx, columns); + + grn_mrb_ctx_check(mrb); + + return mrb_column_ids; +} + +static mrb_value +mrb_grn_table_create_column(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *table; + mrb_value mrb_name; + mrb_int flags; + mrb_value mrb_type; + grn_obj *type; + grn_obj *column; + + mrb_get_args(mrb, "oio", &mrb_name, &flags, &mrb_type); + + table = DATA_PTR(self); + type = DATA_PTR(mrb_type); + column = grn_column_create(ctx, table, + RSTRING_PTR(mrb_name), + RSTRING_LEN(mrb_name), + NULL, + flags, + type); + grn_mrb_ctx_check(mrb); + + return grn_mrb_value_from_grn_obj(mrb, column); +} + +static mrb_value +mrb_grn_table_is_locked(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + unsigned int is_locked; + + is_locked = grn_obj_is_locked(ctx, DATA_PTR(self)); + grn_mrb_ctx_check(mrb); + + return mrb_bool_value(is_locked != 0); +} + +static mrb_value +mrb_grn_table_get_size(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + unsigned int size; + + size = grn_table_size(ctx, DATA_PTR(self)); + grn_mrb_ctx_check(mrb); + + return mrb_fixnum_value(size); +} + +static mrb_value +mrb_grn_table_is_empty(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + unsigned int size; + + size = grn_table_size(ctx, DATA_PTR(self)); + grn_mrb_ctx_check(mrb); + + return mrb_bool_value(size == 0); +} + +static mrb_value +mrb_grn_table_select(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *table; + grn_obj *expr; + grn_obj *result = NULL; + grn_operator operator = GRN_OP_OR; + mrb_value mrb_expr; + mrb_value mrb_options = mrb_nil_value(); + + table = DATA_PTR(self); + mrb_get_args(mrb, "o|H", &mrb_expr, &mrb_options); + + expr = DATA_PTR(mrb_expr); + + if (!mrb_nil_p(mrb_options)) { + mrb_value mrb_result; + mrb_value mrb_operator; + + mrb_result = grn_mrb_options_get_lit(mrb, mrb_options, "result"); + if (!mrb_nil_p(mrb_result)) { + result = DATA_PTR(mrb_result); + } + + mrb_operator = grn_mrb_options_get_lit(mrb, mrb_options, "operator"); + if (!mrb_nil_p(mrb_operator)) { + operator = mrb_fixnum(mrb_operator); + } + } + + result = grn_table_select(ctx, table, expr, result, operator); + if (ctx->rc != GRN_SUCCESS) { + grn_mrb_ctx_check(mrb); + } + + return grn_mrb_value_from_grn_obj(mrb, result); +} + +static mrb_value +mrb_grn_table_sort_raw(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *table; + mrb_value mrb_keys; + grn_table_sort_key *keys; + int i, n_keys; + mrb_int offset; + mrb_int limit; + mrb_value mrb_result; + grn_obj *result; + + table = DATA_PTR(self); + mrb_get_args(mrb, "oiio", &mrb_keys, &offset, &limit, &mrb_result); + + mrb_keys = mrb_convert_type(mrb, mrb_keys, + MRB_TT_ARRAY, "Array", "to_ary"); + + n_keys = RARRAY_LEN(mrb_keys); + keys = GRN_MALLOCN(grn_table_sort_key, n_keys); + for (i = 0; i < n_keys; i++) { + grn_memcpy(&(keys[i]), + DATA_PTR(RARRAY_PTR(mrb_keys)[i]), + sizeof(grn_table_sort_key)); + } + result = DATA_PTR(mrb_result); + grn_table_sort(ctx, table, offset, limit, result, keys, n_keys); + GRN_FREE(keys); + grn_mrb_ctx_check(mrb); + + return mrb_result; +} + +static mrb_value +mrb_grn_table_group_raw(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *table; + mrb_value mrb_keys; + grn_table_sort_key *keys; + int i, n_keys; + mrb_value mrb_result; + grn_table_group_result *result; + + table = DATA_PTR(self); + mrb_get_args(mrb, "oo", &mrb_keys, &mrb_result); + + mrb_keys = mrb_convert_type(mrb, mrb_keys, + MRB_TT_ARRAY, "Array", "to_ary"); + + n_keys = RARRAY_LEN(mrb_keys); + keys = GRN_MALLOCN(grn_table_sort_key, n_keys); + for (i = 0; i < n_keys; i++) { + grn_memcpy(&(keys[i]), + DATA_PTR(RARRAY_PTR(mrb_keys)[i]), + sizeof(grn_table_sort_key)); + } + result = DATA_PTR(mrb_result); + grn_table_group(ctx, table, keys, n_keys, result, 1); + GRN_FREE(keys); + grn_mrb_ctx_check(mrb); + + return mrb_result; +} + +static mrb_value +mrb_grn_table_delete(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *table; + mrb_value mrb_options; + mrb_value mrb_id; + mrb_value mrb_key; + mrb_value mrb_expression; + + table = DATA_PTR(self); + mrb_get_args(mrb, "H", &mrb_options); + + mrb_id = grn_mrb_options_get_lit(mrb, mrb_options, "id"); + if (!mrb_nil_p(mrb_id)) { + grn_table_delete_by_id(ctx, table, mrb_fixnum(mrb_id)); + grn_mrb_ctx_check(mrb); + return mrb_nil_value(); + } + + mrb_key = grn_mrb_options_get_lit(mrb, mrb_options, "key"); + if (!mrb_nil_p(mrb_key)) { + grn_id key_domain_id; + void *key; + unsigned int key_size; + grn_mrb_value_to_raw_data_buffer buffer; + + key_domain_id = table->header.domain; + grn_mrb_value_to_raw_data_buffer_init(mrb, &buffer); + grn_mrb_value_to_raw_data(mrb, "key", mrb_key, key_domain_id, + &buffer, &key, &key_size); + grn_table_delete(ctx, table, key, key_size); + grn_mrb_value_to_raw_data_buffer_fin(mrb, &buffer); + grn_mrb_ctx_check(mrb); + return mrb_nil_value(); + } + + mrb_expression = grn_mrb_options_get_lit(mrb, mrb_options, "expression"); + if (!mrb_nil_p(mrb_expression)) { + grn_obj *expression; + grn_obj *selected_records; + grn_table_cursor *cursor; + + expression = DATA_PTR(mrb_expression); + selected_records = grn_table_select(ctx, table, expression, NULL, GRN_OP_OR); + grn_mrb_ctx_check(mrb); + cursor = grn_table_cursor_open(ctx, selected_records, + NULL, 0, + NULL, 0, + 0, -1, 0); + if (cursor) { + while (grn_table_cursor_next(ctx, cursor) != GRN_ID_NIL) { + grn_id *id; + grn_table_cursor_get_key(ctx, cursor, (void **)&id); + grn_table_delete_by_id(ctx, table, *id); + } + grn_table_cursor_close(ctx, cursor); + } + grn_mrb_ctx_check(mrb); + + return mrb_nil_value(); + } + + mrb_raisef(mrb, E_ARGUMENT_ERROR, + "must have :id, :key or :expression: %S", + mrb_options); + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_table_truncate(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_obj *table; + + table = DATA_PTR(self); + grn_table_truncate(ctx, table); + grn_mrb_ctx_check(mrb); + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_table_apply_expression(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_output_column; + mrb_value mrb_expression; + grn_obj *table; + grn_obj *output_column = NULL; + grn_obj *expression = NULL; + + mrb_get_args(mrb, "oo", &mrb_output_column, &mrb_expression); + + table = DATA_PTR(self); + output_column = GRN_MRB_DATA_PTR(mrb_output_column); + expression = GRN_MRB_DATA_PTR(mrb_expression); + grn_table_apply_expr(ctx, table, output_column, expression); + grn_mrb_ctx_check(mrb); + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_table_apply_window_function_raw(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_output_column; + mrb_value mrb_window_definition; + mrb_value mrb_window_function_call; + grn_obj *table; + grn_obj *output_column = NULL; + grn_window_definition *window_definition = NULL; + grn_obj *window_function_call = NULL; + + mrb_get_args(mrb, "ooo", + &mrb_output_column, + &mrb_window_definition, + &mrb_window_function_call); + + table = DATA_PTR(self); + output_column = GRN_MRB_DATA_PTR(mrb_output_column); + window_definition = GRN_MRB_DATA_PTR(mrb_window_definition); + window_function_call = GRN_MRB_DATA_PTR(mrb_window_function_call); + grn_table_apply_window_function(ctx, + table, + output_column, + window_definition, + window_function_call); + grn_mrb_ctx_check(mrb); + + return mrb_nil_value(); +} + +void +grn_mrb_table_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *object_class = data->object_class; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "Table", object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_method(mrb, klass, "[]", + mrb_grn_table_array_reference, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "id?", + mrb_grn_table_is_id, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "find_column", + mrb_grn_table_find_column, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "column_ids", + mrb_grn_table_get_column_ids, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "create_column", + mrb_grn_table_create_column, MRB_ARGS_REQ(3)); + + mrb_define_method(mrb, klass, "locked?", + mrb_grn_table_is_locked, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "size", + mrb_grn_table_get_size, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "empty?", + mrb_grn_table_is_empty, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "select", + mrb_grn_table_select, MRB_ARGS_ARG(1, 1)); + mrb_define_method(mrb, klass, "sort_raw", + mrb_grn_table_sort_raw, MRB_ARGS_REQ(4)); + mrb_define_method(mrb, klass, "group_raw", + mrb_grn_table_group_raw, MRB_ARGS_REQ(2)); + + mrb_define_method(mrb, klass, "delete", + mrb_grn_table_delete, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, klass, "truncate", + mrb_grn_table_truncate, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "apply_expression", + mrb_grn_table_apply_expression, MRB_ARGS_REQ(2)); + mrb_define_method(mrb, klass, "apply_window_function_raw", + mrb_grn_table_apply_window_function_raw, MRB_ARGS_REQ(4)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_table.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table.h new file mode 100644 index 00000000..fd06db56 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_table_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_cursor.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_cursor.c new file mode 100644 index 00000000..a7748168 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_cursor.c @@ -0,0 +1,208 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> +#include <mruby/string.h> +#include <mruby/hash.h> +#include <mruby/variable.h> + +#include "mrb_ctx.h" +#include "mrb_bulk.h" +#include "mrb_table_cursor.h" + +#include "mrb_converter.h" +#include "mrb_options.h" + +static struct mrb_data_type mrb_grn_table_cursor_type = { + "Groonga::TableCursor", + NULL +}; + +static mrb_value +mrb_grn_table_cursor_class_open_raw(mrb_state *mrb, mrb_value klass) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_table; + mrb_value mrb_options = mrb_nil_value(); + grn_table_cursor *table_cursor; + grn_obj *table; + void *min = NULL; + unsigned int min_size = 0; + grn_mrb_value_to_raw_data_buffer min_buffer; + void *max = NULL; + unsigned int max_size = 0; + grn_mrb_value_to_raw_data_buffer max_buffer; + int offset = 0; + int limit = -1; + int flags = 0; + + mrb_get_args(mrb, "o|H", &mrb_table, &mrb_options); + + table = DATA_PTR(mrb_table); + grn_mrb_value_to_raw_data_buffer_init(mrb, &min_buffer); + grn_mrb_value_to_raw_data_buffer_init(mrb, &max_buffer); + if (!mrb_nil_p(mrb_options)) { + grn_id key_domain_id; + mrb_value mrb_min; + mrb_value mrb_max; + mrb_value mrb_flags; + + if (table->header.type == GRN_DB) { + key_domain_id = GRN_DB_SHORT_TEXT; + } else { + key_domain_id = table->header.domain; + } + + mrb_min = grn_mrb_options_get_lit(mrb, mrb_options, "min"); + grn_mrb_value_to_raw_data(mrb, "min", mrb_min, + key_domain_id, &min_buffer, &min, &min_size); + + mrb_max = grn_mrb_options_get_lit(mrb, mrb_options, "max"); + grn_mrb_value_to_raw_data(mrb, "max", mrb_max, + key_domain_id, &max_buffer, &max, &max_size); + + mrb_flags = grn_mrb_options_get_lit(mrb, mrb_options, "flags"); + if (!mrb_nil_p(mrb_flags)) { + flags = mrb_fixnum(mrb_flags); + } + } + table_cursor = grn_table_cursor_open(ctx, table, + min, min_size, + max, max_size, + offset, limit, flags); + grn_mrb_value_to_raw_data_buffer_fin(mrb, &min_buffer); + grn_mrb_value_to_raw_data_buffer_fin(mrb, &max_buffer); + grn_mrb_ctx_check(mrb); + + { + mrb_value mrb_table_cursor; + mrb_table_cursor = mrb_funcall(mrb, klass, + "new", 1, mrb_cptr_value(mrb, table_cursor)); + mrb_iv_set(mrb, mrb_table_cursor, mrb_intern_lit(mrb, "@table"), mrb_table); + return mrb_table_cursor; + } +} + +static mrb_value +mrb_grn_table_cursor_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_table_cursor_ptr; + + mrb_get_args(mrb, "o", &mrb_table_cursor_ptr); + DATA_TYPE(self) = &mrb_grn_table_cursor_type; + DATA_PTR(self) = mrb_cptr(mrb_table_cursor_ptr); + + return self; +} + +static mrb_value +mrb_grn_table_cursor_close(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_table_cursor *table_cursor; + + table_cursor = DATA_PTR(self); + if (table_cursor) { + DATA_PTR(self) = NULL; + grn_table_cursor_close(ctx, table_cursor); + grn_mrb_ctx_check(mrb); + } + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_table_cursor_next(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_id id; + + id = grn_table_cursor_next(ctx, DATA_PTR(self)); + grn_mrb_ctx_check(mrb); + + return mrb_fixnum_value(id); +} + +static mrb_value +mrb_grn_table_cursor_count(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + int n_records = 0; + + while (grn_table_cursor_next(ctx, DATA_PTR(self)) != GRN_ID_NIL) { + n_records++; + } + + return mrb_fixnum_value(n_records); +} + +static mrb_value +mrb_grn_table_cursor_get_key(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_table; + grn_obj *table; + grn_id domain; + void *key; + int key_size; + + mrb_table = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@table")); + table = DATA_PTR(mrb_table); + if (table->header.type == GRN_DB) { + domain = GRN_DB_SHORT_TEXT; + } else { + domain = table->header.domain; + } + key_size = grn_table_cursor_get_key(ctx, DATA_PTR(self), &key); + + return grn_mrb_value_from_raw_data(mrb, domain, key, key_size); +} + +void +grn_mrb_table_cursor_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "TableCursor", mrb->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_class_method(mrb, klass, "open_raw", + mrb_grn_table_cursor_class_open_raw, + MRB_ARGS_ARG(1, 1)); + + mrb_define_method(mrb, klass, "initialize", + mrb_grn_table_cursor_initialize, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "close", + mrb_grn_table_cursor_close, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "next", + mrb_grn_table_cursor_next, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "count", + mrb_grn_table_cursor_count, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "key", + mrb_grn_table_cursor_get_key, MRB_ARGS_NONE()); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_cursor.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_cursor.h new file mode 100644 index 00000000..6ffd51af --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_cursor.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_table_cursor_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_cursor_flags.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_cursor_flags.c new file mode 100644 index 00000000..58a3137a --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_cursor_flags.c @@ -0,0 +1,60 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> + +#include "mrb_table_cursor_flags.h" + +void +grn_mrb_table_cursor_flags_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *flags_module; + + flags_module = mrb_define_module_under(mrb, module, "TableCursorFlags"); + + mrb_define_const(mrb, flags_module, "ASCENDING", + mrb_fixnum_value(GRN_CURSOR_ASCENDING)); + mrb_define_const(mrb, flags_module, "DESCENDING", + mrb_fixnum_value(GRN_CURSOR_DESCENDING)); + mrb_define_const(mrb, flags_module, "GE", + mrb_fixnum_value(GRN_CURSOR_GE)); + mrb_define_const(mrb, flags_module, "GT", + mrb_fixnum_value(GRN_CURSOR_GT)); + mrb_define_const(mrb, flags_module, "LE", + mrb_fixnum_value(GRN_CURSOR_LE)); + mrb_define_const(mrb, flags_module, "LT", + mrb_fixnum_value(GRN_CURSOR_LT)); + mrb_define_const(mrb, flags_module, "BY_KEY", + mrb_fixnum_value(GRN_CURSOR_BY_KEY)); + mrb_define_const(mrb, flags_module, "BY_ID", + mrb_fixnum_value(GRN_CURSOR_BY_ID)); + mrb_define_const(mrb, flags_module, "PREFIX", + mrb_fixnum_value(GRN_CURSOR_PREFIX)); + mrb_define_const(mrb, flags_module, "SIZE_BY_BIT", + mrb_fixnum_value(GRN_CURSOR_SIZE_BY_BIT)); + mrb_define_const(mrb, flags_module, "RK", + mrb_fixnum_value(GRN_CURSOR_RK)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_cursor_flags.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_cursor_flags.h new file mode 100644 index 00000000..5db915a7 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_cursor_flags.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_table_cursor_flags_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_group_flags.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_group_flags.c new file mode 100644 index 00000000..8984ebef --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_group_flags.c @@ -0,0 +1,48 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> + +#include "mrb_table_group_flags.h" + +void +grn_mrb_table_group_flags_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *flags_module; + + flags_module = mrb_define_module_under(mrb, module, "TableGroupFlags"); + + mrb_define_const(mrb, flags_module, "CALC_COUNT", + mrb_fixnum_value(GRN_TABLE_GROUP_CALC_COUNT)); + mrb_define_const(mrb, flags_module, "CALC_MAX", + mrb_fixnum_value(GRN_TABLE_GROUP_CALC_MAX)); + mrb_define_const(mrb, flags_module, "CALC_MIN", + mrb_fixnum_value(GRN_TABLE_GROUP_CALC_MIN)); + mrb_define_const(mrb, flags_module, "CALC_SUM", + mrb_fixnum_value(GRN_TABLE_GROUP_CALC_SUM)); + mrb_define_const(mrb, flags_module, "CALC_AVG", + mrb_fixnum_value(GRN_TABLE_GROUP_CALC_AVG)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_group_flags.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_group_flags.h new file mode 100644 index 00000000..4230a240 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_group_flags.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_table_group_flags_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_group_result.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_group_result.c new file mode 100644 index 00000000..c4aaafa4 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_group_result.c @@ -0,0 +1,254 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> +#include <mruby/hash.h> +#include <mruby/array.h> +#include <mruby/string.h> + +#include "mrb_ctx.h" +#include "mrb_converter.h" +#include "mrb_operator.h" +#include "mrb_table_group_result.h" + +static void +mrb_grn_table_group_result_free(mrb_state *mrb, void *data) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_table_group_result *result = data; + + if (!result) { + return; + } + + if (result->calc_target) { + grn_obj_unlink(ctx, result->calc_target); + } + if (result->table) { + grn_obj_unlink(ctx, result->table); + } + mrb_free(mrb, result); +} + +static struct mrb_data_type mrb_grn_table_group_result_type = { + "Groonga::TableGroupResult", + mrb_grn_table_group_result_free +}; + +static mrb_value +mrb_grn_table_group_result_initialize(mrb_state *mrb, mrb_value self) +{ + grn_table_group_result *result; + + DATA_TYPE(self) = &mrb_grn_table_group_result_type; + + result = mrb_calloc(mrb, 1, sizeof(grn_table_group_result)); + DATA_PTR(self) = result; + + return self; +} + + +static mrb_value +mrb_grn_table_group_result_close(mrb_state *mrb, mrb_value self) +{ + grn_table_group_result *result; + + result = DATA_PTR(self); + if (result) { + mrb_grn_table_group_result_free(mrb, result); + DATA_PTR(self) = NULL; + } + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_table_group_result_get_table(mrb_state *mrb, mrb_value self) +{ + grn_table_group_result *result; + + result = DATA_PTR(self); + + return grn_mrb_value_from_grn_obj(mrb, result->table); +} + +static mrb_value +mrb_grn_table_group_result_set_table(mrb_state *mrb, mrb_value self) +{ + grn_table_group_result *result; + mrb_value mrb_table; + + result = DATA_PTR(self); + mrb_get_args(mrb, "o", &mrb_table); + + if (mrb_nil_p(mrb_table)) { + result->table = NULL; + } else { + result->table = DATA_PTR(mrb_table); + } + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_table_group_result_set_key_begin(mrb_state *mrb, mrb_value self) +{ + grn_table_group_result *result; + mrb_int key_begin; + + result = DATA_PTR(self); + mrb_get_args(mrb, "i", &key_begin); + + result->key_begin = key_begin; + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_table_group_result_set_key_end(mrb_state *mrb, mrb_value self) +{ + grn_table_group_result *result; + mrb_int key_end; + + result = DATA_PTR(self); + mrb_get_args(mrb, "i", &key_end); + + result->key_end = key_end; + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_table_group_result_set_limit(mrb_state *mrb, mrb_value self) +{ + grn_table_group_result *result; + mrb_int limit; + + result = DATA_PTR(self); + mrb_get_args(mrb, "i", &limit); + + result->limit = limit; + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_table_group_result_set_flags(mrb_state *mrb, mrb_value self) +{ + grn_table_group_result *result; + mrb_int flags; + + result = DATA_PTR(self); + mrb_get_args(mrb, "i", &flags); + + result->flags = flags; + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_table_group_result_set_operator(mrb_state *mrb, mrb_value self) +{ + grn_table_group_result *result; + mrb_value mrb_operator; + + result = DATA_PTR(self); + mrb_get_args(mrb, "o", &mrb_operator); + + result->op = grn_mrb_value_to_operator(mrb, mrb_operator); + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_table_group_result_set_max_n_sub_records(mrb_state *mrb, mrb_value self) +{ + grn_table_group_result *result; + mrb_int max_n_sub_records; + + result = DATA_PTR(self); + mrb_get_args(mrb, "i", &max_n_sub_records); + + result->max_n_subrecs = max_n_sub_records; + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_table_group_result_set_calc_target(mrb_state *mrb, mrb_value self) +{ + grn_table_group_result *result; + mrb_value mrb_calc_target; + + result = DATA_PTR(self); + mrb_get_args(mrb, "o", &mrb_calc_target); + + if (mrb_nil_p(mrb_calc_target)) { + result->calc_target = NULL; + } else { + result->calc_target = DATA_PTR(mrb_calc_target); + } + + return mrb_nil_value(); +} + +void +grn_mrb_table_group_result_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "TableGroupResult", + mrb->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_method(mrb, klass, "initialize", + mrb_grn_table_group_result_initialize, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "close", + mrb_grn_table_group_result_close, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "table", + mrb_grn_table_group_result_get_table, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "table=", + mrb_grn_table_group_result_set_table, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "key_begin=", + mrb_grn_table_group_result_set_key_begin, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "key_end=", + mrb_grn_table_group_result_set_key_end, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "limit=", + mrb_grn_table_group_result_set_limit, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "flags=", + mrb_grn_table_group_result_set_flags, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "operator=", + mrb_grn_table_group_result_set_operator, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "max_n_sub_records=", + mrb_grn_table_group_result_set_max_n_sub_records, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "calc_target=", + mrb_grn_table_group_result_set_calc_target, MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_group_result.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_group_result.h new file mode 100644 index 00000000..c3b17af2 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_group_result.h @@ -0,0 +1,31 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_table_group_result_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_sort_flags.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_sort_flags.c new file mode 100644 index 00000000..47f0169e --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_sort_flags.c @@ -0,0 +1,42 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> + +#include "mrb_table_sort_flags.h" + +void +grn_mrb_table_sort_flags_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *flags_module; + + flags_module = mrb_define_module_under(mrb, module, "TableSortFlags"); + + mrb_define_const(mrb, flags_module, "ASCENDING", + mrb_fixnum_value(GRN_TABLE_SORT_ASC)); + mrb_define_const(mrb, flags_module, "DESCENDING", + mrb_fixnum_value(GRN_TABLE_SORT_DESC)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_sort_flags.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_sort_flags.h new file mode 100644 index 00000000..7450399e --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_sort_flags.h @@ -0,0 +1,31 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_table_sort_flags_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_sort_key.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_sort_key.c new file mode 100644 index 00000000..f8692d48 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_sort_key.c @@ -0,0 +1,159 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> +#include <mruby/hash.h> +#include <mruby/array.h> +#include <mruby/string.h> + +#include "mrb_ctx.h" +#include "mrb_table_sort_key.h" + +static void +mrb_grn_table_sort_key_free(mrb_state *mrb, void *data) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_table_sort_key *sort_key = data; + + if (!sort_key) { + return; + } + + if (sort_key->key) { + if (sort_key->key->header.type == GRN_ACCESSOR) { + grn_obj_unlink(ctx, sort_key->key); + } + } + mrb_free(mrb, sort_key); +} + +static struct mrb_data_type mrb_grn_table_sort_key_type = { + "Groonga::TableSortKey", + mrb_grn_table_sort_key_free +}; + +static mrb_value +mrb_grn_table_sort_key_initialize(mrb_state *mrb, mrb_value self) +{ + grn_table_sort_key *result; + + DATA_TYPE(self) = &mrb_grn_table_sort_key_type; + + result = mrb_calloc(mrb, 1, sizeof(grn_table_sort_key)); + DATA_PTR(self) = result; + + return self; +} + + +static mrb_value +mrb_grn_table_sort_key_close(mrb_state *mrb, mrb_value self) +{ + grn_table_sort_key *sort_key; + + sort_key = DATA_PTR(self); + if (sort_key) { + mrb_grn_table_sort_key_free(mrb, sort_key); + DATA_PTR(self) = NULL; + } + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_table_sort_key_set_key(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + grn_table_sort_key *sort_key; + mrb_value mrb_key; + + sort_key = DATA_PTR(self); + mrb_get_args(mrb, "o", &mrb_key); + + if (sort_key->key) { + grn_obj_unlink(ctx, sort_key->key); + } + + if (mrb_nil_p(mrb_key)) { + sort_key->key = NULL; + } else { + sort_key->key = DATA_PTR(mrb_key); + } + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_table_sort_key_set_flags(mrb_state *mrb, mrb_value self) +{ + grn_table_sort_key *sort_key; + mrb_int flags; + + sort_key = DATA_PTR(self); + mrb_get_args(mrb, "i", &flags); + + sort_key->flags = flags; + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_table_sort_key_set_offset(mrb_state *mrb, mrb_value self) +{ + grn_table_sort_key *sort_key; + mrb_int offset; + + sort_key = DATA_PTR(self); + mrb_get_args(mrb, "i", &offset); + + sort_key->offset = offset; + + return mrb_nil_value(); +} + +void +grn_mrb_table_sort_key_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "TableSortKey", + mrb->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_method(mrb, klass, "initialize", + mrb_grn_table_sort_key_initialize, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "close", + mrb_grn_table_sort_key_close, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "key=", + mrb_grn_table_sort_key_set_key, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "flags=", + mrb_grn_table_sort_key_set_flags, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "offset=", + mrb_grn_table_sort_key_set_offset, MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_sort_key.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_sort_key.h new file mode 100644 index 00000000..9ca38bfc --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_table_sort_key.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_table_sort_key_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_thread.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_thread.c new file mode 100644 index 00000000..ba3a7e7b --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_thread.c @@ -0,0 +1,46 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> + +#include "mrb_thread.h" + +static mrb_value +thread_limit(mrb_state *mrb, mrb_value self) +{ + uint32_t limit; + limit = grn_thread_get_limit(); + return mrb_fixnum_value(limit); +} + +void +grn_mrb_thread_init(grn_ctx *ctx) +{ + mrb_state *mrb = ctx->impl->mrb.state; + struct RClass *module = ctx->impl->mrb.module; + struct RClass *thread_module; + + thread_module = mrb_define_module_under(mrb, module, "Thread"); + + mrb_define_class_method(mrb, thread_module, + "limit", thread_limit, MRB_ARGS_NONE()); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_thread.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_thread.h new file mode 100644 index 00000000..030eafed --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_thread.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_thread_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_type.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_type.c new file mode 100644 index 00000000..a288d60f --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_type.c @@ -0,0 +1,60 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> + +#include "mrb_ctx.h" +#include "mrb_type.h" + +static struct mrb_data_type mrb_grn_type_type = { + "Groonga::Type", + NULL +}; + +static mrb_value +mrb_grn_type_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_type_ptr; + + mrb_get_args(mrb, "o", &mrb_type_ptr); + DATA_TYPE(self) = &mrb_grn_type_type; + DATA_PTR(self) = mrb_cptr(mrb_type_ptr); + return self; +} + +void +grn_mrb_type_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *object_class = data->object_class; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "Type", object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_method(mrb, klass, "initialize", + mrb_grn_type_initialize, MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_type.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_type.h new file mode 100644 index 00000000..8dc74b79 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_type.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_type_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_variable_size_column.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_variable_size_column.c new file mode 100644 index 00000000..78f3de86 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_variable_size_column.c @@ -0,0 +1,60 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> + +#include "mrb_variable_size_column.h" + +static struct mrb_data_type mrb_grn_variable_size_column_type = { + "Groonga::VariableSizeColumn", + NULL +}; + +static mrb_value +mrb_grn_variable_size_column_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_variable_size_column_ptr; + + mrb_get_args(mrb, "o", &mrb_variable_size_column_ptr); + DATA_TYPE(self) = &mrb_grn_variable_size_column_type; + DATA_PTR(self) = mrb_cptr(mrb_variable_size_column_ptr); + return self; +} + +void +grn_mrb_variable_size_column_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *column_class; + struct RClass *klass; + + column_class = mrb_class_get_under(mrb, module, "Column"); + klass = mrb_define_class_under(mrb, module, + "VariableSizeColumn", column_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + mrb_define_method(mrb, klass, "initialize", + mrb_grn_variable_size_column_initialize, MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_variable_size_column.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_variable_size_column.h new file mode 100644 index 00000000..1bac1238 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_variable_size_column.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_variable_size_column_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_void.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_void.c new file mode 100644 index 00000000..33cdea6c --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_void.c @@ -0,0 +1,59 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/variable.h> +#include <mruby/data.h> + +#include "../grn_db.h" +#include "mrb_void.h" + +static struct mrb_data_type mrb_grn_void_type = { + "Groonga::Void", + NULL +}; + +static mrb_value +mrb_grn_void_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_value mrb_void_ptr; + + mrb_get_args(mrb, "o", &mrb_void_ptr); + DATA_TYPE(self) = &mrb_grn_void_type; + DATA_PTR(self) = mrb_cptr(mrb_void_ptr); + return self; +} + +void +grn_mrb_void_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "Void", mrb->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + mrb_define_method(mrb, klass, "initialize", + mrb_grn_void_initialize, MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_void.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_void.h new file mode 100644 index 00000000..dced2747 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_void.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2014-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_void_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_window_definition.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_window_definition.c new file mode 100644 index 00000000..86ff372e --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_window_definition.c @@ -0,0 +1,164 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2017 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/class.h> +#include <mruby/data.h> +#include <mruby/array.h> + +#include "mrb_ctx.h" +#include "mrb_window_definition.h" + +static void +mrb_grn_window_definition_free(mrb_state *mrb, void *data) +{ + grn_window_definition *definition = data; + + if (!definition) { + return; + } + + if (definition->sort_keys) { + mrb_free(mrb, definition->sort_keys); + } + if (definition->group_keys) { + mrb_free(mrb, definition->group_keys); + } + mrb_free(mrb, definition); +} + +static struct mrb_data_type mrb_grn_window_definition_type = { + "Groonga::WindowDefinition", + mrb_grn_window_definition_free +}; + +static mrb_value +mrb_grn_window_definition_initialize(mrb_state *mrb, mrb_value self) +{ + grn_window_definition *result; + + DATA_TYPE(self) = &mrb_grn_window_definition_type; + + result = mrb_calloc(mrb, 1, sizeof(grn_window_definition)); + DATA_PTR(self) = result; + + return self; +} + + +static mrb_value +mrb_grn_window_definition_close(mrb_state *mrb, mrb_value self) +{ + grn_window_definition *definition; + + definition = DATA_PTR(self); + if (definition) { + mrb_grn_window_definition_free(mrb, definition); + DATA_PTR(self) = NULL; + } + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_window_definition_set_sort_keys(mrb_state *mrb, mrb_value self) +{ + grn_window_definition *definition; + mrb_value mrb_keys; + + definition = DATA_PTR(self); + mrb_get_args(mrb, "A!", &mrb_keys); + + if (definition->sort_keys) { + mrb_free(mrb, definition->sort_keys); + } + + if (mrb_nil_p(mrb_keys)) { + definition->sort_keys = NULL; + definition->n_sort_keys = 0; + } else { + mrb_int i, n; + n = RARRAY_LEN(mrb_keys); + definition->sort_keys = mrb_calloc(mrb, n, sizeof(grn_table_sort_key)); + for (i = 0; i < n; i++) { + grn_table_sort_key *sort_key = DATA_PTR(RARRAY_PTR(mrb_keys)[i]); + definition->sort_keys[i] = *sort_key; + } + definition->n_sort_keys = n; + } + + return mrb_nil_value(); +} + +static mrb_value +mrb_grn_window_definition_set_group_keys(mrb_state *mrb, mrb_value self) +{ + grn_window_definition *definition; + mrb_value mrb_keys; + + definition = DATA_PTR(self); + mrb_get_args(mrb, "A!", &mrb_keys); + + if (definition->group_keys) { + mrb_free(mrb, definition->group_keys); + } + + if (mrb_nil_p(mrb_keys)) { + definition->group_keys = NULL; + definition->n_group_keys = 0; + } else { + mrb_int i, n; + n = RARRAY_LEN(mrb_keys); + definition->group_keys = mrb_calloc(mrb, n, sizeof(grn_table_sort_key)); + for (i = 0; i < n; i++) { + grn_table_sort_key *group_key = DATA_PTR(RARRAY_PTR(mrb_keys)[i]); + definition->group_keys[i] = *group_key; + } + definition->n_group_keys = n; + } + + return mrb_nil_value(); +} + +void +grn_mrb_window_definition_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "WindowDefinition", + mrb->object_class); + MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); + + mrb_define_method(mrb, klass, "initialize", + mrb_grn_window_definition_initialize, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "close", + mrb_grn_window_definition_close, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "sort_keys=", + mrb_grn_window_definition_set_sort_keys, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "group_keys=", + mrb_grn_window_definition_set_group_keys, MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_window_definition.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_window_definition.h new file mode 100644 index 00000000..ea1b8ef6 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_window_definition.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2017 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_window_definition_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_writer.c b/storage/mroonga/vendor/groonga/lib/mrb/mrb_writer.c new file mode 100644 index 00000000..b2ca09f9 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_writer.c @@ -0,0 +1,253 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#include "../grn_ctx_impl.h" + +#ifdef GRN_WITH_MRUBY +#include <mruby.h> +#include <mruby/data.h> +#include <mruby/hash.h> +#include <mruby/string.h> + +#include "../grn_mrb.h" +#include "../grn_output.h" +#include "mrb_ctx.h" +#include "mrb_writer.h" +#include "mrb_options.h" + +static mrb_value +writer_write(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value target; + + mrb_get_args(mrb, "o", &target); + + switch (mrb_type(target)) { + case MRB_TT_FALSE : + if (mrb_nil_p(target)) { + GRN_OUTPUT_NULL(); + } else { + GRN_OUTPUT_BOOL(GRN_FALSE); + } + break; + case MRB_TT_TRUE : + GRN_OUTPUT_BOOL(GRN_TRUE); + break; + case MRB_TT_FIXNUM : + GRN_OUTPUT_INT32(mrb_fixnum(target)); + break; + case MRB_TT_FLOAT : + GRN_OUTPUT_FLOAT(mrb_float(target)); + break; + case MRB_TT_SYMBOL : + { + const char *name; + mrb_int name_length; + + name = mrb_sym2name_len(mrb, mrb_symbol(target), &name_length); + GRN_OUTPUT_STR(name, name_length); + } + break; + case MRB_TT_STRING : + GRN_OUTPUT_STR(RSTRING_PTR(target), RSTRING_LEN(target)); + break; + default : + mrb_raisef(mrb, E_ARGUMENT_ERROR, + "must be nil, true, false, number, float, symbol or string: " + "%S", + target); + break; + } + + return mrb_nil_value(); +} + +static mrb_value +writer_open_array(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + char *name; + mrb_int n_elements; + + mrb_get_args(mrb, "zi", &name, &n_elements); + GRN_OUTPUT_ARRAY_OPEN(name, n_elements); + + return mrb_nil_value(); +} + +static mrb_value +writer_close_array(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + GRN_OUTPUT_ARRAY_CLOSE(); + + return mrb_nil_value(); +} + +static mrb_value +writer_open_map(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + char *name; + mrb_int n_elements; + + mrb_get_args(mrb, "zi", &name, &n_elements); + GRN_OUTPUT_MAP_OPEN(name, n_elements); + + return mrb_nil_value(); +} + +static mrb_value +writer_close_map(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + + GRN_OUTPUT_MAP_CLOSE(); + + return mrb_nil_value(); +} + +static mrb_value +writer_write_table_columns(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_table; + char *columns; + mrb_int columns_size; + grn_obj *table; + grn_obj_format format; + int n_hits = 0; + int offset = 0; + int limit = 0; + int hits_offset = 0; + + mrb_get_args(mrb, "os", &mrb_table, &columns, &columns_size); + + table = DATA_PTR(mrb_table); + GRN_OBJ_FORMAT_INIT(&format, n_hits, offset, limit, hits_offset); + format.flags |= GRN_OBJ_FORMAT_WITH_COLUMN_NAMES; + { + grn_rc rc; + rc = grn_output_format_set_columns(ctx, &format, + table, columns, columns_size); + if (rc != GRN_SUCCESS) { + GRN_OBJ_FORMAT_FIN(ctx, &format); + grn_mrb_ctx_check(mrb); + } + } + GRN_OUTPUT_TABLE_COLUMNS(table, &format); + GRN_OBJ_FORMAT_FIN(ctx, &format); + + return mrb_nil_value(); +} + +static mrb_value +writer_write_table_records(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_value mrb_table; + mrb_value mrb_options = mrb_nil_value(); + char *columns; + mrb_int columns_size; + grn_obj *table; + grn_obj_format format; + int n_hits = 0; + int offset = 0; + int limit = -1; + int hits_offset = 0; + + mrb_get_args(mrb, "os|H", &mrb_table, &columns, &columns_size, &mrb_options); + + table = DATA_PTR(mrb_table); + if (!mrb_nil_p(mrb_options)) { + mrb_value mrb_offset; + mrb_value mrb_limit; + + mrb_offset = grn_mrb_options_get_lit(mrb, mrb_options, "offset"); + if (!mrb_nil_p(mrb_offset)) { + offset = mrb_fixnum(mrb_offset); + } + + mrb_limit = grn_mrb_options_get_lit(mrb, mrb_options, "limit"); + if (!mrb_nil_p(mrb_limit)) { + limit = mrb_fixnum(mrb_limit); + } + } + if (limit < 0) { + limit = grn_table_size(ctx, table) + limit + 1; + } + GRN_OBJ_FORMAT_INIT(&format, n_hits, offset, limit, hits_offset); + { + grn_rc rc; + rc = grn_output_format_set_columns(ctx, &format, + table, columns, columns_size); + if (rc != GRN_SUCCESS) { + GRN_OBJ_FORMAT_FIN(ctx, &format); + grn_mrb_ctx_check(mrb); + } + } + GRN_OUTPUT_TABLE_RECORDS(table, &format); + GRN_OBJ_FORMAT_FIN(ctx, &format); + + return mrb_nil_value(); +} + +static mrb_value +writer_set_content_type(mrb_state *mrb, mrb_value self) +{ + grn_ctx *ctx = (grn_ctx *)mrb->ud; + mrb_int content_type; + + mrb_get_args(mrb, "i", &content_type); + + grn_ctx_set_output_type(ctx, content_type); + + return mrb_nil_value(); +} + +void +grn_mrb_writer_init(grn_ctx *ctx) +{ + grn_mrb_data *data = &(ctx->impl->mrb); + mrb_state *mrb = data->state; + struct RClass *module = data->module; + struct RClass *klass; + + klass = mrb_define_class_under(mrb, module, "Writer", mrb->object_class); + + mrb_define_method(mrb, klass, "write", writer_write, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, klass, "open_array", + writer_open_array, MRB_ARGS_REQ(2)); + mrb_define_method(mrb, klass, "close_array", + writer_close_array, MRB_ARGS_NONE()); + mrb_define_method(mrb, klass, "open_map", + writer_open_map, MRB_ARGS_REQ(2)); + mrb_define_method(mrb, klass, "close_map", + writer_close_map, MRB_ARGS_NONE()); + + mrb_define_method(mrb, klass, "write_table_columns", + writer_write_table_columns, MRB_ARGS_REQ(2)); + mrb_define_method(mrb, klass, "write_table_records", + writer_write_table_records, MRB_ARGS_ARG(2, 1)); + + mrb_define_method(mrb, klass, "content_type=", + writer_set_content_type, MRB_ARGS_REQ(1)); +} +#endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/mrb_writer.h b/storage/mroonga/vendor/groonga/lib/mrb/mrb_writer.h new file mode 100644 index 00000000..7b5b32d4 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/mrb_writer.h @@ -0,0 +1,32 @@ +/* -*- c-basic-offset: 2 -*- */ +/* + Copyright(C) 2015-2016 Brazil + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License version 2.1 as published by the Free Software Foundation. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#pragma once + +#include "../grn_ctx.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void grn_mrb_writer_init(grn_ctx *ctx); + +#ifdef __cplusplus +} +#endif + diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/Makefile.am b/storage/mroonga/vendor/groonga/lib/mrb/scripts/Makefile.am new file mode 100644 index 00000000..835d881b --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/Makefile.am @@ -0,0 +1,16 @@ +SUBDIRS = \ + command_line \ + context \ + expression_tree \ + initialize \ + logger \ + query_logger + +include sources.am + +EXTRA_DIST = \ + $(RUBY_SCRIPT_FILES) + +if WITH_MRUBY +ruby_scripts_DATA = $(RUBY_SCRIPT_FILES) +endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/accessor.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/accessor.rb new file mode 100644 index 00000000..3ae08fb6 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/accessor.rb @@ -0,0 +1,5 @@ +module Groonga + class Accessor + include Indexable + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/backtrace_entry.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/backtrace_entry.rb new file mode 100644 index 00000000..34f95e96 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/backtrace_entry.rb @@ -0,0 +1,28 @@ +module Groonga + class BacktraceEntry + class << self + def parse(entry) + match_data = /:(\d+):?/.match(entry) + file = match_data.pre_match + line = match_data[1].to_i + detail_match_data = /\A(in )?(\S+)\s*/.match(match_data.post_match) + if detail_match_data[1] + method = detail_match_data[2] + message = detail_match_data.post_match + else + method = "" + message = match_data.post_match + end + new(file, line, method, message) + end + end + + attr_reader :file, :line, :method, :message + def initialize(file, line, method, message) + @file = file + @line = line + @method = method + @message = message + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/command.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/command.rb new file mode 100644 index 00000000..26dfe68c --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/command.rb @@ -0,0 +1,64 @@ +module Groonga + class Command + @@classes = {} + class << self + def register_class(name, klass) + @@classes[name] = klass + end + + def find_class(name) + @@classes[name] + end + end + + private + def context + @context ||= Context.instance + end + + def writer + @writer ||= context.writer + end + + def query_logger + @query_logger ||= context.query_logger + end + + def cache_key(input) + nil + end + + def cache_output(key, options={}) + if key.nil? + yield + else + cache = Cache.current + cached_value = cache.fetch(key) + if cached_value + context.output = cached_value + query_logger.log(:cache, ":", "cache(#{cached_value.bytesize})") + else + yield + cache.update(key, context.output) if options[:update] + end + end + end + + def run_internal(input) + begin + options = { + :update => (input["cache"] != "no"), + } + cache_output(cache_key(input), options) do + run_body(input) + end + rescue GroongaError => groonga_error + context.set_groonga_error(groonga_error) + nil + rescue => error + context.record_error(:command_error, error) + nil + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/command_input.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/command_input.rb new file mode 100644 index 00000000..779edb47 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/command_input.rb @@ -0,0 +1,15 @@ +module Groonga + class CommandInput + include Enumerable + + def each + args = arguments + arg = Record.new(args, nil) + args.each do |id| + arg.id = id + key = arg.key + yield(key, self[key]) + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/command_line/Makefile.am b/storage/mroonga/vendor/groonga/lib/mrb/scripts/command_line/Makefile.am new file mode 100644 index 00000000..8d580810 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/command_line/Makefile.am @@ -0,0 +1,9 @@ +include sources.am + +EXTRA_DIST = \ + $(RUBY_SCRIPT_FILES) + +if WITH_MRUBY +ruby_scripts_command_linedir = $(ruby_scriptsdir)/command_line +ruby_scripts_command_line_DATA = $(RUBY_SCRIPT_FILES) +endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/command_line/grndb.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/command_line/grndb.rb new file mode 100644 index 00000000..edd16d58 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/command_line/grndb.rb @@ -0,0 +1,452 @@ +module Groonga + module CommandLine + class Grndb + def initialize(argv) + @program_path, *@arguments = argv + @succeeded = true + @database_path = nil + end + + def run + command_line_parser = create_command_line_parser + options = nil + begin + options = command_line_parser.parse(@arguments) + rescue Slop::Error => error + $stderr.puts(error.message) + $stderr.puts + $stderr.puts(command_line_parser.help_message) + return false + end + @succeeded + end + + private + def create_command_line_parser + program_name = File.basename(@program_path) + parser = CommandLineParser.new(program_name) + + parser.add_command("check") do |command| + command.description = "Check database" + + options = command.options + options.banner += " DB_PATH" + options.string("--target", "Check only the target object.") + + command.add_action do |options| + open_database(command, options) do |database, rest_arguments| + check(database, options, rest_arguments) + end + end + end + + parser.add_command("recover") do |command| + command.description = "Recover database" + + options = command.options + options.banner += " DB_PATH" + options.boolean("--force-truncate", "Force to truncate corrupted objects.") + + command.add_action do |options| + open_database(command, options) do |database, rest_arguments| + recover(database, options, rest_arguments) + end + end + end + + parser + end + + def open_database(command, options) + arguments = options.arguments + if arguments.empty? + $stderr.puts("Database path is missing") + $stderr.puts + $stderr.puts(command.help_message) + @succeesed = false + return + end + + database = nil + @database_path, *rest_arguments = arguments + begin + database = Database.open(@database_path) + rescue Error => error + $stderr.puts("Failed to open database: <#{@database_path}>") + $stderr.puts(error.message) + @succeeded = false + return + end + + begin + yield(database, rest_arguments) + ensure + database.close + end + end + + def failed(*messages) + messages.each do |message| + $stderr.puts(message) + end + @succeeded = false + end + + def recover(database, options, arguments) + recoverer = Recoverer.new + recoverer.database = database + recoverer.force_truncate = options[:force_truncate] + begin + recoverer.recover + rescue Error => error + failed("Failed to recover database: <#{@database_path}>", + error.message) + end + end + + def check(database, options, arguments) + checker = Checker.new + checker.program_path = @program_path + checker.database_path = @database_path + checker.database = database + checker.on_failure = lambda do |message| + failed(message) + end + + checker.check_database + + target_name = options[:target] + if target_name + checker.check_one(target_name) + else + checker.check_all + end + end + + class Checker + attr_writer :program_path + attr_writer :database_path + attr_writer :database + attr_writer :on_failure + + def initialize + @context = Context.instance + @checked = {} + end + + def check_database + check_database_orphan_inspect + check_database_locked + check_database_corrupt + check_database_dirty + end + + def check_one(target_name) + target = @context[target_name] + if target.nil? + exist_p = open_database_cursor do |cursor| + cursor.any? do + cursor.key == target_name + end + end + if exist_p + failed_to_open(target_name) + else + message = "[#{target_name}] Not exist." + failed(message) + end + return + end + + check_object_recursive(target) + end + + def check_all + open_database_cursor do |cursor| + cursor.each do |id| + next if ID.builtin?(id) + next if builtin_object_name?(cursor.key) + next if @context[id] + failed_to_open(cursor.key) + end + end + + @database.each do |object| + check_object(object) + end + end + + private + def check_database_orphan_inspect + open_database_cursor do |cursor| + cursor.each do |id| + if cursor.key == "inspect" and @context[id].nil? + message = + "Database has orphan 'inspect' object. " + + "Remove it by '#{@program_path} recover #{@database_path}'." + failed(message) + break + end + end + end + end + + def check_database_locked + return unless @database.locked? + + message = + "Database is locked. " + + "It may be broken. " + + "Re-create the database." + failed(message) + end + + def check_database_corrupt + return unless @database.corrupt? + + message = + "Database is corrupt. " + + "Re-create the database." + failed(message) + end + + def check_database_dirty + return unless @database.dirty? + + last_modified = @database.last_modified + if File.stat(@database.path).mtime > last_modified + return + end + + open_database_cursor do |cursor| + cursor.each do |id| + next if ID.builtin?(id) + path = "%s.%07x" % [@database.path, id] + next unless File.exist?(path) + return if File.stat(path).mtime > last_modified + end + end + + message = + "Database wasn't closed successfully. " + + "It may be broken. " + + "Re-create the database." + failed(message) + end + + def check_object(object) + return if @checked.key?(object.id) + @checked[object.id] = true + + check_object_locked(object) + check_object_corrupt(object) + end + + def check_object_locked(object) + case object + when IndexColumn + return unless object.locked? + message = + "[#{object.name}] Index column is locked. " + + "It may be broken. " + + "Re-create index by '#{@program_path} recover #{@database_path}'." + failed(message) + when Column + return unless object.locked? + name = object.name + message = + "[#{name}] Data column is locked. " + + "It may be broken. " + + "(1) Truncate the column (truncate #{name}) or " + + "clear lock of the column (lock_clear #{name}) " + + "and (2) load data again." + failed(message) + when Table + return unless object.locked? + name = object.name + message = + "[#{name}] Table is locked. " + + "It may be broken. " + + "(1) Truncate the table (truncate #{name}) or " + + "clear lock of the table (lock_clear #{name}) " + + "and (2) load data again." + failed(message) + end + end + + def check_object_corrupt(object) + case object + when IndexColumn + return unless object.corrupt? + message = + "[#{object.name}] Index column is corrupt. " + + "Re-create index by '#{@program_path} recover #{@database_path}'." + failed(message) + when Column + return unless object.corrupt? + name = object.name + message = + "[#{name}] Data column is corrupt. " + + "(1) Truncate the column (truncate #{name} or " + + "'#{@program_path} recover --force-truncate #{@database_path}') " + + "and (2) load data again." + failed(message) + when Table + return unless object.corrupt? + name = object.name + message = + "[#{name}] Table is corrupt. " + + "(1) Truncate the table (truncate #{name} or " + + "'#{@program_path} recover --force-truncate #{@database_path}') " + + "and (2) load data again." + failed(message) + end + end + + def check_object_recursive(target) + return if @checked.key?(target.id) + + check_object(target) + case target + when Table + unless target.is_a?(Groonga::Array) + domain_id = target.domain_id + domain = @context[domain_id] + if domain.nil? + record = Record.new(@database, domain_id) + failed_to_open(record.key) + elsif domain.is_a?(Table) + check_object_recursive(domain) + end + end + + target.column_ids.each do |column_id| + column = @context[column_id] + if column.nil? + record = Record.new(@database, column_id) + failed_to_open(record.key) + else + check_object_recursive(column) + end + end + when FixedSizeColumn, VariableSizeColumn + range_id = target.range_id + range = @context[range_id] + if range.nil? + record = Record.new(@database, range_id) + failed_to_open(record.key) + elsif range.is_a?(Table) + check_object_recursive(range) + end + + lexicon_ids = [] + target.indexes.each do |index_info| + index = index_info.index + lexicon_ids << index.domain_id + check_object(index) + end + lexicon_ids.uniq.each do |lexicon_id| + lexicon = @context[lexicon_id] + if lexicon.nil? + record = Record.new(@database, lexicon_id) + failed_to_open(record.key) + else + check_object(lexicon) + end + end + when IndexColumn + range_id = target.range_id + range = @context[range_id] + if range.nil? + record = Record.new(@database, range_id) + failed_to_open(record.key) + return + end + check_object(range) + + target.source_ids.each do |source_id| + source = @context[source_id] + if source.nil? + record = Record.new(database, source_id) + failed_to_open(record.key) + elsif source.is_a?(Column) + check_object_recursive(source) + end + end + end + end + + def open_database_cursor(&block) + flags = + TableCursorFlags::ASCENDING | + TableCursorFlags::BY_ID + TableCursor.open(@database, :flags => flags, &block) + end + + def builtin_object_name?(name) + case name + when "inspect" + # Just for compatibility. It's needed for users who used + # Groonga master at between 2016-02-03 and 2016-02-26. + true + else + false + end + end + + def failed(message) + @on_failure.call(message) + end + + def failed_to_open(name) + message = + "[#{name}] Can't open object. " + + "It's broken. " + + "Re-create the object or the database." + failed(message) + end + end + + class Recoverer + attr_writer :database + attr_writer :force_truncate + + def initialize + @context = Context.instance + end + + def recover + if @force_truncate + truncate_corrupt_objects + end + @database.recover + end + + def truncate_corrupt_objects + @database.each do |object| + next unless object.corrupt? + logger = @context.logger + object_path = object.path + object_dirname = File.dirname(object_path) + object_basename = File.basename(object_path) + object.truncate + Dir.foreach(object_dirname) do |path| + if path.start_with?("#{object_basename}.") + begin + File.unlink("#{object_dirname}/#{path}") + message = "Corrupted <#{object_path}> related file is removed: <#{path}>" + $stdout.puts(message) + logger.log(Logger::Level::INFO.to_i, __FILE__, __LINE__, "truncate_corrupt_objects", message) + rescue Error => error + message = "Failed to remove file which is related to corrupted <#{object_path}>: <#{path}>" + $stderr.puts(message) + logger.log_error(message) + end + end + end + end + end + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/command_line/sources.am b/storage/mroonga/vendor/groonga/lib/mrb/scripts/command_line/sources.am new file mode 100644 index 00000000..759948ee --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/command_line/sources.am @@ -0,0 +1,2 @@ +RUBY_SCRIPT_FILES = \ + grndb.rb diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/command_line_parser.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/command_line_parser.rb new file mode 100644 index 00000000..7dad55a7 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/command_line_parser.rb @@ -0,0 +1,168 @@ +module Slop + class MissingCommand < Error + end + + class UnknownCommand < Error + attr_reader :name + + def initialize(msg, name) + super(msg) + @name = name + end + end +end + +module Groonga + class CommandLineParser + def initialize(program_name=nil) + $0 ||= nil + @program_name = program_name || $0 + @commands = [] + @action_runner = ActionRunner.new + @options = Slop::Options.new + setup_options + end + + def options + yield(@options) if block_given? + @options + end + + def add_command(name) + command = Command.new(@program_name, name) + setup_common_options(command.options) + yield(command) + @commands << command + end + + def add_action(&action) + @action_runner.add(&action) + end + + def parse(command_line) + if @commands.empty? + result = @options.parse(command_line) + apply_actions(result) + return result + end + + if command_line.empty? + message = "Command is missing" + raise Slop::MissingCommand.new(message) + end + + first_argument = command_line.first + if first_argument.start_with?("-") + result = @options.parse(command_line) + apply_actions(result) + return result + end + + command_name = first_argument + command = find_command(command_name) + if command.nil? + message = "Unknown command: <#{command_name}>" + raise Slop::UnknownCommand.new(message, command_name) + end + + command.parse(command_line[1..-1]) + end + + def help_message + message = @options.to_s + @commands.each do |command| + message << "\n" + indent = " " * 4 + message << "#{command.description}:\n" if command.description + message << "#{indent}#{command.options.banner}\n" + end + message + end + + private + def setup_options + @options.banner = "Usage: #{@program_name} [OPTIONS]" + setup_common_options(@options) + @options.on("-h", "--help", "Display this help message.", + :tail => true) do + $stdout.puts(help_message) + end + end + + def setup_common_options(options) + options.string("--log-path", + "Change log path (#{Logger.default_path})", + default: Logger.default_path) + default_log_level = Logger.default_level + options.string("--log-level", + "Change log level (#{default_log_level.name})", + default: default_log_level) + end + + def find_command(name) + @commands.find do |command| + command.name == name + end + end + + def apply_actions(result) + @action_runner.run(result) unless result.help? + end + + class ActionRunner + def initialize + @actions = [] + end + + def add(&action) + @actions << action + end + + def run(*args) + @actions.each do |action| + action.call(*args) + end + end + end + + class Command + attr_reader :name + attr_reader :options + attr_accessor :description + def initialize(program_name, name) + @program_name = program_name + @name = name + @options = Slop::Options.new + setup_options + @description = nil + @action_runner = ActionRunner.new + end + + def add_action(&action) + @action_runner.add(&action) + end + + def parse(command_line) + result = @options.parse(command_line) + @action_runner.run(result) unless result.help? + result + end + + def help_message + message = "" + message << "Description: #{@description}\n" if @description + message << @options.to_s + message + end + + private + def setup_options + @options.banner = "Usage: #{@program_name} #{@name} [OPTIONS]" + @options.on("-h", "--help", "Display this help message.", + :tail => true) do + $stdout.puts(help_message) + end + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/context.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/context.rb new file mode 100644 index 00000000..b6f59dc3 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/context.rb @@ -0,0 +1,85 @@ +require "context/error_level" +require "context/rc" + +module Groonga + class Context + def guard(fallback=nil) + begin + yield + rescue => error + logger.log_error(error) + fallback + end + end + + def logger + @logger ||= Logger.new + end + + def query_logger + @query_logger ||= QueryLogger.new + end + + def writer + @writer ||= Writer.new + end + + def set_groonga_error(groonga_error) + set_error_raw(groonga_error.class.rc, + ErrorLevel::ERROR, + groonga_error.message, + groonga_error.backtrace) + end + + def record_error(rc, error) + rc = RC.find(rc) if rc.is_a?(Symbol) + set_error_raw(rc, ErrorLevel::ERROR, error.message, error.backtrace) + + logger.log_error(error) + end + + def with_command_version(version) + old_version = command_version + begin + self.command_version = version + yield + ensure + self.command_version = old_version + end + end + + def open_temporary(id) + if Thread.limit == 1 + need_close = !opened?(id) + else + need_close = false + end + object = self[id] + begin + yield(object) + ensure + if need_close and object and !object.closed? + case object + when Table, Column + object.close + end + end + end + end + + private + def set_error_raw(rc, error_level, message, backtrace) + self.rc = rc.to_i + self.error_level = error_level.to_i + + self.error_message = message + + if backtrace + entry = BacktraceEntry.parse(backtrace.first) + self.error_file = entry.file + self.error_line = entry.line + self.error_method = entry.method + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/context/Makefile.am b/storage/mroonga/vendor/groonga/lib/mrb/scripts/context/Makefile.am new file mode 100644 index 00000000..8d862082 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/context/Makefile.am @@ -0,0 +1,9 @@ +include sources.am + +EXTRA_DIST = \ + $(RUBY_SCRIPT_FILES) + +if WITH_MRUBY +ruby_scripts_contextdir = $(ruby_scriptsdir)/context +ruby_scripts_context_DATA = $(RUBY_SCRIPT_FILES) +endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/context/error_level.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/context/error_level.rb new file mode 100644 index 00000000..c0685f16 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/context/error_level.rb @@ -0,0 +1,30 @@ +module Groonga + class Context + class ErrorLevel + @@names = {} + + class << self + def find(name) + @@names[name] + end + end + + attr_reader :name + def initialize(name, level) + @@names[name] = self + @name = name + @level = level + end + + def to_i + @level + end + + EMERGENCY = new(:emergency, 1) + ALERT = new(:alert, 2) + CRITICAL = new(:critical, 3) + ERROR = new(:error, 4) + WARNING = new(:warning, 5) + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/context/rc.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/context/rc.rb new file mode 100644 index 00000000..45187c22 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/context/rc.rb @@ -0,0 +1,205 @@ +module Groonga + class Context + class RC + @@codes = {} + @@names = {} + + class << self + def find(name_or_code) + if name_or_code.is_a?(Symbol) + @@names[name_or_code] || UNKNOWN_ERROR + else + @@codes[name_or_code] || UNKNOWN_ERROR + end + end + + def register(name, code, error_class) + rc = new(name, code, error_class) + @@codes[code] = rc + @@names[name] = rc + error_class.rc = rc if error_class + rc + end + end + + attr_reader :name + attr_reader :error_class + def initialize(name, code, error_class) + @name = name + @code = code + @error_class = error_class + end + + def to_i + @code + end + + SUCCESS = + register(:success, 0, nil) + END_OF_DATA = + register(:end_of_data, 1, EndOfData) + UNKNOWN_ERROR = + register(:unknown_error, -1, UnknownError) + OPERATION_NOT_PERMITTED = + register(:operation_not_permitted, -2, OperationNotPermitted) + NO_SUCH_FILE_OR_DIRECTORY = + register(:no_such_file_or_directory, -3, NoSuchFileOrDirectory) + NO_SUCH_PROCESS = + register(:no_such_process, -4, NoSuchProcess) + INTERRUPTED_FUNCTION_CALL = + register(:interrupted_function_call, -5, InterruptedFunctionCall) + INPUT_OUTPUT_ERROR = + register(:input_output_error, -6, InputOutputError) + NO_SUCH_DEVICE_OR_ADDRESS = + register(:no_such_device_or_address, -7, NoSuchDeviceOrAddress) + ARG_LIST_TOO_LONG = + register(:arg_list_too_long, -8, ArgListTooLong) + EXEC_FORMAT_ERROR = + register(:exec_format_error, -9, ExecFormatError) + BAD_FILE_DESCRIPTOR = + register(:bad_file_descriptor, -10, BadFileDescriptor) + NO_CHILD_PROCESSES = + register(:no_child_processes, -11, NoChildProcesses) + RESOURCE_TEMPORARILY_UNAVAILABLE = + register(:resource_temporarily_unavailable, -12, + ResourceTemporarilyUnavailable) + NOT_ENOUGH_SPACE = + register(:not_enough_space, -13, NotEnoughSpace) + PERMISSION_DENIED = + register(:permission_denied, -14, PermissionDenied) + BAD_ADDRESS = + register(:bad_address, -15, BadAddress) + RESOURCE_BUSY = + register(:resource_busy, -16, ResourceBusy) + FILE_EXISTS = + register(:file_exists, -17, FileExists) + IMPROPER_LINK = + register(:improper_link, -18, ImproperLink) + NO_SUCH_DEVICE = + register(:no_such_device, -19, NoSuchDevice) + NOT_DIRECTORY = + register(:not_directory, -20, NotDirectory) + IS_DIRECTORY = + register(:is_directory, -21, IsDirectory) + INVALID_ARGUMENT = + register(:invalid_argument, -22, InvalidArgument) + TOO_MANY_OPEN_FILES_IN_SYSTEM = + register(:too_many_open_files_in_system, -23, TooManyOpenFilesInSystem) + TOO_MANY_OPEN_FILES = + register(:too_many_open_files, -24, TooManyOpenFiles) + INAPPROPRIATE_IO_CONTROL_OPERATION = + register(:inappropriate_io_control_operation, -25, + InappropriateIOControlOperation) + FILE_TOO_LARGE = + register(:file_too_large, -26, FileTooLarge) + NO_SPACE_LEFT_ON_DEVICE = + register(:no_space_left_on_device, -27, NoSpaceLeftOnDevice) + INVALID_SEEK = + register(:invalid_seek, -28, InvalidSeek) + READ_ONLY_FILE_SYSTEM = + register(:read_only_file_system, -29, ReadOnlyFileSystem) + TOO_MANY_LINKS = + register(:too_many_links, -30, TooManyLinks) + BROKEN_PIPE = + register(:broken_pipe, -31, BrokenPipe) + DOMAIN_ERROR = + register(:domain_error, -32, DomainError) + RESULT_TOO_LARGE = + register(:result_too_large, -33, ResultTooLarge) + RESOURCE_DEADLOCK_AVOIDED = + register(:resource_deadlock_avoided, -34, ResourceDeadlockAvoided) + NO_MEMORY_AVAILABLE = + register(:no_memory_available, -35, NoMemoryAvailable) + FILENAME_TOO_LONG = + register(:filename_too_long, -36, FilenameTooLong) + NO_LOCKS_AVAILABLE = + register(:no_locks_available, -37, NoLocksAvailable) + FUNCTION_NOT_IMPLEMENTED = + register(:function_not_implemented, -38, FunctionNotImplemented) + DIRECTORY_NOT_EMPTY = + register(:directory_not_empty, -39, DirectoryNotEmpty) + ILLEGAL_BYTE_SEQUENCE = + register(:illegal_byte_sequence, -40, IllegalByteSequence) + SOCKET_NOT_INITIALIZED = + register(:socket_not_initialized, -41, SocketNotInitialized) + OPERATION_WOULD_BLOCK = + register(:operation_would_block, -42, OperationWouldBlock) + ADDRESS_IS_NOT_AVAILABLE = + register(:address_is_not_available, -43, AddressIsNotAvailable) + NETWORK_IS_DOWN = + register(:network_is_down, -44, NetworkIsDown) + NO_BUFFER = + register(:no_buffer, -45, NoBuffer) + SOCKET_IS_ALREADY_CONNECTED = + register(:socket_is_already_connected, -46, SocketIsAlreadyConnected) + SOCKET_IS_NOT_CONNECTED = + register(:socket_is_not_connected, -47, SocketIsNotConnected) + SOCKET_IS_ALREADY_SHUTDOWNED = + register(:socket_is_already_shutdowned, -48, SocketIsAlreadyShutdowned) + OPERATION_TIMEOUT = + register(:operation_timeout, -49, OperationTimeout) + CONNECTION_REFUSED = + register(:connection_refused, -50, ConnectionRefused) + RANGE_ERROR = + register(:range_error, -51, RangeError) + TOKENIZER_ERROR = + register(:tokenizer_error, -52, TokenizerError) + FILE_CORRUPT = + register(:file_corrupt, -53, FileCorrupt) + INVALID_FORMAT = + register(:invalid_format, -54, InvalidFormat) + OBJECT_CORRUPT = + register(:object_corrupt, -55, ObjectCorrupt) + TOO_MANY_SYMBOLIC_LINKS = + register(:too_many_symbolic_links, -56, TooManySymbolicLinks) + NOT_SOCKET = + register(:not_socket, -57, NotSocket) + OPERATION_NOT_SUPPORTED = + register(:operation_not_supported, -58, OperationNotSupported) + ADDRESS_IS_IN_USE = + register(:address_is_in_use, -59, AddressIsInUse) + ZLIB_ERROR = + register(:zlib_error, -60, ZlibError) + LZ4_ERROR = + register(:lz4_error, -61, LZ4Error) + STACK_OVER_FLOW = + register(:stack_over_flow, -62, StackOverFlow) + SYNTAX_ERROR = + register(:syntax_error, -63, SyntaxError) + RETRY_MAX = + register(:retry_max, -64, RetryMax) + INCOMPATIBLE_FILE_FORMAT = + register(:incompatible_file_format, -65, IncompatibleFileFormat) + UPDATE_NOT_ALLOWED = + register(:update_not_allowed, -66, UpdateNotAllowed) + TOO_SMALL_OFFSET = + register(:too_small_offset, -67, TooSmallOffset) + TOO_LARGE_OFFSET = + register(:too_large_offset, -68, TooLargeOffset) + TOO_SMALL_LIMIT = + register(:too_small_limit, -69, TooSmallLimit) + CAS_ERROR = + register(:cas_error, -70, CASError) + UNSUPPORTED_COMMAND_VERSION = + register(:unsupported_command_version, -71, UnsupportedCommandVersion) + NORMALIZER_ERROR = + register(:normalizer_error, -72, NormalizerError) + TOKEN_FILTER_ERROR = + register(:token_filter_error, -73, TokenFilterError) + COMMAND_ERROR = + register(:command_error, -74, CommandError) + PLUGIN_ERROR = + register(:plugin_error, -75, PluginError) + SCORER_ERROR = + register(:scorer_error, -76, ScorerError) + CANCEL = + register(:cancel, -77, Cancel) + WINDOW_FUNCTION_ERROR = + register(:window_function_error, -78, WindowFunctionError) + ZSTD_ERROR = + register(:zstd_error, -79, ZstdError) + + GroongaError.rc = UNKNOWN_ERROR + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/context/sources.am b/storage/mroonga/vendor/groonga/lib/mrb/scripts/context/sources.am new file mode 100644 index 00000000..1f0d1624 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/context/sources.am @@ -0,0 +1,3 @@ +RUBY_SCRIPT_FILES = \ + error_level.rb \ + rc.rb diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/database.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/database.rb new file mode 100644 index 00000000..e0c6b4a0 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/database.rb @@ -0,0 +1,65 @@ +module Groonga + class Database + def each_raw(options=nil) + return to_enum(__method__, options) unless block_given? + + if options + min = options[:prefix] + order = options[:order] + order_by = options[:order_by] + else + min = nil + order = :ascending + order_by = :id + end + flags = 0 + + if order == :descending + flags |= TableCursorFlags::DESCENDING + else + flags |= TableCursorFlags::ASCENDING + end + if order_by == :id + flags |= TableCursorFlags::BY_ID + else + flags |= TableCursorFlags::BY_KEY + end + flags |= TableCursorFlags::PREFIX if min + TableCursor.open(self, :min => min, :flags => flags) do |cursor| + cursor.each do |id| + yield(id, cursor) + end + end + end + + def each(options=nil) + return to_enum(__method__, options) unless block_given? + + context = Context.instance + each_raw(options) do |id, cursor| + object = context[id] + yield(object) if object + end + end + + def each_name(options=nil) + return to_enum(__method__, options) unless block_given? + + each_raw(options) do |id, cursor| + name = cursor.key + yield(name) + end + end + + def each_table(options={}) + return to_enum(__method__, options) unless block_given? + + context = Context.instance + each_name(options) do |name| + next if name.include?(".") + object = context[name] + yield(object) if object.is_a?(Table) + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/error.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/error.rb new file mode 100644 index 00000000..e39c9045 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/error.rb @@ -0,0 +1,16 @@ +module Groonga + class GroongaError + class << self + def rc + @rc + end + + def rc=(rc) + @rc = rc + end + end + end + + class ErrorMessage < Error + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/eval_context.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/eval_context.rb new file mode 100644 index 00000000..05c7ee8d --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/eval_context.rb @@ -0,0 +1,18 @@ +module Groonga + class EvalContext + def eval(script) + proc = compile(script) + instance_eval(&proc) + end + + def method_missing(id, *args, &block) + return super unless args.empty? + return super if block_given? + + object = Context.instance[id.to_s] + return super if object.nil? + + object + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression.rb new file mode 100644 index 00000000..27dadcb7 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression.rb @@ -0,0 +1,68 @@ +require "expression_rewriter" +require "expression_rewriters" + +require "expression_tree_builder" + +require "scan_info" +require "scan_info_builder" + +require "scan_info_data_size_estimator" +require "expression_size_estimator" + +module Groonga + class Expression + def rewrite + rewritten = nil + begin + return nil unless ExpressionRewriters.enabled? + source = self + ExpressionRewriters.classes.each do |rewriter_class| + rewriter = rewriter_class.new(source) + new_rewritten = rewriter.rewrite + if new_rewritten + rewritten.close if rewritten + rewritten = new_rewritten + source = rewritten + end + end + rescue GroongaError => groonga_error + context.set_groonga_error(groonga_error) + rewritten.close if rewritten + rewritten = nil + rescue => error + context.record_error(:invalid_argument, error) + rewritten.close if rewritten + rewritten = nil + end + rewritten + end + + def build_scan_info(op, record_exist) + begin + builder = ScanInfoBuilder.new(self, op, record_exist) + builder.build + rescue => error + context.record_error(:invalid_argument, error) + nil + end + end + + def estimate_size(table) + begin + estimator = ExpressionSizeEstimator.new(self, table) + estimator.estimate + rescue GroongaError => groonga_error + context.set_groonga_error(groonga_error) + table.size + rescue => error + context.record_error(:unknown_error, error) + table.size + end + end + + private + def context + @context ||= Context.instance + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_rewriter.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_rewriter.rb new file mode 100644 index 00000000..8f56ca7c --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_rewriter.rb @@ -0,0 +1,22 @@ +module Groonga + class ExpressionRewriter + class << self + def register(name) + ExpressionRewriters.register(name, self) + end + end + + def initialize(expression) + @expression = expression + end + + def rewrite + nil + end + + private + def context + @context ||= Context.instance + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_rewriters.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_rewriters.rb new file mode 100644 index 00000000..ae773541 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_rewriters.rb @@ -0,0 +1,41 @@ +module Groonga + module ExpressionRewriters + @rewriters = {} + + class << self + def register(name, rewriter_class) + @rewriters[name] = rewriter_class + end + + def enabled? + rewriters_table_name = + Config["expression_rewriter.table"] || "expression_rewriters" + rewriters_table = Context.instance[rewriters_table_name] + return false if rewriters_table.nil? + return false if rewriters_table.empty? + + true + end + + def classes + rewriters_table_name = + Config["expression_rewriter.table"] || "expression_rewriters" + rewriters_table = Context.instance[rewriters_table_name] + return [] if rewriters_table.nil? + + rewriters_table.collect do |id| + record = Record.new(rewriters_table, id) + name = record.key + rewriter = @rewriters[name] + if rewriter.nil? + plugin_name = record.plugin_name.value + require plugin_name + rewriter = @rewriters[name] + raise "unknown rewriter: <#{name}>:<#{plugin_name}>" if rewriter.nil? + end + rewriter + end + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_size_estimator.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_size_estimator.rb new file mode 100644 index 00000000..597b56f9 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_size_estimator.rb @@ -0,0 +1,54 @@ +module Groonga + class ExpressionSizeEstimator + def initialize(expression, table) + @expression = expression + @table = table + @table_size = @table.size + end + + def estimate + builder = ScanInfoBuilder.new(@expression, Operator::OR, false) + data_list = builder.build + return @table_size if data_list.nil? + + current_size = 0 + sizes = [] + data_list.each do |data| + if (data.flags & ScanInfo::Flags::POP) != 0 + size = sizes.pop + case data.logical_op + when Operator::AND, Operator::AND_NOT + current_size = size if size < current_size + when Operator::OR + current_size = size if size > current_size + else + message = "invalid logical operator: <#{data.logical_op.inspect}>" + raise InvalidArgument, message + end + else + if (data.flags & ScanInfo::Flags::PUSH) != 0 + sizes.push(current_size) + current_size = 0 + end + + estimator = ScanInfoDataSizeEstimator.new(data, @table) + size = estimator.estimate + case data.logical_op + when Operator::AND + current_size = size if size < current_size + when Operator::AND_NOT + size = @table_size - size + size = 0 if size < 0 + current_size = size if size < current_size + when Operator::OR + current_size = size if size > current_size + else + message = "invalid logical operator: <#{data.logical_op.inspect}>" + raise InvalidArgument, message + end + end + end + current_size + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree.rb new file mode 100644 index 00000000..124ace0e --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree.rb @@ -0,0 +1,9 @@ +require "expression_tree/accessor" +require "expression_tree/constant" +require "expression_tree/binary_operation" +require "expression_tree/function_call" +require "expression_tree/index_column" +require "expression_tree/logical_operation" +require "expression_tree/options" +require "expression_tree/procedure" +require "expression_tree/variable" diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/Makefile.am b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/Makefile.am new file mode 100644 index 00000000..1235932f --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/Makefile.am @@ -0,0 +1,9 @@ +include sources.am + +EXTRA_DIST = \ + $(RUBY_SCRIPT_FILES) + +if WITH_MRUBY +ruby_scripts_expression_treedir = $(ruby_scriptsdir)/expression_tree +ruby_scripts_expression_tree_DATA = $(RUBY_SCRIPT_FILES) +endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/accessor.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/accessor.rb new file mode 100644 index 00000000..ac4b122f --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/accessor.rb @@ -0,0 +1,14 @@ +module Groonga + module ExpressionTree + class Accessor + attr_reader :object + def initialize(object) + @object = object + end + + def build(expression) + expression.append_object(@object, Operator::PUSH, 1) + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/binary_operation.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/binary_operation.rb new file mode 100644 index 00000000..d59c65c7 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/binary_operation.rb @@ -0,0 +1,67 @@ +module Groonga + module ExpressionTree + class BinaryOperation + attr_reader :operator + attr_reader :left + attr_reader :right + def initialize(operator, left, right) + @operator = operator + @left = left + @right = right + end + + def build(expression) + @left.build(expression) + @right.build(expression) + expression.append_operator(@operator, 2) + end + + RANGE_OPERATORS = [ + Operator::LESS, + Operator::GREATER, + Operator::LESS_EQUAL, + Operator::GREATER_EQUAL, + ] + def estimate_size(table) + case @operator + when *RANGE_OPERATORS + estimate_size_range(table) + else + table.size + end + end + + private + def estimate_size_range(table) + return table.size unless @left.is_a?(Variable) + return table.size unless @right.is_a?(Constant) + + column = @left.column + value = @right.value + index_info = column.find_index(@operator) + return table.size if index_info.nil? + + index_column = index_info.index + lexicon = index_column.lexicon + options = {} + case @operator + when Operator::LESS + options[:max] = value + options[:flags] = TableCursorFlags::LT + when Operator::LESS_EQUAL + options[:max] = value + options[:flags] = TableCursorFlags::LE + when Operator::GREATER + options[:min] = value + options[:flags] = TableCursorFlags::GT + when Operator::GREATER_EQUAL + options[:min] = value + options[:flags] = TableCursorFlags::GE + end + TableCursor.open(lexicon, options) do |cursor| + index_column.estimate_size(:lexicon_cursor => cursor) + end + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/constant.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/constant.rb new file mode 100644 index 00000000..228a1fc8 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/constant.rb @@ -0,0 +1,22 @@ +module Groonga + module ExpressionTree + class Constant + attr_reader :value + def initialize(value) + @value = value + end + + def build(expression) + expression.append_constant(@value, Operator::PUSH, 1) + end + + def estimate_size(table) + if Bulk.true?(@value) + table.size + else + 0 + end + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/function_call.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/function_call.rb new file mode 100644 index 00000000..0c7438d6 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/function_call.rb @@ -0,0 +1,66 @@ +module Groonga + module ExpressionTree + class FunctionCall + attr_reader :procedure + attr_reader :arguments + def initialize(procedure, arguments) + @procedure = procedure + @arguments = arguments + end + + def build(expression) + @procedure.build(expression) + @arguments.each do |argument| + argument.build(expression) + end + expression.append_operator(Operator::CALL, @arguments.size) + end + + def estimate_size(table) + return table.size unless @procedure.name == "between" + + column, min, min_border, max, max_border = @arguments + + if column.is_a?(Groonga::ExpressionTree::IndexColumn) + index_column = column.object + else + index_info = column.column.find_index(Operator::CALL) + return table.size if index_info.nil? + index_column = index_info.index + end + + while index_column.is_a?(Groonga::Accessor) + if index_column.have_next? + index_column = index_column.next + else + index_column = index_column.object + index_info = index_column.find_index(Operator::CALL) + return table.size if index_info.nil? + index_column = index_info.index + end + end + + lexicon = index_column.lexicon + options = { + :min => min.value, + :max => max.value, + :flags => 0, + } + if min_border.value == "include" + options[:flags] |= TableCursorFlags::LT + else + options[:flags] |= TableCursorFlags::LE + end + if max_border.value == "include" + options[:flags] |= TableCursorFlags::GT + else + options[:flags] |= TableCursorFlags::GE + end + + TableCursor.open(lexicon, options) do |cursor| + index_column.estimate_size(:lexicon_cursor => cursor) + end + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/index_column.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/index_column.rb new file mode 100644 index 00000000..c62a8d19 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/index_column.rb @@ -0,0 +1,14 @@ +module Groonga + module ExpressionTree + class IndexColumn + attr_reader :object + def initialize(object) + @object = object + end + + def build(expression) + expression.append_object(@object, Operator::PUSH, 1) + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/logical_operation.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/logical_operation.rb new file mode 100644 index 00000000..e8d494f8 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/logical_operation.rb @@ -0,0 +1,33 @@ +module Groonga + module ExpressionTree + class LogicalOperation + attr_reader :operator + attr_reader :nodes + def initialize(operator, nodes) + @operator = operator + @nodes = nodes + end + + def build(expression) + @nodes.each_with_index do |node, i| + node.build(expression) + expression.append_operator(@operator, 2) if i > 0 + end + end + + def estimate_size(table) + estimated_sizes = @nodes.collect do |node| + node.estimate_size(table) + end + case @operator + when Operator::AND + estimated_sizes.min + when Operator::OR + estimated_sizes.max + else + estimated_sizes.first + end + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/options.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/options.rb new file mode 100644 index 00000000..1504b57a --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/options.rb @@ -0,0 +1,14 @@ +module Groonga + module ExpressionTree + class Options + attr_reader :object + def initialize(object) + @object = object + end + + def build(expression) + expression.append_object(@object, Operator::PUSH, 1) + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/procedure.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/procedure.rb new file mode 100644 index 00000000..1d63149c --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/procedure.rb @@ -0,0 +1,18 @@ +module Groonga + module ExpressionTree + class Procedure + attr_reader :object + def initialize(object) + @object = object + end + + def name + @object.name + end + + def build(expression) + expression.append_object(@object, Operator::PUSH, 1) + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/sources.am b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/sources.am new file mode 100644 index 00000000..d8a776bf --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/sources.am @@ -0,0 +1,10 @@ +RUBY_SCRIPT_FILES = \ + accessor.rb \ + binary_operation.rb \ + constant.rb \ + function_call.rb \ + index_column.rb \ + logical_operation.rb \ + options.rb \ + procedure.rb \ + variable.rb diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/variable.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/variable.rb new file mode 100644 index 00000000..e99ad9a8 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree/variable.rb @@ -0,0 +1,18 @@ +module Groonga + module ExpressionTree + class Variable + attr_reader :column + def initialize(column) + @column = column + end + + def build(expression) + expression.append_object(@column, Operator::GET_VALUE, 1) + end + + def estimate_size(table) + table.size + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree_builder.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree_builder.rb new file mode 100644 index 00000000..f2cc297c --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/expression_tree_builder.rb @@ -0,0 +1,111 @@ +require "expression_tree" + +module Groonga + class ExpressionTreeBuilder + RELATION_OPERATORS = [ + Operator::MATCH, + Operator::NEAR, + Operator::NEAR2, + Operator::SIMILAR, + Operator::PREFIX, + Operator::SUFFIX, + Operator::EQUAL, + Operator::NOT_EQUAL, + Operator::LESS, + Operator::GREATER, + Operator::LESS_EQUAL, + Operator::GREATER_EQUAL, + Operator::GEO_WITHINP5, + Operator::GEO_WITHINP6, + Operator::GEO_WITHINP8, + Operator::TERM_EXTRACT, + Operator::REGEXP, + Operator::FUZZY, + ] + + ARITHMETIC_OPERATORS = [ + Operator::BITWISE_OR, + Operator::BITWISE_XOR, + Operator::BITWISE_AND, + Operator::BITWISE_NOT, + Operator::SHIFTL, + Operator::SHIFTR, + Operator::SHIFTRR, + Operator::PLUS, + Operator::MINUS, + Operator::STAR, + Operator::MOD, + ] + + LOGICAL_OPERATORS = [ + Operator::AND, + Operator::OR, + Operator::AND_NOT, + Operator::ADJUST, + ] + + def initialize(expression) + @expression = expression + end + + def build + stack = [] + codes = @expression.codes + codes.each do |code| + case code.op + when *LOGICAL_OPERATORS + right = stack.pop + left = stack.pop + nodes = [] + add_logical_operation_node(code.op, nodes, left) + add_logical_operation_node(code.op, nodes, right) + node = ExpressionTree::LogicalOperation.new(code.op, nodes) + stack.push(node) + when *RELATION_OPERATORS, *ARITHMETIC_OPERATORS + right = stack.pop + left = stack.pop + node = ExpressionTree::BinaryOperation.new(code.op, left, right) + stack.push(node) + when Operator::GET_VALUE + node = ExpressionTree::Variable.new(code.value) + stack.push(node) + when Operator::PUSH + case code.value + when Procedure + node = ExpressionTree::Procedure.new(code.value) + when IndexColumn + node = ExpressionTree::IndexColumn.new(code.value) + when Accessor + node = ExpressionTree::Accessor.new(code.value) + when HashTable + node = ExpressionTree::Options.new(code.value) + else + node = ExpressionTree::Constant.new(code.value.value) + end + stack.push(node) + when Operator::CALL + arguments = [] + (code.n_args - 1).times do + arguments.unshift(stack.pop) + end + procedure = stack.pop + node = ExpressionTree::FunctionCall.new(procedure, arguments) + stack.push(node) + else + raise "unknown operator: #{code.inspect}" + end + end + stack.pop + end + + private + def add_logical_operation_node(operator, nodes, node) + if node.is_a?(ExpressionTree::LogicalOperation) and + node.operator == operator + nodes.concat(node.nodes) + else + nodes << node + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/fixed_size_column.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/fixed_size_column.rb new file mode 100644 index 00000000..4fab9fb7 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/fixed_size_column.rb @@ -0,0 +1,5 @@ +module Groonga + class FixedSizeColumn + include Indexable + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/id.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/id.rb new file mode 100644 index 00000000..a49e4fde --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/id.rb @@ -0,0 +1,12 @@ +module Groonga + module ID + # TODO: Should we bind GRN_N_RESERVED_TYPES? + N_RESERVED_TYPES = 256 + + class << self + def builtin?(id) + id < N_RESERVED_TYPES + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/index_column.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/index_column.rb new file mode 100644 index 00000000..25ebc149 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/index_column.rb @@ -0,0 +1,39 @@ +module Groonga + class IndexColumn + private :estimate_size_for_term_id + private :estimate_size_for_query + private :estimate_size_for_lexicon_cursor + + # Estimate the number of matched records for term ID or query. + # + # @overload estimate_size(:term_id => term_id) + # @return [Integer] the number of matched records for the term ID. + # + # @overload estimate_size(:query => query) + # @return [Integer] the number of matched records for the query. + # + # @overload estimate_size(:lexicon_cursor => lexicon_cursor) + # @return [Integer] the number of matched records for the lexicon cursor. + # + def estimate_size(parameters) + term_id = parameters[:term_id] + if term_id + return estimate_size_for_term_id(term_id) + end + + query = parameters[:query] + if query + return estimate_size_for_query(query, parameters) + end + + lexicon_cursor = parameters[:lexicon_cursor] + if lexicon_cursor + return estimate_size_for_lexicon_cursor(lexicon_cursor) + end + + message = + "must specify :term_id, :query, :lexicon_cursor: #{parameters.inspect}" + raise InvalidArgument, message + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/index_cursor.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/index_cursor.rb new file mode 100644 index 00000000..80440669 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/index_cursor.rb @@ -0,0 +1,18 @@ +module Groonga + class IndexCursor + class << self + def open(*arguments) + cursor = open_raw(*arguments) + if block_given? + begin + yield(cursor) + ensure + cursor.close + end + else + cursor + end + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/index_info.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/index_info.rb new file mode 100644 index 00000000..cf8336e5 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/index_info.rb @@ -0,0 +1,10 @@ +module Groonga + class IndexInfo + attr_reader :index + attr_reader :section_id + def initialize(index, section_id) + @index = index + @section_id = section_id + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/initialize/Makefile.am b/storage/mroonga/vendor/groonga/lib/mrb/scripts/initialize/Makefile.am new file mode 100644 index 00000000..e7531fdc --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/initialize/Makefile.am @@ -0,0 +1,9 @@ +include sources.am + +EXTRA_DIST = \ + $(RUBY_SCRIPT_FILES) + +if WITH_MRUBY +ruby_scripts_initializedir = $(ruby_scriptsdir)/initialize +ruby_scripts_initialize_DATA = $(RUBY_SCRIPT_FILES) +endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/initialize/post.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/initialize/post.rb new file mode 100644 index 00000000..c1215f3e --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/initialize/post.rb @@ -0,0 +1,28 @@ +require "error" + +require "context" + +require "writer" + +require "id" + +require "object" +require "database" +require "table" +require "record" +require "fixed_size_column" +require "variable_size_column" +require "index_column" +require "accessor" +require "command" +require "command_input" +require "table_cursor" +require "index_cursor" + +require "expression" + +require "plugin_loader" + +require "eval_context" + +require "command_line_parser" diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/initialize/pre.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/initialize/pre.rb new file mode 100644 index 00000000..99300d11 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/initialize/pre.rb @@ -0,0 +1,3 @@ +require "backtrace_entry" + +require "operator" diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/initialize/sources.am b/storage/mroonga/vendor/groonga/lib/mrb/scripts/initialize/sources.am new file mode 100644 index 00000000..3c26e19b --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/initialize/sources.am @@ -0,0 +1,3 @@ +RUBY_SCRIPT_FILES = \ + pre.rb \ + post.rb diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/logger.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/logger.rb new file mode 100644 index 00000000..95f86974 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/logger.rb @@ -0,0 +1,34 @@ +module Groonga + class Logger + def log_error(error) + log_level = Level::ERROR.to_i + + if error.is_a?(Error) + message = error.message + else + message = "#{error.class}: #{error.message}" + end + backtrace = error.backtrace + first_raw_entry = backtrace.first + if first_raw_entry + first_entry = BacktraceEntry.parse(first_raw_entry) + file = first_entry.file + line = first_entry.line + method = first_entry.method + # message = "#{file}:#{line}:#{method}: #{message}" + else + file = "" + line = 0 + method = "" + end + log(log_level, file, line, method, message) + + backtrace.each_with_index do |raw_entry, i| + entry = BacktraceEntry.parse(raw_entry) + message = entry.message + message = raw_entry if message.empty? + log(log_level, entry.file, entry.line, entry.method, raw_entry) + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/logger/Makefile.am b/storage/mroonga/vendor/groonga/lib/mrb/scripts/logger/Makefile.am new file mode 100644 index 00000000..448e72ca --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/logger/Makefile.am @@ -0,0 +1,9 @@ +include sources.am + +EXTRA_DIST = \ + $(RUBY_SCRIPT_FILES) + +if WITH_MRUBY +ruby_scripts_loggerdir = $(ruby_scriptsdir)/logger +ruby_scripts_logger_DATA = $(RUBY_SCRIPT_FILES) +endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/logger/level.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/logger/level.rb new file mode 100644 index 00000000..4b8afa2c --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/logger/level.rb @@ -0,0 +1,40 @@ +module Groonga + class Logger + class Level + @@names = {} + @@levels = {} + class << self + def find(name_or_level) + if name_or_level.is_a?(Integer) + @@levels[name_or_level] + else + @@names[name_or_level] + end + end + end + + attr_reader :name + def initialize(name, level) + @@names[name] = self + @@levels[level] = self + @name = name + @level = level + end + + def to_i + @level + end + + NONE = new(:none, 0) + EMERG = new(:emerg, 1) + ALERT = new(:alert, 2) + CRIT = new(:crit, 3) + ERROR = new(:error, 4) + WARNING = new(:warning, 5) + NOTICE = new(:notice, 6) + INFO = new(:info, 7) + DEBUG = new(:debug, 8) + DUMP = new(:dump, 9) + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/logger/sources.am b/storage/mroonga/vendor/groonga/lib/mrb/scripts/logger/sources.am new file mode 100644 index 00000000..7231ee4e --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/logger/sources.am @@ -0,0 +1,2 @@ +RUBY_SCRIPT_FILES = \ + level.rb diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/object.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/object.rb new file mode 100644 index 00000000..aa8e9e65 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/object.rb @@ -0,0 +1,18 @@ +module Groonga + class Object + def domain + Context.instance[domain_id] + end + + def range + Context.instance[range_id] + end + + def corrupt? + check_corrupt + false + rescue + true + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/operator.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/operator.rb new file mode 100644 index 00000000..349695e1 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/operator.rb @@ -0,0 +1,22 @@ +module Groonga + class Operator + @values = {} + class << self + def register(operator) + const_set(operator.name, operator) + @values[operator.value] = operator + end + + def find(value) + @values[value] + end + end + + attr_reader :name + attr_reader :value + def initialize(name, value) + @name = name + @value = value + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/plugin_loader.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/plugin_loader.rb new file mode 100644 index 00000000..09b972f1 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/plugin_loader.rb @@ -0,0 +1,14 @@ +module Groonga + class PluginLoader + class << self + def load_file(path) + begin + load(path) + rescue => error + Context.instance.record_error(:plugin_error, error) + nil + end + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/query_logger.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/query_logger.rb new file mode 100644 index 00000000..386ec0e2 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/query_logger.rb @@ -0,0 +1,9 @@ +module Groonga + class QueryLogger + def log(flag, mark, message) + flag = Flag.find(flag) if flag.is_a?(Symbol) + flag = flag.to_i if flag.is_a?(Flag) + log_raw(flag, mark, message) + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/query_logger/Makefile.am b/storage/mroonga/vendor/groonga/lib/mrb/scripts/query_logger/Makefile.am new file mode 100644 index 00000000..14b4f61c --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/query_logger/Makefile.am @@ -0,0 +1,9 @@ +include sources.am + +EXTRA_DIST = \ + $(RUBY_SCRIPT_FILES) + +if WITH_MRUBY +ruby_scripts_query_loggerdir = $(ruby_scriptsdir)/query_logger +ruby_scripts_query_logger_DATA = $(RUBY_SCRIPT_FILES) +endif diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/query_logger/flag.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/query_logger/flag.rb new file mode 100644 index 00000000..659570f6 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/query_logger/flag.rb @@ -0,0 +1,39 @@ +module Groonga + class QueryLogger + class Flag + @@names = {} + class << self + def find(name) + @@names[name] + end + end + + attr_reader :name + def initialize(name, flag) + @@names[name] = self + @name = name + @flag = flag + end + + def to_i + @flag + end + + NONE = new(:none, 0x00) + COMMAND = new(:command, 0x01 << 0) + RESULT_CODE = new(:result_code, 0x01 << 1) + DESTINATION = new(:destination, 0x01 << 2) + CACHE = new(:cache, 0x01 << 3) + SIZE = new(:size, 0x01 << 4) + SCORE = new(:score, 0x01 << 5) + + all_flags = COMMAND.to_i | + RESULT_CODE.to_i | + DESTINATION.to_i | + CACHE.to_i | + SIZE.to_i | + SCORE.to_i + ALL = new(:all, all_flags) + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/query_logger/sources.am b/storage/mroonga/vendor/groonga/lib/mrb/scripts/query_logger/sources.am new file mode 100644 index 00000000..44871a85 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/query_logger/sources.am @@ -0,0 +1,2 @@ +RUBY_SCRIPT_FILES = \ + flag.rb diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/record.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/record.rb new file mode 100644 index 00000000..cd7d1a4c --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/record.rb @@ -0,0 +1,38 @@ +module Groonga + class Record + attr_reader :table + attr_reader :id + + def inspect + super.gsub(/>\z/) do + "@id=#{@id.inspect}, @table=#{@table.inspect}>" + end + end + + def [](name) + column = find_column(name) + if column.nil? + raise InvalidArgument, "unknown column: <#{absolute_column_name(name)}>" + end + column[@id] + end + + def method_missing(name, *args, &block) + return super unless args.empty? + + column = find_column(name) + return super if column.nil? + + column[@id] + end + + private + def absolute_column_name(name) + "#{@table.name}.#{name}" + end + + def find_column(name) + Context.instance[absolute_column_name(name)] + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/require.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/require.rb new file mode 100644 index 00000000..1352b327 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/require.rb @@ -0,0 +1,71 @@ +$" = [__FILE__] + +class ScriptLoader + @@loading_paths = {} + + def initialize(path) + @base_path = path + end + + def load_once + if absolute_path?(@base_path) + loaded = load_once_path(@base_path) + if loaded.nil? + raise LoadError, error_message + else + loaded + end + else + $LOAD_PATH.each do |load_path| + unless absolute_path?(load_path) + load_path = File.expand_path(load_path) + if File::ALT_SEPARATOR + load_path = load_path.gsub(File::ALT_SEPARATOR, "/") + end + end + loaded = load_once_path(File.join(load_path, @base_path)) + return loaded unless loaded.nil? + end + raise LoadError, error_message + end + end + + private + def error_message + "cannot load such file -- #{@base_path}" + end + + def absolute_path?(path) + path.start_with?("/") or (/\A[a-z]:\\/i === path) + end + + def load_once_path(path) + loaded = load_once_absolute_path(path) + return loaded unless loaded.nil? + + return nil unless File.extname(path).empty? + + load_once_absolute_path("#{path}.rb") + end + + def load_once_absolute_path(path) + return false if $".include?(path) + return false if @@loading_paths.key?(path) + + return nil unless File.file?(path) + + @@loading_paths[path] = true + load(path) + $" << path + @@loading_paths.delete(path) + + true + end +end + +module Kernel + def require(path) + loader = ScriptLoader.new(path) + loader.load_once + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/scan_info.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/scan_info.rb new file mode 100644 index 00000000..acdb2eeb --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/scan_info.rb @@ -0,0 +1,38 @@ +module Groonga + class ScanInfo + module Flags + ACCESSOR = 0x01 + PUSH = 0x02 + POP = 0x04 + PRE_CONST = 0x08 + end + + def apply(data) + self.op = data.op + self.logical_op = data.logical_op + self.end = data.end + self.query = data.query + self.flags = data.flags + if data.max_interval + self.max_interval = data.max_interval + end + if data.similarity_threshold + self.similarity_threshold = data.similarity_threshold + end + data.args.each do |arg| + push_arg(arg) + end + data.search_indexes.each do |search_index| + put_index(search_index.index_column, + search_index.section_id, + search_index.weight, + search_index.scorer, + search_index.scorer_args_expr, + search_index.scorer_args_expr_offset || 0) + end + if data.start_position + self.start_position = data.start_position + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/scan_info_builder.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/scan_info_builder.rb new file mode 100644 index 00000000..66dad9ea --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/scan_info_builder.rb @@ -0,0 +1,577 @@ +require "scan_info_data" + +module Groonga + class ScanInfoBuilder + def initialize(expression, operator, record_exist) + @data_list = [] + @expression = expression + @operator = operator + @record_exist = record_exist + @variable = @expression[0] + @table = Context.instance[@variable.domain] + end + + RELATION_OPERATORS = [ + Operator::MATCH, + Operator::NEAR, + Operator::NEAR2, + Operator::SIMILAR, + Operator::PREFIX, + Operator::SUFFIX, + Operator::EQUAL, + Operator::NOT_EQUAL, + Operator::LESS, + Operator::GREATER, + Operator::LESS_EQUAL, + Operator::GREATER_EQUAL, + Operator::GEO_WITHINP5, + Operator::GEO_WITHINP6, + Operator::GEO_WITHINP8, + Operator::TERM_EXTRACT, + Operator::REGEXP, + Operator::FUZZY, + ] + + ARITHMETIC_OPERATORS = [ + Operator::BITWISE_OR, + Operator::BITWISE_XOR, + Operator::BITWISE_AND, + Operator::BITWISE_NOT, + Operator::SHIFTL, + Operator::SHIFTR, + Operator::SHIFTRR, + Operator::PLUS, + Operator::MINUS, + Operator::STAR, + Operator::MOD, + ] + + LOGICAL_OPERATORS = [ + Operator::AND, + Operator::OR, + Operator::AND_NOT, + Operator::ADJUST, + ] + def build + return nil unless valid? + + context = BuildContext.new(@expression) + codes = context.codes + while context.have_next? + code = context.code + code_op = context.code_op + i = context.i + context.next + + case code_op + when *RELATION_OPERATORS + context.status = :start + data = context.data + data.op = code_op + data.end = i + data.weight = code.value.value if code.value + data.match_resolve_index + @data_list << data + context.data = nil + when *LOGICAL_OPERATORS + if context.status == :const + data = context.data + data.op = Operator::PUSH + data.end = data.start + @data_list << data + context.data = nil + end + put_logical_op(code_op, i) + # TODO: rescue and return nil + context.status = :start + when Operator::PUSH + context.data ||= ScanInfoData.new(i) + data = context.data + if code.value == @variable + context.status = :var + else + data.args << code.value + if context.status == :start + data.flags |= ScanInfo::Flags::PRE_CONST + end + context.status = :const + end + if code.modify > 0 and + LOGICAL_OPERATORS.include?(codes[i + code.modify].op) + data.op = Operator::PUSH + data.end = data.start + @data_list << data + context.data = nil + context.status = :start + end + when Operator::GET_VALUE + case context.status + when :start + context.data ||= ScanInfoData.new(i) + data = context.data + context.status = :column1 + data.args << code.value + when :const, :var + context.status = :column1 + data.args << code.value + when :column1 + message = "invalid expression: can't use column as a value: " + message << "<#{code.value.name}>: <#{@expression.grn_inspect}>" + raise ErrorMessage, message + when :column2 + # Do nothing + else + message = "internal expression parsing error: unknown status: " + message << "<#{context.status.inspect}>: " + message << "<#{@expression.grn_inspect}>" + raise ErrorMessage, message + end + when Operator::CALL + context.data ||= ScanInfoData.new(i) + data = context.data + if (code.flags & ExpressionCode::Flags::RELATIONAL_EXPRESSION) != 0 or + (not context.have_next?) + context.status = :start + data.op = code_op + data.end = i + data.call_relational_resolve_indexes + @data_list << data + context.data = nil + else + context.status = :column2 + end + when Operator::GET_REF + context.data ||= ScanInfoData.new(i) + case context.status + when :start + data = context.data + context.status = :column1 + data.args << code.value + end + when Operator::GET_MEMBER + data = context.data + index = data.args.pop + data.start_position = index.value + context.status = :column1 + when Operator::NOT + success = build_not(context, code, i) + return nil unless success + end + end + + if @operator == Operator::OR and !@record_exist + first_data = @data_list.first + if (first_data.flags & ScanInfo::Flags::PUSH) == 0 or + first_data.logical_op != @operator + raise ErrorMessage, "invalid expr" + else + first_data.flags &= ~ScanInfo::Flags::PUSH + first_data.logical_op = @operator + end + else + put_logical_op(@operator, context.n_codes) + end + + optimize + end + + private + def valid? + n_relation_expressions = 0 + n_logical_expressions = 0 + status = :start + codes = @expression.codes + codes.each_with_index do |code, i| + case code.op + when *RELATION_OPERATORS + if status == :start || status == :var + return false + end + status = :start + n_relation_expressions += 1 + when *ARITHMETIC_OPERATORS + if status == :start || status == :var + return false + end + status = :start + return false if n_relation_expressions != (n_logical_expressions + 1) + when *LOGICAL_OPERATORS + case status + when :start + n_logical_expressions += 1 + return false if n_logical_expressions >= n_relation_expressions + when :const + n_logical_expressions += 1 + n_relation_expressions += 1 + return false if n_logical_expressions >= n_relation_expressions + status = :start + else + return false + end + when Operator::PUSH + if code.modify > 0 and + LOGICAL_OPERATORS.include?(codes[i + code.modify].op) + n_relation_expressions += 1 + status = :start + else + if code.value == @variable + status = :var + else + status = :const + end + end + when Operator::GET_VALUE + case status + when :start, :const, :var + status = :column1 + when :column1 + status = :column2 + when :column2 + # Do nothing + else + return false + end + when Operator::CALL + if (code.flags & ExpressionCode::Flags::RELATIONAL_EXPRESSION) != 0 or + code == codes.last + status = :start + n_relation_expressions += 1 + else + status = :column2 + end + when Operator::GET_REF + case status + when :start + status = :column1 + else + return false + end + when Operator::GET_MEMBER + case status + when :const + return false unless codes[i - 1].value.value.is_a?(Integer) + status = :column1 + else + return false + end + when Operator::NOT + # Do nothing + else + return false + end + end + + return false if status != :start + return false if n_relation_expressions != (n_logical_expressions + 1) + + true + end + + def put_logical_op(operator, start) + n_parens = 1 + n_dif_ops = 0 + r = 0 + j = @data_list.size + while j > 0 + j -= 1 + data = @data_list[j] + if (data.flags & ScanInfo::Flags::POP) != 0 + n_dif_ops += 1 + n_parens += 1 + else + if (data.flags & ScanInfo::Flags::PUSH) != 0 + n_parens -= 1 + if n_parens == 0 + if r == 0 + if n_dif_ops > 0 + if j > 0 and operator != Operator::AND_NOT + n_parens = 1 + n_dif_ops = 0 + r = j + else + new_data = ScanInfoData.new(start) + new_data.flags = ScanInfo::Flags::POP + new_data.logical_op = operator + @data_list << new_data + break + end + else + data.flags &= ~ScanInfo::Flags::PUSH + data.logical_op = operator + break + end + else + if n_dif_ops > 0 + new_data = ScanInfoData.new(start) + new_data.flags = ScanInfo::Flags::POP + new_data.logical_op = operator + @data_list << new_data + else + data.flags &= ~ScanInfo::Flags::PUSH + data.logical_op = operator + @data_list = + @data_list[0...j] + + @data_list[r..-1] + + @data_list[j...r] + end + break + end + end + else + if operator == Operator::AND_NOT or operator != data.logical_op + n_dif_ops += 1 + end + end + end + + if j < 0 + raise ErrorMessage, "unmatched nesting level" + end + end + end + + def build_not(context, code, i) + last_data = @data_list.last + return false if last_data.nil? + + case last_data.op + when Operator::LESS + last_data.op = Operator::GREATER_EQUAL + last_data.end += 1 + when Operator::LESS_EQUAL + last_data.op = Operator::GREATER + last_data.end += 1 + when Operator::GREATER + last_data.op = Operator::LESS_EQUAL + last_data.end += 1 + when Operator::GREATER_EQUAL + last_data.op = Operator::LESS + last_data.end += 1 + when Operator::NOT_EQUAL + last_data.op = Operator::EQUAL + last_data.end += 1 + else + if @data_list.size == 1 + if last_data.search_indexes.empty? + if last_data.op == Operator::EQUAL + last_data.op = Operator::NOT_EQUAL + last_data.end += 1 + else + return false + end + else + last_data.logical_op = Operator::AND_NOT + last_data.flags &= ~ScanInfo::Flags::PUSH + @data_list.unshift(create_all_match_data) + end + else + next_code = context.code + return false if next_code.nil? + + case next_code.op + when Operator::AND + context.code_op = Operator::AND_NOT + when Operator::AND_NOT + context.code_op = Operator::AND + when Operator::OR + @data_list[-1, 0] = create_all_match_data + put_logical_op(Operator::AND_NOT, i) + else + return false + end + end + end + + true + end + + def optimize + optimized_data_list = [] + i = 0 + n = @data_list.size + while i < n + data = @data_list[i] + next_data = @data_list[i + 1] + i += 1 + if next_data.nil? + optimized_data_list << data + next + end + if range_operations?(data, next_data) + between_data = create_between_data(data, next_data) + optimized_data_list << between_data + i += 1 + next + end + optimized_data_list << data + end + + optimize_by_estimated_size(optimized_data_list) + end + + def optimize_by_estimated_size(data_list) + return data_list unless Groonga::ORDER_BY_ESTIMATED_SIZE + + start_index = nil + data_list.size.times do |i| + data = data_list[i] + if data.logical_op != Operator::AND + if start_index.nil? + start_index = i + else + sort_by_estimated_size!(data_list, start_index...i) + start_index = nil + end + end + end + unless start_index.nil? + sort_by_estimated_size!(data_list, start_index...data_list.size) + end + data_list + end + + def sort_by_estimated_size!(data_list, range) + target_data_list = data_list[range] + return if target_data_list.size < 2 + + start_logical_op = target_data_list.first.logical_op + sorted_data_list = target_data_list.sort_by do |data| + estimator = ScanInfoDataSizeEstimator.new(data, @table) + estimator.estimate + end + sorted_data_list.each do |sorted_data| + sorted_data.logical_op = Operator::AND + end + sorted_data_list.first.logical_op = start_logical_op + data_list[range] = sorted_data_list + end + + def range_operations?(data, next_data) + return false unless next_data.logical_op == Operator::AND + + op, next_op = data.op, next_data.op + return false if !(lower_condition?(op) or lower_condition?(next_op)) + return false if !(upper_condition?(op) or upper_condition?(next_op)) + + return false if data.args[0] != next_data.args[0] + + data_search_indexes = data.search_indexes + return false if data_search_indexes.empty? + + data_search_indexes == next_data.search_indexes + end + + def lower_condition?(operator) + case operator + when Operator::GREATER, Operator::GREATER_EQUAL + true + else + false + end + end + + def upper_condition?(operator) + case operator + when Operator::LESS, Operator::LESS_EQUAL + true + else + false + end + end + + def create_all_match_data + data = ScanInfoData.new(0) + data.end = 0 + data.flags = ScanInfo::Flags::PUSH + data.op = Operator::CALL + data.logical_op = Operator::OR + data.args = [Context.instance["all_records"]] + data.search_indexes = [] + data + end + + def create_between_data(data, next_data) + between_data = ScanInfoData.new(data.start) + between_data.end = next_data.end + 1 + between_data.flags = data.flags + between_data.op = Operator::CALL + between_data.logical_op = data.logical_op + between_data.args = create_between_data_args(data, next_data) + between_data.search_indexes = data.search_indexes + between_data + end + + def create_between_data_args(data, next_data) + between = Context.instance["between"] + @expression.take_object(between) + column = data.args[0] + op, next_op = data.op, next_data.op + if lower_condition?(op) + min = data.args[1] + min_operator = op + max = next_data.args[1] + max_operator = next_op + else + min = next_data.args[1] + min_operator = next_op + max = data.args[1] + max_operator = op + end + if min_operator == Operator::GREATER + min_border = "exclude" + else + min_border = "include" + end + if max_operator == Operator::LESS + max_border = "exclude" + else + max_border = "include" + end + + [ + between, + column, + min, + @expression.allocate_constant(min_border), + max, + @expression.allocate_constant(max_border), + ] + end + + class BuildContext + attr_accessor :status + attr_reader :codes + attr_reader :n_codes + attr_reader :i + attr_writer :code_op + attr_accessor :data + def initialize(expression) + @expression = expression + @status = :start + @current_data = nil + @codes = @expression.codes + @n_codes = @codes.size + @i = 0 + @code_op = nil + @data = nil + end + + def have_next? + @i < @n_codes + end + + def next + @i += 1 + @code_op = nil + end + + def code + @codes[@i] + end + + def code_op + @code_op || code.op + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/scan_info_data.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/scan_info_data.rb new file mode 100644 index 00000000..342f7a7a --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/scan_info_data.rb @@ -0,0 +1,324 @@ +require "scan_info_search_index" + +module Groonga + class ScanInfoData + attr_accessor :start + attr_accessor :end + attr_accessor :op + attr_accessor :logical_op + attr_accessor :query + attr_accessor :args + attr_accessor :search_indexes + attr_accessor :flags + attr_accessor :max_interval + attr_accessor :similarity_threshold + attr_accessor :start_position + attr_accessor :weight + def initialize(start) + @start = start + @end = 0 + @op = Operator::NOP + @logical_op = Operator::OR + @query = nil + @args = [] + @search_indexes = [] + @flags = ScanInfo::Flags::PUSH + @max_interval = nil + @similarity_threshold = nil + @start_position = nil + @weight = 0 + end + + def match_resolve_index + if near_search? + match_near_resolve_index + elsif similar_search? + match_similar_resolve_index + else + match_generic_resolve_index + end + end + + def call_relational_resolve_indexes + procedure, *args = *@args + return unless procedure.selector? + + selector_op = procedure.selector_operator + args.each do |arg| + call_relational_resolve_index(arg, selector_op) + end + end + + private + def near_search? + (@op == Operator::NEAR or @op == Operator::NEAR2) and @args.size == 3 + end + + def match_near_resolve_index + arg = @args[0] + case arg + when Expression + match_resolve_index_expression(arg) + when Accessor + match_resolve_index_accessor(arg) + when Indexable + match_resolve_index_indexable(arg) + else + message = + "The first argument of NEAR/NEAR2 must be Expression, Accessor or Indexable: #{arg.class}" + raise ErrorMessage, message + end + + self.query = @args[1] + self.max_interval = @args[2].value + end + + def similar_search? + @op == Operator::SIMILAR and @args.size == 3 + end + + def match_similar_resolve_index + arg = @args[0] + case arg + when Expression + match_resolve_index_expression(arg) + when Accessor + match_resolve_index_accessor(arg) + when Indexable + match_resolve_index_indexable(arg) + else + message = + "The first argument of SIMILAR must be Expression, Accessor or Indexable: #{arg.class}" + raise ErrorMesesage, message + end + + self.query = @args[1] + self.similarity_threshold = @args[2].value + end + + def match_generic_resolve_index + @args.each do |arg| + case arg + when Expression + match_resolve_index_expression(arg) + when Accessor + match_resolve_index_accessor(arg) + when IndexColumn + match_resolve_index_index_column(arg) + when Indexable + match_resolve_index_indexable(arg) + when Procedure + break + else + self.query = arg + end + end + if @op == Operator::REGEXP and not index_searchable_regexp?(@query) + @search_indexes.clear + end + end + + def index_searchable_regexp?(pattern) + return false if pattern.nil? + + previous_char = nil + pattern.value.each_char do |char| + if previous_char == "\\" + case char + when "Z" + return false + when "b", "B" + return false + when "d", "D", "h", "H", "p", "s", "S", "w", "W" + return false + when "X" + return false + when "k", "g", "1", "2", "3", "4", "5", "6", "7", "8", "9" + return false + when "\\" + previous_char = nil + next + end + else + case char + when ".", "[", "]", "|", "?", "+", "*", "{", "}", "^", "$", "(", ")" + return false + end + end + previous_char = char + end + true + end + + def match_resolve_index_expression(expression) + codes = expression.codes + n_codes = codes.size + i = 0 + while i < n_codes + i = match_resolve_index_expression_codes(expression, codes, i, n_codes) + end + end + + def match_resolve_index_expression_codes(expression, codes, i, n_codes) + code = codes[i] + value = code.value + return i + 1 if value.nil? + + case value + when Accessor, Column + index_info, offset = + match_resolve_index_expression_find_index(expression, + codes, i, n_codes) + i += offset - 1 + if index_info + if value.is_a?(Accessor) + self.flags |= ScanInfo::Flags::ACCESSOR + end + weight, offset = codes[i].weight + i += offset + put_search_index(index_info.index, index_info.section_id, weight) + end + when Procedure + unless value.scorer? + message = "procedure must be scorer: #{scorer.name}>" + raise ErrorMessage, message + end + scorer = value + i += 1 + index_info, offset = + match_resolve_index_expression_find_index(expression, + codes, i, n_codes) + i += offset + if index_info + scorer_args_expr_offset = 0 + if codes[i].op != Operator::CALL + scorer_args_expr_offset = i + end + while i < n_codes and codes[i].op != Operator::CALL + i += 1 + end + weight, offset = codes[i].weight + i += offset + put_search_index(index_info.index, + index_info.section_id, + weight, + scorer, + expression, + scorer_args_expr_offset) + end + when Table + raise ErrorMessage, "invalid match target: <#{value.name}>" + end + i + 1 + end + + def match_resolve_index_expression_find_index(expression, codes, i, n_codes) + code = codes[i] + value = code.value + index_info = nil + offset = 1 + case value + when Accessor + accessor = value + index_info = accessor.find_index(@op) + if index_info + if accessor.have_next? and index_info.index != accessor.object + index_info = IndexInfo.new(accessor, index_info.section_id) + end + end + when FixedSizeColumn, VariableSizeColumn + index_info = value.find_index(@op) + when IndexColumn + index = value + section_id = 0 + rest_n_codes = n_codes - i + if rest_n_codes >= 2 and + codes[i + 1].value.is_a?(Bulk) and + (codes[i + 1].value.domain == ID::UINT32 or + codes[i + 1].value.domain == ID::INT32) and + codes[i + 2].op == Operator::GET_MEMBER + section_id = codes[i + 1].value.value + 1 + offset += 2 + end + index_info = IndexInfo.new(index, section_id) + end + + [index_info, offset] + end + + def match_resolve_index_expression_accessor(expr_code) + accessor = expr_code.value + self.flags |= ScanInfo::Flags::ACCESSOR + index_info = accessor.find_index(op) + return if index_info.nil? + + section_id = index_info.section_id + weight = expr_code.weight + if accessor.next + put_search_index(accessor, section_id, weight) + else + put_search_index(index_info.index, section_id, weight) + end + end + + def match_resolve_index_expression_data_column(expr_code) + column = expr_code.value + index_info = column.find_index(op) + return if index_info.nil? + put_search_index(index_info.index, index_info.section_id, expr_code.weight) + end + + def match_resolve_index_index_column(index) + put_search_index(index, 0, 1) + end + + def match_resolve_index_indexable(indexable) + index_info = indexable.find_index(op) + return if index_info.nil? + put_search_index(index_info.index, index_info.section_id, 1) + end + + def match_resolve_index_accessor(accessor) + self.flags |= ScanInfo::Flags::ACCESSOR + index_info = accessor.find_index(op) + return if index_info.nil? + if accessor.next + put_search_index(accessor, index_info.section_id, 1) + else + put_search_index(index_info.index, index_info.section_id, 1) + end + end + + def call_relational_resolve_index(object, selector_op) + case object + when Accessor + call_relational_resolve_index_accessor(object, selector_op) + when Bulk + self.query = object + when Indexable + call_relational_resolve_index_indexable(object, selector_op) + end + end + + def call_relational_resolve_index_indexable(indexable, selector_op) + index_info = indexable.find_index(selector_op) + return if index_info.nil? + put_search_index(index_info.index, index_info.section_id, 1) + end + + def call_relational_resolve_index_accessor(accessor, selector_op) + self.flags |= ScanInfo::Flags::ACCESSOR + index_info = accessor.find_index(selector_op) + return if index_info.nil? + put_search_index(index_info.index, index_info.section_id, 1) + end + + def put_search_index(index, section_id, weight, *args) + search_index = ScanInfoSearchIndex.new(index, + section_id, + weight + @weight, + *args) + @search_indexes << search_index + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/scan_info_data_size_estimator.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/scan_info_data_size_estimator.rb new file mode 100644 index 00000000..5d3dc4e0 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/scan_info_data_size_estimator.rb @@ -0,0 +1,185 @@ +module Groonga + class ScanInfoDataSizeEstimator + def initialize(data, table) + @data = data + @table = table + @table_size = @table.size + end + + def estimate + search_index = @data.search_indexes.first + return @table_size if search_index.nil? + + index_column = resolve_index_column(search_index.index_column) + return @table_size if index_column.nil? + + size = nil + case @data.op + when Operator::MATCH, + Operator::FUZZY + size = estimate_match(index_column) + when Operator::REGEXP + size = estimate_regexp(index_column) + when Operator::EQUAL + size = estimate_equal(index_column) + when Operator::LESS, + Operator::LESS_EQUAL, + Operator::GREATER, + Operator::GREATER_EQUAL + size = estimate_range(index_column) + when Operator::PREFIX + size = estimate_prefix(index_column) + when Operator::CALL + size = estimate_call(index_column) + end + size || @table_size + end + + private + def resolve_index_column(index_column) + while index_column.is_a?(Accessor) + index_info = index_column.find_index(@data.op) + return nil if index_info.nil? + break if index_info.index == index_column + index_column = index_info.index + end + + index_column + end + + def sampling_cursor_limit(n_terms) + limit = n_terms * 0.01 + if limit < 10 + 10 + elsif limit > 1000 + 1000 + else + limit.to_i + end + end + + def estimate_match(index_column) + index_column.estimate_size(:query => @data.query.value) + end + + def estimate_regexp(index_column) + index_column.estimate_size(:query => @data.query.value, + :mode => @data.op) + end + + def estimate_equal(index_column) + query = @data.query + if index_column.is_a?(Accessor) + table = index_column.object + if index_column.name == "_id" + if table.id?(query.value) + 1 + else + 0 + end + else + if table[query.value] + 1 + else + 0 + end + end + else + lexicon = index_column.lexicon + if query.domain == lexicon.id + term_id = query.value + else + term_id = lexicon[query] + end + return 0 if term_id.nil? + + index_column.estimate_size(:term_id => term_id) + end + end + + def estimate_range(index_column) + if index_column.is_a?(Table) + is_table_search = true + lexicon = index_column + elsif index_column.is_a?(Groonga::Accessor) + is_table_search = true + lexicon = index_column.object + else + is_table_search = false + lexicon = index_column.lexicon + end + n_terms = lexicon.size + return 0 if n_terms.zero? + + value = @data.query.value + options = { + :limit => sampling_cursor_limit(n_terms), + } + case @data.op + when Operator::LESS + options[:max] = value + options[:flags] = TableCursorFlags::LT + when Operator::LESS_EQUAL + options[:max] = value + options[:flags] = TableCursorFlags::LE + when Operator::GREATER + options[:min] = value + options[:flags] = TableCursorFlags::GT + when Operator::GREATER_EQUAL + options[:min] = value + options[:flags] = TableCursorFlags::GE + end + TableCursor.open(lexicon, options) do |cursor| + if is_table_search + size = 1 + else + size = index_column.estimate_size(:lexicon_cursor => cursor) + end + size += 1 if cursor.next != ID::NIL + size + end + end + + def estimate_prefix(index_column) + is_table_search = + (index_column.is_a?(Accessor) and + index_column.name == "_key") + if is_table_search + lexicon = index_column.object + else + lexicon = index_column.lexicon + end + n_terms = lexicon.size + return 0 if n_terms.zero? + + value = @data.query.value + options = { + :min => value, + :limit => sampling_cursor_limit(n_terms), + :flags => TableCursorFlags::PREFIX, + } + TableCursor.open(lexicon, options) do |cursor| + if is_table_search + size = 1 + else + size = index_column.estimate_size(:lexicon_cursor => cursor) + end + size += 1 if cursor.next != ID::NIL + size + end + end + + def estimate_call(index_column) + procedure = @data.args[0] + arguments = @data.args[1..-1].collect do |arg| + if arg.is_a?(::Groonga::Object) + ExpressionTree::Variable.new(arg) + else + ExpressionTree::Constant.new(arg) + end + end + node = ExpressionTree::FunctionCall.new(procedure, arguments) + node.estimate_size(@table) + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/scan_info_search_index.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/scan_info_search_index.rb new file mode 100644 index 00000000..a2818160 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/scan_info_search_index.rb @@ -0,0 +1,9 @@ +module Groonga + class ScanInfoSearchIndex < Struct.new(:index_column, + :section_id, + :weight, + :scorer, + :scorer_args_expr, + :scorer_args_expr_offset) + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/sources.am b/storage/mroonga/vendor/groonga/lib/mrb/scripts/sources.am new file mode 100644 index 00000000..9a9e2bae --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/sources.am @@ -0,0 +1,37 @@ +RUBY_SCRIPT_FILES = \ + accessor.rb \ + backtrace_entry.rb \ + command.rb \ + command_input.rb \ + command_line_parser.rb \ + context.rb \ + database.rb \ + error.rb \ + eval_context.rb \ + expression.rb \ + expression_rewriter.rb \ + expression_rewriters.rb \ + expression_size_estimator.rb \ + expression_tree.rb \ + expression_tree_builder.rb \ + fixed_size_column.rb \ + id.rb \ + index_column.rb \ + index_cursor.rb \ + index_info.rb \ + logger.rb \ + object.rb \ + operator.rb \ + plugin_loader.rb \ + query_logger.rb \ + record.rb \ + require.rb \ + scan_info.rb \ + scan_info_builder.rb \ + scan_info_data.rb \ + scan_info_data_size_estimator.rb \ + scan_info_search_index.rb \ + table.rb \ + table_cursor.rb \ + variable_size_column.rb \ + writer.rb diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/table.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/table.rb new file mode 100644 index 00000000..75c91894 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/table.rb @@ -0,0 +1,144 @@ +module Groonga + class Table + include Enumerable + include Indexable + + def columns + context = Context.instance + column_ids.collect do |id| + context[id] + end + end + + def each + flags = + TableCursorFlags::ASCENDING | + TableCursorFlags::BY_ID + TableCursor.open(self, :flags => flags) do |cursor| + cursor.each do |id| + yield(id) + end + end + end + + def sort(keys, options={}) + offset = options[:offset] || 0 + limit = options[:limit] || -1 + ensure_sort_keys(keys) do |sort_keys| + sorted = Array.create("", self) + begin + sort_raw(sort_keys, offset, limit, sorted) + rescue Exception + sorted.close + raise + end + sorted + end + end + + def group(keys, result) + ensure_sort_keys(keys) do |sort_keys| + group_raw(sort_keys, result) + end + end + + def apply_window_function(output_column, + window_function_call, + options={}) + ensure_sort_keys_accept_nil(options[:sort_keys]) do |sort_keys| + ensure_sort_keys_accept_nil(options[:group_keys]) do |group_keys| + window_definition = WindowDefinition.new + begin + window_definition.sort_keys = sort_keys + window_definition.group_keys = group_keys + apply_window_function_raw(output_column, + window_definition, + window_function_call) + ensure + window_definition.close + end + end + end + end + + private + def ensure_sort_keys_accept_nil(keys, &block) + return yield(nil) if keys.nil? + + ensure_sort_keys(keys, &block) + end + + def ensure_sort_keys(keys) + if keys.is_a?(::Array) and keys.all? {|key| key.is_a?(TableSortKey)} + return yield(keys) + end + + converted_keys = [] + + begin + keys = [keys] unless keys.is_a?(::Array) + sort_keys = keys.collect do |key| + ensure_sort_key(key, converted_keys) + end + yield(sort_keys) + ensure + converted_keys.each do |converted_key| + converted_key.close + end + end + end + + def ensure_sort_key(key, converted_keys) + return key if key.is_a?(TableSortKey) + + sort_key = TableSortKey.new + converted_keys << sort_key + + key_name = nil + order = :ascending + offset = 0 + if key.is_a?(::Hash) + key_name = key[:key] + order = key[:order] || order + offset = key[:offset] || offset + else + key_name = key + end + + case key_name + when String + # Do nothing + when Symbol + key_name = key_name.to_s + else + message = "sort key name must be String or Symbol: " + + "#{key_name.inspect}: #{key.inspect}" + raise ArgumentError, message + end + + if key_name.start_with?("-") + key_name[0] = "" + order = :descending + elsif key_name.start_with?("+") + key_name[0] = "" + end + + key = find_column(key_name) + if key.nil? + table_name = name || "(temporary)" + message = "unknown key: #{key_name.inspect}: " + message << "#{table_name}(#{size})" + raise ArgumentError, message + end + + sort_key.key = key + if order == :ascending + sort_key.flags = Groonga::TableSortFlags::ASCENDING + else + sort_key.flags = Groonga::TableSortFlags::DESCENDING + end + sort_key.offset = offset + sort_key + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/table_cursor.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/table_cursor.rb new file mode 100644 index 00000000..45949b71 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/table_cursor.rb @@ -0,0 +1,28 @@ +module Groonga + class TableCursor + include Enumerable + + class << self + def open(*arguments) + cursor = open_raw(*arguments) + if block_given? + begin + yield(cursor) + ensure + cursor.close + end + else + cursor + end + end + end + + def each + loop do + id = self.next + return if id == Groonga::ID::NIL + yield(id) + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/variable_size_column.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/variable_size_column.rb new file mode 100644 index 00000000..3d75502f --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/variable_size_column.rb @@ -0,0 +1,5 @@ +module Groonga + class VariableSizeColumn + include Indexable + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/scripts/writer.rb b/storage/mroonga/vendor/groonga/lib/mrb/scripts/writer.rb new file mode 100644 index 00000000..de2bc261 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/scripts/writer.rb @@ -0,0 +1,21 @@ +module Groonga + class Writer + def array(name, n_elements) + open_array(name, n_elements) + begin + yield + ensure + close_array + end + end + + def map(name, n_elements) + open_map(name, n_elements) + begin + yield + ensure + close_map + end + end + end +end diff --git a/storage/mroonga/vendor/groonga/lib/mrb/sources.am b/storage/mroonga/vendor/groonga/lib/mrb/sources.am new file mode 100644 index 00000000..9db16737 --- /dev/null +++ b/storage/mroonga/vendor/groonga/lib/mrb/sources.am @@ -0,0 +1,93 @@ +libgrnmrb_la_SOURCES = \ + mrb_accessor.c \ + mrb_accessor.h \ + mrb_array.c \ + mrb_array.h \ + mrb_bulk.c \ + mrb_bulk.h \ + mrb_cache.c \ + mrb_cache.h \ + mrb_column.c \ + mrb_column.h \ + mrb_command.c \ + mrb_command.h \ + mrb_command_input.c \ + mrb_command_input.h \ + mrb_command_version.c \ + mrb_command_version.h \ + mrb_config.c \ + mrb_config.h \ + mrb_content_type.c \ + mrb_content_type.h \ + mrb_converter.c \ + mrb_converter.h \ + mrb_ctx.c \ + mrb_ctx.h \ + mrb_database.c \ + mrb_database.h \ + mrb_double_array_trie.c \ + mrb_double_array_trie.h \ + mrb_error.c \ + mrb_error.h \ + mrb_eval_context.c \ + mrb_eval_context.h \ + mrb_expr.c \ + mrb_expr.h \ + mrb_fixed_size_column.c \ + mrb_fixed_size_column.h \ + mrb_hash_table.c \ + mrb_hash_table.h \ + mrb_id.c \ + mrb_id.h \ + mrb_indexable.c \ + mrb_indexable.h \ + mrb_index_column.c \ + mrb_index_column.h \ + mrb_index_cursor.c \ + mrb_index_cursor.h \ + mrb_logger.c \ + mrb_logger.h \ + mrb_object.c \ + mrb_object.h \ + mrb_object_flags.c \ + mrb_object_flags.h \ + mrb_operator.c \ + mrb_operator.h \ + mrb_options.c \ + mrb_options.h \ + mrb_patricia_trie.c \ + mrb_patricia_trie.h \ + mrb_pointer.c \ + mrb_pointer.h \ + mrb_procedure.c \ + mrb_procedure.h \ + mrb_query_logger.c \ + mrb_query_logger.h \ + mrb_record.c \ + mrb_record.h \ + mrb_table.c \ + mrb_table.h \ + mrb_table_cursor.c \ + mrb_table_cursor.h \ + mrb_table_cursor_flags.c \ + mrb_table_cursor_flags.h \ + mrb_table_group_flags.c \ + mrb_table_group_flags.h \ + mrb_table_group_result.c \ + mrb_table_group_result.h \ + mrb_table_sort_flags.c \ + mrb_table_sort_flags.h \ + mrb_table_sort_key.c \ + mrb_table_sort_key.h \ + mrb_thread.c \ + mrb_thread.h \ + mrb_type.c \ + mrb_type.h \ + mrb_variable_size_column.c \ + mrb_variable_size_column.h \ + mrb_void.c \ + mrb_void.h \ + mrb_window_definition.c \ + mrb_window_definition.h \ + mrb_writer.c \ + mrb_writer.h |