sbf-dm-migrations 1.3.0.beta

data/lib/dm-migrations/migration.rb

@@ -0,0 +1,323 @@
+require 'dm-migrations/exceptions/duplicate_migration'
+require 'dm-migrations/sql'
+
+require 'benchmark'
+
+module DataMapper
+  class Migration
+    include SQL
+
+    # The position or version the migration belongs to
+    attr_reader :position
+
+    # The name of the migration
+    attr_reader :name
+
+    # The repository the migration operates on
+    attr_reader :repository
+
+    #
+    # Creates a new migration.
+    #
+    # @param [Symbol, String, Integer] position
+    #   The position or version the migration belongs to.
+    #
+    # @param [Symbol] name
+    #   The name of the migration.
+    #
+    # @param [Hash] options
+    #   Additional options for the migration.
+    #
+    # @option options [Boolean] :verbose (true)
+    #   Enables or disables verbose output.
+    #
+    # @option options [Symbol] :repository (:default)
+    #   The DataMapper repository the migration will operate on.
+    #
+    def initialize(position, name, options = {}, &block)
+      @position    = position
+      @name        = name
+      @options     = options
+      @verbose     = options.fetch(:verbose, true)
+      @up_action   = nil
+      @down_action = nil
+
+      @repository = if options.key?(:database)
+                      warn 'Using the :database option with migrations is deprecated, use :repository instead'
+                      options[:database]
+                    else
+                      options.fetch(:repository, :default)
+                    end
+
+      instance_eval(&block)
+    end
+
+    #
+    # The repository the migration will operate on.
+    #
+    # @return [Symbol, nil]
+    #   The name of the DataMapper repository the migration will run against.
+    #
+    # @deprecated Use {#repository} instead.
+    #
+    # @since 1.0.1.
+    #
+    def database
+      warn 'Using the DataMapper::Migration#database method is deprecated, use #repository instead'
+      @repository
+    end
+
+    #
+    # The adapter the migration will use.
+    #
+    # @return [DataMapper::Adapter]
+    #   The adapter the migration will operate on.
+    #
+    # @since 1.0.1
+    #
+    def adapter
+      setup! unless setup?
+
+      @adapter
+    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
+        if @up_action
+          say_with_time "== Performing Up Migration ##{position}: #{name}", 0 do
+            result = @up_action&.call
+          end
+        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
+        if @down_action
+          say_with_time "== Performing Down Migration ##{position}: #{name}", 0 do
+            result = @down_action&.call
+          end
+        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
+
+    #
+    # Execute raw SQL and return a result set.
+    #
+    # @param [String] sql
+    #   The raw SQL statement.
+    #
+    # @param [Array] bind_values
+    #   Additional values to bind to the statement.
+    #
+    # @return [Array<Struct>]
+    #   The result set.
+    #
+    # @since 1.3.0
+    #
+    def select(sql, *bind_values)
+      say_with_time(sql) do
+        adapter.select(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)
+      opts = if columns_and_options.last.is_a?(Hash)
+               columns_and_options.pop
+             else
+               {}
+             end
+      columns = columns_and_options.flatten
+
+      opts[:name] ||= "#{opts[:unique] ? 'unique_' : ''}index_#{table_name}_#{columns.join('_')}"
+
+      execute DataMapper::Ext::String.compress_lines(<<-SQL)
+        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 position == other.position
+        name.to_s <=> other.name.to_s
+      else
+        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
+      execute("CREATE TABLE #{migration_info_table} (#{migration_name_column} VARCHAR(255) UNIQUE)") unless migration_info_table_exists?
+      @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
+
+    #
+    # Determines whether the migration has been setup.
+    #
+    # @return [Boolean]
+    #   Specifies whether the migration has been setup.
+    #
+    # @since 1.0.1
+    #
+    protected def setup?
+      !@adapter.nil?
+    end
+
+    #
+    # Sets up the migration.
+    #
+    # @since 1.0.1
+    #
+    protected def setup!
+      @adapter = DataMapper.repository(@repository)&.adapter
+
+      case @adapter.class.name
+      when /Sqlite/    then @adapter.extend(SQL::Sqlite)
+      when /Mysql/     then @adapter.extend(SQL::Mysql)
+      when /Postgres/  then @adapter.extend(SQL::Postgres)
+      when /Sqlserver/ then @adapter.extend(SQL::Sqlserver)
+      when /Oracle/    then @adapter.extend(SQL::Oracle)
+      else
+        raise(RuntimeError, "Unsupported Migration Adapter #{@adapter.class}", caller)
+      end
+    end
+  end
+end

data/lib/dm-migrations/migration_runner.rb

@@ -0,0 +1,76 @@
+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
+    # necessary 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.
+    #
+    # Additionally, 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 against. 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(&: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|
+        migration.perform_up if level.nil? || migration.position <= level.to_i
+      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 position greater than the level.
+    def migrate_down!(level = nil)
+      migrations.sort.reverse.each do |migration|
+        migration.perform_down if level.nil? || migration.position > level.to_i
+      end
+    end
+
+    def migrations
+      @@migrations ||= []
+    end
+  end
+end
+
+include DataMapper::MigrationRunner

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,84 @@
+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(opts)
+      opt_engine    = opts[:storage_engine] || storage_engine
+      opt_char_set  = opts[:character_set] || character_set
+      opt_collation = opts[:collation] || collation
+
+      " ENGINE = #{opt_engine} CHARACTER SET #{opt_char_set} COLLATE #{opt_collation}"
+    end
+
+    def property_schema_statement(connection, schema)
+      if supports_serial? && schema[:serial]
+        "#{schema[:quote_column_name]} SERIAL PRIMARY KEY"
+      else
+        super
+      end
+    end
+
+    def change_column_type_statement(name, column)
+      "ALTER TABLE #{quote_name(name)} MODIFY COLUMN #{column.to_sql}"
+    end
+
+    def rename_column_type_statement(table_name, old_col, new_col)
+      table       = quote_name(table_name)
+      column_info = select("SHOW COLUMNS FROM #{table} LIKE ?", old_col).first
+
+      column_options = {
+        name: column_info.field,
+        primitive: column_info.type,
+        serial: column_info.extra == 'auto_increment',
+        allow_nil: column_info.null == 'YES',
+        default: column_info.default
+      }
+
+      column = with_connection do |connection|
+        property_schema_statement(connection, column_options)
+      end
+
+      column_definition = column.split(' ', 2).last
+
+      "ALTER TABLE #{table} CHANGE #{quote_name(old_col)} #{quote_name(new_col)} #{column_definition}"
+    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 = col_struct.name
+        @type = col_struct.type
+        @default_value = col_struct.dflt_value
+        @primary_key = col_struct.pk
+
+        @not_null = col_struct.notnull == 0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+require 'dm-migrations/sql/table'
+
+module SQL
+  module Oracle
+    def change_column_type_statement(name, column)
+      "ALTER TABLE #{quote_name(name)} MODIFY ( #{column.to_sql} )"
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+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
+        statement << " DEFAULT nextval('#{schema[:sequence_name]}') NOT NULL" if schema.key?(:sequence_name)
+        statement
+      end
+      statement
+    end
+
+    def table_options(_opts)
+      ''
+    end
+
+    def change_column_type_statement(name, column)
+      "ALTER TABLE #{quote_name(name)} ALTER COLUMN #{column.to_sql}"
+    end
+
+    def rename_column_type_statement(table_name, old_col, new_col)
+      "ALTER TABLE #{quote_name(table_name)} RENAME COLUMN #{quote_name(old_col)} TO #{quote_name(new_col)}"
+    end
+
+    class Table < SQL::Table
+      def initialize(adapter, table_name)
+        super()
+        @adapter = adapter
+        @name = 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|
+              next unless 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
+
+    class Column < SQL::Column
+      def initialize(col_struct)
+        super()
+        @name = col_struct.column_name
+        @type = col_struct.data_type
+        @default_value = col_struct.column_default
+
+        @not_null = col_struct.is_nullable != 'YES'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'dm-migrations/sql/table'
+
+require 'fileutils'
+
+module SQL
+  module Sqlite
+    def supports_schema_transactions?
+      true
+    end
+
+    def table(table_name)
+      SQL::Sqlite::Table.new(self, table_name)
+    end
+
+    def recreate_database
+      DataMapper.logger.info "Dropping #{@uri.path}"
+      FileUtils.rm_f(@uri.path)
+      # do nothing, sqlite will automatically create the database file
+    end
+
+    def table_options(_opts)
+      ''
+    end
+
+    def supports_serial?
+      true
+    end
+
+    def change_column_type_statement(*)
+      raise NotImplementedError
+    end
+
+    def rename_column_type_statement(*)
+      raise NotImplementedError
+    end
+
+    class Table < SQL::Table
+      def initialize(adapter, table_name)
+        super()
+        @columns = []
+        adapter.table_info(table_name).each do |col_struct|
+          @columns << SQL::Sqlite::Column.new(col_struct)
+        end
+      end
+    end
+
+    class Column < SQL::Column
+      def initialize(col_struct)
+        super()
+        @name = col_struct.name
+        @type = col_struct.type
+        @default_value = col_struct.dflt_value
+        @primary_key = col_struct.pk
+
+        @not_null = col_struct.notnull == 0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+require 'dm-migrations/sql/table'
+
+module SQL
+  module Sqlserver
+    def change_column_type_statement(name, column)
+      "ALTER TABLE #{quote_name(name)} ALTER COLUMN #{column.to_sql}"
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'dm-migrations/sql/column'
+
+module SQL
+  class Table
+    attr_accessor :name, :columns
+
+    def to_s
+      name
+    end
+
+    def column(column_name)
+      @columns.select { |c| c.name == column_name.to_s }.first
+    end
+  end
+end