rroonga 6.0.0-x64-mingw32 → 6.0.2-x64-mingw32

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/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

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

@@ -9,20 +9,23 @@ module Groonga
                  "min_border",
                  "max",
                  "max_border",
+                 "dependent",
                ])
 
       def run_body(input)
+        @dependent = (input[:dependent] == "yes")
+
         enumerator = LogicalEnumerator.new("logical_table_remove", input)
 
-        succeess = true
+        success = true
         enumerator.each do |shard, shard_range|
-          remove_table(shard, shard_range, enumerator.target_range)
+          remove_shard(shard, shard_range, enumerator.target_range)
         end
-        writer.write(succeess)
+        writer.write(success)
       end
 
       private
-      def remove_table(shard, shard_range, target_range)
+      def remove_shard(shard, shard_range, target_range)
         cover_type = target_range.cover_type(shard_range)
         return if cover_type == :none
 
@@ -40,22 +43,54 @@ module Groonga
 
         case cover_type
         when :all
-          table.remove
+          remove_table(shard)
         when :partial_min
           remove_records(table) do |expression|
             expression_builder.build_partial_min(expression)
           end
-          table.remove if table.empty?
+          remove_table(shard) if table.empty?
         when :partial_max
           remove_records(table) do |expression|
             expression_builder.build_partial_max(expression)
           end
-          table.remove if table.empty?
+          remove_table(shard) if table.empty?
         when :partial_min_and_max
           remove_records(table) do |expression|
             expression_builder.build_partial_min_and_max(expression)
           end
-          table.remove if table.empty?
+          remove_table(shard) if table.empty?
+        end
+      end
+
+      def remove_table(shard)
+        table = shard.table
+        shard_suffix = shard.range_data.to_suffix
+
+        referenced_table_ids = []
+        if @dependent
+          table.columns.each do |column|
+            range = column.range
+            if range.is_a?(Table)
+              referenced_table_ids << range.id
+              range.indexes.each do |index_info|
+                referenced_table_ids << index_info.index.domain.id
+              end
+            end
+            column.indexes.each do |index_info|
+              referenced_table_ids << index_info.index.domain.id
+            end
+          end
+        end
+
+        table.remove(:dependent => @dependent)
+
+        context = Groonga::Context.instance
+        referenced_table_ids.each do |referenced_table_id|
+          referenced_table = context[referenced_table_id]
+          next if referenced_table.nil?
+          if referenced_table.name.end_with?(shard_suffix)
+            referenced_table.remove(:dependent => @dependent)
+          end
         end
       end