rroonga 6.0.0-x86-mingw32 → 6.0.2-x86-mingw32

data/test/test-type.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2016  Kouhei Sutou <kou@clear-code.com>
 # Copyright (C) 2015  Masafumi Yokoyama <yokoyama@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -91,6 +91,106 @@ class TypeTest < Test::Unit::TestCase
     assert_false(Groonga["UInt32"].geo_point?)
   end
 
+  class TextFamilyTest < self
+    def test_short_text
+      assert do
+        Groonga["ShortText"].text_family?
+      end
+    end
+
+    def test_text
+      assert do
+        Groonga["Text"].text_family?
+      end
+    end
+
+    def test_long_text
+      assert do
+        Groonga["LongText"].text_family?
+      end
+    end
+
+    def test_under_short_text
+      assert do
+        not Groonga["Time"].text_family?
+      end
+    end
+
+    def test_over_long_text
+      assert do
+        not Groonga["TokyoGeoPoint"].text_family?
+      end
+    end
+  end
+
+  class NumberFamilyTest < self
+    def test_int8
+      assert do
+        Groonga["Int8"].number_family?
+      end
+    end
+
+    def test_uint8
+      assert do
+        Groonga["UInt8"].number_family?
+      end
+    end
+
+    def test_int16
+      assert do
+        Groonga["Int16"].number_family?
+      end
+    end
+
+    def test_uint16
+      assert do
+        Groonga["UInt16"].number_family?
+      end
+    end
+
+    def test_int32
+      assert do
+        Groonga["Int32"].number_family?
+      end
+    end
+
+    def test_uint32
+      assert do
+        Groonga["UInt32"].number_family?
+      end
+    end
+
+    def test_int64
+      assert do
+        Groonga["Int64"].number_family?
+      end
+    end
+
+    def test_uint64
+      assert do
+        Groonga["UInt64"].number_family?
+      end
+    end
+
+    def test_float
+      assert do
+        Groonga["Float"].number_family?
+      end
+    end
+
+    def test_under_int8
+      assert do
+        not Groonga["Bool"].number_family?
+      end
+    end
+
+    def test_over_float
+      assert do
+        not Groonga["Time"].number_family?
+      end
+    end
+  end
+
   def test_builtins
     assert_equal_type("Object", Groonga::Type::OBJECT) # FIXME!!!
     assert_equal_type("Bool", Groonga::Type::BOOLEAN)
@@ -125,7 +225,9 @@ class TypeTest < Test::Unit::TestCase
        "builtin - Time" => "Time")
   def test_builtin?(name)
     type = Groonga[name]
-    assert_predicate(type, :builtin?)
+    assert do
+      type.builtin?
+    end
   end
 
   private

data/vendor/local/etc/groonga/httpd/groonga-httpd.conf

@@ -1,9 +1,17 @@
 worker_processes 1;
+pid ${prefix}/var/run/groonga-httpd.pid;
 
 # Match this to the file owner of Groonga database files if groonga-httpd is
 # run as root.
 user groonga groonga;
 
+env GRN_IN_VALUES_TOO_MANY_INDEX_MATCH_RATIO;
+env GRN_BETWEEN_TOO_MANY_INDEX_MATCH_RATIO;
+env GRN_II_CURSOR_SET_MIN_ENABLE;
+env GRN_INDEX_CHUNK_SPLIT_ENABLE;
+env GRN_MECAB_CHUNKED_TOKENIZE_ENABLED;
+env GRN_MECAB_CHUNK_SIZE_THRESHOLD;
+
 events {
   worker_connections 1024;
 }

data/vendor/local/include/groonga/groonga/dump.h

@@ -23,7 +23,7 @@ extern "C" {
 #endif
 
 GRN_API grn_rc grn_dump_table_create_flags(grn_ctx *ctx,
-                                           grn_obj_flags flags,
+                                           grn_table_flags flags,
                                            grn_obj *buffer);
 GRN_API grn_rc grn_dump_column_create_flags(grn_ctx *ctx,
                                             grn_obj_flags flags,

data/vendor/local/include/groonga/groonga/expr.h

@@ -42,6 +42,7 @@ GRN_API grn_obj *grn_expr_get_var(grn_ctx *ctx, grn_obj *expr,
 GRN_API grn_obj *grn_expr_get_var_by_offset(grn_ctx *ctx, grn_obj *expr, unsigned int offset);
 GRN_API grn_rc grn_expr_clear_vars(grn_ctx *ctx, grn_obj *expr);
 
+GRN_API void grn_expr_take_obj(grn_ctx *ctx, grn_obj *expr, grn_obj *obj);
 
 GRN_API grn_obj *grn_expr_append_obj(grn_ctx *ctx, grn_obj *expr, grn_obj *obj,
                                      grn_operator op, int nargs);
@@ -52,8 +53,6 @@ GRN_API grn_obj *grn_expr_append_const_str(grn_ctx *ctx, grn_obj *expr,
                                            grn_operator op, int nargs);
 GRN_API grn_obj *grn_expr_append_const_int(grn_ctx *ctx, grn_obj *expr, int i,
                                            grn_operator op, int nargs);
-GRN_API grn_obj *grn_expr_append_const_ptr(grn_ctx *ctx, grn_obj *expr, grn_obj *ptr,
-                                           grn_operator op, int nargs);
 GRN_API grn_rc grn_expr_append_op(grn_ctx *ctx, grn_obj *expr, grn_operator op, int nargs);
 
 GRN_API grn_rc grn_expr_get_keywords(grn_ctx *ctx, grn_obj *expr, grn_obj *keywords);

data/vendor/local/include/groonga/groonga/groonga.h

@@ -36,7 +36,7 @@ extern "C" {
 #endif /* GRN_API */
 
 typedef unsigned int grn_id;
-typedef unsigned char grn_bool;
+typedef uint8_t grn_bool;
 
 #define GRN_ID_NIL                     (0x00)
 #define GRN_ID_MAX                     (0x3fffffff)
@@ -124,7 +124,8 @@ typedef enum {
   GRN_TOKEN_FILTER_ERROR = -73,
   GRN_COMMAND_ERROR = -74,
   GRN_PLUGIN_ERROR = -75,
-  GRN_SCORER_ERROR = -76
+  GRN_SCORER_ERROR = -76,
+  GRN_CANCEL = -77
 } grn_rc;
 
 GRN_API grn_rc grn_init(void);
@@ -290,7 +291,12 @@ GRN_API grn_encoding grn_encoding_parse(const char *name);
 
 /* obj */
 
-typedef unsigned short int grn_obj_flags;
+typedef uint16_t grn_obj_flags;
+typedef uint32_t grn_table_flags;
+
+/* flags for grn_obj_flags and grn_table_flags */
+
+#define GRN_OBJ_FLAGS_MASK             (0xffff)
 
 #define GRN_OBJ_TABLE_TYPE_MASK        (0x07)
 #define GRN_OBJ_TABLE_HASH_KEY         (0x00)
@@ -335,6 +341,8 @@ typedef unsigned short int grn_obj_flags;
 #define GRN_OBJ_UNIT_USERDEF_SECTION   (0x07<<8)
 #define GRN_OBJ_UNIT_USERDEF_POSITION  (0x08<<8)
 
+/* Don't use (0x01<<12) because it's used internally. */
+
 #define GRN_OBJ_NO_SUBREC              (0x00<<13)
 #define GRN_OBJ_WITH_SUBREC            (0x01<<13)
 
@@ -343,6 +351,10 @@ typedef unsigned short int grn_obj_flags;
 #define GRN_OBJ_TEMPORARY              (0x00<<15)
 #define GRN_OBJ_PERSISTENT             (0x01<<15)
 
+/* flags only for grn_table_flags */
+
+#define GRN_OBJ_KEY_LARGE              (0x01<<16)
+
 /* obj types */
 
 #define GRN_VOID                       (0x00)
@@ -531,7 +543,7 @@ GRN_API grn_proc_type grn_proc_get_type(grn_ctx *ctx, grn_obj *proc);
 
 GRN_API grn_obj *grn_table_create(grn_ctx *ctx,
                                   const char *name, unsigned int name_size,
-                                  const char *path, grn_obj_flags flags,
+                                  const char *path, grn_table_flags flags,
                                   grn_obj *key_type, grn_obj *value_type);
 
 #define GRN_TABLE_OPEN_OR_CREATE(ctx,name,name_size,path,flags,key_type,value_type,table) \
@@ -645,7 +657,7 @@ GRN_API int grn_table_sort(grn_ctx *ctx, grn_obj *table, int offset, int limit,
                            grn_obj *result, grn_table_sort_key *keys, int n_keys);
 
 typedef struct _grn_table_group_result grn_table_group_result;
-typedef unsigned int grn_table_group_flags;
+typedef uint32_t grn_table_group_flags;
 
 #define GRN_TABLE_GROUP_CALC_COUNT     (0x01<<3)
 #define GRN_TABLE_GROUP_CALC_MAX       (0x01<<4)
@@ -893,6 +905,7 @@ GRN_API int grn_obj_get_values(grn_ctx *ctx, grn_obj *obj, grn_id offset, void *
 
 GRN_API grn_rc grn_obj_set_value(grn_ctx *ctx, grn_obj *obj, grn_id id, grn_obj *value, int flags);
 GRN_API grn_rc grn_obj_remove(grn_ctx *ctx, grn_obj *obj);
+GRN_API grn_rc grn_obj_remove_dependent(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_rc grn_obj_rename(grn_ctx *ctx, grn_obj *obj,
                               const char *name, unsigned int name_size);
 GRN_API grn_rc grn_table_rename(grn_ctx *ctx, grn_obj *table,

data/vendor/local/include/groonga/groonga/obj.h

@@ -37,6 +37,7 @@ GRN_API grn_bool grn_obj_is_reference_column(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_bool grn_obj_is_accessor(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_bool grn_obj_is_key_accessor(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_bool grn_obj_is_type(grn_ctx *ctx, grn_obj *obj);
+GRN_API grn_bool grn_obj_is_text_family_type(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_bool grn_obj_is_proc(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_bool grn_obj_is_tokenizer_proc(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_bool grn_obj_is_function_proc(grn_ctx *ctx, grn_obj *obj);

data/vendor/local/include/groonga/groonga/plugin.h

@@ -75,6 +75,9 @@ GRN_API void grn_plugin_free(grn_ctx *ctx, void *ptr, const char *file,
 
 #define GRN_PLUGIN_MALLOC(ctx, size) \
   grn_plugin_malloc((ctx), (size), __FILE__, __LINE__, __FUNCTION__)
+#define GRN_PLUGIN_MALLOCN(ctx, type, n) \
+  ((type *)(grn_plugin_malloc((ctx), sizeof(type) * (n), \
+                              __FILE__, __LINE__, __FUNCTION__)))
 #define GRN_PLUGIN_CALLOC(ctx, size) \
   grn_plugin_calloc((ctx), (size), __FILE__, __LINE__, __FUNCTION__)
 #define GRN_PLUGIN_REALLOC(ctx, ptr, size) \
@@ -93,6 +96,8 @@ GRN_API void grn_plugin_set_error(grn_ctx *ctx, grn_log_level level,
                                   grn_rc error_code,
                                   const char *file, int line, const char *func,
                                   const char *format, ...) GRN_ATTRIBUTE_PRINTF(7);
+GRN_API void grn_plugin_clear_error(grn_ctx *ctx);
+
 
 /*
   Don't call these functions directly. grn_plugin_backtrace() and
@@ -116,6 +121,10 @@ GRN_API void grn_plugin_logtrace(grn_ctx *ctx, grn_log_level level);
 #define GRN_PLUGIN_ERROR(ctx, error_code, ...) \
   GRN_PLUGIN_SET_ERROR(ctx, GRN_LOG_ERROR, error_code, __VA_ARGS__)
 
+#define GRN_PLUGIN_CLEAR_ERROR(ctx) do { \
+  grn_plugin_clear_error((ctx)); \
+} while (0)
+
 typedef struct _grn_plugin_mutex grn_plugin_mutex;
 
 GRN_API grn_plugin_mutex *grn_plugin_mutex_open(grn_ctx *ctx);

data/vendor/local/include/groonga/groonga/portability.h

@@ -141,6 +141,14 @@
   snprintf((dest), (n), __VA_ARGS__)
 #endif /* WIN32 */
 
+#ifdef WIN32
+# define grn_vsnprintf(dest, dest_size, format, args)           \
+  vsnprintf((dest), (dest_size) - 1, (format), (args))
+#else /* WIN32 */
+# define grn_vsnprintf(dest, dest_size, format, args)           \
+  vsnprintf((dest), (dest_size), (format), (args))
+#endif /* WIN32 */
+
 #ifdef WIN32
 # define grn_write(fd, buf, count) _write((fd), (buf), (count))
 #else /* WIN32 */

data/vendor/local/include/groonga/groonga/request_canceler.h

@@ -30,6 +30,7 @@ GRN_API void grn_request_canceler_unregister(grn_ctx *ctx,
                                              unsigned int size);
 GRN_API grn_bool grn_request_canceler_cancel(const char *request_id,
                                              unsigned int size);
+GRN_API grn_bool grn_request_canceler_cancel_all(void);
 
 #ifdef __cplusplus
 }

data/vendor/local/include/groonga/groonga/request_timer.h

@@ -0,0 +1,53 @@
+/*
+  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 as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  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-1301  USA
+*/
+
+#pragma once
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef struct _grn_request_timer {
+  void *user_data;
+  void *(*register_func)(const char *request_id,
+                         unsigned int request_id_size,
+                         double timeout,
+                         void *user_data);
+  void (*unregister_func)(void *timer_id,
+                          void *user_data);
+  void (*fin_func)(void *user_data);
+} grn_request_timer;
+
+/* Multithreading unsafe. */
+GRN_API void grn_request_timer_set(grn_request_timer *timer);
+
+/* Multithreading safety is depends on grn_request_timer. */
+GRN_API void *grn_request_timer_register(const char *request_id,
+                                         unsigned int request_id_size,
+                                         double timeout);
+/* Multithreading safety is depends on grn_request_timer. */
+GRN_API void grn_request_timer_unregister(void *timer_id);
+
+
+GRN_API double grn_get_default_request_timeout(void);
+GRN_API void grn_set_default_request_timeout(double timeout);
+
+
+#ifdef __cplusplus
+}
+#endif

data/vendor/local/include/groonga/groonga/type.h

@@ -22,6 +22,15 @@
 extern "C" {
 #endif
 
+/* Just for backward compatibility.
+   Use grn_type_id_is_text_family() instead. */
+#define GRN_TYPE_IS_TEXT_FAMILY(type)                           \
+  grn_type_id_is_text_family(NULL, (type))
+
+GRN_API grn_bool grn_type_id_is_builtin(grn_ctx *ctx, grn_id id);
+GRN_API grn_bool grn_type_id_is_number_family(grn_ctx *ctx, grn_id id);
+GRN_API grn_bool grn_type_id_is_text_family(grn_ctx *ctx, grn_id id);
+
 GRN_API grn_obj *grn_type_create(grn_ctx *ctx, const char *name, unsigned int name_size,
                                  grn_obj_flags flags, unsigned int size);
 GRN_API uint32_t grn_type_size(grn_ctx *ctx, grn_obj *type);

data/vendor/local/include/groonga/groonga.h

@@ -34,6 +34,7 @@
 #include "groonga/output.h"
 #include "groonga/pat.h"
 #include "groonga/request_canceler.h"
+#include "groonga/request_timer.h"
 #include "groonga/thread.h"
 #include "groonga/type.h"
 #include "groonga/util.h"

data/vendor/local/lib/groonga/plugins/expression_rewriters/optimizer.rb

@@ -4,34 +4,143 @@ module Groonga
       register "optimizer"
 
       def rewrite
-        codes = @expression.codes
-        n_codes = codes.size
+        builder = ExpressionTreeBuilder.new(@expression)
+        root_node = builder.build
 
-        # (A >= x && A < y) -> between(A, x, "include", y, "exclude")
-        return nil if n_codes != 7
+        variable = @expression[0]
+        table = context[variable.domain]
+        optimized_root_node = optimize_node(table, root_node)
 
-        return nil if codes[6].op != Operator::AND
+        rewritten = Expression.create(table)
+        optimized_root_node.build(rewritten)
+        rewritten
+      end
 
-        return nil if codes[0].op != Operator::GET_VALUE
-        return nil if codes[1].op != Operator::PUSH
-        return nil if codes[2].op != Operator::GREATER_EQUAL
+      private
+      def optimize_node(table, node)
+        case node
+        when ExpressionTree::LogicalOperation
+          optimized_sub_nodes = node.nodes.collect do |sub_node|
+            optimize_node(table, sub_node)
+          end
+          case node.operator
+          when Operator::AND
+            optimized_sub_nodes =
+              optimize_and_sub_nodes(table, optimized_sub_nodes)
+          end
+          ExpressionTree::LogicalOperation.new(node.operator,
+                                               optimized_sub_nodes)
+        when ExpressionTree::BinaryOperation
+          optimized_left = optimize_node(table, node.left)
+          optimized_right = optimize_node(table, node.right)
+          if optimized_left.is_a?(ExpressionTree::Constant) and
+              optimized_right.is_a?(ExpressionTree::Variable)
+            ExpressionTree::BinaryOperation.new(node.operator,
+                                                optimized_right,
+                                                optimized_left)
+          elsif node.left == optimized_left and node.right == optimized_right
+            node
+          else
+            ExpressionTree::BinaryOperation.new(node.operator,
+                                                optimized_left,
+                                                optimized_right)
+          end
+        else
+          node
+        end
+      end
 
-        return nil if codes[3].op != Operator::GET_VALUE
-        return nil if codes[4].op != Operator::PUSH
-        return nil if codes[5].op != Operator::LESS
+      def optimize_and_sub_nodes(table, sub_nodes)
+        grouped_sub_nodes = sub_nodes.group_by do |sub_node|
+          case sub_node
+          when ExpressionTree::BinaryOperation
+            if sub_node.left.is_a?(ExpressionTree::Variable)
+              sub_node.left.column
+            else
+              nil
+            end
+          else
+            nil
+          end
+        end
 
-        return nil if codes[3].value != codes[0].value
+        optimized_nodes = []
+        grouped_sub_nodes.each do |column, grouped_nodes|
+          if column
+            grouped_nodes = optimize_grouped_nodes(column, grouped_nodes)
+          end
+          optimized_nodes.concat(grouped_nodes)
+        end
 
-        variable = @expression[0]
-        rewritten = Expression.create(context[variable.domain])
-        rewritten.append_object(Context.instance["between"], Operator::PUSH, 1)
-        rewritten.append_object(codes[0].value, Operator::GET_VALUE, 1)
-        rewritten.append_constant(codes[1].value.value, Operator::PUSH, 1)
-        rewritten.append_constant("include", Operator::PUSH, 1)
-        rewritten.append_constant(codes[4].value.value, Operator::PUSH, 1)
-        rewritten.append_constant("exclude", Operator::PUSH, 1)
-        rewritten.append_operator(Operator::CALL, 5)
-        rewritten
+        optimized_nodes.sort_by do |node|
+          node.estimate_size(table)
+        end
+      end
+
+      COMPARISON_OPERATORS = [
+        Operator::EQUAL,
+        Operator::NOT_EQUAL,
+        Operator::LESS,
+        Operator::GREATER,
+        Operator::LESS_EQUAL,
+        Operator::GREATER_EQUAL,
+      ]
+      def optimize_grouped_nodes(column, grouped_nodes)
+        target_nodes, done_nodes = grouped_nodes.partition do |node|
+          node.is_a?(ExpressionTree::BinaryOperation) and
+            COMPARISON_OPERATORS.include?(node.operator) and
+            node.right.is_a?(ExpressionTree::Constant)
+        end
+
+        # TODO: target_nodes = remove_needless_nodes(target_nodes)
+        # e.g.: x < 1 && x < 3 -> x < 1: (x < 3) is meaningless
+
+        if target_nodes.size == 2
+          between_node = try_optimize_between(column, target_nodes)
+          if between_node
+            done_nodes << between_node
+          else
+            done_nodes.concat(target_nodes)
+          end
+        else
+          done_nodes.concat(target_nodes)
+        end
+
+        done_nodes
+      end
+
+      def try_optimize_between(column, target_nodes)
+        greater_node = nil
+        less_node = nil
+        target_nodes.each do |node|
+          case node.operator
+          when Operator::GREATER, Operator::GREATER_EQUAL
+            greater_node = node
+          when Operator::LESS, Operator::LESS_EQUAL
+            less_node = node
+          end
+        end
+        return nil if greater_node.nil? or less_node.nil?
+
+        between = context["between"]
+        if greater_node.operator == Operator::GREATER
+          greater_border = "exclude"
+        else
+          greater_border = "include"
+        end
+        if less_node.operator == Operator::LESS
+          less_border = "exclude"
+        else
+          less_border = "include"
+        end
+        arguments = [
+          ExpressionTree::Variable.new(column),
+          greater_node.right,
+          ExpressionTree::Constant.new(greater_border),
+          less_node.right,
+          ExpressionTree::Constant.new(less_border),
+        ]
+        ExpressionTree::FunctionCall.new(between, arguments)
       end
     end
   end

data/vendor/local/lib/groonga/plugins/ruby/eval.rb

@@ -0,0 +1,36 @@
+module Groonga
+  module Ruby
+    class EvalCommand < Command
+      register("ruby_eval",
+               [
+                 "script",
+               ])
+
+      def run_body(input)
+        script = input[:script]
+        unless script.is_a?(String)
+          message = "script must be a string: <#{script.inspect}>"
+          raise Groonga::InvalidArgument, message
+        end
+
+        eval_context = EvalContext.new
+        begin
+          result = eval_context.eval(script)
+        rescue => error
+          writer.map("result", 1) do
+            writer.write("exception")
+            writer.map("exception", 1) do
+              writer.write("message")
+              writer.write(error.message)
+            end
+          end
+        else
+          writer.map("result", 1) do
+            writer.write("value")
+            writer.write(result)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/local/lib/groonga/plugins/sharding/logical_enumerator.rb

@@ -143,6 +143,14 @@ module Groonga
           @month = month
           @day = day
         end
+
+        def to_suffix
+          if @day.nil?
+            "_%02d%02d" % [@year, @month]
+          else
+            "_%02d%02d%02d" % [@year, @month, @day]
+          end
+        end
       end
 
       class DayShardRange