sbf-dm-migrations 1.3.0.beta

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

@@ -0,0 +1,306 @@
+require 'dm-migrations/auto_migration'
+require 'dm-migrations/adapters/dm-do-adapter'
+
+module DataMapper
+  module Migrations
+    module MysqlAdapter
+      DEFAULT_ENGINE        = 'InnoDB'.freeze
+      DEFAULT_CHARACTER_SET = 'utf8'.freeze
+      DEFAULT_COLLATION     = 'utf8_unicode_ci'.freeze
+      MAXIMUM_CHAR_LENGTH   = ((2**16) - 1) / 4 # allow room for utf8mb4
+
+      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('SHOW TABLES LIKE ?', storage_name).first == storage_name
+      end
+
+      # @api semipublic
+      def field_exists?(storage_name, field)
+        result = select("SHOW COLUMNS FROM #{quote_name(storage_name)} LIKE ?", field).first
+        result ? result.field == field : false
+      end
+
+      module SQL # :nodoc:
+        # private  ## This cannot be private for current migrations
+
+        # Allows for specification of the default storage engine to use when creating tables via
+        # migrations.  Defaults to DEFAULT_ENGINE.
+        #
+        # adapter = DataMapper.setup(:default, 'mysql://localhost/foo')
+        # adapter.storage_engine = 'MyISAM'
+        #
+        # @api public
+        attr_accessor :storage_engine
+
+        # @api private
+        def supports_serial?
+          true
+        end
+
+        # @api private
+        def supports_drop_table_if_exists?
+          true
+        end
+
+        # @api private
+        def schema_name
+          # TODO: is there a cleaner way to find out the current DB we are connected to?
+          normalized_uri.path.split('/').last
+        end
+
+        # @api private
+        def create_table_statement(connection, model, properties)
+          "#{super} ENGINE = #{storage_engine} CHARACTER SET #{character_set} COLLATE #{collation}"
+        end
+
+        # @api private
+        def property_schema_hash(property)
+          schema = super
+
+          case property.dump_as
+          when Integer.singleton_class
+            if property.respond_to?(:min) && property.respond_to?(:max)
+              min = property.min
+              max = property.max
+              schema[:primitive] = integer_column_statement(min..max) if min && max
+            end
+          when String.singleton_class
+            if property.is_a?(Property::Text)
+              schema[:primitive] = text_column_statement(property.length)
+              schema.delete(:default)
+            else
+              schema[:length] ||= MAXIMUM_CHAR_LENGTH
+            end
+          end
+
+          schema
+        end
+
+        # @api private
+        def property_schema_statement(connection, schema)
+          statement = super
+
+          statement << ' AUTO_INCREMENT' if supports_serial? && schema[:serial]
+
+          statement
+        end
+
+        # @api private
+        def storage_engine
+          # Don't pull the default engine via show_variable for backwards compat where it was hard
+          # coded to InnoDB
+          @storage_engine ||= DEFAULT_ENGINE
+        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)
+          result = select('SHOW VARIABLES LIKE ?', name).first
+          result ? result.value.freeze : nil
+        end
+
+        # Return SQL statement for the text column
+        #
+        # @param [Integer] length
+        #   the max allowed length
+        #
+        # @return [String]
+        #   the statement to create the text column
+        #
+        # @api private
+        private def text_column_statement(length)
+          if length < 2**8
+            'TINYTEXT'
+          elsif length < 2**16
+            'TEXT'
+          elsif length < 2**24
+            'MEDIUMTEXT'
+          elsif length < 2**32
+            'LONGTEXT'
+
+          # http://www.postgresql.org/files/documentation/books/aw_pgsql/node90.html
+          # Implies that PostgreSQL doesn't have a size limit on text
+          # fields, so this param validation happens here instead of
+          # DM::Property#initialize.
+          else
+            raise ArgumentError, "length of #{length} exceeds maximum size supported"
+          end
+        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)
+          format('%s(%d)%s', integer_column_type(range), integer_display_size(range), integer_statement_sign(range))
+        end
+
+        # Return the integer column type
+        #
+        # Use the smallest available column type that will satisfy the
+        # allowable range of numbers
+        #
+        # @param [Range] range
+        #   the min/max allowed integers
+        #
+        # @return [String]
+        #   the column type
+        #
+        # @api private
+        private def integer_column_type(range)
+          if range.first < 0
+            signed_integer_column_type(range)
+          else
+            unsigned_integer_column_type(range)
+          end
+        end
+
+        # Return the signed integer column type
+        #
+        # @param [Range] range
+        #   the min/max allowed integers
+        #
+        # @return [String]
+        #
+        # @api private
+        private def signed_integer_column_type(range)
+          min = range.first
+          max = range.last
+
+          tinyint   = 2**7
+          smallint  = 2**15
+          integer   = 2**31
+          mediumint = 2**23
+          bigint    = 2**63
+
+          if min >= -tinyint && max < tinyint
+            'TINYINT'
+          elsif min >= -smallint && max < smallint
+            'SMALLINT'
+          elsif min >= -mediumint && max < mediumint
+            'MEDIUMINT'
+          elsif min >= -integer && max < integer
+            'INT'
+          elsif min >= -bigint && max < bigint
+            'BIGINT'
+          else
+            raise ArgumentError, "min #{min} and max #{max} exceeds supported range"
+          end
+        end
+
+        # Return the unsigned integer column type
+        #
+        # @param [Range] range
+        #   the min/max allowed integers
+        #
+        # @return [String]
+        #
+        # @api private
+        private def unsigned_integer_column_type(range)
+          max = range.last
+
+          if max < 2**8
+            'TINYINT'
+          elsif max < 2**16
+            'SMALLINT'
+          elsif max < 2**24
+            'MEDIUMINT'
+          elsif max < 2**32
+            'INT'
+          elsif max < 2**64
+            'BIGINT'
+          else
+            raise ArgumentError, "min #{range.first} and max #{max} exceeds supported range"
+          end
+        end
+
+        # Return the integer column display size
+        #
+        # Adjust the display size to match the maximum number of
+        # expected digits. This is more for documentation purposes
+        # and does not affect what can actually be stored in a
+        # specific column
+        #
+        # @param [Range] range
+        #   the min/max allowed integers
+        #
+        # @return [Integer]
+        #   the display size for the integer
+        #
+        # @api private
+        private def integer_display_size(range)
+          [range.first.to_s.length, range.last.to_s.length].max
+        end
+
+        # Return the integer sign statement
+        #
+        # @param [Range] range
+        #   the min/max allowed integers
+        #
+        # @return [String, nil]
+        #   statement if unsigned, nil if signed
+        #
+        # @api private
+        private def integer_statement_sign(range)
+          ' UNSIGNED' unless range.first < 0
+        end
+
+        # @api private
+        private def indexes(model)
+          filter_indexes(model, super)
+        end
+
+        # @api private
+        private def unique_indexes(model)
+          filter_indexes(model, super)
+        end
+
+        # Filter out any indexes with a non index-able column in MySQL
+        #
+        # @api private
+        private def filter_indexes(model, indexes)
+          field_map = model.properties(name).field_map
+          indexes.select do |_index_name, fields|
+            fields.all? { |field| !field_map[field].is_a?(Property::Text) }
+          end
+        end
+      end
+
+      module ClassMethods
+        # Types for MySQL databases.
+        #
+        # @return [Hash] types for MySQL databases.
+        #
+        # @api private
+        def type_map
+          super.merge(
+            DateTime => {primitive: 'DATETIME'},
+            Time => {primitive: 'DATETIME'}
+          ).freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,339 @@
+require 'dm-migrations/auto_migration'
+require 'dm-migrations/adapters/dm-do-adapter'
+
+module DataMapper
+  module Migrations
+    module OracleAdapter
+      include SQL, DataObjectsAdapter
+
+      # @api private
+      def self.included(base)
+        base.extend DataObjectsAdapter::ClassMethods
+        base.extend ClassMethods
+      end
+
+      # @api semipublic
+      def storage_exists?(storage_name)
+        statement = DataMapper::Ext::String.compress_lines(<<-SQL)
+          SELECT COUNT(*)
+          FROM all_tables
+          WHERE owner = ?
+          AND table_name = ?
+        SQL
+
+        select(statement, schema_name, oracle_upcase(storage_name)).first > 0
+      end
+
+      # @api semipublic
+      def sequence_exists?(sequence_name)
+        return false unless sequence_name
+
+        statement = DataMapper::Ext::String.compress_lines(<<-SQL)
+          SELECT COUNT(*)
+          FROM all_sequences
+          WHERE sequence_owner = ?
+          AND sequence_name = ?
+        SQL
+
+        select(statement, schema_name, oracle_upcase(sequence_name)).first > 0
+      end
+
+      # @api semipublic
+      def field_exists?(storage_name, field_name)
+        statement = DataMapper::Ext::String.compress_lines(<<-SQL)
+          SELECT COUNT(*)
+          FROM all_tab_columns
+          WHERE owner = ?
+          AND table_name = ?
+          AND column_name = ?
+        SQL
+
+        select(statement, schema_name, oracle_upcase(storage_name), oracle_upcase(field_name)).first > 0
+      end
+
+      # @api semipublic
+      def storage_fields(storage_name)
+        statement = DataMapper::Ext::String.compress_lines(<<-SQL)
+          SELECT column_name
+          FROM all_tab_columns
+          WHERE owner = ?
+          AND table_name = ?
+        SQL
+
+        select(statement, schema_name, oracle_upcase(storage_name))
+      end
+
+      def drop_table_statement(model)
+        table_name = quote_name(model.storage_name(name))
+        "DROP TABLE #{table_name} CASCADE CONSTRAINTS"
+      end
+
+      # @api semipublic
+      def create_model_storage(model)
+        name       = self.name
+        properties = model.properties_with_subclasses(name)
+        table_name = model.storage_name(name)
+        truncate_or_delete = self.class.auto_migrate_with
+        table_is_truncated = truncate_or_delete && @truncated_tables && @truncated_tables[table_name]
+
+        return false if storage_exists?(table_name) && !table_is_truncated
+        return false if properties.empty?
+
+        with_connection do |connection|
+          # if table was truncated then check if all columns for properties are present
+          # TODO: check all other column definition options
+          if table_is_truncated && storage_has_all_fields?(table_name, properties)
+            @truncated_tables[table_name] = nil
+          else
+            # forced drop of table if properties are different
+            destroy_model_storage(model, true) if truncate_or_delete
+
+            statements = [create_table_statement(connection, model, properties)]
+            statements.concat(create_index_statements(model))
+            statements.concat(create_unique_index_statements(model))
+            statements.concat(create_sequence_statements(model))
+
+            statements.each do |statement|
+              command = connection.create_command(statement)
+              command.execute_non_query
+            end
+          end
+        end
+
+        true
+      end
+
+      # @api semipublic
+      def destroy_model_storage(model, forced = false)
+        table_name = model.storage_name(name)
+        klass      = self.class
+        truncate_or_delete = klass.auto_migrate_with
+        if storage_exists?(table_name)
+          if truncate_or_delete && !forced
+            case truncate_or_delete
+            when :truncate
+              execute(truncate_table_statement(model))
+            when :delete
+              execute(delete_table_statement(model))
+            else
+              raise ArgumentError, 'Unsupported auto_migrate_with option'
+            end
+            @truncated_tables ||= {}
+            @truncated_tables[table_name] = true
+          else
+            execute(drop_table_statement(model))
+            @truncated_tables[table_name] = nil if @truncated_tables
+          end
+        end
+        # added destroy of sequences
+        reset_sequences = klass.auto_migrate_reset_sequences
+        table_is_truncated = @truncated_tables && @truncated_tables[table_name]
+        unless truncate_or_delete && !reset_sequences && !forced
+          if sequence_exists?(model_sequence_name(model))
+            statement = if table_is_truncated && !forced
+                          reset_sequence_statement(model)
+                        else
+                          drop_sequence_statement(model)
+                        end
+            execute(statement) if statement
+          end
+        end
+        true
+      end
+
+      private def storage_has_all_fields?(table_name, properties)
+        properties.map { |property| oracle_upcase(property.field) }.sort == storage_fields(table_name).sort
+      end
+
+      # If table or column name contains just lowercase characters then do uppercase
+      # as uppercase version will be used in Oracle data dictionary tables
+      private def oracle_upcase(name)
+        (name =~ /[A-Z]/) ? name : name.upcase
+      end
+
+      module SQL # :nodoc:
+        # private  ## This cannot be private for current migrations
+
+        # @api private
+        def schema_name
+          @schema_name ||= select("SELECT SYS_CONTEXT('userenv','current_schema') FROM dual").first.freeze
+        end
+
+        # @api private
+        def property_schema_hash(property)
+          schema = super
+
+          if property.is_a?(Property::Binary)
+            # BLOB does not support length
+            schema.delete(:length)
+          end
+
+          if property.primitive == String && property.length > 4000
+            # Oracle doesn't support string over 4000 bytes
+            schema[:primitive] = 'NCLOB'
+            # CLOB and NCLOB do not support length
+            schema.delete(:length)
+          end
+
+          schema
+        end
+
+        # @api private
+        def create_sequence_statements(model)
+          name       = self.name
+          table_name = model.storage_name(name)
+          serial     = model.serial(name)
+
+          statements = []
+          if (sequence_name = model_sequence_name(model))
+            sequence_name = quote_name(sequence_name)
+            column_name   = quote_name(serial.field)
+
+            statements << DataMapper::Ext::String.compress_lines(<<-SQL)
+              CREATE SEQUENCE #{sequence_name} NOCACHE
+            SQL
+
+            # create trigger only if custom sequence name was not specified
+            unless serial.options[:sequence]
+              statements << DataMapper::Ext::String.compress_lines(<<-SQL)
+                CREATE OR REPLACE TRIGGER #{quote_name(default_trigger_name(table_name))}
+                BEFORE INSERT ON #{quote_name(table_name)} FOR EACH ROW
+                BEGIN
+                  IF inserting THEN
+                    IF :new.#{column_name} IS NULL THEN
+                      SELECT #{sequence_name}.NEXTVAL INTO :new.#{column_name} FROM dual;
+                    END IF;
+                  END IF;
+                END;
+              SQL
+            end
+          end
+
+          statements
+        end
+
+        # @api private
+        def drop_sequence_statement(model)
+          return unless (sequence_name = model_sequence_name(model))
+
+          "DROP SEQUENCE #{quote_name(sequence_name)}"
+        end
+
+        # @api private
+        def reset_sequence_statement(model)
+          return unless (sequence_name = model_sequence_name(model))
+
+          sequence_name = quote_name(sequence_name)
+          DataMapper::Ext::String.compress_lines(<<-SQL)
+            DECLARE
+              cval   INTEGER;
+            BEGIN
+              SELECT #{sequence_name}.NEXTVAL INTO cval FROM dual;
+              EXECUTE IMMEDIATE 'ALTER SEQUENCE #{sequence_name} INCREMENT BY -' || cval || ' MINVALUE 0';
+              SELECT #{sequence_name}.NEXTVAL INTO cval FROM dual;
+              EXECUTE IMMEDIATE 'ALTER SEQUENCE #{sequence_name} INCREMENT BY 1';
+            END;
+          SQL
+        end
+
+        # @api private
+        def truncate_table_statement(model)
+          "TRUNCATE TABLE #{quote_name(model.storage_name(name))}"
+        end
+
+        # @api private
+        def delete_table_statement(model)
+          "DELETE FROM #{quote_name(model.storage_name(name))}"
+        end
+
+        private def model_sequence_name(model)
+          name       = self.name
+          table_name = model.storage_name(name)
+          serial     = model.serial(name)
+
+          return unless serial
+
+          serial.options[:sequence] || default_sequence_name(table_name)
+        end
+
+        private def default_sequence_name(table_name)
+          # truncate table name if necessary to fit in max length of identifier
+          "#{table_name[0, self.class::IDENTIFIER_MAX_LENGTH - 4]}_seq"
+        end
+
+        private def default_trigger_name(table_name)
+          # truncate table name if necessary to fit in max length of identifier
+          "#{table_name[0, self.class::IDENTIFIER_MAX_LENGTH - 4]}_pkt"
+        end
+
+        # @api private
+        private def add_column_statement
+          'ADD'
+        end
+      end
+
+      module ClassMethods
+        # Types for Oracle databases.
+        #
+        # @return [Hash] types for Oracle databases.
+        #
+        # @api private
+        def type_map
+          length    = Property::String.length
+          precision = Property::Numeric.precision
+          _scale = Property::Decimal.scale
+
+          super.merge(
+            Integer => {primitive: 'NUMBER', precision: precision, scale: 0},
+            String => {primitive: 'VARCHAR2', length: length},
+            Class => {primitive: 'VARCHAR2', length: length},
+            BigDecimal => {primitive: 'NUMBER', precision: precision, scale: nil},
+            Float => {primitive: 'BINARY_FLOAT'},
+            DateTime => {primitive: 'DATE'},
+            Date => {primitive: 'DATE'},
+            Time => {primitive: 'DATE'},
+            TrueClass => {primitive: 'NUMBER', precision: 1, scale: 0},
+            Property::Text => {primitive: 'CLOB'}
+          ).freeze
+        end
+
+        # Use table truncate or delete for auto_migrate! to speed up test execution
+        #
+        # @param [Symbol] :truncate, :delete or :drop_and_create (or nil)
+        #   do not specify parameter to return current value
+        #
+        # @return [Mixed]
+        #   [Symbol] current value of auto_migrate_with option
+        #   (nil returned for :drop_and_create)
+        #
+        # @api semipublic
+        def auto_migrate_with(value = :not_specified)
+          return @auto_migrate_with if value == :not_specified
+
+          value = nil if value == :drop_and_create
+          raise ArgumentError unless [nil, :truncate, :delete].include?(value)
+
+          @auto_migrate_with = value
+        end
+
+        # Set if sequences will or will not be reset during auto_migrate!
+        #
+        # @param [Mixed] value
+        #   reset sequences? TrueClass, FalseClass
+        #   do not specify parameter to return current value
+        #
+        # @return [Mixed]
+        #   [Symbol] current value of auto_migrate_reset_sequences option
+        #   (default value is true)
+        #
+        # @api semipublic
+        def auto_migrate_reset_sequences(value = :not_specified)
+          return @auto_migrate_reset_sequences.nil? ? true : @auto_migrate_reset_sequences if value == :not_specified
+          raise ArgumentError unless [true, false].include?(value)
+
+          @auto_migrate_reset_sequences = value
+        end
+      end
+    end
+  end
+end