foreign_keys 1.2.0 → 2.0.0

data/README.markdown

@@ -1,73 +1,64 @@
-Foreign Keys Plugin
+Foreign Keys 
 ===================
 
-This plugin adds basic support for foreign keys, by providing some additional
-schema statements as well as integration into the standard schema dumper.
-
-Currently, mysql and postgresql connection adapters are supported.
+Add foreign key functionality for Rails migrations and schema dumps.
+MySQL and PostgreSQL adapters supported.
 
 Installation
 ------------
 
-Via standard git clone:
+As Rails gem (from GemCutter)
 
-    git clone git://github.com/dwalters/foreign_keys.git vendor/plugins/foreign_keys
+    sudo gem install foreign_keys
 
-Via rails plugin (requires 2.1):
+As Rails plugin
 
-    script/plugin install git://github.com/dwalters/foreign_keys.git
+    script/plugin install git://github.com/perfectline/foreign_keys.git
 
-Adding Foreign Keys
+Quickstart
 -------------------
 
-Just place the appropriate statements in your migrations.  The simplest example is:
-
-    add_foreign_key :orders, :user_id
-
-The usual rails conventions are used to deduce that this should result in a
-foreign key from the `orders.user_id` column to the `users.id` column
-
-Of course, you may specify these values explicitly too, and will need to when
-the conventions don't match exactly:
+Just place the FK statements in your migrations.  The simplest example is:
 
-    add_foreign_key :articles, :author_id, :references => :users
+    add_foreign_key :albums, :user_id
 
-Some other options of note:
+The referenced table and column are decidec by using rails conventions, i.e this
+example would result in a foreign key from 'albums.user_id' to 'users.id' column.
 
-* `references`: the name of the referenced table
-* `keys`: the corresponding column name(s) in the referenced table
-* `on_delete` / `on_update`: one of `:restrict`, `:set_null`, `:cascade`
-* `name`: the name to assign to the foreign key constraint
+You can additionally provide multiple options for cases where the association information cannot
+be decided by conventions.
 
-Note that recent mysql versions will create an index on the referenced
-column(s) if one does not already exist.
+    add_foreign_key :albums, :author_id, :references => :users, :keys => :user_id, :name => "my_special_fk"
 
-You may wish to check the documentation for further options.
+Removing foreign keys is just as easy.
+You can remove them either by providing the constraint name or column(s).
 
-Removing Foreign Keys
----------------------
+    remove_foreign_key :albums, :user_id
+    remove_foreign_key :albums, :name => "my_special_fk"
 
-You can remove foreign keys by name:
+Note: MySQL creates an index on the FK column automatically. Removing a FK will remove that index also.
 
-    remove_foreign_key :orders, :name => "index_orders_on_user_id"
-
-Or the name can be deduced if you used standard conventions when you created it:
-
-    remove_foreign_key :orders, :user_id
+Options
+-------------------
 
-This will not automatically remove any indexes.
+* **references**: name of the references table
+* **keys**: column name(s) on the references table
+* **on_delete**: on delete hook with a value of `:restrict`, `:set_null`, `:cascade`
+* **on_update**: on update hook with a value of `:restrict`, `:set_null`, `:cascade`
+* **name**: foreign key constraint name
 
 Schema Dump
------------
+---------------
 
 The usual rake targets for `db:schema:dump`, `db:schema:load`, and `db:reset`
 should all work as desired.
 
-Author
-------
-
-Dan Walters
+Authors
+---------------
 
-<http://github.com/dwalters/foreign_keys>
+**Tanel Suurhans** - tanel.suurhans_at_perfectline.ee
+**Tarmo Lehtpuu** - tarmo.lehtpuu_at_perfectline.ee
 
-Max Lapshin -- PostgreSQL support
+License
+--------------
+Copyright 2009 by PerfectLine LLC (<http://www.perfectline.co.uk>) and is released under the MIT license.

data/lib/foreign_keys/connection_adapters/abstract.rb

@@ -0,0 +1,54 @@
+module Perfectline
+  module ConnectionAdapters
+    module AbstractAdapter
+
+      # Adds a foreign key to given table.
+      # Columns can be a String or a Symbol, or an Array of either.
+      #
+      # The references tables and columns are decided using the usual Rails conventions.
+      # These can be explicitly overriden via +:references+ and/or +:keys+ options.
+      #
+      # Name of the FK can be specified via +:name+ option, if this is not provided, foreign_key_name method is used.
+      #
+      # You can also specify update and delete hooks with +:on_delete+ and +:on_update+ options.
+      # Valid values for these are +:restrict+, +:set_null+, +:cascade+.
+      #
+      # Examples:
+      # add_foreign_key :albums, :user_id
+      # add_foreign_key :albums, :author_id, :references => :users
+      # add_foreign_key :albums, [:first_name, :last_name], :references => :users, :keys => [:first_name, :last_name], :name => "composite_fk"
+      def add_foreign_key(table_name, columns, options = {})
+        name      = options.delete(:name) || foreign_key_name(table_name, Array(columns))
+        reference = options.delete(:references) || Array(columns).first.to_s.gsub(/_id$/, '').tableize
+        columns   = Array(columns).collect{ |column| quote_column_name(column) }.join(", ")
+        keys      = Array(options.delete(:keys) || :id).collect{ |key| quote_column_name(key) }.join(", ")
+
+        on_delete = options.delete(:on_delete)
+        on_update = options.delete(:on_update)
+
+        sql = "ALTER TABLE #{quote_table_name(table_name)} "
+        sql << "ADD CONSTRAINT #{quote_column_name(name)} "
+        sql << "FOREIGN KEY (#{columns}) REFERENCES #{quote_table_name(reference)} (#{keys})"
+        sql << " ON DELETE #{on_delete.to_s.gsub(/_/, " ")}" unless on_delete.nil?
+        sql << " ON UPDATE #{on_update.to_s.gsub(/_/, " ")}" unless on_update.nil?
+
+        execute(sql)
+      end
+
+      # Removes a foreign key from the table.
+      # Accepts either a column name Symbol/String or an Array of either (will use foreign_key_name method to generate the constraint name).
+      # Additionally you can provide the +:name+ option with the FK name.
+      #
+      # remove_foreign_key :albums, :name => "albums_user_id_fk"
+      # remove_foreign_key :albums, :user_id
+      def remove_foreign_key(table_name, *options)
+      end
+
+      # Generates a foreign key from given table name and columns
+      def foreign_key_name(table_name, columns)
+        "#{table_name}_#{Array(columns).map(&:to_s).join("_")}_fk"
+      end
+
+    end
+  end
+end

data/lib/foreign_keys/connection_adapters/mysql.rb

@@ -0,0 +1,43 @@
+module Perfectline
+  module ConnectionAdapters
+    module MysqlAdapter
+
+      def self.included(base)
+        base.__send__(:include, InstanceMethods)
+      end
+
+      module InstanceMethods
+
+        def remove_foreign_key(table_name, *args)
+          options = args.extract_options!
+          name = options.delete(:name) || foreign_key_name(table_name, args.first)
+
+          execute("ALTER TABLE #{quote_table_name(table_name)} DROP FOREIGN KEY #{quote_column_name(name)}")
+          execute("ALTER TABLE #{quote_table_name(table_name)} DROP KEY #{quote_column_name(name)}")
+        end
+
+        def foreign_keys(table_name)
+          sql = execute("SHOW CREATE TABLE #{quote_table_name(table_name)}").fetch_hash["Create Table"]
+
+          returning([]) do |fks|
+            sql.scan(/CONSTRAINT `(\w+)` FOREIGN KEY \((.*?)\) REFERENCES `(\w+)` \((.*?)\)(?:\s+ON DELETE\s+(.*?))?(?:\s+ON UPDATE\s+(.*?))?[,\)\n]/) do |name, cols, refs, keys, delete, update|
+
+              cols = returning([]){ |array| cols.scan(/`(\w+)`/) { |match| array << match.first.to_sym }}
+              keys = returning([]){ |array| keys.scan(/`(\w+)`/) { |match| array << match.first.to_sym }}
+
+              fks.push({
+                      :name       => name,
+                      :columns    => cols,
+                      :keys       => keys,
+                      :references => refs,                      
+                      :on_update  => update,
+                      :on_delete  => delete
+              })
+            end
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/foreign_keys/connection_adapters/postgresql.rb

@@ -0,0 +1,75 @@
+module Perfectline
+  module ConnectionAdapters
+    module PostgreSQLAdapter
+
+      def self.included(base)
+        base.__send__(:include, InstanceMethods)
+      end
+
+      module InstanceMethods
+
+        def remove_foreign_key(table_name, *args)
+          options = args.extract_options!
+          name = options.delete(:name) || foreign_key_name(table_name, args.first)
+
+          execute("ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{quote_column_name(name)}")
+        end
+
+        def foreign_keys(table_name)
+          sql = %Q{
+          SELECT t.constraint_name AS name,
+            k.table_name AS from_table,
+            k.column_name AS from_column,
+            c.table_name AS to_table,
+            c.column_name AS to_column,
+            r.update_rule AS update_rule,
+            r.delete_rule AS delete_rule
+          FROM
+            information_schema.table_constraints t,
+            information_schema.constraint_column_usage c,
+            information_schema.key_column_usage k,
+            information_schema.referential_constraints r
+          WHERE
+            t.constraint_name = c.constraint_name AND
+            k.constraint_name = c.constraint_name AND
+            r.constraint_name = c.constraint_name AND
+            t.constraint_type = 'FOREIGN KEY' AND
+            t.table_name = '#{table_name}'
+          }
+
+          foreign_keys = returning({}) do |foreign_keys|
+            select_all(sql).each do |row|
+              if foreign_keys.has_key?(row["name"])
+                foreign_keys[row["name"]][:columns] << row["from_column"]
+                foreign_keys[row["name"]][:keys]    << row["to_column"]
+              else
+                foreign_keys.store(row["name"], {
+                        :name       => row["name"],
+                        :columns    => [row["from_column"]],
+                        :references => row["to_table"],
+                        :keys       => [row["to_column"]],
+                        :on_update  => row["update_rule"],
+                        :on_delete  => row["delete_rule"]
+                })
+              end
+            end
+          end
+
+          foreign_keys.each_value do |value|
+            columns = Array(value[:columns]).uniq.compact
+            keys    = Array(value[:keys]).uniq.compact
+
+            value[:columns] = columns.size == 1 ? columns.first : columns
+            value[:keys]   = keys.size == 1 ? keys.first : keys
+
+            value.delete(:on_update) if value[:on_update] == "NO ACTION"
+            value.delete(:on_delete) if value[:on_delete] == "NO ACTION"
+          end
+
+          return foreign_keys.values.to_a
+        end
+
+      end
+    end
+  end
+end

data/lib/foreign_keys/schema_dumper.rb

@@ -1,33 +1,38 @@
-ActiveRecord::SchemaDumper.class_eval do
-  private
+module Perfectline
+  module SchemaDumper
 
-  def tables(stream)
-    table_names = @connection.tables.sort.reject do |tbl|
-      ['schema_migrations', 'schema_info', ignore_tables].flatten.any? do |ignored|
-        case ignored
-        when String; tbl == ignored
-        when Regexp; tbl =~ ignored
-        else
-          raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
+    def self.included(base)
+      base.__send__(:include, InstanceMethods)
+      base.__send__(:alias_method_chain, :tables, :foreign_keys)
+    end
+
+    module InstanceMethods
+      def tables_with_foreign_keys(stream)
+        tables_without_foreign_keys(stream)
+        @connection.tables.sort.each do |table|
+          foreign_keys(table, stream)
         end
       end
-    end
 
-    table_names.each { |tbl| table(tbl, stream) }
-    table_names.each { |tbl| foreign_keys(tbl, stream) } if @connection.respond_to?(:foreign_keys)
-  end
+      def foreign_keys(table_name, stream)
+        @connection.foreign_keys(table_name).each do |foreign_key|          
+          stream.print " add_foreign_key #{table_name.inspect}, #{foreign_key[:columns].inspect}"
+          if foreign_key[:references] && foreign_key[:references] != foreign_key[:columns].first.to_s.gsub(/_id$/, "").tableize
+            stream.print ", :references => #{foreign_key[:references].inspect}"
+          end
+          if foreign_key[:keys] && foreign_key[:keys] != ["id"]
+            stream.print ", :keys => #{foreign_key[:keys].inspect}"
+          end
+          if foreign_key[:name]
+            stream.print ", :name => #{foreign_key[:name].inspect}"
+          end
 
-  def foreign_keys(table, stream)
-    foreign_keys = @connection.foreign_keys(table).sort { |a, b| a[:columns] <=> b[:columns] }
-    foreign_keys.each do |foreign_key|
-      stream.print "  add_foreign_key #{table.inspect}, #{foreign_key[:columns].inspect}"
-      stream.print ", :references => #{foreign_key[:references].inspect}" if foreign_key[:references] && foreign_key[:references] != foreign_key[:columns].first.gsub(/_id$/, '').tableize
-      stream.print ", :keys => #{foreign_key[:keys].inspect}" if foreign_key[:keys] && foreign_key[:keys] != ["id"]
-      stream.print ", :name => #{foreign_key[:name].inspect}" if foreign_key[:name]
-      stream.print ", :on_delete => #{foreign_key[:on_delete].downcase.gsub(/ /, '_').to_sym.inspect}" if foreign_key[:on_delete]
-      stream.print ", :on_update => #{foreign_key[:on_update].downcase.gsub(/ /, '_').to_sym.inspect}" if foreign_key[:on_update]
-      stream.puts
+          stream.print ", :on_delete => #{foreign_key[:on_delete].downcase.gsub(/ /, '_').to_sym.inspect}" if foreign_key[:on_delete]
+          stream.print ", :on_update => #{foreign_key[:on_update].downcase.gsub(/ /, '_').to_sym.inspect}" if foreign_key[:on_update]
+          stream.puts
+        end
+      end
     end
-    stream.puts unless foreign_keys.empty?
+
   end
-end
+end

data/lib/foreign_keys.rb

@@ -1,4 +1,18 @@
-require 'foreign_keys/mysql_adapter' if defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter)
-require 'foreign_keys/postgresql_adapter' if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
-require 'foreign_keys/schema_dumper'
-require 'foreign_keys/schema_statements'
+require "foreign_keys/connection_adapters/abstract"
+require "foreign_keys/connection_adapters/mysql"
+require "foreign_keys/connection_adapters/postgresql"
+
+require "foreign_keys/schema_dumper"
+
+
+ActiveRecord::ConnectionAdapters::AbstractAdapter.__send__(:include, Perfectline::ConnectionAdapters::AbstractAdapter)
+
+if defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter)
+  ActiveRecord::ConnectionAdapters::MysqlAdapter.__send__(:include, Perfectline::ConnectionAdapters::MysqlAdapter)
+end
+
+if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.__send__(:include, Perfectline::ConnectionAdapters::PostgreSQLAdapter)
+end
+
+ActiveRecord::SchemaDumper.__send__(:include, Perfectline::SchemaDumper)

metadata

@@ -1,20 +1,23 @@
 --- !ruby/object:Gem::Specification 
 name: foreign_keys
 version: !ruby/object:Gem::Version 
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors: 
-- Dan Walters
+- Tanel Suurhans
+- Tarmo Lehtpuu
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-05-26 00:00:00 +03:00
+date: 2009-11-23 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
-description: Foreign key support plugin for Rails and MySQL, with schema dumper integration
+description: Foreign key support plugin for Rails, with schema dumper integration
 email: 
+- tanel.suurhans@perfectline.ee
+- tarmo.lehtpuu@perfectline.ee
 executables: []
 
 extensions: []
@@ -22,19 +25,15 @@ extensions: []
 extra_rdoc_files: 
 - README.markdown
 files: 
-- .gitignore
 - README.markdown
-- Rakefile
-- VERSION.yml
-- foreign_keys.gemspec
 - init.rb
 - lib/foreign_keys.rb
-- lib/foreign_keys/mysql_adapter.rb
-- lib/foreign_keys/postgresql_adapter.rb
+- lib/foreign_keys/connection_adapters/abstract.rb
+- lib/foreign_keys/connection_adapters/mysql.rb
+- lib/foreign_keys/connection_adapters/postgresql.rb
 - lib/foreign_keys/schema_dumper.rb
-- lib/foreign_keys/schema_statements.rb
 has_rdoc: true
-homepage: http://github.com/dwalters/foreign_keys/tree/master
+homepage: http://github.com/perfectline/foreign_keys/tree/master
 licenses: []
 
 post_install_message: 
@@ -60,6 +59,6 @@ rubyforge_project:
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: Foreign key sypport for Rails (MySQL, PostgreSQL)
+summary: Foreign key support for Rails
 test_files: []
 

data/.gitignore

@@ -1,3 +0,0 @@
-pkg
-rdoc
-.idea

data/Rakefile

@@ -1,28 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |jewel|
-    jewel.name = 'foreign_keys'
-    jewel.summary = 'Foreign key sypport for Rails (MySQL, PostgreSQL)'
-    jewel.homepage = 'http://github.com/dwalters/foreign_keys/tree/master'
-    jewel.description = 'Foreign key support plugin for Rails and MySQL, with schema dumper integration'
-    jewel.authors = ["Dan Walters"]
-  end
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end
-
-desc 'Default: run unit tests.'
-task :default => :rdoc
-
-desc 'Generate documentation for the smurf plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Foreign keys'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README.markdown')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/VERSION.yml

@@ -1,4 +0,0 @@
---- 
-:major: 1
-:minor: 2
-:patch: 0

data/foreign_keys.gemspec

@@ -1,42 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{foreign_keys}
-  s.version = "1.2.0"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Dan Walters"]
-  s.date = %q{2009-05-26}
-  s.description = %q{Foreign key support plugin for Rails and MySQL, with schema dumper integration}
-  s.extra_rdoc_files = [
-    "README.markdown"
-  ]
-  s.files = [
-    ".gitignore",
-     "README.markdown",
-     "Rakefile",
-     "VERSION.yml",
-     "foreign_keys.gemspec",
-     "init.rb",
-     "lib/foreign_keys.rb",
-     "lib/foreign_keys/mysql_adapter.rb",
-     "lib/foreign_keys/postgresql_adapter.rb",
-     "lib/foreign_keys/schema_dumper.rb",
-     "lib/foreign_keys/schema_statements.rb"
-  ]
-  s.homepage = %q{http://github.com/dwalters/foreign_keys/tree/master}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.3}
-  s.summary = %q{Foreign key sypport for Rails (MySQL, PostgreSQL)}
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
-end

data/lib/foreign_keys/mysql_adapter.rb

@@ -1,22 +0,0 @@
-ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
-  def foreign_keys(table_name)#:nodoc:
-    sql = execute("SHOW CREATE TABLE #{quote_table_name(table_name)}").fetch_hash["Create Table"]
-
-    foreign_keys = []
-    sql.scan(/CONSTRAINT `(\w+)` FOREIGN KEY \((.*?)\) REFERENCES `(\w+)` \((.*?)\)(?:\s+ON DELETE\s+(.*?))?(?:\s+ON UPDATE\s+(.*?))?[,\)\n]/) do |name, column_list, references, key_list, on_delete, on_update|
-      columns = []; column_list.scan(/`(\w+)`/) { |match| columns << match.first }
-      keys = []; key_list.scan(/`(\w+)`/) { |match| keys << match.first }
-
-      foreign_keys << {
-        :name => name,
-        :columns => columns,
-        :references => references,
-        :keys => keys,
-        :on_update => on_update,
-        :on_delete => on_delete
-      }
-    end
-
-    foreign_keys
-  end
-end

data/lib/foreign_keys/postgresql_adapter.rb

@@ -1,45 +0,0 @@
-ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
-  def foreign_keys(table_name)#:nodoc:
-    data = select_all(<<-EOF)
-    select t.constraint_name as name,
-            k.table_name as from_table,
-    	k.column_name as from_column,
-    	c.table_name as to_table,
-    	c.column_name as to_column,
-    	r.update_rule as update_rule,
-    	r.delete_rule as delete_rule
-    from information_schema.table_constraints t,
-         information_schema.constraint_column_usage c,
-         information_schema.key_column_usage k,
-         information_schema.referential_constraints r
-    where t.constraint_name = c.constraint_name and
-          k.constraint_name = c.constraint_name and
-          r.constraint_name = c.constraint_name and
-          t.constraint_type = 'FOREIGN KEY' and
-          t.table_name = '#{table_name}'
-    EOF
-
-    foreign_keys = data.inject({}) do |list, row|
-      if !list[row["name"]]
-        list[row["name"]] = {
-          :name => row["name"],
-          :columns => [row["from_column"]],
-          :references => row["to_table"],
-          :keys => [row["to_column"]],
-          :on_update => row["update_rule"],
-          :on_delete => row["delete_rule"]
-        }
-      else
-        list[row["name"]][:columns] << row["from_column"]
-        list[row["name"]][:keys] << row["to_column"]
-      end
-      list
-    end.map do |key, ref|
-      ref[:columns] = Array(ref[:columns]).uniq.compact.join(", ")
-      ref[:keys] = Array(ref[:keys]).uniq.compact.join(", ")
-      ref.delete(:on_update) if ref[:on_update] == "NO ACTION"
-      ref.delete(:on_delete) if ref[:on_delete] == "NO ACTION"
-      ref
-    end
-  end
-end

data/lib/foreign_keys/schema_statements.rb

@@ -1,70 +0,0 @@
-ActiveRecord::ConnectionAdapters::SchemaStatements.module_eval do
-  # Adds a new foreign key to a table.  +columns+ can be a single Symbol, or an
-  # array of Symbols, on which the key will be added.
-  #
-  # The referenced table name and columns are deduced using the usual conventions
-  # unless explicitly specified via +:references+ and/or +:keys+ options.
-  #
-  # The foreign key will be named using the same rules as #add_index, unless you
-  # pass +:name+ as an option.
-  #
-  # Options for +:on_delete+ and +:on_update+ may be specified.  Acceptable
-  # values are +:restrict+, +:set_null+, and +:cascade+.
-  #
-  # Note that some databases will automatically create an index on the constrained
-  # columns.
-  #
-  # ===== Examples
-  # ====== Creating a simple foreign key
-  #  add_foreign_key :orders, :user_id
-  # generates
-  #  ALTER TABLE orders ADD CONSTRAINT index_orders_on_user_id FOREIGN KEY (user_id) REFERENCES users (id)
-  # ====== Specifying the target table
-  #  add_foreign_key :articles, :author_id, :references => :users
-  # generates
-  #  ALTER TABLE articles ADD CONSTRAINT index_articles_on_author_id FOREIGN KEY (author_id) REFERENCES users (id)
-  # ====== Cascading deletes
-  #  add_foreign_key :comments, :post_id, :on_delete => :cascade
-  # generates
-  #  ALTER TABLE comments ADD CONSTRAINT index_comments_on_post_id FOREIGN KEY (post_id) REFERENCES posts (id) ON DELETE CASCADE
-  def add_foreign_key(table_name, columns, options = {})
-    columns = Array(columns)
-    name = options[:name] || index_name(table_name, :column => columns)
-    column_list = columns.collect { |column| quote_column_name(column) }.join(", ")
-    keys = Array(options[:keys] || :id)
-    key_list = keys.collect { |key| quote_column_name(key) }.join(", ")
-    references = if options[:references]
-      options[:references]
-    else
-      columns.first.to_s.gsub(/_id$/, '').tableize
-    end
-
-    sql = "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{quote_column_name(name)} FOREIGN KEY (#{column_list}) REFERENCES #{quote_table_name(references)} (#{key_list})"
-    sql << " ON DELETE #{options[:on_delete].to_s.gsub(/_/,' ')}" if options[:on_delete]
-    sql << " ON UPDATE #{options[:on_update].to_s.gsub(/_/,' ')}" if options[:on_update]
-    execute sql
-  end
-
-  # Remove the given foreign key from the table.  If +:name+ is specified, it will be used
-  # directly as the name of the key to delete.  Otherwise, the same conventions used
-  # when by #add_foreign_key may be provided.
-  #
-  # Any underlying indexes will not be automatically dropped.
-  #
-  # ===== Examples
-  # ====== Removing a foreign key by name
-  #  remove_foreign_key :orders, :name => "index_orders_on_user_id"
-  # ====== Removing a foreign key by column
-  #  remove_foreign_key :orders, :user_id
-  def remove_foreign_key(table_name, *args)
-    options = args.extract_options!
-    name = if options[:name]
-      options[:name]
-    else
-      columns = args.first
-      index_name(table_name, :column => Array(columns))
-    end
-
-    execute "ALTER TABLE #{quote_table_name(table_name)} DROP FOREIGN KEY #{quote_column_name(name)}"
-  end
-end