groonga 0.0.5 → 0.0.6

data/lib/groonga/expression-builder.rb

@@ -17,11 +17,8 @@
 
 module Groonga
   module ExpressionBuildable
-    attr_accessor :builder, :expression, :variable
+    attr_reader :table
     def initialize(*args)
-      @builder = self
-      @expression = nil
-      @variable = nil
       @table = nil
       @name = nil
       @query = nil
@@ -29,17 +26,119 @@ module Groonga
     end
 
     def build
-      @expression = Expression.new(:table => @table,
-                                   :name => @name,
-                                   :query => @query,
-                                   :default_column => @default_column)
-      if block_given?
-        @variable = @expression.define_variable(:domain => @table)
-        @expression.append_object(@variable)
-        yield(self)
-        @expression.compile
-      end
-      @expression
+      expression = Expression.new(:table => @table,
+                                  :name => @name,
+                                  :query => @query,
+                                  :default_column => @default_column)
+      variable = expression.define_variable(:domain => @table)
+
+      builder = nil
+      builder = yield(self) if block_given?
+      if builder.nil? or builder == self
+        expression.append_constant(1)
+        expression.append_constant(1)
+        expression.append_operation(Groonga::Operation::OR, 2)
+      else
+        builder.build(expression, variable)
+      end
+
+      expression.compile
+      expression
+    end
+
+    class ExpressionBuilder
+      def initialize
+        super()
+      end
+
+      def &(other)
+        AndExpressionBuilder.new(self, other)
+      end
+
+      def |(other)
+        OrExpressionBuilder.new(self, other)
+      end
+    end
+
+    class SetExpressionBuilder < ExpressionBuilder
+      def initialize(operation, *expression_builders)
+        super()
+        @operation = operation
+        @expression_builders = expression_builders
+      end
+
+      def build(expression, variable)
+        return if @expression_builders.empty?
+        @expression_builders.each do |builder|
+          builder.build(expression, variable)
+        end
+        expression.append_operation(@operation, @expression_builders.size)
+      end
+    end
+
+    class AndExpressionBuilder < SetExpressionBuilder
+      def initialize(*expression_builders)
+        super(Groonga::Operation::AND, *expression_builders)
+      end
+    end
+
+    class OrExpressionBuilder < SetExpressionBuilder
+      def initialize(*expression_builders)
+        super(Groonga::Operation::OR, *expression_builders)
+      end
+    end
+
+    class BinaryExpressionBuilder < ExpressionBuilder
+      def initialize(operation, column_name, value)
+        super()
+        @operation = operation
+        @column_name = column_name
+        @value = value
+      end
+
+      def build(expression, variable)
+        expression.append_object(variable)
+        expression.append_constant(@column_name)
+        expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
+        expression.append_constant(@value)
+        expression.append_operation(@operation, 2)
+      end
+    end
+
+    class EqualExpressionBuilder < BinaryExpressionBuilder
+      def initialize(column_name, value)
+        super(Groonga::Operation::EQUAL, column_name, value)
+      end
+    end
+
+    class MatchExpressionBuilder < BinaryExpressionBuilder
+      def initialize(column_name, value)
+        super(Groonga::Operation::MATCH, column_name, value)
+      end
+    end
+
+    class LessExpressionBuilder < BinaryExpressionBuilder
+      def initialize(column_name, value)
+        super(Groonga::Operation::LESS, column_name, value)
+      end
+    end
+
+    class LessEqualExpressionBuilder < BinaryExpressionBuilder
+      def initialize(column_name, value)
+        super(Groonga::Operation::LESS_EQUAL, column_name, value)
+      end
+    end
+
+    class GreaterExpressionBuilder < BinaryExpressionBuilder
+      def initialize(column_name, value)
+        super(Groonga::Operation::GREATER, column_name, value)
+      end
+    end
+
+    class GreaterEqualExpressionBuilder < BinaryExpressionBuilder
+      def initialize(column_name, value)
+        super(Groonga::Operation::GREATER_EQUAL, column_name, value)
+      end
     end
   end
 
@@ -47,7 +146,7 @@ module Groonga
     include ExpressionBuildable
 
     def initialize(table, name)
-      super
+      super()
       @table = table
       @name = name
     end
@@ -59,16 +158,7 @@ module Groonga
           "for table <#{@table.inspect}>"
         raise ArgumentError, message
       end
-      builder = ColumnExpressionBuilder.new(column, nil, nil)
-      builder.builder = @builder
-      builder.expression = @expression
-      builder.variable = @variable
-      builder
-    end
-
-    def &(other)
-      @expression.append_operation(Groonga::Operation::AND, 2)
-      @builder
+      ColumnExpressionBuilder.new(column, nil, nil)
     end
   end
 
@@ -76,8 +166,9 @@ module Groonga
     include ExpressionBuildable
 
     def initialize(column, name, query)
-      super
+      super()
       @table = column.table
+      @range = column.range
       @column = column
       @default_column = column.local_name
       @name = name
@@ -85,57 +176,36 @@ module Groonga
     end
 
     def ==(other)
-      @expression.append_object(@variable)
-      @expression.append_constant(@column.local_name)
-      @expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
-      @expression.append_constant(other)
-      @expression.append_operation(Groonga::Operation::EQUAL, 2)
-      @builder
+      EqualExpressionBuilder.new(@column.local_name, normalize(other))
     end
 
     def =~(other)
-      @expression.append_object(@variable)
-      @expression.append_constant(@column.local_name)
-      @expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
-      @expression.append_constant(other)
-      @expression.append_operation(Groonga::Operation::MATCH, 2)
-      @builder
+      MatchExpressionBuilder.new(@column.local_name, normalize(other))
     end
 
     def <(other)
-      @expression.append_object(@variable)
-      @expression.append_constant(@column.local_name)
-      @expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
-      @expression.append_constant(other)
-      @expression.append_operation(Groonga::Operation::LESS, 2)
-      @builder
+      LessExpressionBuilder.new(@column.local_name, normalize(other))
     end
 
     def <=(other)
-      @expression.append_object(@variable)
-      @expression.append_constant(@column.local_name)
-      @expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
-      @expression.append_constant(other)
-      @expression.append_operation(Groonga::Operation::LESS_EQUAL, 2)
-      @builder
+      LessEqualExpressionBuilder.new(@column.local_name, normalize(other))
     end
 
     def >(other)
-      @expression.append_object(@variable)
-      @expression.append_constant(@column.local_name)
-      @expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
-      @expression.append_constant(other)
-      @expression.append_operation(Groonga::Operation::GREATER, 2)
-      @builder
+      GreaterExpressionBuilder.new(@column.local_name, normalize(other))
     end
 
     def >=(other)
-      @expression.append_object(@variable)
-      @expression.append_constant(@column.local_name)
-      @expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
-      @expression.append_constant(other)
-      @expression.append_operation(Groonga::Operation::GREATER_EQUAL, 2)
-      @builder
+      GreaterEqualExpressionBuilder.new(@column.local_name, normalize(other))
+    end
+
+    private
+    def normalize(other)
+      if @range.is_a?(Groonga::Table) and other.is_a?(Integer)
+        Groonga::Record.new(@range, other)
+      else
+        other
+      end
     end
   end
 end

data/lib/groonga/schema.rb

@@ -19,6 +19,29 @@
 module Groonga
 
   # groongaのスキーマ（データ構造）を管理するクラス。
+  #
+  # Groonga::Schemaを使うことにより簡単にテーブルやカラムを
+  # 追加・削除することができる。
+  #
+  # http://qwik.jp/senna/senna2.files/rect4605.png
+  # のようなスキーマを定義する場合は以下のようになる。
+  #
+  #   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.text("content")
+  #       table.time("issued")
+  #     end
+  #   end
   class Schema
     class << self
 
@@ -70,16 +93,35 @@ module Groonga
       #   合はパス名は自動的に作成される。デフォルトでは永続
       #   テーブルとなる。
       #
-      # [+:value_size+]
-      #   値のサイズを指定する。デフォルトは0。
+      # [+:value_type+]
+      #   値の型を指定する。省略すると値のための領域を確保しない。
+      #   値を保存したい場合は必ず指定すること。
       def create_table(name, options={}, &block)
         define do |schema|
           schema.create_table(name, options, &block)
         end
       end
 
+      # 名前が_name_のテーブルを削除する。
+      # _options_に指定可能な値は以下の通り。
+      #
+      # [+:context+]
+      #   スキーマ定義時に使用するGroonga::Contextを指定する。
+      #   省略した場合はGroonga::Context.defaultを使用する。
+      def remove_table(name, options={})
+        define do |schema|
+          schema.remove_table(name, options)
+        end
+      end
+
+      def change_table(name, options={}, &block)
+        define do |schema|
+          schema.change_table(name, options, &block)
+        end
+      end
+
       # スキーマの内容を文字列で返す。返された値は
-      # Groonga::Schema#restoreすることによりスキーマ内に組
+      # Groonga::Schema.restoreすることによりスキーマ内に組
       # み込むことができる。
       #
       #   dump.rb:
@@ -90,9 +132,7 @@ module Groonga
       #   restore.rb:
       #     dumped_text = Groonga::Schema.dump
       #     Groonga::Database.create(:path => "/tmp/new-db.grn")
-      #     Groonga::Schema.define do |schema|
-      #       schema.restore(dumped_text)
-      #     end
+      #     Groonga::Schema.restore(dumped_text)
       #
       # _options_に指定可能な値は以下の通り。
       #
@@ -103,6 +143,13 @@ module Groonga
         Dumper.new(options).dump
       end
 
+      # Groonga::Schema.dumpで文字列化したスキーマを組み込む。
+      def restore(dumped_text, options={})
+        define(options) do |schema|
+          schema.load(dumped_text)
+	end
+      end
+
       def normalize_type(type) # :nodoc:
         return type if type.nil?
         return type if type.is_a?(Groonga::Object)
@@ -152,7 +199,7 @@ module Groonga
     #
     # 読み込まれた内容は#defineを呼び出すまでは実行されない
     # ことに注意すること。
-    def restore(dumped_text)
+    def load(dumped_text)
       instance_eval(dumped_text)
     end
 
@@ -178,36 +225,97 @@ module Groonga
     #   合はパス名は自動的に作成される。デフォルトでは永続
     #   テーブルとなる。
     #
-    # [+:value_size+]
-    #   値のサイズを指定する。デフォルトは0。
+    # [+:value_type+]
+    #   値の型を指定する。省略すると値のための領域を確保しな
+    #   い。値を保存したい場合は必ず指定すること。
+    #
+    #   参考: Groonga::Type.new
     def create_table(name, options={})
       definition = TableDefinition.new(name, @options.merge(options || {}))
       yield(definition)
       @definitions << definition
     end
 
+    def remove_table(name, options={})
+      definition = TableRemoveDefinition.new(name, @options.merge(options || {}))
+      @definitions << definition
+    end
+
+    def change_table(name, options={})
+      options = @options.merge(options || {}).merge(:change => true)
+      definition = TableDefinition.new(name, options)
+      yield(definition)
+      @definitions << definition
+    end
+
     class TableDefinition
+      attr_reader :name
+
       def initialize(name, options)
         @name = name
         @name = @name.to_s if @name.is_a?(Symbol)
-        @columns = []
+        @definitions = []
+        validate_options(options)
         @options = options
         @table_type = table_type
       end
 
       def define
-        table = @table_type.create(create_options)
-        @columns.each do |column|
-          column.define(table)
+        if @options[:change]
+          table = context[@name]
+        else
+          table = context[@name]
+          if table and @options[:force]
+            table.remove
+          end
+          table = @table_type.create(create_options)
+        end
+        @definitions.each do |definition|
+          definition.define(table)
         end
         table
       end
 
       def column(name, type, options={})
-        column = self[name] || ColumnDefinition.new(name, options)
-        column.type = type
-        column.options.merge!(options)
-        @columns << column unless @columns.include?(column)
+        definition = self[name, ColumnDefinition]
+        if definition.nil?
+          definition = ColumnDefinition.new(name, options)
+          update_definition(name, ColumnDefinition, definition)
+        end
+        definition.type = type
+        definition.options.merge!(column_options.merge(options))
+        self
+      end
+
+      def remove_column(name, options={})
+        definition = self[name, ColumnRemoveDefinition]
+        if definition.nil?
+          definition = ColumnRemoveDefinition.new(name, options)
+          update_definition(name, ColumnRemoveDefinition, definition)
+        end
+        definition.options.merge!(options)
+        self
+      end
+
+      def index(target_column, options={})
+        name = options.delete(:name)
+        if name.nil?
+          target_column_name = nil
+          if target_column.is_a?(Groonga::Column)
+            target_column_name = target_column.name
+          else
+            target_column_name = target_column
+          end
+          name = target_column_name.gsub(/\./, "_")
+        end
+
+        definition = self[name, IndexColumnDefinition]
+        if definition.nil?
+          definition = IndexColumnDefinition.new(name, options)
+          update_definition(name, IndexColumnDefinition, definition)
+        end
+        definition.target = target_column
+        definition.options.merge!(column_options.merge(options))
         self
       end
 
@@ -254,19 +362,47 @@ module Groonga
         column(name, "LongText", options)
       end
 
-      def index(name, target_column, options={})
-        column = self[name] || IndexColumnDefinition.new(name, options)
-        column.target = target_column
-        column.options.merge!(options)
-        @columns << column unless @columns.include?(column)
-        self
+      def reference(name, table, options={})
+        column(name, table, options)
+      end
+
+      def [](name, definition_class=nil)
+        @definitions.find do |definition|
+          definition.name.to_s == name.to_s and
+            (definition_class.nil? or definition.is_a?(definition_class))
+        end
       end
 
-      def [](name)
-        @columns.find {|column| column.name == name}
+      def context
+        @options[:context] || Groonga::Context.default
       end
 
       private
+      def update_definition(name, definition_class, definition)
+        old_definition = self[name, definition_class]
+        if old_definition
+          index = @definitions.index(old_definition)
+          @definitions[index] = definition
+        else
+          @definitions << definition
+        end
+      end
+
+      AVAILABLE_OPTION_KEYS = [:context, :change, :force,
+                               :type, :path, :persistent,
+                               :key_type, :value_type, :sub_records,
+                               :default_tokenizer,
+                               :key_normalize, :key_with_sis]
+      def validate_options(options)
+        return if options.nil?
+        unknown_keys = options.keys - AVAILABLE_OPTION_KEYS
+        unless unknown_keys.empty?
+          message = "unknown keys are specified: #{unknown_keys.inspect}"
+          message << ": available keys: #{AVAILABLE_OPTION_KEYS.inspect}"
+          raise ArgumentError, message
+        end
+      end
+
       def table_type
         type = @options[:type]
         case type
@@ -286,8 +422,9 @@ module Groonga
           :name => @name,
           :path => @options[:path],
           :persistent => persistent?,
-          :value_size => @options[:value_size],
+          :value_type => @options[:value_type],
           :context => context,
+          :sub_records => @options[:sub_records],
         }
         key_support_table_common = {
           :key_type => Schema.normalize_type(@options[:key_type]),
@@ -309,12 +446,24 @@ module Groonga
         end
       end
 
+      def column_options
+        {:persistent => persistent?}
+      end
+
       def persistent?
         @options[:persistent].nil? ? true : @options[:persistent]
       end
+    end
 
-      def context
-        @options[:context] || Groonga::Context.default
+    class TableRemoveDefinition
+      def initialize(name, options={})
+        @name = name
+        @options = options
+      end
+
+      def define
+        context = @options[:context] || Groonga::Context.default
+        context[@name].remove
       end
     end
 
@@ -336,6 +485,21 @@ module Groonga
       end
     end
 
+    class ColumnRemoveDefinition
+      attr_accessor :name
+      attr_reader :options
+
+      def initialize(name, options={})
+        @name = name
+        @name = @name.to_s if @name.is_a?(Symbol)
+        @options = (options || {}).dup
+      end
+
+      def define(table)
+        table.column(@name).remove
+      end
+    end
+
     class IndexColumnDefinition
       attr_accessor :name, :target
       attr_reader :options
@@ -350,6 +514,9 @@ module Groonga
       def define(table)
         target = @target
         target = context[target] unless target.is_a?(Groonga::Object)
+        if target.nil?
+          raise ArgumentError, "Unknown index target: #{@target.inspect}"
+        end
         index = table.define_index_column(@name,
                                           target.table,
                                           @options)
@@ -373,24 +540,49 @@ module Groonga
         database = context.database
         return nil if database.nil?
 
-        schema = ""
+        reference_columns = []
+        definitions = []
         database.each do |object|
           next unless object.is_a?(Groonga::Table)
-          next if object.name == "<ranguba:objects>"
-          schema << "create_table(#{object.name.inspect}) do |table|\n"
-          object.columns.each do |column|
-            type = column_method(column)
+          schema = "create_table(#{object.name.inspect}) do |table|\n"
+          object.columns.sort_by {|column| column.local_name}.each do |column|
+            if column.range.is_a?(Groonga::Table)
+              reference_columns << column
+            else
+              type = column_method(column)
+              name = column.local_name
+              schema << "  table.#{type}(#{name.inspect})\n"
+            end
+          end
+          schema << "end"
+          definitions << schema
+        end
+
+        reference_columns.group_by do |column|
+          column.table
+        end.each do |table, columns|
+          schema = "change_table(#{table.name.inspect}) do |table|\n"
+          columns.each do |column|
             name = column.local_name
-            schema << "  table.#{type}(#{name.inspect})\n"
+            reference = column.range
+            schema << "  table.reference(#{name.inspect}, " +
+                                        "#{reference.name.inspect})\n"
           end
-          schema << "end\n"
+          schema << "end"
+          definitions << schema
+        end
+
+        if definitions.empty?
+          ""
+        else
+          definitions.join("\n\n") + "\n"
         end
-        schema
       end
 
       private
       def column_method(column)
-        case column.range.name
+        range = column.range
+        case range.name
         when "Int32"
           "integer32"
         when "Int64"

data/test/groonga-test-utils.rb

@@ -81,8 +81,8 @@ module GroongaTestUtils
 
   def teardown_sandbox
     @database = nil
-    teardown_tmp_directory
     GC.start
+    teardown_tmp_directory
   end
 
   def teardown_tmp_directory

data/test/test-array.rb

@@ -30,6 +30,7 @@ class ArrayTest < Test::Unit::TestCase
                  "path: <#{path}>, " +
                  "domain: <nil>, " +
                  "range: <nil>, " +
+                 "flags: <>, " +
                  "size: <3>>",
                  contain_table.inspect)
   end

data/test/test-context.rb

@@ -54,9 +54,15 @@ class ContextTest < Test::Unit::TestCase
                  context.inspect)
   end
 
-  def test_array_reference
+  def test_array_reference_by_string
     Groonga::Database.create
     context = Groonga::Context.default
     assert_equal("Int32", context["<int>"].name)
   end
+
+  def test_array_reference_by_symbol
+    Groonga::Database.create
+    context = Groonga::Context.default
+    assert_equal("Bool", context[:Bool].name)
+  end
 end