dm-hibernate-migrations 1.0.0

data/lib/dm-migrations/migration.rb

@@ -0,0 +1,217 @@
+require 'benchmark'
+
+require 'dm-migrations/sql'
+
+module DataMapper
+  class DuplicateMigrationNameError < StandardError
+    def initialize(migration)
+      super("Duplicate Migration Name: '#{migration.name}', version: #{migration.position}")
+    end
+  end
+
+  class Migration
+    include SQL
+
+    attr_accessor :position, :name, :database, :adapter
+
+    def initialize( position, name, opts = {}, &block )
+      @position, @name = position, name
+      @options = opts
+
+      @database = DataMapper.repository(@options[:database] || :default)
+      @adapter = @database.adapter
+
+      if @adapter.respond_to?(:dialect)
+        begin
+          @adapter.extend(SQL.const_get("#{@adapter.dialect}"))
+        rescue NameError
+          raise "Unsupported Migration Adapter #{@adapter.class} with SQL dialect #{@adapter.dialect}"
+        end
+      else
+        raise "Unsupported Migration Adapter #{@adapter.class}"
+      end
+
+      @verbose = @options.has_key?(:verbose) ? @options[:verbose] : true
+
+      @up_action   = lambda {}
+      @down_action = lambda {}
+
+      instance_eval &block
+    end
+
+    # define the actions that should be performed on an up migration
+    def up(&block)
+      @up_action = block
+    end
+
+    # define the actions that should be performed on a down migration
+    def down(&block)
+      @down_action = block
+    end
+
+    # perform the migration by running the code in the #up block
+    def perform_up
+      result = nil
+      if needs_up?
+        # TODO: fix this so it only does transactions for databases that support create/drop
+        # database.transaction.commit do
+          say_with_time "== Performing Up Migration ##{position}: #{name}", 0 do
+            result = @up_action.call
+          end
+          update_migration_info(:up)
+        # end
+      end
+      result
+    end
+
+    # un-do the migration by running the code in the #down block
+    def perform_down
+      result = nil
+      if needs_down?
+        # TODO: fix this so it only does transactions for databases that support create/drop
+        # database.transaction.commit do
+          say_with_time "== Performing Down Migration ##{position}: #{name}", 0 do
+            result = @down_action.call
+          end
+          update_migration_info(:down)
+        # end
+      end
+      result
+    end
+
+    # execute raw SQL
+    def execute(sql, *bind_values)
+      say_with_time(sql) do
+        @adapter.execute(sql, *bind_values)
+      end
+    end
+
+    def create_table(table_name, opts = {}, &block)
+      execute TableCreator.new(@adapter, table_name, opts, &block).to_sql
+    end
+
+    def drop_table(table_name, opts = {})
+      execute "DROP TABLE #{@adapter.send(:quote_name, table_name.to_s)}"
+    end
+
+    def modify_table(table_name, opts = {}, &block)
+      TableModifier.new(@adapter, table_name, opts, &block).statements.each do |sql|
+        execute(sql)
+      end
+    end
+
+    def create_index(table_name, *columns_and_options)
+      if columns_and_options.last.is_a?(Hash)
+        opts = columns_and_options.pop
+      else
+        opts = {}
+      end
+      columns = columns_and_options.flatten
+
+      opts[:name] ||= "#{opts[:unique] ? 'unique_' : ''}index_#{table_name}_#{columns.join('_')}"
+
+      execute <<-SQL.compress_lines
+        CREATE #{opts[:unique] ? 'UNIQUE ' : '' }INDEX #{quote_column_name(opts[:name])} ON
+        #{quote_table_name(table_name)} (#{columns.map { |c| quote_column_name(c) }.join(', ') })
+      SQL
+    end
+
+    # Orders migrations by position, so we know what order to run them in.
+    # First order by position, then by name, so at least the order is predictable.
+    def <=> other
+      if self.position == other.position
+        self.name.to_s <=> other.name.to_s
+      else
+        self.position <=> other.position
+      end
+    end
+
+    # Output some text. Optional indent level
+    def say(message, indent = 4)
+      write "#{" " * indent} #{message}"
+    end
+
+    # Time how long the block takes to run, and output it with the message.
+    def say_with_time(message, indent = 2)
+      say(message, indent)
+      result = nil
+      time = Benchmark.measure { result = yield }
+      say("-> %.4fs" % time.real, indent)
+      result
+    end
+
+    # output the given text, but only if verbose mode is on
+    def write(text="")
+      puts text if @verbose
+    end
+
+    # Inserts or removes a row into the `migration_info` table, so we can mark this migration as run, or un-done
+    def update_migration_info(direction)
+      save, @verbose = @verbose, false
+
+      create_migration_info_table_if_needed
+
+      if direction.to_sym == :up
+        execute("INSERT INTO #{migration_info_table} (#{migration_name_column}) VALUES (#{quoted_name})")
+      elsif direction.to_sym == :down
+        execute("DELETE FROM #{migration_info_table} WHERE #{migration_name_column} = #{quoted_name}")
+      end
+      @verbose = save
+    end
+
+    def create_migration_info_table_if_needed
+      save, @verbose = @verbose, false
+      unless migration_info_table_exists?
+        execute("CREATE TABLE #{migration_info_table} (#{migration_name_column} VARCHAR(255) UNIQUE)")
+      end
+      @verbose = save
+    end
+
+    # Quote the name of the migration for use in SQL
+    def quoted_name
+      "'#{name}'"
+    end
+
+    def migration_info_table_exists?
+      adapter.storage_exists?('migration_info')
+    end
+
+    # Fetch the record for this migration out of the migration_info table
+    def migration_record
+      return [] unless migration_info_table_exists?
+      @adapter.select("SELECT #{migration_name_column} FROM #{migration_info_table} WHERE #{migration_name_column} = #{quoted_name}")
+    end
+
+    # True if the migration needs to be run
+    def needs_up?
+      return true unless migration_info_table_exists?
+      migration_record.empty?
+    end
+
+    # True if the migration has already been run
+    def needs_down?
+      return false unless migration_info_table_exists?
+      ! migration_record.empty?
+    end
+
+    # Quoted table name, for the adapter
+    def migration_info_table
+      @migration_info_table ||= quote_table_name('migration_info')
+    end
+
+    # Quoted `migration_name` column, for the adapter
+    def migration_name_column
+      @migration_name_column ||= quote_column_name('migration_name')
+    end
+
+    def quote_table_name(table_name)
+      # TODO: Fix this for 1.9 - can't use this hack to access a private method
+      @adapter.send(:quote_name, table_name.to_s)
+    end
+
+    def quote_column_name(column_name)
+      # TODO: Fix this for 1.9 - can't use this hack to access a private method
+      @adapter.send(:quote_name, column_name.to_s)
+    end
+  end
+end

data/lib/dm-migrations/migration_runner.rb

@@ -0,0 +1,85 @@
+require 'dm-migrations/migration'
+
+module DataMapper
+  module MigrationRunner
+    # Creates a new migration, and adds it to the list of migrations to be run.
+    # Migrations can be defined in any order, they will be sorted and run in the
+    # correct order.
+    #
+    # The order that migrations are run in is set by the first argument. It is not
+    # neccessary that this be unique; migrations with the same version number are
+    # expected to be able to be run in any order.
+    #
+    # The second argument is the name of the migration. This name is used internally
+    # to track if the migration has been run. It is required that this name be unique
+    # across all migrations.
+    #
+    # Addtionally, it accepts a number of options:
+    # * <tt>:database</tt> If you defined several DataMapper::database instances use this
+    #   to choose which one to run the migration gagainst. Defaults to <tt>:default</tt>.
+    #   Migrations are tracked individually per database.
+    # * <tt>:verbose</tt> true/false, defaults to true. Determines if the migration should
+    #   output its status messages when it runs.
+    #
+    # Example of a simple migration:
+    #
+    #   migration( 1, :create_people_table ) do
+    #     up do
+    #       create_table :people do
+    #         column :id,   Integer, :serial => true
+    #         column :name, String, :size => 50
+    #         column :age,  Integer
+    #       end
+    #     end
+    #     down do
+    #       drop_table :people
+    #     end
+    #   end
+    #
+    # Its recommended that you stick with raw SQL for migrations that manipulate data. If
+    # you write a migration using a model, then later change the model, there's a
+    # possibility the migration will no longer work. Using SQL will always work.
+    def migration( number, name, opts = {}, &block )
+      raise "Migration name conflict: '#{name}'" if migrations.map { |m| m.name }.include?(name.to_s)
+
+      migrations << DataMapper::Migration.new( number, name.to_s, opts, &block )
+    end
+
+    # Run all migrations that need to be run. In most cases, this would be called by a
+    # rake task as part of a larger project, but this provides the ability to run them
+    # in a script or test.
+    #
+    # has an optional argument 'level' which if supplied, only performs the migrations
+    # with a position less than or equal to the level.
+    def migrate_up!(level = nil)
+      migrations.sort.each do |migration|
+        if level.nil?
+          migration.perform_up()
+        else
+          migration.perform_up() if migration.position <= level.to_i
+        end
+      end
+    end
+
+    # Run all the down steps for the migrations that have already been run.
+    #
+    # has an optional argument 'level' which, if supplied, only performs the
+    # down migrations with a postion greater than the level.
+    def migrate_down!(level = nil)
+      migrations.sort.reverse.each do |migration|
+        if level.nil?
+          migration.perform_down()
+        else
+          migration.perform_down() if migration.position > level.to_i
+        end
+      end
+    end
+
+    def migrations
+      @migrations ||= []
+    end
+
+  end
+end
+
+include DataMapper::MigrationRunner

data/lib/dm-migrations/sql.rb

@@ -0,0 +1,5 @@
+require 'dm-migrations/sql/table_creator'
+require 'dm-migrations/sql/table_modifier'
+require 'dm-migrations/sql/sqlite'
+require 'dm-migrations/sql/mysql'
+require 'dm-migrations/sql/postgres'

data/lib/dm-migrations/sql/column.rb

@@ -0,0 +1,5 @@
+module SQL
+  class Column
+    attr_accessor :name, :type, :not_null, :default_value, :primary_key, :unique
+  end
+end

data/lib/dm-migrations/sql/mysql.rb

@@ -0,0 +1,53 @@
+require 'dm-migrations/sql/table'
+
+module SQL
+  module Mysql
+
+    def supports_schema_transactions?
+      false
+    end
+
+    def table(table_name)
+      SQL::Mysql::Table.new(self, table_name)
+    end
+
+    def recreate_database
+      execute "DROP DATABASE #{schema_name}"
+      execute "CREATE DATABASE #{schema_name}"
+      execute "USE #{schema_name}"
+    end
+
+    def supports_serial?
+      true
+    end
+
+    def table_options
+      " ENGINE = InnoDB CHARACTER SET #{character_set} COLLATE #{collation}"
+    end
+
+    def property_schema_statement(connection, schema)
+      if supports_serial? && schema[:serial]
+        statement = "#{schema[:quote_column_name]} SERIAL PRIMARY KEY"
+      else
+        super
+      end
+    end
+
+    class Table
+      def initialize(adapter, table_name)
+        @columns = []
+        adapter.table_info(table_name).each do |col_struct|
+          @columns << SQL::Mysql::Column.new(col_struct)
+        end
+      end
+    end
+
+    class Column
+      def initialize(col_struct)
+        @name, @type, @default_value, @primary_key = col_struct.name, col_struct.type, col_struct.dflt_value, col_struct.pk
+
+        @not_null = col_struct.notnull == 0
+      end
+    end
+  end
+end

data/lib/dm-migrations/sql/postgres.rb

@@ -0,0 +1,78 @@
+module SQL
+  module Postgres
+
+    def supports_schema_transactions?
+      true
+    end
+
+    def table(table_name)
+      SQL::Postgres::Table.new(self, table_name)
+    end
+
+    def recreate_database
+      execute 'DROP SCHEMA IF EXISTS test CASCADE'
+      execute 'CREATE SCHEMA test'
+      execute 'SET search_path TO test'
+    end
+
+    def supports_serial?
+      true
+    end
+
+    def property_schema_statement(connection, schema)
+      if supports_serial? && schema[:serial]
+        statement = "#{schema[:quote_column_name]} SERIAL PRIMARY KEY"
+      else
+        statement = super
+        if schema.has_key?(:sequence_name)
+          statement << " DEFAULT nextval('#{schema[:sequence_name]}') NOT NULL"
+        end
+        statement
+      end
+      statement
+    end
+
+    def table_options
+      ''
+    end
+
+    class Table < SQL::Table
+      def initialize(adapter, table_name)
+        @adapter, @name = adapter, table_name
+        @columns = []
+        adapter.query_table(table_name).each do |col_struct|
+          @columns << SQL::Postgres::Column.new(col_struct)
+        end
+
+        query_column_constraints
+      end
+
+      def query_column_constraints
+        @adapter.select(
+          "SELECT * FROM information_schema.table_constraints WHERE table_name='#{@name}' AND table_schema=current_schema()"
+        ).each do |table_constraint|
+          @adapter.select(
+            "SELECT * FROM information_schema.constraint_column_usage WHERE constraint_name='#{table_constraint.constraint_name}' AND table_schema=current_schema()"
+          ).each do |constrained_column|
+            @columns.each do |column|
+              if column.name == constrained_column.column_name
+                case table_constraint.constraint_type
+                when "UNIQUE"       then column.unique = true
+                when "PRIMARY KEY"  then column.primary_key = true
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    class Column < SQL::Column
+      def initialize(col_struct)
+        @name, @type, @default_value = col_struct.column_name, col_struct.data_type, col_struct.column_default
+
+        @not_null = col_struct.is_nullable != "YES"
+      end
+    end
+  end
+end