pg_saurus 2.1.1

data/lib/pg_saurus/connection_adapters/postgresql_adapter/extension_methods.rb

@@ -0,0 +1,124 @@
+# Provides methods to extend {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter}
+# to support extensions feature.
+module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::ExtensionMethods
+  # Default options for {#create_extension} method.
+  CREATE_EXTENSION_DEFAULTS = {
+      :if_not_exists => true,
+      :schema_name   => nil,
+      :version       => nil,
+      :old_version   => nil
+  }
+
+  # Default options for {#drop_extension} method.
+  DROP_EXTENSION_DEFAULTS = {
+      :if_exists => true,
+      :mode      => :restrict
+  }
+
+  # The modes which determine postgresql behavior on DROP EXTENSION operation.
+  #
+  # *:restrict* refuse to drop the extension if any objects depend on it
+  # *:cascade* automatically drop objects that depend on the extension
+  AVAILABLE_DROP_MODES = {
+      :restrict => 'RESTRICT',
+      :cascade  => 'CASCADE'
+  }
+
+  # @return [Boolean] if adapter supports postgresql extension manipulation
+  def supports_extensions?
+    true
+  end
+
+  # Execute SQL to load a postgresql extension module into the current database.
+  #
+  # @param [#to_s] extension_name Name of the extension module to load
+  # @param [Hash] options
+  # @option options [Boolean] :if_not_exists should the 'IF NOT EXISTS' clause be added
+  # @option options [#to_s,nil] :schema_name The name of the schema in which to install the extension's objects
+  # @option options [#to_s,nil] :version The version of the extension to install
+  # @option options [#to_s,nil] :old_version Alternative installation script name
+  #    that absorbs the existing objects into the extension, instead of creating new objects
+  def create_extension(extension_name, options = {})
+    options = CREATE_EXTENSION_DEFAULTS.merge(options.symbolize_keys)
+
+    sql = ['CREATE EXTENSION']
+    sql << 'IF NOT EXISTS'                   if options[:if_not_exists]
+    sql << %Q{"#{extension_name.to_s}"}
+    sql << "SCHEMA #{options[:schema_name]}" if options[:schema_name].present?
+    sql << "VERSION '#{options[:version]}'"  if options[:version].present?
+    sql << "FROM #{options[:old_version]}"   if options[:old_version].present?
+
+    sql = sql.join(' ')
+    execute(sql)
+  end
+
+  # Execute SQL to remove a postgresql extension module from the current database.
+  #
+  # @param [#to_s] extension_name Name of the extension module to unload
+  # @param [Hash] options
+  # @option options [Boolean] :if_exists should the 'IF EXISTS' clause be added
+  # @option options [Symbol] :mode Operation mode. See {AVAILABLE_DROP_MODES} for details
+  def drop_extension(extension_name, options = {})
+    options = DROP_EXTENSION_DEFAULTS.merge(options.symbolize_keys)
+
+    sql = ['DROP EXTENSION']
+    sql << 'IF EXISTS' if options[:if_exists]
+    sql << %Q{"#{extension_name.to_s}"}
+
+    mode = options[:mode]
+    if mode.present?
+      mode = mode.to_sym
+
+      unless AVAILABLE_DROP_MODES.include?(mode)
+        raise ArgumentError,
+              "Expected one of #{AVAILABLE_DROP_MODES.keys.inspect} drop modes, " \
+              "but #{mode} received"
+      end
+
+      sql << AVAILABLE_DROP_MODES[mode]
+    end
+
+    sql = sql.join(' ')
+    execute(sql)
+  end
+
+  # Query the pg_catalog for all extension modules loaded to the current database.
+  #
+  # @note
+  #   Since Rails 4 connection has method +extensions+ that returns array of extensions.
+  #   This method is slightly different, since it returns also additional options.
+  #
+  # Please note all extensions which belong to pg_catalog schema are omitted
+  # ===Example
+  #
+  #   extension # => {
+  #     "fuzzystrmatch" => {:schema_name => "public", :version => "1.0" }
+  #   }
+  #
+  # @return [Hash{String => Hash{Symbol => String}}] A list of loaded extensions with their options
+  def pg_extensions
+    # Check postgresql version to not break on Postgresql < 9.1 during schema dump
+    pg_version_str = select_value('SELECT version()')
+    return {} unless pg_version_str =~ /^PostgreSQL (\d+\.\d+.\d+)/ && ($1 >= '9.1')
+
+    sql = <<-SQL
+      SELECT pge.extname AS ext_name, pgn.nspname AS schema_name, pge.extversion AS ext_version
+      FROM pg_extension pge
+      INNER JOIN pg_namespace pgn on pge.extnamespace = pgn.oid
+      WHERE pgn.nspname <> 'pg_catalog'
+    SQL
+
+    result = select_all(sql)
+    formatted_result = result.map do |row|
+      [
+          row['ext_name'],
+          {
+              :schema_name => row['schema_name'],
+              :version => row['ext_version']
+          }
+      ]
+    end
+
+    Hash[formatted_result]
+  end
+end

data/lib/pg_saurus/connection_adapters/postgresql_adapter/foreigner_methods.rb

@@ -0,0 +1,221 @@
+module PgSaurus # :nodoc:
+  # Provides methods to extend {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter}
+  # to support foreign keys feature.
+  module ConnectionAdapters::PostgreSQLAdapter::ForeignerMethods
+    def supports_foreign_keys?
+      true
+    end
+
+    # Fetch information about foreign keys related to the passed table.
+    # @param [String, Symbol] table_name name of table (e.g. "users", "music.bands")
+    # @return [Foreigner::ConnectionAdapters::ForeignKeyDefinition]
+    def foreign_keys(table_name)
+      relation, schema = table_name.to_s.split('.', 2).reverse
+      quoted_schema = schema ? "'#{schema}'" : "ANY (current_schemas(false))"
+
+      fk_info = select_all <<-SQL
+        SELECT nsp.nspname || '.' || t2.relname AS to_table,
+               a1.attname    AS column     ,
+               a2.attname    AS primary_key,
+               c.conname     AS name       ,
+               c.confdeltype AS dependency
+        FROM pg_constraint c
+        JOIN pg_class t1      ON c.conrelid     = t1.oid
+        JOIN pg_class t2      ON c.confrelid    = t2.oid
+        JOIN pg_attribute a1  ON a1.attnum      = c.conkey[1]  AND a1.attrelid = t1.oid
+        JOIN pg_attribute a2  ON a2.attnum      = c.confkey[1] AND a2.attrelid = t2.oid
+        JOIN pg_namespace t3  ON c.connamespace = t3.oid
+        JOIN pg_namespace nsp ON nsp.oid        = t2.relnamespace
+        WHERE c.contype = 'f'
+        AND t1.relname = '#{relation}'
+        AND t3.nspname = #{quoted_schema}
+        ORDER BY c.conname
+      SQL
+
+      fk_info.map do |row|
+        options = { :column      => row['column'],
+                    :name        => row['name'],
+                    :primary_key => row['primary_key'] }
+
+        options[:dependent] =
+          case row['dependency']
+          when 'c' then :delete
+          when 'n' then :nullify
+          when 'r' then :restrict
+          end
+
+        PgSaurus::ConnectionAdapters::ForeignKeyDefinition.new(table_name, row['to_table'], options)
+      end
+    end
+
+    # Drop table and optionally disable triggers.
+    # Changes adapted from https://github.com/matthuhiggins/foreigner/blob/e72ab9c454c156056d3f037d55e3359cd972af32/lib/foreigner/connection_adapters/sql2003.rb
+    # NOTE: Disabling referential integrity requires superuser access in postgres.
+    #       Default AR behavior is just to drop_table.
+    #
+    # == Options:
+    # * :force - force disabling of referential integrity
+    #
+    # Note: I don't know a good way to test this -mike 20120420
+    def drop_table(*args)
+      options = args.clone.extract_options!
+      if options[:force]
+        disable_referential_integrity { super }
+      else
+        super
+      end
+    end
+
+    # Add foreign key.
+    #
+    # Ensures that an index is created for the foreign key, unless :exclude_index is true.
+    #
+    # == Options:
+    # * :column
+    # * :primary_key
+    # * :dependent
+    # * :exclude_index    [Boolean]
+    # * :concurrent_index [Boolean]
+    #
+    # @param [String, Symbol]          from_table
+    # @param [String, Symbol]          to_table
+    # @param [Hash]                    options
+    # @option options [String, Symbol] :column
+    # @option options [String, Symbol] :primary_key
+    # @option options [Hash]           :dependent
+    # @option options [Boolean]        :exclude_index
+    # @option options [Boolean]        :concurrent_index
+    #
+    # @raise [PgSaurus::IndexExistsError] when :exclude_index is true, but the index already exists
+    def add_foreign_key(from_table, to_table, options = {})
+      options[:column]             ||= id_column_name_from_table_name(to_table)
+      options[:exclude_index]      ||= false
+
+      if index_exists?(from_table, options[:column]) && !options[:exclude_index]
+        raise PgSaurus::IndexExistsError,
+          "The index, #{index_name(from_table, options[:column])}, already exists." \
+          "  Use :exclude_index => true when adding the foreign key."
+      end
+
+      sql = "ALTER TABLE #{quote_table_name(from_table)} #{add_foreign_key_sql(from_table, to_table, options)}"
+      execute(sql)
+
+      # GOTCHA:
+      #   Index can not be created concurrently inside transaction in PostgreSQL.
+      #   So, in case of concurrently created index with foreign key only
+      #   foreign key will be created inside migration transaction and after
+      #   closing transaction queries for index creation will be send to database.
+      #   That's why I prevent here normal index creation in case of
+      #   `concurrent_index` option is given.
+      #   NOTE: Index creation after closing migration transaction could lead
+      #   to weird effects when transaction moves smoothly, but index
+      #   creation with error. In that case transaction will not be rolled back.
+      #   As it was closed before even index was attempted to create.
+      #   -- zekefast 2012-09-12
+      unless options[:exclude_index] || options[:concurrent_index]
+        add_index(from_table, options[:column])
+      end
+    end
+
+    # Return the SQL code fragment to add the foreign key based on the table names and options.
+    def add_foreign_key_sql(from_table, to_table, options = {})
+      column           = options[:column]
+      options_options  = options[:options]
+      foreign_key_name = foreign_key_name(from_table, column, options)
+      primary_key      = options[:primary_key] || "id"
+      dependency       = dependency_sql(options[:dependent])
+
+      sql =
+        "ADD CONSTRAINT #{quote_column_name(foreign_key_name)} " +
+        "FOREIGN KEY (#{quote_column_name(column)}) " +
+        "REFERENCES #{quote_table_name(ActiveRecord::Migrator.proper_table_name(to_table))}(#{primary_key})"
+      sql << " #{dependency}"      if dependency.present?
+      sql << " #{options_options}" if options_options
+
+      sql
+    end
+
+    #
+    # TODO Determine if we can refactor the method signature
+    #   remove_foreign_key(from_table, to_table_or_options_hash, options={}) => remove_foreign_key(from_table, to_table, options={})
+    #
+    # Remove the foreign key.
+    # @param [String, Symbol] from_table
+    # @param [String, Hash] to_table_or_options_hash
+    #
+    # The flexible method signature allows calls of two principal forms. Examples:
+    #
+    #   remove_foreign_key(from_table, options_hash)
+    #
+    # or:
+    #
+    #   remove_foreign_key(from_table, to_table, options_hash)
+    #
+    def remove_foreign_key(from_table, to_table_or_options_hash, options={})
+      if Hash === to_table_or_options_hash
+        options          =   to_table_or_options_hash
+        column           =   options[:column]
+        foreign_key_name =   foreign_key_name(from_table, column, options)
+        column           ||= id_column_name_from_foreign_key_metadata(from_table, foreign_key_name)
+      else
+        column           =   id_column_name_from_table_name(to_table_or_options_hash)
+        foreign_key_name =   foreign_key_name(from_table, column)
+      end
+
+      execute "ALTER TABLE #{quote_table_name(from_table)} #{remove_foreign_key_sql(foreign_key_name)}"
+
+      options[:exclude_index] ||= false
+      unless options[:exclude_index] || !index_exists?(from_table, column) then
+        remove_index(from_table, column)
+      end
+    end
+
+    # Return the SQL code fragment to remove foreign key based on table name and options.
+    def remove_foreign_key_sql(foreign_key_name)
+      "DROP CONSTRAINT #{quote_column_name(foreign_key_name)}"
+    end
+
+    # Build the foreign key column id from the referenced table.
+    def id_column_name_from_table_name(table)
+      "#{table.to_s.split('.').last.singularize}_id"
+    end
+
+    # Extract the foreign key column id from the foreign key metadata.
+    # @param [String, Symbol] from_table
+    # @param [String]         foreign_key_name
+    def id_column_name_from_foreign_key_metadata(from_table, foreign_key_name)
+      keys     = foreign_keys(from_table)
+      this_key = keys.find {|key| key.options[:name] == foreign_key_name}
+      this_key.options[:column]
+    end
+    private :id_column_name_from_foreign_key_metadata
+
+    # Build default name for constraint.
+    def foreign_key_name(table, column, options = {})
+      name = options[:name]
+
+      if !name.nil? then
+        name
+      else
+        prefix = table.gsub(".", "_")
+        "#{prefix}_#{column}_fk"
+      end
+    end
+    private :foreign_key_name
+
+    # Get the SQL code fragment that represents dependency for a constraint.
+    #
+    # @param dependency [Symbol] :nullify, :delete or :restrict
+    #
+    # @return [String]
+    def dependency_sql(dependency)
+      case dependency
+        when :nullify  then "ON DELETE SET NULL"
+        when :delete   then "ON DELETE CASCADE"
+        when :restrict then "ON DELETE RESTRICT"
+        else ""
+      end
+    end
+    private :dependency_sql
+  end
+end

data/lib/pg_saurus/connection_adapters/postgresql_adapter/index_methods.rb

@@ -0,0 +1,42 @@
+# Provides methods to extend {ActiveRecord::ConnectionAdapters::SchemaStatements}
+# to support index features.
+module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::IndexMethods
+  def supports_partial_index?
+    true
+  end
+
+  # Overrides ActiveRecord::ConnectionAdapters::SchemaStatements.index_name
+  # to support schema notation.  Converts dots in index name to underscores.
+  #
+  # === Example
+  #  add_index 'demography.citizens', :country_id
+  #  # produces
+  #  CREATE INDEX "index_demography_citizens_on_country_id" ON "demography"."citizens" ("country_id")
+  #  # instead of
+  #  CREATE INDEX "index_demography.citizens_on_country_id" ON "demography"."citizens" ("country_id")
+  #
+  def index_name(table_name, options) #:nodoc:
+    super.gsub('.','_')
+  end
+
+  # Overrides ActiveRecord::ConnectionAdapters::SchemaStatements.index_name_for_remove
+  # to support schema notation. Prepends the schema name to the index name.
+  #
+  # === Example
+  #  drop_index 'demography.citizens', :country_id
+  #  # produces
+  #  DROP INDEX "demography"."index_demography_citizens_on_country_id"
+  #  # instead of
+  #  DROP INDEX "index_demography_citizens_on_country_id"
+  #
+  def index_name_for_remove(table_name, options = {})
+    index_name = super
+
+    if table_name.include?('.') # schema notation
+      schema = table_name.split('.').first
+      "#{schema}.#{index_name}"
+    else
+      index_name
+    end
+  end
+end

data/lib/pg_saurus/connection_adapters/postgresql_adapter/schema_methods.rb

@@ -0,0 +1,58 @@
+# Provides methods to extend {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter}
+# to support schemas feature.
+module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::SchemaMethods
+  # Creates new schema in DB.
+  # @param [String] schema_name
+  def create_schema(schema_name)
+    ::PgSaurus::Tools.create_schema(schema_name)
+  end
+
+  # Drops schema in DB.
+  # @param [String] schema_name
+  def drop_schema(schema_name)
+    ::PgSaurus::Tools.drop_schema(schema_name)
+  end
+
+  # Move table to another schema
+  # @param [String] table table name. Can be with schema prefix e.g. "demography.people"
+  # @param [String] schema schema where table should be moved to.
+  def move_table_to_schema(table, schema)
+    ::PgSaurus::Tools.move_table_to_schema(table, schema)
+  end
+
+  # Create schema if it does not exist yet.
+  #
+  # @param schema_name [String]
+  def create_schema_if_not_exists(schema_name)
+    ::PgSaurus::Tools.create_schema_if_not_exists(schema_name)
+  end
+
+  # Drop schema if it exists.
+  #
+  # @param schema_name [String]
+  def drop_schema_if_exists(schema_name)
+    ::PgSaurus::Tools.drop_schema_if_exists(schema_name)
+  end
+
+  # Make method +tables+ return tables not only from public schema.
+  #
+  # @note
+  #   Tables from public schema have no "public." prefix. It's done for
+  #   compatibility with other libraries that relies on a table name.
+  #   Tables from other schemas has appropriate prefix with schema name.
+  #   See: https://github.com/TMXCredit/pg_power/pull/42
+  #
+  # @return [Array<String>] table names
+  def tables_with_non_public_schema_tables(*args)
+    public_tables = tables_without_non_public_schema_tables(*args)
+
+    non_public_tables =
+      query(<<-SQL, 'SCHEMA').map { |row| row[0] }
+        SELECT schemaname || '.' || tablename AS table
+        FROM pg_tables
+        WHERE schemaname NOT IN ('pg_catalog', 'information_schema', 'public')
+      SQL
+
+    public_tables + non_public_tables
+  end
+end

data/lib/pg_saurus/connection_adapters/postgresql_adapter/translate_exception.rb

@@ -0,0 +1,20 @@
+# Extend ActiveRecord::ConnectionAdapter::PostgreSQLAdapter logic
+# to wrap more pg-specific errors into specific exception classes
+module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::TranslateException
+  # # See http://www.postgresql.org/docs/9.1/static/errcodes-appendix.html
+  INSUFFICIENT_PRIVILEGE = "42501"
+
+  # Intercept insufficient privilege PGError and raise active_record wrapped database exception
+  def translate_exception(exception, message)
+    exception_result = exception.result
+
+    case exception_result.try(:error_field, PGresult::PG_DIAG_SQLSTATE)
+    when INSUFFICIENT_PRIVILEGE
+      exc_message = exception_result.try(:error_field, PGresult::PG_DIAG_MESSAGE_PRIMARY)
+      exc_message ||= message
+      ::ActiveRecord::InsufficientPrivilege.new(exc_message, exception)
+    else
+      super
+    end
+  end
+end

data/lib/pg_saurus/connection_adapters/postgresql_adapter/view_methods.rb

@@ -0,0 +1,17 @@
+# Provides methods to extend {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter}
+# to support views feature.
+module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::ViewMethods
+  # Creates new view in DB.
+  # @param [String, Symbol] view_name
+  # @param [String] view_definition
+  def create_view(view_name, view_definition)
+    ::PgSaurus::Tools.create_view(view_name, view_definition)
+  end
+
+  # Drops view in DB.
+  # @param [String, Symbol] view_name
+  def drop_view(view_name)
+    ::PgSaurus::Tools.drop_view(view_name)
+  end
+
+end

data/lib/pg_saurus/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,28 @@
+# Provides methods to extend {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter}
+# to support pg_saurus features.
+module PgSaurus::ConnectionAdapters::PostgreSQLAdapter
+  extend ActiveSupport::Autoload
+  extend ActiveSupport::Concern
+
+  # TODO: Looks like explicit path specification can be omitted -- aignatyev 20120904
+  autoload :ExtensionMethods,   'pg_saurus/connection_adapters/postgresql_adapter/extension_methods'
+  autoload :SchemaMethods,      'pg_saurus/connection_adapters/postgresql_adapter/schema_methods'
+  autoload :CommentMethods,     'pg_saurus/connection_adapters/postgresql_adapter/comment_methods'
+  autoload :ForeignerMethods,   'pg_saurus/connection_adapters/postgresql_adapter/foreigner_methods'
+  autoload :IndexMethods,       'pg_saurus/connection_adapters/postgresql_adapter/index_methods'
+  autoload :TranslateException, 'pg_saurus/connection_adapters/postgresql_adapter/translate_exception'
+  autoload :ViewMethods,        'pg_saurus/connection_adapters/postgresql_adapter/view_methods'
+
+  include ExtensionMethods
+  include SchemaMethods
+  include CommentMethods
+  include ForeignerMethods
+  include IndexMethods
+  include TranslateException
+  include ViewMethods
+
+  included do
+    alias_method_chain :tables, :non_public_schema_tables
+    alias_method_chain :add_index, :concurrently
+  end
+end

data/lib/pg_saurus/connection_adapters/table/comment_methods.rb

@@ -0,0 +1,58 @@
+# Provides methods to extend ActiveRecord::ConnectionAdapters::Table
+# to support comments feature.
+module PgSaurus::ConnectionAdapters::Table::CommentMethods
+  # Set the comment on the table.
+  #
+  # ===== Example
+  # ====== Set comment on table
+  #   t.set_table_comment 'This table stores phone numbers that conform to the North American Numbering Plan.'
+  def set_table_comment(comment)
+    @base.set_table_comment(@table_name, comment)
+  end
+
+  # Remove any comment from the table.
+  #
+  # ===== Example
+  # ====== Remove table comment
+  #   t.remove_table_comment
+  def remove_table_comment
+    @base.remove_table_comment(@table_name)
+  end
+
+  # Set the comment for a given column.
+  #
+  # ===== Example
+  # ====== Set comment on the npa column
+  #   t.set_column_comment :npa, 'Numbering Plan Area Code - Allowed ranges: [2-9] for first digit, [0-9] for second and third digit.'
+  def set_column_comment(column_name, comment)
+    @base.set_column_comment(@table_name, column_name, comment)
+  end
+
+  # Set comments on multiple columns. 'comments' is a hash of column_name => comment pairs.
+  #
+  # ===== Example
+  # ====== Setting comments on the columns of the phone_numbers table
+  #  t.set_column_comments :npa => 'Numbering Plan Area Code - Allowed ranges: [2-9] for first digit, [0-9] for second and third digit.',
+  #                        :nxx => 'Central Office Number'
+  def set_column_comments(comments)
+    @base.set_column_comments(@table_name, comments)
+  end
+
+  # Remove any comment for a given column.
+  #
+  # ===== Example
+  # ====== Remove comment from the npa column
+  #   t.remove_column_comment :npa
+  def remove_column_comment(column_name)
+    @base.remove_column_comment(@table_name, column_name)
+  end
+
+  # Remove any comments from the given columns.
+  #
+  # ===== Example
+  # ====== Remove comment from the npa and nxx columns
+  #   t.remove_column_comment :npa, :nxx
+  def remove_column_comments(*column_names)
+    @base.remove_column_comments(@table_name, *column_names)
+  end
+end

data/lib/pg_saurus/connection_adapters/table/foreigner_methods.rb

@@ -0,0 +1,51 @@
+# Provides methods to extend ActiveRecord::ConnectionAdapters::Table
+# to support foreign keys feature.
+module PgSaurus::ConnectionAdapters::Table::ForeignerMethods
+  # Adds a new foreign key to the table. +to_table+ can be a single Symbol, or
+  # an Array of Symbols. See SchemaStatements#add_foreign_key
+  #
+  # ===== Examples
+  # ====== Creating a simple foreign key
+  # t.foreign_key(:people)
+  # ====== Defining the column
+  # t.foreign_key(:people, :column => :sender_id)
+  # ====== Creating a named foreign key
+  # t.foreign_key(:people, :column => :sender_id, :name => 'sender_foreign_key')
+  # ====== Defining the column of the +to_table+.
+  # t.foreign_key(:people, :column => :sender_id, :primary_key => :person_id)
+  def foreign_key(to_table, options = {})
+    @base.add_foreign_key(@table_name, to_table, options)
+  end
+
+  # Remove the given foreign key from the table.
+  #
+  # ===== Examples
+  # ====== Remove the suppliers_company_id_fk in the suppliers table.
+  # change_table :suppliers do |t|
+  # t.remove_foreign_key :companies
+  # end
+  # ====== Remove the foreign key named accounts_branch_id_fk in the accounts table.
+  # change_table :accounts do |t|
+  # t.remove_foreign_key :column => :branch_id
+  # end
+  # ====== Remove the foreign key named party_foreign_key in the accounts table.
+  # change_table :accounts do |t|
+  # t.remove_index :name => :party_foreign_key
+  # end
+  def remove_foreign_key(options)
+    @base.remove_foreign_key(@table_name, options)
+  end
+
+  # Deprecated
+  def references_with_foreign_keys(*args)
+    options = args.extract_options!
+
+    if options.delete(:foreign_key)
+      p ActiveSupport::Deprecation.send(:deprecation_message, caller,
+        ":foreign_key in t.references is deprecated. " \
+        "Use t.foreign_key instead")
+    end
+
+    references_without_foreign_keys(*(args.dup << options))
+  end
+end

data/lib/pg_saurus/connection_adapters/table.rb

@@ -0,0 +1,17 @@
+# Provides methods to extend ActiveRecord::ConnectionAdapters::Table
+# to support pg_saurus features.
+module PgSaurus::ConnectionAdapters::Table
+  extend ActiveSupport::Autoload
+  extend ActiveSupport::Concern
+
+  autoload :CommentMethods
+  autoload :ForeignerMethods
+
+  include CommentMethods
+  include ForeignerMethods
+
+
+  included do
+    alias_method_chain :references, :foreign_keys
+  end
+end

data/lib/pg_saurus/connection_adapters.rb

@@ -0,0 +1,9 @@
+module PgSaurus::ConnectionAdapters # :nodoc:
+  extend ActiveSupport::Autoload
+
+  autoload :AbstractAdapter
+  autoload :PostgreSQLAdapter, 'pg_saurus/connection_adapters/postgresql_adapter'
+  autoload :Table
+  autoload :ForeignKeyDefinition
+  autoload :IndexDefinition, 'pg_saurus/connection_adapters/index_definition'
+end