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

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
 

data/vendor/local/lib/groonga/scripts/ruby/command_line/grndb.rb

@@ -161,6 +161,7 @@ module Groonga
             context = Context.instance
             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
@@ -208,6 +209,8 @@ module Groonga
         end
 
         def check_object_recursive(target)
+          return if @checked.key?(target.id)
+
           check_object(target)
           case target
           when Table
@@ -285,6 +288,17 @@ module Groonga
           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

data/vendor/local/lib/groonga/scripts/ruby/context/rc.rb

@@ -182,6 +182,10 @@ module Groonga
         register(:command_error, -74, CommandError)
       PLUGIN_ERROR =
         register(:plugin_error, -75, PluginError)
+      SCORER_ERROR =
+        register(:scorer_error, -76, ScorerError)
+      CANCEL =
+        register(:cancel, -77, Cancel)
 
       GroongaError.rc = UNKNOWN_ERROR
     end

data/vendor/local/lib/groonga/scripts/ruby/eval_context.rb

@@ -1,5 +1,10 @@
 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?

data/vendor/local/lib/groonga/scripts/ruby/expression.rb

@@ -1,6 +1,8 @@
 require "expression_rewriter"
 require "expression_rewriters"
 
+require "expression_tree_builder"
+
 require "scan_info"
 require "scan_info_builder"
 

data/vendor/local/lib/groonga/scripts/ruby/expression_size_estimator.rb

@@ -74,10 +74,7 @@ module Groonga
            Operator::GREATER_EQUAL
         size = estimate_range(data, index_column)
       when Operator::CALL
-        procedure = data.args.first
-        if procedure.is_a?(Procedure) and procedure.name == "between"
-          size = estimate_between(data, index_column)
-        end
+        size = estimate_call(data, index_column)
       end
       size || @table_size
     end
@@ -137,28 +134,17 @@ module Groonga
       end
     end
 
-    def estimate_between(data, index_column)
-      lexicon = index_column.lexicon
-      _, _, min, min_border, max, max_border = data.args
-      options = {
-        :min => min,
-        :max => max,
-        :flags => 0,
-      }
-      if min_border == "include"
-        options[:flags] |= TableCursorFlags::LT
-      else
-        options[:flags] |= TableCursorFlags::LE
-      end
-      if max_border == "include"
-        options[:flags] |= TableCursorFlags::GT
-      else
-        options[:flags] |= TableCursorFlags::GE
-      end
-
-      TableCursor.open(lexicon, options) do |cursor|
-        index_column.estimate_size(:lexicon_cursor => cursor)
+    def estimate_call(data, 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

data/vendor/local/lib/groonga/scripts/ruby/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

data/vendor/local/lib/groonga/scripts/ruby/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

data/vendor/local/lib/groonga/scripts/ruby/expression_tree/function_call.rb

@@ -0,0 +1,50 @@
+module Groonga
+  module ExpressionTree
+    class FunctionCall
+      attr_reader :procedure
+      attr_reader :arguments
+      def initialize(procedure, arguments)
+        @procedure = procedure
+        @arguments = arguments
+      end
+
+      def build(expression)
+        expression.append_object(@procedure, Operator::PUSH, 1)
+        @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
+        index_info = column.column.find_index(Operator::CALL)
+        return table.size if index_info.nil?
+
+        index_column = index_info.index
+        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

data/vendor/local/lib/groonga/scripts/ruby/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

data/vendor/local/lib/groonga/scripts/ruby/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

data/vendor/local/lib/groonga/scripts/ruby/expression_tree.rb

@@ -0,0 +1,5 @@
+require "expression_tree/constant"
+require "expression_tree/binary_operation"
+require "expression_tree/function_call"
+require "expression_tree/logical_operation"
+require "expression_tree/variable"

data/vendor/local/lib/groonga/scripts/ruby/expression_tree_builder.rb

@@ -0,0 +1,92 @@
+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
+          node = ExpressionTree::Constant.new(code.value.value)
+          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

data/vendor/local/lib/groonga/scripts/ruby/scan_info_builder.rb

@@ -76,6 +76,12 @@ module Groonga
           @data_list << data
           data = nil
         when *LOGICAL_OPERATORS
+          if status == Status::CONST
+            data.op = Operator::PUSH
+            data.end = data.start
+            @data_list << data
+            data = nil
+          end
           put_logical_op(code.op, i)
           # TODO: rescue and return nil
           status = Status::START
@@ -90,6 +96,14 @@ module Groonga
             end
             status = 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
+            data = nil
+            status = Status::START
+          end
         when Operator::GET_VALUE
           case status
           when Status::START
@@ -169,14 +183,29 @@ module Groonga
           status = Status::START
           return false if n_relation_expressions != (n_logical_expressions + 1)
         when *LOGICAL_OPERATORS
-          return false if status != Status::START
-          n_logical_expressions += 1
-          return false if n_logical_expressions >= n_relation_expressions
+          case status
+          when Status::START
+            n_logical_expressions += 1
+            return false if n_logical_expressions >= n_relation_expressions
+          when Status::CONST
+            n_logical_expressions += 1
+            n_relation_expressions += 1
+            return false if n_logical_expressions >= n_relation_expressions
+            status = Status::START
+          else
+            return false
+          end
         when Operator::PUSH
-          if code.value == variable
-            status = Status::VAR
+          if code.modify > 0 and
+              LOGICAL_OPERATORS.include?(codes[i + code.modify].op)
+            n_relation_expressions += 1
+            status = Status::START
           else
-            status = Status::CONST
+            if code.value == variable
+              status = Status::VAR
+            else
+              status = Status::CONST
+            end
           end
         when Operator::GET_VALUE
           case status

data/vendor/local/lib/pkgconfig/groonga.pc

@@ -11,10 +11,10 @@ pluginsdir=${libdir}/groonga/plugins
 groonga=${bindir}/groonga.exe
 groonga_httpd=${sbindir}/groonga-httpd.exe
 groonga_suggest_create_dataset=${bindir}/groonga-suggest-create-dataset.exe
-groonga_version=6.0.0
+groonga_version=6.0.2
 
 Name: Groonga
 Description: An Embeddable Fulltext Search Engine
-Version: 6.0.0
+Version: 6.0.2
 Libs: -L${libdir} -lgroonga
 Cflags: -I${includedir}/groonga

data/vendor/local/share/doc/groonga/en/html/.buildinfo

@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: 854339bcc6ea7ba27acbbd757eeb3f0a
+config: bfc9d3724004ca2676fddac668bf3138
 tags: 645f666f9bcd5a90fca523b33c5a78b7