rroonga 1.2.9 → 1.3.0

data/lib/groonga/patricia-trie.rb

@@ -17,22 +17,19 @@
 
 module Groonga
   class PatriciaTrie
-    # call-seq:
-    #   patricia_trie.tag_keys(text, options={}) {|record, word| ...} -> String
-    #
-    # _text_を走査し、レコードのキーとマッチする部分文字列ごとに
-    # そのレコードが_record_として、その部分文字列が_word_として、
+    # _text_ を走査し、レコードのキーとマッチする部分文字列ごとに
+    # そのレコードが _record_ として、その部分文字列が _word_ として、
     # ブロックが呼び出される。ブロックから返された文字列が元の部
     # 分文字列と置換される。全てのヒットに対してのその置換処理が
     # 行われた文字列が返される。
     #
-    # _options_に指定可能な値は以下の通り。
+    # @param options [::Hash] The name and value
+    #   pairs. Omitted names are initialized as the default value.
+    # @option options [Proc] :other_text_handler The other_text_handler
     #
-    # [+:other_text_handler+]
-    #   マッチした部分文字列の前後の文字列を変換するProcを指
-    #   定する。
+    #  マッチした部分文字列の前後の文字列を変換するProcを指定する。
     #
-    # 例:
+    # @example
     #   include ERB::Util
     #   Groonga::Context.default_options = {:encoding => "utf-8"}
     #   words = Groonga::PatriciaTrie.create(:key_type => "ShortText",

data/lib/groonga/posting.rb

@@ -52,7 +52,7 @@ module Groonga
 
     # Updates all values.
     #
-    # @param [Hash] parameters The name and value
+    # @param [::Hash] parameters The name and value
     #   pairs. Omitted names are initialized as the default value.
     # @option parameters [Integer] :record_id The record_id.
     # @option parameters [Integer] :section_id The section_id.

data/lib/groonga/query-log.rb

@@ -0,0 +1,348 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2011  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 "English"
+require "shellwords"
+require "cgi"
+
+module Groonga
+  module QueryLog
+    class Command
+      class << self
+        @@registered_commands = {}
+        def register(name, klass)
+          @@registered_commands[name] = klass
+        end
+
+        def parse(input)
+          if input.start_with?("/d/")
+            parse_uri_path(input)
+          else
+            parse_command_line(input)
+          end
+        end
+
+        private
+        def parse_uri_path(path)
+          name, parameters_string = path.split(/\?/, 2)
+          parameters = {}
+          if parameters_string
+            parameters_string.split(/&/).each do |parameter_string|
+              key, value = parameter_string.split(/\=/, 2)
+              parameters[key] = CGI.unescape(value)
+            end
+          end
+          name = name.gsub(/\A\/d\//, '')
+          name, output_type = name.split(/\./, 2)
+          parameters["output_type"] = output_type if output_type
+          command_class = @@registered_commands[name] || self
+          command = command_class.new(name, parameters)
+          command.original_format = :uri
+          command
+        end
+
+        def parse_command_line(command_line)
+          name, *options = Shellwords.shellwords(command_line)
+          parameters = {}
+          options.each_slice(2) do |key, value|
+            parameters[key.gsub(/\A--/, '')] = value
+          end
+          command_class = @@registered_commands[name] || self
+          command = command_class.new(name, parameters)
+          command.original_format = :command
+          command
+        end
+      end
+
+      attr_reader :name, :parameters
+      attr_accessor :original_format
+      def initialize(name, parameters)
+        @name = name
+        @parameters = parameters
+        @original_format = nil
+      end
+
+      def ==(other)
+        other.is_a?(self.class) and
+          @name == other.name and
+          @parameters == other.parameters
+      end
+
+      def uri_format?
+        @original_format == :uri
+      end
+
+      def command_format?
+        @original_format == :command
+      end
+
+      def to_uri_format
+        path = "/d/#{@name}"
+        parameters = @parameters.dup
+        output_type = parameters.delete("output_type")
+        path << ".#{output_type}" if output_type
+        unless parameters.empty?
+          sorted_parameters = parameters.sort_by do |name, _|
+            name.to_s
+          end
+          uri_parameters = sorted_parameters.collect do |name, value|
+            "#{CGI.escape(name)}=#{CGI.escape(value)}"
+          end
+          path << "?"
+          path << uri_parameters.join("&")
+        end
+        path
+      end
+
+      def to_command_format
+        command_line = [@name]
+        sorted_parameters = @parameters.sort_by do |name, _|
+          name.to_s
+        end
+        sorted_parameters.each do |name, value|
+          escaped_value = value.gsub(/[\n"\\]/) do
+            special_character = $MATCH
+            case special_character
+            when "\n"
+              "\\n"
+            else
+              "\\#{special_character}"
+            end
+          end
+          command_line << "--#{name}"
+          command_line << "\"#{escaped_value}\""
+        end
+        command_line.join(" ")
+      end
+    end
+
+    class SelectCommand < Command
+      register("select", self)
+
+      def sortby
+        @parameters["sortby"]
+      end
+
+      def scorer
+        @parameters["scorer"]
+      end
+
+      def query
+        @parameters["query"]
+      end
+
+      def filter
+        @parameters["filter"]
+      end
+
+      def conditions
+        @conditions ||= filter.split(/(?:&&|&!|\|\|)/).collect do |condition|
+          condition = condition.strip
+          condition = condition.gsub(/\A[\s\(]*/, '')
+          condition = condition.gsub(/[\s\)]*\z/, '') unless /\(/ =~ condition
+          condition
+        end
+      end
+
+      def drilldowns
+        @drilldowns ||= (@parameters["drilldown"] || "").split(/\s*,\s*/)
+      end
+
+      def output_columns
+        @parameters["output_columns"]
+      end
+    end
+
+    class Statistic
+      attr_reader :context_id, :start_time, :raw_command
+      attr_reader :elapsed, :return_code
+      attr_accessor :slow_operation_threshold, :slow_response_threshold
+      def initialize(context_id)
+        @context_id = context_id
+        @start_time = nil
+        @command = nil
+        @raw_command = nil
+        @operations = []
+        @elapsed = nil
+        @return_code = 0
+        @slow_operation_threshold = 0.1
+        @slow_response_threshold = 0.2
+      end
+
+      def start(start_time, command)
+        @start_time = start_time
+        @raw_command = command
+      end
+
+      def finish(elapsed, return_code)
+        @elapsed = elapsed
+        @return_code = return_code
+      end
+
+      def command
+        @command ||= Command.parse(@raw_command)
+      end
+
+      def elapsed_in_seconds
+        nano_seconds_to_seconds(@elapsed)
+      end
+
+      def last_time
+        @start_time + elapsed_in_seconds
+      end
+
+      def slow?
+        elapsed_in_seconds >= @slow_response_threshold
+      end
+
+      def each_operation
+        previous_elapsed = 0
+        ensure_parse_command
+        operation_context_context = {
+          :filter_index => 0,
+          :drilldown_index => 0,
+        }
+        @operations.each_with_index do |operation, i|
+          relative_elapsed = operation[:elapsed] - previous_elapsed
+          relative_elapsed_in_seconds = nano_seconds_to_seconds(relative_elapsed)
+          previous_elapsed = operation[:elapsed]
+          parsed_operation = {
+            :i => i,
+            :elapsed => operation[:elapsed],
+            :elapsed_in_seconds => nano_seconds_to_seconds(operation[:elapsed]),
+            :relative_elapsed => relative_elapsed,
+            :relative_elapsed_in_seconds => relative_elapsed_in_seconds,
+            :name => operation[:name],
+            :context => operation_context(operation[:name],
+                                          operation_context_context),
+            :n_records => operation[:n_records],
+            :slow? => slow_operation?(relative_elapsed_in_seconds),
+          }
+          yield parsed_operation
+        end
+      end
+
+      def add_operation(operation)
+        @operations << operation
+      end
+
+      def operations
+        _operations = []
+        each_operation do |operation|
+          _operations << operation
+        end
+        _operations
+      end
+
+      def select_command?
+        command.name == "select"
+      end
+
+      private
+      def nano_seconds_to_seconds(nano_seconds)
+        nano_seconds / 1000.0 / 1000.0 / 1000.0
+      end
+
+      def operation_context(label, context)
+        case label
+        when "filter"
+          if @select_command.query and context[:query_used].nil?
+            context[:query_used] = true
+            "query: #{@select_command.query}"
+          else
+            index = context[:filter_index]
+            context[:filter_index] += 1
+            @select_command.conditions[index]
+          end
+        when "sort"
+          @select_command.sortby
+        when "score"
+          @select_command.scorer
+        when "output"
+          @select_command.output_columns
+        when "drilldown"
+          index = context[:drilldown_index]
+          context[:drilldown_index] += 1
+          @select_command.drilldowns[index]
+        else
+          nil
+        end
+      end
+
+      def ensure_parse_command
+        return unless select_command?
+        @select_command = SelectCommand.parse(@raw_command)
+      end
+
+      def slow_operation?(elapsed)
+        elapsed >= @slow_operation_threshold
+      end
+    end
+
+    class Parser
+      def initialize
+      end
+
+      def parse(input, &block)
+        current_statistics = {}
+        input.each_line do |line|
+          case line
+          when /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)\.(\d+)\|(.+?)\|([>:<])/
+            year, month, day, hour, minutes, seconds, micro_seconds =
+              $1, $2, $3, $4, $5, $6, $7
+            context_id = $8
+            type = $9
+            rest = $POSTMATCH.strip
+            time_stamp = Time.local(year, month, day, hour, minutes, seconds,
+                                    micro_seconds)
+            parse_line(current_statistics,
+                       time_stamp, context_id, type, rest, &block)
+          end
+        end
+      end
+
+      private
+      def parse_line(current_statistics,
+                     time_stamp, context_id, type, rest, &block)
+        case type
+        when ">"
+          statistic = Statistic.new(context_id)
+          statistic.start(time_stamp, rest)
+          current_statistics[context_id] = statistic
+        when ":"
+          return unless /\A(\d+) (.+)\((\d+)\)/ =~ rest
+          elapsed = $1
+          name = $2
+          n_records = $3.to_i
+          statistic = current_statistics[context_id]
+          return if statistic.nil?
+          statistic.add_operation(:name => name,
+                                  :elapsed => elapsed.to_i,
+                                  :n_records => n_records)
+        when "<"
+          return unless /\A(\d+) rc=(\d+)/ =~ rest
+          elapsed = $1
+          return_code = $2
+          statistic = current_statistics.delete(context_id)
+          return if statistic.nil?
+          statistic.finish(elapsed.to_i, return_code.to_i)
+          block.call(statistic)
+        end
+      end
+    end
+  end
+end

data/lib/groonga/record.rb

@@ -21,7 +21,7 @@ module Groonga
   class Record
     # レコードが所属するテーブル
     attr_reader :table
-    # _table_の_id_に対応するレコードを作成する。_values_には各
+    # _table_ の _id_ に対応するレコードを作成する。_values_ には各
     # カラムに設定する値を以下のような形式で指定する。
     #
     #   [
@@ -40,141 +40,96 @@ module Groonga
       end
     end
 
-    # call-seq:
-    #   record == other -> true/false
-    #
-    # _record_と_other_が同じテーブルに属していて、さらに、
-    # 同じレコードIDを持つなら+true+を返し、そうでなければ
-    # +false+を返す。
+    # _record_ と _other_ が同じテーブルに属していて、さらに、
+    # 同じレコードIDを持つなら +true+ を返し、そうでなければ
+    # +false+ を返す。
     def ==(other)
       self.class == other.class and
         [table, id] == [other.table, other.id]
     end
 
-    # call-seq:
-    #   record.eql?(other) -> true/false
-    #
     # Groonga::Record#==と同じ。
     def eql?(other)
       self == other
     end
 
-    # call-seq:
-    #   record.hash -> ハッシュ値
-    #
     # 同じテーブルの同じIDのレコードに対しては常に同じハッシュ
     # 値を返す。
     def hash
       @table.hash ^ @id.hash
     end
 
-    # call-seq:
-    #   record[column_name] -> 値
-    #
-    # このレコードの_column_name_で指定されたカラムの値を返す。
+    # このレコードの _column_name_ で指定されたカラムの値を返す。
     def [](column_name)
       @table.column_value(@id, column_name, :id => true)
     end
 
-    # call-seq:
-    #   record[column_name] = 値
-    #
-    # このレコードの_column_name_で指定されたカラムの値を設定す
+    # このレコードの _column_name_ で指定されたカラムの値を設定す
     # る。
     def []=(column_name, value)
       @table.set_column_value(@id, column_name, value, :id => true)
     end
 
-    # call-seq:
-    #   record.append(column_name, value)
-    #
-    # このレコードの_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_を追加する。
+    # このレコードの _column_name_ で指定されたカラムの値の最初に
+    # _value_ を追加する。
     def prepend(column_name, value)
       column(column_name).prepend(@id, value)
     end
 
-    # call-seq:
-    #   record.support_key? -> true/false
-    #
-    # _record_が所属するテーブルで主キーを使える場合は+true+
-    # を返し、使えない場合は+false+を返す。
+    # _record_ が所属するテーブルで主キーを使える場合は +true+
+    # を返し、使えない場合は +false+ を返す。
     def support_key?
       @table.support_key?
     end
 
-    # call-seq:
-    #   record.have_column?(name) -> true/false
-    #
-    # 名前が_name_のカラムがレコードの所属するテーブルで定義され
-    # ているなら+true+を返す。
+    # 名前が _name_ のカラムがレコードの所属するテーブルで定義され
+    # ているなら +true+ を返す。
     def have_column?(name)
       not @table.column(normalize_column_name(name)).nil?
     end
 
-    # call-seq:
-    #   record.reference_column?(name) -> true/false
-    #
-    # 名前が_name_のカラムが参照カラムであるなら+true+を返す。
+    # 名前が _name_ のカラムが参照カラムであるなら +true+ を返す。
     def reference_column?(name)
       column(name).reference?
     end
 
-    # call-seq:
-    #   record.index_column?(name) -> true/false
-    #
-    # 名前が_name_のカラムが索引カラム
-    # （Groonga::IndexColumn）であるなら+true+を返す。
+    # 名前が _name_ のカラムが索引カラム
+    # （Groonga::IndexColumn）であるなら +true+ を返す。
     def index_column?(name)
       column(name).index?
     end
 
-    # call-seq:
-    #   record.vector_column?(name) -> true/false
-    #
-    # 名前が_name_のカラムの値がベクターであるなら+true+を返す。
+    # 名前が _name_ のカラムの値がベクターであるなら +true+ を返す。
     #
     # @since: 1.0.5
     def vector_column?(name)
       column(name).vector?
     end
 
-    # call-seq:
-    #   record.scalar_column?(name) -> true/false
-    #
-    # 名前が_name_のカラムの値がスカラーであるなら+true+を返す。
+    # 名前が _name_ のカラムの値がスカラーであるなら +true+ を返す。
     #
     # @since: 1.0.5
     def scalar_column?(name)
       column(name).scalar?
     end
 
-    # call-seq:
-    #   record.search(name, query, options={}) -> Groonga::Hash
-    #
-    # 名前が_name_のGroonga::IndexColumnのsearchメソッドを呼ぶ。
-    # _query_と_options_はそのメソッドにそのまま渡される。詳しく
+    # 名前が _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+を返す。
+    # _record_ が所属するテーブルがGroonga:::Arrayの場合は常
+    # に +nil+ を返す。
     def key
       if support_key?
         @key ||= @table.key(@id)
@@ -182,13 +137,9 @@ module Groonga
         nil
       end
     end
-
-    # call-seq:
-    #   record.record_id -> IDまたは主キー
-    #
     # レコードを一意に識別するための情報を返す。
     #
-    # _record_が所属するテーブルがGroonga:::Arrayの場合はID
+    # _record_ が所属するテーブルがGroonga:::Arrayの場合はID
     # を返し、それ以外の場合は主キーを返す。
     def record_id
       if support_key?
@@ -198,36 +149,24 @@ module Groonga
       end
     end
 
-    # call-seq:
-    #   record.record_raw_id -> ID
-    #
     # レコードのIDを返す。
     def record_raw_id
       @id
     end
     alias_method :id, :record_raw_id
 
-    # call-seq:
-    #   record.score -> スコア値
-    #
     # レコードのスコア値を返す。検索結果として生成されたテーブル
     # のみに定義される。
     def score
       self["_score"]
     end
 
-    # call-seq:
-    #   record.support_score? -> true/false
-    #
-    # Groonga::Record#scoreが利用できる場合はtrueを
+    # Groonga::Record#scoreが利用できる場合は +true+ を
     # 返す。
     def support_score?
       @table.have_column?("_score") # TODO delegate to Table
     end
 
-    # call-seq:
-    #   record.n_sub_records -> 件数
-    #
     # 主キーの値が同一であったレコードの件数を返す。検索結果とし
     # て生成されたテーブルのみに定義される。
     #
@@ -237,60 +176,39 @@ module Groonga
       self["_nsubrecs"]
     end
 
-    # call-seq:
-    #   record.support_sub_records? -> true/false
-    #
-    # Groonga::Record#n_sub_recordsが利用できる場合はtrueを
+    # Groonga::Record#n_sub_recordsが利用できる場合は +true+ を
     # 返す。
     def support_sub_records?
       @table.support_sub_records?
     end
 
-    # call-seq:
-    #   record.value -> 値
-    #
     # レコードの値を返す。
     def value
       @table.value(@id, :id => true)
     end
 
-    # call-seq:
-    #   record.value = 値
-    #
     # レコードの値を設定する。既存の値は上書きされる。
     def value=(value)
       @table.set_value(@id, value, :id => true)
     end
 
-    # call-seq:
-    #   record.increment!(name, delta=nil)
-    #
-    # このレコードの_name_で指定されたカラムの値を_delta_だけ増
-    # 加する。_delta_が+nil+の場合は1増加する。
+    # このレコードの _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減少する。
+    # このレコードの _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
-    #
     # レコードが所属しているテーブルで定義されているインデックス
     # 型のカラムでない全カラムを対象とし、カラムの名前をキーとし
     # たこのレコードのカラムの値のハッシュを返す。
@@ -301,36 +219,26 @@ module Groonga
       accessor.build
     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_秒以内にロックを獲得できなかった
-    #   場合は例外が発生する。
+    # 利用可能な _option_ は以下の通り。
+    # @param [Hash] options The name and value
+    #   pairs. Omitted names are initialized as the default value.
+    # @option options [Integer] :timeout The timeout
+    #   ロックを獲得できなかった場合は _:timeout_ 秒間ロックの獲得を試みる。
+    #   _:timeout_ 秒以内にロックを獲得できなかった場合は例外が発生する。
     def lock(options={}, &block)
       @table.lock(options.merge(:id => @id), &block)
     end
 
-    # call-seq:
-    #   record.unlock(options={})
-    #
     # レコードが所属するテーブルのロックを解除する。
     #
     # 利用可能なオプションは現在は無い。
@@ -338,9 +246,6 @@ module Groonga
       @table.unlock(options.merge(:id => @id))
     end
 
-    # call-seq:
-    #   record.clear_lock(options={})
-    #
     # レコードが所属するテーブルのロックを強制的に解除する。
     #
     # 利用可能なオプションは現在は無い。
@@ -348,25 +253,20 @@ module Groonga
       @table.clear_lock(options.merge(:id => @id))
     end
 
-    # call-seq:
-    #   record.locked?(options={}) -> true/false
-    #
-    # レコードが所属するテーブルがロックされていれば+true+を返す。
+    # レコードが所属するテーブルがロックされていれば +true+ を返す。
     #
     # 利用可能なオプションは現在は無い。
     def locked?(options={})
       @table.locked?(options.merge(:id => @id))
     end
 
-    # call-seq:
-    #   record.valid_id? -> true/false
-    #
-    # レコードが持つIDが有効なIDであれば+true+を返す。
+    # レコードが持つIDが有効なIDであれば +true+ を返す。
     def valid_id?
       @table.exist?(@id)
     end
 
-    def methods(include_inherited=true) # :nodoc:
+    # @private
+    def methods(include_inherited=true)
       _methods = super
       return _methods unless include_inherited
       columns.each do |column|
@@ -377,7 +277,8 @@ module Groonga
       _methods
     end
 
-    def respond_to?(name) # :nodoc:
+    # @private
+    def respond_to?(name)
       super or !@table.column(name.to_s.sub(/=\z/, '')).nil?
     end
 
@@ -395,7 +296,8 @@ module Groonga
       name.to_s
     end
 
-    def column(name) # :nodoc:
+    # @private
+    def column(name)
       _column = @table.column(normalize_column_name(name))
       raise NoSuchColumn, "column(#{name.inspect}) is nil" if _column.nil?
       _column
@@ -421,7 +323,8 @@ module Groonga
       end
     end
 
-    class AttributeHashBuilder # :nodoc:
+    # @private
+    class AttributeHashBuilder
       attr_reader :attributes
 
       def initialize(root_record)
@@ -510,3 +413,4 @@ module Groonga
     end
   end
 end
+