rroonga 3.0.1 → 3.0.2

data/ext/groonga/rb-grn.h

@@ -76,7 +76,7 @@ RB_GRN_BEGIN_DECLS
 
 #define RB_GRN_MAJOR_VERSION 3
 #define RB_GRN_MINOR_VERSION 0
-#define RB_GRN_MICRO_VERSION 1
+#define RB_GRN_MICRO_VERSION 2
 
 #define RB_GRN_QUERY_DEFAULT_MAX_EXPRESSIONS 32
 
@@ -616,8 +616,8 @@ VALUE          rb_grn_column_expression_builder_build
 
 #define RVAL2GRNUVECTOR(object, context, uvector, related_object)	\
     (rb_grn_uvector_from_ruby_object(object, context, uvector, related_object))
-#define GRNUVECTOR2RVAL(context, uvector) \
-    (rb_grn_uvector_to_ruby_object(context, uvector))
+#define GRNUVECTOR2RVAL(context, uvector, range, related_object)        \
+    (rb_grn_uvector_to_ruby_object(context, uvector, range, related_object))
 
 #define GRNVALUE2RVAL(context, value, range, related_object) \
     (rb_grn_value_to_ruby_object(context, value, range, related_object))
@@ -735,7 +735,9 @@ grn_obj       *rb_grn_uvector_from_ruby_object      (VALUE object,
 						     grn_obj *uvector,
 						     VALUE related_object);
 VALUE          rb_grn_uvector_to_ruby_object        (grn_ctx *context,
-						     grn_obj *uvector);
+						     grn_obj *uvector,
+                                                     grn_obj *range,
+                                                     VALUE related_object);
 
 VALUE          rb_grn_value_to_ruby_object          (grn_ctx *context,
 						     grn_obj *value,

data/lib/groonga/dumper.rb

@@ -54,15 +54,12 @@ module Groonga
         options[:context] ||= Groonga::Context.default
         options[:database] = options[:context].database
       end
-      options[:dump_plugins] = true if options[:dump_plugins].nil?
       options[:dump_schema] = true if options[:dump_schema].nil?
       options[:dump_tables] = true if options[:dump_tables].nil?
 
       if options[:dump_schema]
+        dump_plugins(options)
         schema_dumper = SchemaDumper.new(options.merge(:syntax => :command))
-      end
-      dump_plugins(options) if options[:dump_plugins]
-      if options[:dump_schema]
         schema_dumper.dump_tables
         if schema_dumper.have_reference_columns?
           options[:output].write("\n")
@@ -102,6 +99,7 @@ module Groonga
       options[:database].each(each_options(:order_by => :key)) do |object|
         next unless object.is_a?(Groonga::Table)
         next if object.size.zero?
+        next if index_only_table?(object)
         next if target_table?(options[:exclude_tables], object, false)
         next unless target_table?(options[:tables], object, true)
         options[:output].write("\n") if !first_table or options[:dump_schema]
@@ -124,6 +122,12 @@ module Groonga
       output.write("register #{plugin_name}\n")
     end
 
+    def index_only_table?(table)
+      table.columns.all? do |column|
+        column.index?
+      end
+    end
+
     def target_table?(target_tables, table, default_value)
       return default_value if target_tables.nil? or target_tables.empty?
       target_tables.any? do |name|
@@ -277,8 +281,17 @@ module Groonga
 
       def each_table
         each_options = {:order_by => :key, :ignore_missing_object => true}
+        reference_tables = []
         @database.each(each_options) do |object|
-          yield(object) if object.is_a?(Groonga::Table)
+          next unless object.is_a?(Groonga::Table)
+          if reference_table?(object)
+            reference_tables << object
+          else
+            yield(object)
+          end
+        end
+        reference_tables.each do |table|
+          yield(table)
         end
       end
 
@@ -287,7 +300,7 @@ module Groonga
         sorted_columns.each(&block)
       end
 
-      def collect_columns
+      def find_all_columns
         columns = []
         each_table do |table|
           each_column(table) do |column|
@@ -298,13 +311,13 @@ module Groonga
       end
 
       def reference_columns
-        @reference_columns ||= collect_columns do |column|
+        @reference_columns ||= find_all_columns do |column|
           reference_column?(column)
         end
       end
 
       def index_columns
-        @index_columns ||= collect_columns do |column|
+        @index_columns ||= find_all_columns do |column|
           index_column?(column)
         end
       end
@@ -333,6 +346,10 @@ module Groonga
         write("\n")
       end
 
+      def reference_table?(table)
+        table.support_key? and table.domain.is_a?(Groonga::Table)
+      end
+
       def column_type(column)
         if column.is_a?(Groonga::IndexColumn)
           :index

data/lib/groonga/record.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2009-2011  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2013  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
@@ -16,6 +16,7 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 require 'English'
+require "time"
 
 module Groonga
   class Record
@@ -253,6 +254,22 @@ module Groonga
       accessor.build
     end
 
+    def as_json
+      accessor = AttributeHashBuilder.new(self) do |value|
+        if value.is_a?(Time)
+          value.iso8601
+        else
+          value
+        end
+      end
+      accessor.build
+    end
+
+    # @return [String] the record formatted as JSON.
+    def to_json(*args)
+      as_json.to_json(*args)
+    end
+
     # レコードを削除する。
     def delete
       @table.delete(@id)
@@ -384,9 +401,10 @@ module Groonga
     class AttributeHashBuilder
       attr_reader :attributes
 
-      def initialize(root_record)
+      def initialize(root_record, &value_translator)
         @root_record = root_record
         @all_built_attributes = {}
+        @value_translator = value_translator
       end
 
       def build
@@ -415,6 +433,7 @@ module Groonga
         if value.is_a?(Record)
           build_attributes(value)
         else
+          value = @value_translator.call(value) if @value_translator
           value
         end
       end

data/lib/groonga/schema.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2009-2011  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2013  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
@@ -1463,7 +1463,7 @@ module Groonga
         return false unless table.range == resolve_name(options[:value_type])
         sub_records = options[:sub_records]
         sub_records = false if sub_records.nil?
-        return false unless table.support_sub_records? == sub_records
+        return false unless table.have_n_sub_records_space? == sub_records
 
         case table
         when Groonga::Array

data/rroonga-build.rb

@@ -19,7 +19,7 @@ module RroongaBuild
   module RequiredGroongaVersion
     MAJOR = 3
     MINOR = 0
-    MICRO = 3
+    MICRO = 4
     VERSION = [MAJOR, MINOR, MICRO]
   end
 

data/rroonga.gemspec

@@ -79,6 +79,8 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.rubyforge_project = "groonga"
 
+  s.required_ruby_version = ">= 1.9.3"
+
   s.add_runtime_dependency("pkg-config")
   s.add_runtime_dependency("json")
   s.add_runtime_dependency("archive-zip")

data/test/test-database-dumper.rb

@@ -107,13 +107,13 @@ column_create Users Posts_author COLUMN_INDEX Posts author
 EOS
   end
 
-  class EmptyTest < DatabaseDumperTest
+  class EmptyTest < self
     def test_default
       assert_equal(dumped_schema, dump)
     end
   end
 
-  class HaveDataTest < DatabaseDumperTest
+  class HaveDataTest < self
     setup
     def setup_data
       posts.add(:author => "mori",
@@ -287,7 +287,7 @@ EOS
     end
   end
 
-  class PluginTest < DatabaseDumperTest
+  class PluginTest < self
     def test_standard_plugin
       Groonga::Plugin.register("suggest/suggest")
       assert_equal("register suggest/suggest\n" +
@@ -296,4 +296,46 @@ EOS
                    dump)
     end
   end
+
+  class IndexTest < self
+    def setup_tables
+      Groonga::Schema.define do |schema|
+        schema.create_table("Posts") do |table|
+          table.text("title")
+          table.short_text("tag_text")
+        end
+
+        schema.create_table("Tags",
+                            :type => :hash,
+                            :key_type => :short_text,
+                            :default_tokenizer => :delimit) do |table|
+          table.index("Posts.tag_text")
+        end
+      end
+    end
+
+    setup
+    def setup_data
+      posts.add(:title => "Why search engine find?",
+                :tag_text => "search mori")
+    end
+
+    def test_index_column_only
+      assert_equal(<<-COMMAND, dump)
+table_create Posts TABLE_NO_KEY
+column_create Posts tag_text COLUMN_SCALAR ShortText
+column_create Posts title COLUMN_SCALAR Text
+
+table_create Tags TABLE_HASH_KEY --key_type ShortText --default_tokenizer TokenDelimit
+
+load --table Posts
+[
+["_id","tag_text","title"],
+[1,"search mori","Why search engine find?"]
+]
+
+column_create Tags Posts_tag_text COLUMN_INDEX Posts tag_text
+COMMAND
+    end
+  end
 end

data/test/test-expression-builder.rb

@@ -626,18 +626,5 @@ EOC
       assert_equal([["morita", 2]],
                    result.collect {|record| [record["_key"], record.key.score]})
     end
-
-    def test_n_sub_records
-      result = @users.select do |record|
-        (record.name =~ "o") | (record.key == "yu")
-      end
-      result = result.select do |record|
-        record.n_sub_records > 1
-      end
-      matched_records = result.collect do |record|
-        [record["_key"], record.key.n_sub_records]
-      end
-      assert_equal([["yu", 2]], matched_records)
-    end
   end
 end

data/test/test-fix-size-column.rb

@@ -64,14 +64,45 @@ class FixSizeColumnTest < Test::Unit::TestCase
     assert_equal(@bookmarks, @viewed.table)
   end
 
-  def test_assign_time
-    comments = Groonga::Array.create(:name => "Comments")
-    comments.define_column("title", "ShortText")
-    comments.define_column("issued", "Time")
-    title = "Good"
-    issued = 1187430026
-    record = comments.add(:title => title, :issued => issued)
-    assert_equal([title, Time.at(issued)],
-                 [record["title"], record["issued"]])
+  class TimeTest < self
+    class IntegerTest < self
+      def test_assign
+        comments = Groonga::Array.create(:name => "Comments")
+        comments.define_column("issued", "Time")
+        issued = 1187430026
+        record = comments.add(:issued => issued)
+        assert_equal(Time.at(issued), record["issued"])
+      end
+    end
+
+    class FloatTest < self
+      def test_assign
+        comments = Groonga::Array.create(:name => "Comments")
+        comments.define_column("issued", "Time")
+        issued = 1187430026.29
+        record = comments.add(:issued => issued)
+        assert_in_delta(issued, record["issued"].to_f, 0.001)
+      end
+    end
+
+    class TimeTest < self
+      def test_assign
+        comments = Groonga::Array.create(:name => "Comments")
+        comments.define_column("issued", "Time")
+        issued_in_float = 1187430026.29
+        issued = Time.at(issued_in_float)
+        record = comments.add(:issued => issued)
+        assert_in_delta(issued_in_float, record["issued"].to_f, 0.001)
+      end
+    end
+
+    class StringTest < self
+      def test_assign
+        comments = Groonga::Array.create(:name => "Comments")
+        comments.define_column("issued", "Time")
+        record = comments.add(:issued => "2010/06/01 00:00:00")
+        assert_equal(Time.new(2010, 6, 1, 0, 0, 0), record["issued"])
+      end
+    end
   end
 end

data/test/test-index-column.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2009-2011  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2013  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
@@ -88,6 +88,135 @@ class IndexColumnTest < Test::Unit::TestCase
                  content_index.search("エンジン").collect {|record| record.key})
   end
 
+  def test_add
+    articles = Groonga::Array.create(:name => "Articles")
+    articles.define_column("content", "Text")
+
+    terms = Groonga::Hash.create(:name => "Terms",
+                                 :key_type => "ShortText",
+                                 :default_tokenizer => "TokenBigram")
+    content_index = terms.define_index_column("content", articles,
+                                              :with_position => true,
+                                              :with_section => true)
+
+    content = <<-CONTENT
+    Groonga is a fast and accurate full text search engine based on
+    inverted index. One of the characteristics of groonga is that a
+    newly registered document instantly appears in search
+    results. Also, groonga allows updates without read locks. These
+    characteristics result in superior performance on real-time
+    applications.
+
+    Groonga is also a column-oriented database management system
+    (DBMS). Compared with well-known row-oriented systems, such as
+    MySQL and PostgreSQL, column-oriented systems are more suited for
+    aggregate queries. Due to this advantage, groonga can cover
+    weakness of row-oriented systems.
+
+    The basic functions of groonga are provided in a C library. Also,
+    libraries for using groonga in other languages, such as Ruby, are
+    provided by related projects. In addition, groonga-based storage
+    engines are provided for MySQL and PostgreSQL. These libraries
+    and storage engines allow any application to use groonga. See
+    usage examples.
+    CONTENT
+
+    groonga = articles.add(:content => content)
+
+    content.split(/\n{2,}/).each_with_index do |sentence, i|
+      content_index.add(groonga, sentence, :section => i + 1)
+    end
+    assert_equal([groonga], content_index.search("engine").collect(&:key))
+  end
+
+  def test_delete
+    articles = Groonga::Array.create(:name => "Articles")
+    articles.define_column("content", "Text")
+
+    terms = Groonga::Hash.create(:name => "Terms",
+                                 :key_type => "ShortText",
+                                 :default_tokenizer => "TokenBigram")
+    content_index = terms.define_index_column("content", articles,
+                                              :with_position => true,
+                                              :with_section => true)
+
+    content = <<-CONTENT
+    Groonga is a fast and accurate full text search engine based on
+    inverted index. One of the characteristics of groonga is that a
+    newly registered document instantly appears in search
+    results. Also, groonga allows updates without read locks. These
+    characteristics result in superior performance on real-time
+    applications.
+
+    Groonga is also a column-oriented database management system
+    (DBMS). Compared with well-known row-oriented systems, such as
+    MySQL and PostgreSQL, column-oriented systems are more suited for
+    aggregate queries. Due to this advantage, groonga can cover
+    weakness of row-oriented systems.
+
+    The basic functions of groonga are provided in a C library. Also,
+    libraries for using groonga in other languages, such as Ruby, are
+    provided by related projects. In addition, groonga-based storage
+    engines are provided for MySQL and PostgreSQL. These libraries
+    and storage engines allow any application to use groonga. See
+    usage examples.
+    CONTENT
+
+    groonga = articles.add(:content => content)
+
+    content.split(/\n{2,}/).each_with_index do |sentence, i|
+      content_index.add(groonga, sentence, :section => i + 1)
+    end
+    content.split(/\n{2,}/).each_with_index do |sentence, i|
+      content_index.delete(groonga, sentence, :section => i + 1)
+    end
+    assert_equal([], content_index.search("engine").collect(&:key))
+  end
+
+  def test_update
+    articles = Groonga::Array.create(:name => "Articles")
+    articles.define_column("content", "Text")
+
+    terms = Groonga::Hash.create(:name => "Terms",
+                                 :key_type => "ShortText",
+                                 :default_tokenizer => "TokenBigram")
+    content_index = terms.define_index_column("content", articles,
+                                              :with_position => true,
+                                              :with_section => true)
+
+    old_sentence = <<-SENTENCE
+    Groonga is a fast and accurate full text search engine based on
+    inverted index. One of the characteristics of groonga is that a
+    newly registered document instantly appears in search
+    results. Also, groonga allows updates without read locks. These
+    characteristics result in superior performance on real-time
+    applications.
+    SENTENCE
+
+    new_sentence = <<-SENTENCE
+    Groonga is also a column-oriented database management system
+    (DBMS). Compared with well-known row-oriented systems, such as
+    MySQL and PostgreSQL, column-oriented systems are more suited for
+    aggregate queries. Due to this advantage, groonga can cover
+    weakness of row-oriented systems.
+    SENTENCE
+
+    groonga = articles.add(:content => old_sentence)
+
+    content_index.add(groonga, old_sentence, :section => 1)
+    assert_equal([groonga],
+                 content_index.search("engine").collect(&:key))
+    assert_equal([],
+                 content_index.search("MySQL").collect(&:key))
+
+    groonga[:content] = new_sentence
+    content_index.update(groonga, old_sentence, new_sentence, :section => 1)
+    assert_equal([],
+                 content_index.search("engine").collect(&:key))
+    assert_equal([groonga],
+                 content_index.search("MySQL").collect(&:key))
+  end
+
   def test_shorter_query_than_ngram
     articles = Groonga::Array.create(:name => "Articles")
     articles.define_column("content", "Text")