sbf-dm-migrations 1.3.0.beta

data/db/migrations/2_add_dob_to_people.rb

@@ -0,0 +1,13 @@
+migration 2, :add_dob_to_people do
+  up do
+    modify_table :people do
+      add_column :dob, DateTime, allow_nil: true
+    end
+  end
+
+  down do
+    modify_table :people do
+      drop_column :dob
+    end
+  end
+end

data/db/migrations/config.rb

@@ -0,0 +1,4 @@
+DataMapper::Logger.new($stdout, :debug)
+DataMapper.logger.debug('Starting Migration')
+
+DataMapper.setup(:default, 'postgres://postgres@localhost/dm_core_test')

data/dm-migrations.gemspec

@@ -0,0 +1,20 @@
+require File.expand_path('../lib/dm-migrations/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Dan Kubb']
+  gem.email         = ['dan.kubb@gmail.com']
+  gem.summary       = 'DataMapper plugin for writing and spec-ing migrations'
+  gem.description   = 'DataMapper plugin for modifying and maintaining database structure, triggers, stored procedures, and data'
+  gem.homepage      = 'https://datamapper.org'
+  gem.license = 'Nonstandard'
+
+  gem.files = `git ls-files`.split("\n")
+  gem.extra_rdoc_files = %w(LICENSE README.rdoc)
+
+  gem.name          = 'sbf-dm-migrations'
+  gem.require_paths = ['lib']
+  gem.version       = DataMapper::Migrations::VERSION
+  gem.required_ruby_version = '>= 2.7.8'
+
+  gem.add_runtime_dependency('sbf-dm-core', '~> 1.3.0.beta')
+end

data/examples/Rakefile

@@ -0,0 +1,149 @@
+# Sample tasks using dm-migrations
+# Roughly following Rails conventions, and mostly based on Padrino's dm:* tasks
+#
+# Cf. https://github.com/padrino/padrino-framework/blob/master/padrino-gen/lib/padrino-gen/padrino-tasks/datamapper.rb
+#     https://github.com/firespring/dm-rails/blob/master/lib/dm-rails/railties/database.rake
+#
+
+require 'rake'
+
+# replace this with however your app configures DataMapper repositor(ies)
+task :environment do
+  require File.expand_path('boot', File.dirname(__FILE__))
+end
+
+namespace :db do
+
+  namespace :auto do
+
+    desc 'Perform auto-migration (reset your db data)'
+    task migrate: :environment do |t, _|
+      puts '=> Auto-migrating'
+      DataMapper.auto_migrate!
+      puts "<= #{t.name} done"
+    end
+
+    desc 'Perform non destructive auto-migration'
+    task upgrade: :environment do |t, _|
+      puts '=> Auto-upgrading'
+      DataMapper.auto_upgrade!
+      puts "<= #{t.name} done"
+    end
+
+  end
+
+  desc 'Run all pending migrations, or up to specified migration'
+  task :migrate, [:version] => :load_migrations do |t, args|
+    if (vers = args[:version] || ENV.fetch('VERSION', nil))
+      puts "=> Migrating up to version #{vers}"
+      migrate_up!(vers)
+    else
+      puts '=> Migrating up'
+      migrate_up!
+    end
+    puts "<= #{t.name} done"
+  end
+
+  desc 'Rollback down to specified migration, or rollback last STEP=x migrations (default 1)'
+  task :rollback, [:version] => :load_migrations do |t, args|
+    if (vers = args[:version] || ENV.fetch('VERSION', nil))
+      puts "=> Rolling back down to migration #{vers}"
+      migrate_down!(vers)
+    else
+      step = ENV['STEP'].to_i || 1
+      applied = migrations.delete_if(&:needs_up?).sort # NOTE: this is N queries as currently implemented
+      target = applied[-1 * step] || applied[0]
+      if target
+        puts "=> Rolling back #{step} step(s)"
+        migrate_down!(target.position - 1)
+      else
+        warn "No migrations to rollback: #{step} step(s)"
+      end
+    end
+    puts "<= #{t.name} done"
+  end
+
+  desc 'List migrations descending, showing which have been applied'
+  task migrations: :load_migrations do
+    puts(migrations.sort.reverse.map { |m| "#{m.position}  #{m.name}  #{m.needs_up? ? '' : 'APPLIED'}" })
+  end
+
+  task load_migrations: :environment do
+    require 'dm-migrations/migration_runner'
+    FileList['db/migrate/*.rb'].each do |migration|
+      load migration
+    end
+  end
+
+
+  desc 'Create the database'
+  task :create, [:repository] => :environment do |t, args|
+    repo = args[:repository] || ENV['REPOSITORY'] || :default
+    config = DataMapper.repository(repo)&.adapter&.options&.symbolize_keys
+    user = config[:user]
+    password = config[:password]
+    host = config[:host]
+    database       = config[:database]  || config[:path].sub('/', '')
+    charset        = config[:charset]   || ENV['CHARSET']   || 'utf8'
+    collation      = config[:collation] || ENV['COLLATION'] || 'utf8_unicode_ci'
+    puts "=> Creating database '#{database}'"
+
+    case config[:adapter]
+    when 'postgres'
+      system('createdb', '-E', charset, '-h', host, '-U', user, database)
+    when 'mysql'
+      query = [
+        'mysql', "--user=#{user}", (password.blank? ? '' : "--password=#{password}"), (%w(127.0.0.1 localhost).include?(host) ? '-e' : "--host=#{host} -e"),
+        "CREATE DATABASE #{database} DEFAULT CHARACTER SET #{charset} DEFAULT COLLATE #{collation}".inspect
+      ]
+      system(query.compact.join(' '))
+    when 'sqlite3'
+      DataMapper.setup(DataMapper.repository&.name, config)
+    else
+      raise "Adapter #{config[:adapter]} not supported for creating databases yet."
+    end
+    puts "<= #{t.name} done"
+  end
+
+  desc 'Drop the database'
+  task :drop, [:repository] => :environment do |t, args|
+    repo = args[:repository] || ENV['REPOSITORY'] || :default
+    config = DataMapper.repository(repo)&.adapter&.options&.symbolize_keys
+    user = config[:user]
+    password = config[:password]
+    host = config[:host]
+    database = config[:database] || config[:path].sub('/', '')
+    puts "=> Dropping database '#{database}'"
+    case config[:adapter]
+    when 'postgres'
+      system('dropdb', '-h', host, '-U', user, database)
+    when 'mysql'
+      query = [
+        'mysql', "--user=#{user}",
+        (password.blank? ? '' : "--password=#{password}"),
+        (%w(127.0.0.1 localhost).include?(host) ? '-e' : "--host=#{host} -e"),
+        "DROP DATABASE IF EXISTS #{database}".inspect
+      ]
+      system(query.compact.join(' '))
+    when 'sqlite3'
+      FileUtils.rm_f(config[:path])
+    else
+      raise "Adapter #{config[:adapter]} not supported for dropping databases yet."
+    end
+    puts "<= #{t.name} done"
+  end
+
+  desc 'Load the seed data from db/seeds.rb'
+  task seed: :environment do |t, _|
+    puts '=> Loading seed data'
+    seed_file = File.expand_path('db/seeds.rb', File.dirname(__FILE__))
+    load(seed_file) if File.exist?(seed_file)
+    puts "<= #{t.name} done"
+  end
+
+  desc 'Drop the database, migrate from scratch and initialize with the seed data'
+  task reset: %i(drop setup)
+
+  desc 'Create the database, migrate and initialize with the seed data'
+  task setup: %i(create migrate seed)
+end

data/examples/sample_migration.rb

@@ -0,0 +1,58 @@
+require 'dm-migrations/migration_runner'
+
+DataMapper.setup(:default, 'sqlite3::memory')
+
+DataMapper::Logger.new(STDOUT, :debug)
+DataMapper.logger.debug( 'Starting 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
+
+migration 2, :add_dob_to_people do
+  up do
+    modify_table :people do
+      add_column :dob, DateTime, allow_nil: true
+    end
+  end
+
+  down do
+    modify_table :people do
+      drop_column :dob
+    end
+  end
+end
+
+# migrate_down!
+# migrate_up!
+#
+# class Person
+#   include DataMapper::Resource
+#
+#   property :id, Serial
+#   property :name, String, :size => 50
+#   property :age, Integer
+#   property :dob, DateTime, :default => proc { Time.now }
+#
+# end
+#
+# Person.create(:name => "Mark Bates", :age => 31)
+# puts Person.first.inspect
+# puts Person.all.inspect
+
+if $0 == __FILE__
+  if $*.first == 'down'
+    migrate_down!
+  else
+    migrate_up!
+  end
+end

data/examples/sample_migration_spec.rb

@@ -0,0 +1,46 @@
+require 'pathname'
+
+dir = Pathname(__FILE__).dirname.expand_path
+
+require "#{dir}sample_migration"
+require "#{dir}../lib/spec/example/migration_example_group"
+
+describe :create_people_table, type: :migration do
+  before do
+    run_migration
+  end
+
+  it 'creates a people table' do
+    expect(repository(:default)).to have_table(:people)
+  end
+
+  it 'has an id column as the primary key' do
+    expect(table(:people)).to have_column(:id)
+    expect(table(:people).column(:id).type).to eq 'integer'
+    # expect(table(:people).column(:id)).to be_primary_key
+  end
+
+  it 'has a name column as a string' do
+    expect(table(:people)).to have_column(:name)
+    expect(table(:people).column(:name).type).to eq 'character varying'
+    expect(table(:people).column(:name)).to permit_null
+  end
+
+  it 'has a nullable age column as a int' do
+    expect(table(:people)).to have_column(:age)
+    expect(table(:people).column(:age).type).to eq 'integer'
+    expect(table(:people).column(:age)).to permit_null
+  end
+end
+
+describe :add_dob_to_people, type: :migration do
+  before do
+    run_migration
+  end
+
+  it 'adds a dob column as a timestamp' do
+    expect(table(:people)).to have_column(:dob)
+    expect(table(:people).column(:dob).type).to eq 'timestamp without time zone'
+    expect(table(:people).column(:dob)).to permit_null
+  end
+end

data/lib/dm-migrations/adapters/dm-do-adapter.rb

@@ -0,0 +1,304 @@
+require 'dm-migrations/auto_migration'
+
+module DataMapper
+  module Migrations
+    module DataObjectsAdapter
+      # Returns whether the storage_name exists.
+      #
+      # @param [String] storage_name
+      #   a String defining the name of a storage, for example a table name.
+      #
+      # @return [Boolean]
+      #   true if the storage exists
+      #
+      # @api semipublic
+      def storage_exists?(storage_name)
+        statement = DataMapper::Ext::String.compress_lines(<<-SQL)
+          SELECT COUNT(*)
+          FROM "information_schema"."tables"
+          WHERE "table_type" = 'BASE TABLE'
+          AND "table_schema" = ?
+          AND "table_name" = ?
+        SQL
+
+        select(statement, schema_name, storage_name).first > 0
+      end
+
+      # Returns whether the field exists.
+      #
+      # @param [String] storage_name
+      #   a String defining the name of a storage, for example a table name.
+      # @param [String] column_name
+      #   a String defining the name of a field, for example a column name.
+      #
+      # @return [Boolean]
+      #   true if the field exists.
+      #
+      # @api semipublic
+      def field_exists?(storage_name, column_name)
+        statement = DataMapper::Ext::String.compress_lines(<<-SQL)
+          SELECT COUNT(*)
+          FROM "information_schema"."columns"
+          WHERE "table_schema" = ?
+          AND "table_name" = ?
+          AND "column_name" = ?
+        SQL
+
+        select(statement, schema_name, storage_name, column_name).first > 0
+      end
+
+      # @api semipublic
+      def upgrade_model_storage(model)
+        name       = self.name
+        properties = model.properties_with_subclasses(name)
+
+        return properties if create_model_storage(model)
+
+        table_name = model.storage_name(name)
+
+        with_connection do |connection|
+          properties.map do |property|
+            schema_hash = property_schema_hash(property)
+            next if field_exists?(table_name, schema_hash[:name])
+
+            statement = alter_table_add_column_statement(connection, table_name, schema_hash)
+            command   = connection.create_command(statement)
+            command.execute_non_query
+
+            # For simple :index => true columns, add an appropriate index.
+            # Upgrading doesn't know how to deal with complex indexes yet.
+            if property.options[:index] === true
+              statement = create_index_statement(model, property.name, [property.field])
+              command   = connection.create_command(statement)
+              command.execute_non_query
+            end
+
+            property
+          end.compact
+        end
+      end
+
+      # @api semipublic
+      def create_model_storage(model)
+        name       = self.name
+        properties = model.properties_with_subclasses(name)
+
+        return false if storage_exists?(model.storage_name(name))
+        return false if properties.empty?
+
+        with_connection do |connection|
+          statements = [create_table_statement(connection, model, properties)]
+          statements.concat(create_index_statements(model))
+          statements.concat(create_unique_index_statements(model))
+
+          statements.each do |statement|
+            command = connection.create_command(statement)
+            command.execute_non_query
+          end
+        end
+
+        true
+      end
+
+      # @api semipublic
+      def destroy_model_storage(model)
+        return true unless supports_drop_table_if_exists? || storage_exists?(model.storage_name(name))
+
+        execute(drop_table_statement(model))
+        true
+      end
+
+      module SQL # :nodoc:
+        # private  ## This cannot be private for current migrations
+
+        # Adapters that support AUTO INCREMENT fields for CREATE TABLE
+        # statements should overwrite this to return true
+        #
+        # @api private
+        def supports_serial?
+          false
+        end
+
+        # @api private
+        def supports_drop_table_if_exists?
+          false
+        end
+
+        # @api private
+        def schema_name
+          raise NotImplementedError, "#{self.class}#schema_name not implemented"
+        end
+
+        # @api private
+        def alter_table_add_column_statement(connection, table_name, schema_hash)
+          "ALTER TABLE #{quote_name(table_name)} #{add_column_statement} #{property_schema_statement(connection, schema_hash)}"
+        end
+
+        # @api private
+        def create_table_statement(connection, model, properties)
+          DataMapper::Ext::String.compress_lines(<<-SQL)
+            CREATE TABLE #{quote_name(model.storage_name(name))}
+            (#{properties.map { |property| property_schema_statement(connection, property_schema_hash(property)) }.join(', ')},
+            PRIMARY KEY(#{properties.key.map { |property| quote_name(property.field) }.join(', ')}))
+          SQL
+        end
+
+        # @api private
+        def drop_table_statement(model)
+          table_name = quote_name(model.storage_name(name))
+          if supports_drop_table_if_exists?
+            "DROP TABLE IF EXISTS #{table_name}"
+          else
+            "DROP TABLE #{table_name}"
+          end
+        end
+
+        # @api private
+        def create_index_statements(model)
+          name = self.name
+          model.storage_name(name)
+
+          indexes(model).map do |index_name, fields|
+            create_index_statement(model, index_name, fields)
+          end
+        end
+
+        # @api private
+        def create_index_statement(model, index_name, fields)
+          table_name = model.storage_name(name)
+
+          DataMapper::Ext::String.compress_lines(<<-SQL)
+            CREATE INDEX #{quote_name("index_#{table_name}_#{index_name}")} ON
+            #{quote_name(table_name)} (#{fields.map { |field| quote_name(field) }.join(', ')})
+          SQL
+        end
+
+        # @api private
+        def create_unique_index_statements(model)
+          name           = self.name
+          table_name     = model.storage_name(name)
+          key            = model.key(name).map(&:field)
+          unique_indexes = unique_indexes(model).reject { |_index_name, fields| fields == key }
+
+          unique_indexes.map do |index_name, fields|
+            DataMapper::Ext::String.compress_lines(<<-SQL)
+              CREATE UNIQUE INDEX #{quote_name("unique_#{table_name}_#{index_name}")} ON
+              #{quote_name(table_name)} (#{fields.map { |field| quote_name(field) }.join(', ')})
+            SQL
+          end
+        end
+
+        # @api private
+        def property_schema_hash(property)
+          dump_class = property.dump_class
+          type_by_property_class = self.class.type_by_property_class(property.class)
+
+          schema = (type_by_property_class || self.class.type_map[dump_class]).merge(name: property.field)
+
+          schema_primitive = schema[:primitive]
+
+          if dump_class.equal?(String) && schema_primitive != 'TEXT' && schema_primitive != 'CLOB' && schema_primitive != 'NVARCHAR' &&
+             schema_primitive != 'BYTEA' && schema_primitive != 'VARBINARY'
+            schema[:length] = property.length
+          elsif dump_class.equal?(BigDecimal) || dump_class.equal?(Float)
+            schema[:precision] = property.precision
+            schema[:scale]     = property.scale
+          end
+
+          schema[:allow_nil] = property.allow_nil?
+          schema[:serial]    = property.serial?
+
+          default = property.default
+
+          if default.nil? || default.respond_to?(:call)
+            # remove the default if the property does not allow nil
+            schema.delete(:default) unless schema[:allow_nil]
+          else
+            schema[:default] = property.dump(default)
+          end
+
+          schema
+        end
+
+        # @api private
+        def property_schema_statement(connection, schema)
+          statement = quote_name(schema[:name])
+          statement << " #{schema[:primitive]}"
+
+          length = schema[:length]
+
+          if schema[:precision] && schema[:scale]
+            statement << "(#{%i(precision scale).map { |key| connection.quote_value(schema[key]) }.join(', ')})"
+          elsif length == 'max'
+            statement << '(max)'
+          elsif length
+            statement << "(#{connection.quote_value(length)})"
+          end
+
+          default = schema[:default]
+          statement << " DEFAULT #{connection.quote_value(default)}" if default
+
+          statement << ' NOT NULL' unless schema[:allow_nil]
+
+          statement
+        end
+
+        # @api private
+        def indexes(model)
+          model.properties(name).indexes
+        end
+
+        # @api private
+        def unique_indexes(model)
+          model.properties(name).unique_indexes
+        end
+
+        # @api private
+        def add_column_statement
+          'ADD COLUMN'
+        end
+      end
+
+      include SQL
+
+      module ClassMethods
+        # Default types for all data object based adapters.
+        #
+        # @return [Hash] default types for data objects adapters.
+        #
+        # @api private
+        def type_map
+          length    = Property::String.length
+          precision = Property::Numeric.precision
+          scale     = Property::Decimal.scale
+
+          {
+            Property::Binary => {primitive: 'BLOB'},
+            Object => {primitive: 'TEXT'},
+            Integer => {primitive: 'INTEGER'},
+            String => {primitive: 'VARCHAR', length: length},
+            Class => {primitive: 'VARCHAR', length: length},
+            BigDecimal => {primitive: 'DECIMAL', precision: precision, scale: scale},
+            Float => {primitive: 'FLOAT', precision: precision},
+            DateTime => {primitive: 'TIMESTAMP'},
+            Date => {primitive: 'DATE'},
+            Time => {primitive: 'TIMESTAMP'},
+            TrueClass => {primitive: 'BOOLEAN'},
+            Property::Text => {primitive: 'TEXT'}
+          }.freeze
+        end
+
+        # Finds a type for a given property.
+        #
+        # @return [Hash | nil] type matching the given property or one of the properties ancestors
+        #
+        # @api private
+        def type_by_property_class(property_class)
+          return nil unless property_class < DataMapper::Property
+
+          type_map[property_class] || type_by_property_class(property_class.superclass)
+        end
+      end
+    end
+  end
+end