RubyGems - fluent-plugin-droonga - Versions diffs - 0.7.0 → 0.8.0 - Mend

fluent-plugin-droonga 0.7.0 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (163) hide show

checksums.yaml +4 -4
data/.gitignore +1 -4
data/benchmark/watch/benchmark-notify.rb +2 -2
data/benchmark/watch/benchmark-scan.rb +3 -0
data/benchmark/watch/fluentd.conf +0 -1
data/fluent-plugin-droonga.gemspec +2 -3
data/lib/droonga/catalog.rb +10 -124
data/lib/droonga/catalog/base.rb +140 -0
data/lib/droonga/catalog/version1.rb +23 -0
data/lib/droonga/catalog_loader.rb +33 -0
data/lib/droonga/collector.rb +2 -71
data/lib/droonga/collector_plugin.rb +2 -34
data/lib/droonga/dispatcher.rb +141 -196
data/lib/droonga/distribution_planner.rb +76 -0
data/lib/droonga/distributor.rb +5 -7
data/lib/droonga/distributor_plugin.rb +23 -15
data/lib/droonga/engine.rb +2 -2
data/lib/droonga/event_loop.rb +46 -0
data/lib/droonga/farm.rb +9 -5
data/lib/droonga/fluent_message_sender.rb +84 -0
data/lib/droonga/forwarder.rb +43 -53
data/lib/droonga/handler.rb +20 -68
data/lib/droonga/handler_message.rb +61 -0
data/lib/droonga/handler_messenger.rb +92 -0
data/lib/droonga/handler_plugin.rb +10 -12
data/lib/droonga/input_adapter.rb +52 -0
data/lib/droonga/{adapter.rb → input_adapter_plugin.rb} +7 -13
data/lib/droonga/input_message.rb +11 -11
data/lib/droonga/logger.rb +4 -3
data/lib/droonga/message_pack_packer.rb +62 -0
data/lib/droonga/message_processing_error.rb +54 -0
data/lib/droonga/message_pusher.rb +60 -0
data/lib/droonga/message_receiver.rb +61 -0
data/lib/droonga/output_adapter.rb +53 -0
data/lib/droonga/{adapter_plugin.rb → output_adapter_plugin.rb} +3 -21
data/lib/droonga/output_message.rb +37 -0
data/lib/droonga/partition.rb +27 -5
data/lib/droonga/pluggable.rb +9 -4
data/lib/droonga/plugin.rb +12 -3
data/lib/droonga/plugin/collector/basic.rb +91 -18
data/lib/droonga/plugin/distributor/crud.rb +9 -9
data/lib/droonga/plugin/distributor/distributed_search_planner.rb +401 -0
data/lib/droonga/plugin/distributor/groonga.rb +5 -5
data/lib/droonga/plugin/distributor/search.rb +4 -246
data/lib/droonga/plugin/distributor/watch.rb +11 -6
data/lib/droonga/plugin/handler/add.rb +69 -7
data/lib/droonga/plugin/handler/groonga.rb +6 -6
data/lib/droonga/plugin/handler/search.rb +5 -3
data/lib/droonga/plugin/handler/watch.rb +19 -13
data/lib/droonga/plugin/{adapter → input_adapter}/groonga.rb +5 -11
data/lib/droonga/plugin/{adapter → input_adapter}/groonga/select.rb +2 -36
data/lib/droonga/plugin/output_adapter/groonga.rb +30 -0
data/lib/droonga/plugin/output_adapter/groonga/select.rb +54 -0
data/lib/droonga/plugin_loader.rb +2 -2
data/lib/droonga/processor.rb +21 -23
data/lib/droonga/replier.rb +40 -0
data/lib/droonga/searcher.rb +298 -174
data/lib/droonga/server.rb +0 -67
data/lib/droonga/session.rb +85 -0
data/lib/droonga/test.rb +21 -0
data/lib/droonga/test/stub_distributor.rb +31 -0
data/lib/droonga/test/stub_handler.rb +37 -0
data/lib/droonga/test/stub_handler_message.rb +35 -0
data/lib/droonga/test/stub_handler_messenger.rb +34 -0
data/lib/droonga/time_formatter.rb +37 -0
data/lib/droonga/watcher.rb +1 -0
data/lib/droonga/worker.rb +16 -19
data/lib/fluent/plugin/out_droonga.rb +9 -9
data/lib/groonga_command_converter.rb +5 -5
data/sample/cluster/catalog.json +1 -1
data/test/command/config/default/catalog.json +19 -1
data/test/command/fixture/event.jsons +41 -0
data/test/command/fixture/user-table.jsons +9 -0
data/test/command/run-test.rb +2 -2
data/test/command/suite/add/error/invalid-integer.expected +20 -0
data/test/command/suite/add/error/invalid-integer.test +12 -0
data/test/command/suite/add/error/invalid-time.expected +20 -0
data/test/command/suite/add/error/invalid-time.test +12 -0
data/test/command/suite/add/error/missing-key.expected +13 -0
data/test/command/suite/add/error/missing-key.test +16 -0
data/test/command/suite/add/error/missing-table.expected +13 -0
data/test/command/suite/add/error/missing-table.test +16 -0
data/test/command/suite/add/error/unknown-column.expected +20 -0
data/test/command/suite/add/error/unknown-column.test +12 -0
data/test/command/suite/add/error/unknown-table.expected +13 -0
data/test/command/suite/add/error/unknown-table.test +17 -0
data/test/command/suite/add/minimum.expected +1 -3
data/test/command/suite/add/with-values.expected +1 -3
data/test/command/suite/add/without-key.expected +1 -3
data/test/command/suite/message/error/missing-dataset.expected +13 -0
data/test/command/suite/message/error/missing-dataset.test +5 -0
data/test/command/suite/message/error/unknown-command.expected +13 -0
data/test/command/suite/message/error/unknown-command.test +6 -0
data/test/command/suite/message/error/unknown-dataset.expected +13 -0
data/test/command/suite/message/error/unknown-dataset.test +6 -0
data/test/command/suite/search/{array-attribute-label.expected → attributes/array.expected} +0 -0
data/test/command/suite/search/{array-attribute-label.test → attributes/array.test} +0 -0
data/test/command/suite/search/{hash-attribute-label.expected → attributes/hash.expected} +0 -0
data/test/command/suite/search/{hash-attribute-label.test → attributes/hash.test} +0 -0
data/test/command/suite/search/{condition-nested.expected → condition/nested.expected} +0 -0
data/test/command/suite/search/{condition-nested.test → condition/nested.test} +0 -0
data/test/command/suite/search/{condition-query.expected → condition/query.expected} +0 -0
data/test/command/suite/search/{condition-query.test → condition/query.test} +0 -0
data/test/command/suite/search/{condition-script.expected → condition/script.expected} +0 -0
data/test/command/suite/search/{condition-script.test → condition/script.test} +0 -0
data/test/command/suite/search/error/cyclic-source.expected +18 -0
data/test/command/suite/search/error/cyclic-source.test +12 -0
data/test/command/suite/search/error/deeply-cyclic-source.expected +21 -0
data/test/command/suite/search/error/deeply-cyclic-source.test +15 -0
data/test/command/suite/search/error/missing-source-parameter.expected +17 -0
data/test/command/suite/search/error/missing-source-parameter.test +11 -0
data/test/command/suite/search/error/unknown-source.expected +18 -0
data/test/command/suite/search/error/unknown-source.test +12 -0
data/test/command/suite/search/{minimum.expected → group/count.expected} +2 -1
data/test/command/suite/search/{minimum.test → group/count.test} +5 -3
data/test/command/suite/search/group/limit.expected +19 -0
data/test/command/suite/search/group/limit.test +20 -0
data/test/command/suite/search/group/string.expected +36 -0
data/test/command/suite/search/group/string.test +44 -0
data/test/command/suite/search/{chained-queries.expected → multiple/chained.expected} +0 -0
data/test/command/suite/search/{chained-queries.test → multiple/chained.test} +0 -0
data/test/command/suite/search/{multiple-queries.expected → multiple/parallel.expected} +0 -0
data/test/command/suite/search/{multiple-queries.test → multiple/parallel.test} +0 -0
data/test/command/suite/search/{output-range.expected → range/only-output.expected} +0 -0
data/test/command/suite/search/{output-range.test → range/only-output.test} +0 -0
data/test/command/suite/search/{sort-range.expected → range/only-sort.expected} +0 -0
data/test/command/suite/search/{sort-range.test → range/only-sort.test} +0 -0
data/test/command/suite/search/{sort-and-output-range.expected → range/sort-and-output.expected} +0 -0
data/test/command/suite/search/{sort-and-output-range.test → range/sort-and-output.test} +0 -0
data/test/command/suite/search/range/too-large-output-offset.expected +16 -0
data/test/command/suite/search/range/too-large-output-offset.test +25 -0
data/test/command/suite/search/range/too-large-sort-offset.expected +16 -0
data/test/command/suite/search/range/too-large-sort-offset.test +28 -0
data/test/command/suite/search/response/records/value/time.expected +24 -0
data/test/command/suite/search/response/records/value/time.test +24 -0
data/test/command/suite/search/sort/default-offset-limit.expected +43 -0
data/test/command/suite/search/sort/default-offset-limit.test +26 -0
data/test/command/suite/search/{sort-with-invisible-column.expected → sort/invisible-column.expected} +0 -0
data/test/command/suite/search/{sort-with-invisible-column.test → sort/invisible-column.test} +0 -0
data/test/command/suite/watch/subscribe.expected +12 -0
data/test/command/suite/watch/subscribe.test +9 -0
data/test/command/suite/watch/unsubscribe.expected +12 -0
data/test/command/suite/watch/unsubscribe.test +9 -0
data/test/unit/{test_catalog.rb → catalog/test_version1.rb} +12 -4
data/test/unit/fixtures/{catalog.json → catalog/version1.json} +0 -0
data/test/unit/helper.rb +2 -0
data/test/unit/plugin/collector/test_basic.rb +289 -33
data/test/unit/plugin/distributor/test_search.rb +176 -861
data/test/unit/plugin/distributor/test_search_planner.rb +1102 -0
data/test/unit/plugin/handler/groonga/test_column_create.rb +17 -13
data/test/unit/plugin/handler/groonga/test_table_create.rb +10 -10
data/test/unit/plugin/handler/test_add.rb +74 -11
data/test/unit/plugin/handler/test_groonga.rb +15 -1
data/test/unit/plugin/handler/test_search.rb +33 -17
data/test/unit/plugin/handler/test_watch.rb +43 -27
data/test/unit/run-test.rb +2 -0
data/test/unit/test_message_pack_packer.rb +51 -0
data/test/unit/test_time_formatter.rb +29 -0
metadata +208 -110
data/lib/droonga/job_queue.rb +0 -87
data/lib/droonga/job_queue_schema.rb +0 -65
data/test/unit/test_adapter.rb +0 -51
data/test/unit/test_job_queue_schema.rb +0 -45

data/test/unit/plugin/distributor/test_search.rb CHANGED Viewed

@@ -16,899 +16,214 @@
 require "droonga/plugin/distributor/search"
 class SearchDistributorTest < Test::Unit::TestCase
-  include PluginHelper
   def setup
     setup_database
-    setup_plugin(Droonga::SearchDistributor)
+    @distributor = Droonga::Test::StubDistributor.new
+    @plugin = Droonga::SearchDistributor.new(@distributor)
   end
   def teardown
-    teardown_plugin
     teardown_database
   end
-  class MultipleQueriesTest < SearchDistributorTest
-    def test_distribute
-      envelope = {
-        "type" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "query1" => {
-              "source" => "User",
-              "output" => {
-                "format" => "complex",
-                "elements" => ["count", "records"],
-                "attributes" => [],
-                "offset" => 0,
-                "limit" => 10,
-              },
-            },
-            "query2" => {
-              "source" => "User",
-              "output" => {
-                "format" => "complex",
-                "elements" => ["count", "records"],
-                "attributes" => [],
-                "offset" => 0,
-                "limit" => 20,
-              },
-            },
-            "query3" => {
-              "source" => "User",
-              "output" => {
-                "format" => "complex",
-                "elements" => ["count", "records"],
-                "attributes" => [],
-                "offset" => 0,
-                "limit" => 30,
-              },
-            },
-          },
-        },
-      }
-      @plugin.process("search", envelope)
-      message = []
-      message << {
-        "type" => "reduce",
-        "body" => {
+  def test_distribute
+    envelope = {
+      "type" => "search",
+      "dataset" => "Droonga",
+      "body" => {
+        "queries" => {
           "query1" => {
-            "query1_reduced" => {
-              "count" => {
-                "type" => "sum",
-              },
-              "records" => {
-                "type" => "sort",
-                "operators" => [],
-                "limit" => 10,
-              },
+            "source" => "User",
+            "output" => {
+              "format" => "complex",
+              "elements" => ["count", "records"],
+              "attributes" => [],
+              "offset" => 0,
+              "limit" => 10,
             },
           },
-        },
-        "inputs" => ["query1"],
-        "outputs" => ["query1_reduced"],
-      }
-      message << {
-        "type" => "reduce",
-        "body" => {
           "query2" => {
-            "query2_reduced" => {
-              "count" => {
-                "type" => "sum",
-              },
-              "records" => {
-                "type" => "sort",
-                "operators" => [],
-                "limit" => 20,
-              },
+            "source" => "User",
+            "output" => {
+              "format" => "complex",
+              "elements" => ["count", "records"],
+              "attributes" => [],
+              "offset" => 0,
+              "limit" => 20,
             },
           },
-        },
-        "inputs" => ["query2"],
-        "outputs" => ["query2_reduced"],
-      }
-      message << {
-        "type" => "reduce",
-        "body" => {
           "query3" => {
-            "query3_reduced" => {
-              "count" => {
-                "type" => "sum",
-              },
-              "records" => {
-                "type" => "sort",
-                "operators" => [],
-                "limit" => 30,
-              },
+            "source" => "User",
+            "output" => {
+              "format" => "complex",
+              "elements" => ["count", "records"],
+              "attributes" => [],
+              "offset" => 0,
+              "limit" => 30,
             },
           },
         },
-        "inputs" => ["query3"],
-        "outputs" => ["query3_reduced"],
-      }
+      },
+    }
-      gatherer = {
-        "type" => "gather",
-        "body" => {
-          "query1_reduced" => {
-            "output" => "query1",
-            "element" => "records",
-            "offset" => 0,
-            "limit" => 10,
-            "format" => "complex",
-            "attributes" => [],
-          },
-          "query2_reduced" => {
-            "output" => "query2",
-            "element" => "records",
-            "offset" => 0,
-            "limit" => 20,
-            "format" => "complex",
-            "attributes" => [],
-          },
-          "query3_reduced" => {
-            "output" => "query3",
-            "element" => "records",
-            "offset" => 0,
-            "limit" => 30,
-            "format" => "complex",
-            "attributes" => [],
-          },
-        },
-        "inputs" => [
-          "query1_reduced",
-          "query2_reduced",
-          "query3_reduced",
-        ],
-        "post" => true,
-      }
-      message << gatherer
-      searcher = {
-        "type" => "broadcast",
-        "command" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "query1" => {
-              "source" => "User",
-              "output" => {
-                "format" => "simple",
-                "elements" => ["count", "records"],
-                "attributes" => [],
-                "offset" => 0,
-                "limit" => 10,
-              },
-            },
-            "query2" => {
-              "source" => "User",
-              "output" => {
-                "format" => "simple",
-                "elements" => ["count", "records"],
-                "attributes" => [],
-                "offset" => 0,
-                "limit" => 20,
-              },
-            },
-            "query3" => {
-              "source" => "User",
-              "output" => {
-                "format" => "simple",
-                "elements" => ["count", "records"],
-                "attributes" => [],
-                "offset" => 0,
-                "limit" => 30,
-              },
-            },
-          },
-        },
-        "outputs" => [
-          "query1",
-          "query2",
-          "query3",
-        ],
-        "replica" => "random",
-      }
-      message << searcher
-      assert_equal(message, @posted.last.last)
-    end
-  end
-  class SingleQueryTest < SearchDistributorTest
-    def test_no_output
-      envelope = {
-        "type" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "no_output" => {
-              "source" => "User",
-              "sortBy" => {
-                "keys" => ["name"],
-                "offset" => 0,
-                "limit" => 1,
-              },
-            },
-          },
-        },
-      }
-      @plugin.process("search", envelope)
+    @plugin.process("search", envelope)
-      message = []
-      message << gatherer(envelope, :no_output => true)
-      message << searcher(envelope, :no_output => true)
-      assert_equal(message, @posted.last.last)
-    end
+    message = []
-    def test_no_records_element
-      envelope = {
-        "type" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "no_records" => {
-              "source" => "User",
-              "sortBy" => {
-                "keys" => ["name"],
-                "offset" => 0,
-                "limit" => 1,
-              },
-              "output" => {
-                "elements" => ["count"],
-              },
-            },
-          },
-        },
-      }
-      @plugin.process("search", envelope)
-      message = []
-      message << reducer(envelope, {
-        "count" => {
-          "type" => "sum",
-        },
-      })
-      message << gatherer(envelope)
-      message << searcher(envelope, :output_limit => 0)
-      assert_equal(message, @posted.last.last)
-    end
-    def test_no_output_limit
-      envelope = {
-        "type" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "no_limit" => {
-              "source" => "User",
-              "output" => {
-                "format" => "complex",
-                "elements" => ["count", "records"],
-              },
-            },
-          },
-        },
-      }
-      @plugin.process("search", envelope)
-      message = []
-      message << reducer(envelope, {
-        "count" => {
-          "type" => "sum",
-        },
-      })
-      message << gatherer(envelope)
-      message << searcher(envelope, :output_offset => 0,
-                                    :output_limit => 0)
-      assert_equal(message, @posted.last.last)
-    end
-    def test_have_records
-      envelope = {
-        "type" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "have_records" => {
-              "source" => "User",
-              "output" => {
-                "format" => "complex",
-                "elements" => ["records"],
-                "attributes" => ["_key", "name", "age"],
-                "offset" => 0,
-                "limit" => 1,
-              },
-            },
-          },
-        },
-      }
-      @plugin.process("search", envelope)
-      message = []
-      message << reducer(envelope, {
-        "records" => {
-          "type" => "sort",
-          "operators" => [],
-          "limit" => 1,
-        },
-      })
-      message << gatherer(envelope, :offset => 0,
-                                    :limit => 1,
-                                    :element => "records",
-                                    :format => "complex",
-                                    :attributes => ["_key", "name", "age"])
-      message << searcher(envelope, :output_offset => 0,
-                                    :output_limit => 1)
-      assert_equal(message, @posted.last.last)
-    end
-    def test_have_output_offset
-      envelope = {
-        "type" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "have_records" => {
-              "source" => "User",
-              "output" => {
-                "format" => "complex",
-                "elements" => ["records"],
-                "attributes" => ["_key", "name", "age"],
-                "offset" => 1,
-                "limit" => 1,
-              },
-            },
-          },
-        },
-      }
-      @plugin.process("search", envelope)
-      message = []
-      message << reducer(envelope, {
-        "records" => {
-          "type" => "sort",
-          "operators" => [],
-          "limit" => 2,
-        },
-      })
-      message << gatherer(envelope, :offset => 1,
-                                    :limit => 1,
-                                    :element => "records",
-                                    :format => "complex",
-                                    :attributes => ["_key", "name", "age"])
-      message << searcher(envelope, :output_offset => 0,
-                                    :output_limit => 2)
-      assert_equal(message, @posted.last.last)
-    end
-    def test_have_simple_sortBy
-      envelope = {
-        "type" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "have_records" => {
-              "source" => "User",
-              "sortBy" => ["name"],
-              "output" => {
-                "format" => "complex",
-                "elements" => ["records"],
-                "attributes" => ["_key", "name", "age"],
-                "offset" => 0,
-                "limit" => 1,
-              },
-            },
-          },
-        },
-      }
-      @plugin.process("search", envelope)
-      message = []
-      message << reducer(envelope, {
-        "records" => {
-          "type" => "sort",
-          "operators" => [
-            { "column" => 1, "operator" => "<" },
-          ],
-          "limit" => 1,
-        },
-      })
-      message << gatherer(envelope, :offset => 0,
-                                    :limit => 1,
-                                    :element => "records",
-                                    :format => "complex",
-                                    :attributes => ["_key", "name", "age"])
-      message << searcher(envelope, :output_offset => 0,
-                                    :output_limit => 1)
-      assert_equal(message, @posted.last.last)
-    end
-    def test_have_sortBy
-      envelope = {
-        "type" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "have_records" => {
-              "source" => "User",
-              "sortBy" => {
-                "keys" => ["name"],
-              },
-              "output" => {
-                "format" => "complex",
-                "elements" => ["records"],
-                "attributes" => ["_key", "name", "age"],
-                "offset" => 0,
-                "limit" => 1,
-              },
-            },
-          },
-        },
-      }
-      @plugin.process("search", envelope)
-      message = []
-      message << reducer(envelope, {
-        "records" => {
-          "type" => "sort",
-          "operators" => [
-            { "column" => 1, "operator" => "<" },
-          ],
-          "limit" => 1,
-        },
-      })
-      message << gatherer(envelope, :offset => 0,
-                                    :limit => 1,
-                                    :element => "records",
-                                    :format => "complex",
-                                    :attributes => ["_key", "name", "age"])
-      message << searcher(envelope, :sort_offset => 0,
-                                    :sort_limit => 1,
-                                    :output_offset => 0,
-                                    :output_limit => 1)
-      assert_equal(message, @posted.last.last)
-    end
-    def test_have_sortBy_offset_limit
-      envelope = {
-        "type" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "have_records" => {
-              "source" => "User",
-              "sortBy" => {
-                "keys" => ["name"],
-                "offset" => 1,
-                "limit" => 2,
-              },
-              "output" => {
-                "format" => "complex",
-                "elements" => ["records"],
-                "attributes" => ["_key", "name", "age"],
-                "offset" => 4,
-                "limit" => 8,
-              },
-            },
-          },
-        },
-      }
-      @plugin.process("search", envelope)
-      message = []
-      message << reducer(envelope, {
-        "records" => {
-          "type" => "sort",
-          "operators" => [
-            { "column" => 1, "operator" => "<" },
-          ],
-          "limit" => 1 + 4 + [2, 8].min,
-        },
-      })
-      message << gatherer(envelope, :offset => 5,
-                                    :limit => 2,
-                                    :element => "records",
-                                    :format => "complex",
-                                    :attributes => ["_key", "name", "age"])
-      message << searcher(envelope, :sort_offset => 0,
-                                    :sort_limit => 7,
-                                    :output_offset => 0,
-                                    :output_limit => 7)
-      assert_equal(message, @posted.last.last)
-    end
-    def test_have_sortBy_with_infinity_output_limit
-      envelope = {
-        "type" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "have_records" => {
-              "source" => "User",
-              "sortBy" => {
-                "keys" => ["name"],
-                "offset" => 1,
-                "limit" => 2,
-              },
-              "output" => {
-                "format" => "complex",
-                "elements" => ["records"],
-                "attributes" => ["_key", "name", "age"],
-                "offset" => 4,
-                "limit" => -1,
-              },
+    message << {
+      "type" => "reduce",
+      "body" => {
+        "query1" => {
+          "query1_reduced" => {
+            "count" => {
+              "type" => "sum",
             },
-          },
-        },
-      }
-      @plugin.process("search", envelope)
-      message = []
-      message << reducer(envelope, {
-        "records" => {
-          "type" => "sort",
-          "operators" => [
-            { "column" => 1, "operator" => "<" },
-          ],
-          "limit" => 1 + 4 + 2,
-        },
-      })
-      message << gatherer(envelope, :offset => 5,
-                                    :limit => 2,
-                                    :element => "records",
-                                    :format => "complex",
-                                    :attributes => ["_key", "name", "age"])
-      message << searcher(envelope, :sort_offset => 0,
-                                    :sort_limit => 7,
-                                    :output_offset => 0,
-                                    :output_limit => 7)
-      assert_equal(message, @posted.last.last)
-    end
-    def test_have_sortBy_with_infinity_sort_limit
-      envelope = {
-        "type" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "have_records" => {
-              "source" => "User",
-              "sortBy" => {
-                "keys" => ["name"],
-                "offset" => 1,
-                "limit" => -1,
-              },
-              "output" => {
-                "format" => "complex",
-                "elements" => ["records"],
-                "attributes" => ["_key", "name", "age"],
-                "offset" => 4,
-                "limit" => 8,
-              },
+            "records" => {
+              "type" => "sort",
+              "operators" => [],
+              "limit" => 10,
             },
           },
         },
-      }
-      @plugin.process("search", envelope)
-      message = []
-      message << reducer(envelope, {
-        "records" => {
-          "type" => "sort",
-          "operators" => [
-            { "column" => 1, "operator" => "<" },
-          ],
-          "limit" => 1 + 4 + 8,
-        },
-      })
-      message << gatherer(envelope, :offset => 5,
-                                    :limit => 8,
-                                    :element => "records",
-                                    :format => "complex",
-                                    :attributes => ["_key", "name", "age"])
-      message << searcher(envelope, :sort_offset => 0,
-                                    :sort_limit => 8,
-                                    :output_offset => 0,
-                                    :output_limit => 8)
-      assert_equal(message, @posted.last.last)
-    end
-    def test_have_sortBy_with_infinity_limit
-      envelope = {
-        "type" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "have_records" => {
-              "source" => "User",
-              "sortBy" => {
-                "keys" => ["name"],
-                "offset" => 1,
-                "limit" => -1,
-              },
-              "output" => {
-                "format" => "complex",
-                "elements" => ["records"],
-                "attributes" => ["_key", "name", "age"],
-                "offset" => 4,
-                "limit" => -1,
-              },
+      },
+      "inputs" => ["query1"],
+      "outputs" => ["query1_reduced"],
+    }
+    message << {
+      "type" => "reduce",
+      "body" => {
+        "query2" => {
+          "query2_reduced" => {
+            "count" => {
+              "type" => "sum",
             },
-          },
-        },
-      }
-      @plugin.process("search", envelope)
-      message = []
-      message << reducer(envelope, {
-        "records" => {
-          "type" => "sort",
-          "operators" => [
-            { "column" => 1, "operator" => "<" },
-          ],
-          "limit" => -1,
-        },
-      })
-      message << gatherer(envelope, :offset => 5,
-                                    :limit => -1,
-                                    :element => "records",
-                                    :format => "complex",
-                                    :attributes => ["_key", "name", "age"])
-      message << searcher(envelope, :sort_offset => 0,
-                                    :sort_limit => -1,
-                                    :output_offset => 0,
-                                    :output_limit => -1)
-      assert_equal(message, @posted.last.last)
-    end
-    def test_have_sortBy_with_multiple_sort_keys
-      envelope = {
-        "type" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "have_records" => {
-              "source" => "User",
-              "sortBy" => {
-                "keys" => ["-age", "name"],
-                "limit" => -1,
-              },
-              "output" => {
-                "format" => "complex",
-                "elements" => ["records"],
-                "attributes" => ["_key", "name", "age"],
-                "limit" => -1,
-              },
+            "records" => {
+              "type" => "sort",
+              "operators" => [],
+              "limit" => 20,
             },
           },
         },
-      }
-      @plugin.process("search", envelope)
-      message = []
-      message << reducer(envelope, {
-        "records" => {
-          "type" => "sort",
-          "operators" => [
-            { "column" => 2, "operator" => ">" },
-            { "column" => 1, "operator" => "<" },
-          ],
-          "limit" => -1,
-        },
-      })
-      message << gatherer(envelope, :offset => 0,
-                                    :limit => -1,
-                                    :element => "records",
-                                    :format => "complex",
-                                    :attributes => ["_key", "name", "age"])
-      message << searcher(envelope, :sort_offset => 0,
-                                    :sort_limit => -1,
-                                    :output_offset => 0,
-                                    :output_limit => -1)
-      assert_equal(message, @posted.last.last)
-    end
-    def test_have_sortBy_with_missing_sort_attributes
-      envelope = {
-        "type" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "have_records" => {
-              "source" => "User",
-              "sortBy" => {
-                "keys" => ["-public_age", "public_name"],
-                "limit" => -1,
-              },
-              "output" => {
-                "format" => "complex",
-                "elements" => ["records"],
-                "attributes" => ["_key", "name", "age"],
-                "limit" => -1,
-              },
+      },
+      "inputs" => ["query2"],
+      "outputs" => ["query2_reduced"],
+    }
+    message << {
+      "type" => "reduce",
+      "body" => {
+        "query3" => {
+          "query3_reduced" => {
+            "count" => {
+              "type" => "sum",
+            },
+            "records" => {
+              "type" => "sort",
+              "operators" => [],
+              "limit" => 30,
+            },
+          },
+        },
+      },
+      "inputs" => ["query3"],
+      "outputs" => ["query3_reduced"],
+    }
+    gatherer = {
+      "type" => "gather",
+      "body" => {
+        "query1_reduced" => {
+          "output" => "query1",
+          "elements" => {
+            "records" => {
+              "type" => "sort",
+              "offset" => 0,
+              "limit" => 10,
+              "format" => "complex",
+              "attributes" => [],
+            },
+          },
+        },
+        "query2_reduced" => {
+          "output" => "query2",
+          "elements" => {
+            "records" => {
+              "type" => "sort",
+              "offset" => 0,
+              "limit" => 20,
+              "format" => "complex",
+              "attributes" => [],
+            },
+          },
+        },
+        "query3_reduced" => {
+          "output" => "query3",
+          "elements" => {
+            "records" => {
+              "type" => "sort",
+              "offset" => 0,
+              "limit" => 30,
+              "format" => "complex",
+              "attributes" => [],
+            },
+          },
+        },
+      },
+      "inputs" => [
+        "query1_reduced",
+        "query2_reduced",
+        "query3_reduced",
+      ],
+      "post" => true,
+    }
+    message << gatherer
+    searcher = {
+      "type" => "broadcast",
+      "command" => "search",
+      "dataset" => "Droonga",
+      "body" => {
+        "queries" => {
+          "query1" => {
+            "source" => "User",
+            "output" => {
+              "format" => "simple",
+              "elements" => ["count", "records"],
+              "attributes" => [],
+              "offset" => 0,
+              "limit" => 10,
             },
           },
-        },
-      }
-      @plugin.process("search", envelope)
-      message = []
-      message << reducer(envelope, {
-        "records" => {
-          "type" => "sort",
-          "operators" => [
-            { "column" => 3, "operator" => ">" },
-            { "column" => 4, "operator" => "<" },
-          ],
-          "limit" => -1,
-        },
-      })
-      message << gatherer(envelope, :offset => 0,
-                                    :limit => -1,
-                                    :element => "records",
-                                    :format => "complex",
-                                    :attributes => ["_key", "name", "age"])
-      message << searcher(envelope, :sort_offset => 0,
-                                    :sort_limit => -1,
-                                    :output_offset => 0,
-                                    :output_limit => -1,
-                                    :extra_attributes => ["public_age", "public_name"])
-      assert_equal(message, @posted.last.last)
-    end
-    def test_hash_attributes
-      envelope = {
-        "type" => "search",
-        "dataset" => "Droonga",
-        "body" => {
-          "queries" => {
-            "have_records" => {
-              "source" => "User",
-              "sortBy" => {
-                "keys" => ["-public_age", "public_name"],
-                "limit" => -1,
-              },
-              "output" => {
-                "format" => "complex",
-                "elements" => ["records"],
-                "attributes" => {
-                  "id" => "_key",
-                  "name" => { "source" => "name" },
-                  "age" => { "source" => "age" },
-                },
-                "limit" => -1,
-              },
+          "query2" => {
+            "source" => "User",
+            "output" => {
+              "format" => "simple",
+              "elements" => ["count", "records"],
+              "attributes" => [],
+              "offset" => 0,
+              "limit" => 20,
             },
           },
-        },
-      }
-      @plugin.process("search", envelope)
-      message = []
-      message << reducer(envelope, {
-        "records" => {
-          "type" => "sort",
-          "operators" => [
-            { "column" => 3, "operator" => ">" },
-            { "column" => 4, "operator" => "<" },
-          ],
-          "limit" => -1,
-        },
-      })
-      message << gatherer(envelope, :offset => 0,
-                                    :limit => -1,
-                                    :element => "records",
-                                    :format => "complex",
-                                    :attributes => ["id", "name", "age"])
-      message << searcher(envelope, :sort_offset => 0,
-                                    :sort_limit => -1,
-                                    :output_offset => 0,
-                                    :output_limit => -1,
-                                    :extra_attributes => ["public_age", "public_name"])
-      assert_equal(message, @posted.last.last)
-    end
-    private
-    def reducer(search_request_envelope, reducer_body)
-      queries = search_request_envelope["body"]["queries"]
-      query_name = queries.keys.first
-      reducer = {
-        "type" => "reduce",
-        "body" => {
-          query_name => {
-            "#{query_name}_reduced" => reducer_body,
-          },
-        },
-        "inputs" => [query_name],
-        "outputs" => ["#{query_name}_reduced"],
-      }
-      reducer
-    end
-    def gatherer(search_request_envelope, options={})
-      queries = search_request_envelope["body"]["queries"]
-      query_name = queries.keys.first
-      gatherer = {
-        "type" => "gather",
-        "body" => {
-        },
-        "inputs" => [
-        ],
-        "post" => true,
-      }
-      unless options[:no_output]
-        output = {
-          "output" => query_name,
-        }
-        if options[:element]
-          output.merge!({
-            "element" => options[:element],
-            "offset" => options[:offset] || 0,
-            "limit" => options[:limit] || 0,
-            "format" => options[:format] || "simple",
-            "attributes" => options[:attributes] || [],
-          })
-        end
-        gatherer["body"]["#{query_name}_reduced"] = output
-        gatherer["inputs"] << "#{query_name}_reduced"
-      end
-      gatherer
-    end
-    def searcher(search_request_envelope, options={})
-      searcher = search_request_envelope.dup
-      queries = searcher["body"]["queries"]
-      query_name = queries.keys.first
-      query = queries.values.first
-      if options[:extra_attributes]
-        query["output"]["attributes"] += options[:extra_attributes]
-      end
-      if options[:sort_offset]
-        query["sortBy"]["offset"] = options[:sort_offset]
-      end
-      if options[:sort_limit]
-        query["sortBy"]["limit"] = options[:sort_limit]
-      end
-      if options[:output_offset]
-        query["output"]["offset"] = options[:output_offset]
-      end
-      if options[:output_limit]
-        query["output"]["limit"] = options[:output_limit]
-      end
-      outputs = []
-      outputs << query_name unless options[:no_output]
-      searcher["type"] = "broadcast"
-      searcher["command"] = "search"
-      searcher["outputs"] = outputs
-      searcher["replica"] = "random"
-      searcher
-    end
+          "query3" => {
+            "source" => "User",
+            "output" => {
+              "format" => "simple",
+              "elements" => ["count", "records"],
+              "attributes" => [],
+              "offset" => 0,
+              "limit" => 30,
+            },
+          },
+        },
+      },
+      "outputs" => [
+        "query1",
+        "query2",
+        "query3",
+      ],
+      "replica" => "random",
+    }
+    message << searcher
+    assert_equal([message], @distributor.messages)
   end
 end