rroonga 5.1.1-x64-mingw32 → 6.0.0-x64-mingw32

data/ext/groonga/rb-grn-object.c

@@ -93,7 +93,7 @@ rb_grn_object_unbind (RbGrnObject *rb_grn_object)
 {
     debug("unbind: %p:%p:%p %s(%#x)\n",
           rb_grn_object->context, rb_grn_object->object, rb_grn_object,
-          rb_grn_inspect_type(rb_grn_object->object->header.type),
+          grn_obj_type_to_string(rb_grn_object->object->header.type),
           rb_grn_object->object->header.type);
 
     rb_grn_object->rb_grn_context = NULL;
@@ -116,7 +116,7 @@ rb_grn_object_run_finalizer (grn_ctx *context, grn_obj *grn_object,
           context, grn_object, rb_grn_object,
           rb_grn_object->context, rb_grn_object->object,
           rb_grn_object->rb_grn_context,
-          rb_grn_inspect_type(grn_object->header.type),
+          grn_obj_type_to_string(grn_object->header.type),
           grn_object->header.type);
 
     rb_grn_context = rb_grn_object->rb_grn_context;
@@ -173,7 +173,7 @@ rb_grn_object_run_finalizer (grn_ctx *context, grn_obj *grn_object,
     default:
         rb_raise(rb_eTypeError,
                  "unsupported Groonga object type for finalizer: %s(%#x)",
-                 rb_grn_inspect_type(grn_object->header.type),
+                 grn_obj_type_to_string(grn_object->header.type),
                  grn_object->header.type);
         break;
     }
@@ -217,7 +217,7 @@ rb_grn_object_free (RbGrnObject *rb_grn_object)
             user_data = grn_obj_user_data(context, grn_object);
         }
         debug("type: %s(%#x); need_close: %d; user_data: %p; ptr: %p\n",
-              rb_grn_inspect_type(grn_object->header.type),
+              grn_obj_type_to_string(grn_object->header.type),
               grn_object->header.type,
               rb_grn_object->need_close,
               user_data,
@@ -362,7 +362,7 @@ rb_grn_object_bind_common (VALUE klass, VALUE self, VALUE rb_context,
 
     debug("bind: %p:%p:%p %s(%#x)\n",
           context, object, rb_grn_object,
-          rb_grn_inspect_type(object->header.type),
+          grn_obj_type_to_string(object->header.type),
           object->header.type);
 
     Data_Get_Struct(rb_context, RbGrnContext, rb_grn_context);
@@ -378,7 +378,7 @@ rb_grn_object_bind_common (VALUE klass, VALUE self, VALUE rb_context,
     if (user_data) {
         debug("set-finalizer: %p:%p:%p %s(%#x)\n",
               context, object, rb_grn_object,
-              rb_grn_inspect_type(object->header.type),
+              grn_obj_type_to_string(object->header.type),
               object->header.type);
         user_data->ptr = rb_grn_object;
         grn_obj_set_finalizer(context, object, rb_grn_object_finalizer);
@@ -386,7 +386,7 @@ rb_grn_object_bind_common (VALUE klass, VALUE self, VALUE rb_context,
     } else if (object->header.type == GRN_ACCESSOR) {
         debug("set-finalizer(implicit): %p:%p:%p %s(%#x)\n",
               context, object, rb_grn_object,
-              rb_grn_inspect_type(object->header.type),
+              grn_obj_type_to_string(object->header.type),
               object->header.type);
         rb_grn_object->have_finalizer = GRN_TRUE;
     }
@@ -500,7 +500,7 @@ rb_grn_object_assign (VALUE klass, VALUE self, VALUE rb_context,
     } else {
         rb_raise(rb_eTypeError,
                  "unsupported Groonga object type for assignment: %s(%#x)",
-                 rb_grn_inspect_type(object->header.type),
+                 grn_obj_type_to_string(object->header.type),
                  object->header.type);
     }
 
@@ -508,7 +508,7 @@ rb_grn_object_assign (VALUE klass, VALUE self, VALUE rb_context,
 
     debug("assign: %p:%p:%p %s(%#x)\n",
           context, object, rb_grn_object,
-          rb_grn_inspect_type(object->header.type), object->header.type);
+          grn_obj_type_to_string(object->header.type), object->header.type);
 }
 
 void
@@ -545,7 +545,7 @@ rb_grn_named_object_set_name (RbGrnNamedObject *rb_grn_named_object,
               RB_GRN_OBJECT(rb_grn_named_object)->context,
               RB_GRN_OBJECT(rb_grn_named_object)->object,
               rb_grn_named_object,
-              rb_grn_inspect_type(RB_GRN_OBJECT(rb_grn_named_object)->header.type),
+              grn_obj_type_to_string(RB_GRN_OBJECT(rb_grn_named_object)->header.type),
               RB_GRN_OBJECT(rb_grn_named_object)->object->header.type,
               name_size, name);
     }

data/ext/groonga/rb-grn-operator.c

@@ -1,6 +1,7 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
   Copyright (C) 2009-2015  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -224,6 +225,8 @@ rb_grn_operator_from_ruby_object (VALUE rb_operator)
         operator = GRN_OP_JSON_PUT;
     } else if (rb_grn_equal_option(rb_operator, "regexp")) {
         operator = GRN_OP_REGEXP;
+    } else if (rb_grn_equal_option(rb_operator, "fuzzy")) {
+        operator = GRN_OP_FUZZY;
     } else {
         rb_raise(rb_eArgError,
                  "operator should be one of "
@@ -635,6 +638,10 @@ rb_grn_init_operator (VALUE mGrn)
                     rb_funcall(rb_cGrnRegexpOperator, rb_intern("new"), 2,
                                rb_str_new_cstr("regexp"),
                                UINT2NUM(GRN_OP_REGEXP)));
+    rb_define_const(rb_cGrnOperator, "FUZZY",
+                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
+                               rb_str_new_cstr("fuzzy"),
+                               UINT2NUM(GRN_OP_FUZZY)));
 
 
 /*

data/ext/groonga/rb-grn-plugin.c

@@ -1,6 +1,7 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
   Copyright (C) 2011-2015  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -205,6 +206,42 @@ rb_grn_plugin_s_ruby_suffix (VALUE klass)
     return rb_str_new_cstr(grn_plugin_get_ruby_suffix());
 }
 
+/*
+ * Returns the names of loaded plugins.
+ *
+ * @overload names(options={})
+ *   @return [Array<String>]
+ *   @param options [::Hash] The name and value pairs.
+ *   @option options :context (Groonga::Context.default)
+ *     The context which is bound to database.
+ *
+ * @since 6.0.0
+ */
+static VALUE
+rb_grn_plugin_s_names (int argc, VALUE *argv, VALUE klass)
+{
+    VALUE rb_options, rb_context, rb_names;
+    grn_ctx *context;
+    grn_obj names;
+
+    rb_scan_args(argc, argv, "01", &rb_options);
+    rb_grn_scan_options(rb_options,
+                        "context", &rb_context,
+                        NULL);
+    if (NIL_P(rb_context)) {
+        rb_context = rb_grn_context_get_default();
+    }
+    context = RVAL2GRNCONTEXT(rb_context);
+
+    GRN_TEXT_INIT(&names, GRN_OBJ_VECTOR);
+    grn_plugin_get_names(context, &names);
+    rb_names = GRNVECTOR2RVAL(context, &names);
+    GRN_OBJ_FIN(context, &names);
+
+    rb_grn_context_check(context, rb_ary_new_from_values(argc, argv));
+    return rb_names;
+}
+
 void
 rb_grn_init_plugin (VALUE mGrn)
 {
@@ -221,4 +258,6 @@ rb_grn_init_plugin (VALUE mGrn)
                                rb_grn_plugin_s_suffix, 0);
     rb_define_singleton_method(cGrnPlugin, "ruby_suffix",
                                rb_grn_plugin_s_ruby_suffix, 0);
+    rb_define_singleton_method(cGrnPlugin, "names",
+                               rb_grn_plugin_s_names, -1);
 }

data/ext/groonga/rb-grn-utils.c

@@ -30,67 +30,6 @@ rb_grn_inspect (VALUE object)
     return StringValueCStr(inspected);
 }
 
-const char *
-rb_grn_inspect_type (unsigned char type)
-{
-    switch (type) {
-    case GRN_VOID:
-        return "void";
-    case GRN_BULK:
-        return "bulk";
-    case GRN_PTR:
-        return "ptr";
-    case GRN_UVECTOR:
-        return "uvector";
-    case GRN_PVECTOR:
-        return "pvector";
-    case GRN_MSG:
-        return "msg";
-    case GRN_QUERY:
-        return "query";
-    case GRN_ACCESSOR:
-        return "accessor";
-    case GRN_SNIP:
-        return "snip";
-    case GRN_PATSNIP:
-        return "patsnip";
-    case GRN_CURSOR_TABLE_HASH_KEY:
-        return "cursor-table-hash-key";
-    case GRN_CURSOR_TABLE_PAT_KEY:
-        return "cursor-table-pat-key";
-    case GRN_CURSOR_TABLE_DAT_KEY:
-        return "cursor-table-dat-key";
-    case GRN_CURSOR_TABLE_NO_KEY:
-        return "cursor-table-no-key";
-    case GRN_CURSOR_COLUMN_INDEX:
-        return "cursor-column-index";
-    case GRN_TYPE:
-        return "type";
-    case GRN_PROC:
-        return "proc";
-    case GRN_EXPR:
-        return "expr";
-    case GRN_TABLE_HASH_KEY:
-        return "table-hash-key";
-    case GRN_TABLE_PAT_KEY:
-        return "table-pat-key";
-    case GRN_TABLE_DAT_KEY:
-        return "table-dat-key";
-    case GRN_TABLE_NO_KEY:
-        return "table-no-key";
-    case GRN_DB:
-        return "db";
-    case GRN_COLUMN_FIX_SIZE:
-        return "column-fix-size";
-    case GRN_COLUMN_VAR_SIZE:
-        return "column-var-size";
-    case GRN_COLUMN_INDEX:
-        return "column-index";
-    default:
-        return "unknown";
-    }
-}
-
 void
 rb_grn_scan_options (VALUE options, ...)
 {
@@ -903,7 +842,7 @@ rb_grn_uvector_to_ruby_object (grn_ctx *context, grn_obj *uvector,
     default:
         rb_raise(rb_eTypeError,
                  "unknown range uvector can't be converted: %s(%#x): <%s>",
-                 rb_grn_inspect_type(range->header.type),
+                 grn_obj_type_to_string(range->header.type),
                  range->header.type,
                  rb_grn_inspect(related_object));
         break;
@@ -1023,7 +962,7 @@ rb_grn_uvector_from_ruby_object_body (VALUE user_data)
     default:
         rb_raise(rb_eTypeError,
                  "can't convert to unknown domain uvector: %s(%#x): <%s>",
-                 rb_grn_inspect_type(domain->header.type),
+                 grn_obj_type_to_string(domain->header.type),
                  domain->header.type,
                  rb_grn_inspect(data->related_object));
         break;
@@ -1108,7 +1047,7 @@ rb_grn_value_to_ruby_object (grn_ctx *context,
     default:
         rb_raise(rb_eGrnError,
                  "unsupported value type: %s(%#x): %s",
-                 rb_grn_inspect_type(value->header.type),
+                 grn_obj_type_to_string(value->header.type),
                  value->header.type,
                  rb_grn_inspect(related_object));
         break;
@@ -1284,6 +1223,7 @@ rb_grn_obj_to_ruby_object (VALUE klass, grn_ctx *context,
     /* case GRN_CURSOR_TABLE_PAT_KEY: */
     /* case GRN_CURSOR_TABLE_NO_KEY: */
     /* case GRN_CURSOR_COLUMN_INDEX: */
+    /* case GRN_CURSOR_CONFIG: */
     /* case GRN_TYPE: */
     /* case GRN_PROC: */
     /* case GRN_EXPR: */
@@ -1298,7 +1238,7 @@ rb_grn_obj_to_ruby_object (VALUE klass, grn_ctx *context,
     default:
         rb_raise(rb_eTypeError,
                  "unsupported groonga object: %s(%#x): <%s>",
-                 rb_grn_inspect_type(obj->header.type),
+                 grn_obj_type_to_string(obj->header.type),
                  obj->header.type,
                  rb_grn_inspect(related_object));
         break;

data/ext/groonga/rb-grn.h

@@ -21,10 +21,8 @@
 #define __RB_GRN_H__
 
 #include <ruby.h>
+#include <ruby/encoding.h>
 
-#ifdef HAVE_RUBY_ENCODING_H
-#  include <ruby/encoding.h>
-#endif
 #ifdef HAVE_RUBY_INTERN_H
 #  include <ruby/intern.h>
 #endif
@@ -99,9 +97,9 @@ RB_GRN_BEGIN_DECLS
 #  define debug(...)
 #endif
 
-#define RB_GRN_MAJOR_VERSION 5
-#define RB_GRN_MINOR_VERSION 1
-#define RB_GRN_MICRO_VERSION 1
+#define RB_GRN_MAJOR_VERSION 6
+#define RB_GRN_MINOR_VERSION 0
+#define RB_GRN_MICRO_VERSION 0
 
 #define RB_GRN_QUERY_DEFAULT_MAX_EXPRESSIONS 32
 
@@ -301,6 +299,7 @@ RB_GRN_VAR VALUE rb_cGrnRecordExpressionBuilder;
 RB_GRN_VAR VALUE rb_cGrnColumnExpressionBuilder;
 RB_GRN_VAR VALUE rb_cGrnPlugin;
 RB_GRN_VAR VALUE rb_cGrnNormalizer;
+RB_GRN_VAR VALUE rb_cGrnIndex;
 
 void           rb_grn_init_utils                    (VALUE mGrn);
 void           rb_grn_init_exception                (VALUE mGrn);
@@ -355,6 +354,7 @@ void           rb_grn_init_plugin                   (VALUE mGrn);
 void           rb_grn_init_normalizer               (VALUE mGrn);
 void           rb_grn_init_thread                   (VALUE mGrn);
 void           rb_grn_init_config                   (VALUE mGrn);
+void           rb_grn_init_index                    (VALUE mGrn);
 
 VALUE          rb_grn_rc_to_exception               (grn_rc rc);
 const char    *rb_grn_rc_to_message                 (grn_rc rc);
@@ -383,7 +383,6 @@ void           rb_grn_context_object_created        (VALUE rb_context,
                                                      VALUE rb_object);
 
 const char    *rb_grn_inspect                       (VALUE object);
-const char    *rb_grn_inspect_type                  (unsigned char type);
 void           rb_grn_scan_options                  (VALUE options, ...)
                                                      RB_GRN_GNUC_NULL_TERMINATED;
 grn_bool       rb_grn_equal_option                  (VALUE option,
@@ -634,6 +633,9 @@ VALUE          rb_grn_column_expression_builder_new (VALUE column,
 VALUE          rb_grn_column_expression_builder_build
                                                     (VALUE self);
 
+VALUE          rb_grn_index_new                     (VALUE rb_index_column,
+                                                     VALUE rb_section);
+
 
 #define RB_GRN_INTERN(c_string)       (rb_to_symbol(rb_str_new_cstr(c_string)))
 
@@ -740,11 +742,9 @@ VALUE          rb_grn_column_expression_builder_build
 grn_encoding   rb_grn_encoding_from_ruby_object     (VALUE object,
                                                      grn_ctx *context);
 VALUE          rb_grn_encoding_to_ruby_object       (grn_encoding encoding);
-#ifdef HAVE_RUBY_ENCODING_H
 rb_encoding   *rb_grn_encoding_to_ruby_encoding     (grn_encoding encoding);
 VALUE          rb_grn_encoding_to_ruby_encoding_object
                                                     (grn_encoding encoding);
-#endif
 
 grn_ctx       *rb_grn_context_from_ruby_object      (VALUE object);
 VALUE          rb_grn_context_to_ruby_object        (grn_ctx *context);

data/ext/groonga/rb-groonga.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2015  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2016  Kouhei Sutou <kou@clear-code.com>
   Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 
   This library is free software; you can redistribute it and/or
@@ -30,6 +30,34 @@ finish_groonga (VALUE data)
     debug("finish: done\n");
 }
 
+/*
+ * @overload error_message
+ *   @return [String, nil] The process global error message.
+ *
+ * @since 6.0.0
+ */
+static VALUE
+rb_grn_s_get_error_message (VALUE klass)
+{
+    const char *message;
+
+    message = grn_get_global_error_message();
+    if (message[0] == '\0') {
+        return Qnil;
+    } else {
+        grn_encoding encoding = grn_get_default_encoding();
+        return rb_enc_str_new_cstr(message,
+                                   rb_grn_encoding_to_ruby_encoding(encoding));
+    }
+}
+
+static void
+rb_grn_init_error_message (VALUE mGrn)
+{
+    rb_define_singleton_method(mGrn, "error_message",
+                               rb_grn_s_get_error_message, 0);
+}
+
 static void
 rb_grn_init_runtime_version (VALUE mGrn)
 {
@@ -180,6 +208,7 @@ Init_groonga (void)
 
     mGrn = rb_define_module("Groonga");
 
+    rb_grn_init_error_message(mGrn);
     rb_grn_init_exception(mGrn);
 
     rb_grn_rc_check(grn_init(), Qnil);
@@ -219,4 +248,5 @@ Init_groonga (void)
     rb_grn_init_normalizer(mGrn);
     rb_grn_init_thread(mGrn);
     rb_grn_init_config(mGrn);
+    rb_grn_init_index(mGrn);
 }

data/lib/groonga.rb

@@ -38,6 +38,7 @@ require "groonga/geo-point"
 require "groonga/record"
 require "groonga/expression-builder"
 require "groonga/posting"
+require "groonga/index"
 begin
   major, minor, _ = RUBY_VERSION.split(/\./)
   require "#{major}.#{minor}/groonga.so"

data/lib/groonga/column.rb

@@ -21,5 +21,18 @@ module Groonga
       measurer = StatisticMeasurer.new
       measurer.measure_disk_usage(path)
     end
+
+    # @param [Groonga::Operator] operator (Groonga::Operator::MATCH)
+    # @return [Array<Groonga::IndexColumn>] Indexes on `column` which can
+    #    execute `operator`.
+    # @since 1.0.9
+    #
+    # @deprecated since 6.0.0. Use {Groonga::Column#find_indexes} instead.
+    def indexes(operator=nil)
+      operator ||= Operator::MATCH
+      find_indexes(:operator => operator).collect do |index|
+        index.column
+      end
+    end
   end
 end

data/lib/groonga/dumper.rb

@@ -666,6 +666,7 @@ module Groonga
       @have_output = !@output.nil?
       @output ||= Dumper.default_output
       @error_output = @options[:error_output]
+      @max_records = @options[:max_records]
     end
 
     def dump
@@ -709,7 +710,8 @@ module Groonga
       when Groonga::Array, Groonga::Hash
         order_by = nil if order_by == :key
       end
-      @table.each(:order_by => order_by) do |record|
+      limit = @options[:max_records]
+      @table.each(:order_by => order_by, :limit => limit) do |record|
         write(",\n")
         values = columns.collect do |column|
           resolve_value(record, column, column[record.id])