groonga 0.0.7 → 0.9.0

data/lib/groonga.rb

@@ -66,6 +66,16 @@ module Groonga
     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
 

data/lib/groonga/expression-builder.rb

@@ -16,14 +16,23 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 module Groonga
-  module ExpressionBuildable
+  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
 
     def initialize(*args)
       @table = nil
       @name = nil
       @query = nil
+      @syntax = nil
+      @allow_pragma = nil
+      @allow_column = nil
+      @allow_update = nil
       @default_column = nil
     end
 
@@ -32,7 +41,7 @@ module Groonga
       variable = expression.define_variable(:domain => @table)
 
       builder = nil
-      builder = match(@query) if @query
+      builder = match(@query, default_parse_options) if @query
       if block_given?
         if builder
           builder &= yield(self)
@@ -52,7 +61,26 @@ module Groonga
       expression
     end
 
-    class ExpressionBuilder
+    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
@@ -66,7 +94,7 @@ module Groonga
       end
     end
 
-    class SetExpressionBuilder < ExpressionBuilder
+    class SetExpressionBuilder < ExpressionBuilder # :nodoc:
       def initialize(operation, *expression_builders)
         super()
         @operation = operation
@@ -82,72 +110,76 @@ module Groonga
       end
     end
 
-    class AndExpressionBuilder < SetExpressionBuilder
+    class AndExpressionBuilder < SetExpressionBuilder # :nodoc:
       def initialize(*expression_builders)
         super(Groonga::Operation::AND, *expression_builders)
       end
     end
 
-    class OrExpressionBuilder < SetExpressionBuilder
+    class OrExpressionBuilder < SetExpressionBuilder # :nodoc:
       def initialize(*expression_builders)
         super(Groonga::Operation::OR, *expression_builders)
       end
     end
 
-    class BinaryExpressionBuilder < ExpressionBuilder
-      def initialize(operation, column_name, value)
+    class BinaryExpressionBuilder < ExpressionBuilder # :nodoc:
+      def initialize(operation, column, value)
         super()
         @operation = operation
-        @column_name = column_name
+        @default_column = column
         @value = value
       end
 
       def build(expression, variable)
         expression.append_object(variable)
-        expression.append_constant(@column_name)
+        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
-      def initialize(column_name, value)
-        super(Groonga::Operation::EQUAL, column_name, value)
+    class EqualExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column, value)
+        super(Groonga::Operation::EQUAL, column, value)
       end
     end
 
-    class MatchExpressionBuilder < BinaryExpressionBuilder
-      def initialize(column_name, value)
-        super(Groonga::Operation::MATCH, column_name, value)
+    class MatchExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column, value)
+        super(Groonga::Operation::MATCH, column, value)
       end
     end
 
-    class LessExpressionBuilder < BinaryExpressionBuilder
-      def initialize(column_name, value)
-        super(Groonga::Operation::LESS, column_name, value)
+    class LessExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column, value)
+        super(Groonga::Operation::LESS, column, value)
       end
     end
 
-    class LessEqualExpressionBuilder < BinaryExpressionBuilder
-      def initialize(column_name, value)
-        super(Groonga::Operation::LESS_EQUAL, column_name, value)
+    class LessEqualExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column, value)
+        super(Groonga::Operation::LESS_EQUAL, column, value)
       end
     end
 
-    class GreaterExpressionBuilder < BinaryExpressionBuilder
-      def initialize(column_name, value)
-        super(Groonga::Operation::GREATER, column_name, value)
+    class GreaterExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column, value)
+        super(Groonga::Operation::GREATER, column, value)
       end
     end
 
-    class GreaterEqualExpressionBuilder < BinaryExpressionBuilder
-      def initialize(column_name, value)
-        super(Groonga::Operation::GREATER_EQUAL, column_name, value)
+    class GreaterEqualExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column, value)
+        super(Groonga::Operation::GREATER_EQUAL, column, value)
       end
     end
 
-    class SubExpressionBuilder < ExpressionBuilder
+    class SubExpressionBuilder < ExpressionBuilder # :nodoc:
       def initialize(query, options)
         super()
         @query = query
@@ -160,7 +192,7 @@ module Groonga
     end
   end
 
-  class RecordExpressionBuilder
+  class RecordExpressionBuilder # :nodoc:
     include ExpressionBuildable
 
     def initialize(table, name)
@@ -176,7 +208,9 @@ module Groonga
           "for table <#{@table.inspect}>"
         raise ArgumentError, message
       end
-      ColumnExpressionBuilder.new(column, nil, nil)
+      ColumnExpressionBuilder.new(column, nil, nil,
+                                  :table => @table,
+                                  :column_name => name)
     end
 
     def match(query, options_or_default_column={})
@@ -185,20 +219,21 @@ module Groonga
       else
         options = options_or_default_column
       end
-      default_options = {:parser => :table}
-      SubExpressionBuilder.new(query, default_options.merge(options))
+      options = options.dup
+      options[:syntax] ||= :query
+      SubExpressionBuilder.new(query, options)
     end
   end
 
-  class ColumnExpressionBuilder
+  class ColumnExpressionBuilder # :nodoc:
     include ExpressionBuildable
 
-    def initialize(column, name, query)
+    def initialize(column, name, query, options={})
       super()
-      @table = column.table
-      @range = column.range
-      @column = column
-      @default_column = column.local_name
+      @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
@@ -208,6 +243,10 @@ module Groonga
     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
 
@@ -228,9 +267,9 @@ module Groonga
     end
 
     def match(query, options={})
-      default_options = {:parser => :table}
-      ensure_options = {:default_column => @default_column}
-      options = default_options.merge(options).merge(ensure_options)
+      options = options.dup
+      options[:syntax] ||= :query
+      options[:default_column] = @column_name
       SubExpressionBuilder.new(query, options)
     end
 

data/lib/groonga/patricia-trie.rb

@@ -17,6 +17,14 @@
 
 module Groonga
   class PatriciaTrie
+    # call-seq:
+    #   patricia_trie.tag_keys(text) {|record, word| ...} -> String
+    #
+    # _text_を走査し、レコードのキーとマッチする部分文字列ごとに
+    # そのレコードが_record_として、その部分文字列が_word_として、
+    # ブロックが呼び出される。ブロックから返された文字列が元の部
+    # 分文字列と置換される。全てのヒットに対してのその置換処理が
+    # 行われた文字列が返される。
     def tag_keys(text)
       position = 0
       result = ''
@@ -34,6 +42,11 @@ module Groonga
         result << yield(record, word)
         position = start + length
       end
+      last_text = bytes[position..-1]
+      unless last_text.empty?
+        last_text.force_encoding(encoding) if encoding
+        result << last_text
+      end
       result
     end
   end

data/lib/groonga/record.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+# 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
@@ -17,7 +17,18 @@
 
 module Groonga
   class Record
-    attr_reader :table, :id
+    # レコードが所属するテーブル
+    attr_reader :table
+    # レコードのID
+    attr_reader :id
+    # _table_の_id_に対応するレコードを作成する。_values_には各
+    # カラムに設定する値を以下のような形式で指定する。
+    #
+    #   [
+    #    ["カラム名", 値],
+    #    ["カラム名", 値],
+    #    ...,
+    #   ]
     def initialize(table, id, values=nil)
       @table = table
       @id = id
@@ -28,103 +39,237 @@ module Groonga
       end
     end
 
+    # call-seq:
+    #   record == other -> true/false
+    #
+    # _record_と_other_が同じgroongaのレコードなら+true+を返し、
+    # そうでなければ+false+を返す。
     def ==(other)
       self.class == other.class and
         [table, id] == [other.table, other.id]
     end
 
+    # call-seq:
+    #   record[column_name] -> 値
+    #
+    # このレコードの_column_name_で指定されたカラムの値を返す。
     def [](column_name)
-      column(column_name)[@id]
+      @table.column_value(@id, column_name, :id => true)
     end
 
+    # call-seq:
+    #   record[column_name] = 値
+    #
+    # このレコードの_column_name_で指定されたカラムの値を設定す
+    # る。
     def []=(column_name, value)
-      column(column_name)[@id] = value
+      @table.set_column_value(@id, column_name, value, :id => true)
     end
 
+    # call-seq:
+    #   record.append(column_name, value)
+    #
+    # このレコードの_column_name_で指定されたカラムの値の最後に
+    # _value_を追加する。
     def append(column_name, value)
       column(column_name).append(@id, value)
     end
 
+    # call-seq:
+    #   record.prepend(column_name, value)
+    #
+    # このレコードの_column_name_で指定されたカラムの値の最初に
+    # _value_を追加する。
     def prepend(column_name, value)
       column(column_name).prepend(@id, value)
     end
 
+    # call-seq:
+    #   record.have_column?(name) -> true/false
+    #
+    # 名前が_name_のカラムがレコードの所属するテーブルで定義され
+    # ているなら+true+を返す。
     def have_column?(name)
       column(name).is_a?(Groonga::Column)
-    rescue Groonga::InvalidArgument
+    rescue Groonga::NoSuchColumn
       false
     end
 
+    # call-seq:
+    #   record.reference_column?(name) -> true/false
+    #
+    # 名前が_name_のカラムが参照カラムであるなら+true+を返す。
     def reference_column?(name)
       column(name).range.is_a?(Groonga::Table)
     end
 
+    # call-seq:
+    #   record.search(name, query, options={}) -> Groonga::Hash
+    #
+    # 名前が_name_のGroonga::IndexColumnのsearchメソッドを呼ぶ。
+    # _query_と_options_はそのメソッドにそのまま渡される。詳しく
+    # はGroonga::IndexColumn#searchを参照。
     def search(name, query, options={})
       column(name).search(query, options)
     end
 
+    # call-seq:
+    #   record.key -> 主キー
+    #
+    # レコードの主キーを返す。
+    #
+    # _record_が所属するテーブルがGroonga:::Arrayの場合は常
+    # に+nil+を返す。
     def key
-      @table.key(@id)
+      if @table.is_a?(Groonga::Array)
+        nil
+      else
+        @key ||= @table.key(@id)
+      end
     end
 
+    # call-seq:
+    #   record.score -> スコア値
+    #
+    # レコードのスコア値を返す。検索結果として生成されたテーブル
+    # のみに定義される。
     def score
-      self[".:score"]
+      self["._score"]
+    end
+
+    # call-seq:
+    #   record.n_sub_records -> 件数
+    #
+    # 主キーの値が同一であったレコードの件数を返す。検索結果とし
+    # て生成されたテーブルのみに定義される。
+    def n_sub_records
+      self["._nsubrecs"]
     end
 
+    # call-seq:
+    #   record.value -> 値
+    #
+    # レコードの値を返す。
     def value
-      @table[@id]
+      @table.value(@id, :id => true)
     end
 
+    # call-seq:
+    #   record.value = 値
+    #
+    # レコードの値を設定する。既存の値は上書きされる。
     def value=(value)
-      @table[@id] = value
+      @table.set_value(@id, value, :id => true)
     end
 
+    # call-seq:
+    #   record.increment!(name, delta=nil)
+    #
+    # このレコードの_name_で指定されたカラムの値を_delta_だけ増
+    # 加する。_delta_が+nil+の場合は1増加する。
     def increment!(name, delta=nil)
       column(name).increment!(@id, delta)
     end
 
+    # call-seq:
+    #   record.decrement!(name, delta=nil)
+    #
+    # このレコードの_name_で指定されたカラムの値を_delta_だけ減
+    # 少する。_delta_が+nil+の場合は1減少する。
     def decrement!(name, delta=nil)
       column(name).decrement!(@id, delta)
     end
 
+    # call-seq:
+    #   record.columns -> Groonga::Columnの配列
+    #
+    # レコードが所属するテーブルの全てのカラムを返す。
     def columns
       @table.columns
     end
 
+    # call-seq:
+    #   attributes -> Hash
+    #
+    # レコードが所属しているテーブルで定義されているインデックス
+    # 型のカラムでない全カラムを対象とし、カラムの名前をキーとし
+    # たこのレコードのカラムの値のハッシュを返す。
     def attributes
-      attributes = {}
+      attributes = {"id" => id}
+      _key = key
+      attributes["key"] = _key if _key
       table_name = @table.name
       columns.each do |column|
         next if column.is_a?(Groonga::IndexColumn)
-        attributes[column.local_name] = column[@id]
+        value = column[@id]
+        # TODO: support recursive reference.
+        value = value.attributes if value.is_a?(Groonga::Record)
+        attributes[column.local_name] = value
       end
       attributes
     end
 
+    # call-seq:
+    #   record.delete
+    #
+    # レコードを削除する。
     def delete
       @table.delete(@id)
     end
 
+    # call-seq:
+    #   record.lock(options={})
+    #   record.lock(options={}) {...}
+    #
+    # レコードが所属するテーブルをロックする。ロックに失敗した場
+    # 合はGroonga::ResourceDeadlockAvoided例外が発生する。
+    #
+    # ブロックを指定した場合はブロックを抜けたときにunlockする。
+    #
+    # 利用可能なオプションは以下の通り。
+    #
+    # [_:timeout_]
+    #   ロックを獲得できなかった場合は_:timeout_秒間ロックの獲
+    #   得を試みる。_:timeout_秒以内にロックを獲得できなかった
+    #   場合は例外が発生する。
     def lock(options={}, &block)
       @table.lock(options.merge(:id => @id), &block)
     end
 
+    # call-seq:
+    #   record.unlock(options={})
+    #
+    # レコードが所属するテーブルのロックを解除する。
+    #
+    # 利用可能なオプションは現在は無い。
     def unlock(options={})
       @table.unlock(options.merge(:id => @id))
     end
 
+    # call-seq:
+    #   record.clear_lock(options={})
+    #
+    # レコードが所属するテーブルのロックを強制的に解除する。
+    #
+    # 利用可能なオプションは現在は無い。
     def clear_lock(options={})
       @table.clear_lock(options.merge(:id => @id))
     end
 
+    # call-seq:
+    #   record.locked?(options={}) -> true/false
+    #
+    # レコードが所属するテーブルがロックされていれば+true+を返す。
+    #
+    # 利用可能なオプションは現在は無い。
     def locked?(options={})
       @table.locked?(options.merge(:id => @id))
     end
 
     private
-    def column(name)
+    def column(name) # :nodoc:
       _column = @table.column(name.to_s)
-      raise InvalidArgument, "column(#{name.inspect}) is nil" if _column.nil?
+      raise NoSuchColumn, "column(#{name.inspect}) is nil" if _column.nil?
       _column
     end
   end