rroonga 6.1.3-x64-mingw32 → 7.0.2-x64-mingw32

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

@@ -50,8 +50,7 @@ module Groonga
         end
 
         expression_builder = RangeExpressionBuilder.new(shard_key,
-                                                        target_range,
-                                                        nil)
+                                                        target_range)
         case cover_type
         when :partial_min
           remove_records(table) do |expression|

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

@@ -1,16 +1,23 @@
 module Groonga
   module Sharding
     class RangeExpressionBuilder
-      def initialize(key, target_range, filter)
+      attr_reader :match_columns_expression
+
+      attr_writer :match_columns
+      attr_writer :query
+      attr_writer :filter
+
+      def initialize(key, target_range)
         @key = key
         @target_range = target_range
-        @filter = filter
+        @match_columns_expression = nil
+        @match_columns = nil
+        @query = nil
+        @filter = nil
       end
 
       def build_all(expression)
-        return if @filter.nil?
-
-        expression.parse(@filter)
+        build_condition(expression)
       end
 
       def build_partial_min(expression)
@@ -22,10 +29,7 @@ module Groonga
         else
           expression.append_operator(Operator::GREATER, 2)
         end
-        if @filter
-          expression.parse(@filter)
-          expression.append_operator(Operator::AND, 2)
-        end
+        build_condition(expression)
       end
 
       def build_partial_max(expression)
@@ -37,10 +41,7 @@ module Groonga
         else
           expression.append_operator(Operator::LESS, 2)
         end
-        if @filter
-          expression.parse(@filter)
-          expression.append_operator(Operator::AND, 2)
-        end
+        build_condition(expression)
       end
 
       def build_partial_min_and_max(expression)
@@ -55,9 +56,31 @@ module Groonga
         expression.append_constant(@target_range.max_border,
                                    Operator::PUSH, 1)
         expression.append_operator(Operator::CALL, 5)
+        build_condition(expression)
+      end
+
+      private
+      def build_condition(expression)
+        if @query
+          is_empty = expression.empty?
+          if @match_columns
+            table = Context.instance[expression[0].domain]
+            @match_columns_expression = Expression.create(table)
+            @match_columns_expression.parse(@match_columns)
+          end
+          flags = Expression::SYNTAX_QUERY |
+            Expression::ALLOW_PRAGMA |
+            Expression::ALLOW_COLUMN
+          expression.parse(@query,
+                           default_column: @match_columns_expression,
+                           flags: flags)
+          expression.append_operator(Operator::AND, 2) unless is_empty
+        end
+
         if @filter
+          is_empty = expression.empty?
           expression.parse(@filter)
-          expression.append_operator(Operator::AND, 2)
+          expression.append_operator(Operator::AND, 2) unless is_empty
         end
       end
     end

data/vendor/local/lib/groonga/plugins/suggest/suggest.la

@@ -17,7 +17,7 @@ old_library='suggest.a'
 inherited_linker_flags=''
 
 # Libraries that this one depends upon.
-dependency_libs=' -L/vagrant/dist-x64/lib /vagrant/dist-x64/lib/libgroonga.la /vagrant/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32 -lmsgpackc'
+dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libgroonga.la /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32 -lmsgpackc'
 
 # Names of additional weak libraries provided by this library
 weak_library_names=''
@@ -38,4 +38,4 @@ dlopen=''
 dlpreopen=''
 
 # Directory that this library needs to be installed in:
-libdir='/vagrant/dist-x64/lib/groonga/plugins/suggest'
+libdir='/build/dist-x64/lib/groonga/plugins/suggest'

data/vendor/local/lib/groonga/plugins/token_filters/stop_word.la

@@ -17,7 +17,7 @@ old_library='stop_word.a'
 inherited_linker_flags=''
 
 # Libraries that this one depends upon.
-dependency_libs=' -L/vagrant/dist-x64/lib /vagrant/dist-x64/lib/libgroonga.la -lmsgpackc /vagrant/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32'
+dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libgroonga.la -lmsgpackc /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32'
 
 # Names of additional weak libraries provided by this library
 weak_library_names=''
@@ -38,4 +38,4 @@ dlopen=''
 dlpreopen=''
 
 # Directory that this library needs to be installed in:
-libdir='/vagrant/dist-x64/lib/groonga/plugins/token_filters'
+libdir='/build/dist-x64/lib/groonga/plugins/token_filters'

data/vendor/local/lib/groonga/plugins/tokenizers/mecab.la

@@ -17,7 +17,7 @@ old_library='mecab.a'
 inherited_linker_flags=''
 
 # Libraries that this one depends upon.
-dependency_libs=' -L/vagrant/dist-x64/lib /vagrant/dist-x64/lib/libmecab.la /vagrant/dist-x64/lib/libgroonga.la -lmsgpackc /vagrant/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32'
+dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libmecab.la /build/dist-x64/lib/libgroonga.la -lmsgpackc /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32'
 
 # Names of additional weak libraries provided by this library
 weak_library_names=''
@@ -38,4 +38,4 @@ dlopen=''
 dlpreopen=''
 
 # Directory that this library needs to be installed in:
-libdir='/vagrant/dist-x64/lib/groonga/plugins/tokenizers'
+libdir='/build/dist-x64/lib/groonga/plugins/tokenizers'

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

@@ -36,7 +36,6 @@ module Groonga
         cached_value = cache.fetch(key)
         if cached_value
           context.output = cached_value
-          cache.unref(key)
           query_logger.log(:cache, ":", "cache(#{cached_value.bytesize})")
         else
           yield

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

@@ -0,0 +1,15 @@
+module Groonga
+  class CommandInput
+    include Enumerable
+
+    def each
+      args = arguments
+      arg = Record.new(args, nil)
+      args.each do |id|
+        arg.id = id
+        key = arg.key
+        yield(key, self[key])
+      end
+    end
+  end
+end

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

@@ -6,6 +6,7 @@ require "expression_tree_builder"
 require "scan_info"
 require "scan_info_builder"
 
+require "scan_info_data_size_estimator"
 require "expression_size_estimator"
 
 module Groonga

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

@@ -31,7 +31,8 @@ module Groonga
             current_size = 0
           end
 
-          size = estimate_data(data)
+          estimator = ScanInfoDataSizeEstimator.new(data, @table)
+          size = estimator.estimate
           case data.logical_op
           when Operator::AND
             current_size = size if size < current_size
@@ -49,140 +50,5 @@ module Groonga
       end
       current_size
     end
-
-    private
-    def estimate_data(data)
-      search_index = data.search_indexes.first
-      return @table_size if search_index.nil?
-
-      index_column = resolve_index_column(search_index.index_column,
-                                          data.op)
-      return @table_size if index_column.nil?
-
-      size = nil
-      case data.op
-      when Operator::MATCH,
-           Operator::FUZZY
-        size = estimate_match(data, index_column)
-      when Operator::REGEXP
-        size = estimate_regexp(data, index_column)
-      when Operator::EQUAL
-        size = estimate_equal(data, index_column)
-      when Operator::LESS,
-           Operator::LESS_EQUAL,
-           Operator::GREATER,
-           Operator::GREATER_EQUAL
-        size = estimate_range(data, index_column)
-      when Operator::PREFIX
-        size = estimate_prefix(data, index_column)
-      when Operator::CALL
-        size = estimate_call(data, index_column)
-      end
-      size || @table_size
-    end
-
-    def resolve_index_column(index_column, operator)
-      while index_column.is_a?(Accessor)
-        index_info = index_column.find_index(operator)
-        return nil if index_info.nil?
-        index_column = index_info.index
-      end
-
-      index_column
-    end
-
-    def sampling_cursor_limit(n_terms)
-      limit = n_terms * 0.01
-      if limit < 10
-        10
-      elsif limit > 1000
-        1000
-      else
-        limit.to_i
-      end
-    end
-
-    def estimate_match(data, index_column)
-      index_column.estimate_size(:query => data.query.value)
-    end
-
-    def estimate_regexp(data, index_column)
-      index_column.estimate_size(:query => data.query.value,
-                                 :mode => data.op)
-    end
-
-    def estimate_equal(data, index_column)
-      lexicon = index_column.lexicon
-      query = data.query
-      if query.domain == lexicon.id
-        term_id = query.value
-      else
-        term_id = lexicon[query]
-      end
-      return 0 if term_id.nil?
-
-      index_column.estimate_size(:term_id => term_id)
-    end
-
-    def estimate_range(data, index_column)
-      lexicon = index_column.lexicon
-      n_terms = lexicon.size
-      return 0 if n_terms.zero?
-
-      value = data.query.value
-      options = {
-        :limit => sampling_cursor_limit(n_terms),
-      }
-      case data.op
-      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|
-        size = index_column.estimate_size(:lexicon_cursor => cursor)
-        size += 1 if cursor.next != ID::NIL
-        size
-      end
-    end
-
-    def estimate_prefix(data, index_column)
-      lexicon = index_column.lexicon
-      n_terms = lexicon.size
-      return 0 if n_terms.zero?
-
-      value = data.query.value
-      options = {
-        :min => value,
-        :limit => sampling_cursor_limit(n_terms),
-        :flags => TableCursorFlags::PREFIX,
-      }
-      TableCursor.open(lexicon, options) do |cursor|
-        size = index_column.estimate_size(:lexicon_cursor => cursor)
-        size += 1 if cursor.next != ID::NIL
-        size
-      end
-    end
-
-    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/function_call.rb

@@ -20,10 +20,21 @@ module Groonga
         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
+        while index_column.is_a?(Groonga::Accessor)
+          if index_column.have_next?
+            index_column = index_column.next
+          else
+            index_column = index_column.object
+            index_info = index_column.find_index(Operator::CALL)
+            return table.size if index_info.nil?
+            index_column = index_info.index
+          end
+        end
+
         lexicon = index_column.lexicon
         options = {
           :min => min.value,

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

@@ -85,7 +85,7 @@ module Groonga
           stack.push(node)
         when Operator::CALL
           arguments = []
-          code.n_args.times do
+          (code.n_args - 1).times do
             arguments.unshift(stack.pop)
           end
           procedure = stack.pop

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

@@ -15,6 +15,7 @@ require "variable_size_column"
 require "index_column"
 require "accessor"
 require "command"
+require "command_input"
 require "table_cursor"
 require "index_cursor"
 

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

@@ -9,12 +9,12 @@ module Groonga
         message = "#{error.class}: #{error.message}"
       end
       backtrace = error.backtrace
-      last_raw_entry = backtrace.last
-      if last_raw_entry
-        last_entry = BacktraceEntry.parse(last_raw_entry)
-        file = last_entry.file
-        line = last_entry.line
-        method = last_entry.method
+      first_raw_entry = backtrace.first
+      if first_raw_entry
+        first_entry = BacktraceEntry.parse(first_raw_entry)
+        file = first_entry.file
+        line = first_entry.line
+        method = first_entry.method
         # message = "#{file}:#{line}:#{method}: #{message}"
       else
         file = ""
@@ -23,8 +23,7 @@ module Groonga
       end
       log(log_level, file, line, method, message)
 
-      backtrace.reverse_each.with_index do |raw_entry, i|
-        next if i == 0
+      backtrace.each_with_index do |raw_entry, i|
         entry = BacktraceEntry.parse(raw_entry)
         message = entry.message
         message = raw_entry if message.empty?

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

@@ -2,19 +2,13 @@ require "scan_info_data"
 
 module Groonga
   class ScanInfoBuilder
-    module Status
-      START = 0
-      VAR = 1
-      COL1 = 2
-      COL2 = 3
-      CONST = 4
-    end
-
     def initialize(expression, operator, record_exist)
       @data_list = []
       @expression = expression
       @operator = operator
       @record_exist = record_exist
+      @variable = @expression[0]
+      @table = Context.instance[@variable.domain]
     end
 
     RELATION_OPERATORS = [
@@ -61,89 +55,106 @@ module Groonga
     def build
       return nil unless valid?
 
-      status = Status::START
-      variable = @expression[0]
-      data = nil
-      codes = @expression.codes
-      n_codes = codes.size
-      codes.each_with_index do |code, i|
-        case code.op
+      context = BuildContext.new(@expression)
+      codes = context.codes
+      while context.have_next?
+        code = context.code
+        code_op = context.code_op
+        i = context.i
+        context.next
+
+        case code_op
         when *RELATION_OPERATORS
-          status = Status::START
-          data.op = code.op
+          context.status = :start
+          data = context.data
+          data.op = code_op
           data.end = i
           data.match_resolve_index
           @data_list << data
-          data = nil
+          context.data = nil
         when *LOGICAL_OPERATORS
-          if status == Status::CONST
+          if context.status == :const
+            data = context.data
             data.op = Operator::PUSH
             data.end = data.start
             @data_list << data
-            data = nil
+            context.data = nil
           end
-          put_logical_op(code.op, i)
+          put_logical_op(code_op, i)
           # TODO: rescue and return nil
-          status = Status::START
+          context.status = :start
         when Operator::PUSH
-          data ||= ScanInfoData.new(i)
-          if code.value == variable
-            status = Status::VAR
+          context.data ||= ScanInfoData.new(i)
+          data = context.data
+          if code.value == @variable
+            context.status = :var
           else
             data.args << code.value
-            if status == Status::START
+            if context.status == :start
               data.flags |= ScanInfo::Flags::PRE_CONST
             end
-            status = Status::CONST
+            context.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
+            context.data = nil
+            context.status = :start
           end
         when Operator::GET_VALUE
-          case status
-          when Status::START
-            data ||= ScanInfoData.new(i)
-            status = Status::COL1
+          case context.status
+          when :start
+            context.data ||= ScanInfoData.new(i)
+            data = context.data
+            context.status = :column1
             data.args << code.value
-          when Status::CONST, Status::VAR
-            status = Status::COL1
+          when :const, :var
+            context.status = :column1
             data.args << code.value
-          when Status::COL1
-            raise ErrorMessage, "invalid expression: can't use column as a value: <#{code.value.name}>: <#{@expression.grn_inspect}>"
-            status = Status::COL2
-          when Status::COL2
+          when :column1
+            message = "invalid expression: can't use column as a value: "
+            message << "<#{code.value.name}>: <#{@expression.grn_inspect}>"
+            raise ErrorMessage, message
+          when :column2
             # Do nothing
+          else
+            message = "internal expression parsing error: unknown status: "
+            message << "<#{context.status.inspect}>: "
+            message << "<#{@expression.grn_inspect}>"
+            raise ErrorMessage, message
           end
         when Operator::CALL
-          data ||= ScanInfoData.new(i)
+          context.data ||= ScanInfoData.new(i)
+          data = context.data
           if (code.flags & ExpressionCode::Flags::RELATIONAL_EXPRESSION) != 0 or
-              (i + 1) == n_codes
-            status = Status::START
-            data.op = code.op
+              (not context.have_next?)
+            context.status = :start
+            data.op = code_op
             data.end = i
             data.call_relational_resolve_indexes
             @data_list << data
-            data = nil
+            context.data = nil
           else
-            status = Status::COL2
+            context.status = :column2
           end
         when Operator::GET_REF
-          data ||= ScanInfoData.new(i)
-          case status
-          when Status::START
-            data ||= ScanInfoData.new(i)
-            status = Status::COL1
+          context.data ||= ScanInfoData.new(i)
+          case context.status
+          when :start
+            data = context.data
+            context.status = :column1
             data.args << code.value
           end
         when Operator::GET_MEMBER
+          data = context.data
           index = data.args.pop
           data.start_position = index.value
-          status = Status::COL1
+          context.status = :column1
+        when Operator::NOT
+          success = build_not(context, code, i)
+          return nil unless success
         end
       end
 
@@ -157,7 +168,7 @@ module Groonga
           first_data.logical_op = @operator
         end
       else
-        put_logical_op(@operator, n_codes)
+        put_logical_op(@operator, context.n_codes)
       end
 
       optimize
@@ -167,31 +178,32 @@ module Groonga
     def valid?
       n_relation_expressions = 0
       n_logical_expressions = 0
-      status = Status::START
-      variable = @expression[0]
+      status = :start
       codes = @expression.codes
       codes.each_with_index do |code, i|
         case code.op
         when *RELATION_OPERATORS
-          return false if status < Status::COL1
-          return false if status > Status::CONST
-          status = Status::START
+          if status == :start || status == :var
+            return false
+          end
+          status = :start
           n_relation_expressions += 1
         when *ARITHMETIC_OPERATORS
-          return false if status < Status::COL1
-          return false if status > Status::CONST
-          status = Status::START
+          if status == :start || status == :var
+            return false
+          end
+          status = :start
           return false if n_relation_expressions != (n_logical_expressions + 1)
         when *LOGICAL_OPERATORS
           case status
-          when Status::START
+          when :start
             n_logical_expressions += 1
             return false if n_logical_expressions >= n_relation_expressions
-          when Status::CONST
+          when :const
             n_logical_expressions += 1
             n_relation_expressions += 1
             return false if n_logical_expressions >= n_relation_expressions
-            status = Status::START
+            status = :start
           else
             return false
           end
@@ -199,21 +211,21 @@ module Groonga
           if code.modify > 0 and
               LOGICAL_OPERATORS.include?(codes[i + code.modify].op)
             n_relation_expressions += 1
-            status = Status::START
+            status = :start
           else
-            if code.value == variable
-              status = Status::VAR
+            if code.value == @variable
+              status = :var
             else
-              status = Status::CONST
+              status = :const
             end
           end
         when Operator::GET_VALUE
           case status
-          when Status::START, Status::CONST, Status::VAR
-            status = Status::COL1
-          when Status::COL1
-            status = Status::COL2
-          when Status::COL2
+          when :start, :const, :var
+            status = :column1
+          when :column1
+            status = :column2
+          when :column2
             # Do nothing
           else
             return false
@@ -221,32 +233,34 @@ module Groonga
         when Operator::CALL
           if (code.flags & ExpressionCode::Flags::RELATIONAL_EXPRESSION) != 0 or
               code == codes.last
-            status = Status::START
+            status = :start
             n_relation_expressions += 1
           else
-            status = Status::COL2
+            status = :column2
           end
         when Operator::GET_REF
           case status
-          when Status::START
-            status = Status::COL1
+          when :start
+            status = :column1
           else
             return false
           end
         when Operator::GET_MEMBER
           case status
-          when Status::CONST
+          when :const
             return false unless codes[i - 1].value.value.is_a?(Integer)
-            status = Status::COL1
+            status = :column1
           else
             return false
           end
+        when Operator::NOT
+          # Do nothing
         else
           return false
         end
       end
 
-      return false if status != Status::START
+      return false if status != :start
       return false if n_relation_expressions != (n_logical_expressions + 1)
 
       true
@@ -315,6 +329,61 @@ module Groonga
       end
     end
 
+    def build_not(context, code, i)
+      last_data = @data_list.last
+      return false if last_data.nil?
+
+      case last_data.op
+      when Operator::LESS
+        last_data.op = Operator::GREATER_EQUAL
+        last_data.end += 1
+      when Operator::LESS_EQUAL
+        last_data.op = Operator::GREATER
+        last_data.end += 1
+      when Operator::GREATER
+        last_data.op = Operator::LESS_EQUAL
+        last_data.end += 1
+      when Operator::GREATER_EQUAL
+        last_data.op = Operator::LESS
+        last_data.end += 1
+      when Operator::NOT_EQUAL
+        last_data.op = Operator::EQUAL
+        last_data.end += 1
+      else
+        if @data_list.size == 1
+          if last_data.search_indexes.empty?
+            if last_data.op == Operator::EQUAL
+              last_data.op = Operator::NOT_EQUAL
+              last_data.end += 1
+            else
+              return false
+            end
+          else
+            last_data.logical_op = Operator::AND_NOT
+            last_data.flags &= ~ScanInfo::Flags::PUSH
+            @data_list.unshift(create_all_match_data)
+          end
+        else
+          next_code = context.code
+          return false if next_code.nil?
+
+          case next_code.op
+          when Operator::AND
+            context.code_op = Operator::AND_NOT
+          when Operator::AND_NOT
+            context.code_op = Operator::AND
+          when Operator::OR
+            @data_list[-1, 0] = create_all_match_data
+            put_logical_op(Operator::AND_NOT, i)
+          else
+            return false
+          end
+        end
+      end
+
+      true
+    end
+
     def optimize
       optimized_data_list = []
       i = 0
@@ -335,7 +404,45 @@ module Groonga
         end
         optimized_data_list << data
       end
-      optimized_data_list
+
+      optimize_by_estimated_size(optimized_data_list)
+    end
+
+    def optimize_by_estimated_size(data_list)
+      return data_list unless Groonga::ORDER_BY_ESTIMATED_SIZE
+
+      start_index = nil
+      data_list.size.times do |i|
+        data = data_list[i]
+        if data.logical_op != Operator::AND
+          if start_index.nil?
+            start_index = i
+          else
+            sort_by_estimated_size!(data_list, start_index...i)
+            start_index = nil
+          end
+        end
+      end
+      unless start_index.nil?
+        sort_by_estimated_size!(data_list, start_index...data_list.size)
+      end
+      data_list
+    end
+
+    def sort_by_estimated_size!(data_list, range)
+      target_data_list = data_list[range]
+      return if target_data_list.size < 2
+
+      start_logical_op = target_data_list.first.logical_op
+      sorted_data_list = target_data_list.sort_by do |data|
+        estimator = ScanInfoDataSizeEstimator.new(data, @table)
+        estimator.estimate
+      end
+      sorted_data_list.each do |sorted_data|
+        sorted_data.logical_op = Operator::AND
+      end
+      sorted_data_list.first.logical_op = start_logical_op
+      data_list[range] = sorted_data_list
     end
 
     def range_operations?(data, next_data)
@@ -371,6 +478,17 @@ module Groonga
       end
     end
 
+    def create_all_match_data
+      data = ScanInfoData.new(0)
+      data.end = 0
+      data.flags = ScanInfo::Flags::PUSH
+      data.op = Operator::CALL
+      data.logical_op = Operator::OR
+      data.args = [Context.instance["all_records"]]
+      data.search_indexes = []
+      data
+    end
+
     def create_between_data(data, next_data)
       between_data = ScanInfoData.new(data.start)
       between_data.end = next_data.end + 1
@@ -418,5 +536,41 @@ module Groonga
         @expression.allocate_constant(max_border),
       ]
     end
+
+    class BuildContext
+      attr_accessor :status
+      attr_reader :codes
+      attr_reader :n_codes
+      attr_reader :i
+      attr_writer :code_op
+      attr_accessor :data
+      def initialize(expression)
+        @expression = expression
+        @status = :start
+        @current_data = nil
+        @codes = @expression.codes
+        @n_codes = @codes.size
+        @i = 0
+        @code_op = nil
+        @data = nil
+      end
+
+      def have_next?
+        @i < @n_codes
+      end
+
+      def next
+        @i += 1
+        @code_op = nil
+      end
+
+      def code
+        @codes[@i]
+      end
+
+      def code_op
+        @code_op || code.op
+      end
+    end
   end
 end