schema_plus_foreign_keys 0.1.0

data/lib/schema_plus/foreign_keys/active_record/base.rb

@@ -0,0 +1,33 @@
+module SchemaPlus::ForeignKeys
+  module ActiveRecord
+
+    #
+    # SchemaPlus::ForeignKeys adds several methods to ActiveRecord::Base
+    #
+    module Base
+      module ClassMethods #:nodoc:
+
+        public
+
+        # Returns a list of ForeignKeyDefinition objects, for each foreign
+        # key constraint defined in this model's table
+        #
+        # (memoized result gets reset in Middleware::Model::ResetColumnInformation)
+        def foreign_keys
+          @foreign_keys ||= connection.foreign_keys(table_name, "#{name} Foreign Keys")
+        end
+
+        def reset_foreign_key_information
+          @foreign_keys = @reverse_foreign_keys = nil
+        end
+
+        # Returns a list of ForeignKeyDefinition objects, for each foreign
+        # key constraint of other tables that refer to this model's table
+        def reverse_foreign_keys
+          @reverse_foreign_keys ||= connection.reverse_foreign_keys(table_name, "#{name} Reverse Foreign Keys")
+        end
+
+      end
+    end
+  end
+end

data/lib/schema_plus/foreign_keys/active_record/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,168 @@
+module SchemaPlus::ForeignKeys
+  module ActiveRecord
+    # SchemaPlus::ForeignKeys adds several methods to the connection adapter (as returned by ActiveRecordBase#connection).  See AbstractAdapter for details.
+    module ConnectionAdapters
+
+      #
+      # SchemaPlus::ForeignKeys adds several methods to
+      # ActiveRecord::ConnectionAdapters::AbstractAdapter.  In most cases
+      # you don't call these directly, but rather the methods that define
+      # things are called by schema statements, and methods that query
+      # things are called by ActiveRecord::Base.
+      #
+      module AbstractAdapter
+
+        # Define a foreign key constraint.  Valid options are :on_update,
+        # :on_delete, and :deferrable, with values as described at
+        # ConnectionAdapters::ForeignKeyDefinition
+        #
+        # (NOTE: Sqlite3 does not support altering a table to add foreign-key
+        # constraints; they must be included in the table specification when
+        # it's created.  If you're using Sqlite3, this method will raise an
+        # error.)
+        def add_foreign_key(*args) # (table_name, column, to_table, primary_key, options = {})
+          options = args.extract_options!
+          case args.length
+          when 2
+            from_table, to_table = args
+          when 4
+            ActiveSupport::Deprecation.warn "4-argument form of add_foreign_key is deprecated.  use add_foreign_key(from_table, to_table, options)"
+            (from_table, column, to_table, primary_key) = args
+            options.merge!(column: column, primary_key: primary_key)
+          end
+
+          options = options.dup
+          options[:column] ||= foreign_key_column_for(to_table)
+          options[:name]   ||= ForeignKeyDefinition.default_name(from_table, options[:column])
+
+          foreign_key_sql = add_foreign_key_sql(from_table, to_table, options)
+          execute "ALTER TABLE #{quote_table_name(from_table)} #{foreign_key_sql}"
+        end
+
+        # called directly by AT's bulk_change_table, for migration
+        # change_table :name, :bulk => true { ... }
+        def add_foreign_key_sql(from_table, to_table, options = {}) #:nodoc:
+          foreign_key = ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(from_table, AbstractAdapter.proper_table_name(to_table), options)
+          "ADD #{foreign_key.to_sql}"
+        end
+
+        def _build_foreign_key(from_table, to_table, options = {}) #:nodoc:
+          ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(from_table, AbstractAdapter.proper_table_name(to_table), options)
+        end
+
+        def self.proper_table_name(name)
+          proper_name = ::ActiveRecord::Migration.new.proper_table_name(name)
+        end
+
+        # Remove a foreign key constraint
+        #
+        # Arguments are the same as for add_foreign_key, or by name:
+        #
+        #    remove_foreign_key table_name, to_table, options
+        #    remove_foreign_key table_name, name: constraint_name
+        #
+        # (NOTE: Sqlite3 does not support altering a table to remove
+        # foreign-key constraints.  If you're using Sqlite3, this method will
+        # raise an error.)
+        def remove_foreign_key(*args)
+          from_table, to_table, options = normalize_remove_foreign_key_args(*args)
+          options[:column] ||= foreign_key_column_for(to_table)
+          if sql = remove_foreign_key_sql(from_table, to_table, options)
+            execute "ALTER TABLE #{quote_table_name(from_table)} #{sql}"
+          end
+        end
+
+        def normalize_remove_foreign_key_args(*args)
+          options = args.extract_options!
+          if options.has_key? :column_names
+            ActiveSupport::Deprecation.warn ":column_names option is deprecated, use :column"
+            options[:column] = options.delete(:column_names)
+          end
+          if options.has_key? :references_column_names
+            ActiveSupport::Deprecation.warn ":references_column_names option is deprecated, use :primary_key"
+            options[:primary_key] = options.delete(:references_column_names)
+          end
+          if options.has_key? :references_table_name
+            ActiveSupport::Deprecation.warn ":references_table_name option is deprecated, use :to_table"
+            options[:to_table] = options.delete(:references_table_name)
+          end
+          case args.length
+          when 1
+            from_table = args[0]
+          when 2
+            from_table, to_table = args
+          when 3, 4
+            ActiveSupport::Deprecation.warn "3- and 4-argument forms of remove_foreign_key are deprecated.  use add_foreign_key(from_table, to_table, options)"
+            (from_table, column, to_table, primary_key) = args
+            options.merge!(column: column, primary_key: primary_key)
+          else
+            raise ArgumentError, "Wrong number of arguments(#{args.length}) to remove_foreign_key"
+          end
+          to_table ||= options.delete(:to_table)
+          [from_table, to_table, options]
+        end
+
+        def get_foreign_key_name(from_table, to_table, options)
+          return options[:name] if options[:name]
+
+          fks = foreign_keys(from_table)
+          if fks.detect(&its.name == to_table)
+            ActiveSupport::Deprecation.warn "remove_foreign_key(table, name) is deprecated.  use remove_foreign_key(table, name: name)"
+            return to_table
+          end
+          test_fk = _build_foreign_key(from_table, to_table, options)
+          if fk = fks.detect { |fk| fk.match(test_fk) }
+            fk.name
+          else
+            raise "SchemaPlus::ForeignKeys: no foreign key constraint found on #{from_table.inspect} matching #{[to_table, options].inspect}" unless options[:if_exists]
+            nil
+          end
+        end
+
+        def remove_foreign_key_sql(from_table, to_table, options)
+          if foreign_key_name = get_foreign_key_name(from_table, to_table, options)
+            "DROP CONSTRAINT #{options[:if_exists] ? "IF EXISTS" : ""} #{foreign_key_name}"
+          end
+        end
+
+
+        # called from individual adpaters, after renaming table from old
+        # name to
+        def rename_foreign_keys(oldname, newname) #:nodoc:
+          foreign_keys(newname).each do |fk|
+            index = indexes(newname).find{|index| index.name == ForeignKeyDefinition.auto_index_name(oldname, fk.column)}
+            begin
+              remove_foreign_key(newname, name: fk.name)
+            rescue NotImplementedError
+              # sqlite3 can't remove foreign keys, so just skip it
+            end
+            # rename the index only when the fk constraint doesn't exist.
+            # mysql doesn't allow the rename (which is a delete & add)
+            # if the index is on a foreign key constraint
+            rename_index(newname, index.name, ForeignKeyDefinition.auto_index_name(newname, index.columns)) if index
+            begin
+              add_foreign_key(newname, fk.to_table, :column => fk.column, :primary_key => fk.primary_key, :name => fk.name.sub(/#{oldname}/, newname), :on_update => fk.on_update, :on_delete => fk.on_delete, :deferrable => fk.deferrable)
+            rescue NotImplementedError
+              # sqlite3 can't add foreign keys, so just skip it
+            end
+          end
+        end
+
+
+        #####################################################################
+        #
+        # The functions below here are abstract; each subclass should
+        # define them all. Defining them here only for reference.
+        #
+
+        # (abstract) Return the ForeignKeyDefinition objects for foreign key
+        # constraints defined on this table
+        def foreign_keys(table_name, name = nil) raise "Internal Error: Connection adapter didn't override abstract function"; [] end
+
+        # (abstract) Return the ForeignKeyDefinition objects for foreign key
+        # constraints defined on other tables that reference this table
+        def reverse_foreign_keys(table_name, name = nil) raise "Internal Error: Connection adapter didn't override abstract function"; [] end
+      end
+    end
+  end
+end

data/lib/schema_plus/foreign_keys/active_record/connection_adapters/foreign_key_definition.rb

@@ -0,0 +1,137 @@
+require 'active_record/connection_adapters/abstract/schema_definitions'
+
+module SchemaPlus::ForeignKeys
+  module ActiveRecord
+    module ConnectionAdapters
+      # Instances of this class are returned by the queries ActiveRecord::Base#foreign_keys and ActiveRecord::Base#reverse_foreign_keys (via AbstractAdapter#foreign_keys and AbstractAdapter#reverse_foreign_keys)
+      #
+      # The on_update and on_delete attributes can take on the following values:
+      #   :cascade
+      #   :restrict
+      #   :nullify
+      #   :set_default
+      #   :no_action
+      #
+      # The deferrable attribute can take on the following values:
+      #   true
+      #   :initially_deferred
+      module ForeignKeyDefinition
+
+        def column_names
+          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#column_names is deprecated, use Array.wrap(column)"
+          Array.wrap(column)
+        end
+
+        def references_column_names
+          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#references_column_names is deprecated, use Array.wrap(primary_key)"
+          Array.wrap(primary_key)
+        end
+
+        def references_table_name
+          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#references_table_name is deprecated, use #to_table"
+          to_table
+        end
+
+        def table_name
+          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#table_name is deprecated, use #from_table"
+          from_table
+        end
+
+        ACTIONS = { :cascade => "CASCADE", :restrict => "RESTRICT", :nullify => "SET NULL", :set_default => "SET DEFAULT", :no_action => "NO ACTION" }.freeze
+        ACTION_LOOKUP = ACTIONS.invert.freeze
+
+        def initialize(from_table, to_table, options={})
+          [:on_update, :on_delete].each do |key|
+            if options[key] == :set_null
+              ActiveSupport::Deprecation.warn ":set_null value for #{key} is deprecated.  use :nullify instead"
+              options[key] = :nullify
+            end
+          end
+
+          super from_table, to_table, options
+
+          if column.is_a?(Array) and column.length == 1
+            options[:column] = column[0]
+          end
+          if primary_key.is_a?(Array) and primary_key.length == 1
+            options[:primary_key] = primary_key[0]
+          end
+
+          ACTIONS.has_key?(on_update) or raise(ArgumentError, "invalid :on_update action: #{on_update.inspect}") if on_update
+          ACTIONS.has_key?(on_delete) or raise(ArgumentError, "invalid :on_delete action: #{on_delete.inspect}") if on_delete
+          if ::ActiveRecord::Base.connection.adapter_name =~ /^mysql/i
+            raise(NotImplementedError, "MySQL does not support ON UPDATE SET DEFAULT") if on_update == :set_default
+            raise(NotImplementedError, "MySQL does not support ON DELETE SET DEFAULT") if on_delete == :set_default
+          end
+        end
+
+        # Truthy if the constraint is deferrable
+        def deferrable
+          options[:deferrable]
+        end
+
+        # Dumps a definition of foreign key.
+        def to_dump(column: nil)
+          dump = case
+                 when column then "foreign_key: {references:"
+                 else "add_foreign_key #{from_table.inspect},"
+                 end
+          dump << " #{to_table.inspect}"
+
+          val_or_array = -> val { val.is_a?(Array) ? "[#{val.map(&:inspect).join(', ')}]" : val.inspect }
+
+          dump << ", column: #{val_or_array.call self.column}" unless column
+          dump << ", primary_key: #{val_or_array.call self.primary_key}" if custom_primary_key?
+          dump << ", name: #{name.inspect}" if name
+          dump << ", on_update: #{on_update.inspect}" if on_update
+          dump << ", on_delete: #{on_delete.inspect}" if on_delete
+          dump << ", deferrable: #{deferrable.inspect}" if deferrable
+          dump << "}" if column
+          dump
+        end
+
+        def to_sql
+          sql = name ? "CONSTRAINT #{name} " : ""
+          sql << "FOREIGN KEY (#{quoted_column_names.join(", ")}) REFERENCES #{quoted_to_table} (#{quoted_primary_keys.join(", ")})"
+          sql << " ON UPDATE #{ACTIONS[on_update]}" if on_update
+          sql << " ON DELETE #{ACTIONS[on_delete]}" if on_delete
+          sql << " DEFERRABLE" if deferrable
+          sql << " INITIALLY DEFERRED" if deferrable == :initially_deferred
+          sql
+        end
+
+        def quoted_column_names
+          Array(column).map { |name| ::ActiveRecord::Base.connection.quote_column_name(name) }
+        end
+
+        def quoted_primary_keys
+          Array(primary_key).map { |name| ::ActiveRecord::Base.connection.quote_column_name(name) }
+        end
+
+        def quoted_to_table
+          ::ActiveRecord::Base.connection.quote_table_name(to_table)
+        end
+
+        def self.default_name(from_table, column)
+          "fk_#{fixup_schema_name(from_table)}_#{Array.wrap(column).join('_and_')}"
+        end
+
+        def self.auto_index_name(from_table, column_name)
+          "fk__#{fixup_schema_name(from_table)}_#{Array.wrap(column_name).join('_and_')}"
+        end
+
+        def self.fixup_schema_name(table_name)
+          # replace . with _
+          table_name.to_s.gsub(/[.]/, '_')
+        end
+
+        def match(test)
+          return false unless from_table == test.from_table
+          [:to_table, :column].reject{ |attr| test.send(attr).blank? }.all? { |attr|
+            test.send(attr).to_s == self.send(attr).to_s
+          }
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/foreign_keys/active_record/connection_adapters/mysql2_adapter.rb

@@ -0,0 +1,126 @@
+module SchemaPlus::ForeignKeys
+  module ActiveRecord
+    module ConnectionAdapters
+      # SchemaPlus::ForeignKeys includes a MySQL implementation of the AbstractAdapter
+      # extensions.
+      module Mysql2Adapter
+
+        #:enddoc:
+
+        def remove_column(table_name, column_name, type=nil, options={})
+          foreign_keys(table_name).select { |foreign_key| Array.wrap(foreign_key.column).include?(column_name.to_s) }.each do |foreign_key|
+            remove_foreign_key(table_name, name: foreign_key.name)
+          end
+          super table_name, column_name, type, options
+        end
+
+        def rename_table(oldname, newname)
+          super
+          rename_foreign_keys(oldname, newname)
+        end
+
+        def remove_foreign_key(*args)
+          from_table, to_table, options = normalize_remove_foreign_key_args(*args)
+          if options[:if_exists]
+            foreign_key_name = get_foreign_key_name(from_table, to_table, options)
+            return if !foreign_key_name or not foreign_keys(from_table).detect{|fk| fk.name == foreign_key_name}
+          end
+          options.delete(:if_exists)
+          super from_table, to_table, options
+        end
+
+        def remove_foreign_key_sql(*args)
+          super.tap { |ret|
+            ret.sub!(/DROP CONSTRAINT/, 'DROP FOREIGN KEY') if ret
+          }
+        end
+
+        def foreign_keys(table_name, name = nil)
+          results = select_all("SHOW CREATE TABLE #{quote_table_name(table_name)}", name)
+
+          table_name = table_name.to_s
+          namespace_prefix = table_namespace_prefix(table_name)
+
+          foreign_keys = []
+
+          results.each do |result|
+            create_table_sql = result["Create Table"]
+            create_table_sql.lines.each do |line|
+              if line =~ /^  CONSTRAINT [`"](.+?)[`"] FOREIGN KEY \([`"](.+?)[`"]\) REFERENCES [`"](.+?)[`"] \((.+?)\)( ON DELETE (.+?))?( ON UPDATE (.+?))?,?$/
+                name = $1
+                columns = $2
+                to_table = $3
+                to_table = namespace_prefix + to_table if table_namespace_prefix(to_table).blank?
+                primary_keys = $4
+                on_update = $8
+                on_delete = $6
+                on_update = ForeignKeyDefinition::ACTION_LOOKUP[on_update] || :restrict
+                on_delete = ForeignKeyDefinition::ACTION_LOOKUP[on_delete] || :restrict
+
+                options = { :name => name,
+                            :on_delete => on_delete,
+                            :on_update => on_update,
+                            :column => columns.gsub('`', '').split(', '),
+                            :primary_key => primary_keys.gsub('`', '').split(', ')
+                }
+
+                foreign_keys << ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
+                  namespace_prefix + table_name,
+                  to_table,
+                  options)
+              end
+            end
+          end
+
+          foreign_keys
+        end
+
+        def reverse_foreign_keys(table_name, name = nil)
+          results = select_all(<<-SQL, name)
+        SELECT constraint_name, table_name, column_name, referenced_table_name, referenced_column_name
+          FROM information_schema.key_column_usage
+         WHERE table_schema = #{table_schema_sql(table_name)}
+           AND referenced_table_schema = table_schema
+         ORDER BY constraint_name, ordinal_position;
+          SQL
+
+          constraints = results.to_a.group_by do |r|
+            r.values_at('constraint_name', 'table_name', 'referenced_table_name')
+          end
+
+          from_table_constraints = constraints.select do |(_, _, to_table), _|
+            table_name_without_namespace(table_name).casecmp(to_table) == 0
+          end
+
+          from_table_constraints.map do |(constraint_name, from_table, to_table), columns|
+            from_table = table_namespace_prefix(from_table) + from_table
+            to_table = table_namespace_prefix(to_table) + to_table
+
+            options = {
+              :name => constraint_name,
+              :column => columns.map { |row| row['column_name'] },
+              :primary_key => columns.map { |row| row['referenced_column_name'] }
+            }
+
+            ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(from_table, to_table, options)
+          end
+        end
+
+        private
+
+        def table_namespace_prefix(table_name)
+          table_name.to_s =~ /(.*[.])/ ? $1 : ""
+        end
+
+        def table_schema_sql(table_name)
+          table_name.to_s =~ /(.*)[.]/ ? "'#{$1}'" : "SCHEMA()"
+        end
+
+        def table_name_without_namespace(table_name)
+          table_name.to_s.sub /.*[.]/, ''
+        end
+
+      end
+    end
+  end
+end