schema_plus 1.8.9 → 2.0.0.pre1

data/lib/schema_plus/active_record/base.rb

@@ -10,38 +10,21 @@ module SchemaPlus
       end
 
       module ClassMethods #:nodoc:
-        def self.extended(base) #:nodoc:
-          class << base
-            alias_method_chain :columns, :schema_plus
-            alias_method_chain :reset_column_information, :schema_plus
-          end
-        end
 
         public
 
-        def columns_with_schema_plus #:nodoc:
-          columns = columns_without_schema_plus
-          columns.each do |column| column.model = self end unless (@schema_plus_extended_columns ||= false)
-          columns
-        end
-
-        def reset_column_information_with_schema_plus #:nodoc:
-          reset_column_information_without_schema_plus
-          @indexes = @foreign_keys = @schema_plus_extended_columns = nil
-        end
-
-        # Returns a list of IndexDefinition objects, for each index
-        # defind on this model's table.
-        def indexes
-          @indexes ||= connection.indexes(table_name, "#{name} Indexes")
-        end
-
         # 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 = 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

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

@@ -11,59 +11,6 @@ module SchemaPlus
       # things are called by ActiveRecord::Base.
       #
       module AbstractAdapter
-        def self.included(base) #:nodoc:
-          base.alias_method_chain :initialize, :schema_plus
-          base.alias_method_chain :remove_index, :schema_plus
-        end
-
-        def initialize_with_schema_plus(*args) #:nodoc:
-          initialize_without_schema_plus(*args)
-          adapter = case adapter_name
-                      # name of MySQL adapter depends on mysql gem
-                      # * with mysql gem adapter is named MySQL
-                      # * with mysql2 gem adapter is named Mysql2
-                      # Here we handle this and hopefully futher adapter names
-                    when /^MySQL/i                 then 'MysqlAdapter'
-                    when 'PostgreSQL', 'PostGIS'   then 'PostgresqlAdapter'
-                    when 'SQLite'                  then 'Sqlite3Adapter'
-                    end
-          if adapter.nil?
-            unless adapter_name == 'JDBC' # ARJDBC
-              ::ActiveRecord::Base.logger.warn "SchemaPlus: Unsupported adapter name #{adapter_name.inspect}.  Leaving it alone."
-            end
-            return
-          end
-          adapter_module = SchemaPlus::ActiveRecord::ConnectionAdapters.const_get(adapter)
-          self.class.send(:include, adapter_module) unless self.class.include?(adapter_module)
-
-          if "#{::ActiveRecord::VERSION::MAJOR}.#{::ActiveRecord::VERSION::MINOR}".to_r >= "4.1".to_r
-            self.class.const_get(:SchemaCreation).send(:include, adapter_module.const_get(:AddColumnOptions))
-          else
-            self.class.send(:include, adapter_module.const_get(:AddColumnOptions))
-          end
-
-          extend(SchemaPlus::ActiveRecord::ForeignKeys)
-        end
-
-        # Create a view given the SQL definition.  Specify :force => true
-        # to first drop the view if it already exists.
-        def create_view(view_name, definition, options={})
-          definition = definition.to_sql if definition.respond_to? :to_sql
-          if options[:force]
-            drop_view(view_name, if_exists: true)
-          end
-          execute "CREATE VIEW #{quote_table_name(view_name)} AS #{definition}"
-        end
-
-        # Drop the named view.  Specify :if_exists => true
-        # to fail silently if the view doesn't exist.
-        def drop_view(view_name, options = {})
-          sql = "DROP VIEW"
-          sql += " IF EXISTS" if options[:if_exists]
-          sql += " #{quote_table_name(view_name)}"
-          execute sql
-        end
-
 
         # Define a foreign key constraint.  Valid options are :on_update,
         # :on_delete, and :deferrable, with values as described at
@@ -73,102 +20,118 @@ module SchemaPlus
         # 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 = {})
-          foreign_key_sql = add_foreign_key_sql(table_name, column_names, references_table_name, references_column_names, options)
-          execute "ALTER TABLE #{quote_table_name(table_name)} #{foreign_key_sql}"
+        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)
+
+          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(table_name, column_names, references_table_name, references_column_names, options = {}) #:nodoc:
-          foreign_key = _build_foreign_key(table_name, column_names, references_table_name, references_column_names, options)
+        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(table_name, column_names, references_table_name, references_column_names, options = {}) #:nodoc:
-          options.merge!(:column_names => column_names, :references_column_names => references_column_names)
-          options.reverse_merge!(:name => ForeignKeyDefinition.default_name(table_name, column_names))
-          ForeignKeyDefinition.new(table_name, AbstractAdapter.proper_table_name(references_table_name), options)
+        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)
-           if ::ActiveRecord::Migration.instance_methods(false).include? :proper_table_name
-           proper_name = ::ActiveRecord::Migration.new.proper_table_name(name) # Rails >= 4.1
-         else
-           proper_name = ::ActiveRecord::Migrator.proper_table_name(name) # Rails <= 4.0 ; Deprecated in 4.1
-         end
+          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, column_names, references_table_name, references_column_names
-        #    remove_foreign_key name: constraint_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(table_name, *args)
-          case sql = remove_foreign_key_sql(table_name, *args)
-          when String then execute "ALTER TABLE #{quote_table_name(table_name)} #{sql}"
+        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 remove_foreign_key_sql(table_name, *args)
-          column_names, references_table_name, references_column_names, options = args
-          options ||= {}
-          foreign_key_name = case
-                             when args.length == 1
-                               case args[0]
-                               when Hash then   args[0][:name]
-                               else args[0]
-                               end
-                             else
-                               test_fk = _build_foreign_key(table_name, column_names, references_table_name, references_column_names, options)
-                               if foreign_keys(table_name).detect { |fk| fk == test_fk }
-                                 test_fk.name
-                               else
-                                 raise "SchemaPlus: no foreign key constraint found on #{table_name.inspect} matching #{args.inspect}" unless options[:if_exists]
-                                 nil
-                               end
-                             end
-          foreign_key_name ? "DROP CONSTRAINT #{foreign_key_name}" : []  # hack -- return empty array rather than nil, so that result will disappear when caller flattens but doesn't compact
+        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
 
-        # Extends rails' drop_table to include these options:
-        #   :cascade
-        #   :if_exists
-        #
-        def drop_table(name, options = {})
-          sql = "DROP TABLE"
-          sql += " IF EXISTS" if options[:if_exists]
-          sql += " #{quote_table_name(name)}"
-          sql += " CASCADE" if options[:cascade]
-          execute sql
+        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: no foreign key constraint found on #{from_table.inspect} matching #{[to_table, options].inspect}" unless options[:if_exists]
+            nil
+          end
         end
 
-        # Extends rails' remove_index to include this options:
-        #   :if_exists
-        def remove_index_with_schema_plus(table_name, *args)
-          options = args.extract_options!
-          if_exists = options.delete(:if_exists)
-          options.delete(:column) if options[:name] and ::ActiveRecord::VERSION::MAJOR < 4
-          args << options if options.any?
-          return if if_exists and not index_name_exists?(table_name, options[:name] || index_name(table_name, *args), false)
-          remove_index_without_schema_plus(table_name, *args)
+        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_indexes_and_foreign_keys(oldname, newname) #:nodoc:
-          indexes(newname).select{|index| index.name == index_name(oldname, index.columns)}.each do |index|
-            rename_index(newname, index.name, index_name(newname, index.columns))
-          end
+        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_names)}
+            index = indexes(newname).find{|index| index.name == ForeignKeyDefinition.auto_index_name(oldname, fk.column)}
             begin
-              remove_foreign_key(newname, fk.name)
+              remove_foreign_key(newname, name: fk.name)
             rescue NotImplementedError
               # sqlite3 can't remove foreign keys, so just skip it
             end
@@ -177,69 +140,13 @@ module SchemaPlus
             # 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.column_names, fk.references_table_name, fk.references_column_names, :name => fk.name.sub(/#{oldname}/, newname), :on_update => fk.on_update, :on_delete => fk.on_delete, :deferrable => fk.deferrable)
+              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
 
-        # Returns true if the database supports parital indexes (abstract; only
-        # Postgresql returns true)
-        def supports_partial_indexes?
-          false
-        end
-
-        module AddColumnOptions
-          def self.included(base) #:nodoc:
-            base.alias_method_chain :add_column_options!, :schema_plus
-          end
-
-          def add_column_options_with_schema_plus!(sql, options)
-            if options_include_default?(options)
-              default = options[:default]
-
-              if default.is_a? Hash and [[:expr], [:value]].include?(default.keys)
-                value = default[:value]
-                expr = sql_for_function(default[:expr]) || default[:expr] if default[:expr]
-              else
-                value = default
-                expr = sql_for_function(default)
-              end
-
-              if expr
-                raise ArgumentError, "Invalid default expression" unless default_expr_valid?(expr)
-                sql << " DEFAULT #{expr}"
-                # must explicitly check for :null to allow change_column to work on migrations
-                if options[:null] == false
-                  sql << " NOT NULL"
-                end
-              else
-                add_column_options_without_schema_plus!(sql, options.merge(default: value))
-              end
-            else
-              add_column_options_without_schema_plus!(sql, options)
-            end
-          end
-
-          #####################################################################
-          #
-          # The functions below here are abstract; each subclass should
-          # define them all. Defining them here only for reference.
-
-          # (abstract) Return true if the passed expression can be used as a column
-          # default value.  (For most databases the specific expression
-          # doesn't matter, and the adapter's function would return a
-          # constant true if default expressions are supported or false if
-          # they're not.)
-          def default_expr_valid?(expr) raise "Internal Error: Connection adapter didn't override abstract function"; end
-
-          # (abstract) Return SQL definition for a given canonical function_name symbol.
-          # Currently, the only function to support is :now, which should
-          # return a DATETIME object for the current time.
-          def sql_for_function(function_name) raise "Internal Error: Connection adapter didn't override abstract function"; end
-        end
-
         module VisitTableDefinition
           def self.included(base) #:nodoc:
             base.alias_method_chain :visit_TableDefinition, :schema_plus
@@ -266,14 +173,6 @@ module SchemaPlus
         # define them all. Defining them here only for reference.
         #
 
-        # (abstract) Returns the names of all views, as an array of strings
-        def views(name = nil) raise "Internal Error: Connection adapter didn't override abstract function"; [] end
-
-        # (abstract) Returns the SQL definition of a given view.  This is
-        # the literal SQL would come after 'CREATVE VIEW viewname AS ' in
-        # the SQL statement to create a view.
-        def view_definition(view_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 this table
         def foreign_keys(table_name, name = nil) raise "Internal Error: Connection adapter didn't override abstract function"; [] end

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

@@ -1,42 +1,4 @@
-if "#{::ActiveRecord::VERSION::MAJOR}.#{::ActiveRecord::VERSION::MINOR}".to_r < "4.2".to_r
-  class ActiveRecord::ConnectionAdapters::ForeignKeyDefinition < Struct.new(:from_table, :to_table, :options) #:nodoc:
-    # The name of the foreign key constraint
-    def name
-      options[:name]
-    end
-
-    def column
-      options[:column]
-    end
-
-    def primary_key
-      options[:primary_key] || default_primary_key
-    end
-
-    # The ON_DELETE behavior for the constraint.  See above for the
-    # possible values.
-    def on_delete
-      options[:on_delete]
-    end
-
-    # The ON_UPDATE behavior for the constraint.  See above for the
-    # possible values.
-    def on_update
-      options[:on_update]
-    end
-
-    def custom_primary_key?
-      options[:primary_key] != default_primary_key
-    end
-
-    private
-    def default_primary_key
-      "id"
-    end
-  end
-else
-  require 'active_record/connection_adapters/abstract/schema_definitions'
-end
+require 'active_record/connection_adapters/abstract/schema_definitions'
 
 module SchemaPlus
   module ActiveRecord
@@ -46,31 +8,60 @@ module SchemaPlus
       # The on_update and on_delete attributes can take on the following values:
       #   :cascade
       #   :restrict
-      #   :set_null
+      #   :nullify
       #   :set_default
       #   :no_action
       #
       # The deferrable attribute can take on the following values:
       #   true
       #   :initially_deferred
-      class ForeignKeyDefinition < ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
+      module ForeignKeyDefinition
 
-        # The list of column names that are constrained (as strings).
-        attr_reader :column_names
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :initialize, :schema_plus
+          end
+        end
 
-        # The list of column names (as strings) of the foreign table that are referenced
-        # by the constraint
-        attr_reader :references_column_names
-        # :enddoc:
+        def column_names
+          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#column_names is depcreated, use Array.wrap(column)"
+          Array.wrap(column)
+        end
 
-        ACTIONS = { :cascade => "CASCADE", :restrict => "RESTRICT", :set_null => "SET NULL", :set_default => "SET DEFAULT", :no_action => "NO ACTION" }.freeze
+        def references_column_names
+          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#references_column_names is depcreated, use Array.wrap(primary_key)"
+          Array.wrap(primary_key)
+        end
 
-        def initialize(from_table, to_table, options)
-          super
-          @from_table = unquote(from_table)
-          @to_table = unquote(to_table)
-          @column_names = unquote(Array.wrap(options.delete(:column_names)))
-          @references_column_names = unquote(Array.wrap(options.delete(:references_column_names)))
+        def references_table_name
+          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#references_table_name is depcreated, use #to_table"
+          to_table
+        end
+
+        def table_name
+          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#table_name is depcreated, 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_with_schema_plus(from_table, to_table, options={})
+          [:on_update, :on_delete].each do |key|
+            if options[key] == :set_null
+              require 'byebug' ; byebug
+              ActiveSupport::Deprecation.warn ":set_null value for #{key} is deprecated.  use :nullify instead"
+              options[key] = :nullify
+            end
+          end
+
+          initialize_without_schema_plus(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
@@ -80,35 +71,36 @@ module SchemaPlus
           end
         end
 
-        def table_name
-          from_table
-        end
-
-        def references_table_name
-          to_table
-        end
-
-        # True if the constraint is deferrable
+        # Truthy if the constraint is deferrable
         def deferrable
           options[:deferrable]
         end
 
         # Dumps a definition of foreign key.
         def to_dump(opts={})
-          dump = (opts[:inline] ? "  t.foreign_key" : "add_foreign_key #{table_name.inspect},")
-          dump << " [#{Array(column_names).collect{ |name| name.inspect }.join(', ')}]"
-          dump << ", #{references_table_name.inspect}, [#{Array(references_column_names).collect{ |name| name.inspect }.join(', ')}]"
-          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 << ", :name => #{name.inspect}" if name
-          dump << "\n"
+          opts = opts.keyword_args(:column, :inline)
+          dump = case 
+                 when opts.column then "foreign_key: {references:"
+                 when opts.inline then "t.foreign_key"
+                 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 column}" unless opts.column
+          dump << ", primary_key: #{val_or_array.call column}" 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 opts.column
           dump
         end
 
         def to_sql
           sql = name ? "CONSTRAINT #{name} " : ""
-          sql << "FOREIGN KEY (#{quoted_column_names.join(", ")}) REFERENCES #{quoted_references_table_name} (#{quoted_references_column_names.join(", ")})"
+          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
@@ -117,35 +109,23 @@ module SchemaPlus
         end
 
         def quoted_column_names
-          Array(column_names).collect { |name| ::ActiveRecord::Base.connection.quote_column_name(name) }
+          Array(column).map { |name| ::ActiveRecord::Base.connection.quote_column_name(name) }
         end
 
-        def quoted_references_column_names
-          Array(references_column_names).collect { |name| ::ActiveRecord::Base.connection.quote_column_name(name) }
-        end
-
-        def quoted_references_table_name
-          ::ActiveRecord::Base.connection.quote_table_name(references_table_name)
-        end
-
-        def unquote(names)
-          if names.is_a?(Array)
-            names.collect { |name| __unquote(name) }
-          else
-            __unquote(names)
-          end
+        def quoted_primary_keys
+          Array(primary_key).map { |name| ::ActiveRecord::Base.connection.quote_column_name(name) }
         end
 
-        def __unquote(value)
-          value.to_s.sub(/^["`](.*)["`]$/, '\1')
+        def quoted_to_table
+          ::ActiveRecord::Base.connection.quote_table_name(to_table)
         end
 
-        def self.default_name(table_name, column_names)
-          "fk_#{fixup_schema_name(table_name)}_#{Array.wrap(column_names).join('_and_')}"
+        def self.default_name(from_table, column)
+          "fk_#{fixup_schema_name(from_table)}_#{Array.wrap(column).join('_and_')}"
         end
 
-        def self.auto_index_name(table_name, column_name)
-          "fk__#{fixup_schema_name(table_name)}_#{Array.wrap(column_name).join('_and_')}"
+        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)
@@ -153,12 +133,11 @@ module SchemaPlus
           table_name.to_s.gsub(/[.]/, '_')
         end
 
-        def ==(other) # note equality test ignores :name and options
-          [:table_name,
-           :column_names,
-           :references_table_name,
-           :references_column_names
-           ].all? { |attr| self.send(attr) == other.send(attr) }
+        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