activegroonga 0.0.1

data/lib/active_groonga/schema.rb

@@ -0,0 +1,314 @@
+# 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
+  module Schema
+    class << self
+      def define(info={}, &block)
+        initialize_schema_management_tables
+        instance_eval(&block)
+
+        unless info[:version].blank?
+          assume_migrated_upto_version(info[:version])
+        end
+      end
+
+      def assume_migrated_upto_version(version)
+        version = version.to_i
+        table_name = Migrator.groonga_schema_migrations_table_name
+
+        migrations_table = Base.context[table_name]
+        migrated = migrations_table.records.collect do |record|
+          record["version"].to_i
+        end
+        versions = Dir['db/migrate/[0-9]*_*.rb'].map do |filename|
+          filename.split('/').last.split('_').first.to_i
+        end
+
+        unless migrated.include?(version)
+          migrations_table.add(version.to_s)
+        end
+
+        inserted = Set.new
+        (versions - migrated).each do |v|
+          if inserted.include?(v)
+            raise "Duplicate migration #{v}. Please renumber your migrations to resolve the conflict."
+          elsif v < version
+            migration = migrations_table.add
+            migration["version"] = v.to_s
+            inserted << v
+          end
+        end
+      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
+      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
+      end
+
+      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
+        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
+        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_column(name, table,
+                                                 :path => path,
+                                                 :type => "index",
+                                                 :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"])
+        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)
+
+          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
+        if Base.context[groonga_table_name].nil?
+          table_file = File.join(Base.metadata_directory,
+                                 "#{table_name}.groonga")
+          Groonga::Hash.create(:name => groonga_table_name,
+                               :path => table_file,
+                               :key_type => "<shorttext>")
+        end
+      end
+    end
+
+    class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+      undef_method :primary_key, :to_sql, :native
+
+      def initialize(name)
+        super(nil)
+        @name = name
+        @indexes = []
+      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
+      end
+
+      def column(name, type, options={})
+        column = self[name] || ColumnDefinition.new(@name, name)
+        column.type = type
+        @columns << column unless @columns.include?(column)
+        self
+      end
+
+      def index(column_name, options={})
+        @indexes << [column_name.to_s, options]
+      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
+      end
+      alias :belongs_to :references
+    end
+
+    class ColumnDefinition
+      attr_accessor :name, :type
+
+      def initialize(table_name, name)
+        @table_name = table_name
+        @name = name
+        @name = @name.to_s if @name.is_a?(Symbol)
+        @type = nil
+      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)
+      end
+
+      def remove
+        Base.context[@name].remove
+      end
+
+      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
+        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

@@ -0,0 +1,147 @@
+# 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 SchemaDumper < ActiveRecord::SchemaDumper
+    class << self
+      def dump(stream=STDOUT)
+        new.dump(StreamWrapper.new(stream))
+        stream
+      end
+    end
+
+    def initialize
+      @version = Migrator.current_version
+    end
+
+    def dump(stream)
+      @references = []
+      header(stream)
+      dump_tables(stream)
+      dump_references(stream)
+      trailer(stream)
+      stream
+    end
+
+    private
+    def dump_tables(stream)
+      tables.sort.each do |name|
+        next if ignore_tables.any? {|ignored| ignored === name}
+        dump_table(name, stream)
+      end
+    end
+
+    def tables
+      Dir[File.join(Base.tables_directory, "*.groonga")].collect do |path|
+        File.basename(path, ".groonga")
+      end
+    end
+
+    def dump_table(name, stream)
+      begin
+        table_schema = StringIO.new
+        table_schema.puts "  create_table #{name.inspect}, :force => true do |t|"
+        column_specs = []
+        columns(name).each do |column|
+          if column.reference_type?
+            @references << [name, column]
+            next
+          end
+
+          spec = {}
+          spec[:type] = column.type.to_s
+          spec[:name] = column.name.inspect
+          column_specs << spec
+        end
+
+        column_specs.each do |spec|
+          table_schema.print("    t.#{spec[:type]} #{spec[:name]}")
+          table_schema.puts
+        end
+
+        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}"
+        stream.puts "#   #{e.message}"
+        e.backtrace.each do |trace|
+          stream.puts "#   #{trace}"
+        end
+        stream.puts
+      end
+
+      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}"
+        stream.puts(statement)
+      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
+      end
+
+      def method_missing(name, *args, &block)
+        @stream.send(name, *args.collect {|arg| normalize_string(arg)}, &block)
+      end
+
+      private
+      def normalize_string(string)
+        if string.is_a?(String)
+          string.gsub(/Active ?Record/, "ActiveGroonga")
+        else
+          string
+        end
+      end
+    end
+  end
+end