advanced patterns when using Rails 7.1 with `destroy_all` on associated records with callbacks
Can someone help me understand I'm working with an scenario where calling `destroy_all` on a collection of associated records in Rails 7.1 does not seem to trigger the `before_destroy` or `after_destroy` callbacks as expected. I have two models, `Post` and `Comment`, where a post has many comments. I want to ensure that when I delete a post, all associated comments are also deleted and that the callbacks are triggered for each comment. Here’s how I set up my models: ```ruby class Post < ApplicationRecord has_many :comments, dependent: :destroy end class Comment < ApplicationRecord belongs_to :post before_destroy :log_comment_deletion private def log_comment_deletion Rails.logger.info "Comment #{id} is being deleted" end end ``` When I call `@post.comments.destroy_all`, I expect to see log messages for each comment being deleted, but there are none. Instead, it seems that the comments are deleted without triggering any callbacks. I tried using `@post.comments.each(&:destroy)` and that works as intended, triggering the callbacks, but it’s much slower for a large number of comments due to the N+1 query scenario. I also checked the Rails documentation, and it mentions that `destroy_all` does not run the callbacks for efficiency reasons. However, I need a solution that allows the callbacks to run without compromising performance. Is there a more efficient way to achieve this, or should I consider alternative approaches to ensure that callbacks are executed when deleting associated records? I'm using Ruby LTS in this project. Any advice would be much appreciated. This issue appeared after updating to Ruby 3.10. I'd really appreciate any guidance on this.