schema_plus 0.1.0.pre1

data/lib/schema_plus/active_record/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,163 @@
+module SchemaPlus
+  module ActiveRecord
+    module ConnectionAdapters
+      # The Postgresql adapter implements the SchemaPlus extensions and
+      # enhancements
+      module PostgresqlAdapter
+
+        def self.included(base) #:nodoc:
+          base.class_eval do
+            remove_method :indexes
+          end
+        end
+
+        # SchemaPlus provides the following extra options for Postgres
+        # indexes:
+        # * +:conditions+ - SQL conditions for the WHERE clause of the index
+        # * +:expression+ - SQL expression to index.  column_name can be nil or ommitted, in which case :name must be provided
+        # * +:kind+ - index method for Postgresql to use
+        # * +:case_sensitive - if +false+ then the index will be created on LOWER(column_name)
+        #
+        # The <tt>:case_sensitive => false</tt> option ties in with Rails built-in support for case-insensitive searching:
+        #    validates_uniqueness_of :name, :case_sensitive => false
+        #
+        def add_index(table_name, column_name, options = {})
+          column_name, options = [], column_name if column_name.is_a?(Hash)
+          column_names = Array(column_name).compact
+          if column_names.empty?
+            raise ArgumentError, "No columns and :expression missing from options - cannot create index" if options[:expression].blank?
+            raise ArgumentError, "Index name not given. Pass :name option" if options[:name].blank?
+          end
+
+          index_type = options[:unique] ? "UNIQUE" : ""
+          index_name = options[:name] || index_name(table_name, column_names)
+          conditions = options[:conditions]
+
+          if options[:expression] then
+            sql = "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} #{options[:expression]}"
+          else
+            quoted_column_names = column_names.map { |e| options[:case_sensitive] == false && e.to_s !~ /_id$/ ? "LOWER(#{quote_column_name(e)})" : quote_column_name(e) }
+
+            sql = "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names.join(", ")})"
+            sql += " WHERE (#{ ::ActiveRecord::Base.send(:sanitize_sql, conditions, quote_table_name(table_name)) })" if conditions
+          end
+          execute sql
+        end
+
+        def supports_partial_indexes? #:nodoc:
+          true
+        end
+
+        def indexes(table_name, name = nil) #:nodoc:
+          schemas = schema_search_path.split(/,/).map { |p| quote(p) }.join(',')
+          result = query(<<-SQL, name)
+           SELECT distinct i.relname, d.indisunique, d.indkey, m.amname, t.oid, 
+                    pg_get_expr(d.indpred, t.oid), pg_get_expr(d.indexprs, t.oid)
+             FROM pg_class t, pg_class i, pg_index d, pg_am m
+           WHERE i.relkind = 'i'
+             AND i.relam = m.oid
+             AND d.indexrelid = i.oid
+             AND d.indisprimary = 'f'
+             AND t.oid = d.indrelid
+             AND t.relname = '#{table_name}'
+             AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname IN (#{schemas}) )
+          ORDER BY i.relname
+          SQL
+
+          result.map do |(index_name, is_unique, indkey, kind, oid, conditions, expression)|
+            unique = (is_unique == 't')
+            index_keys = indkey.split(" ")
+
+            columns = Hash[query(<<-SQL, "Columns for index #{index_name} on #{table_name}")]
+            SELECT a.attnum, a.attname
+            FROM pg_attribute a
+            WHERE a.attrelid = #{oid}
+            AND a.attnum IN (#{index_keys.join(",")})
+            SQL
+
+            column_names = columns.values_at(*index_keys).compact
+            if md = expression.try(:match, /^lower\(\(?([^)]+)\)?(::text)?\)$/i)
+              column_names << md[1]
+            end
+            ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, column_names,
+                                                                    :name => index_name,
+                                                                    :unique => unique,
+                                                                    :conditions => conditions,
+                                                                    :case_sensitive => !(expression =~ /lower/i),
+                                                                    :kind => kind.downcase == "btree" ? nil : kind,
+                                                                    :expression => expression)
+          end
+        end
+
+        def foreign_keys(table_name, name = nil) #:nodoc:
+          load_foreign_keys(<<-SQL, name)
+        SELECT f.conname, pg_get_constraintdef(f.oid), t.relname
+          FROM pg_class t, pg_constraint f
+         WHERE f.conrelid = t.oid
+           AND f.contype = 'f'
+           AND t.relname = '#{table_name}'
+          SQL
+        end
+
+        def reverse_foreign_keys(table_name, name = nil) #:nodoc:
+          load_foreign_keys(<<-SQL, name)
+        SELECT f.conname, pg_get_constraintdef(f.oid), t2.relname
+          FROM pg_class t, pg_class t2, pg_constraint f
+         WHERE f.confrelid = t.oid
+           AND f.conrelid = t2.oid
+           AND f.contype = 'f'
+           AND t.relname = '#{table_name}'
+          SQL
+        end
+
+        def views(name = nil) #:nodoc:
+          schemas = schema_search_path.split(/,/).map { |p| quote(p) }.join(',')
+          query(<<-SQL, name).map { |row| row[0] }
+        SELECT viewname
+          FROM pg_views
+         WHERE schemaname IN (#{schemas})
+          SQL
+        end
+
+        def view_definition(view_name, name = nil) #:nodoc:
+          result = query(<<-SQL, name)
+        SELECT pg_get_viewdef(oid)
+          FROM pg_class
+         WHERE relkind = 'v'
+           AND relname = '#{view_name}'
+          SQL
+          row = result.first
+          row.first.chomp(';') unless row.nil?
+        end
+
+        private
+
+        def load_foreign_keys(sql, name = nil) #:nodoc:
+          foreign_keys = []
+
+          query(sql, name).each do |row|
+            if row[1] =~ /^FOREIGN KEY \((.+?)\) REFERENCES (.+?)\((.+?)\)( ON UPDATE (.+?))?( ON DELETE (.+?))?( (DEFERRABLE|NOT DEFERRABLE))?$/
+              name = row[0]
+              from_table_name = row[2]
+              column_names = $1
+              references_table_name = $2
+              references_column_names = $3
+              on_update = $5
+              on_delete = $7
+              deferrable = $9 == "DEFERRABLE"
+              on_update = on_update ? on_update.downcase.gsub(' ', '_').to_sym : :no_action
+              on_delete = on_delete ? on_delete.downcase.gsub(' ', '_').to_sym : :no_action
+
+              foreign_keys << ForeignKeyDefinition.new(name,
+                                                       from_table_name, column_names.split(', '),
+                                                       references_table_name.sub(/^"(.*)"$/, '\1'), references_column_names.split(', '),
+                                                       on_update, on_delete, deferrable)
+            end
+          end
+
+          foreign_keys
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/active_record/connection_adapters/schema_statements.rb

@@ -0,0 +1,39 @@
+module SchemaPlus::ActiveRecord::ConnectionAdapters
+  module SchemaStatements
+
+    def self.included(base) #:nodoc:
+      base.class_eval do
+        alias_method_chain :create_table, :schema_plus
+      end
+    end
+
+    ##
+    # :method: create_table
+    #
+    # SchemaPlus extends SchemaStatements::create_table to allow you to specify configuration options per table.  Pass them in as a hash keyed by configuration set (see SchemaPlus::Config),
+    # for example:
+    #
+    #     create_table :widgets, :foreign_keys => {:auto_create => true, :on_delete => :cascade} do |t|
+    #        ...
+    #     end
+    def create_table_with_schema_plus(table, options = {})
+      options = options.dup
+      config_options = {}
+      options.keys.each { |key| config_options[key] = options.delete(key) if SchemaPlus.config.class.attributes.include? key }
+
+      indexes = []
+      create_table_without_schema_plus(table, options) do |table_definition|
+        table_definition.schema_plus_config = SchemaPlus.config.merge(config_options)
+        table_definition.name = table
+        yield table_definition if block_given?
+        indexes = table_definition.indexes
+      end
+      indexes.each do |index|
+        add_index(table, index.columns, index.opts)
+      end
+
+
+    end
+
+  end
+end

data/lib/schema_plus/active_record/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,78 @@
+module SchemaPlus
+  module ActiveRecord
+    module ConnectionAdapters
+      # SchemaPlus includes an Sqlite3 implementation of the AbstractAdapater
+      # extensions.  
+      module Sqlite3Adapter
+
+        # :enddoc:
+
+        def add_foreign_key(table_name, column_names, references_table_name, references_column_names, options = {})
+          raise NotImplementedError, "Sqlite3 does not support altering a table to add foreign key constraints (table #{table_name.inspect} column #{column_names.inspect})"
+        end
+
+        def remove_foreign_key(table_name, foreign_key_name)
+          raise NotImplementedError, "Sqlite3 does not support altering a table to remove foreign key constraints (table #{table_name.inspect} constraint #{foreign_key_name.inspect})"
+        end
+
+        def foreign_keys(table_name, name = nil)
+          get_foreign_keys(table_name, name)
+        end
+
+        def reverse_foreign_keys(table_name, name = nil)
+          get_foreign_keys(nil, name).select{|definition| definition.references_table_name == table_name}
+        end
+
+        def views(name = nil)
+          execute("SELECT name FROM sqlite_master WHERE type='view'", name).collect{|row| row["name"]}
+        end
+
+        def view_definition(view_name, name = nil)
+          sql = execute("SELECT sql FROM sqlite_master WHERE type='view' AND name=#{quote(view_name)}", name).collect{|row| row["sql"]}.first
+          sql.sub(/^CREATE VIEW \S* AS\s+/im, '') unless sql.nil?
+        end
+
+        protected
+
+        def post_initialize
+          execute('PRAGMA FOREIGN_KEYS = 1')
+        end
+
+        def get_foreign_keys(table_name = nil, name = nil)
+          results = execute(<<-SQL, name)
+            SELECT name, sql FROM sqlite_master
+            WHERE type='table' #{table_name && %" AND name='#{table_name}' "}
+          SQL
+
+          re = %r[
+            \bFOREIGN\s+KEY\s* \(\s*[`"](.+?)[`"]\s*\)
+            \s*REFERENCES\s*[`"](.+?)[`"]\s*\((.+?)\)
+            (\s+ON\s+UPDATE\s+(.+?))?
+            (\s*ON\s+DELETE\s+(.+?))?
+            \s*[,)]
+          ]x
+
+          foreign_keys = []
+          results.each do |row|
+            table_name = row["name"]
+            row["sql"].scan(re).each do |column_names, references_table_name, references_column_names, d1, on_update, d2, on_delete|
+              column_names = column_names.gsub('`', '').split(', ')
+
+              references_column_names = references_column_names.gsub('`"', '').split(', ')
+              on_update = on_update ? on_update.downcase.gsub(' ', '_').to_sym : :no_action
+              on_delete = on_delete ? on_delete.downcase.gsub(' ', '_').to_sym : :no_action
+              foreign_keys << ForeignKeyDefinition.new(nil,
+                                                       table_name, column_names,
+                                                       references_table_name, references_column_names,
+                                                       on_update, on_delete)
+            end
+          end
+
+          foreign_keys
+        end
+
+      end
+
+    end
+  end
+end

data/lib/schema_plus/active_record/connection_adapters/table_definition.rb

@@ -0,0 +1,130 @@
+module SchemaPlus::ActiveRecord::ConnectionAdapters
+
+  #
+  # SchemaPlus adds several methods to TableDefinition, allowing indexes
+  # and foreign key constraints to be defined within a
+  # <tt>create_table</tt> block of a migration, allowing for better
+  # encapsulation and more DRY definitions.
+  #
+  # For example, without SchemaPlus you might define a table like this:
+  #
+  #    create_table :widgets do |t|
+  #       t.string :name
+  #    end
+  #    add_index :widgets, :name
+  #
+  # But with SchemaPlus, the index can be defined within the create_table
+  # block, so you don't need to repeat the table name:
+  #
+  #    create_table :widgets do |t|
+  #       t.string :name
+  #       t.index :name
+  #    end
+  #
+  # Even more DRY, you can define the index as part of the column
+  # definition, via:
+  #
+  #   create_table :widgets do |t|
+  #      t.string :name, :index => true
+  #   end
+  #
+  # For details about the :index option (including unique and multi-column indexes), see the
+  # documentation for Migration::ClassMethods#add_column
+  #
+  # SchemaPlus also supports creation of foreign key constraints analogously, using Migration::ClassMethods#add_foreign_key or TableDefinition#foreign_key or as part of the column definition, for example:
+  #
+  #    create_table :posts do |t|  # not DRY
+  #       t.integer :author_id    
+  #    end
+  #    add_foreign_key :posts, :author_id, :references => :authors
+  #
+  #    create_table :posts do |t|  # DRYer
+  #       t.integer :author_id
+  #       t.foreign_key :author_id, :references => :authors
+  #    end
+  #
+  #    create_table :posts do |t|  # Dryest
+  #       t.integer :author_id, :references => :authors
+  #    end
+  #
+  # <b>NOTE:</b> In the standard configuration, SchemaPlus automatically
+  # creates foreign key constraints for columns whose names end in
+  # <tt>_id</tt>.  So the above examples are redundant, unless automatic
+  # creation was disabled at initialization in the global Config.
+  #
+  # Finally, the configuration for foreign keys can be overriden on a per-table
+  # basis by passing Config options to Migration::ClassMethods#create_table, such as
+  #
+  #      create_table :students, :foreign_keys => {:auto_create => false} do
+  #         t.integer :student_id
+  #      end
+  #
+  module TableDefinition
+
+    attr_accessor :schema_plus_config #:nodoc:
+
+    def self.included(base) #:nodoc:
+      base.class_eval do
+        attr_accessor :name
+        attr_accessor :indexes
+        alias_method_chain :initialize, :schema_plus
+        alias_method_chain :column, :schema_plus
+        alias_method_chain :primary_key, :schema_plus
+        alias_method_chain :to_sql, :schema_plus
+      end
+    end
+        
+    def initialize_with_schema_plus(*args) #:nodoc:
+      initialize_without_schema_plus(*args)
+      @foreign_keys = []
+      @indexes = []
+    end
+
+    def primary_key_with_schema_plus(name, options = {}) #:nodoc:
+      column(name, :primary_key, options)
+    end
+
+    def column_with_schema_plus(name, type, options = {}) #:nodoc:
+      column_without_schema_plus(name, type, options)
+      if references = ActiveRecord::Migration.get_references(self.name, name, options, schema_plus_config)
+        if index = options.fetch(:index, fk_use_auto_index?)
+          self.column_index(name, index)
+        end
+        foreign_key(name, references.first, references.last,
+                    options.reverse_merge(:on_update => schema_plus_config.foreign_keys.on_update,
+                                          :on_delete => schema_plus_config.foreign_keys.on_delete))
+      elsif options[:index]
+        self.column_index(name, options[:index])
+      end
+      self
+    end
+
+    def to_sql_with_schema_plus #:nodoc:
+      sql = to_sql_without_schema_plus
+      sql << ', ' << @foreign_keys.map(&:to_sql) * ', ' unless @foreign_keys.empty?
+      sql
+    end
+
+    # Define an index for the current 
+    def index(column_name, options={})
+      @indexes << ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(self.name, column_name, options)
+    end
+
+    def foreign_key(column_names, references_table_name, references_column_names, options = {})
+      @foreign_keys << ForeignKeyDefinition.new(options[:name], nil, column_names, ::ActiveRecord::Migrator.proper_table_name(references_table_name), references_column_names, options[:on_update], options[:on_delete], options[:deferrable])
+      self
+    end
+
+    protected
+    def column_index(name, options) #:nodoc:
+      options = {} if options == true
+      name = [name] + Array.wrap(options.delete(:with)).compact
+      self.index(name, options)
+    end
+
+    def fk_use_auto_index? #:nodoc:
+      schema_plus_config.foreign_keys.auto_index? && !ActiveRecord::Schema.defining?
+    end
+
+  end
+end

data/lib/schema_plus/active_record/migration.rb

@@ -0,0 +1,220 @@
+module SchemaPlus::ActiveRecord
+  # SchemaPlus extends ActiveRecord::Migration with several enhancements.  See documentation at Migration::ClassMethods
+  module Migration
+    def self.included(base) #:nodoc:
+      base.extend(ClassMethods)
+    end
+
+    #
+    # SchemaPlus extends ActiveRecord::Migration with the following enhancements.
+    #
+    module ClassMethods
+
+      # Create a new view, given its name and SQL definition
+      #
+      def create_view(view_name, definition)
+        connection.create_view(view_name, definition)
+      end
+
+      # Drop the named view
+      def drop_view(view_name)
+        connection.drop_view(view_name)
+      end
+
+      # 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(table_name, column_names, references_table_name, references_column_names, options = {})
+        connection.add_foreign_key(table_name, column_names, references_table_name, references_column_names, options)
+      end
+
+      # Remove a foreign key constraint
+      #
+      # (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(table_name, foreign_key_name)
+        connection.remove_foreign_key(table_name, foreign_key_name)
+      end
+      
+      # Enhances ActiveRecord::Migration#add_column to support indexes and foreign keys, with automatic creation
+      #
+      # == Indexes
+      #
+      # The <tt>:index</tt> option takes a hash of parameters to pass to ActiveRecord::Migration.add_index.  Thus
+      #
+      #    add_column('books', 'isbn', :string, :index => {:name => "ISBN-index", :unique => true })
+      # 
+      # is equivalent to:
+      #
+      #    add_column('books', 'isbn', :string)
+      #    add_index('books', ['isbn'], :name => "ISBN-index", :unique => true)
+      #
+      #
+      # In order to support multi-column indexes, an special parameter <tt>:with</tt> may be specified, which takes another column name or an array of column names to include in the index.  Thus
+      #
+      #    add_column('contacts', 'phone_number', :string, :index => { :with => [:country_code, :area_code], :unique => true })
+      # 
+      # is equivalent to:
+      #
+      #    add_column('contacts', 'phone_number', :string)
+      #    add_index('contacts', ['phone_number', 'country_code', 'area_code'], :unique => true)
+      #
+      #
+      # Some convenient shorthands are available:
+      #
+      #    add_column('books', 'isbn', :index => true) # adds index with no extra options
+      #    add_column('books', 'isbn', :index => :unique) # adds index with :unique => true
+      #
+      # == Foreign Key Constraints
+      #
+      # The +:references+ option takes the name of a table to reference in
+      # a foreign key constraint.  For example:
+      #
+      #    add_column('widgets', 'color', :integer, :references => 'colors')
+      #
+      # is equivalent to
+      #
+      #    add_column('widgets', 'color', :integer)
+      #    add_foreign_key('widgets', 'color', 'colors', 'id')
+      #
+      # The foreign column name defaults to +id+, but a different column
+      # can be specified using <tt>:references => [table_name,column_name]</tt>
+      #
+      # Additional options +:on_update+ and +:on_delete+ can be spcified,
+      # with values as described at ConnectionAdapters::ForeignKeyDefinition.  For example:
+      #
+      #     add_column('comments', 'post', :integer, :references => 'posts', :on_delete => :cascade)
+      #
+      # Global default values for +:on_update+ and +:on_delete+ can be
+      # specified in SchemaPlus.steup via, e.g., <tt>config.foreign_keys.on_update = :cascade</tt>
+      #
+      # == Automatic Foreign Key Constraints
+      #
+      # SchemaPlus supports the convention of naming foreign key columns
+      # with a suffix of +_id+.   That is, if you define a column suffixed
+      # with +_id+, SchemaPlus assumes an implied :references to a table
+      # whose name is the column name prefix, pluralized.  For example,
+      # these are equivalent:
+      #
+      #     add_column('posts', 'author_id', :integer)
+      #     add_column('posts', 'author_id', :integer, :references => 'authors')
+      #
+      # As a special case, if the column is named 'parent_id', SchemaPlus
+      # assumes it's a self reference, for a record that acts as a node of
+      # a tree.  Thus, these are equivalent:
+      #
+      #     add_column('sections', 'parent_id', :integer)
+      #     add_column('sections', 'parent_id', :integer, :references => 'sections')
+      #      
+      # If the implicit +:references+ value isn't what you want (e.g., the
+      # table name isn't pluralized), you can explicitly specify
+      # +:references+ and it will override the implicit value.
+      #
+      # If you don't want a foreign key constraint to be created, specify
+      # <tt>:references => nil</tt>.
+      # To disable automatic foreign key constraint creation globally, set
+      # <tt>config.foreign_keys.auto_create = false</tt> in
+      # SchemaPlus.steup.
+      #
+      # == Automatic Foreign Key Indexes
+      #
+      # Since efficient use of foreign key constraints requires that the
+      # referencing column be indexed, SchemaPlus will automatically create
+      # an index for the column if it created a foreign key.  Thus
+      #
+      #    add_column('widgets', 'color', :integer, :references => 'colors')
+      #
+      # is equivalent to:
+      #
+      #    add_column('widgets', 'color', :integer, :references => 'colors', :index => true)
+      #
+      # If you want to pass options to the index, you can explcitly pass
+      # index options, such as <tt>:index => :unique</tt>. 
+      #
+      # If you don't want an index to be created, specify
+      # <tt>:index => nil</tt>.
+      # To disable automatic foreign key index creation globally, set
+      # <tt>config.foreign_keys.auto_index = false</tt> in
+      # SchemaPlus.steup.  (*Note*: If you're using MySQL, it will
+      # automatically create an index for foreign keys if you don't.)
+      #
+      def add_column(table_name, column_name, type, options = {})
+        super
+        handle_column_options(table_name, column_name, options)
+      end
+
+      # Enhances ActiveRecord::Migration#change_column to support indexes and foreign keys same as add_column.
+      def change_column(table_name, column_name, type, options = {})
+        super
+        remove_foreign_key_if_exists(table_name, column_name)
+        handle_column_options(table_name, column_name, options)
+      end
+      
+      # Determines referenced table and column.
+      # Used in migrations.  
+      #
+      # If auto_create is true:
+      #   get_references('comments', 'post_id') # => ['posts', 'id']
+      #
+      # And if <tt>column_name</tt> is parent_id it references to the same table
+      #   get_references('pages', 'parent_id')  # => ['pages', 'id']
+      #
+      # If :references option is given, it is used (whether or not auto_create is true)
+      #   get_references('widgets', 'main_page_id', :references => 'pages')) 
+      #   # => ['pages', 'id']
+      #
+      # Also the referenced id column may be specified:
+      #   get_references('addresses', 'member_id', :references => ['users', 'uuid'])
+      #   # => ['users', 'uuid']
+      def get_references(table_name, column_name, options = {}, config=nil) #:nodoc:
+        column_name = column_name.to_s
+        if options.has_key?(:references)
+          references = options[:references]
+          references = [references, :id] unless references.nil? || references.is_a?(Array)
+          references
+        elsif (config || SchemaPlus.config).foreign_keys.auto_create? && !ActiveRecord::Schema.defining?
+          if column_name == 'parent_id'
+            [table_name, :id]
+          elsif column_name =~ /^(.*)_id$/
+            determined_table_name = ActiveRecord::Base.pluralize_table_names ? $1.to_s.pluralize : $1
+            [determined_table_name, :id]
+          end
+        end
+      end
+
+      protected
+      def handle_column_options(table_name, column_name, options) #:nodoc:
+        if references = get_references(table_name, column_name, options)
+          if index = options.fetch(:index, SchemaPlus.config.foreign_keys.auto_index? && !ActiveRecord::Schema.defining?)
+            column_index(table_name, column_name, index)
+          end
+          add_foreign_key(table_name, column_name, references.first, references.last,
+                          options.reverse_merge(:on_update => SchemaPlus.config.foreign_keys.on_update,
+                                                :on_delete => SchemaPlus.config.foreign_keys.on_delete))
+        elsif options[:index]
+          column_index(table_name, column_name, options[:index])
+        end
+      end
+
+      def column_index(table_name, column_name, options) #:nodoc:
+        options = {} if options == true
+        options = { :unique => true } if options == :unique
+        column_name = [column_name] + Array.wrap(options.delete(:with)).compact
+        add_index(table_name, column_name, options)
+      end
+
+      def remove_foreign_key_if_exists(table_name, column_name) #:nodoc:
+        foreign_keys = ActiveRecord::Base.connection.foreign_keys(table_name.to_s)
+        fk = foreign_keys.detect { |fk| fk.table_name == table_name.to_s && fk.column_names == Array(column_name).collect(&:to_s) }
+        remove_foreign_key(table_name, fk.name) if fk
+      end
+
+    end
+  end
+end