activegroonga 0.0.2 → 0.0.6

data/lib/active_groonga/column.rb

@@ -60,6 +60,14 @@ module ActiveGroonga
       end
     end
 
+    def index?
+      @type == :index
+    end
+
+    def index_sources
+      @column.sources
+    end
+
     def reference_type?
       @type == :references
     end
@@ -77,6 +85,7 @@ module ActiveGroonga
 
     private
     def detect_type
+      return :index if @column.is_a?(Groonga::IndexColumn)
       case @column.range
       when Groonga::Type
         case @column.range.id

data/lib/active_groonga/dynamic_record_expression_builder.rb

@@ -0,0 +1,40 @@
+# Copyright (C) 2009  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 ActiveGroonga
+  class DynamicRecordExpressionBuilder
+    # Instantiates a new dynamic record expression builder.
+    #
+    # +record+ is a Groonga::RecordExpressionBuilder.
+    def initialize(record)
+      @record = record
+      define_column_readers
+    end
+
+    def [](name)
+      @record[name]
+    end
+
+    private
+    def define_column_readers
+      singleton_class = class << self; self; end
+      @record.table.columns.each do |column|
+        singleton_class.send(:define_method, column.local_name) do ||
+          self[column.local_name]
+        end
+      end
+    end
+  end
+end

data/lib/active_groonga/schema.rb

@@ -54,155 +54,54 @@ module ActiveGroonga
       end
 
       def initialize_schema_management_tables
-        initialize_index_management_table
-        initialize_index_table
         initialize_migrations_table
       end
 
-      def create_table(name, options={})
-        table_definition = TableDefinition.new(name)
-        yield(table_definition)
-        table_definition.create
+      def create_table(name, options={}, &block)
+        table_file = File.join(Base.tables_directory, "#{name}.groonga")
+        table_name = Base.groonga_table_name(name)
+        options = {:path => table_file}.merge(options)
+        options = default_table_options(options).merge(options)
+        options = options.merge(:context => Base.context)
+        Groonga::Schema.create_table(table_name, options) do |table|
+          block.call(TableDefinitionWrapper.new(table))
+        end
       end
 
-      def drop_table(name, options={})
-        table = Base.context[Base.groonga_table_name(name)]
-        table_id = table.id
-        table.remove
-        index_management_table.open_cursor do |cursor|
-          while cursor.next
-            cursor.delete if cursor.table_id == table_id
-          end
-        end
+      def remove_table(name, options={})
+        options = options.merge(:context => Base.context)
+        Groonga::Schema.remove_table(name, options)
       end
+      alias_method :drop_table, :remove_table
 
       def add_column(table_name, column_name, type, options={})
-        column = ColumnDefinition.new(table_name, column_name)
-        if type.to_s == "references"
-          table = options.delete(:to) || column_name.pluralize
-          column.type = Base.groonga_table_name(table)
-        else
-          column.type = type
+        options_with_context = options.merge(:context => Base.context)
+        Groonga::Schema.change_table(table_name, options_with_context) do |table|
+          table = TableDefinitionWrapper.new(table)
+          table.column(column_name, type, options)
         end
-        column.create(options)
       end
 
       def remove_column(table_name, *column_names)
-        column_names.each do |column_name|
-          ColumnDefinition.new(table_name, column_name).remove
+        options_with_context = options.merge(:context => Base.context)
+        Groonga::Schema.change_table(table_name, options_with_context) do |table|
+          column_names.each do |column_name|
+            table.remove_column(column_name)
+          end
         end
       end
 
-      def add_index(table_name, column_name, options={})
-        groonga_table_name = Base.groonga_table_name(table_name)
-        table = Base.context[groonga_table_name]
-        column_name = column_name.to_s
-        column = table.column(column_name)
-
-        base_dir = File.join(Base.metadata_directory,
-                             index_table_name,
-                             table_name)
-        FileUtils.mkdir_p(base_dir)
-
-        name = "#{table_name}/#{column_name}"
-        path = File.join(base_dir, "#{column_name}.groonga")
-        index_column = index_table.define_index_column(name, table,
-                                                       :path => path,
-                                                       :compress => "zlib",
-                                                       # :with_section => true,
-                                                       # :with_weight => true,
-                                                       :with_position => true)
-        index_column.source = column
-
-        record = index_management_table.add
-        record["table"] = groonga_table_name
-        record["column"] = column_name
-        record["index"] = name
-      end
-
-      def index_management_table
-        Base.context[groonga_index_management_table_name]
-      end
-
-      def index_table
-        Base.context[groonga_index_table_name]
-      end
-
-      def indexes(table_or_table_name)
-        if table_or_table_name.is_a?(String)
-          table_name = table_or_table_name
-          table = Base.context[Base.groonga_table_name(table_name)]
-        else
-          table = table_or_table_name
-          table_name = table.name.gsub(/(?:\A<table:|>\z)/, '')
-        end
-        indexes = []
-        index_management_table.records.each do |record|
-          next if record["table"] != table.name
-          indexes << IndexDefinition.new(table_name, record["index"],
-                                         false, record["column"])
+      def add_index_column(table_name, target_table_name, target_column_name,
+                           options={})
+        options_for_table = options.reject {|key, value| key == :name}
+        options_for_table = options_for_table.merge(:context => Base.context)
+        Groonga::Schema.change_table(table_name, options_for_table) do |table|
+          table = TableDefinitionWrapper.new(table)
+          table.index(target_table_name, target_column_name, options)
         end
-        indexes
       end
 
       private
-      def index_management_table_name
-        Base.table_name_prefix + 'indexes' + Base.table_name_suffix
-      end
-
-      def groonga_index_management_table_name
-        Base.groonga_metadata_table_name(index_management_table_name)
-      end
-
-      def index_table_name
-        Base.table_name_prefix + 'index' + Base.table_name_suffix
-      end
-
-      def groonga_index_table_name
-        Base.groonga_metadata_table_name(index_table_name)
-      end
-
-      def initialize_index_management_table
-        table_name = index_management_table_name
-        groonga_table_name = groonga_index_management_table_name
-        if Base.context[groonga_table_name].nil?
-          table_file = File.join(Base.metadata_directory,
-                                 "#{table_name}.groonga")
-          table = Groonga::Array.create(:name => groonga_table_name,
-                                        :path => table_file)
-
-          base_dir = File.join(Base.metadata_directory, table_name)
-          FileUtils.mkdir_p(base_dir)
-
-          column_file = File.join(base_dir, "table.groonga")
-          table.define_column("table", "<shorttext>", :path => column_file)
-
-          column_file = File.join(base_dir, "column.groonga")
-          table.define_column("column", "<shorttext>", :path => column_file)
-
-          column_file = File.join(base_dir, "index.groonga")
-          table.define_column("index", "<shorttext>", :path => column_file)
-        end
-      end
-
-      def initialize_index_table
-        table_name = index_table_name
-        groonga_table_name = groonga_index_table_name
-        if Base.context[groonga_table_name].nil?
-          table_file = File.join(Base.metadata_directory,
-                                 "#{table_name}.groonga")
-          table = Groonga::PatriciaTrie.create(:name => groonga_table_name,
-                                               :key_type => "<shorttext>",
-                                               # :key_with_sis => true,
-                                               # :key_normalize => true,
-                                               :path => table_file)
-          table.default_tokenizer = "<token:bigram>"
-
-          base_dir = File.join(Base.metadata_directory, table_name)
-          FileUtils.mkdir_p(base_dir)
-        end
-      end
-
       def initialize_migrations_table
         table_name = Migrator.schema_migrations_table_name
         groonga_table_name = Migrator.groonga_schema_migrations_table_name
@@ -211,104 +110,108 @@ module ActiveGroonga
                                  "#{table_name}.groonga")
           Groonga::Hash.create(:name => groonga_table_name,
                                :path => table_file,
-                               :key_type => "<shorttext>")
+                               :key_type => "ShortText")
         end
       end
+
+      def default_table_options(options)
+        default_options = {:sub_records => true}
+        case options[:type]
+        when :hash, :patricia_trie
+          default_options[:default_tokenizer] = "TokenBigram"
+        end
+        default_options
+      end
     end
 
-    class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
-      undef_method :primary_key, :to_sql, :native
+    class TableDefinitionWrapper
+      def initialize(definition)
+        @definition = definition
+      end
+
+      def column(name, type, options={})
+        column_file = File.join(Base.columns_directory(@definition.name),
+                                "#{name}.groonga")
+        options = {:path => column_file}.merge(options)
+        @definition.column(name, type, options)
+      end
+
+      def remove_column(name, options={})
+        @definition.remove_column(name, options)
+      end
+      alias_method :remove_index, :remove_column
+
+      def index(target_table_name, target_column_name, options={})
+        column_name = options.delete(:name)
+        column_name ||= [target_table_name, target_column_name].join("_")
+        column_dir = Base.index_columns_directory(@definition.name,
+                                                  target_table_name.to_s)
+        column_file = File.join(column_dir, "#{column_name}.groonga")
+        options = {
+          :with_position => true,
+          :path => column_file,
+          :name => column_name,
+        }.merge(options)
+        target_table = @definition.context[target_table_name]
+        target_column = target_table.column(target_column_name)
+        @definition.index(target_column, options)
+      end
+
+      def timestamps(*args)
+        options = args.extract_options!
+        column(:created_at, :datetime, options)
+        column(:updated_at, :datetime, options)
+      end
 
-      def initialize(name)
-        super(nil)
-        @name = name
-        @indexes = []
+      def string(*args)
+        columns("ShortText", *args)
       end
 
-      def create
-        table_file = File.join(Base.tables_directory, "#{@name}.groonga")
-        Groonga::Array.create(:name => Base.groonga_table_name(@name),
-                              :path => table_file)
-        @columns.each(&:create)
-        @indexes.each do |column_name, options|
-          Schema.add_index(@name.to_s, column_name, options)
-        end
+      def text(*args)
+        columns("Text", *args)
       end
 
-      def column(name, type, options={})
-        column = self[name] || ColumnDefinition.new(@name, name)
-        column.type = type
-        @columns << column unless @columns.include?(column)
-        self
+      def integer(*args)
+        columns("Int32", *args)
       end
 
-      def index(column_name, options={})
-        @indexes << [column_name.to_s, options]
+      def float(*args)
+        columns("Float", *args)
       end
 
-      def references(*args)
-        options = args.extract_options!
-        args.each do |col|
-          groonga_table_name = Base.groonga_table_name(col.to_s.pluralize)
-          table = Base.context[groonga_table_name]
-          column(col, table, options)
-        end
+      def decimal(*args)
+        columns("Int64", *args)
       end
-      alias :belongs_to :references
-    end
 
-    class ColumnDefinition
-      attr_accessor :name, :type
+      def time(*args)
+        columns("Time", *args)
+      end
+      alias_method :datetime, :time
+      alias_method :timestamp, :time
 
-      def initialize(table_name, name)
-        @table_name = table_name
-        @name = name
-        @name = @name.to_s if @name.is_a?(Symbol)
-        @type = nil
+      def binary(*args)
+        columns("LongText", *args)
       end
 
-      def create(options={})
-        column_file = File.join(Base.columns_directory(@table_name),
-                                "#{@name}.groonga")
-        options = options.merge(:path => column_file)
-        table = Base.context[Base.groonga_table_name(@table_name)]
-        table.define_column(@name,
-                            normalize_type(@type),
-                            options)
+      def boolean(*args)
+        columns("Bool", *args)
       end
 
-      def remove
-        Base.context[@name].remove
+      def reference(name, table=nil, options={})
+        table = Base.groonga_table_name(table || name.to_s.pluralize)
+        column(name, table, options)
       end
+      alias_method :references, :reference
+      alias_method :belongs_to, :references
 
-      def normalize_type(type)
-        return type if type.is_a?(Groonga::Object)
-        case type.to_s
-        when "string"
-          "<shorttext>"
-        when "text"
-          "<text>"
-        when "integer"
-          "<int>"
-        when "float"
-          "<float>"
-        when "decimal"
-          "<int64>"
-        when "datetime", "timestamp", "time", "date"
-          "<time>"
-        when "binary"
-          "<longtext>"
-        when "boolean"
-          "<int>"
-        else
-          type
+      private
+      def columns(type, *args)
+        options = args.extract_options!
+        column_names = args
+        column_names.each do |name|
+          column(name, type, options)
         end
       end
     end
-
-    class IndexDefinition < ActiveRecord::ConnectionAdapters::IndexDefinition
-      alias_method :column, :columns
-      alias_method :column=, :columns=
-    end
   end
 end

data/lib/active_groonga/schema_dumper.rb

@@ -28,9 +28,11 @@ module ActiveGroonga
 
     def dump(stream)
       @references = []
+      @indexes = []
       header(stream)
       dump_tables(stream)
       dump_references(stream)
+      dump_indexes(stream)
       trailer(stream)
       stream
     end
@@ -52,13 +54,34 @@ module ActiveGroonga
     def dump_table(name, stream)
       begin
         table_schema = StringIO.new
-        table_schema.puts "  create_table #{name.inspect}, :force => true do |t|"
+
+        table_name = Base.groonga_table_name(name)
+        table = Base.context[table_name]
+        options = [":force => true"]
+        case table
+        when Groonga::Hash
+          options << ":type => :hash"
+        when Groonga::PatriciaTrie
+          options << ":type => :patricia_trie"
+        end
+        if table.domain
+          options << ":key_type => #{table.domain.name.inspect}"
+        end
+        if table.respond_to?(:default_tokenizer) and table.default_tokenizer
+          options << ":default_tokenizer => #{table.default_tokenizer.name.inspect}"
+        end
+
+        table_schema.puts "  create_table #{name.inspect}, #{options.join(', ')} do |t|"
         column_specs = []
         columns(name).each do |column|
           if column.reference_type?
             @references << [name, column]
             next
           end
+          if column.index?
+            @indexes << [name, column]
+            next
+          end
 
           spec = {}
           spec[:type] = column.type.to_s
@@ -74,8 +97,6 @@ module ActiveGroonga
         table_schema.puts "  end"
         table_schema.puts
 
-        dump_indexes(name, table_schema)
-
         stream.print table_schema.string
       rescue => e
         stream.puts "# Could not dump table #{name.inspect} because of following #{e.class}"
@@ -89,42 +110,36 @@ module ActiveGroonga
       stream
     end
 
-    def dump_indexes(table, stream)
-      _indexes = indexes(table)
-      return if _indexes.empty?
-
-      add_index_statements = _indexes.collect do |index|
-        statement_parts = []
-        statement_parts << "add_index #{index.table.inspect}"
-        statement_parts << index.columns.inspect
-        statement_parts << ":name => #{index.name.inspect}"
-        '  ' + statement_parts.join(', ')
-      end
-
-      stream.puts add_index_statements.sort.join("\n")
-      stream.puts
-    end
-
     def dump_references(stream)
       @references.sort_by do |name, column|
         [name, column.name]
       end.each do |name, column|
         statement = "  add_column #{name.inspect}, "
-        statement << "#{column.name.inspect}, :references, "
-        statement << ":to => #{column.reference_object_name.inspect}"
+        statement << "#{column.name.inspect}, "
+        statement << "#{column.reference_object_name.inspect}"
         stream.puts(statement)
       end
     end
 
+    def dump_indexes(stream)
+      @indexes.sort_by do |name, column|
+        [name, column.name]
+      end.each do |name, column|
+        column.index_sources.each do |source|
+          statement = "  add_index_column #{name.inspect}, "
+          statement << "#{source.table.name.inspect}, "
+          statement << "#{source.local_name.inspect}, "
+          statement << ":name => #{column.name.inspect}"
+          stream.puts(statement)
+        end
+      end
+    end
+
     def columns(table_name)
       table_name = Base.groonga_table_name(table_name)
       Base.context[table_name].columns.collect {|column| Column.new(column)}
     end
 
-    def indexes(table_name)
-      Schema.indexes(table_name)
-    end
-
     class StreamWrapper
       def initialize(stream)
         @stream = stream