rroonga 0.9.4-x86-mingw32 → 0.9.5-x86-mingw32

data/lib/groonga.rb

@@ -31,12 +31,7 @@ if local_groonga_bin_dir.exist?
     end
   end
 
-  case RUBY_PLATFORM
-  when /mingw|mswin/
-    prepend_path.call("PATH", ";")
-  when /cygwin/
-    prepend_path.call("PATH", ":")
-  end
+  prepend_path.call("PATH", File::PATH_SEPARATOR)
 end
 
 require 'groonga/view-record'
@@ -50,7 +45,7 @@ rescue LoadError
 end
 
 ##
-# Ruby/groonga用のネームスペース。Ruby/groongaのクラスやメソッ
+# rroonga用のネームスペース。rroongaのクラスやメソッ
 # ドなどはこのモジュール以下に定義される。
 module Groonga
   class << self
@@ -93,3 +88,4 @@ end
 require 'groonga/context'
 require 'groonga/patricia-trie'
 require 'groonga/schema'
+require 'groonga/pagination'

data/lib/groonga/context.rb

@@ -36,19 +36,12 @@ module Groonga
       select.exec
     end
 
-    class SelectResult < Struct.new(:return_code, :start_time, :elapsed,
-                                    :error_message,
-                                    :n_hits, :columns, :values,
+    class SelectResult < Struct.new(:n_hits, :columns, :values,
                                     :drill_down)
       class << self
         def parse(json, drill_down_keys)
-          status, (select_result, *drill_down_results) = parse_json(json)
+          select_result, *drill_down_results = parse_json(json)
           result = new
-          return_code, start_time, elapsed, error_message = status
-          result.return_code = return_code
-          result.start_time = Time.at(start_time)
-          result.elapsed = elapsed
-          result.error_message = error_message
           n_hits, columns, values = extract_result(select_result)
           result.n_hits = n_hits
           result.columns = columns
@@ -118,10 +111,6 @@ module Groonga
         @records ||= self.class.create_records(columns, values)
       end
 
-      def success?
-        return_code.zero?
-      end
-
       class DrillDownResult < Struct.new(:n_hits, :columns, :values)
         def records
           @records ||= SelectResult.create_records(columns, values)

data/lib/groonga/expression-builder.rb

@@ -38,29 +38,10 @@ module Groonga
       @default_column = nil
     end
 
-    def build
+    def build(&block)
       expression = Expression.new(:name => @name)
       variable = expression.define_variable(:domain => @table)
-
-      builder = nil
-      builder = match(@query, default_parse_options) if @query
-      if block_given?
-        if builder
-          builder &= yield(self)
-        else
-          builder = yield(self)
-        end
-      end
-      if builder.nil? or builder == self
-        expression.append_constant(1)
-        expression.append_constant(1)
-        expression.append_operation(Groonga::Operation::OR, 2)
-      else
-        builder.build(expression, variable)
-      end
-
-      expression.compile
-      expression
+      build_expression(expression, variable, &block)
     end
 
     def &(other)
@@ -82,6 +63,37 @@ module Groonga
       }
     end
 
+    def build_expression(expression, variable)
+      builders = []
+      builders << match(@query, default_parse_options) if @query
+      if block_given?
+        custom_builder = yield(self)
+        if custom_builder.is_a?(::Array)
+          builders.concat(custom_builder)
+        else
+          builders << custom_builder
+        end
+      end
+
+      if builders.empty? or builders == [self]
+        expression.append_constant(1)
+        expression.append_constant(1)
+        expression.append_operation(Groonga::Operation::OR, 2)
+      else
+        combined_builder = builders.inject(nil) do |previous, builder|
+          if previous.nil?
+            builder
+          else
+            previous & builder
+          end
+        end
+        combined_builder.build(expression, variable)
+      end
+
+      expression.compile
+      expression
+    end
+
     class ExpressionBuilder # :nodoc:
       def initialize
         super()
@@ -124,60 +136,215 @@ module Groonga
       end
     end
 
-    class BinaryExpressionBuilder < ExpressionBuilder # :nodoc:
-      def initialize(operation, column, value)
+    class ColumnValueExpressionBuilder < ExpressionBuilder # :nodoc:
+      def initialize(column, options={})
         super()
-        @operation = operation
-        @default_column = column
-        @value = value
+        @table = options[:table] || column.table
+        @column = column
+        @column_name = options[:column_name] || @column.local_name
+        @range = options[:range] || @column.range
+        @name = options[:name]
       end
 
       def build(expression, variable)
         expression.append_object(variable)
-        if @default_column.is_a?(String)
-          expression.append_constant(@default_column)
+        if @column.is_a?(String)
+          expression.append_constant(@column)
+        else
+          expression.append_object(@column)
+        end
+        expression.append_operation(Groonga::Operation::GET_VALUE, 2)
+      end
+
+      def ==(other)
+        EqualExpressionBuilder.new(self, normalize(other))
+      end
+
+      def =~(other)
+        if other.nil?
+          full_column_name = "#{@table.name}.#{@column_name}"
+          raise ArgumentError,
+                 "match word should not be nil: #{full_column_name}"
+        end
+        MatchExpressionBuilder.new(self, normalize(other))
+      end
+
+      def <(other)
+        LessExpressionBuilder.new(self, normalize(other))
+      end
+
+      def <=(other)
+        LessEqualExpressionBuilder.new(self, normalize(other))
+      end
+
+      def >(other)
+        GreaterExpressionBuilder.new(self, normalize(other))
+      end
+
+      def >=(other)
+        GreaterEqualExpressionBuilder.new(self, normalize(other))
+      end
+
+      def +(other)
+        PlusExpressionBuilder.new(self, normalize(other))
+      end
+
+      def -(other)
+        MinusExpressionBuilder.new(self, normalize(other))
+      end
+
+      def *(other)
+        StarExpressionBuilder.new(self, normalize(other))
+      end
+
+      def /(other)
+        SlashExpressionBuilder.new(self, normalize(other))
+      end
+
+      def %(other)
+        ModExpressionBuilder.new(self, normalize(other))
+      end
+
+      def match(query, options={})
+        options = options.dup
+        options[:syntax] ||= :query
+        options[:default_column] = @column_name
+        SubExpressionBuilder.new(query, options)
+      end
+
+      private
+      def normalize(other)
+        if @range.is_a?(Groonga::Table) and other.is_a?(Integer)
+          Groonga::Record.new(@range, other)
+        else
+          other
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        return super if block
+        return super unless args.empty?
+        if VALID_COLUMN_NAME_RE =~ name.to_s
+          RecordExpressionBuilder.new(@table, @name)["#{@column_name}.#{name}"]
+        else
+          super
+        end
+      end
+    end
+
+    class MatchTargetColumnExpressionBuilder < ColumnValueExpressionBuilder # :nodoc:
+      def build(expression, variable)
+        if @column.is_a?(String)
+          expression.append_constant(@column)
         else
-          expression.append_object(@default_column)
+          expression.append_object(@column)
         end
+      end
+
+      private
+      def normalize(other)
+        other
+      end
+    end
+
+    class MatchTargetExpressionBuilder < ExpressionBuilder # :nodoc:
+      def initialize(target)
+        super()
+        @target = target
+      end
+
+      def build(expression, variable)
+        expression.append_object(variable)
+        expression.append_object(@target)
         expression.append_operation(Groonga::Operation::GET_VALUE, 2)
+      end
+
+      def =~(query)
+        if query.nil?
+          raise ArgumentError, "match word should not be nil"
+        end
+        MatchExpressionBuilder.new(self, query)
+      end
+    end
+
+    class BinaryExpressionBuilder < ExpressionBuilder # :nodoc:
+      def initialize(operation, column_value_builder, value)
+        super()
+        @operation = operation
+        @column_value_builder = column_value_builder
+        @value = value
+      end
+
+      def build(expression, variable)
+        @column_value_builder.build(expression, variable)
         expression.append_constant(@value)
         expression.append_operation(@operation, 2)
       end
     end
 
     class EqualExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::EQUAL, column, value)
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::EQUAL, column_value_builder, value)
       end
     end
 
     class MatchExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::MATCH, column, value)
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::MATCH, column_value_builder, value)
       end
     end
 
     class LessExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::LESS, column, value)
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::LESS, column_value_builder, value)
       end
     end
 
     class LessEqualExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::LESS_EQUAL, column, value)
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::LESS_EQUAL, column_value_builder, value)
       end
     end
 
     class GreaterExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::GREATER, column, value)
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::GREATER, column_value_builder, value)
       end
     end
 
     class GreaterEqualExpressionBuilder < BinaryExpressionBuilder # :nodoc:
-      def initialize(column, value)
-        super(Groonga::Operation::GREATER_EQUAL, column, value)
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::GREATER_EQUAL, column_value_builder, value)
+      end
+    end
+
+    class PlusExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::PLUS, column_value_builder, value)
+      end
+    end
+
+    class MinusExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::MINUS, column_value_builder, value)
+      end
+    end
+
+    class StarExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::STAR, column_value_builder, value)
+      end
+    end
+
+    class SlashExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::SLASH, column_value_builder, value)
+      end
+    end
+
+    class ModExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::MOD, column_value_builder, value)
       end
     end
 
@@ -210,9 +377,7 @@ module Groonga
           "for table <#{@table.inspect}>"
         raise ArgumentError, message
       end
-      ColumnExpressionBuilder.new(column, nil, nil,
-                                  :table => @table,
-                                  :column_name => name)
+      column_expression_builder(column, name)
     end
 
     def id
@@ -231,7 +396,7 @@ module Groonga
       self["_nsubrecs"]
     end
 
-    def match(query, options_or_default_column={})
+    def match(query, options_or_default_column={}, &block)
       if options_or_default_column.is_a?(String)
         options = {:default_column => options_or_default_column}
       else
@@ -239,10 +404,30 @@ module Groonga
       end
       options = options.dup
       options[:syntax] ||= :query
+      if block_given? and options[:default_column].nil?
+        options[:default_column] = build_match_target(&block)
+      end
       SubExpressionBuilder.new(query, options)
     end
 
+    def match_target(&block)
+      MatchTargetExpressionBuilder.new(build_match_target(&block))
+    end
+
     private
+    def build_match_target(&block)
+      sub_builder = MatchTargetRecordExpressionBuilder.new(@table, nil)
+      sub_builder.build do |record|
+        block.call(record)
+      end
+    end
+
+    def column_expression_builder(column, name)
+      ColumnValueExpressionBuilder.new(column,
+                                       :table => @table,
+                                       :column_name => name)
+    end
+
     def method_missing(name, *args, &block)
       return super if block
       return super unless args.empty?
@@ -254,6 +439,15 @@ module Groonga
     end
   end
 
+  class MatchTargetRecordExpressionBuilder < RecordExpressionBuilder # :nodoc:
+    private
+    def column_expression_builder(column, name)
+      MatchTargetColumnExpressionBuilder.new(column,
+                                             :table => @table,
+                                             :column_name => name)
+    end
+  end
+
   class ColumnExpressionBuilder # :nodoc:
     include ExpressionBuildable
 
@@ -268,54 +462,66 @@ module Groonga
     end
 
     def ==(other)
-      EqualExpressionBuilder.new(@default_column, normalize(other))
+      column_value_builder == other
     end
 
     def =~(other)
-      if other.nil?
-        full_column_name = "#{@table.name}.#{@column_name}"
-        raise ArgumentError, "match word should not be nil: #{full_column_name}"
-      end
-      MatchExpressionBuilder.new(@default_column, normalize(other))
+      column_value_builder =~ other
     end
 
     def <(other)
-      LessExpressionBuilder.new(@default_column, normalize(other))
+      column_value_builder < other
     end
 
     def <=(other)
-      LessEqualExpressionBuilder.new(@default_column, normalize(other))
+      column_value_builder <= other
     end
 
     def >(other)
-      GreaterExpressionBuilder.new(@default_column, normalize(other))
+      column_value_builder > other
     end
 
     def >=(other)
-      GreaterEqualExpressionBuilder.new(@default_column, normalize(other))
+      column_value_builder >= other
     end
 
-    def match(query, options={})
-      options = options.dup
-      options[:syntax] ||= :query
-      options[:default_column] = @column_name
-      SubExpressionBuilder.new(query, options)
+    def +(other)
+      column_value_builder + other
+    end
+
+    def -(other)
+      column_value_builder - other
+    end
+
+    def *(other)
+      column_value_builder * other
+    end
+
+    def /(other)
+      column_value_builder / other
+    end
+
+    def %(other)
+      column_value_builder % other
+    end
+
+    def match(query, options={}, &block)
+      column_value_builder.match(query, options, &block)
     end
 
     private
-    def normalize(other)
-      if @range.is_a?(Groonga::Table) and other.is_a?(Integer)
-        Groonga::Record.new(@range, other)
-      else
-        other
-      end
+    def column_value_builder
+      ColumnValueExpressionBuilder.new(@default_column,
+                                       :table => @table,
+                                       :column_name => @column_name,
+                                       :range => @range)
     end
 
     def method_missing(name, *args, &block)
       return super if block
       return super unless args.empty?
       if VALID_COLUMN_NAME_RE =~ name.to_s
-        RecordExpressionBuilder.new(@table, @name)["#{@column_name}.#{name}"]
+        column_value_builder.send(name)
       else
         super
       end