rroonga 7.1.1-x64-mingw32 → 9.0.2-x64-mingw32

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

@@ -3,6 +3,8 @@ module Groonga
     class Constant
       attr_reader :value
       def initialize(value)
+        # Groonga::Bulk, Groonga::Vector or raw Ruby object.
+        # Should we unify to Groonga::*?
         @value = value
       end
 
@@ -10,13 +12,26 @@ module Groonga
         expression.append_constant(@value, Operator::PUSH, 1)
       end
 
+      def estimatable?
+        true
+      end
+
       def estimate_size(table)
-        if Bulk.true?(@value)
+        if true_value?
           table.size
         else
           0
         end
       end
+
+      private
+      def true_value?
+        if @value.respond_to?(:true?)
+          @value.true?
+        else
+          Bulk.true?(@value)
+        end
+      end
     end
   end
 end

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

@@ -16,9 +16,23 @@ module Groonga
         expression.append_operator(Operator::CALL, @arguments.size)
       end
 
+      def estimatable?
+        true
+      end
+
       def estimate_size(table)
-        return table.size unless @procedure.name == "between"
+        case @procedure.name
+        when "between"
+          estimate_size_between(table)
+        when "in_values"
+          estimate_size_in_values(table)
+        else
+          table.size
+        end
+      end
 
+      private
+      def estimate_size_between(table)
         column, min, min_border, max, max_border = @arguments
 
         if column.is_a?(Groonga::ExpressionTree::IndexColumn)
@@ -61,6 +75,21 @@ module Groonga
           index_column.estimate_size(:lexicon_cursor => cursor)
         end
       end
+
+      def estimate_size_in_values(table)
+        column, *values = @arguments
+        total = values.inject(0) do |sum, value|
+          node = BinaryOperation.new(Operator::EQUAL, column, value)
+          sum + node.estimate_size(table)
+        end
+        duplicated_ratio = 0.3 # No reason :p
+        estimated_size = (total * (1 - duplicated_ratio)).round
+        if estimated_size < table.size
+          estimated_size
+        else
+          table.size
+        end
+      end
     end
   end
 end

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

@@ -15,6 +15,12 @@ module Groonga
         end
       end
 
+      def estimatable?
+        @nodes.all? do |node|
+          node.estimatable?
+        end
+      end
+
       def estimate_size(table)
         estimated_sizes = @nodes.collect do |node|
           node.estimate_size(table)

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

@@ -0,0 +1,18 @@
+module Groonga
+  module ExpressionTree
+    class Member
+      attr_reader :variable
+      attr_reader :index
+      def initialize(variable, index)
+        @variable = variable
+        @index = index
+      end
+
+      def build(expression)
+        @variable.build(expression)
+        @index.build(expression)
+        expression.append_operator(Operator::GET_MEMBER, 2)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Groonga
+  module ExpressionTree
+    class Null
+      def build(expression)
+        expression.append_constant(nil, Operator::PUSH, 1)
+      end
+
+      def estimatable?
+        true
+      end
+
+      def estimate_size(table)
+        0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Groonga
+  module ExpressionTree
+    class Reference
+      attr_reader :column
+      def initialize(column)
+        @column = column
+      end
+
+      def build(expression)
+        expression.append_object(@column, Operator::GET_REF, 1)
+      end
+
+      def estimate_size(table)
+        table.size
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Groonga
+  module ExpressionTree
+    class Table
+      attr_reader :table
+      def initialize(table)
+        @table = table
+      end
+
+      def build(expression)
+        expression.append_object(@table, Operator::PUSH, 1)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Groonga
+  module ExpressionTree
+    class UnaryOperation
+      attr_reader :operator
+      attr_reader :value
+      def initialize(operator, value)
+        @operator = operator
+        @value = value
+      end
+
+      def build(expression)
+        @value.build(expression)
+        expression.append_operator(@operator, 1)
+      end
+
+      def estimatable?
+        true
+      end
+
+      def estimate_size(table)
+        # TODO
+        table.size
+      end
+    end
+  end
+end

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

@@ -10,6 +10,10 @@ module Groonga
         expression.append_object(@column, Operator::GET_VALUE, 1)
       end
 
+      def estimatable?
+        true
+      end
+
       def estimate_size(table)
         table.size
       end

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

@@ -28,13 +28,12 @@ module Groonga
       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::SLASH,
       Operator::MOD,
     ]
 
@@ -45,6 +44,29 @@ module Groonga
       Operator::ADJUST,
     ]
 
+    UNARY_OPERATIONS = [
+      Operator::NOT,
+      Operator::BITWISE_NOT,
+      Operator::INCR,
+      Operator::DECR,
+      Operator::INCR_POST,
+      Operator::DECR_POST,
+    ]
+
+    ASSIGN_ARITHMETIC_OPERATIONS = [
+      Operator::STAR_ASSIGN,
+      Operator::SLASH_ASSIGN,
+      Operator::MOD_ASSIGN,
+      Operator::PLUS_ASSIGN,
+      Operator::MINUS_ASSIGN,
+      Operator::SHIFTL_ASSIGN,
+      Operator::SHIFTR_ASSIGN,
+      Operator::SHIFTRR_ASSIGN,
+      Operator::AND_ASSIGN,
+      Operator::XOR_ASSIGN,
+      Operator::OR_ASSIGN,
+    ]
+
     def initialize(expression)
       @expression = expression
     end
@@ -63,13 +85,53 @@ module Groonga
           node = ExpressionTree::LogicalOperation.new(code.op, nodes)
           stack.push(node)
         when *RELATION_OPERATORS, *ARITHMETIC_OPERATORS
+          options = {}
+          options[:parameter] = stack.pop if code.n_args == 3
+          options[:value] = code.value.value if code.value
           right = stack.pop
           left = stack.pop
-          node = ExpressionTree::BinaryOperation.new(code.op, left, right)
+          node = ExpressionTree::BinaryOperation.new(code.op,
+                                                     left,
+                                                     right,
+                                                     options)
+          stack.push(node)
+        when *UNARY_OPERATIONS
+          value = stack.pop
+          node = ExpressionTree::UnaryOperation.new(code.op, value)
+          stack.push(node)
+        when *ASSIGN_ARITHMETIC_OPERATIONS
+          value = stack.pop
+          variable = stack.pop
+          node = ExpressionTree::AssignBinaryOperation.new(code.op,
+                                                           variable,
+                                                           value)
+          stack.push(node)
+        when Operator::MINUS
+          if code.n_args == 1
+            value = stack.pop
+            node = ExpressionTree::UnaryOperation.new(code.op, value)
+          else
+            right = stack.pop
+            left = stack.pop
+            node = ExpressionTree::BinaryOperation.new(code.op, left, right)
+          end
+          stack.push(node)
+        when Operator::GET_REF
+          node = ExpressionTree::Reference.new(code.value)
           stack.push(node)
         when Operator::GET_VALUE
           node = ExpressionTree::Variable.new(code.value)
           stack.push(node)
+        when Operator::GET_MEMBER
+          index = stack.pop
+          variable = stack.pop
+          node = ExpressionTree::Member.new(variable, index)
+          stack.push(node)
+        when Operator::ASSIGN
+          value = stack.pop
+          variable = stack.pop
+          node = ExpressionTree::Assign.new(variable, value)
+          stack.push(node)
         when Operator::PUSH
           case code.value
           when Procedure
@@ -78,10 +140,12 @@ module Groonga
             node = ExpressionTree::IndexColumn.new(code.value)
           when Accessor
             node = ExpressionTree::Accessor.new(code.value)
-          when HashTable
-            node = ExpressionTree::Options.new(code.value)
+          when Table
+            node = ExpressionTree::Table.new(code.value)
+          when Void
+            node = ExpressionTree::Null.new
           else
-            node = ExpressionTree::Constant.new(code.value.value)
+            node = ExpressionTree::Constant.new(code.value)
           end
           stack.push(node)
         when Operator::CALL
@@ -96,13 +160,19 @@ module Groonga
           raise "unknown operator: #{code.inspect}"
         end
       end
-      stack.pop
+      if stack.size == 1
+        stack.pop
+      else
+        # Unsupported expression
+        nil
+      end
     end
 
     private
     def add_logical_operation_node(operator, nodes, node)
       if node.is_a?(ExpressionTree::LogicalOperation) and
-          node.operator == operator
+          node.operator == operator and
+          node.operator != Operator::AND_NOT
         nodes.concat(node.nodes)
       else
         nodes << node

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

@@ -6,6 +6,10 @@ module Groonga
 
     # Estimate the number of matched records for term ID or query.
     #
+    # @overload estimate_size(:term => term)
+    #   @param term [Record] the term as a Record
+    #   @return [Integer] the number of matched records for the term ID.
+    #
     # @overload estimate_size(:term_id => term_id)
     #   @return [Integer] the number of matched records for the term ID.
     #
@@ -16,6 +20,12 @@ module Groonga
     #   @return [Integer] the number of matched records for the lexicon cursor.
     #
     def estimate_size(parameters)
+      term = parameters[:term]
+      if term
+        # TODO: Validate lexicon
+        return estimate_size_for_term_id(term.id)
+      end
+
       term_id = parameters[:term_id]
       if term_id
         return estimate_size_for_term_id(term_id)

data/vendor/local/lib/groonga/scripts/ruby/initialize/post.rb

@@ -29,6 +29,8 @@ require "labeled_arguments"
 
 require "command_line_parser"
 
+require "locale_output"
+
 load_path = ENV["GRN_RUBY_LOAD_PATH"]
 if load_path
   load_path.split(File::PATH_SEPARATOR).each do |path|

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

@@ -0,0 +1,28 @@
+module Groonga
+  class LocaleOutput
+    def puts(*args)
+      if args.empty?
+        write("\n")
+        return nil
+      end
+
+      args.each do |arg|
+        case arg
+        when String
+          write(arg)
+          write("\n") if arg[-1] != "\n"
+        when Array
+          next if arg.empty?
+          puts(*arg)
+        else
+          if arg.respond_to?(:to_ary)
+            puts(arg.to_ary)
+          else
+            puts(arg.to_s)
+          end
+        end
+      end
+      nil
+    end
+  end
+end

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

@@ -1,5 +1,28 @@
 module Groonga
   class Logger
+    def log(log_level, *args)
+      case log_level
+      when Symbol
+        log_level = Level.find(log_level).to_i
+      when String
+        log_level = Level.find(log_level.to_sym).to_i
+      when Level
+        log_level = log_level.to_i
+      end
+
+      if args.size == 1
+        entry = BacktraceEntry.parse(caller(1, 1)[0])
+        file = entry.file
+        line = entry.line
+        method = entry.method
+        message = args[0]
+      else
+        file, line, method, message = args
+      end
+
+      log_raw(log_level, file, line, method, message)
+    end
+
     def log_error(error)
       log_level = Level::ERROR.to_i
 
@@ -15,7 +38,6 @@ module Groonga
         file = first_entry.file
         line = first_entry.line
         method = first_entry.method
-        # message = "#{file}:#{line}:#{method}: #{message}"
       else
         file = ""
         line = 0
@@ -25,10 +47,20 @@ module Groonga
 
       backtrace.each_with_index do |raw_entry, i|
         entry = BacktraceEntry.parse(raw_entry)
-        message = entry.message
-        message = raw_entry if message.empty?
-        log(log_level, entry.file, entry.line, entry.method, raw_entry)
+        if use_raw_entry_as_message?(entry)
+          message = raw_entry
+        else
+          message = entry.message
+        end
+        log(log_level, entry.file, entry.line, entry.method, message)
       end
     end
+
+    private
+    def use_raw_entry_as_message?(entry)
+      return false unless entry.message.empty?
+      return true if entry.file.empty?
+      need_location_in_message?
+    end
   end
 end