rroonga 2.0.4-x86-mingw32 → 2.0.7-x86-mingw32

data/test/test-schema-create-table.rb

@@ -0,0 +1,267 @@
+# Copyright (C) 2009-2011  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+module SchemaCreateTableTests
+  def test_normal
+    assert_nil(context["Posts"])
+    Groonga::Schema.create_table("Posts", options) do |table|
+    end
+    assert_not_nil(context["Posts"])
+  end
+
+  def test_force
+    Groonga::Schema.create_table("Posts", options) do |table|
+      table.string("name")
+    end
+    assert_not_nil(context["Posts.name"])
+
+    Groonga::Schema.create_table("Posts",
+                                 options(:type => differnt_type,
+                                         :force => true)) do |table|
+    end
+    assert_nil(context["Posts.name"])
+  end
+
+  def test_different_type
+    Groonga::Schema.create_table("Posts", options) do |table|
+    end
+
+    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
+      Groonga::Schema.create_table("Posts",
+                                   options(:type => differnt_type)) do |table|
+      end
+    end
+  end
+
+  def test_same_options
+    Groonga::Schema.create_table("Posts", options) do |table|
+    end
+
+    Groonga::Schema.create_table("Posts", options) do |table|
+    end
+    assert_not_nil(context["Posts"])
+  end
+
+  def test_same_value_type
+    Groonga::Schema.create_table("Posts",
+                                 options(:value_type => "UInt32")) do |table|
+    end
+
+    Groonga::Schema.create_table("Posts",
+                                 options(:value_type => "UInt32")) do |table|
+    end
+    assert_equal(context["UInt32"], context["Posts"].range)
+  end
+
+  def test_differnt_value_type
+    Groonga::Schema.create_table("Posts", options) do |table|
+    end
+
+    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
+      Groonga::Schema.create_table("Posts",
+                                   options(:value_type => "Int32")) do |table|
+      end
+    end
+  end
+
+  def test_same_sub_records
+    Groonga::Schema.create_table("Posts",
+                                 options(:sub_records => true)) do |table|
+    end
+
+    Groonga::Schema.create_table("Posts",
+                                 options(:sub_records => true)) do |table|
+    end
+    assert_true(context["Posts"].support_sub_records?)
+  end
+
+  def test_different_sub_records
+    Groonga::Schema.create_table("Posts",
+                                 options(:sub_records => true)) do |table|
+    end
+
+    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
+      Groonga::Schema.create_table("Posts",
+                                   options(:sub_records => false)) do |table|
+      end
+    end
+  end
+
+  def test_default_path
+    Groonga::Schema.create_table("Posts", options) do |table|
+    end
+    assert_equal("#{@database_path}.0000100",
+                 context["Posts"].path)
+  end
+
+  def test_default_named_path
+    options_with_named_path = options.merge(:named_path => true)
+    Groonga::Schema.create_table("Posts", options_with_named_path) do |table|
+    end
+    assert_equal("#{@database_path}.tables/Posts",
+                 context["Posts"].path)
+  end
+
+  private
+  def options(addional_options={})
+    default_options.merge(addional_options)
+  end
+end
+
+module SchemaCreateTableWithKeyTests
+  def test_same_key_type
+    Groonga::Schema.create_table("Posts",
+                                 options(:key_type => "ShortText")) do |table|
+    end
+
+    Groonga::Schema.create_table("Posts",
+                                 options(:key_type => "ShortText")) do |table|
+    end
+    assert_equal(context["ShortText"], context["Posts"].domain)
+  end
+
+  def test_differnt_key_type
+    Groonga::Schema.create_table("Posts",
+                                 options(:key_type => "Int32")) do |table|
+    end
+
+    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
+      Groonga::Schema.create_table("Posts",
+                                   options(:key_type => "ShortText")) do |table|
+      end
+    end
+  end
+
+  def test_same_default_tokenizer
+    _options = options(:key_type => "ShortText",
+                       :default_tokenizer => "TokenBigram")
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+    assert_equal(context["TokenBigram"], context["Posts"].default_tokenizer)
+  end
+
+  def test_differnt_default_tokenizer
+    _options = options(:key_type => "ShortText")
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+
+    _options = _options.merge(:default_tokenizer => "TokenBigram")
+    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
+      Groonga::Schema.create_table("Posts", _options) do |table|
+      end
+    end
+  end
+
+  def test_same_key_normalize
+    _options = options(:key_type => "ShortText",
+                       :key_normalize => true)
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+    assert_true(context["Posts"].normalize_key?)
+  end
+
+  def test_differnt_key_normalize
+    _options = options(:key_type => "ShortText",
+                       :key_normalize => true)
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+
+    _options = _options.merge(:key_normalize => false)
+    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
+      Groonga::Schema.create_table("Posts", _options) do |table|
+      end
+    end
+  end
+end
+
+class SchemaCreateTableArrayTest < Test::Unit::TestCase
+  include GroongaTestUtils
+  include SchemaCreateTableTests
+
+  setup :setup_database
+
+  private
+  def default_options
+    {}
+  end
+
+  def differnt_type
+    :hash
+  end
+end
+
+class SchemaCreateTableHashTest < Test::Unit::TestCase
+  include GroongaTestUtils
+  include SchemaCreateTableTests
+  include SchemaCreateTableWithKeyTests
+
+  setup :setup_database
+
+  private
+  def default_options
+    {:type => :hash}
+  end
+
+  def differnt_type
+    :patricia_trie
+  end
+end
+
+class SchemaCreateTablePatriciaTrieTest < Test::Unit::TestCase
+  include GroongaTestUtils
+  include SchemaCreateTableTests
+  include SchemaCreateTableWithKeyTests
+
+  setup :setup_database
+
+  def test_same_key_with_sis
+    _options = options(:key_type => "ShortText",
+                       :key_with_sis => true)
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+    assert_true(context["Posts"].register_key_with_sis?)
+  end
+
+  def test_differnt_key_with_sis
+    _options = options(:key_type => "ShortText",
+                       :key_with_sis => true)
+    Groonga::Schema.create_table("Posts", _options) do |table|
+    end
+
+    _options = _options.merge(:key_with_sis => false)
+    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
+      Groonga::Schema.create_table("Posts", _options) do |table|
+      end
+    end
+  end
+
+  private
+  def default_options
+    {:type => :patricia_trie}
+  end
+
+  def differnt_type
+    :array
+  end
+end

data/test/test-schema-dumper.rb

@@ -0,0 +1,235 @@
+# Copyright (C) 2009-2011  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+class SchemaDumperTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  private
+  def define_simple_schema
+    Groonga::Schema.define do |schema|
+      schema.create_table("Posts") do |table|
+        table.short_text :title
+        table.short_text :comments, :type => :vector
+      end
+    end
+  end
+
+  def define_built_in_types_schema
+    Groonga::Schema.define do |schema|
+      schema.create_table("Posts") do |table|
+        table.boolean :public
+        table.int8 :int8
+        table.uint8 :uint8
+        table.int16 :int16
+        table.uint16 :uint16
+        table.int32 :int32
+        table.uint32 :uint32
+        table.int64 :int64
+        table.uint64 :uint64
+        table.float :vote_average
+        table.time :published_at
+        table.short_text :title
+        table.text :content
+        table.long_text :attachment
+        table.tokyo_geo_point :location_tokyo
+        table.wgs84_geo_point :location_wgs84
+      end
+    end
+  end
+
+  def define_reference_schema
+    Groonga::Schema.define do |schema|
+      schema.create_table("Items") do |table|
+        table.short_text("title")
+      end
+
+      schema.create_table("Users") do |table|
+        table.short_text("name")
+      end
+
+      schema.create_table("Comments") do |table|
+        table.reference("item", "Items")
+        table.reference("author", "Users")
+        table.reference("children", "Items", :type => :vector)
+        table.text("content")
+        table.time("issued")
+      end
+    end
+  end
+
+  def define_index_schema
+    Groonga::Schema.define do |schema|
+      schema.create_table("Items",
+                          :type => :hash,
+                          :key_type => "ShortText") do |table|
+        table.short_text("title")
+      end
+
+      schema.create_table("Terms",
+                          :type => :patricia_trie,
+                          :key_type => "ShortText",
+                          :key_normalize => true,
+                          :default_tokenizer => "TokenBigram") do |table|
+        table.index("Items", "_key")
+        table.index("Items", "title")
+      end
+    end
+  end
+
+  class RubySyntaxSchemaDumperTest < SchemaDumperTest
+    def test_simple
+      define_simple_schema
+      assert_equal(<<-EOS, dump)
+create_table("Posts",
+             :force => true) do |table|
+  table.short_text("comments", :type => :vector)
+  table.short_text("title")
+end
+EOS
+    end
+
+    def test_built_in_types
+      define_built_in_types_schema
+      assert_equal(<<-EOS, dump)
+create_table("Posts",
+             :force => true) do |table|
+  table.long_text("attachment")
+  table.text("content")
+  table.integer16("int16")
+  table.integer32("int32")
+  table.integer64("int64")
+  table.integer8("int8")
+  table.tokyo_geo_point("location_tokyo")
+  table.wgs84_geo_point("location_wgs84")
+  table.boolean("public")
+  table.time("published_at")
+  table.short_text("title")
+  table.unsigned_integer16("uint16")
+  table.unsigned_integer32("uint32")
+  table.unsigned_integer64("uint64")
+  table.unsigned_integer8("uint8")
+  table.float("vote_average")
+end
+EOS
+    end
+
+    def test_reference
+      define_reference_schema
+      assert_equal(<<-EOS, dump)
+create_table("Comments",
+             :force => true) do |table|
+  table.text("content")
+  table.time("issued")
+end
+
+create_table("Items",
+             :force => true) do |table|
+  table.short_text("title")
+end
+
+create_table("Users",
+             :force => true) do |table|
+  table.short_text("name")
+end
+
+change_table("Comments") do |table|
+  table.reference("author", "Users")
+  table.reference("children", "Items", :type => :vector)
+  table.reference("item", "Items")
+end
+EOS
+    end
+
+    def test_index
+      define_index_schema
+      assert_equal(<<-EOS, dump)
+create_table("Items",
+             :type => :hash,
+             :key_type => "ShortText",
+             :force => true) do |table|
+  table.short_text("title")
+end
+
+create_table("Terms",
+             :type => :patricia_trie,
+             :key_type => "ShortText",
+             :key_normalize => true,
+             :default_tokenizer => "TokenBigram",
+             :force => true) do |table|
+end
+
+change_table("Terms") do |table|
+  table.index("Items", "_key", :name => "Items__key")
+  table.index("Items", "title", :name => "Items_title")
+end
+EOS
+    end
+
+    private
+    def dump
+      Groonga::Schema.dump
+    end
+  end
+
+  class CommandSyntaxSchemaDumperTest < SchemaDumperTest
+    def test_simple
+      define_simple_schema
+      assert_equal(<<-EOS, dump)
+table_create Posts TABLE_NO_KEY
+column_create Posts comments COLUMN_VECTOR ShortText
+column_create Posts title COLUMN_SCALAR ShortText
+EOS
+    end
+
+    def test_reference
+      define_reference_schema
+      assert_equal(<<-EOS, dump)
+table_create Comments TABLE_NO_KEY
+column_create Comments content COLUMN_SCALAR Text
+column_create Comments issued COLUMN_SCALAR Time
+
+table_create Items TABLE_NO_KEY
+column_create Items title COLUMN_SCALAR ShortText
+
+table_create Users TABLE_NO_KEY
+column_create Users name COLUMN_SCALAR ShortText
+
+column_create Comments author COLUMN_SCALAR Users
+column_create Comments children COLUMN_VECTOR Items
+column_create Comments item COLUMN_SCALAR Items
+EOS
+    end
+
+    def test_index
+      define_index_schema
+      assert_equal(<<-EOS, dump)
+table_create Items TABLE_HASH_KEY --key_type ShortText
+column_create Items title COLUMN_SCALAR ShortText
+
+table_create Terms TABLE_PAT_KEY|KEY_NORMALIZE --key_type ShortText --default_tokenizer TokenBigram
+
+column_create Terms Items__key COLUMN_INDEX|WITH_POSITION Items _key
+column_create Terms Items_title COLUMN_INDEX|WITH_POSITION Items title
+EOS
+    end
+
+    private
+    def dump
+      Groonga::Schema.dump(:syntax => :command)
+    end
+  end
+end

data/test/test-schema-type.rb

@@ -0,0 +1,208 @@
+# Copyright (C) 2010  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+class SchemaTypeTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  def test_normalize_short_text
+    assert_normalize_type("ShortText", "short_text")
+    assert_normalize_type("ShortText", "string")
+    assert_normalize_type("ShortText", "ShortText")
+  end
+
+  def test_normalize_text
+    assert_normalize_type("Text", "text")
+    assert_normalize_type("Text", "Text")
+  end
+
+  def test_normalize_long_text
+    assert_normalize_type("LongText", "binary")
+    assert_normalize_type("LongText", "long_text")
+    assert_normalize_type("LongText", "LongText")
+  end
+
+  def test_normalize_integer8
+    assert_normalize_type("Int8", "int8")
+    assert_normalize_type("Int8", "integer8")
+    assert_normalize_type("Int8", "Int8")
+  end
+
+  def test_normalize_integer16
+    assert_normalize_type("Int16", "int16")
+    assert_normalize_type("Int16", "integer16")
+    assert_normalize_type("Int16", "Int16")
+  end
+
+  def test_normalize_integer32
+    assert_normalize_type("Int32", "int")
+    assert_normalize_type("Int32", "integer")
+    assert_normalize_type("Int32", "int32")
+    assert_normalize_type("Int32", "integer32")
+    assert_normalize_type("Int32", "Int32")
+  end
+
+  def test_normalize_integer64
+    assert_normalize_type("Int64", "int64")
+    assert_normalize_type("Int64", "integer64")
+    assert_normalize_type("Int64", "Int64")
+  end
+
+  def test_normalize_unsigned_integer8
+    assert_normalize_type("UInt8", "uint8")
+    assert_normalize_type("UInt8", "unsigned_integer8")
+    assert_normalize_type("UInt8", "UInt8")
+  end
+
+  def test_normalize_unsigned_integer16
+    assert_normalize_type("UInt16", "uint16")
+    assert_normalize_type("UInt16", "unsigned_integer16")
+    assert_normalize_type("UInt16", "UInt16")
+  end
+
+  def test_normalize_unsigned_integer32
+    assert_normalize_type("UInt32", "uint")
+    assert_normalize_type("UInt32", "unsigned_integer")
+    assert_normalize_type("UInt32", "uint32")
+    assert_normalize_type("UInt32", "unsigned_integer32")
+    assert_normalize_type("UInt32", "UInt32")
+  end
+
+  def test_normalize_unsigned_integer64
+    assert_normalize_type("UInt64", "uint64")
+    assert_normalize_type("UInt64", "unsigned_integer64")
+    assert_normalize_type("UInt64", "UInt64")
+  end
+
+  def test_normalize_float
+    assert_normalize_type("Float", "float")
+    assert_normalize_type("Float", "Float")
+  end
+
+  def test_normalize_time
+    assert_normalize_type("Time", "datetime")
+    assert_normalize_type("Time", "timestamp")
+    assert_normalize_type("Time", "time")
+    assert_normalize_type("Time", "date")
+    assert_normalize_type("Time", "Time")
+  end
+
+  def test_normalize_boolean
+    assert_normalize_type("Bool", "boolean")
+    assert_normalize_type("Bool", "Bool")
+  end
+
+  def test_normalize_tokyo_geo_point
+    assert_normalize_type("TokyoGeoPoint", "tokyo_geo_point")
+    assert_normalize_type("TokyoGeoPoint", "TokyoGeoPoint")
+  end
+
+  def test_normalize_wgs84_geo_point
+    assert_normalize_type("WGS84GeoPoint", "geo_point")
+    assert_normalize_type("WGS84GeoPoint", "wgs84_geo_point")
+    assert_normalize_type("WGS84GeoPoint", "WGS84GeoPoint")
+  end
+
+  def test_normalize_delimit
+    assert_normalize_type("TokenDelimit", "delimit")
+    assert_normalize_type("TokenDelimit", "token_delimit")
+    assert_normalize_type("TokenDelimit", "TokenDelimit")
+  end
+
+  def test_normalize_unigram
+    assert_normalize_type("TokenUnigram", "unigram")
+    assert_normalize_type("TokenUnigram", "token_unigram")
+    assert_normalize_type("TokenUnigram", "TokenUnigram")
+  end
+
+  def test_normalize_bigram
+    assert_normalize_type("TokenBigram", "bigram")
+    assert_normalize_type("TokenBigram", "token_bigram")
+    assert_normalize_type("TokenBigram", "TokenBigram")
+  end
+
+  def test_normalize_bigram_split_symbol
+    assert_normalize_type("TokenBigramSplitSymbol", "bigram_split_symbol")
+    assert_normalize_type("TokenBigramSplitSymbol", "token_bigram_split_symbol")
+    assert_normalize_type("TokenBigramSplitSymbol", "TokenBigramSplitSymbol")
+  end
+
+  def test_normalize_bigram_split_symbol_alpha
+    assert_normalize_type("TokenBigramSplitSymbolAlpha",
+                          "bigram_split_symbol_alpha")
+    assert_normalize_type("TokenBigramSplitSymbolAlpha",
+                          "token_bigram_split_symbol_alpha")
+    assert_normalize_type("TokenBigramSplitSymbolAlpha",
+                          "TokenBigramSplitSymbolAlpha")
+  end
+
+  def test_normalize_bigram_split_symbol_alpha_digit
+    assert_normalize_type("TokenBigramSplitSymbolAlphaDigit",
+                          "bigram_split_symbol_alpha_digit")
+    assert_normalize_type("TokenBigramSplitSymbolAlphaDigit",
+                          "token_bigram_split_symbol_alpha_digit")
+    assert_normalize_type("TokenBigramSplitSymbolAlphaDigit",
+                          "TokenBigramSplitSymbolAlphaDigit")
+  end
+
+  def test_normalize_bigram_ignore_blank
+    assert_normalize_type("TokenBigramIgnoreBlank", "bigram_ignore_blank")
+    assert_normalize_type("TokenBigramIgnoreBlank", "token_bigram_ignore_blank")
+    assert_normalize_type("TokenBigramIgnoreBlank", "TokenBigramIgnoreBlank")
+  end
+
+  def test_normalize_bigram_ignore_blank_split_symbol
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbol",
+                          "bigram_ignore_blank_split_symbol")
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbol",
+                          "token_bigram_ignore_blank_split_symbol")
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbol",
+                          "TokenBigramIgnoreBlankSplitSymbol")
+  end
+
+  def test_normalize_bigram_ignore_blank_split_symbol_alpha
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlpha",
+                          "bigram_ignore_blank_split_symbol_alpha")
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlpha",
+                          "token_bigram_ignore_blank_split_symbol_alpha")
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlpha",
+                          "TokenBigramIgnoreBlankSplitSymbolAlpha")
+  end
+
+  def test_normalize_bigram_ignore_blank_split_symbol_alpha_digit
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlphaDigit",
+                          "bigram_ignore_blank_split_symbol_alpha_digit")
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlphaDigit",
+                          "token_bigram_ignore_blank_split_symbol_alpha_digit")
+    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlphaDigit",
+                          "TokenBigramIgnoreBlankSplitSymbolAlphaDigit")
+  end
+
+  def test_normalize_trigram
+    assert_normalize_type("TokenTrigram", "trigram")
+    assert_normalize_type("TokenTrigram", "token_trigram")
+    assert_normalize_type("TokenTrigram", "TokenTrigram")
+  end
+
+  def test_normalize_mecab
+    assert_normalize_type("TokenMecab", "mecab")
+    assert_normalize_type("TokenMecab", "token_mecab")
+    assert_normalize_type("TokenMecab", "TokenMecab")
+  end
+
+  private
+  def assert_normalize_type(expected, type)
+    assert_equal(expected, Groonga::Schema.normalize_type(type))
+  end
+end