sbf-dm-migrations 1.3.0.beta

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

@@ -0,0 +1,152 @@
+require 'dm-migrations/auto_migration'
+require 'dm-migrations/adapters/dm-do-adapter'
+
+module DataMapper
+  module Migrations
+    module PostgresAdapter
+      include SQL, DataObjectsAdapter
+
+      # @api private
+      def self.included(base)
+        base.extend DataObjectsAdapter::ClassMethods
+        base.extend ClassMethods
+      end
+
+      # @api semipublic
+      def upgrade_model_storage(model)
+        without_notices { super }
+      end
+
+      # @api semipublic
+      def create_model_storage(model)
+        without_notices { super }
+      end
+
+      # @api semipublic
+      def destroy_model_storage(model)
+        if supports_drop_table_if_exists?
+          without_notices { super }
+        else
+          super
+        end
+      end
+
+      module SQL # :nodoc:
+        # private  ## This cannot be private for current migrations
+
+        # @api private
+        def supports_drop_table_if_exists?
+          @supports_drop_table_if_exists ||= postgres_version >= '8.2'
+        end
+
+        # @api private
+        def schema_name
+          @schema_name ||= select('SELECT current_schema()').first.freeze
+        end
+
+        # @api private
+        def postgres_version
+          @postgres_version ||= select('SELECT version()').first.split[1].freeze
+        end
+
+        # @api private
+        def without_notices
+          # execute the block with NOTICE messages disabled
+          execute('SET client_min_messages = warning')
+          yield
+        ensure
+          execute('RESET client_min_messages')
+        end
+
+        # @api private
+        def property_schema_hash(property)
+          schema = super
+
+          # Postgres does not support precision and scale for Float
+          if property.is_a?(Property::Float)
+            schema.delete(:precision)
+            schema.delete(:scale)
+          end
+
+          if property.is_a?(Property::Integer)
+            min = property.min
+            max = property.max
+
+            schema[:primitive] = integer_column_statement(min..max) if min && max
+          end
+
+          schema[:primitive] = serial_column_statement(min..max) if schema[:serial]
+
+          schema
+        end
+
+        # Return SQL statement for the integer column
+        #
+        # @param [Range] range
+        #   the min/max allowed integers
+        #
+        # @return [String]
+        #   the statement to create the integer column
+        #
+        # @api private
+        private def integer_column_statement(range)
+          min = range.first
+          max = range.last
+
+          smallint = 2**15
+          integer  = 2**31
+          bigint   = 2**63
+
+          if min >= -smallint && max < smallint
+            'SMALLINT'
+          elsif min >= -integer  && max < integer
+            'INTEGER'
+          elsif min >= -bigint   && max < bigint
+            'BIGINT'
+          else
+            raise ArgumentError, "min #{min} and max #{max} exceeds supported range"
+          end
+        end
+
+        # Return SQL statement for the serial column
+        #
+        # @param [Range] range
+        #   the range of allowed integers
+        #
+        # @return [String]
+        #   the statement to create the serial column
+        #
+        # @api private
+        private def serial_column_statement(range)
+          max = range.last
+
+          if max.nil? || max < 2**31
+            'SERIAL'
+          elsif max < 2**63
+            'BIGSERIAL'
+          else
+            raise ArgumentError, "min #{range.first} and max #{max} exceeds supported range"
+          end
+        end
+      end
+
+      module ClassMethods
+        # Types for PostgreSQL databases.
+        #
+        # @return [Hash] types for PostgreSQL databases.
+        #
+        # @api private
+        def type_map
+          precision = Property::Numeric.precision
+          scale     = Property::Decimal.scale
+
+          super.merge(
+            Property::Binary => {primitive: 'BYTEA'},
+            BigDecimal => {primitive: 'NUMERIC', precision: precision, scale: scale},
+            Float => {primitive: 'DOUBLE PRECISION'}
+          ).freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require 'dm-migrations/auto_migration'
+require 'dm-migrations/adapters/dm-do-adapter'
+
+module DataMapper
+  module Migrations
+    module SqliteAdapter
+      include SQL, DataObjectsAdapter
+
+      # @api private
+      def self.included(base)
+        base.extend DataObjectsAdapter::ClassMethods
+        base.extend ClassMethods
+      end
+
+      # @api semipublic
+      def storage_exists?(storage_name)
+        table_info(storage_name).any?
+      end
+
+      # @api semipublic
+      def field_exists?(storage_name, column_name)
+        table_info(storage_name).any? do |row|
+          row.name == column_name
+        end
+      end
+
+      module SQL # :nodoc:
+        # private  ## This cannot be private for current migrations
+
+        # @api private
+        def supports_serial?
+          @supports_serial ||= sqlite_version >= '3.1.0'
+        end
+
+        # @api private
+        def supports_drop_table_if_exists?
+          @supports_drop_table_if_exists ||= sqlite_version >= '3.3.0'
+        end
+
+        # @api private
+        def table_info(table_name)
+          select("PRAGMA table_info(#{quote_name(table_name)})")
+        end
+
+        # @api private
+        def create_table_statement(connection, model, properties)
+          statement = 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(', ')}
+          SQL
+
+          # skip adding the primary key if one of the columns is serial.  In
+          # SQLite the serial column must be the primary key, so it has already
+          # been defined
+          statement << ", PRIMARY KEY(#{properties.key.map { |property| quote_name(property.field) }.join(', ')})" unless properties.any?(&:serial?)
+
+          statement << ')'
+          statement
+        end
+
+        # @api private
+        def property_schema_statement(connection, schema)
+          statement = super
+
+          statement << ' PRIMARY KEY AUTOINCREMENT' if supports_serial? && schema[:serial]
+
+          statement
+        end
+
+        # @api private
+        def sqlite_version
+          @sqlite_version ||= select('SELECT sqlite_version(*)').first.freeze
+        end
+      end
+
+      module ClassMethods
+        # Types for SQLite 3 databases.
+        #
+        # @return [Hash] types for SQLite 3 databases.
+        #
+        # @api private
+        def type_map
+          super.merge(Class => {primitive: 'VARCHAR'}).freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,184 @@
+require 'dm-migrations/auto_migration'
+require 'dm-migrations/adapters/dm-do-adapter'
+
+module DataMapper
+  module Migrations
+    module SqlserverAdapter
+      DEFAULT_CHARACTER_SET = 'utf8'.freeze
+
+      include SQL, DataObjectsAdapter
+
+      # @api private
+      def self.included(base)
+        base.extend DataObjectsAdapter::ClassMethods
+        base.extend ClassMethods
+      end
+
+      # @api semipublic
+      def storage_exists?(storage_name)
+        select('SELECT name FROM sysobjects WHERE name LIKE ?', storage_name).first == storage_name
+      end
+
+      # @api semipublic
+      def field_exists?(storage_name, field_name)
+        result = select(
+          'SELECT c.name FROM sysobjects as o JOIN syscolumns AS c ON o.id = c.id WHERE o.name = ? AND c.name LIKE ?',
+          storage_name,
+          field_name
+        ).first
+        result ? result.to_s == field_name.to_s : false
+      end
+
+      module SQL # :nodoc:
+        # private  ## This cannot be private for current migrations
+
+        # @api private
+        def supports_serial?
+          true
+        end
+
+        # @api private
+        def supports_drop_table_if_exists?
+          false
+        end
+
+        # @api private
+        def schema_name
+          select('SELECT DB_NAME()')
+        end
+
+        # TODO: update dkubb/dm-more/dm-migrations to use schema_name and remove this
+
+        alias_method :db_name, :schema_name
+
+        # @api private
+        def create_table_statement(connection, model, properties)
+          statement = 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(', ')}
+          SQL
+
+          # specific the primary keys.
+          # don't have to filter out Serial (aka IDENTITY) type
+          statement << ", PRIMARY KEY(#{properties.key.map { |property| quote_name(property.field) }.join(', ')})"
+
+          statement << ')'
+          statement
+        end
+
+        # @api private
+        def property_schema_hash(property)
+          schema = super
+
+          if property.is_a?(Property::Integer)
+            min = property.min
+            max = property.max
+
+            schema[:primitive] = integer_column_statement(min..max) if min && max
+          end
+
+          schema_primitive = schema[:primitive]
+
+          if schema_primitive == 'NVARCHAR'
+            schema[:length] = if property.length <= 4000
+                                property.length
+                              else
+                                'max'
+                              end
+          end
+
+          schema.delete(:default) if schema[:primitive] == 'TEXT'
+
+          schema
+        end
+
+        # @api private
+        def property_schema_statement(connection, schema)
+          if supports_serial? && schema[:serial]
+            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
+              statement << "(#{connection.quote_value(length)})"
+            end
+
+            statement << ' IDENTITY'
+          else
+            statement = super
+          end
+
+          statement
+        end
+
+        # @api private
+        def character_set
+          @character_set ||= show_variable('character_set_connection') || DEFAULT_CHARACTER_SET
+        end
+
+        # @api private
+        def collation
+          @collation ||= show_variable('collation_connection') || DEFAULT_COLLATION
+        end
+
+        # @api private
+        def show_variable(_name)
+          raise 'SqlserverAdapter#show_variable: Not implemented'
+        end
+
+        # Return SQL statement for the integer column
+        #
+        # @param [Range] range
+        #   the min/max allowed integers
+        #
+        # @return [String]
+        #   the statement to create the integer column
+        #
+        # @api private
+        private def integer_column_statement(range)
+          min = range.first
+          max = range.last
+
+          smallint = 2**15
+          integer  = 2**31
+          bigint   = 2**63
+
+          if min >= 0 && max < 2**8
+            'TINYINT'
+          elsif min >= -smallint && max < smallint then 'SMALLINT'
+          elsif min >= -integer  && max < integer  then 'INT'
+          elsif min >= -bigint   && max < bigint   then 'BIGINT'
+          else
+            raise ArgumentError, "min #{min} and max #{max} exceeds supported range"
+          end
+        end
+      end
+
+      module ClassMethods
+        # Types for Sqlserver databases.
+        #
+        # @return [Hash] types for Sqlserver databases.
+        #
+        # @api private
+        def type_map
+          length = Property::String.length
+          _precision = Property::Numeric.precision
+          _scale     = Property::Decimal.scale
+
+          super.merge(
+            DateTime => {primitive: 'DATETIME'},
+            Date => {primitive: 'SMALLDATETIME'},
+            Time => {primitive: 'SMALLDATETIME'},
+            TrueClass => {primitive: 'BIT'},
+            String => {primitive: 'NVARCHAR', length: length},
+            Property::Text => {primitive: 'NVARCHAR', length: 'max'},
+            Property::Binary => {primitive: 'VARBINARY', length: 'max'}
+          ).freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'dm-migrations/auto_migration'
+require 'dm-migrations/adapters/dm-do-adapter'
+
+module DataMapper
+  module Migrations
+    module YamlAdapter
+      def self.included(_base)
+        DataMapper.extend(Migrations::SingletonMethods)
+        %i(Repository Model).each do |name|
+          DataMapper.const_get(name).send(:include, Migrations.const_get(name))
+        end
+      end
+
+      # @api semipublic
+      def destroy_model_storage(model)
+        yaml_file(model).unlink if yaml_file(model).file?
+        true
+      end
+    end
+  end
+end

data/lib/dm-migrations/auto_migration.rb

@@ -0,0 +1,227 @@
+require 'dm-core'
+
+module DataMapper
+  module Migrations
+    module SingletonMethods
+      # destructively migrates the repository upwards to match model definitions
+      #
+      # @param [Symbol] repository_name repository to act on, :default is the default
+      #
+      # @api public
+      def migrate!(repository_name = nil)
+        repository(repository_name).migrate!
+      end
+
+      # drops and recreates the repository upwards to match model definitions
+      #
+      # @param [Symbol] repository_name repository to act on, :default is the default
+      #
+      # @api public
+      def auto_migrate!(repository_name = nil)
+        repository_execute(:auto_migrate!, repository_name)
+      end
+
+      # @api public
+      def auto_upgrade!(repository_name = nil)
+        repository_execute(:auto_upgrade!, repository_name)
+      end
+
+      # @api semipublic
+      private def auto_migrate_down!(repository_name)
+        repository_execute(:auto_migrate_down!, repository_name)
+      end
+
+      # @api semipublic
+      private def auto_migrate_up!(repository_name)
+        repository_execute(:auto_migrate_up!, repository_name)
+      end
+
+      # @api private
+      private def repository_execute(method, repository_name)
+        models = DataMapper::Model.descendants
+        models = models.select { |m| m.repository_name == repository_name } if repository_name
+        models.each do |model|
+          model.send(method, model.repository_name)
+        end
+      end
+    end
+
+    module Repository
+      # Determine whether a particular named storage exists in this repository
+      #
+      # @param [String]
+      #   storage_name name of the storage to test for
+      #
+      # @return [Boolean]
+      #   true if the data-store +storage_name+ exists
+      #
+      # @api semipublic
+      def storage_exists?(storage_name)
+        adapter = self.adapter
+        return false unless adapter.respond_to?(:storage_exists?)
+
+        adapter.storage_exists?(storage_name)
+      end
+
+      # @api semipublic
+      def upgrade_model_storage(model)
+        adapter = self.adapter
+        return unless adapter.respond_to?(:upgrade_model_storage)
+
+        adapter.upgrade_model_storage(model)
+      end
+
+      # @api semipublic
+      def create_model_storage(model)
+        adapter = self.adapter
+        return unless adapter.respond_to?(:create_model_storage)
+
+        adapter.create_model_storage(model)
+      end
+
+      # @api semipublic
+      def destroy_model_storage(model)
+        adapter = self.adapter
+        return unless adapter.respond_to?(:destroy_model_storage)
+
+        adapter.destroy_model_storage(model)
+      end
+
+      # Destructively automigrates the data-store to match the model.
+      # First migrates all models down and then up.
+      # REPEAT: THIS IS DESTRUCTIVE
+      #
+      # @api public
+      def auto_migrate!
+        DataMapper.auto_migrate!(name)
+      end
+
+      # Safely migrates the data-store to match the model
+      # preserving data already in the data-store
+      #
+      # @api public
+      def auto_upgrade!
+        DataMapper.auto_upgrade!(name)
+      end
+    end
+
+    module Model
+      # @api private
+      def self.included(mod)
+        mod.descendants.each { |model| model.extend self }
+      end
+
+      # @api semipublic
+      def storage_exists?(repository_name = default_repository_name)
+        repository(repository_name).storage_exists?(storage_name(repository_name))
+      end
+
+      # Destructively automigrates the data-store to match the model
+      # REPEAT: THIS IS DESTRUCTIVE
+      #
+      # @param [Symbol] repository_name the repository to be migrated
+      #
+      # @api public
+      def auto_migrate!(repository_name = self.repository_name)
+        assert_valid(true)
+        auto_migrate_down!(repository_name)
+        auto_migrate_up!(repository_name)
+      end
+
+      # Safely migrates the data-store to match the model
+      # preserving data already in the data-store
+      #
+      # @param [Symbol] repository_name the repository to be migrated
+      #
+      # @api public
+      def auto_upgrade!(repository_name = self.repository_name)
+        assert_valid(true)
+        base_model = self.base_model
+        if base_model == self
+          repository(repository_name).upgrade_model_storage(self)
+        else
+          base_model.auto_upgrade!(repository_name)
+        end
+      end
+
+      # Destructively migrates the data-store down, which basically
+      # deletes all the models.
+      # REPEAT: THIS IS DESTRUCTIVE
+      #
+      # @param [Symbol] repository_name the repository to be migrated
+      #
+      # @api private
+      def auto_migrate_down!(repository_name = self.repository_name)
+        assert_valid(true)
+        base_model = self.base_model
+        if base_model == self
+          repository(repository_name).destroy_model_storage(self)
+        else
+          base_model.auto_migrate_down!(repository_name)
+        end
+      end
+
+      # Auto migrates the data-store to match the model
+      #
+      # @param [Symbol] repository_name the repository to be migrated
+      #
+      # @api private
+      def auto_migrate_up!(repository_name = self.repository_name)
+        assert_valid(true)
+        base_model = self.base_model
+        if base_model == self
+          repository(repository_name).create_model_storage(self)
+        else
+          base_model.auto_migrate_up!(repository_name)
+        end
+      end
+    end
+
+    def self.include_migration_api
+      DataMapper.extend(SingletonMethods)
+      %i(Repository Model).each do |name|
+        DataMapper.const_get(name).send(:include, const_get(name))
+      end
+      DataMapper::Model.append_extensions(Model)
+      Adapters::AbstractAdapter.descendants.each do |adapter_class|
+        Adapters.include_migration_api(DataMapper::Inflector.demodulize(adapter_class.name))
+      end
+    end
+  end
+
+  module Adapters
+    def self.include_migration_api(const_name)
+      require auto_migration_extensions(const_name)
+      if Migrations.const_defined?(const_name)
+        adapter = const_get(const_name)
+        adapter.send(:include, migration_module(const_name))
+      end
+    rescue LoadError
+      # Silently ignore the fact that no adapter extensions could be required
+      # This means that the adapter in use doesn't support migrations
+    end
+
+    def self.migration_module(const_name)
+      Migrations.const_get(const_name)
+    end
+
+    class << self
+      # @api private
+      private def auto_migration_extensions(const_name)
+        name = adapter_name(const_name)
+        name = 'do' if name == 'dataobjects'
+        "dm-migrations/adapters/dm-#{name}-adapter"
+      end
+    end
+
+    extendable do
+      # @api private
+      def const_added(const_name)
+        include_migration_api(const_name)
+        super
+      end
+    end
+  end
+
+  Migrations.include_migration_api
+end

data/lib/dm-migrations/exceptions/duplicate_migration.rb

@@ -0,0 +1,6 @@
+module DataMapper
+  module Migrations
+    class DuplicateMigration < StandardError
+    end
+  end
+end