groonga 0.0.1 → 0.0.2

data/test/test-table.rb

@@ -36,9 +36,8 @@ class TableTest < Test::Unit::TestCase
   def test_open
     table_path = @tables_dir + "table"
     table = Groonga::Hash.create(:name => "bookmarks",
-                                  :path => table_path.to_s)
+                                 :path => table_path.to_s)
     assert_equal("bookmarks", table.name)
-    table.close
 
     called = false
     Groonga::Table.open(:name => "bookmarks") do |_table|
@@ -113,25 +112,32 @@ class TableTest < Test::Unit::TestCase
     table_path = @tables_dir + "table"
     table = Groonga::Hash.create(:name => "bookmarks",
                                  :path => table_path.to_s)
-    column = table.define_column("name", "<text>",
-                                 :type => "index",
-                                 :compress => "zlib",
-                                 :with_section => true,
-                                 :with_weight => true,
-                                 :with_position => true)
+    column = table.define_column("name", "<text>")
     assert_equal("bookmarks.name", column.name)
     assert_equal(column, table.column("name"))
   end
 
+  def test_define_index_column
+    bookmarks = Groonga::Hash.create(:name => "<bookmarks>")
+    bookmarks.define_column("content", "<text>")
+    terms = Groonga::Hash.create(:name => "<terms>")
+    terms.default_tokenizer = "<token:bigram>"
+    index = terms.define_index_column("content-index", bookmarks,
+                                      :with_section => true,
+                                      :source => "<bookmarks>.content")
+    bookmarks.add("google", :content => "Search engine")
+    assert_equal(["google"],
+                 index.search("engine").collect {|record| record.key.key})
+  end
+
   def test_add_column
     bookmarks = Groonga::Hash.create(:name => "bookmarks",
                                      :path => (@tables_dir + "bookmarks").to_s)
 
     description_column_path = @columns_dir + "description"
     bookmarks_description =
-      bookmarks.define_column("description", "<text>",
-                              :type => "index",
-                              :path => description_column_path.to_s)
+      bookmarks.define_index_column("description", "<text>",
+                                    :path => description_column_path.to_s)
 
     books = Groonga::Hash.create(:name => "books",
                                  :path => (@tables_dir + "books").to_s)
@@ -273,94 +279,6 @@ class TableTest < Test::Unit::TestCase
     assert_not_predicate(bookmarks_path, :exist?)
   end
 
-  def test_array_reference
-    bookmarks_path = @tables_dir + "bookmarks"
-    bookmarks = Groonga::Hash.create(:name => "bookmarks",
-                                     :path => bookmarks_path.to_s,
-                                     :key_type => "<shorttext>")
-    bookmark = bookmarks.add("http://google.com/")
-    assert_equal(bookmark, bookmarks["http://google.com/"])
-  end
-
-  def test_tokenizer
-    table = Groonga::Hash.create
-    assert_equal(Groonga::Context.default["<token:bigram>"],
-                 table.default_tokenizer)
-    table.default_tokenizer = "<token:mecab>"
-    assert_equal(Groonga::Context.default["<token:mecab>"],
-                 table.default_tokenizer)
-  end
-
-  def test_inspect_anonymous
-    path = @tables_dir + "anoymous.groonga"
-    anonymous_table = Groonga::Hash.create(:path => path.to_s)
-    assert_equal("#<Groonga::Hash " +
-                 "id: <#{anonymous_table.id}>, " +
-                 "name: (anonymous), " +
-                 "path: <#{path}>, " +
-                 "domain: <nil>, " +
-                 "range: <nil>, " +
-                 "encoding: <#{encoding.inspect}>, " +
-                 "size: <0>>",
-                 anonymous_table.inspect)
-  end
-
-  def test_inspect_anonymous_temporary
-    anonymous_table = Groonga::Hash.create
-    assert_equal("#<Groonga::Hash " +
-                 "id: <#{anonymous_table.id}>, " +
-                 "name: (anonymous), " +
-                 "path: (temporary), " +
-                 "domain: <nil>, " +
-                 "range: <nil>, " +
-                 "encoding: <#{encoding.inspect}>, " +
-                 "size: <0>>",
-                 anonymous_table.inspect)
-  end
-
-  def test_inspect_named
-    path = @tables_dir + "named.groonga"
-    named_table = Groonga::Hash.create(:name => "name", :path => path.to_s)
-    assert_equal("#<Groonga::Hash " +
-                 "id: <#{named_table.id}>, " +
-                 "name: <name>, " +
-                 "path: <#{path}>, " +
-                 "domain: <nil>, " +
-                 "range: <nil>, " +
-                 "encoding: <#{encoding.inspect}>, " +
-                 "size: <0>>",
-                 named_table.inspect)
-  end
-
-  def test_inspect_named_temporary
-    named_table = Groonga::Hash.create(:name => "name")
-    assert_equal("#<Groonga::Hash " +
-                 "id: <#{named_table.id}>, " +
-                 "name: <name>, " +
-                 "path: (temporary), " +
-                 "domain: <nil>, " +
-                 "range: <nil>, " +
-                 "encoding: <#{encoding.inspect}>, " +
-                 "size: <0>>",
-                 named_table.inspect)
-  end
-
-  def test_inspect_size
-    path = @tables_dir + "named.groonga"
-    contain_table = Groonga::Array.create(:name => "name", :path => path.to_s)
-    3.times do
-      contain_table.add
-    end
-    assert_equal("#<Groonga::Array " +
-                 "id: <#{contain_table.id}>, " +
-                 "name: <name>, " +
-                 "path: <#{path}>, " +
-                 "domain: <nil>, " +
-                 "range: <nil>, " +
-                 "size: <3>>",
-                 contain_table.inspect)
-  end
-
   def test_temporary_add
     table = Groonga::Hash.create(:key_type => "<shorttext>")
     assert_equal(0, table.size)
@@ -368,27 +286,6 @@ class TableTest < Test::Unit::TestCase
     assert_equal(1, table.size)
   end
 
-  def test_search
-    users = Groonga::Array.create(:name => "<users>")
-    user_name = users.define_column("name", "<shorttext>")
-
-    bookmarks = Groonga::Hash.create(:name => "<bookmarks>",
-                                     :key_type => "<shorttext>")
-    bookmark_user_id = bookmarks.define_column("user_id", users)
-
-    daijiro = users.add
-    daijiro["name"] = "daijiro"
-    gunyarakun = users.add
-    gunyarakun["name"] = "gunyarakun"
-
-    groonga = bookmarks.add("http://groonga.org/")
-    groonga["user_id"] = daijiro
-
-    records = bookmarks.search("http://groonga.org/")
-    assert_equal(["daijiro"],
-                 records.records.collect {|record| record[".user_id.name"]})
-  end
-
   def test_each
     users = Groonga::Array.create(:name => "<users>")
     user_name = users.define_column("name", "<shorttext>")
@@ -414,16 +311,6 @@ class TableTest < Test::Unit::TestCase
     # assert_equal(0, users.size) # truncate isn't implemented in groonga.
   end
 
-  def test_encoding
-    assert_equal(Groonga::Encoding.default,
-                 Groonga::Hash.create.encoding)
-    assert_equal(Groonga::Encoding.default,
-                 Groonga::PatriciaTrie.create.encoding)
-
-    array = Groonga::Array.create
-    assert_false(array.respond_to?(:encoding))
-  end
-
   def test_sort
     bookmarks = Groonga::Array.create(:name => "<bookmarks>")
     id_column = bookmarks.define_column("id", "<int>")
@@ -444,4 +331,24 @@ class TableTest < Test::Unit::TestCase
     end
     assert_equal((180..199).to_a.reverse, results)
   end
+
+  def test_sort_without_limit
+    bookmarks = Groonga::Array.create(:name => "<bookmarks>")
+    id_column = bookmarks.define_column("id", "<int>")
+    100.times do |i|
+      bookmark = bookmarks.add
+      bookmark["id"] = i + 100
+    end
+
+    results = bookmarks.sort([
+                              {
+                                :key => "id",
+                                :order => :descending,
+                              },
+                             ])
+    results = results.records(:order => :ascending).collect do |record|
+      id_column[record.value.unpack("i")[0]]
+    end
+    assert_equal((100..199).to_a.reverse, results)
+  end
 end

data/test/test-type.rb

@@ -24,9 +24,10 @@ class TypeTest < Test::Unit::TestCase
   end
 
   def test_builtins
-    assert_equal_type("<int>", Groonga::Type::INT)
-    assert_equal_type("<uint>", Groonga::Type::UINT)
+    assert_equal_type("<int>", Groonga::Type::INT32)
+    assert_equal_type("<uint>", Groonga::Type::UINT32)
     assert_equal_type("<int64>", Groonga::Type::INT64)
+    assert_equal_type("<uint64>", Groonga::Type::UINT64)
     assert_equal_type("<float>", Groonga::Type::FLOAT)
     assert_equal_type("<time>", Groonga::Type::TIME)
     assert_equal_type("<shorttext>", Groonga::Type::SHORT_TEXT)
@@ -35,7 +36,7 @@ class TypeTest < Test::Unit::TestCase
   end
 
   def test_inspect
-    assert_equal("#<Groonga::Type id: <8>, " +
+    assert_equal("#<Groonga::Type id: <9>, " +
                  "name: <<longtext>>, " +
                  "path: (temporary), " +
                  "domain: <nil>, " +

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: groonga
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Kouhei Sutou
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-30 00:00:00 +09:00
+date: 2009-06-04 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
@@ -39,7 +39,9 @@ files:
 - README.rdoc
 - Rakefile
 - TUTORIAL.ja.rdoc
-- benchmark/small-many-items.rb
+- benchmark/common.rb
+- benchmark/read-write-small-many-items.rb
+- benchmark/write-small-many-items.rb
 - example/bookmark.rb
 - ext/.gitignore
 - ext/rb-grn-accessor.c
@@ -48,10 +50,13 @@ files:
 - ext/rb-grn-column.c
 - ext/rb-grn-context.c
 - ext/rb-grn-database.c
+- ext/rb-grn-encoding-support.c
 - ext/rb-grn-encoding.c
 - ext/rb-grn-exception.c
+- ext/rb-grn-fix-size-column.c
 - ext/rb-grn-hash-cursor.c
 - ext/rb-grn-hash.c
+- ext/rb-grn-index-column.c
 - ext/rb-grn-logger.c
 - ext/rb-grn-object.c
 - ext/rb-grn-patricia-trie-cursor.c
@@ -73,6 +78,8 @@ files:
 - html/developer.html
 - html/developer.svg
 - html/download.svg
+- html/favicon.ico
+- html/favicon.xcf
 - html/footer.html.erb
 - html/head.html.erb
 - html/header.html.erb
@@ -166,11 +173,15 @@ files:
 - test/.gitignore
 - test/groonga-test-utils.rb
 - test/run-test.rb
+- test/test-array.rb
 - test/test-column.rb
 - test/test-context.rb
 - test/test-database.rb
 - test/test-encoding.rb
 - test/test-exception.rb
+- test/test-hash.rb
+- test/test-index-column.rb
+- test/test-patricia-trie.rb
 - test/test-procedure.rb
 - test/test-query.rb
 - test/test-record.rb
@@ -205,7 +216,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: groonga
-rubygems_version: 1.3.2
+rubygems_version: 1.3.3
 signing_key: 
 specification_version: 3
 summary: Ruby bindings for groonga that provides full text search and column store features.

data/benchmark/small-many-items.rb

@@ -1,175 +0,0 @@
-#!/usr/bin/ruby
-
-# This benchmark is based on Tokyo Cabinet's benchmark at
-# http://alpha.mixi.co.jp/blog/?p=791
-#
-# On my environment at 2009/04/29:
-# % for x in {0..8}; do ruby benchmark/small-many-items.rb $x; done
-#                           user     system      total        real        memory
-# Hash                  1.070000   0.140000   1.210000 (  1.462675)     46.234MB
-# groonga: Hash: memory 1.380000   0.140000   1.520000 (  1.804040)     23.531MB
-# groonga: Trie: memory 1.780000   0.110000   1.890000 (  2.136395)     15.520MB
-# groonga: Hash: file   1.380000   0.180000   1.560000 (  1.879252)     23.535MB
-# groonga: Trie: file   1.650000   0.160000   1.810000 (  2.257756)     15.523MB
-# TC: Hash: memory      0.680000   0.170000   0.850000 (  1.038155)     38.246MB
-# TC: Tree: memory      0.640000   0.130000   0.770000 (  1.029011)     30.609MB
-# TC: Hash: file        1.150000   2.900000   4.050000 (  4.908274)      0.164MB
-# TC: Tree: file        0.970000   0.210000   1.180000 (  1.416418)      5.367MB
-#
-# Ruby: Debian GNU/Linux sid at 2009/04/29:
-#       ruby 1.8.7 (2008-08-11 patchlevel 72) [x86_64-linux]
-# groonga: HEAD at 2009/04/29: c97c3cf78b8f0761ca48ef211caa155135f89487
-# Ruby/Groonga: trunk at 2009/04/29: r221
-# Tokyo Cabinet: 1.4.17
-# Tokyo Cabinet Ruby: 1.23
-
-require 'benchmark'
-require 'tempfile'
-
-def memory_usage()
-  status = `cat /proc/#{$$}/status`
-  lines = status.split("\n")
-  lines.each do |line|
-    if line =~ /^VmRSS:/
-      line.gsub!(/.*:\s*(\d+).*/, '\1')
-      return line.to_i / 1024.0
-    end
-  end
-  return -1;
-end
-
-n = 500000
-
-@items = []
-
-def item(label, &block)
-  @items << [label, block]
-end
-
-def report(index=0)
-  width = @items.collect do |label, _|
-    label.length
-  end.max
-
-  label, block = @items[index]
-  if label.nil?
-    puts "unavailable report ID: #{index}"
-    puts "available IDs:"
-    @items.each_with_index do |(label, block), i|
-      puts "#{i}: #{label}"
-    end
-    exit 1
-  end
-
-  if index.zero?
-    puts(" " * (width - 1) + Benchmark::Tms::CAPTION.rstrip + "memory".rjust(14))
-  end
-  # GC.disable
-  before = memory_usage
-  result = Benchmark.measure(&block)
-  # GC.enable
-  GC.start
-  size = memory_usage - before
-
-  formatted_size = "%10.3f" % size
-  puts "#{label.ljust(width)} #{result.to_s.strip} #{formatted_size}MB"
-end
-
-values = []
-n.times do |i|
-  values << "%08d" % i
-end
-
-item("Hash") do
-  hash = {}
-  values.each do |value|
-    hash[value] = value
-  end
-end
-
-begin
-  base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
-  $LOAD_PATH.unshift(File.join(base_dir, "src"))
-  $LOAD_PATH.unshift(File.join(base_dir, "src", "lib"))
-
-  require 'groonga'
-  Groonga::Database.create
-
-  item("groonga: Hash: memory") do
-    hash = Groonga::Hash.create(:key_type => "<shorttext>",
-                                :value_size => 8)
-    values.each do |value|
-      hash[value] = value
-    end
-  end
-
-  item("groonga: Trie: memory") do
-    hash = Groonga::PatriciaTrie.create(:key_type => "<shorttext>",
-                                        :value_size => 8)
-    values.each do |value|
-      hash[value] = value
-    end
-  end
-
-  hash_file = Tempfile.new("groonga-hash")
-  item("groonga: Hash: file") do
-    hash = Groonga::Hash.create(:key_type => "<shorttext>",
-                                :value_size => 8,
-                                :path => hash_file.path)
-    values.each do |value|
-      hash[value] = value
-    end
-  end
-
-  trie_file = Tempfile.new("groonga-trie")
-  item("groonga: Trie: file") do
-    hash = Groonga::PatriciaTrie.create(:key_type => "<shorttext>",
-                                        :value_size => 8,
-                                        :path => trie_file.path)
-    values.each do |value|
-      hash[value] = value
-    end
-  end
-rescue LoadError
-end
-
-begin
-  require 'tokyocabinet'
-
-  item("TC: Hash: memory") do
-    db = TokyoCabinet::ADB::new
-    db.open("*#bnum=#{n}#mode=wct#xmsiz=0")
-    values.each do |value|
-      db.put(value, value)
-    end
-  end
-
-  item("TC: Tree: memory") do
-    db = TokyoCabinet::ADB::new
-    db.open("+#bnum=#{n}#mode=wct#xmsiz=0")
-    values.each do |value|
-      db.put(value, value)
-    end
-  end
-
-  hash_file = Tempfile.new(["tc-hash", ".tch"])
-  item("TC: Hash: file") do
-    db = TokyoCabinet::ADB::new
-    db.open("#{hash_file.path}#bnum=#{n}#mode=wct#xmsiz=0")
-    values.each do |value|
-      db.put(value, value)
-    end
-  end
-
-  tree_file = Tempfile.new(["tc-tree", ".tcb"])
-  item("TC: Tree: file") do
-    db = TokyoCabinet::ADB::new
-    db.open("#{tree_file.path}#bnum=#{n}#mode=wct#xmsiz=0")
-    values.each do |value|
-      db.put(value, value)
-    end
-  end
-rescue LoadError
-end
-
-report(Integer(ARGV[0] || 0))