rroonga 0.9.2-x86-mingw32

data/lib/groonga.rb

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require 'pathname'
+
+base_dir = Pathname.new(__FILE__).dirname.dirname.expand_path
+local_groonga_dir = base_dir + "vendor" + "local"
+local_groonga_bin_dir = local_groonga_dir + "bin"
+if local_groonga_bin_dir.exist?
+  prepend_path = Proc.new do |environment_name, separator|
+    paths = (ENV[environment_name] || '').split(/#{separator}/)
+    dir = local_groonga_bin_dir.to_s
+    dir = dir.gsub(/\//, File::ALT_SEPARATOR) if File::ALT_SEPARATOR
+    unless paths.include?(dir)
+      paths = [dir] + paths
+      ENV[environment_name] = paths.join(separator)
+    end
+  end
+
+  case RUBY_PLATFORM
+  when /mingw|mswin/
+    prepend_path.call("PATH", ";")
+  when /cygwin/
+    prepend_path.call("PATH", ":")
+  end
+end
+
+require 'groonga/view-record'
+require 'groonga/record'
+require 'groonga/expression-builder'
+require 'groonga.so'
+
+##
+# Ruby/groonga用のネームスペース。Ruby/groongaのクラスやメソッ
+# ドなどはこのモジュール以下に定義される。
+module Groonga
+  class << self
+    ##
+    # BUILD_VERSIONを"."で結合して<tt>"メジャーバージョン.マ
+    # イナーバージョン.マイクロバージョン"</tt>という形式の
+    # 文字列にしたもの。
+    def build_version
+      BUILD_VERSION.join(".")
+    end
+
+    ##
+    # VERSIONを"."で結合して<tt>"メジャーバージョン.マイナー
+    # バージョン.マイクロバージョン"</tt>という形式の文字列に
+    # したもの。
+    def version
+      VERSION.join(".")
+    end
+
+    ##
+    # BINDINGS_VERSIONを"."で結合して<tt>"メジャーバージョン.マ
+    # イナーバージョン.マイクロバージョン"</tt>という形式の文
+    # 字列にしたもの。
+    def bindings_version
+      BINDINGS_VERSION.join(".")
+    end
+
+    ##
+    # call-seq:
+    #   Groonga[name] -> Groonga::Object or nil
+    #   Groonga[id]   -> Groonga::Object or nil
+    #
+    # 便利メソッド。Groonga::Context.default[name]と同じ。
+    def [](name)
+      Context.default[name]
+    end
+  end
+end
+
+require 'groonga/context'
+require 'groonga/patricia-trie'
+require 'groonga/schema'

data/lib/groonga/context.rb

@@ -0,0 +1,184 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2010  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+module Groonga
+  class Context
+    # call-seq:
+    #   context.select(table, options={}) -> SelectResult
+    #
+    # _table_から指定した条件にマッチするレコードの値を取得
+    # する。_table_はテーブル名かテーブルオブジェクトを指定
+    # する。
+    #
+    # _options_に指定できるキーは以下の通り。
+    #
+    # [_output_columns_] 値を取得するカラムを指定する。
+    # [_XXX_] TODO
+    #
+    # 例:
+    #   TODO
+    def select(table, options={})
+      select = SelectCommand.new(self, table, options)
+      select.exec
+    end
+
+    class SelectResult < Struct.new(:return_code, :start_time, :elapsed,
+                                    :error_message,
+                                    :n_hits, :columns, :values,
+                                    :drill_down)
+      class << self
+        def parse(json, drill_down_keys)
+          status, (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
+          result.values = values
+          if drill_down_results
+            result.drill_down = parse_drill_down_results(drill_down_results,
+                                                         drill_down_keys)
+          end
+          result
+        end
+
+        def create_records(columns, values)
+          records = []
+          values.each do |value|
+            record = {}
+            columns.each_with_index do |(name, type), i|
+              record[name] = convert_value(value[i], type)
+            end
+            records << record
+          end
+          records
+        end
+
+        private
+        def parse_drill_down_results(results, keys)
+          named_results = {}
+          results.each_with_index do |drill_down, i|
+            n_hits, columns, values = extract_result(drill_down)
+            drill_down_result = DrillDownResult.new
+            drill_down_result.n_hits = n_hits
+            drill_down_result.columns = columns
+            drill_down_result.values = values
+            named_results[keys[i]] = drill_down_result
+          end
+          named_results
+        end
+
+        def extract_result(result)
+          meta_data, columns, *values = result
+          n_hits, = meta_data
+          [n_hits, columns, values]
+        end
+
+        def convert_value(value, type)
+          case type
+          when "Time"
+            Time.at(value)
+          else
+            value
+          end
+        end
+
+        begin
+          require 'json'
+          def parse_json(json)
+            JSON.parse(json)
+          end
+        rescue LoadError
+          require 'yaml'
+          def parse_json(json)
+            YAML.load(json)
+          end
+        end
+      end
+
+      def records
+        @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)
+        end
+      end
+    end
+
+    class SelectCommand
+      def initialize(context, table, options)
+        @context = context
+        @table = table
+        @options = normalize_options(options)
+      end
+
+      def exec
+        request_id = @context.send(query)
+        loop do
+          response_id, result = @context.receive
+          if request_id == response_id
+            drill_down_keys = @options["drilldown"]
+            if drill_down_keys.is_a?(String)
+              drill_down_keys = drill_down_keys.split(/(?:\s+|\s*,\s*)/)
+            end
+            return SelectResult.parse(result, drill_down_keys)
+          end
+          # raise if request_id < response_id
+        end
+      end
+
+      private
+      def normalize_options(options)
+        normalized_options = {}
+        options.each do |key, value|
+          normalized_options[normalize_option_name(key)] = value
+        end
+        normalized_options
+      end
+
+      def normalize_option_name(name)
+        name = name.to_s.gsub(/-/, "_").gsub(/drill_down/, "drilldown")
+        name.gsub(/sort_by/, 'sortby')
+      end
+
+      def query
+        if @table.is_a?(String)
+          table_name = @table
+        else
+          table_name = @table.name
+        end
+        _query = "select #{table_name}"
+        @options.each do |key, value|
+          value = value.join(", ") if value.is_a?(::Array)
+          escaped_value = value.to_s.gsub(/"/, '\\"')
+          _query << " --#{key} \"#{escaped_value}\""
+        end
+        _query
+      end
+    end
+  end
+end

data/lib/groonga/expression-builder.rb

@@ -0,0 +1,324 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+module Groonga
+  module ExpressionBuildable # :nodoc:
+    attr_reader :table
+    attr_accessor :query
+    attr_accessor :syntax
+    attr_accessor :allow_pragma
+    attr_accessor :allow_column
+    attr_accessor :allow_update
+    attr_accessor :default_column
+
+    VALID_COLUMN_NAME_RE = /\A[a-zA-Z\d_]+\z/
+
+    def initialize(*args)
+      @table = nil
+      @name = nil
+      @query = nil
+      @syntax = nil
+      @allow_pragma = nil
+      @allow_column = nil
+      @allow_update = nil
+      @default_column = nil
+    end
+
+    def build
+      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
+    end
+
+    def &(other)
+      other
+    end
+
+    def |(other)
+      other
+    end
+
+    private
+    def default_parse_options
+      {
+        :syntax => @syntax,
+        :allow_pragma => @allow_pragma,
+        :allow_column => @allow_column,
+        :allow_update => @allow_update,
+        :default_column => @default_column,
+      }
+    end
+
+    class ExpressionBuilder # :nodoc:
+      def initialize
+        super()
+      end
+
+      def &(other)
+        AndExpressionBuilder.new(self, other)
+      end
+
+      def |(other)
+        OrExpressionBuilder.new(self, other)
+      end
+    end
+
+    class SetExpressionBuilder < ExpressionBuilder # :nodoc:
+      def initialize(operation, *expression_builders)
+        super()
+        @operation = operation
+        @expression_builders = expression_builders
+      end
+
+      def build(expression, variable)
+        return if @expression_builders.empty?
+        @expression_builders.each do |builder|
+          builder.build(expression, variable)
+        end
+        expression.append_operation(@operation, @expression_builders.size)
+      end
+    end
+
+    class AndExpressionBuilder < SetExpressionBuilder # :nodoc:
+      def initialize(*expression_builders)
+        super(Groonga::Operation::AND, *expression_builders)
+      end
+    end
+
+    class OrExpressionBuilder < SetExpressionBuilder # :nodoc:
+      def initialize(*expression_builders)
+        super(Groonga::Operation::OR, *expression_builders)
+      end
+    end
+
+    class BinaryExpressionBuilder < ExpressionBuilder # :nodoc:
+      def initialize(operation, column, value)
+        super()
+        @operation = operation
+        @default_column = column
+        @value = value
+      end
+
+      def build(expression, variable)
+        expression.append_object(variable)
+        if @default_column.is_a?(String)
+          expression.append_constant(@default_column)
+        else
+          expression.append_object(@default_column)
+        end
+        expression.append_operation(Groonga::Operation::GET_VALUE, 2)
+        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)
+      end
+    end
+
+    class MatchExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column, value)
+        super(Groonga::Operation::MATCH, column, value)
+      end
+    end
+
+    class LessExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column, value)
+        super(Groonga::Operation::LESS, column, value)
+      end
+    end
+
+    class LessEqualExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column, value)
+        super(Groonga::Operation::LESS_EQUAL, column, value)
+      end
+    end
+
+    class GreaterExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column, value)
+        super(Groonga::Operation::GREATER, column, value)
+      end
+    end
+
+    class GreaterEqualExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column, value)
+        super(Groonga::Operation::GREATER_EQUAL, column, value)
+      end
+    end
+
+    class SubExpressionBuilder < ExpressionBuilder # :nodoc:
+      def initialize(query, options)
+        super()
+        @query = query
+        @options = options
+      end
+
+      def build(expression, variable)
+        expression.parse(@query, @options)
+      end
+    end
+  end
+
+  class RecordExpressionBuilder # :nodoc:
+    include ExpressionBuildable
+
+    def initialize(table, name)
+      super()
+      @table = table
+      @name = name
+    end
+
+    def [](name)
+      column = @table.column(name)
+      if column.nil?
+        message = "unknown column <#{name.inspect}> " +
+          "for table <#{@table.inspect}>"
+        raise ArgumentError, message
+      end
+      ColumnExpressionBuilder.new(column, nil, nil,
+                                  :table => @table,
+                                  :column_name => name)
+    end
+
+    def id
+      self["_id"]
+    end
+
+    def key
+      self["_key"]
+    end
+
+    def score
+      self["_score"]
+    end
+
+    def n_sub_records
+      self["_nsubrecs"]
+    end
+
+    def match(query, options_or_default_column={})
+      if options_or_default_column.is_a?(String)
+        options = {:default_column => options_or_default_column}
+      else
+        options = options_or_default_column
+      end
+      options = options.dup
+      options[:syntax] ||= :query
+      SubExpressionBuilder.new(query, options)
+    end
+
+    private
+    def method_missing(name, *args, &block)
+      return super if block
+      return super unless args.empty?
+      if VALID_COLUMN_NAME_RE =~ name.to_s
+        self[name]
+      else
+        super
+      end
+    end
+  end
+
+  class ColumnExpressionBuilder # :nodoc:
+    include ExpressionBuildable
+
+    def initialize(column, name, query, options={})
+      super()
+      @table = options[:table] || column.table
+      @default_column = column
+      @column_name = options[:column_name] || @default_column.local_name
+      @range = @default_column.range
+      @name = name
+      @query = query
+    end
+
+    def ==(other)
+      EqualExpressionBuilder.new(@default_column, 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(@default_column, normalize(other))
+    end
+
+    def <(other)
+      LessExpressionBuilder.new(@default_column, normalize(other))
+    end
+
+    def <=(other)
+      LessEqualExpressionBuilder.new(@default_column, normalize(other))
+    end
+
+    def >(other)
+      GreaterExpressionBuilder.new(@default_column, normalize(other))
+    end
+
+    def >=(other)
+      GreaterEqualExpressionBuilder.new(@default_column, 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
+end