groonga-client 0.3.3 → 0.3.4

data/test/response/test-schema.rb

@@ -157,6 +157,112 @@ class TestResponseSchema < Test::Unit::TestCase
         assert_equal("Names.users",
                      response.tables["Users"].indexes[0].full_name)
       end
+
+      sub_test_case "#have_full_text_search_index" do
+        test "no tokenizer" do
+          body = {
+            "tables" => {
+              "Names" => {
+                "name" => "Names",
+                "columns" => {
+                  "users_key" => {
+                    "name" => "users_key",
+                    "position" => true,
+                  },
+                },
+                "tokenizer" => nil,
+              },
+              "Users" => {
+                "indexes" => [
+                  {
+                    "table" => "Names",
+                    "name" => "users_key",
+                  },
+                ],
+              },
+            },
+          }
+          response = create_response(body)
+          table = response.tables["Users"]
+          assert do
+            not table.have_full_text_search_index?
+          end
+        end
+
+        test "no position" do
+          body = {
+            "tokenizers" => {
+              "TokenDelimit" => {
+                "name" => "TokenDelimit",
+              },
+            },
+            "tables" => {
+              "Names" => {
+                "name" => "Names",
+                "columns" => {
+                  "users_key" => {
+                    "name" => "users_key",
+                    "position" => false,
+                  },
+                },
+                "tokenizer" => {
+                  "name" => "TokenDelimit",
+                },
+              },
+              "Users" => {
+                "indexes" => [
+                  {
+                    "table" => "Names",
+                    "name" => "users_key",
+                  },
+                ],
+              },
+            },
+          }
+          response = create_response(body)
+          table = response.tables["Users"]
+          assert do
+            not table.have_full_text_search_index?
+          end
+        end
+
+        test "have tokenizer and position" do
+          body = {
+            "tokenizers" => {
+              "TokenBigram" => {
+                "name" => "TokenBigram",
+              },
+            },
+            "tables" => {
+              "Names" => {
+                "name" => "Names",
+                "columns" => {
+                  "users_key" => {
+                    "name" => "users_key",
+                    "position" => true,
+                  },
+                },
+                "tokenizer" => {
+                  "name" => "TokenBigram",
+                },
+              },
+              "Users" => {
+                "indexes" => [
+                  {
+                    "table" => "Names",
+                    "name" => "users_key",
+                  },
+                ],
+              },
+            },
+          }
+          response = create_response(body)
+          table = response.tables["Users"]
+          assert do
+            table.have_full_text_search_index?
+          end
+        end
+      end
     end
 
     class TestColumn < self
@@ -180,6 +286,130 @@ class TestResponseSchema < Test::Unit::TestCase
         assert_equal("Ages.users",
                      response.tables["Users"].columns["age"].indexes[0].full_name)
       end
+
+      sub_test_case "#have_full_text_search_index" do
+        test "no tokenizer" do
+          body = {
+            "tables" => {
+              "Names" => {
+                "name" => "Names",
+                "columns" => {
+                  "users_name" => {
+                    "name" => "users_names",
+                    "position" => true,
+                  },
+                },
+                "tokenizer" => nil,
+              },
+              "Users" => {
+                "columns" => {
+                  "names" => {
+                    "name" => "names",
+                    "type" => "vector",
+                    "indexes" => [
+                      {
+                        "table" => "Names",
+                        "name" => "users_names",
+                      },
+                    ],
+                  },
+                },
+              },
+            },
+          }
+          response = create_response(body)
+          column = response.tables["Users"].columns["names"]
+          assert do
+            not column.have_full_text_search_index?
+          end
+        end
+
+        test "no position" do
+          body = {
+            "tokenizers" => {
+              "TokenDelimit" => {
+                "name" => "TokenDelimit",
+              },
+            },
+            "tables" => {
+              "Names" => {
+                "name" => "Names",
+                "columns" => {
+                  "users_names" => {
+                    "name" => "users_names",
+                    "position" => false,
+                  },
+                },
+                "tokenizer" => {
+                  "name" => "TokenDelimit",
+                },
+              },
+              "Users" => {
+                "columns" => {
+                  "names" => {
+                    "name" => "names",
+                    "type" => "vector",
+                    "indexes" => [
+                      {
+                        "table" => "Names",
+                        "name" => "users_names",
+                      },
+                    ],
+                  },
+                },
+              },
+            },
+          }
+          response = create_response(body)
+          column = response.tables["Users"].columns["names"]
+          assert do
+            not column.have_full_text_search_index?
+          end
+        end
+
+        test "have tokenizer and position" do
+          body = {
+            "tokenizers" => {
+              "TokenBigram" => {
+                "name" => "TokenBigram",
+              },
+            },
+            "tables" => {
+              "Names" => {
+                "name" => "Names",
+                "columns" => {
+                  "users_name" => {
+                    "name" => "users_name",
+                    "position" => true,
+                  },
+                },
+                "tokenizer" => {
+                  "name" => "TokenBigram",
+                },
+              },
+              "Users" => {
+                "columns" => {
+                  "name" => {
+                    "name" => "name",
+                    "type" => "scalar",
+                    "indexes" => [
+                      {
+                        "table" => "Names",
+                        "name" => "users_name",
+                      },
+                    ],
+                  },
+                },
+              },
+            },
+          }
+          response = create_response(body)
+          column = response.tables["Users"].columns["name"]
+          assert do
+            column.have_full_text_search_index?
+          end
+        end
+      end
     end
 
     class TestIndex < self
@@ -228,6 +458,118 @@ class TestResponseSchema < Test::Unit::TestCase
         assert_equal(response.tables["Names"].columns["users_key"],
                      response.tables["Users"].indexes[0].column)
       end
+
+      sub_test_case("#full_text_searchable?") do
+        test "no tokenizer" do
+          body = {
+            "tables" => {
+              "Names" => {
+                "name" => "Names",
+                "columns" => {
+                  "users_names" => {
+                    "name" => "users_names",
+                    "position" => true,
+                  },
+                },
+                "tokenizer" => nil,
+              },
+              "Users" => {
+                "columns" => {
+                  "names" => {
+                    "name" => "names",
+                    "type" => "vector",
+                    "indexes" => [
+                      {
+                        "table" => "Names",
+                        "name" => "users_names",
+                      },
+                    ],
+                  },
+                },
+              },
+            },
+          }
+          response = create_response(body)
+          index = response.tables["Users"].columns["names"].indexes[0]
+          assert do
+            not index.full_text_searchable?
+          end
+        end
+
+        test "no position" do
+          body = {
+            "tokenizers" => {
+              "TokenBigram" => {
+                "name" => "TokenBigram",
+              },
+            },
+            "tables" => {
+              "Names" => {
+                "name" => "Names",
+                "columns" => {
+                  "users_key" => {
+                    "name" => "users_key",
+                    "position" => false,
+                  },
+                },
+                "tokenizer" => {
+                  "name" => "TokenBigram",
+                },
+              },
+              "Users" => {
+                "indexes" => [
+                  {
+                    "table" => "Names",
+                    "name" => "users_key",
+                  },
+                ]
+              }
+            },
+          }
+          response = create_response(body)
+          index = response.tables["Users"].indexes[0]
+          assert do
+            not index.full_text_searchable?
+          end
+        end
+
+        test "have tokenizer and position" do
+          body = {
+            "tokenizers" => {
+              "TokenBigram" => {
+                "name" => "TokenBigram",
+              },
+            },
+            "tables" => {
+              "Names" => {
+                "name" => "Names",
+                "columns" => {
+                  "users_key" => {
+                    "name" => "users_key",
+                    "position" => true,
+                  },
+                },
+                "tokenizer" => {
+                  "name" => "TokenBigram",
+                },
+              },
+              "Users" => {
+                "indexes" => [
+                  {
+                    "table" => "Names",
+                    "name" => "users_key",
+                  },
+                ],
+              },
+            },
+          }
+          response = create_response(body)
+          index = response.tables["Users"].indexes[0]
+          assert do
+            index.full_text_searchable?
+          end
+        end
+      end
     end
   end
 end

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

@@ -1,5 +1,6 @@
 # Copyright (C) 2013-2016  Kouhei Sutou <kou@clear-code.com>
 # Copyright (C) 2013  Kosuke Asami
+# Copyright (C) 2016  Masafumi Yokoyama <yokoyama@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
@@ -315,5 +316,72 @@ class TestResponseSelectCommandVersion1 < Test::Unit::TestCase
         values
       end
     end
+
+    class TestSlices < self
+      def setup
+        pair_arguments = {
+          "slices[groonga].filter" => 'tag @ "groonga"',
+        }
+        @command = Groonga::Command::Select.new("select", pair_arguments)
+        @body = [
+          [
+            [3],
+            [
+              [
+                "_id",
+                "UInt32"
+              ],
+              [
+                "tag",
+                "ShortText"
+              ]
+            ],
+            [1, "groonga"],
+            [2, "rroonga"],
+            [3, "groonga"],
+          ],
+          {
+            "groonga" => [
+              [2],
+              [
+                [
+                  "_id",
+                  "UInt32"
+                ],
+                [
+                  "tag",
+                  "ShortText"
+                ]
+              ],
+              [1, "groonga"],
+              [3, "groonga"],
+            ]
+          }
+        ]
+      end
+
+      def test_slices
+        assert_equal({
+                       "groonga" => [
+                         {"_id" => 1, "tag" => "groonga"},
+                         {"_id" => 3, "tag" => "groonga"},
+                       ]
+                     },
+                     collect_values(@body, &:records))
+      end
+
+      private
+      def slices(body)
+        create_response(body).slices
+      end
+
+      def collect_values(body)
+        values = {}
+        slices(body).each do |label, slice|
+          values[label] = yield(slice)
+        end
+        values
+      end
+    end
   end
 end

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

@@ -1,5 +1,6 @@
 # Copyright (C) 2013-2016  Kouhei Sutou <kou@clear-code.com>
 # Copyright (C) 2013  Kosuke Asami
+# Copyright (C) 2016  Masafumi Yokoyama <yokoyama@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
@@ -278,5 +279,74 @@ class TestResponseSelectCommandVersion3 < Test::Unit::TestCase
         values
       end
     end
+
+    class TestSlices < self
+      def setup
+        pair_arguments = {
+          "slices[groonga].filter" => 'tag @ "groonga"',
+        }
+        @command = Groonga::Command::Select.new("select", pair_arguments)
+        @body = {
+          "n_hits" => 3,
+          "columns" => [
+            {
+              "name" => "_id",
+              "type" => "UInt32"
+            },
+            {
+              "name" => "tag",
+              "type" => "ShortText"
+            }
+          ],
+          "records" => [
+            [1, "groonga"],
+            [2, "rroonga"],
+            [3, "groonga"],
+          ],
+          "slices" => {
+            "groonga" => {
+              "n_hits" => 2,
+              "columns" => [
+                {
+                  "name" => "_id",
+                  "type" => "UInt32"
+                },
+                {
+                  "name" => "tag",
+                  "type" => "ShortText"
+                }
+              ],
+              "records" => [
+                [1, "groonga"],
+                [3, "groonga"],
+              ]
+            }
+          }
+        }
+      end
+
+      def test_slices
+        assert_equal({
+                       "groonga" => [
+                         {"_id" => 1, "tag" => "groonga"},
+                         {"_id" => 3, "tag" => "groonga"},
+                       ]
+                     },
+                     collect_values(@body, &:records))
+      end
+
+      private
+      def slices(body)
+        create_response(body).slices
+      end
+
+      def collect_values(body)
+        values = {}
+        slices(body).each do |label, slice|
+          values[label] = yield(slice)
+        end
+        values
+      end
+    end
   end
 end