activerecord 7.0.0.alpha2 → 7.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c726656eedc83ae6194a4d9ce8a59f0a584cdd619a576681acde6f238446601
-  data.tar.gz: e7e4936dc0f4aa4e5d359d0c240548aed4a83045a1920ae4c748a0f95c7e6fc0
+  metadata.gz: c1a1968982fd2d7c0361ac7cfa9241a02c4ff558cc8fba93545800194274ac90
+  data.tar.gz: e19875a1df942ea1488aff91d0026e8584945504b14f9021660a1b55831f2ad2
 SHA512:
-  metadata.gz: 789244fd0de0167502dd616d255a1d7ab35c8651a26c2a368449aa004265406705f8e26499bbd9ea7c40173b3ef9c7de4208e8ea247c1d0486560291fc530f3e
-  data.tar.gz: b2072dea21d7eda209b0192c32725cb871b3ee3bcec49a4e3cf61e3b7c50d833cb2d843069cc6998bb4da285ec45ee4db5658db2490f637e82f92f6f37594fa3
+  metadata.gz: 17e093b64278febf6fa7db08a4184650581efeabdc2b32c652c2818951fa9608cd2bd804ba51304cbace26ffb2d83873ea416f29d600017161b607968e4fbe7e
+  data.tar.gz: cffe209fcb1de322ef8089a95b24940db52ac4cc5086c6fc7a749646a2e14f83a15384785a2bb390c149b770a17e9597789d12ceffb38e925e6067772d8a0556

data/CHANGELOG.md

@@ -1,3 +1,497 @@
+*   Remove deprecated `ActiveRecord::DatabaseConfigurations::DatabaseConfig#spec_name`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `ActiveRecord::Connection#in_clause_length`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `ActiveRecord::Connection#allowed_index_name_length`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `ActiveRecord::Base#remove_connection`.
+
+    *Rafael Mendonça França*
+
+*   Load STI Models in fixtures
+
+    Data from Fixtures now loads based on the specific class for models with
+    Single Table Inheritance. This affects enums defined in subclasses, previously
+    the value of these fields was not parsed and remained `nil`
+
+    *Andres Howard*
+
+*   `#authenticate` returns false when the password is blank instead of raising an error.
+
+    *Muhammad Muhammad Ibrahim*
+
+*   Fix `ActiveRecord::QueryMethods#in_order_of` behavior for integer enums.
+
+    `ActiveRecord::QueryMethods#in_order_of` didn't work as expected for enums stored as integers in the database when passing an array of strings or symbols as the order argument. This unexpected behavior occurred because the string or symbol values were not casted to match the integers in the database.
+
+    The following example now works as expected:
+
+    ```ruby
+    class Book < ApplicationRecord
+      enum status: [:proposed, :written, :published]
+    end
+
+    Book.in_order_of(:status, %w[written published proposed])
+    ```
+
+    *Alexandre Ruban*
+
+*   Ignore persisted in-memory records when merging target lists.
+
+    *Kevin Sjöberg*
+
+*   Add a new option `:update_only` to `upsert_all` to configure the list of columns to update in case of conflict.
+
+    Before, you could only customize the update SQL sentence via `:on_duplicate`. There is now a new option `:update_only` that lets you provide a list of columns to update in case of conflict:
+
+    ```ruby
+    Commodity.upsert_all(
+      [
+        { id: 2, name: "Copper", price: 4.84 },
+        { id: 4, name: "Gold", price: 1380.87 },
+        { id: 6, name: "Aluminium", price: 0.35 }
+      ],
+      update_only: [:price] # Only prices will be updated
+    )
+    ```
+
+    *Jorge Manrubia*
+
+*   Remove deprecated `ActiveRecord::Result#map!` and `ActiveRecord::Result#collect!`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `ActiveRecord::Base.configurations.to_h`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `ActiveRecord::Base.configurations.default_hash`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `ActiveRecord::Base.arel_attribute`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `ActiveRecord::Base.connection_config`.
+
+    *Rafael Mendonça França*
+
+*   Filter attributes in SQL logs
+
+    Previously, SQL queries in logs containing `ActiveRecord::Base.filter_attributes` were not filtered.
+
+    Now, the filter attributes will be masked `[FILTERED]` in the logs when `prepared_statement` is enabled.
+
+    ```
+    # Before:
+      Foo Load (0.2ms)  SELECT "foos".* FROM "foos" WHERE "foos"."passw" = ? LIMIT ?  [["passw", "hello"], ["LIMIT", 1]]
+
+    # After:
+      Foo Load (0.5ms)  SELECT "foos".* FROM "foos" WHERE "foos"."passw" = ? LIMIT ?  [["passw", "[FILTERED]"], ["LIMIT", 1]]
+    ```
+
+    *Aishwarya Subramanian*
+
+*   Remove deprecated `Tasks::DatabaseTasks.spec`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `Tasks::DatabaseTasks.current_config`.
+
+    *Rafael Mendonça França*
+
+*   Deprecate `Tasks::DatabaseTasks.schema_file_type`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `Tasks::DatabaseTasks.dump_filename`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `Tasks::DatabaseTasks.schema_file`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `environment` and `name` arguments from `Tasks::DatabaseTasks.schema_up_to_date?`.
+
+    *Rafael Mendonça França*
+
+*   Merging conditions on the same column no longer maintain both conditions,
+    and will be consistently replaced by the latter condition.
+
+    ```ruby
+    # Rails 6.1 (IN clause is replaced by merger side equality condition)
+    Author.where(id: [david.id, mary.id]).merge(Author.where(id: bob)) # => [bob]
+    # Rails 6.1 (both conflict conditions exists, deprecated)
+    Author.where(id: david.id..mary.id).merge(Author.where(id: bob)) # => []
+    # Rails 6.1 with rewhere to migrate to Rails 7.0's behavior
+    Author.where(id: david.id..mary.id).merge(Author.where(id: bob), rewhere: true) # => [bob]
+    # Rails 7.0 (same behavior with IN clause, mergee side condition is consistently replaced)
+    Author.where(id: [david.id, mary.id]).merge(Author.where(id: bob)) # => [bob]
+    Author.where(id: david.id..mary.id).merge(Author.where(id: bob)) # => [bob]
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated support to `Model.reorder(nil).first` to search using non-deterministic order.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated rake tasks:
+
+    * `db:schema:load_if_ruby`
+    * `db:structure:dump`
+    * `db:structure:load`
+    * `db:structure:load_if_sql`
+    * `db:structure:dump:#{name}`
+    * `db:structure:load:#{name}`
+    * `db:test:load_structure`
+    * `db:test:load_structure:#{name}`
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `DatabaseConfig#config` method.
+
+    *Rafael Mendonça França*
+
+*   Rollback transactions when the block returns earlier than expected.
+
+    Before this change, when a transaction block returned early, the transaction would be committed.
+
+    The problem is that timeouts triggered inside the transaction block was also making the incomplete transaction
+    to be committed, so in order to avoid this mistake, the transaction block is rolled back.
+
+    *Rafael Mendonça França*
+
+*   Add middleware for automatic shard swapping.
+
+    Provides a basic middleware to perform automatic shard swapping. Applications will provide a resolver which will determine for an individual request which shard should be used. Example:
+
+    ```ruby
+    config.active_record.shard_resolver = ->(request) {
+      subdomain = request.subdomain
+      tenant = Tenant.find_by_subdomain!(subdomain)
+      tenant.shard
+    }
+    ```
+
+    See guides for more details.
+
+    *Eileen M. Uchitelle*, *John Crepezzi*
+
+*   Remove deprecated support to pass a column to `type_cast`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated support to type cast to database values `ActiveRecord::Base` objects.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated support to quote `ActiveRecord::Base` objects.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecacated support to resolve connection using `"primary"` as connection specification name.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecation warning when using `:interval` column is used in PostgreSQL database.
+
+    Now, interval columns will return `ActiveSupport::Duration` objects instead of strings.
+
+    To keep the old behavior, you can add this line to your model:
+
+    ```ruby
+    attribute :column, :string
+    ```
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated support to YAML load `ActiveRecord::Base` instance in the Rails 4.2 and 4.1 formats.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated option `:spec_name` in the `configs_for` method.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated  `ActiveRecord::Base.allow_unsafe_raw_sql`.
+
+    *Rafael Mendonça França*
+
+*   Fix regression bug that caused ignoring additional conditions for preloading has_many-through relations.
+
+    Fixes #43132
+
+    *Alexander Pauly*
+
+*   Fix `has_many` inversing recursion on models with recursive associations.
+
+    *Gannon McGibbon*
+
+*   Add `accepts_nested_attributes_for` support for `delegated_type`
+
+    ```ruby
+    class Entry < ApplicationRecord
+      delegated_type :entryable, types: %w[ Message Comment ]
+      accepts_nested_attributes_for :entryable
+    end
+
+    entry = Entry.create(entryable_type: 'Message', entryable_attributes: { content: 'Hello world' })
+    # => #<Entry:0x00>
+    # id: 1
+    # entryable_id: 1,
+    # entryable_type: 'Message'
+    # ...>
+
+    entry.entryable
+    # => #<Message:0x01>
+    # id: 1
+    # content: 'Hello world'
+    # ...>
+    ```
+
+    Previously it would raise an error:
+
+    ```ruby
+    Entry.create(entryable_type: 'Message', entryable_attributes: { content: 'Hello world' })
+    # ArgumentError: Cannot build association `entryable'. Are you trying to build a polymorphic one-to-one association?
+    ```
+
+    *Sjors Baltus*
+
+*   Use subquery for DELETE with GROUP_BY and HAVING clauses.
+
+    Prior to this change, deletes with GROUP_BY and HAVING were returning an error.
+
+    After this change, GROUP_BY and HAVING are valid clauses in DELETE queries, generating the following query:
+
+    ```sql
+    DELETE FROM "posts" WHERE "posts"."id" IN (
+        SELECT "posts"."id" FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" GROUP BY "posts"."id" HAVING (count(comments.id) >= 2))
+    )  [["flagged", "t"]]
+    ```
+
+    *Ignacio Chiazzo Cardarello*
+
+*   Use subquery for UPDATE with GROUP_BY and HAVING clauses.
+
+    Prior to this change, updates with GROUP_BY and HAVING were being ignored, generating a SQL like this:
+
+    ```sql
+    UPDATE "posts" SET "flagged" = ? WHERE "posts"."id" IN (
+        SELECT "posts"."id" FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+    )  [["flagged", "t"]]
+    ```
+
+    After this change, GROUP_BY and HAVING clauses are used as a subquery in updates, like this:
+
+    ```sql
+    UPDATE "posts" SET "flagged" = ? WHERE "posts"."id" IN (
+        SELECT "posts"."id" FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+        GROUP BY posts.id HAVING (count(comments.id) >= 2)
+    )  [["flagged", "t"]]
+    ```
+
+    *Ignacio Chiazzo Cardarello*
+
+*   Add support for setting the filename of the schema or structure dump in the database config.
+
+    Applications may now set their the filename or path of the schema / structure dump file in their database configuration.
+
+
+    ```yaml
+    production:
+      primary:
+        database: my_db
+        schema_dump: my_schema_dump_filename.rb
+      animals:
+        database: animals_db
+        schema_dump: false
+    ```
+
+    The filename set in `schema_dump` will be used by the application. If set to `false` the schema will not be dumped. The database tasks are responsible for adding the database directory to the filename. If a full path is provided, the Rails tasks will use that instead of `ActiveRecord::DatabaseTasks.db_dir`.
+
+    *Eileen M. Uchitelle*, *Ryan Kerr*
+
+*   Add `ActiveRecord::Base.prohibit_shard_swapping` to prevent attempts to change the shard within a block.
+
+    *John Crepezzi*, *Eileen M. Uchitelle*
+
+*   Filter unchanged attributes with default function from insert query when `partial_inserts` is disabled.
+
+    *Akshay Birajdar*, *Jacopo Beschi*
+
+*   Add support for FILTER clause (SQL:2003) to Arel.
+
+    Currently supported by PostgreSQL 9.4+ and SQLite 3.30+.
+
+    *Andrey Novikov*
+
+*   Automatically set timestamps on record creation during bulk insert/upsert
+
+    Prior to this change, only updates during an upsert operation (e.g. `upsert_all`) would touch timestamps (`updated_{at,on}`). Now, record creations also touch timestamp columns (`{created,updated}_{at,on}`).
+
+    This behaviour is controlled by the `<model>.record_timestamps` config, matching the behaviour of `create`, `update`, etc. It can also be overridden by using the `record_timestamps:` keyword argument.
+
+    Note that this means `upsert_all` on models with `record_timestamps = false` will no longer touch `updated_{at,on}` automatically.
+
+    *Sam Bostock*
+
+*   Don't require `role` when passing `shard` to `connected_to`.
+
+    `connected_to` can now be called with a `shard` only. Note that `role` is still inherited if `connected_to` calls are nested.
+
+    *Eileen M. Uchitelle*
+
+*   Add option to lazily load the schema cache on the connection.
+
+    Previously, the only way to load the schema cache in Active Record was through the Railtie on boot. This option provides the ability to load the schema cache on the connection after it's been established. Loading the cache lazily on the connection can be beneficial for Rails applications that use multiple databases because it will load the cache at the time the connection is established. Currently Railties doesn't have access to the connections before boot.
+
+    To use the cache, set `config.active_record.lazily_load_schema_cache = true` in your application configuration. In addition a `schema_cache_path` should be set in your database configuration if you don't want to use the default "db/schema_cache.yml" path.
+
+    *Eileen M. Uchitelle*
+
+*   Allow automatic `inverse_of` detection for associations with scopes.
+
+    Automatic `inverse_of` detection now works for associations with scopes. For
+    example, the `comments` association here now automatically detects
+    `inverse_of: :post`, so we don't need to pass that option:
+
+    ```ruby
+    class Post < ActiveRecord::Base
+      has_many :comments, -> { visible }
+    end
+
+    class Comment < ActiveRecord::Base
+      belongs_to :post
+    end
+    ```
+
+    Note that the automatic detection still won't work if the inverse
+    association has a scope. In this example a scope on the `post` association
+    would still prevent Rails from finding the inverse for the `comments`
+    association.
+
+    This will be the default for new apps in Rails 7. To opt in:
+
+    ```ruby
+    config.active_record.automatic_scope_inversing = true
+    ```
+
+    *Daniel Colson*, *Chris Bloom*
+
+*   Accept optional transaction args to `ActiveRecord::Locking::Pessimistic#with_lock`
+
+    `#with_lock` now accepts transaction options like `requires_new:`,
+    `isolation:`, and `joinable:`
+
+*   Adds support for deferrable foreign key constraints in PostgreSQL.
+
+    By default, foreign key constraints in PostgreSQL are checked after each statement. This works for most use cases,
+    but becomes a major limitation when creating related records before the parent record is inserted into the database.
+    One example of this is looking up / creating a person via one or more unique alias.
+
+    ```ruby
+    Person.transaction do
+      alias = Alias
+        .create_with(user_id: SecureRandom.uuid)
+        .create_or_find_by(name: "DHH")
+
+      person = Person
+        .create_with(name: "David Heinemeier Hansson")
+        .create_or_find_by(id: alias.user_id)
+    end
+    ```
+
+    Using the default behavior, the transaction would fail when executing the first `INSERT` statement.
+
+    By passing the `:deferrable` option to the `add_foreign_key` statement in migrations, it's possible to defer this
+    check.
+
+    ```ruby
+    add_foreign_key :aliases, :person, deferrable: true
+    ```
+
+    Passing `deferrable: true` doesn't change the default behavior, but allows manually deferring the check using
+    `SET CONSTRAINTS ALL DEFERRED` within a transaction. This will cause the foreign keys to be checked after the
+    transaction.
+
+    It's also possible to adjust the default behavior from an immediate check (after the statement), to a deferred check
+    (after the transaction):
+
+    ```ruby
+    add_foreign_key :aliases, :person, deferrable: :deferred
+    ```
+
+    *Benedikt Deicke*
+
+*   Allow configuring Postgres password through the socket URL.
+
+    For example:
+    ```ruby
+    ActiveRecord::DatabaseConfigurations::UrlConfig.new(
+      :production, :production, 'postgres:///?user=user&password=secret&dbname=app', {}
+    ).configuration_hash
+    ```
+
+    will now return,
+
+    ```ruby
+    { :user=>"user", :password=>"secret", :dbname=>"app", :adapter=>"postgresql" }
+    ```
+
+    *Abeid Ahmed*
+
+*   PostgreSQL: support custom enum types
+
+    In migrations, use `create_enum` to add a new enum type, and `t.enum` to add a column.
+
+    ```ruby
+    def up
+      create_enum :mood, ["happy", "sad"]
+
+      change_table :cats do |t|
+        t.enum :current_mood, enum_type: "mood", default: "happy", null: false
+      end
+    end
+    ```
+
+    Enums will be presented correctly in `schema.rb`. Note that this is only supported by
+    the PostgreSQL adapter.
+
+    *Alex Ghiculescu*
+
+* Avoid COMMENT statements in PostgreSQL structure dumps
+
+    COMMENT statements are now omitted from the output of `db:structure:dump` when using PostgreSQL >= 11.
+    This allows loading the dump without a pgsql superuser account.
+
+    Fixes #36816, #43107.
+
+    *Janosch Müller*
+
+*   Add support for generated columns in PostgreSQL adapter
+
+    Generated columns are supported since version 12.0 of PostgreSQL. This adds
+    support of those to the PostgreSQL adapter.
+
+    ```ruby
+    create_table :users do |t|
+      t.string :name
+      t.virtual :name_upcased, type: :string, as: 'upper(name)', stored: true
+    end
+    ```
+
+    *Michał Begejowicz*
+
+
 ## Rails 7.0.0.alpha2 (September 15, 2021) ##
 
 *   No changes.
@@ -98,10 +592,10 @@
 
     The behavior now is:
 
-    `columns`: (unchanged) raises a db error if the table does not exist
-    `columns_hash`: (unchanged) raises a db error if the table does not exist
-    `primary_keys`: (unchanged) returns `nil` if the table does not exist
-    `indexes`: (changed for mysql2) returns `[]` if the table does not exist
+    `columns`: (unchanged) raises a db error if the table does not exist.
+    `columns_hash`: (unchanged) raises a db error if the table does not exist.
+    `primary_keys`: (unchanged) returns `nil` if the table does not exist.
+    `indexes`: (changed for mysql2) returns `[]` if the table does not exist.
 
     *Eileen M. Uchitelle*
 
@@ -246,7 +740,7 @@
 *   Add option to disable schema dump per-database.
 
     Dumping the schema is on by default for all databases in an application. To turn it off for a
-    specific database use the `schema_dump` option:
+    specific database, use the `schema_dump` option:
 
     ```yaml
     # config/database.yml
@@ -283,7 +777,7 @@
     config.active_record.partial_inserts = true
     ```
 
-    If a migration remove the default value of a column, this option
+    If a migration removes the default value of a column, this option
     would cause old processes to no longer be able to create new records.
 
     If you need to remove a column, you should first use `ignored_columns`
@@ -445,7 +939,7 @@
 
 *   Fix compatibility with `psych >= 4`.
 
-    Starting in Psych 4.0.0 `YAML.load` behaves like `YAML.safe_load`. To preserve compatibility
+    Starting in Psych 4.0.0 `YAML.load` behaves like `YAML.safe_load`. To preserve compatibility,
     Active Record's schema cache loader and `YAMLColumn` now uses `YAML.unsafe_load` if available.
 
     *Jean Boussier*
@@ -499,7 +993,7 @@
 
     ```ruby
     class Person
-      belongs_to :dog
+      has_one :dog
       has_one :veterinarian, through: :dog, disable_joins: true
     end
     ```
@@ -975,8 +1469,8 @@
 
     *Eileen M. Uchitelle*, *John Crepezzi*
 
-*   Support hash config for `structure_dump_flags` and `structure_load_flags` flags
-    Now that Active Record supports multiple databases configuration
+*   Support hash config for `structure_dump_flags` and `structure_load_flags` flags.
+    Now that Active Record supports multiple databases configuration,
     we need a way to pass specific flags for dump/load databases since
     the options are not the same for different adapters.
     We can use in the original way:

data/lib/active_record/associations/association.rb

@@ -52,7 +52,6 @@ module ActiveRecord
         @loaded = false
         @target = nil
         @stale_state = nil
-        @inversed = false
       end
 
       def reset_negative_cache # :nodoc:
@@ -78,7 +77,6 @@ module ActiveRecord
       def loaded!
         @loaded = true
         @stale_state = stale_state
-        @inversed = false
       end
 
       # The target is stale if the target no longer points to the record(s) that the
@@ -88,7 +86,7 @@ module ActiveRecord
       #
       # Note that if the target has not been loaded, it is not considered stale.
       def stale_target?
-        !@inversed && loaded? && @stale_state != stale_state
+        loaded? && @stale_state != stale_state
       end
 
       # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
@@ -137,15 +135,11 @@ module ActiveRecord
 
       def inversed_from(record)
         self.target = record
-        @inversed = !!record
       end
 
       def inversed_from_queries(record)
         if inversable?(record)
           self.target = record
-          @inversed = true
-        else
-          @inversed = false
         end
       end
 
@@ -295,7 +289,7 @@ module ActiveRecord
 
         # Raises ActiveRecord::AssociationTypeMismatch unless +record+ is of
         # the kind of the class of the associated objects. Meant to be used as
-        # a sanity check when you are about to assign an associated record.
+        # a safety check when you are about to assign an associated record.
         def raise_on_type_mismatch!(record)
           unless record.is_a?(reflection.klass)
             fresh_class = reflection.class_name.safe_constantize

data/lib/active_record/associations/builder/collection_association.rb

@@ -30,11 +30,18 @@ module ActiveRecord::Associations::Builder # :nodoc:
     def self.define_callback(model, callback_name, name, options)
       full_callback_name = "#{callback_name}_for_#{name}"
 
-      unless model.method_defined?(full_callback_name)
+      callback_values = Array(options[callback_name.to_sym])
+      method_defined = model.respond_to?(full_callback_name)
+
+      # If there are no callbacks, we must also check if a superclass had
+      # previously defined this association
+      return if callback_values.empty? && !method_defined
+
+      unless method_defined
         model.class_attribute(full_callback_name, instance_accessor: false, instance_predicate: false)
       end
 
-      callbacks = Array(options[callback_name.to_sym]).map do |callback|
+      callbacks = callback_values.map do |callback|
         case callback
         when Symbol
           ->(method, owner, record) { owner.send(callback, record) }

data/lib/active_record/associations/collection_association.rb

@@ -335,7 +335,7 @@ module ActiveRecord
             end
           end
 
-          persisted + memory
+          persisted + memory.reject(&:persisted?)
         end
 
         def _create_record(attributes, raise = false, &block)
@@ -456,6 +456,10 @@ module ActiveRecord
 
           yield(record) if block_given?
 
+          if !index && @replaced_or_added_targets.include?(record)
+            index = @target.index(record)
+          end
+
           @replaced_or_added_targets << record if inversing || index || record.new_record?
 
           if index
@@ -480,7 +484,11 @@ module ActiveRecord
 
         def callbacks_for(callback_name)
           full_callback_name = "#{callback_name}_for_#{reflection.name}"
-          owner.class.send(full_callback_name)
+          if owner.class.respond_to?(full_callback_name)
+            owner.class.send(full_callback_name)
+          else
+            []
+          end
         end
 
         def include_in_memory?(record)