mrb_value
grn_mrb_load(grn_ctx *ctx, const char *path)
{
grn_mrb_data *data = &(ctx->impl->mrb);
mrb_state *mrb = data->state;
char expanded_path[PATH_MAX];
FILE *file;
mrb_value result;
struct mrb_parser_state *parser;
if (!mrb) {
return mrb_nil_value();
}
if (!grn_mrb_expand_script_path(ctx, path, expanded_path, PATH_MAX)) {
return mrb_nil_value();
}
file = grn_fopen(expanded_path, "r");
if (!file) {
mrb_value exception;
SERR("fopen: failed to open mruby script file: <%s>",
expanded_path);
exception = mrb_exc_new(mrb, E_LOAD_ERROR,
ctx->errbuf, strlen(ctx->errbuf));
mrb->exc = mrb_obj_ptr(exception);
return mrb_nil_value();
}
{
char current_base_directory[PATH_MAX];
char *last_directory;
grn_strcpy(current_base_directory, PATH_MAX, data->base_directory);
grn_strcpy(data->base_directory, PATH_MAX, expanded_path);
last_directory = strrchr(data->base_directory, '/');
if (last_directory) {
last_directory[0] = '\0';
}
parser = mrb_parser_new(mrb);
mrb_parser_set_filename(parser, expanded_path);
parser->s = parser->send = NULL;
parser->f = file;
mrb_parser_parse(parser, NULL);
fclose(file);
{
struct RProc *proc;
proc = mrb_generate_code(mrb, parser);
result = mrb_toplevel_run(mrb, proc);
}
mrb_parser_free(parser);
grn_strcpy(data->base_directory, PATH_MAX, current_base_directory);
}
return result;
}
void
grn_ctx_impl_set_current_error_message(grn_ctx *ctx)
{
if (!ctx->impl) {
return;
}
grn_ctx_impl_clear_n_same_error_messagges(ctx);
grn_strcpy(ctx->impl->previous_errbuf, GRN_CTX_MSGSIZE, ctx->errbuf);
}
static grn_bool
grn_mrb_expand_script_path(grn_ctx *ctx, const char *path,
char *expanded_path, size_t expanded_path_size)
{
const char *ruby_scripts_dir;
char dir_last_char;
int path_length, max_path_length;
if (grn_mrb_is_absolute_path(path)) {
expanded_path[0] = '\0';
} else if (path[0] == '.' && path[1] == '/') {
grn_strcpy(expanded_path, expanded_path_size, ctx->impl->mrb.base_directory);
grn_strcat(expanded_path, expanded_path_size, "/");
} else {
ruby_scripts_dir = grn_mrb_get_system_ruby_scripts_dir(ctx);
grn_strcpy(expanded_path, expanded_path_size, ruby_scripts_dir);
dir_last_char = ruby_scripts_dir[strlen(expanded_path) - 1];
if (dir_last_char != '/') {
grn_strcat(expanded_path, expanded_path_size, "/");
}
}
path_length = strlen(path);
max_path_length = PATH_MAX - strlen(expanded_path) - 1;
if (path_length > max_path_length) {
ERR(GRN_INVALID_ARGUMENT,
"script path is too long: %d (max: %d) <%s%s>",
path_length, max_path_length,
expanded_path, path);
return GRN_FALSE;
}
grn_strcat(expanded_path, expanded_path_size, path);
return GRN_TRUE;
}
const char *
get_system_synonyms_file(void)
{
if (win32_synonyms_file[0] == '\0') {
const char *base_dir;
const char *relative_path = GRN_QUERY_EXPANDER_TSV_RELATIVE_SYNONYMS_FILE;
size_t base_dir_length;
base_dir = grn_plugin_windows_base_dir();
base_dir_length = strlen(base_dir);
grn_strcpy(win32_synonyms_file, MAX_PATH, base_dir);
grn_strcat(win32_synonyms_file, MAX_PATH, "/");
grn_strcat(win32_synonyms_file, MAX_PATH, relative_path);
}
return win32_synonyms_file;
}
static const char *
grn_mrb_get_default_system_ruby_scripts_dir(void)
{
if (!windows_ruby_scripts_dir) {
const char *base_dir;
const char *relative_path = GRN_RELATIVE_RUBY_SCRIPTS_DIR;
size_t base_dir_length;
base_dir = grn_windows_base_dir();
base_dir_length = strlen(base_dir);
grn_strcpy(windows_ruby_scripts_dir_buffer, PATH_MAX, base_dir);
grn_strcat(windows_ruby_scripts_dir_buffer, PATH_MAX, "/");
grn_strcat(windows_ruby_scripts_dir_buffer, PATH_MAX, relative_path);
windows_ruby_scripts_dir = windows_ruby_scripts_dir_buffer;
}
return windows_ruby_scripts_dir;
}
mrb_value
grn_mrb_value_from_bulk(mrb_state *mrb, grn_obj *bulk)
{
mrb_value mrb_value_;
grn_ctx *ctx = (grn_ctx *)mrb->ud;
switch (bulk->header.domain) {
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_raisef(mrb, E_RANGE_ERROR,
"can't handle large number: <%S>: max: <%S>",
mrb_fixnum_value(value), /* TODO: This will cause overflow */
mrb_fixnum_value(MRB_INT_MAX));
}
mrb_value_ = mrb_fixnum_value(value);
}
break;
case GRN_DB_TIME :
{
int64_t value;
int32_t sec;
int32_t usec;
value = GRN_TIME_VALUE(bulk);
GRN_TIME_UNPACK(value, sec, usec);
mrb_value_ = mrb_funcall(mrb,
mrb_obj_value(ctx->impl->mrb.builtin.time_class),
"at",
2,
mrb_fixnum_value(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_;
}
static void
grn_loader_save_error(grn_ctx *ctx, grn_loader *loader)
{
loader->rc = ctx->rc;
grn_strcpy(loader->errbuf, GRN_CTX_MSGSIZE, ctx->errbuf);
}
static void
command_schema_column_command_collect_arguments(grn_ctx *ctx,
grn_obj *table,
grn_obj *column,
grn_obj *arguments)
{
#define ADD(name_, value_) \
grn_vector_add_element(ctx, arguments, \
name_, strlen(name_), \
0, GRN_DB_TEXT); \
grn_vector_add_element(ctx, arguments, \
value_, strlen(value_), \
0, GRN_DB_TEXT)
#define ADD_OBJECT_NAME(name_, object_) do { \
char object_name[GRN_TABLE_MAX_KEY_SIZE]; \
unsigned int object_name_size; \
object_name_size = grn_obj_name(ctx, object_, \
object_name, \
GRN_TABLE_MAX_KEY_SIZE); \
object_name[object_name_size] = '\0'; \
ADD(name_, object_name); \
} while (GRN_FALSE)
ADD_OBJECT_NAME("table", table);
{
char column_name[GRN_TABLE_MAX_KEY_SIZE];
unsigned int column_name_size;
column_name_size = grn_column_name(ctx, column,
column_name, GRN_TABLE_MAX_KEY_SIZE);
column_name[column_name_size] = '\0';
ADD("name", column_name);
}
{
grn_obj flags;
GRN_TEXT_INIT(&flags, 0);
grn_dump_column_create_flags(ctx,
column->header.flags & ~GRN_OBJ_PERSISTENT,
&flags);
GRN_TEXT_PUTC(ctx, &flags, '\0');
ADD("flags", GRN_TEXT_VALUE(&flags));
GRN_OBJ_FIN(ctx, &flags);
}
{
grn_obj *value_type;
value_type = grn_ctx_at(ctx, grn_obj_get_range(ctx, column));
ADD_OBJECT_NAME("type", value_type);
}
if (column->header.type == GRN_COLUMN_INDEX) {
grn_obj source_ids;
unsigned int n_ids;
GRN_RECORD_INIT(&source_ids, GRN_OBJ_VECTOR, GRN_ID_NIL);
grn_obj_get_info(ctx, column, GRN_INFO_SOURCE, &source_ids);
n_ids = GRN_BULK_VSIZE(&source_ids) / sizeof(grn_id);
if (n_ids > 0) {
grn_obj sources;
unsigned int i;
GRN_TEXT_INIT(&sources, 0);
for (i = 0; i < n_ids; i++) {
grn_id source_id;
grn_obj *source;
char name[GRN_TABLE_MAX_KEY_SIZE];
unsigned int name_size;
source_id = GRN_RECORD_VALUE_AT(&source_ids, i);
source = grn_ctx_at(ctx, source_id);
if (grn_obj_is_table(ctx, source)) {
grn_strcpy(name, GRN_TABLE_MAX_KEY_SIZE, "_key");
name_size = strlen(name);
} else {
name_size = grn_column_name(ctx, source, name, GRN_TABLE_MAX_KEY_SIZE);
}
if (i > 0) {
GRN_TEXT_PUTC(ctx, &sources, ',');
}
GRN_TEXT_PUT(ctx, &sources, name, name_size);
}
GRN_TEXT_PUTC(ctx, &sources, '\0');
ADD("sources", GRN_TEXT_VALUE(&sources));
GRN_OBJ_FIN(ctx, &sources);
}
GRN_OBJ_FIN(ctx, &source_ids);
}
#undef ADD_OBJECT_NAME
#undef ADD
}
