rroonga 1.3.0-x86-mingw32 → 1.3.1-x86-mingw32

data/Rakefile

@@ -1,6 +1,6 @@
 # -*- coding: utf-8; mode: ruby -*-
 #
-# Copyright (C) 2009-2011  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2012  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
@@ -168,7 +168,38 @@ relative_binary_dir = File.join("vendor", "local")
 vendor_dir = File.join(base_dir, relative_vendor_dir)
 binary_dir = File.join(base_dir, relative_binary_dir)
 
-groonga_win32_i386_p = ENV["GROONGA32"] == "yes"
+groonga_win32_i386_p = ENV["GROONGA64"] != "yes"
+
+namespace :win32 do
+  namespace :groonga do
+    task :download do
+      require "open-uri"
+      require "rroonga-build"
+      groonga_version = RroongaBuild::RequiredGroongaVersion::VERSION.join(".")
+      base_name = "groonga-#{groonga_version}-"
+      if groonga_win32_i386_p
+        base_name << "x86"
+      else
+        base_name << "x64"
+      end
+      base_name << ".zip"
+      base_url = "http://packages.groonga.org/windows/groonga/"
+      Dir.chdir(base_dir) do
+        unless File.exist?(base_name)
+          open("#{base_url}#{base_name}", "rb") do |zip|
+            File.open(base_name, "wb") do |output|
+              output.print(zip.read)
+            end
+          end
+        end
+        sh("unzip", base_name)
+        rm_rf(relative_binary_dir)
+        mkdir_p(File.dirname(relative_binary_dir))
+        mv(File.basename(base_name, ".*"), relative_binary_dir)
+      end
+    end
+  end
+end
 
 Rake::ExtensionTask.new("groonga", spec) do |ext|
   if groonga_win32_i386_p

data/benchmark/common.rb

@@ -35,7 +35,7 @@ def report(index=0)
   end
 
   if index.zero?
-    puts(" " * (width - 1) + Benchmark::Tms::CAPTION.rstrip + "memory".rjust(14))
+    puts(" " * (width - 1) + Benchmark::Tms::CAPTION.rstrip + "memory".rjust(11))
   end
   # GC.disable
   before = memory_usage
@@ -44,6 +44,6 @@ def report(index=0)
   GC.start
   size = memory_usage - before
 
-  formatted_size = "%10.3f" % size
+  formatted_size = "%7.3f" % size
   puts "#{label.ljust(width)} #{result.to_s.strip} #{formatted_size}MB"
 end

data/benchmark/read-write-many-small-items.rb

@@ -3,32 +3,31 @@
 # This benchmark is based on Tokyo Cabinet's benchmark at
 # http://alpha.mixi.co.jp/blog/?p=791
 #
-# On my environment at 2009/07/14:
-# % for x in {0..9}; do ruby benchmark/read-write-many-small-items.rb $x; done
-#                           user     system      total        real        memory
-# Hash                  0.850000   0.170000   1.020000 (  1.050703)     46.957MB
-# groonga: Hash: memory 1.080000   0.180000   1.260000 (  1.251981)     30.152MB
-# groonga: Trie: memory 1.300000   0.120000   1.420000 (  1.429549)     22.199MB
-# groonga: Hash: file   1.070000   0.190000   1.260000 (  1.276910)     30.156MB
-# groonga: Trie: file   1.280000   0.150000   1.430000 (  1.423066)     22.203MB
-# Localmemcache: file   1.320000   0.150000   1.470000 (  1.497013)     45.984MB
-# TC: Hash: memory      0.940000   0.250000   1.190000 (  1.248141)     48.758MB
-# TC: Tree: memory      0.890000   0.140000   1.030000 (  1.067693)     37.270MB
-# TC: Hash: file        1.740000   2.390000   4.130000 (  4.141555)      8.848MB
-# TC: Tree: file        1.290000   0.180000   1.470000 (  1.476853)     12.805MB
+# On my environment at 2012/01/25:
+# % for x in {0..8}; do ruby1.9.1 benchmark/read-write-many-small-items.rb $x; done
+#                              user     system      total        real     memory
+# Hash                     0.410000   0.000000   0.410000 (  0.412228)  44.895MB
+# groonga: Hash            0.910000   0.030000   0.940000 (  0.938278)  38.863MB
+# groonga: PatriciaTrie    1.050000   0.020000   1.070000 (  1.076237)  34.832MB
+# groonga: DoubleArrayTrie 1.050000   0.040000   1.090000 (  1.083912)  34.852MB
+# Localmemcache: file      0.610000   0.040000   0.650000 (  0.641539)  61.441MB
+# TC: Hash: memory         0.470000   0.010000   0.480000 (  0.477577)  55.910MB
+# TC: Tree: memory         0.430000   0.010000   0.440000 (  0.441939)  44.484MB
+# TC: Hash: file           0.980000   0.990000   1.970000 (  1.971581)  17.684MB
+# TC: Tree: file           0.650000   0.030000   0.680000 (  0.683004)  19.801MB
 #
-# CPU: Intel(R) Core(TM)2 Duo 2.33GHz
-# Memory: 2GB
-# Ruby: Debian GNU/Linux sid at 2009/07/14:
-#       ruby 1.8.7 (2009-06-12 patchlevel 174) [x86_64-linux]
-# groonga: HEAD at 2009/07/14: fdaf58df5dd0195c10624eabee3e3f522f4af3f9
-# Ruby/Groonga: trunk at 2009/07/14: r479
-# Localmemcache: HEAD at 2009/07/14: 3121629016344dfd10f7533ca8ec68a0006cca21
-# Tokyo Cabinet: 1.4.29
-# Tokyo Cabinet Ruby: 1.27
+# CPU: Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz stepping 05
+# Memory: 8GB
+# Ruby: Debian GNU/Linux sid at 2012/01/25:
+#       ruby 1.9.3p0 (2011-10-30 revision 33570) [x86_64-linux]
+# groonga: HEAD at 2012/01/25: 07dce043cc8cfbbecbcdc43bf7c6d5c2d085237a
+# rroonga: master at 2012/01/25: 29099bff93377733d81dc2398c3403e1293301dc
+# Localmemcache: 0.4.4
+# Tokyo Cabinet: 1.4.37
+# Tokyo Cabinet Ruby: 1.31
 #
 # NOTE:
-# * groonga, Localmemcache and Tokyo Cabinet are built with "-O3" option.
+# * groonga, Localmemcache and Tokyo Cabinet are built with "-O2" option.
 # * Ruby bindings of them are built with "-O2" option.
 
 require File.join(File.dirname(__FILE__), "common.rb")
@@ -40,44 +39,54 @@ n.times do |i|
   values << "%08d" % i
 end
 
+ruby_hash = {}
 item("Hash") do
-  @hash = {}
   values.each do |value|
-    @hash[value] = value
-    @hash[value]
+    ruby_hash[value] = value
+    ruby_hash[value]
   end
 end
 
 begin
   base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
-  $LOAD_PATH.unshift(File.join(base_dir, "ext"))
+  $LOAD_PATH.unshift(File.join(base_dir, "ext", "groonga"))
   $LOAD_PATH.unshift(File.join(base_dir, "lib"))
 
   require 'groonga'
   tmp_dir = "/tmp/groonga"
   FileUtils.rm_rf(tmp_dir)
   FileUtils.mkdir(tmp_dir)
+  Groonga::Context.default.encoding = :none
   @database = Groonga::Database.create(:path => "#{tmp_dir}/db")
+  column_name = "value"
 
-  item("groonga: Hash: file") do
-    @hash = Groonga::Hash.create(:name => "Hash",
-                                 :key_type => "ShortText")
-    column_name = "value"
-    @column = @hash.define_column(column_name, "ShortText")
+  groonga_hash = Groonga::Hash.create(:name => "Hash",
+                                      :key_type => "ShortText")
+  groonga_hash.define_column(column_name, "ShortText")
+  item("groonga: Hash") do
     values.each do |value|
-      @hash.set_column_value(value, column_name, value)
-      @hash.column_value(value, column_name)
+      groonga_hash.set_column_value(value, column_name, value)
+      groonga_hash.column_value(value, column_name)
     end
   end
 
-  item("groonga: Trie: file") do
-    @trie = Groonga::PatriciaTrie.create(:name => "PatriciaTrie",
-                                         :key_type => "ShortText")
-    column_name = "value"
-    @column = @trie.define_column(column_name, "ShortText")
+  patricia_trie = Groonga::PatriciaTrie.create(:name => "PatriciaTrie",
+                                               :key_type => "ShortText")
+  patricia_trie.define_column(column_name, "ShortText")
+  item("groonga: PatriciaTrie") do
     values.each do |value|
-      @trie.set_column_value(value, column_name, value)
-      @trie.column_value(value, column_name)
+      patricia_trie.set_column_value(value, column_name, value)
+      patricia_trie.column_value(value, column_name)
+    end
+  end
+
+  double_array_trie = Groonga::DoubleArrayTrie.create(:name => "DoubleArrayTrie",
+                                                      :key_type => "ShortText")
+  double_array_trie.define_column(column_name, "ShortText")
+  item("groonga: DoubleArrayTrie") do
+    values.each do |value|
+      patricia_trie.set_column_value(value, column_name, value)
+      patricia_trie.column_value(value, column_name)
     end
   end
 rescue LoadError
@@ -86,13 +95,13 @@ end
 begin
   require 'localmemcache'
 
+  LocalMemCache.drop(:namespace => "read-write-many-small-items",
+                     :force => true)
+  mem_cache = LocalMemCache.new(:namespace => "read-write-many-small-items")
   item("Localmemcache: file") do
-    LocalMemCache.drop(:namespace => "read-write-many-small-items",
-                       :force => true)
-    @db = LocalMemCache.new(:namespace => "read-write-many-small-items")
     values.each do |value|
-      @db[value] = value
-      @db[value]
+      mem_cache[value] = value
+      mem_cache[value]
     end
   end
 rescue LoadError
@@ -101,41 +110,41 @@ end
 begin
   require 'tokyocabinet'
 
+  tc_hash_memory = TokyoCabinet::ADB::new
+  tc_hash_memory.open("*#bnum=#{n}#mode=wct#xmsiz=0")
   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)
-      @db.get(value)
+      tc_hash_memory.put(value, value)
+      tc_hash_memory.get(value)
     end
   end
 
+  tc_tree_memory = TokyoCabinet::ADB::new
+  tc_tree_memory.open("+#bnum=#{n}#mode=wct#xmsiz=0")
   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)
-      @db.get(value)
+      tc_tree_memory.put(value, value)
+      tc_tree_memory.get(value)
     end
   end
 
   hash_file = Tempfile.new(["tc-hash", ".tch"])
+  tc_hash_file = TokyoCabinet::ADB::new
+  tc_hash_file.open("#{hash_file.path}#bnum=#{n}#mode=wct#xmsiz=0")
   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)
-      @db.get(value)
+      tc_hash_file.put(value, value)
+      tc_hash_file.get(value)
     end
   end
 
   tree_file = Tempfile.new(["tc-tree", ".tcb"])
+  tc_tree_file = TokyoCabinet::ADB::new
+  tc_tree_file.open("#{tree_file.path}#bnum=#{n}#mode=wct#xmsiz=0")
   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)
-      @db.get(value)
+      tc_tree_file.put(value, value)
+      tc_tree_file.get(value)
     end
   end
 rescue LoadError

data/benchmark/write-many-small-items.rb

@@ -3,32 +3,31 @@
 # This benchmark is based on Tokyo Cabinet's benchmark at
 # http://alpha.mixi.co.jp/blog/?p=791
 #
-# On my environment at 2009/07/14:
-# % for x in {0..9}; do ruby benchmark/write-many-small-items.rb $x; done
-#                           user     system      total        real        memory
-# Hash                  0.650000   0.130000   0.780000 (  0.799843)     46.957MB
-# groonga: Hash: memory 0.650000   0.130000   0.780000 (  0.781058)     23.477MB
-# groonga: Trie: memory 0.690000   0.180000   0.870000 (  0.862132)     15.516MB
-# groonga: Hash: file   0.660000   0.120000   0.780000 (  0.780952)     23.480MB
-# groonga: Trie: file   0.660000   0.190000   0.850000 (  0.867515)     15.520MB
-# Localmemcache: file   0.900000   0.150000   1.050000 (  1.052692)     39.312MB
-# TC: Hash: memory      0.480000   0.150000   0.630000 (  0.636297)     42.062MB
-# TC: Tree: memory      0.440000   0.150000   0.590000 (  0.593117)     30.570MB
-# TC: Hash: file        1.000000   1.820000   2.820000 (  2.989515)      2.160MB
-# TC: Tree: file        0.720000   0.130000   0.850000 (  0.877557)      6.102MB
+# On my environment at 2012/01/25:
+# % for x in {0..8}; do ruby1.9.1 benchmark/write-many-small-items.rb $x; done
+#                              user     system      total        real     memory
+# Hash                     0.320000   0.030000   0.350000 (  0.345441)  44.910MB
+# groonga: Hash            0.490000   0.020000   0.510000 (  0.512336)  23.305MB
+# groonga: PatriciaTrie    0.560000   0.010000   0.570000 (  0.572077)  19.242MB
+# groonga: DoubleArrayTrie 0.700000   0.020000   0.720000 (  0.730448)  39.789MB
+# Localmemcache: file      0.510000   0.040000   0.550000 (  0.549663)  45.898MB
+# TC: Hash: memory         0.270000   0.020000   0.290000 (  0.292051)  40.148MB
+# TC: Tree: memory         0.220000   0.010000   0.230000 (  0.229233)  28.727MB
+# TC: Hash: file           0.610000   0.630000   1.240000 (  1.247094)   2.129MB
+# TC: Tree: file           0.340000   0.040000   0.380000 (  0.377910)   4.000MB
 #
-# CPU: Intel(R) Core(TM)2 Duo 2.33GHz
-# Memory: 2GB
-# Ruby: Debian GNU/Linux sid at 2009/07/14:
-#       ruby 1.8.7 (2009-06-12 patchlevel 174) [x86_64-linux]
-# groonga: HEAD at 2009/07/14: fdaf58df5dd0195c10624eabee3e3f522f4af3f9
-# Ruby/Groonga: trunk at 2009/07/14: r479
-# Localmemcache: HEAD at 2009/07/14: 3121629016344dfd10f7533ca8ec68a0006cca21
-# Tokyo Cabinet: 1.4.29
-# Tokyo Cabinet Ruby: 1.27
+# CPU: Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz stepping 05
+# Memory: 8GB
+# Ruby: Debian GNU/Linux sid at 2012/01/25:
+#       ruby 1.9.3p0 (2011-10-30 revision 33570) [x86_64-linux]
+# groonga: HEAD at 2012/01/25: 07dce043cc8cfbbecbcdc43bf7c6d5c2d085237a
+# rroonga: master at 2012/01/25: 29099bff93377733d81dc2398c3403e1293301dc
+# Localmemcache: 0.4.4
+# Tokyo Cabinet: 1.4.37
+# Tokyo Cabinet Ruby: 1.31
 #
 # NOTE:
-# * groonga, Localmemcache and Tokyo Cabinet are built with "-O3" option.
+# * groonga, Localmemcache and Tokyo Cabinet are built with "-O2" option.
 # * Ruby bindings of them are built with "-O2" option.
 
 require File.join(File.dirname(__FILE__), "common.rb")
@@ -40,41 +39,50 @@ n.times do |i|
   values << "%08d" % i
 end
 
+ruby_hash = {}
 item("Hash") do
-  @hash = {}
   values.each do |value|
-    @hash[value] = value
+    ruby_hash[value] = value
   end
 end
 
 begin
   base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
-  $LOAD_PATH.unshift(File.join(base_dir, "ext"))
+  $LOAD_PATH.unshift(File.join(base_dir, "ext", "groonga"))
   $LOAD_PATH.unshift(File.join(base_dir, "lib"))
 
   require 'groonga'
   tmp_dir = "/tmp/groonga"
   FileUtils.rm_rf(tmp_dir)
   FileUtils.mkdir(tmp_dir)
+  Groonga::Context.default.encoding = :none
   @database = Groonga::Database.create(:path => "#{tmp_dir}/db")
+  column_name = "value"
 
-  item("groonga: Hash: file") do
-    @hash = Groonga::Hash.create(:name => "Hash",
-                                 :key_type => "ShortText")
-    column_name = "value"
-    @column = @hash.define_column(column_name, "ShortText")
+  groonga_hash = Groonga::Hash.create(:name => "Hash",
+                                      :key_type => "ShortText")
+  groonga_hash.define_column(column_name, "ShortText")
+  item("groonga: Hash") do
     values.each do |value|
-      @hash.set_column_value(value, column_name, value)
+      groonga_hash.set_column_value(value, column_name, value)
     end
   end
 
-  item("groonga: Trie: file") do
-    @trie = Groonga::PatriciaTrie.create(:name => "PatriciaTrie",
-                                         :key_type => "ShortText")
-    column_name = "value"
-    @column = @trie.define_column(column_name, "ShortText")
+  patricia_trie = Groonga::PatriciaTrie.create(:name => "PatriciaTrie",
+                                               :key_type => "ShortText")
+  patricia_trie.define_column(column_name, "ShortText")
+  item("groonga: PatriciaTrie") do
     values.each do |value|
-      @trie.set_column_value(value, column_name, value)
+      patricia_trie.set_column_value(value, column_name, value)
+    end
+  end
+
+  double_array_trie = Groonga::DoubleArrayTrie.create(:name => "DoubleArrayTrie",
+                                                      :key_type => "ShortText")
+  double_array_trie.define_column(column_name, "ShortText")
+  item("groonga: DoubleArrayTrie") do
+    values.each do |value|
+      double_array_trie.set_column_value(value, column_name, value)
     end
   end
 rescue LoadError
@@ -83,11 +91,11 @@ end
 begin
   require 'localmemcache'
 
+  LocalMemCache.drop(:namespace => "write-many-small-items", :force => true)
+  mem_cache = LocalMemCache.new(:namespace => "write-many-small-items")
   item("Localmemcache: file") do
-    LocalMemCache.drop(:namespace => "write-many-small-items", :force => true)
-    @db = LocalMemCache.new(:namespace => "write-many-small-items")
     values.each do |value|
-      @db[value] = value
+      mem_cache[value] = value
     end
   end
 rescue LoadError
@@ -96,37 +104,37 @@ end
 begin
   require 'tokyocabinet'
 
+  tc_hash_memory = TokyoCabinet::ADB::new
+  tc_hash_memory.open("*#bnum=#{n}#mode=wct#xmsiz=0")
   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)
+      tc_hash_memory.put(value, value)
     end
   end
 
+  tc_tree_memory = TokyoCabinet::ADB::new
+  tc_tree_memory.open("+#bnum=#{n}#mode=wct#xmsiz=0")
   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)
+      tc_tree_memory.put(value, value)
     end
   end
 
   hash_file = Tempfile.new(["tc-hash", ".tch"])
+  tc_hash_file = TokyoCabinet::ADB::new
+  tc_hash_file.open("#{hash_file.path}#bnum=#{n}#mode=wct#xmsiz=0")
   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)
+      tc_hash_file.put(value, value)
     end
   end
 
   tree_file = Tempfile.new(["tc-tree", ".tcb"])
+  tc_tree_file = TokyoCabinet::ADB::new
+  tc_tree_file.open("#{tree_file.path}#bnum=#{n}#mode=wct#xmsiz=0")
   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)
+      tc_tree_file.put(value, value)
     end
   end
 rescue LoadError

data/ext/groonga/rb-grn-context.c

@@ -211,13 +211,31 @@ VALUE
 rb_grn_context_rb_string_encode (grn_ctx *context, VALUE rb_string)
 {
 #ifdef HAVE_RUBY_ENCODING_H
-    rb_encoding *encoding, *to_encode;
+    int index, to_index;
+    rb_encoding *encoding, *to_encoding;
+    grn_encoding context_encoding;
+
+    context_encoding = context->encoding;
+    if (context->encoding == GRN_ENC_DEFAULT)
+	context->encoding = grn_get_default_encoding();
+    if (context->encoding == GRN_ENC_NONE)
+	return rb_string;
+
+    if (RSTRING_LEN(rb_string) < 0)
+	return rb_string;
 
     encoding = rb_enc_get(rb_string);
-    to_encode = rb_grn_encoding_to_ruby_encoding(context->encoding);
-    if (rb_enc_to_index(encoding) != rb_enc_to_index(to_encode))
-	rb_string = rb_str_encode(rb_string, rb_enc_from_encoding(to_encode),
-				  0, Qnil);
+    to_encoding = rb_grn_encoding_to_ruby_encoding(context_encoding);
+    index = rb_enc_to_index(encoding);
+    to_index = rb_enc_to_index(to_encoding);
+    if (index == to_index)
+	return rb_string;
+
+    if (rb_enc_asciicompat(to_encoding) && rb_enc_str_asciionly_p(rb_string))
+	return rb_string;
+
+    rb_string = rb_str_encode(rb_string, rb_enc_from_encoding(to_encoding),
+			      0, Qnil);
 #endif
     return rb_string;
 }

data/ext/groonga/rb-grn-index-column.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; c-file-style: "ruby" -*- */
 /*
-  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2012  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
@@ -453,11 +453,7 @@ rb_grn_index_column_search (int argc, VALUE *argv, VALUE self)
 
     rb_scan_args(argc, argv, "11", &rb_query, &options);
 
-    if (CBOOL2RVAL(rb_obj_is_kind_of(rb_query, rb_cGrnQuery))) {
-	grn_query *_query;
-	_query = RVAL2GRNQUERY(rb_query);
-	query = (grn_obj *)_query;
-    } else if (CBOOL2RVAL(rb_obj_is_kind_of(rb_query, rb_cInteger))) {
+    if (CBOOL2RVAL(rb_obj_is_kind_of(rb_query, rb_cInteger))) {
 	grn_id id;
 	id = NUM2UINT(rb_query);
 	GRN_TEXT_SET(context, id_query, &id, sizeof(grn_id));

data/ext/groonga/rb-grn-operator.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; c-file-style: "ruby" -*- */
 /*
-  Copyright (C) 2009-2011  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2012  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
@@ -20,6 +20,36 @@
 
 VALUE rb_mGrnOperator;
 
+grn_operator
+rb_grn_operator_from_ruby_object (VALUE rb_operator)
+{
+    grn_operator operator = GRN_OP_OR;
+
+    if (NIL_P(rb_operator) ||
+        rb_grn_equal_option(rb_operator, "or") ||
+        rb_grn_equal_option(rb_operator, "||")) {
+        operator = GRN_OP_OR;
+    } else if (rb_grn_equal_option(rb_operator, "and") ||
+               rb_grn_equal_option(rb_operator, "+") ||
+               rb_grn_equal_option(rb_operator, "&&")) {
+        operator = GRN_OP_AND;
+    } else if (rb_grn_equal_option(rb_operator, "but") ||
+               rb_grn_equal_option(rb_operator, "not") ||
+               rb_grn_equal_option(rb_operator, "-")) {
+        operator = GRN_OP_BUT;
+    } else if (rb_grn_equal_option(rb_operator, "adjust") ||
+               rb_grn_equal_option(rb_operator, ">")) {
+        operator = GRN_OP_ADJUST;
+    } else {
+        rb_raise(rb_eArgError,
+                 "operator should be one of "
+                 "[:or, :||, :and, :+, :&&, :but, :not, :-, :adjust, :>]: <%s>",
+                 rb_grn_inspect(rb_operator));
+    }
+
+    return operator;
+}
+
 void
 rb_grn_init_operator (VALUE mGrn)
 {

data/ext/groonga/rb-grn-variable-size-column.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; c-file-style: "ruby" -*- */
 /*
-  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+  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
@@ -28,6 +28,80 @@ VALUE rb_cGrnVariableSizeColumn;
  * 可変長データ用のカラム。
  */
 
+/*
+ * Document-method: compressed?
+ *
+ * call-seq:
+ *   column.compressed?        -> boolean
+ *   column.compressed?(type)  -> boolean
+ *
+ * Returns whether the column is compressed or not. If
+ * @type@ is specified, it returns whether the column is
+ * compressed by @type@ or not.
+ *
+ * @return [Boolean] whether the column is compressed or not.
+ * @param [:zlib, :lzo] type (nil) If @type@ isn't @nil@,
+ *   it checks whether specified compressed type is used or
+ *   not.
+ * @since 1.3.1
+ */
+static VALUE
+rb_grn_variable_size_column_compressed_p (int argc, VALUE *argv, VALUE self)
+{
+    RbGrnColumn *rb_grn_column;
+    grn_ctx *context = NULL;
+    grn_obj *column;
+    grn_obj_flags flags;
+    VALUE type;
+    grn_bool compressed_p = GRN_FALSE;
+    grn_bool accept_any_type = GRN_FALSE;
+    grn_bool need_zlib_check = GRN_FALSE;
+    grn_bool need_lzo_check = GRN_FALSE;
+
+    rb_scan_args(argc, argv, "01", &type);
+
+    if (NIL_P(type)) {
+	accept_any_type = GRN_TRUE;
+    } else {
+	if (rb_grn_equal_option(type, "zlib")) {
+	    need_zlib_check = GRN_TRUE;
+	} else if (rb_grn_equal_option(type, "lzo")) {
+	    need_lzo_check = GRN_TRUE;
+	} else {
+	    rb_raise(rb_eArgError,
+		     "compressed type should be <:zlib> or <:lzo>: <%s>",
+		     rb_grn_inspect(type));
+	}
+    }
+
+    rb_grn_column = SELF(self);
+    rb_grn_object_deconstruct(RB_GRN_OBJECT(rb_grn_column), &column, &context,
+			      NULL, NULL,
+			      NULL, NULL);
+
+    flags = column->header.flags;
+    switch (flags & GRN_OBJ_COMPRESS_MASK) {
+      case GRN_OBJ_COMPRESS_ZLIB:
+	if (accept_any_type || need_zlib_check) {
+	    grn_obj support_p;
+	    GRN_BOOL_INIT(&support_p, 0);
+	    grn_obj_get_info(context, NULL, GRN_INFO_SUPPORT_ZLIB, &support_p);
+	    compressed_p = GRN_BOOL_VALUE(&support_p);
+	}
+	break;
+      case GRN_OBJ_COMPRESS_LZO:
+	if (accept_any_type || need_lzo_check) {
+	    grn_obj support_p;
+	    GRN_BOOL_INIT(&support_p, 0);
+	    grn_obj_get_info(context, NULL, GRN_INFO_SUPPORT_LZO, &support_p);
+	    compressed_p = GRN_BOOL_VALUE(&support_p);
+	}
+	break;
+    }
+
+    return CBOOL2RVAL(compressed_p);
+}
+
 /*
  * Document-method: defrag
  *
@@ -77,6 +151,8 @@ rb_grn_init_variable_size_column (VALUE mGrn)
     rb_cGrnVariableSizeColumn =
 	rb_define_class_under(mGrn, "VariableSizeColumn", rb_cGrnColumn);
 
+    rb_define_method(rb_cGrnVariableSizeColumn, "compressed?",
+		     rb_grn_variable_size_column_compressed_p, -1);
     rb_define_method(rb_cGrnVariableSizeColumn, "defrag",
 		     rb_grn_variable_size_column_defrag, -1);
 }