fluent-plugin-droonga 0.7.0 → 0.8.0

data/lib/droonga/plugin/handler/watch.rb

@@ -47,8 +47,8 @@ module Droonga
     end
 
     command "watch.subscribe" => :subscribe
-    def subscribe(request)
-      subscriber, condition, query, route = parse_request(request)
+    def subscribe(message, messenger)
+      subscriber, condition, query, route = parse_message(message)
       normalized_request = {
         :subscriber => subscriber,
         :condition  => condition,
@@ -56,40 +56,46 @@ module Droonga
         :route      => route,
       }
       @watcher.subscribe(normalized_request)
-      emit([true])
+      messenger.emit([true])
     end
 
     command "watch.unsubscribe" => :unsubscribe
-    def unsubscribe(request)
-      subscriber, condition, query, route = parse_request(request)
+    def unsubscribe(message, messenger)
+      subscriber, condition, query, route = parse_message(message)
       normalized_request = {
         :subscriber => subscriber,
         :condition  => condition,
         :query      => query,
       }
       @watcher.unsubscribe(normalized_request)
-      emit([true])
+      messenger.emit([true])
     end
 
     command "watch.feed" => :feed
-    def feed(request)
+    def feed(message, messenger)
+      request = message.request
       @watcher.feed(:targets => request["targets"]) do |route, subscribers|
-        message = request # return request itself
-        envelope["to"] = subscribers
-        post(message, "to" => route, "type" => "watch.notification")
+        notification_message = {
+          "to"   => subscribers,
+          "body" => request,
+        }
+        notification_message = message.raw.merge(notification_message)
+        messenger.forward(notification_message,
+                          "to" => route, "type" => "watch.notification")
       end
     end
 
     command "watch.sweep" => :sweep
-    def sweep(request)
+    def sweep(message, messenger)
       @sweeper.sweep_expired_subscribers
     end
 
     private
-    def parse_request(request)
+    def parse_message(message)
+      request = message.request
       subscriber = request["subscriber"]
       condition = request["condition"]
-      route = request["route"] || envelope["from"]
+      route = request["route"] || message["from"]
       query = condition && condition.to_json
       [subscriber, condition, query, route]
     end

data/lib/droonga/plugin/{adapter → input_adapter}/groonga.rb

@@ -13,28 +13,22 @@
 # 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 "droonga/adapter_plugin"
+require "droonga/input_adapter_plugin"
 
 module Droonga
-  class GroongaAdapter < Droonga::AdapterPlugin
-    repository.register("select", self)
+  class GroongaInputAdapter < Droonga::InputAdapterPlugin
+    repository.register("groonga", self)
 
     command :select
     def select(input_message)
       command = Select.new
       select_request = input_message.body
-      search_request = command.convert_request(select_request)
+      search_request = command.convert(select_request)
       input_message.add_route("select_response")
       input_message.command = "search"
       input_message.body = search_request
     end
-
-    command :select_response
-    def select_response(search_response)
-      command = Select.new
-      emit(command.convert_response(search_response))
-    end
   end
 end
 
-require "droonga/plugin/adapter/groonga/select"
+require "droonga/plugin/input_adapter/groonga/select"

data/lib/droonga/plugin/{adapter → input_adapter}/groonga/select.rb

@@ -14,9 +14,9 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 module Droonga
-  class GroongaAdapter
+  class GroongaInputAdapter
     class Select
-      def convert_request(select_request)
+      def convert(select_request)
         table = select_request["table"]
         result_name = table + "_result"
         match_columns = select_request["match_columns"]
@@ -58,40 +58,6 @@ module Droonga
         end
         search_request
       end
-
-      def convert_response(search_response)
-        select_responses = search_response.collect do |key, value|
-          status_code = 0
-
-          start_time = value["startTime"]
-          start_time_in_unix_time = if start_time
-                                      Time.parse(start_time).to_f
-                                    else
-                                      Time.now.to_f
-                                    end
-          elapsed_time = value["elapsedTime"] || 0
-          count = value["count"]
-
-          attributes = value["attributes"] || []
-          converted_attributes = attributes.collect do |attribute|
-            name = attribute["name"]
-            type = attribute["type"]
-            [name, type]
-          end
-
-          header = [status_code, start_time_in_unix_time, elapsed_time]
-          records = value["records"]
-          if records.empty?
-            results = [[count], converted_attributes]
-          else
-            results = [[count], converted_attributes, records]
-          end
-          body = [results]
-
-          [header, body]
-        end
-        select_responses.first
-      end
     end
   end
 end

data/lib/droonga/plugin/output_adapter/groonga.rb

@@ -0,0 +1,30 @@
+# Copyright (C) 2013 Droonga Project
+#
+# 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 "droonga/output_adapter_plugin"
+
+module Droonga
+  class GroongaOutputAdapter < Droonga::OutputAdapterPlugin
+    repository.register("groonga", self)
+
+    command :select_response
+    def select_response(output_message)
+      command = Select.new
+      output_message.body = command.convert(output_message.body)
+    end
+  end
+end
+
+require "droonga/plugin/output_adapter/groonga/select"

data/lib/droonga/plugin/output_adapter/groonga/select.rb

@@ -0,0 +1,54 @@
+# Copyright (C) 2013 Droonga Project
+#
+# 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 Droonga
+  class GroongaOutputAdapter
+    class Select
+      def convert(search_response)
+        select_responses = search_response.collect do |key, value|
+          status_code = 0
+
+          start_time = value["startTime"]
+          start_time_in_unix_time = if start_time
+                                      Time.parse(start_time).to_f
+                                    else
+                                      Time.now.to_f
+                                    end
+          elapsed_time = value["elapsedTime"] || 0
+          count = value["count"]
+
+          attributes = value["attributes"] || []
+          converted_attributes = attributes.collect do |attribute|
+            name = attribute["name"]
+            type = attribute["type"]
+            [name, type]
+          end
+
+          header = [status_code, start_time_in_unix_time, elapsed_time]
+          records = value["records"]
+          if records.empty?
+            results = [[count], converted_attributes]
+          else
+            results = [[count], converted_attributes, records]
+          end
+          body = [results]
+
+          [header, body]
+        end
+        select_responses.first
+      end
+    end
+  end
+end

data/lib/droonga/plugin_loader.rb

@@ -25,8 +25,8 @@ module Droonga
             type = File.basename(type_path)
             Dir.glob("#{type_path}/*.rb") do |path|
               name = File.basename(path, ".rb")
-              plugin = new(type, name)
-              plugin.load
+              loader = new(type, name)
+              loader.load
             end
           end
         end

data/lib/droonga/processor.rb

@@ -15,50 +15,48 @@
 # 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 "droonga/job_queue"
 require "droonga/handler"
 
 module Droonga
   class Processor
-    def initialize(options={})
+    def initialize(loop, message_pusher, options={})
+      @loop = loop
+      @message_pusher = message_pusher
       @options = options
-      @database_name = @options[:database]
-      @queue_name = @options[:options] || "DroongaQueue"
       @n_workers = @options[:n_workers] || 0
     end
 
     def start
-      Droonga::JobQueue.ensure_schema(@database_name,
-                                      @queue_name)
-      @job_queue = JobQueue.open(@database_name, @queue_name)
-      @handler = Handler.new(@options)
+      @handler = Handler.new(@loop, @options)
+      @handler.start
     end
 
     def shutdown
-      $log.trace("processor: shutdown: start")
+      $log.trace("#{log_tag}: shutdown: start")
       @handler.shutdown
-      @job_queue.close
-      $log.trace("processor: shutdown: done")
+      $log.trace("#{log_tag}: shutdown: done")
     end
 
-    def process(envelope, synchronous=nil)
-      $log.trace("proessor: process: start")
-      reply_to = envelope["replyTo"]
-      command = envelope["type"]
+    def process(message)
+      $log.trace("#{log_tag}: process: start")
+      command = message["type"]
       if @handler.processable?(command)
-        $log.trace("proessor: process: handlable: #{command}")
-        if synchronous.nil?
-          synchronous = @handler.prefer_synchronous?(command)
-        end
+        $log.trace("#{log_tag}: process: handlable: #{command}")
+        synchronous = @handler.prefer_synchronous?(command)
         if @n_workers.zero? or synchronous
-          @handler.process(envelope)
+          @handler.process(message)
         else
-          @job_queue.push_message(envelope)
+          @message_pusher.push(message)
         end
       else
-        $log.trace("proessor: process: ignore #{command}")
+        $log.trace("#{log_tag}: process: ignore #{command}")
       end
-      $log.trace("proessor: process: done")
+      $log.trace("#{log_tag}: process: done")
+    end
+
+    private
+    def log_tag
+      "processor"
     end
   end
 end

data/lib/droonga/replier.rb

@@ -0,0 +1,40 @@
+# Copyright (C) 2013 Droonga Project
+#
+# 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 Droonga
+  class Replier
+    def initialize(forwarder)
+      @forwarder = forwarder
+    end
+
+    def reply(message)
+      $log.trace("#{log_tag}: reply: start")
+      destination = message["replyTo"]
+      reply_message = {
+        "inReplyTo"  => message["id"],
+        "statusCode" => message["statusCode"] || 200,
+        "type"       => destination["type"],
+        "body"       => message["body"],
+      }
+      @forwarder.forward(reply_message, destination)
+      $log.trace("#{log_tag}: reply: done")
+    end
+
+    private
+    def log_tag
+      "[#{Process.ppid}][#{Process.pid}] replier"
+    end
+  end
+end

data/lib/droonga/searcher.rb

@@ -19,16 +19,30 @@ require "English"
 require "tsort"
 require "groonga"
 
+require "droonga/time_formatter"
+
 module Droonga
   class Searcher
-    class Error < StandardError
+    class MissingSourceParameter < BadRequest
+      def initialize(query, queries)
+        super("The query #{query.inspect} has no source. " +
+                "Query must have a valid source.",
+              queries)
+      end
+    end
+
+    class UnknownSource < NotFound
+      def initialize(source, queries)
+        super("The source #{source.inspect} does not exist. " +
+                "It must be a name of an existing table or another query.",
+              queries)
+      end
     end
 
-    class UndefinedSourceError < Error
-      attr_reader :name
-      def initialize(name)
-        @name = name
-        super("undefined source was used: <#{name}>")
+    class CyclicSource < BadRequest
+      def initialize(queries)
+        super("There is cyclic reference of sources.",
+              queries)
       end
     end
 
@@ -54,11 +68,7 @@ module Droonga
         return {}
       end
       $log.trace("#{log_tag}: process_queries: sort: start")
-      query_sorter = QuerySorter.new
-      queries.each do |name, query|
-        query_sorter.add(name, [query["source"]])
-      end
-      sorted_queries = query_sorter.tsort
+      sorted_queries = QuerySorter.sort(queries)
       $log.trace("#{log_tag}: process_queries: sort: done")
       outputs = {}
       results = {}
@@ -66,21 +76,22 @@ module Droonga
         if queries[name]
           $log.trace("#{log_tag}: process_queries: search: start",
                      :name => name)
-          searcher = QuerySearcher.new(@context, queries[name])
-          results[name] = searcher.search(results)
+          search_request = SearchRequest.new(@context, queries[name], results)
+          search_result = QuerySearcher.search(search_request)
+          results[name] = search_result.records
           $log.trace("#{log_tag}: process_queries: search: done",
                      :name => name)
-          if searcher.need_output?
+          if search_request.need_output?
             $log.trace("#{log_tag}: process_queries: format: start",
                        :name => name)
-            outputs[name] = searcher.format
+            outputs[name] = ResultFormatter.format(search_request, search_result)
             $log.trace("#{log_tag}: process_queries: format: done",
                        :name => name)
           end
         elsif @context[name]
           results[name] = @context[name]
         else
-          raise UndefinedSourceError.new(name)
+          raise UnknownSource.new(name, queries)
         end
       end
       $log.trace("#{log_tag}: process_queries: done")
@@ -93,6 +104,29 @@ module Droonga
 
     class QuerySorter
       include TSort
+
+      class << self
+        def sort(queries)
+          query_sorter = new
+          queries.each do |name, query|
+            source = query["source"]
+            raise MissingSourceParameter.new(name, queries) unless source
+            raise CyclicSource.new(queries) if name == source
+            query_sorter.add(name, [source])
+          end
+          begin
+            sorted_queries = query_sorter.tsort
+          rescue TSort::Cyclic
+            raise CyclicSource.new(queries)
+          end
+          sorted_queries
+        end
+
+        def validate_dependencies(queries)
+          sort(queries)
+        end
+      end
+
       def initialize()
         @queries = {}
       end
@@ -112,102 +146,132 @@ module Droonga
       end
     end
 
-    class QuerySearcher
-      def initialize(context, query)
+    class SearchRequest
+      attr_reader :context, :query, :resolved_results
+
+      def initialize(context, query, resolved_results)
         @context = context
         @query = query
-        @result = nil
-        @condition = nil
-        @start_time = nil
+        @resolved_results = resolved_results
       end
 
-      def search(results)
-        search_query(results)
+      def need_output?
+        @query.has_key?("output")
       end
 
-      def need_output?
-        @result and @query.has_key?("output")
+      def output
+        @query["output"]
       end
 
-      def format
-        formatted_result = {}
-        format_count(formatted_result)
-        format_attributes(formatted_result)
-        format_records(formatted_result)
-        if need_element_output?("startTime")
-          formatted_result["startTime"] = @start_time.iso8601
-        end
-        if need_element_output?("elapsedTime")
-          formatted_result["elapsedTime"] = Time.now.to_f - @start_time.to_f
+      def complex_output?
+        output["format"] == "complex"
+      end
+
+      def source
+        source_name = @query["source"]
+        @resolved_results[source_name]
+      end
+    end
+
+    class SearchResult
+      attr_accessor :start_time, :end_time, :condition, :records, :count
+
+      def initialize
+        @start_time = nil
+        @end_time = nil
+        @condition = nil
+        @records = nil
+        @count = nil
+      end
+    end
+
+    class QuerySearcher
+      OPERATOR_CONVERSION_TABLE = {
+        "||" => Groonga::Operator::OR,
+        "&&" => Groonga::Operator::AND,
+        "-"  => Groonga::Operator::AND_NOT,
+      }.freeze
+
+      class << self
+        def search(search_request)
+          new(search_request).search
         end
-        formatted_result
+      end
+
+      def initialize(search_request)
+        @result = SearchResult.new
+        @request = search_request
+      end
+
+      def search
+        search_query!
+        @result
       end
 
       private
-      def parseCondition(source, expression, condition)
-        if condition.is_a? String
+      def parse_condition(source, expression, condition)
+        case condition
+        when String
           expression.parse(condition, :syntax => :script)
-        elsif condition.is_a? Hash
-          options = {}
-          if condition["matchTo"]
-            matchTo = Groonga::Expression.new(context: @context)
-            matchTo.define_variable(:domain => source)
-            match_columns = condition["matchTo"]
-            match_columns = match_columns.join(",") if match_columns.is_a?(Array)
-            matchTo.parse(match_columns, :syntax => :script)
-            options[:default_column] = matchTo
-          end
-          if condition["query"]
-            options[:syntax] = :query
-            if condition["defaultOperator"]
-              case condition["defaultOperator"]
-              when "||"
-                options[:default_operator] = Groonga::Operator::OR
-              when "&&"
-                options[:default_operator] = Groonga::Operator::AND
-              when "-"
-                options[:default_operator] = Groonga::Operator::BUT
-              else
-                raise "undefined operator assigned #{condition["default_operator"]}"
-              end
-            end
-            if condition["allowPragma"]
-              options[:allow_pragma] = true
-            end
-            if condition["allowColumn"]
-              options[:allow_column] = true
-            end
-            expression.parse(condition["query"], options)
-          elsif condition["script"]
-            # "script" is ignored when "query" is also assigned.
-            options[:syntax] = :script
-            if condition["allowUpdate"]
-              options[:allow_update] = true
+        when Hash
+          parse_condition_hash(source, expression, condition)
+        when Array
+          parse_condition_array(source, expression, condition)
+        else
+          raise "unacceptable object #{condition.inspect} assigned"
+        end
+      end
+
+      def parse_condition_hash(source, expression, condition)
+        options = {}
+        if condition["matchTo"]
+          matchTo = Groonga::Expression.new(context: @request.context)
+          matchTo.define_variable(:domain => source)
+          match_columns = condition["matchTo"]
+          match_columns = match_columns.join(",") if match_columns.is_a?(Array)
+          matchTo.parse(match_columns, :syntax => :script)
+          options[:default_column] = matchTo
+        end
+        if condition["query"]
+          options[:syntax] = :query
+          if condition["defaultOperator"]
+            default_operator_string = condition["defaultOperator"]
+            default_operator = OPERATOR_CONVERSION_TABLE[default_operator_string]
+            unless default_operator
+              raise "undefined operator assigned #{default_operator_string}"
             end
-            expression.parse(condition["script"], options)
-          else
-            raise "neither 'query' nor 'script' assigned in #{condition.inspect}"
+            options[:default_operator] = default_operator
           end
-        elsif condition.is_a? Array
-          case condition[0]
-          when "||"
-            operator = Groonga::Operator::OR
-          when "&&"
-            operator = Groonga::Operator::AND
-          when "-"
-            operator = Groonga::Operator::BUT
-          else
-            raise "undefined operator assigned #{condition[0]}"
+          if condition["allowPragma"]
+            options[:allow_pragma] = true
           end
-          if condition[1]
-            parseCondition(source, expression, condition[1])
+          if condition["allowColumn"]
+            options[:allow_column] = true
           end
-          condition[2..-1].each do |element|
-            parseCondition(source, expression, element)
-            expression.append_operation(operator, 2)
+          expression.parse(condition["query"], options)
+        elsif condition["script"]
+          # "script" is ignored when "query" is also assigned.
+          options[:syntax] = :script
+          if condition["allowUpdate"]
+            options[:allow_update] = true
           end
+          expression.parse(condition["script"], options)
         else
-          raise "unacceptable object #{condition.inspect} assigned"
+          raise "neither 'query' nor 'script' assigned in #{condition.inspect}"
+        end
+      end
+
+      def parse_condition_array(source, expression, condition)
+        operator = OPERATOR_CONVERSION_TABLE[condition[0]]
+        unless operator
+          raise "undefined operator assigned #{condition[0]}"
+        end
+        if condition[1]
+          parse_condition(source, expression, condition[1])
+        end
+        condition[2..-1].each do |element|
+          parse_condition(source, expression, element)
+          expression.append_operation(operator, 2)
         end
       end
 
@@ -221,113 +285,169 @@ module Droonga
         end
       end
 
-      def search_query(results)
+      def search_query!
         $log.trace("#{log_tag}: search_query: start")
-        @start_time = Time.now
-        @result = source = results[@query["source"]]
-        condition = @query["condition"]
-        if condition
-          expression = Groonga::Expression.new(context: @context)
-          expression.define_variable(:domain => source)
-          parseCondition(source, expression, condition)
-          $log.trace("#{log_tag}: search_query: select: start",
-                     :condition => condition)
-          @result = source.select(expression)
-          $log.trace("#{log_tag}: search_query: select: done")
-          @condition = expression
+
+        @result.start_time = Time.now
+
+        @records = @request.source
+
+        condition = @request.query["condition"]
+        apply_condition!(condition) if condition
+
+        group_by = @request.query["groupBy"]
+        apply_group_by!(group_by) if group_by
+
+        @result.count = @records.size
+
+        sort_by = @request.query["sortBy"]
+        apply_sort_by!(sort_by) if sort_by
+
+        $log.trace("#{log_tag}: search_query: done")
+        @result.records = @records
+        @result.end_time = Time.now
+      end
+
+      def apply_condition!(condition)
+        expression = Groonga::Expression.new(context: @request.context)
+        expression.define_variable(:domain => @records)
+        parse_condition(@records, expression, condition)
+        $log.trace("#{log_tag}: search_query: select: start",
+                   :condition => condition)
+        @records = @records.select(expression)
+        $log.trace("#{log_tag}: search_query: select: done")
+        @result.condition = expression
+      end
+
+      def apply_group_by!(group_by)
+        $log.trace("#{log_tag}: search_query: group: start",
+                   :by => group_by)
+        case group_by
+        when String
+          @records = @records.group(group_by)
+        when Hash
+          key = group_by["key"]
+          max_n_sub_records = group_by["maxNSubRecords"]
+          @records = @records.group(key, :max_n_sub_records => max_n_sub_records)
+        else
+          raise '"groupBy" parameter must be a Hash or a String'
         end
-        group_by = @query["groupBy"]
-        if group_by
-          $log.trace("#{log_tag}: search_query: group: start",
-                     :by => group_by)
-          if group_by.is_a? String
-            @result = @result.group(group_by)
-          elsif group_by.is_a? Hash
-            key = group_by["key"]
-            max_n_sub_records = group_by["maxNSubRecords"]
-            @result = @result.group(key, :max_n_sub_records => max_n_sub_records)
-          else
-            raise '"groupBy" parameter must be a Hash or a String'
-          end
-          $log.trace("#{log_tag}: search_query: group: done",
-                     :by => group_by)
+        $log.trace("#{log_tag}: search_query: group: done",
+                   :by => group_by)
+      end
+
+      def apply_sort_by!(sort_by)
+        $log.trace("#{log_tag}: search_query: sort: start",
+                   :by => sort_by)
+        case sort_by
+        when Array
+          keys = parse_order_keys(sort_by)
+          offset = 0
+          limit = -1
+        when Hash
+          keys = parse_order_keys(sort_by["keys"])
+          offset = sort_by["offset"]
+          limit = sort_by["limit"]
+        else
+          raise '"sortBy" parameter must be a Hash or an Array'
         end
-        @count = @result.size
-        sort_by = @query["sortBy"]
-        if sort_by
-          $log.trace("#{log_tag}: search_query: sort: start",
-                     :by => sort_by)
-          if sort_by.is_a? Array
-            keys = parse_order_keys(sort_by)
-            offset = 0
-            limit = -1
-          elsif sort_by.is_a? Hash
-            keys = parse_order_keys(sort_by["keys"])
-            offset = sort_by["offset"]
-            limit = sort_by["limit"]
-          else
-            raise '"sortBy" parameter must be a Hash or an Array'
-          end
-          @result = @result.sort(keys, :offset => offset, :limit => limit)
-          $log.trace("#{log_tag}: search_query: sort: done",
-                     :by => sort_by)
+        @records = @records.sort(keys, :offset => offset, :limit => limit)
+        $log.trace("#{log_tag}: search_query: sort: done",
+                   :by => sort_by)
+      end
+
+      def log_tag
+        "[#{Process.ppid}][#{Process.pid}] query_searcher"
+      end
+    end
+
+    class ResultFormatter
+      class << self
+        def format(search_request, search_result)
+          new(search_request, search_result).format
         end
-        $log.trace("#{log_tag}: search_query: done")
-        @result
       end
 
-      def need_element_output?(element)
-        params = @query["output"]
+      def initialize(search_request, search_result)
+        @request = search_request
+        @result = search_result
+      end
+
+      def format
+        formatted_result = {}
+
+        output_elements.each do |name|
+          value = format_element(name)
+          next if value.nil?
+          formatted_result[name] = value
+        end
 
-        elements = params["elements"]
-        return false if elements.nil?
+        formatted_result
+      end
 
-        elements.include?(element)
+      private
+      def format_element(name)
+        case name
+        when "count"
+          format_count
+        when "attributes"
+          format_attributes
+        when "records"
+          format_records
+        when "startTime"
+          format_start_time
+        when "elapsedTime"
+          format_elapsed_time
+        else
+          nil
+        end
       end
 
-      def format_count(formatted_result)
-        return unless need_element_output?("count")
-        formatted_result["count"] = @count
+      def output_elements
+        @request.output["elements"] || []
       end
 
-      def format_attributes(formatted_result)
-        return unless need_element_output?("attributes")
+      def format_count
+        @result.count
+      end
 
+      def format_attributes
         # XXX IMPLEMENT ME!!!
         attributes = nil
-        if @query["output"]["format"] == "complex"
-          # should convert columnst to an object like:
+        if @request.complex_output?
+          # should convert columns to an object like:
           # {"_id" => {"type" => "UInt32", "vector" => false}}
           attributes = {}
         else
-          # should convert columnst to an object like:
+          # should convert columns to an object like:
           # [{"name" => "_id", "type" => "UInt32", "vector" => false}]
           attributes = []
         end
 
-        formatted_result["attributes"] = attributes
+        attributes
       end
 
-      def format_records(formatted_result)
-        return unless need_element_output?("records")
-
-        params = @query["output"]
+      def format_records
+        params = @request.output
 
         attributes = params["attributes"]
         target_attributes = normalize_target_attributes(attributes)
         offset = params["offset"] || 0
         limit = params["limit"] || 10
-        @result.open_cursor(:offset => offset, :limit => limit) do |cursor|
-          if params["format"] == "complex"
-            formatted_result["records"] = cursor.collect do |record|
+        formatted_records = nil
+        @result.records.open_cursor(:offset => offset, :limit => limit) do |cursor|
+          if @request.complex_output?
+            formatted_records = cursor.collect do |record|
               complex_record(target_attributes, record)
             end
           else
-            formatted_result["records"] = cursor.collect do |record|
+            formatted_records = cursor.collect do |record|
               simple_record(target_attributes, record)
             end
           end
         end
+
+        formatted_records
       end
 
       def complex_record(attributes, record)
@@ -346,7 +466,7 @@ module Droonga
 
       def record_value(record, attribute)
         if attribute[:source] == "_subrecs"
-          if @query["output"]["format"] == "complex"
+          if @request.complex_output?
             record.sub_records.collect do |sub_record|
               target_attributes = resolve_attributes(attribute, sub_record)
               complex_record(target_attributes, sub_record)
@@ -382,11 +502,7 @@ module Droonga
         return attribute[:target_attributes]
       end
 
-      def accessor_name?(source)
-        /\A[a-zA-Z\#@$_][a-zA-Z\d\#@$_\-.]*\z/ === source
-      end
-
-      def normalize_target_attributes(attributes, domain = @result)
+      def normalize_target_attributes(attributes, domain = @result.records)
         attributes.collect do |attribute|
           if attribute.is_a?(String)
             attribute = {
@@ -398,12 +514,12 @@ module Droonga
             expression = nil
             variable = nil
           else
-            expression = Groonga::Expression.new(context: @context)
+            expression = Groonga::Expression.new(context: @request.context)
             variable = expression.define_variable(domain: domain)
             expression.parse(source, syntax: :script)
             condition = expression.define_variable(name: "$condition",
                                                    reference: true)
-            condition.value = @condition
+            condition.value = @result.condition
             source = nil
           end
           {
@@ -416,8 +532,16 @@ module Droonga
         end
       end
 
-      def log_tag
-        "[#{Process.ppid}][#{Process.pid}] query_searcher"
+      def accessor_name?(source)
+        /\A[a-zA-Z\#@$_][a-zA-Z\d\#@$_\-.]*\z/ === source
+      end
+
+      def format_start_time
+        TimeFormatter.format(@result.start_time)
+      end
+
+      def format_elapsed_time
+        @result.end_time.to_f - @result.start_time.to_f
       end
     end
   end