sbf-dm-constraints 1.3.0.beta

data/lib/data_mapper/constraints/adapters/abstract_adapter.rb

@@ -0,0 +1,33 @@
+require 'data_mapper/constraints/adapters/extension'
+
+module DataMapper
+  module Constraints
+    module Adapters
+      module AbstractAdapter
+        # @api private
+        def constraint_exists?(*)
+          false
+        end
+
+        # @api private
+        def create_relationship_constraint(*)
+          false
+        end
+
+        # @api private
+        def destroy_relationship_constraint(*)
+          false
+        end
+      end
+    end
+  end
+
+  Adapters::AbstractAdapter.class_eval do
+    include Constraints::Adapters::AbstractAdapter
+  end
+
+  Adapters::AbstractAdapter.descendants.each do |adapter_class|
+    const_name = DataMapper::Inflector.demodulize(adapter_class.name)
+    Adapters.include_constraint_api(const_name)
+  end
+end

data/lib/data_mapper/constraints/adapters/do_adapter.rb

@@ -0,0 +1,192 @@
+module DataMapper
+  module Constraints
+    module Adapters
+      module DataObjectsAdapter
+        ##
+        # Determine if a constraint exists for a table
+        #
+        # @param storage_name [Symbol]
+        #   name of table to check constraint on
+        # @param constraint_name [~String]
+        #   name of constraint to check for
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def constraint_exists?(storage_name, constraint_name)
+          statement = DataMapper::Ext::String.compress_lines(<<-SQL)
+            SELECT COUNT(*)
+            FROM #{quote_name('information_schema')}.#{quote_name('table_constraints')}
+            WHERE #{quote_name('constraint_type')} = 'FOREIGN KEY'
+            AND #{quote_name('table_schema')} = ?
+            AND #{quote_name('table_name')} = ?
+            AND #{quote_name('constraint_name')} = ?
+          SQL
+
+          select(statement, schema_name, storage_name, constraint_name).first > 0
+        end
+
+        ##
+        # Create the constraint for a relationship
+        #
+        # @param relationship [Relationship]
+        #   the relationship to create the constraint for
+        #
+        # @return [true, false]
+        #   true if creating the constraints was successful
+        #
+        # @api semipublic
+        def create_relationship_constraint(relationship)
+          return false unless valid_relationship_for_constraint?(relationship)
+
+          source_storage_name = relationship.source_model.storage_name(name)
+          target_storage_name = relationship.target_model.storage_name(name)
+          constraint_name     = constraint_name(source_storage_name, relationship.name)
+
+          return false if constraint_exists?(source_storage_name, constraint_name)
+
+          constraint_type =
+            case relationship.inverse.constraint
+            when :protect            then 'NO ACTION'
+            # TODO: support :cascade as an option:
+            #   (destroy doesn't communicate the UPDATE constraint)
+            when :destroy, :destroy! then 'CASCADE'
+            when :set_nil            then 'SET NULL'
+            end
+
+          return false if constraint_type.nil?
+
+          source_keys = relationship.source_key.map { |p| property_to_column_name(p, false) }
+          target_keys = relationship.target_key.map { |p| property_to_column_name(p, false) }
+
+          create_constraints_statement = create_constraints_statement(
+            constraint_name,
+            constraint_type,
+            source_storage_name,
+            source_keys,
+            target_storage_name,
+            target_keys
+          )
+
+          execute(create_constraints_statement)
+        end
+
+        ##
+        # Remove the constraint for a relationship
+        #
+        # @param relationship [Relationship]
+        #   the relationship to remove the constraint for
+        #
+        # @return [true, false]
+        #   true if destroying the constraint was successful
+        #
+        # @api semipublic
+        def destroy_relationship_constraint(relationship)
+          return false unless valid_relationship_for_constraint?(relationship)
+
+          storage_name    = relationship.source_model.storage_name(name)
+          constraint_name = constraint_name(storage_name, relationship.name)
+
+          return false unless constraint_exists?(storage_name, constraint_name)
+
+          destroy_constraints_statement =
+            destroy_constraints_statement(storage_name, constraint_name)
+
+          execute(destroy_constraints_statement)
+        end
+
+        ##
+        # Check to see if the relationship's constraints can be used
+        #
+        # Only one-to-one, one-to-many, and many-to-many relationships
+        # can be used for constraints.  They must also be in the same
+        # repository as the adapter is connected to.
+        #
+        # @param relationship [Relationship]
+        #   the relationship to check
+        #
+        # @return [true, false]
+        #   true if a constraint can be established for relationship
+        #
+        # @api private
+        private def valid_relationship_for_constraint?(relationship)
+          return false unless relationship.source_repository_name == name || relationship.source_repository_name.nil?
+          return false unless relationship.target_repository_name == name || relationship.target_repository_name.nil?
+          return false unless relationship.is_a?(Associations::ManyToOne::Relationship)
+
+          true
+        end
+
+        module SQL
+          # Generates the SQL statement to create a constraint
+          #
+          # @param [String] constraint_name
+          #   name of the foreign key constraint
+          # @param [String] constraint_type
+          #   type of constraint to ALTER source_storage_name with
+          # @param [String] source_storage_name
+          #   name of table to ALTER with constraint
+          # @param [Array(String)] source_keys
+          #   columns in source_storage_name that refer to foreign table
+          # @param [String] target_storage_name
+          #   target table of the constraint
+          # @param [Array(String)] target_keys
+          #   columns the target table that are referred to
+          #
+          # @return [String]
+          #   SQL DDL Statement to create a constraint
+          #
+          # @api private
+          private def create_constraints_statement(constraint_name, constraint_type, source_storage_name, source_keys, target_storage_name, target_keys)
+            DataMapper::Ext::String.compress_lines(<<-SQL)
+              ALTER TABLE #{quote_name(source_storage_name)}
+              ADD CONSTRAINT #{quote_name(constraint_name)}
+              FOREIGN KEY (#{source_keys.join(', ')})
+              REFERENCES #{quote_name(target_storage_name)} (#{target_keys.join(', ')})
+              ON DELETE #{constraint_type}
+              ON UPDATE #{constraint_type}
+            SQL
+          end
+
+          ##
+          # Generates the SQL statement to destroy a constraint
+          #
+          # @param [String] storage_name
+          #   name of table to constrain
+          # @param [String] constraint_name
+          #   name of foreign key constraint
+          #
+          # @return [String]
+          #   SQL DDL Statement to destroy a constraint
+          #
+          # @api private
+          private def destroy_constraints_statement(storage_name, constraint_name)
+            DataMapper::Ext::String.compress_lines(<<-SQL)
+              ALTER TABLE #{quote_name(storage_name)}
+              DROP CONSTRAINT #{quote_name(constraint_name)}
+            SQL
+          end
+
+          ##
+          # generates a unique constraint name given a table and a relationships
+          #
+          # @param [String] storage_name
+          #   name of table to constrain
+          # @param [String] relationship_name
+          #   name of the relationship to constrain
+          #
+          # @return [String]
+          #   name of the constraint
+          #
+          # @api private
+          private def constraint_name(storage_name, relationship_name)
+            identifier = "#{storage_name}_#{relationship_name}"[0, self.class::IDENTIFIER_MAX_LENGTH - 3]
+            "#{identifier}_fk"
+          end
+        end
+
+        include SQL
+      end
+    end
+  end
+end

data/lib/data_mapper/constraints/adapters/extension.rb

@@ -0,0 +1,45 @@
+module DataMapper
+  module Constraints
+    module Adapters
+      module Extension
+        # Include the corresponding Constraints module into a adapter class
+        #
+        # @param [Symbol] const_name
+        #   demodulized name of the adapter class to include corresponding
+        #   constraints module into
+        #
+        # TODO: come up with a better way to include modules
+        # into all currently loaded and subsequently loaded Adapters
+        #
+        # @api private
+        def include_constraint_api(const_name)
+          require constraint_extensions(const_name)
+
+          if Constraints::Adapters.const_defined?(const_name)
+            adapter = const_get(const_name)
+            constraint_module = Constraints::Adapters.const_get(const_name)
+            adapter.class_eval { include constraint_module }
+          end
+        rescue LoadError
+          # Silently ignore the fact that no adapter extensions could be required
+          # This means that the adapter in use doesn't support constraints
+        end
+
+        # @api private
+        private def constraint_extensions(const_name)
+          name = adapter_name(const_name)
+          name = 'do' if name == 'dataobjects'
+          "data_mapper/constraints/adapters/#{name}_adapter"
+        end
+
+        # @api private
+        private def const_added(const_name)
+          include_constraint_api(const_name)
+          super
+        end
+      end
+    end
+  end
+
+  Adapters.extend Constraints::Adapters::Extension
+end

data/lib/data_mapper/constraints/adapters/mysql_adapter.rb

@@ -0,0 +1,26 @@
+require 'data_mapper/constraints/adapters/do_adapter'
+
+module DataMapper
+  module Constraints
+    module Adapters
+      module MysqlAdapter
+        include SQL, DataObjectsAdapter
+
+        module SQL
+          ##
+          # MySQL specific query to drop a foreign key
+          #
+          # @see DataMapper::Constraints::Adapters::DataObjectsAdapter#destroy_constraints_statement
+          #
+          # @api private
+          private def destroy_constraints_statement(storage_name, constraint_name)
+            DataMapper::Ext::String.compress_lines(<<-SQL)
+              ALTER TABLE #{quote_name(storage_name)}
+              DROP FOREIGN KEY #{quote_name(constraint_name)}
+            SQL
+          end
+        end
+      end
+    end
+  end
+end

data/lib/data_mapper/constraints/adapters/oracle_adapter.rb

@@ -0,0 +1,53 @@
+require 'data_mapper/constraints/adapters/do_adapter'
+
+module DataMapper
+  module Constraints
+    module Adapters
+      module OracleAdapter
+        include DataObjectsAdapter
+
+        # oracle does not provide the information_schema table
+        # To question internal state like postgres or mysql
+        #
+        # @see DataMapper::Constraints::Adapters::DataObjectsAdapter
+        #
+        # @api private
+        def constraint_exists?(storage_name, constraint_name)
+          statement = DataMapper::Ext::String.compress_lines(<<-SQL)
+            SELECT COUNT(*)
+            FROM USER_CONSTRAINTS
+            WHERE table_name = ?
+            AND constraint_name = ?
+          SQL
+
+          select(statement, oracle_upcase(storage_name)[0, self.class::IDENTIFIER_MAX_LENGTH].gsub('"', '_'), oracle_upcase(constraint_name)[0, self.class::IDENTIFIER_MAX_LENGTH].gsub('"', '_')).first > 0
+        end
+
+        # @see DataMapper::Constraints::Adapters::DataObjectsAdapter#create_constraints_statement
+        #
+        # @api private
+        #
+        # TODO: is it desirable to always set `INITIALLY DEFERRED DEFERRABLE`?
+        def create_constraints_statement(constraint_name, constraint_type, source_storage_name, source_keys, target_storage_name, target_keys)
+          DataMapper::Ext::String.compress_lines(<<-SQL)
+            ALTER TABLE #{quote_name(source_storage_name)}
+            ADD CONSTRAINT #{quote_name(constraint_name)}
+            FOREIGN KEY (#{source_keys.join(', ')})
+            REFERENCES #{quote_name(target_storage_name)} (#{target_keys.join(', ')})
+            #{"ON DELETE #{constraint_type}" if constraint_type && constraint_type != 'NO ACTION'}
+            INITIALLY DEFERRED DEFERRABLE
+          SQL
+        end
+
+        # @api private
+        def destroy_constraints_statement(storage_name, constraint_name)
+          DataMapper::Ext::String.compress_lines(<<-SQL)
+            ALTER TABLE #{quote_name(storage_name)}
+            DROP CONSTRAINT #{quote_name(constraint_name)}
+            CASCADE
+          SQL
+        end
+      end
+    end
+  end
+end

data/lib/data_mapper/constraints/adapters/postgres_adapter.rb

@@ -0,0 +1,13 @@
+require 'data_mapper/constraints/adapters/do_adapter'
+
+module DataMapper
+  module Constraints
+    module Adapters
+
+      module PostgresAdapter
+        include DataObjectsAdapter
+      end
+
+    end
+  end
+end

data/lib/data_mapper/constraints/adapters/sqlite_adapter.rb

@@ -0,0 +1,22 @@
+module DataMapper
+  module Constraints
+    module Adapters
+      module SqliteAdapter
+        # @api private
+        def constraint_exists?(*)
+          false
+        end
+
+        # @api private
+        def create_relationship_constraint(*)
+          false
+        end
+
+        # @api private
+        def destroy_relationship_constraint(*)
+          false
+        end
+      end
+    end
+  end
+end

data/lib/data_mapper/constraints/adapters/sqlserver_adapter.rb

@@ -0,0 +1,11 @@
+require 'data_mapper/constraints/adapters/do_adapter'
+
+module DataMapper
+  module Constraints
+    module Adapters
+      module SqlserverAdapter
+        include DataObjectsAdapter
+      end
+    end
+  end
+end

data/lib/data_mapper/constraints/migrations/model.rb

@@ -0,0 +1,34 @@
+# TODO: figure out some other (less tightly coupled) way to ensure that
+# dm-migrations' method implementations are loaded before this file
+require 'dm-migrations/auto_migration'
+
+module DataMapper
+  module Constraints
+    module Migrations
+      module Model
+        # @api private
+        def auto_migrate_constraints_up(repository_name = self.repository_name)
+          # TODO: this check should not be here
+          return if respond_to?(:is_remixable?) && is_remixable?
+
+          relationships(repository_name).each do |relationship|
+            relationship.auto_migrate_constraints_up(repository_name)
+          end
+        end
+
+        # @api private
+        def auto_migrate_constraints_down(repository_name = self.repository_name)
+          return unless storage_exists?(repository_name)
+          # TODO: this check should not be here
+          return if respond_to?(:is_remixable?) && is_remixable?
+
+          relationships(repository_name).each do |relationship|
+            relationship.auto_migrate_constraints_down(repository_name)
+          end
+        end
+      end
+    end
+  end
+
+  Model.append_extensions Constraints::Migrations::Model
+end

data/lib/data_mapper/constraints/migrations/relationship.rb

@@ -0,0 +1,41 @@
+module DataMapper
+  module Constraints
+    module Migrations
+      module Relationship
+        # @api private
+        def auto_migrate_constraints_up(_repository_name)
+          # no-op
+        end
+
+        # @api private
+        def auto_migrate_constraints_down(_repository_name)
+          # no-op
+        end
+
+        module ManyToOne
+          # @api private
+          def auto_migrate_constraints_up(repository_name)
+            adapter = DataMapper.repository(repository_name)&.adapter
+            adapter&.create_relationship_constraint(self)
+            self
+          end
+
+          # @api private
+          def auto_migrate_constraints_down(repository_name)
+            adapter = DataMapper.repository(repository_name)&.adapter
+            adapter&.destroy_relationship_constraint(self)
+            self
+          end
+        end
+      end
+    end
+  end
+
+  Associations::Relationship.class_eval do
+    include Constraints::Migrations::Relationship
+  end
+
+  Associations::ManyToOne::Relationship.class_eval do
+    include Constraints::Migrations::Relationship::ManyToOne
+  end
+end

data/lib/data_mapper/constraints/migrations/singleton_methods.rb

@@ -0,0 +1,44 @@
+module DataMapper
+  module Constraints
+    module Migrations
+      module SingletonMethods
+        def auto_migrate!(repository_name = nil)
+          auto_migrate_constraints_down(repository_name)
+          # TODO: Model#auto_migrate! drops and adds constraints, as well.
+          #   is that an avoidable duplication?
+          super
+          auto_migrate_constraints_up(repository_name)
+          self
+        end
+
+        private def auto_migrate_down!(repository_name = nil)
+          auto_migrate_constraints_down(repository_name)
+          super
+          self
+        end
+
+        private def auto_migrate_up!(repository_name = nil)
+          super
+          auto_migrate_constraints_up(repository_name)
+          self
+        end
+
+        # @api private
+        private def auto_migrate_constraints_up(repository_name = nil)
+          DataMapper::Model.descendants.each do |model|
+            model.auto_migrate_constraints_up(repository_name || model.default_repository_name)
+          end
+        end
+
+        # @api private
+        private def auto_migrate_constraints_down(repository_name = nil)
+          DataMapper::Model.descendants.each do |model|
+            model.auto_migrate_constraints_down(repository_name || model.default_repository_name)
+          end
+        end
+      end
+    end
+  end
+
+  extend Constraints::Migrations::SingletonMethods
+end

data/lib/data_mapper/constraints/relationship/many_to_many.rb

@@ -0,0 +1,48 @@
+require 'data_mapper/constraints/relationship/one_to_many'
+
+module DataMapper
+  module Constraints
+    module Relationship
+      module ManyToMany
+
+        private def one_to_many_options
+          super.merge(constraint: @constraint)
+        end
+
+        # Checks that the constraint type is appropriate to the relationship
+        #
+        # @param [Fixnum] cardinality
+        #   cardinality of relationship
+        # @param [Symbol] name
+        #   name of relationship to evaluate constraint of
+        # @param [Hash] options
+        #   options hash
+        #
+        # @option *args :constraint[Symbol]
+        #   one of VALID_CONSTRAINT_VALUES
+        #
+        # @raise ArgumentError
+        #   if @option :constraint is not one of VALID_CONSTRAINT_TYPES
+        #
+        # @return [Undefined]
+        #
+        # @api private
+        private def assert_valid_constraint
+          super
+
+          # TODO: is any constraint valid for a m:m relationship?
+          return unless @constraint == :set_nil
+
+          raise ArgumentError, "#{@constraint} is not a valid constraint type for #{self.class}"
+        end
+
+      end
+    end
+  end
+
+  Associations::ManyToMany::Relationship::OPTIONS << :constraint
+
+  Associations::ManyToMany::Relationship.class_eval do
+    include Constraints::Relationship::ManyToMany
+  end
+end

data/lib/data_mapper/constraints/relationship/one_to_many.rb

@@ -0,0 +1,79 @@
+module DataMapper
+  module Constraints
+    module Relationship
+      module OneToMany
+        attr_reader :constraint
+
+        # @api private
+        def enforce_destroy_constraint(resource)
+          return true unless (association = get(resource))
+
+          constraint = self.constraint
+
+          case constraint
+          when :protect
+            Array(association).empty?
+          when :destroy, :destroy!
+            association.__send__(constraint)
+          when :set_nil
+            Array(association).all? do |r|
+              r.update(inverse => nil)
+            end
+          when :skip
+            true # do nothing
+          end
+        end
+
+        ##
+        # Adds the delete constraint options to a relationship
+        #
+        # @param args [*args] Arguments passed to Relationship#initialize
+        #
+        # @return [nil]
+        #
+        # @api private
+        private def initialize(*args)
+          super
+          set_constraint
+          assert_valid_constraint
+        end
+
+        private def set_constraint
+          @constraint = @options.fetch(:constraint, :protect) || :skip
+        end
+
+        # Checks that the constraint type is appropriate to the relationship
+        #
+        # @param [Fixnum] cardinality
+        #   cardinality of relationship
+        # @param [Symbol] name
+        #   name of relationship to evaluate constraint of
+        # @param [Hash] options
+        #   options hash
+        #
+        # @option *args :constraint[Symbol]
+        #   one of VALID_CONSTRAINT_VALUES
+        #
+        # @raise ArgumentError
+        #   if @option :constraint is not one of VALID_CONSTRAINT_VALUES
+        #
+        # @return [Undefined]
+        #
+        # @api semipublic
+        private def assert_valid_constraint
+          return unless @constraint
+
+          return if VALID_CONSTRAINT_VALUES.include?(@constraint)
+
+          raise ArgumentError, ":constraint option must be one of #{VALID_CONSTRAINT_VALUES.to_a.join(', ')}"
+        end
+      end
+    end
+  end
+
+  Associations::OneToMany::Relationship::OPTIONS << :constraint
+
+  Associations::OneToMany::Relationship.class_eval do
+    include Constraints::Relationship::OneToMany
+  end
+end

data/lib/data_mapper/constraints/resource.rb

@@ -0,0 +1,30 @@
+module DataMapper
+  module Constraints
+    module Resource
+      def before_destroy_hook
+        enforce_destroy_constraints
+        super
+      end
+
+      # Check delete constraints prior to destroying a dm resource or collection
+      #
+      # @note
+      #   - It only considers a relationship's constraints if this is the parent model (ie a child shouldn't delete a parent)
+      #   - Many to Many Relationships are skipped, as they are evaluated by their underlying 1:M relationships
+      #
+      # @return [nil]
+      #
+      # @api semi-public
+      private def enforce_destroy_constraints
+        relationships.each do |relationship|
+          next unless relationship.respond_to?(:enforce_destroy_constraint)
+
+          constraint_satisfied = relationship.enforce_destroy_constraint(self)
+
+          throw(:halt, false) unless constraint_satisfied
+        end
+      end
+    end
+  end
+  Model.append_inclusions Constraints::Resource
+end

data/lib/data_mapper/constraints/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Constraints
+    VERSION = '1.3.0.beta'.freeze
+  end
+end