groonga-client 0.6.0 → 0.6.5

data/lib/groonga/client/response/logical-select.rb

@@ -0,0 +1,28 @@
+# Copyright (C) 2019  Sutou Kouhei <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 as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "groonga/client/response/select"
+
+module Groonga
+  class Client
+    module Response
+      class LogicalSelect < Select
+        Response.register("logical_select", self)
+      end
+    end
+  end
+end
+

data/lib/groonga/client/response/searchable.rb

@@ -0,0 +1,97 @@
+# Copyright (C) 2019  Sutou Kouhei <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 as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+module Groonga
+  class Client
+    module Response
+      module Searchable
+        include Enumerable
+
+        attr_accessor :records
+        attr_accessor :raw_columns
+        attr_accessor :raw_records
+
+        # For Kaminari
+        def limit_value
+          (@command[:limit] || 10).to_i
+        end
+
+        # For Kaminari
+        def offset_value
+          (@command[:offset] || 0).to_i
+        end
+
+        # For Kaminari
+        def size
+          records.size
+        end
+
+        def each(&block)
+          records.each(&block)
+        end
+
+        private
+        def parse_records(raw_columns, raw_records)
+          column_names = {}
+          columns = raw_columns.collect do |column|
+            if column.is_a?(::Array)
+              name, type = column
+            else
+              name = column["name"]
+              type = column["type"]
+            end
+            base_column_name = name
+            suffix = 2
+            while column_names.key?(name)
+              name = "#{base_column_name}#{suffix}"
+              suffix += 1
+            end
+            column_names[name] = true
+            [name, type]
+          end
+
+          (raw_records || []).collect do |raw_record|
+            record = Record.new
+            columns.each_with_index do |(name, type), i|
+              record[name] = convert_value(raw_record[i], type)
+            end
+            record
+          end
+        end
+
+        def convert_value(value, type)
+          case value
+          when ::Array
+            value.collect do |element|
+              convert_value(element, type)
+            end
+          else
+            case type
+            when "Time"
+              Time.at(value)
+            else
+              value
+            end
+          end
+        end
+
+        class Record < ::Hash
+          include Hashie::Extensions::MethodAccess
+        end
+      end
+    end
+  end
+end

data/lib/groonga/client/response/select.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2013-2016  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2013-2019  Sutou Kouhei <kou@clear-code.com>
 # Copyright (C) 2013  Kosuke Asami
 # Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 #
@@ -17,6 +17,8 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 require "groonga/client/response/base"
+require "groonga/client/response/drilldownable"
+require "groonga/client/response/searchable"
 
 module Groonga
   class Client
@@ -174,23 +176,14 @@ module Groonga
           end
         end
 
-        include Enumerable
+        include Drilldownable
+        include Searchable
 
         # @return [Integer] The number of records that match againt
         #   a search condition.
         attr_accessor :n_hits
         # For Kaminari
         alias_method :total_count, :n_hits
-        attr_accessor :records
-
-        # @return [::Array<Groonga::Client::Response::Select::Drilldown>,
-        #          ::Hash<String, Groonga::Client::Response::Select::Drilldown>]
-        #   If labeled drilldowns are used or command version 3 or
-        #   later is used, `{"label1" => drilldown1, "label2" => drilldown2}`
-        #   is returned since 0.3.1.
-        #
-        #   Otherwise, `[drilldown1, drilldown2]` is returned.
-        attr_accessor :drilldowns
 
         # @return [::Hash<String, Groonga::Client::Response::Select::Slice>]
         #
@@ -202,29 +195,11 @@ module Groonga
           parse_body(body)
         end
 
-        # For Kaminari
-        def limit_value
-          (@command[:limit] || 10).to_i
-        end
-
-        # For Kaminari
-        def offset_value
-          (@command[:offset] || 0).to_i
-        end
-
-        # For Kaminari
-        def size
-          records.size
-        end
-
-        def each(&block)
-          records.each(&block)
-        end
-
         private
         def parse_body(body)
           if body.is_a?(::Array)
-            @n_hits, @records = parse_match_records_v1(body.first)
+            @n_hits, @raw_columns, @raw_records, @records =
+              parse_record_set_v1(body.first)
             if @command.slices.empty?
               raw_slices = nil
               raw_drilldowns = body[1..-1]
@@ -232,105 +207,74 @@ module Groonga
               raw_slices, *raw_drilldowns = body[1..-1]
             end
             @slices = parse_slices_v1(raw_slices)
-            @drilldowns = parse_drilldowns_v1(raw_drilldowns)
-          else
-            @n_hits, @records = parse_match_records_v3(body)
-            @drilldowns = parse_drilldowns_v3(body["drilldowns"])
-            @slices = parse_slices_v3(body["slices"])
-          end
-          body
-        end
-
-        def parse_records(raw_columns, raw_records)
-          column_names = {}
-          columns = raw_columns.collect do |column|
-            if column.is_a?(::Array)
-              name, type = column
+            drilldown_keys = @command.drilldowns
+            labeled_drilldowns = @command.labeled_drilldowns
+            if drilldown_keys.empty? and !labeled_drilldowns.empty?
+              @drilldowns = parse_labeled_drilldowns(labeled_drilldowns,
+                                                     raw_drilldowns[0])
             else
-              name = column["name"]
-              type = column["type"]
-            end
-            base_column_name = name
-            suffix = 2
-            while column_names.key?(name)
-              name = "#{base_column_name}#{suffix}"
-              suffix += 1
-            end
-            column_names[name] = true
-            [name, type]
-          end
-
-          (raw_records || []).collect do |raw_record|
-            record = Record.new
-            columns.each_with_index do |(name, type), i|
-              record[name] = convert_value(raw_record[i], type)
-            end
-            record
-          end
-        end
-
-        def convert_value(value, type)
-          case value
-          when ::Array
-            value.collect do |element|
-              convert_value(element, type)
+              @drilldowns = parse_drilldowns(drilldown_keys, raw_drilldowns)
             end
           else
-            case type
-            when "Time"
-              Time.at(value)
-            else
-              value
+            @n_hits, @raw_columns, @raw_records, @records =
+              parse_record_set_v3(body)
+            drilldown_keys = @command.drilldowns
+            labeled_drilldowns = @command.labeled_drilldowns
+            if labeled_drilldowns.empty?
+              drilldown_keys.each do |key|
+                labeled_drilldown =
+                  Groonga::Command::Drilldownable::Drilldown.new
+                labeled_drilldown.label = key
+                labeled_drilldown.keys = [key]
+                labeled_drilldowns[key] = labeled_drilldown
+              end
             end
+            @drilldowns = parse_labeled_drilldowns(labeled_drilldowns,
+                                                   body["drilldowns"])
+            @slices = parse_slices_v3(body["slices"])
           end
+          body
         end
 
-        def parse_match_records_v1(raw_records)
+        def parse_record_set_v1(raw_record_set)
+          n_hits = raw_record_set.first.first
+          raw_columns = raw_record_set[1]
+          raw_records = raw_record_set[2..-1] || []
           [
-            raw_records.first.first,
-            parse_records(raw_records[1], raw_records[2..-1]),
+            n_hits,
+            raw_columns,
+            raw_records,
+            parse_records(raw_columns, raw_records),
           ]
         end
 
-        def parse_match_records_v3(raw_records)
+        def parse_record_set_v3(raw_record_set)
+          n_hits = raw_record_set["n_hits"]
+          raw_columns = raw_record_set["columns"]
+          raw_records = raw_record_set["records"] || []
           [
-            raw_records["n_hits"],
-            parse_records(raw_records["columns"], raw_records["records"]),
+            n_hits,
+            raw_columns,
+            raw_records,
+            parse_records(raw_columns, raw_records),
           ]
         end
 
-        def parse_drilldowns_v1(raw_drilldowns)
-          request_drilldowns = @command.drilldowns
-          if request_drilldowns.empty? and !@command.labeled_drilldowns.empty?
-            drilldowns = {}
-            (raw_drilldowns[0] || {}).each do |label, raw_drilldown|
-              n_hits, records = parse_match_records_v1(raw_drilldown)
-              drilldowns[label] = Drilldown.new(label, n_hits, records)
-            end
-            drilldowns
-          else
-            (raw_drilldowns || []).collect.with_index do |raw_drilldown, i|
-              key = request_drilldowns[i]
-              n_hits, records = parse_match_records_v1(raw_drilldown)
-              Drilldown.new(key, n_hits, records)
-            end
-          end
-        end
-
-        def parse_drilldowns_v3(raw_drilldowns)
-          drilldowns = {}
-          (raw_drilldowns || {}).each do |key, raw_drilldown|
-            n_hits, records = parse_match_records_v3(raw_drilldown)
-            drilldowns[key] = Drilldown.new(key, n_hits, records)
-          end
-          drilldowns
-        end
-
         def parse_slices_v1(raw_slices)
           slices = {}
           (raw_slices || {}).each do |key, raw_slice|
-            n_hits, records = parse_match_records_v1(raw_slice)
-            slices[key] = Slice.new(key, n_hits, records)
+            requested_slice = @command.slices[key]
+            if raw_slice.last.is_a?(::Hash)
+              raw_drilldowns = raw_slice.last
+              raw_slice = raw_slice[0..-2]
+              drilldowns =
+                parse_labeled_drilldowns(requested_slice.labeled_drilldowns,
+                                         raw_drilldowns)
+            else
+              drilldowns = {}
+            end
+            n_hits, _, _, records = parse_record_set_v1(raw_slice)
+            slices[key] = Slice.new(key, n_hits, records, drilldowns)
           end
           slices
         end
@@ -338,22 +282,17 @@ module Groonga
         def parse_slices_v3(raw_slices)
           slices = {}
           (raw_slices || {}).each do |key, raw_slice|
-            n_hits, records = parse_match_records_v3(raw_slice)
-            slices[key] = Slice.new(key, n_hits, records)
+            requested_slice = @command.slices[key]
+            n_hits, _, _, records = parse_record_set_v3(raw_slice)
+              drilldowns =
+                parse_labeled_drilldowns(requested_slice.labeled_drilldowns,
+                                         raw_slice["drilldowns"])
+            slices[key] = Slice.new(key, n_hits, records, drilldowns)
           end
           slices
         end
 
-        class Record < ::Hash
-          include Hashie::Extensions::MethodAccess
-        end
-
-        class Drilldown < Struct.new(:key, :n_hits, :records)
-          # @deprecated since 0.2.6. Use {#records} instead.
-          alias_method :items, :records
-        end
-
-        class Slice < Struct.new(:key, :n_hits, :records)
+        class Slice < Struct.new(:key, :n_hits, :records, :drilldowns)
         end
       end
     end

data/lib/groonga/client/version.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2013-2018  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2013-2021  Sutou Kouhei <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
@@ -16,6 +16,6 @@
 
 module Groonga
   class Client
-    VERSION = "0.6.0"
+    VERSION = "0.6.5"
   end
 end

data/test/request/test-select.rb

@@ -186,8 +186,8 @@ class TestRequestSelect < Test::Unit::TestCase
   end
 
   sub_test_case("#paginate") do
-    def paginate(*args)
-      @request.paginate(*args).to_parameters
+    def paginate(*args, **kwargs)
+      @request.paginate(*args, **kwargs).to_parameters
     end
 
     sub_test_case("page") do

data/test/response/test-select-command-version1.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2013-2016  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2013-2020  Sutou Kouhei <kou@clear-code.com>
 # Copyright (C) 2013  Kosuke Asami
 # Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 #
@@ -320,12 +320,14 @@ class TestResponseSelectCommandVersion1 < Test::Unit::TestCase
     class TestSlices < self
       def setup
         pair_arguments = {
-          "slices[groonga].filter" => 'tag @ "groonga"',
+          "slices[groonga].filter" => "tag @ 'groonga'",
+          "slices[groonga].limit" => "2",
+          "slices[groonga].drilldowns[author].keys" => "author",
         }
         @command = Groonga::Command::Select.new("select", pair_arguments)
         @body = [
           [
-            [3],
+            [4],
             [
               [
                 "_id",
@@ -339,10 +341,11 @@ class TestResponseSelectCommandVersion1 < Test::Unit::TestCase
             [1, "groonga"],
             [2, "rroonga"],
             [3, "groonga"],
+            [4, "groonga"],
           ],
           {
             "groonga" => [
-              [2],
+              [3],
               [
                 [
                   "_id",
@@ -355,19 +358,55 @@ class TestResponseSelectCommandVersion1 < Test::Unit::TestCase
               ],
               [1, "groonga"],
               [3, "groonga"],
-            ]
-          }
+              {
+                "author" => [
+                  [3],
+                  [
+                    [
+                      "_key",
+                      "ShortText",
+                    ],
+                    [
+                      "_nsubrecs",
+                      "Int32",
+                    ],
+                  ],
+                  [
+                    "Alice",
+                    1,
+                  ],
+                  [
+                    "Bob",
+                    1,
+                  ],
+                  [
+                    "Chris",
+                    1,
+                  ],
+                ],
+              },
+            ],
+          },
         ]
       end
 
       def test_slices
         assert_equal({
-                       "groonga" => [
-                         {"_id" => 1, "tag" => "groonga"},
-                         {"_id" => 3, "tag" => "groonga"},
-                       ]
+                       "groonga" => {
+                         records: [
+                           {"_id" => 1, "tag" => "groonga"},
+                           {"_id" => 3, "tag" => "groonga"},
+                         ],
+                         drilldowns: {
+                           "author" => [
+                             {"_key" => "Alice", "_nsubrecs" => 1},
+                             {"_key" => "Bob",   "_nsubrecs" => 1},
+                             {"_key" => "Chris", "_nsubrecs" => 1},
+                           ],
+                         },
+                       },
                      },
-                     collect_values(@body, &:records))
+                     collect_values(@body))
       end
 
       private
@@ -378,7 +417,14 @@ class TestResponseSelectCommandVersion1 < Test::Unit::TestCase
       def collect_values(body)
         values = {}
         slices(body).each do |label, slice|
-          values[label] = yield(slice)
+          drilldowns = {}
+          slice.drilldowns.each do |drilldown_label, drilldown|
+            drilldowns[drilldown_label] = drilldown.records
+          end
+          values[label] = {
+            records: slice.records,
+            drilldowns: drilldowns,
+          }
         end
         values
       end