activerecord 3.1.12 → 3.2.22.1

data/lib/active_record/scoping/named.rb

@@ -0,0 +1,200 @@
+require 'active_support/core_ext/array'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/class/attribute'
+
+module ActiveRecord
+  # = Active Record Named \Scopes
+  module Scoping
+    module Named
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Returns an anonymous \scope.
+        #
+        #   posts = Post.scoped
+        #   posts.size # Fires "select count(*) from  posts" and returns the count
+        #   posts.each {|p| puts p.name } # Fires "select * from posts" and loads post objects
+        #
+        #   fruits = Fruit.scoped
+        #   fruits = fruits.where(:color => 'red') if options[:red_only]
+        #   fruits = fruits.limit(10) if limited?
+        #
+        # Anonymous \scopes tend to be useful when procedurally generating complex
+        # queries, where passing intermediate values (\scopes) around as first-class
+        # objects is convenient.
+        #
+        # You can define a \scope that applies to all finders using
+        # ActiveRecord::Base.default_scope.
+        def scoped(options = nil)
+          if options
+            scoped.apply_finder_options(options)
+          else
+            if current_scope
+              current_scope.clone
+            else
+              scope = relation
+              scope.default_scoped = true
+              scope
+            end
+          end
+        end
+
+        ##
+        # Collects attributes from scopes that should be applied when creating
+        # an AR instance for the particular class this is called on.
+        def scope_attributes # :nodoc:
+          if current_scope
+            current_scope.scope_for_create
+          else
+            scope = relation
+            scope.default_scoped = true
+            scope.scope_for_create
+          end
+        end
+
+        ##
+        # Are there default attributes associated with this scope?
+        def scope_attributes? # :nodoc:
+          current_scope || default_scopes.any?
+        end
+
+        # Adds a class method for retrieving and querying objects. A \scope represents a narrowing of a database query,
+        # such as <tt>where(:color => :red).select('shirts.*').includes(:washing_instructions)</tt>.
+        #
+        #   class Shirt < ActiveRecord::Base
+        #     scope :red, where(:color => 'red')
+        #     scope :dry_clean_only, joins(:washing_instructions).where('washing_instructions.dry_clean_only = ?', true)
+        #   end
+        #
+        # The above calls to <tt>scope</tt> define class methods Shirt.red and Shirt.dry_clean_only. Shirt.red,
+        # in effect, represents the query <tt>Shirt.where(:color => 'red')</tt>.
+        #
+        # Note that this is simply 'syntactic sugar' for defining an actual class method:
+        #
+        #   class Shirt < ActiveRecord::Base
+        #     def self.red
+        #       where(:color => 'red')
+        #     end
+        #   end
+        #
+        # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by Shirt.red is not an Array; it
+        # resembles the association object constructed by a <tt>has_many</tt> declaration. For instance,
+        # you can invoke <tt>Shirt.red.first</tt>, <tt>Shirt.red.count</tt>, <tt>Shirt.red.where(:size => 'small')</tt>.
+        # Also, just as with the association objects, named \scopes act like an Array, implementing Enumerable;
+        # <tt>Shirt.red.each(&block)</tt>, <tt>Shirt.red.first</tt>, and <tt>Shirt.red.inject(memo, &block)</tt>
+        # all behave as if Shirt.red really was an Array.
+        #
+        # These named \scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce
+        # all shirts that are both red and dry clean only.
+        # Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt>
+        # returns the number of garments for which these criteria obtain. Similarly with
+        # <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
+        #
+        # All \scopes are available as class methods on the ActiveRecord::Base descendant upon which
+        # the \scopes were defined. But they are also available to <tt>has_many</tt> associations. If,
+        #
+        #   class Person < ActiveRecord::Base
+        #     has_many :shirts
+        #   end
+        #
+        # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of Elton's red, dry clean
+        # only shirts.
+        #
+        # Named \scopes can also be procedural:
+        #
+        #   class Shirt < ActiveRecord::Base
+        #     scope :colored, lambda { |color| where(:color => color) }
+        #   end
+        #
+        # In this example, <tt>Shirt.colored('puce')</tt> finds all puce shirts.
+        #
+        # On Ruby 1.9 you can use the 'stabby lambda' syntax:
+        #
+        #   scope :colored, ->(color) { where(:color => color) }
+        #
+        # Note that scopes defined with \scope will be evaluated when they are defined, rather than
+        # when they are used. For example, the following would be incorrect:
+        #
+        #   class Post < ActiveRecord::Base
+        #     scope :recent, where('published_at >= ?', Time.current - 1.week)
+        #   end
+        #
+        # The example above would be 'frozen' to the <tt>Time.current</tt> value when the <tt>Post</tt>
+        # class was defined, and so the resultant SQL query would always be the same. The correct
+        # way to do this would be via a lambda, which will re-evaluate the scope each time
+        # it is called:
+        #
+        #   class Post < ActiveRecord::Base
+        #     scope :recent, lambda { where('published_at >= ?', Time.current - 1.week) }
+        #   end
+        #
+        # Named \scopes can also have extensions, just as with <tt>has_many</tt> declarations:
+        #
+        #   class Shirt < ActiveRecord::Base
+        #     scope :red, where(:color => 'red') do
+        #       def dom_id
+        #         'red_shirts'
+        #       end
+        #     end
+        #   end
+        #
+        # Scopes can also be used while creating/building a record.
+        #
+        #   class Article < ActiveRecord::Base
+        #     scope :published, where(:published => true)
+        #   end
+        #
+        #   Article.published.new.published    # => true
+        #   Article.published.create.published # => true
+        #
+        # Class methods on your model are automatically available
+        # on scopes. Assuming the following setup:
+        #
+        #   class Article < ActiveRecord::Base
+        #     scope :published, where(:published => true)
+        #     scope :featured, where(:featured => true)
+        #
+        #     def self.latest_article
+        #       order('published_at desc').first
+        #     end
+        #
+        #     def self.titles
+        #       pluck(:title)
+        #     end
+        #   end
+        #
+        # We are able to call the methods like this:
+        #
+        #   Article.published.featured.latest_article
+        #   Article.featured.titles
+        def scope(name, scope_options = {})
+          name = name.to_sym
+          valid_scope_name?(name)
+          extension = Module.new(&Proc.new) if block_given?
+
+          scope_proc = lambda do |*args|
+            options = scope_options.respond_to?(:call) ? unscoped { scope_options.call(*args) } : scope_options
+            options = scoped.apply_finder_options(options) if options.is_a?(Hash)
+
+            relation = scoped.merge(options)
+
+            extension ? relation.extending(extension) : relation
+          end
+
+          singleton_class.send(:redefine_method, name, &scope_proc)
+        end
+
+      protected
+
+        def valid_scope_name?(name)
+          if logger && respond_to?(name, true)
+            logger.warn "Creating scope :#{name}. " \
+                        "Overwriting existing method #{self.name}.#{name}."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/scoping.rb

@@ -0,0 +1,152 @@
+require 'active_support/concern'
+
+module ActiveRecord
+  module Scoping
+    extend ActiveSupport::Concern
+
+    included do
+      include Default
+      include Named
+    end
+
+    module ClassMethods
+      # with_scope lets you apply options to inner block incrementally. It takes a hash and the keys must be
+      # <tt>:find</tt> or <tt>:create</tt>. <tt>:find</tt> parameter is <tt>Relation</tt> while
+      # <tt>:create</tt> parameters are an attributes hash.
+      #
+      #   class Article < ActiveRecord::Base
+      #     def self.create_with_scope
+      #       with_scope(:find => where(:blog_id => 1), :create => { :blog_id => 1 }) do
+      #         find(1) # => SELECT * from articles WHERE blog_id = 1 AND id = 1
+      #         a = create(1)
+      #         a.blog_id # => 1
+      #       end
+      #     end
+      #   end
+      #
+      # In nested scopings, all previous parameters are overwritten by the innermost rule, with the exception of
+      # <tt>where</tt>, <tt>includes</tt>, and <tt>joins</tt> operations in <tt>Relation</tt>, which are merged.
+      #
+      # <tt>joins</tt> operations are uniqued so multiple scopes can join in the same table without table aliasing
+      # problems. If you need to join multiple tables, but still want one of the tables to be uniqued, use the
+      # array of strings format for your joins.
+      #
+      #   class Article < ActiveRecord::Base
+      #     def self.find_with_scope
+      #       with_scope(:find => where(:blog_id => 1).limit(1), :create => { :blog_id => 1 }) do
+      #         with_scope(:find => limit(10)) do
+      #           all # => SELECT * from articles WHERE blog_id = 1 LIMIT 10
+      #         end
+      #         with_scope(:find => where(:author_id => 3)) do
+      #           all # => SELECT * from articles WHERE blog_id = 1 AND author_id = 3 LIMIT 1
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # You can ignore any previous scopings by using the <tt>with_exclusive_scope</tt> method.
+      #
+      #   class Article < ActiveRecord::Base
+      #     def self.find_with_exclusive_scope
+      #       with_scope(:find => where(:blog_id => 1).limit(1)) do
+      #         with_exclusive_scope(:find => limit(10)) do
+      #           all # => SELECT * from articles LIMIT 10
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # *Note*: the +:find+ scope also has effect on update and deletion methods, like +update_all+ and +delete_all+.
+      def with_scope(scope = {}, action = :merge, &block)
+        # If another Active Record class has been passed in, get its current scope
+        scope = scope.current_scope if !scope.is_a?(Relation) && scope.respond_to?(:current_scope)
+
+        previous_scope = self.current_scope
+
+        if scope.is_a?(Hash)
+          # Dup first and second level of hash (method and params).
+          scope = scope.dup
+          scope.each do |method, params|
+            scope[method] = params.dup unless params == true
+          end
+
+          scope.assert_valid_keys([ :find, :create ])
+          relation = construct_finder_arel(scope[:find] || {})
+          relation.default_scoped = true unless action == :overwrite
+
+          if previous_scope && previous_scope.create_with_value && scope[:create]
+            scope_for_create = if action == :merge
+              previous_scope.create_with_value.merge(scope[:create])
+            else
+              scope[:create]
+            end
+
+            relation = relation.create_with(scope_for_create)
+          else
+            scope_for_create = scope[:create]
+            scope_for_create ||= previous_scope.create_with_value if previous_scope
+            relation = relation.create_with(scope_for_create) if scope_for_create
+          end
+
+          scope = relation
+        end
+
+        scope = previous_scope.merge(scope) if previous_scope && action == :merge
+
+        self.current_scope = scope
+        begin
+          yield
+        ensure
+          self.current_scope = previous_scope
+        end
+      end
+
+      protected
+
+      # Works like with_scope, but discards any nested properties.
+      def with_exclusive_scope(method_scoping = {}, &block)
+        if method_scoping.values.any? { |e| e.is_a?(ActiveRecord::Relation) }
+          raise ArgumentError, <<-MSG
+  New finder API can not be used with_exclusive_scope. You can either call unscoped to get an anonymous scope not bound to the default_scope:
+
+  User.unscoped.where(:active => true)
+
+  Or call unscoped with a block:
+
+  User.unscoped do
+  User.where(:active => true).all
+  end
+
+  MSG
+        end
+        with_scope(method_scoping, :overwrite, &block)
+      end
+
+      def current_scope #:nodoc:
+        Thread.current["#{self}_current_scope"]
+      end
+
+      def current_scope=(scope) #:nodoc:
+        Thread.current["#{self}_current_scope"] = scope
+      end
+
+      private
+
+      def construct_finder_arel(options = {}, scope = nil)
+        relation = options.is_a?(Hash) ? unscoped.apply_finder_options(options) : options
+        relation = scope.merge(relation) if scope
+        relation
+      end
+
+    end
+
+    def populate_with_current_scope_attributes
+      return unless self.class.scope_attributes?
+
+      self.class.scope_attributes.each do |att,value|
+        send("#{att}=", value) if respond_to?("#{att}=")
+      end
+    end
+
+  end
+end

data/lib/active_record/serialization.rb

@@ -10,50 +10,8 @@ module ActiveRecord #:nodoc:
       options[:except] = Array.wrap(options[:except]).map { |n| n.to_s }
       options[:except] |= Array.wrap(self.class.inheritance_column)
 
-      hash = super(options)
-
-      serializable_add_includes(options) do |association, records, opts|
-        hash[association] = records.is_a?(Enumerable) ?
-          records.map { |r| r.serializable_hash(opts) } :
-          records.serializable_hash(opts)
-      end
-
-      hash
+      super(options)
     end
-
-    private
-      # Add associations specified via the <tt>:include</tt> option.
-      #
-      # Expects a block that takes as arguments:
-      #   +association+ - name of the association
-      #   +records+     - the association record(s) to be serialized
-      #   +opts+        - options for the association records
-      def serializable_add_includes(options = {})
-        return unless include_associations = options.delete(:include)
-
-        base_only_or_except = { :except => options[:except],
-                                :only => options[:only] }
-
-        include_has_options = include_associations.is_a?(Hash)
-        associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)
-
-        associations.each do |association|
-          records = case self.class.reflect_on_association(association).macro
-          when :has_many, :has_and_belongs_to_many
-            send(association).to_a
-          when :has_one, :belongs_to
-            send(association)
-          end
-
-          if records
-            association_options = include_has_options ? include_associations[association] : base_only_or_except
-            opts = options.merge(association_options)
-            yield(association, records, opts)
-          end
-        end
-
-        options[:include] = include_associations
-      end
   end
 end
 

data/lib/active_record/serializers/xml_serializer.rb

@@ -75,7 +75,7 @@ module ActiveRecord #:nodoc:
     #   </firm>
     #
     # Additionally, the record being serialized will be passed to a Proc's second
-    # parameter.  This allows for ad hoc additions to the resultant document that
+    # parameter. This allows for ad hoc additions to the resultant document that
     # incorporate the context of the record being serialized. And by leveraging the
     # closure created by a Proc, to_xml can be used to add elements that normally fall
     # outside of the scope of the model -- for example, generating and appending URLs
@@ -163,8 +163,9 @@ module ActiveRecord #:nodoc:
     #
     #   class IHaveMyOwnXML < ActiveRecord::Base
     #     def to_xml(options = {})
+    #       require 'builder'
     #       options[:indent] ||= 2
-    #       xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+    #       xml = options[:builder] ||= ::Builder::XmlMarkup.new(:indent => options[:indent])
     #       xml.instruct! unless options[:skip_instruct]
     #       xml.level_one do
     #         xml.tag!(:second_level, 'content')
@@ -179,49 +180,7 @@ module ActiveRecord #:nodoc:
   class XmlSerializer < ActiveModel::Serializers::Xml::Serializer #:nodoc:
     def initialize(*args)
       super
-      options[:except] |= Array.wrap(@serializable.class.inheritance_column)
-    end
-
-    def add_extra_behavior
-      add_includes
-    end
-
-    def add_includes
-      procs = options.delete(:procs)
-      @serializable.send(:serializable_add_includes, options) do |association, records, opts|
-        add_associations(association, records, opts)
-      end
-      options[:procs] = procs
-    end
-
-    # TODO This can likely be cleaned up to simple use ActiveSupport::XmlMini.to_tag as well.
-    def add_associations(association, records, opts)
-      association_name = association.to_s.singularize
-      merged_options   = options.merge(opts).merge!(:root => association_name, :skip_instruct => true)
-
-      if records.is_a?(Enumerable)
-        tag  = ActiveSupport::XmlMini.rename_key(association.to_s, options)
-        type = options[:skip_types] ? { } : {:type => "array"}
-
-        if records.empty?
-          @builder.tag!(tag, type)
-        else
-          @builder.tag!(tag, type) do
-            records.each do |record|
-              if options[:skip_types]
-                record_type = {}
-              else
-                record_class = (record.class.to_s.underscore == association_name) ? nil : record.class.name
-                record_type = {:type => record_class}
-              end
-
-              record.to_xml merged_options.merge(record_type)
-            end
-          end
-        end
-      elsif record = @serializable.send(association)
-        record.to_xml(merged_options)
-      end
+      options[:except] = Array.wrap(options[:except]) | Array.wrap(@serializable.class.inheritance_column)
     end
 
     class Attribute < ActiveModel::Serializers::Xml::Serializer::Attribute #:nodoc:

data/lib/active_record/session_store.rb

@@ -1,13 +1,15 @@
+require 'action_dispatch/middleware/session/abstract_store'
+
 module ActiveRecord
   # = Active Record Session Store
   #
-  # A session store backed by an Active Record class.  A default class is
+  # A session store backed by an Active Record class. A default class is
   # provided, but any object duck-typing to an Active Record Session class
   # with text +session_id+ and +data+ attributes is sufficient.
   #
   # The default assumes a +sessions+ tables with columns:
   #   +id+ (numeric primary key),
-  #   +session_id+ (text, or longtext if your session data exceeds 65K), and
+  #   +session_id+ (string, :limit => 255), and
   #   +data+ (text or longtext; careful if your session data exceeds 65KB).
   #
   # The +session_id+ column should always be indexed for speedy lookups.
@@ -23,7 +25,7 @@ module ActiveRecord
   #   ActiveRecord::SessionStore::Session.data_column_name = 'legacy_session_data'
   #
   # Note that setting the primary key to the +session_id+ frees you from
-  # having a separate +id+ column if you don't want it.  However, you must
+  # having a separate +id+ column if you don't want it. However, you must
   # set <tt>session.model.id = session.session_id</tt> by hand!  A before filter
   # on ApplicationController is a good place.
   #
@@ -46,25 +48,25 @@ module ActiveRecord
   #   save
   #   destroy
   #
-  # The example SqlBypass class is a generic SQL session store.  You may
+  # The example SqlBypass class is a generic SQL session store. You may
   # use it as a basis for high-performance database-specific stores.
   class SessionStore < ActionDispatch::Session::AbstractStore
     module ClassMethods # :nodoc:
       def marshal(data)
-        ActiveSupport::Base64.encode64(Marshal.dump(data)) if data
+        ::Base64.encode64(Marshal.dump(data)) if data
       end
 
       def unmarshal(data)
-        Marshal.load(ActiveSupport::Base64.decode64(data)) if data
+        Marshal.load(::Base64.decode64(data)) if data
       end
 
       def drop_table!
-        connection_pool.clear_table_cache!(table_name)
+        connection.schema_cache.clear_table_cache!(table_name)
         connection.drop_table table_name
       end
 
       def create_table!
-        connection_pool.clear_table_cache!(table_name)
+        connection.schema_cache.clear_table_cache!(table_name)
         connection.create_table(table_name) do |t|
           t.string session_id_column, :limit => 255
           t.text data_column_name
@@ -79,7 +81,7 @@ module ActiveRecord
 
       ##
       # :singleton-method:
-      # Customizable data column name.  Defaults to 'data'.
+      # Customizable data column name. Defaults to 'data'.
       cattr_accessor :data_column_name
       self.data_column_name = 'data'
 
@@ -161,22 +163,22 @@ module ActiveRecord
     end
 
     # A barebones session store which duck-types with the default session
-    # store but bypasses Active Record and issues SQL directly.  This is
+    # store but bypasses Active Record and issues SQL directly. This is
     # an example session model class meant as a basis for your own classes.
     #
     # The database connection, table name, and session id and data columns
-    # are configurable class attributes.  Marshaling and unmarshaling
-    # are implemented as class methods that you may override.  By default,
+    # are configurable class attributes. Marshaling and unmarshaling
+    # are implemented as class methods that you may override. By default,
     # marshaling data is
     #
-    #   ActiveSupport::Base64.encode64(Marshal.dump(data))
+    #   ::Base64.encode64(Marshal.dump(data))
     #
     # and unmarshaling data is
     #
-    #   Marshal.load(ActiveSupport::Base64.decode64(data))
+    #   Marshal.load(::Base64.decode64(data))
     #
     # This marshaling behavior is intended to store the widest range of
-    # binary session data in a +text+ column.  For higher performance,
+    # binary session data in a +text+ column. For higher performance,
     # store in a +blob+ column instead and forgo the Base64 encoding.
     class SqlBypass
       extend ClassMethods
@@ -292,7 +294,7 @@ module ActiveRecord
       end
     end
 
-    # The class used for session storage.  Defaults to
+    # The class used for session storage. Defaults to
     # ActiveRecord::SessionStore::Session
     cattr_accessor :session_class
     self.session_class = Session

data/lib/active_record/store.rb

@@ -0,0 +1,52 @@
+module ActiveRecord
+  # Store gives you a thin wrapper around serialize for the purpose of storing hashes in a single column.
+  # It's like a simple key/value store backed into your record when you don't care about being able to
+  # query that store outside the context of a single record.
+  #
+  # You can then declare accessors to this store that are then accessible just like any other attribute
+  # of the model. This is very helpful for easily exposing store keys to a form or elsewhere that's
+  # already built around just accessing attributes on the model.
+  #
+  # Make sure that you declare the database column used for the serialized store as a text, so there's
+  # plenty of room.
+  #
+  # Examples:
+  #
+  #   class User < ActiveRecord::Base
+  #     store :settings, accessors: [ :color, :homepage ]
+  #   end
+  #   
+  #   u = User.new(color: 'black', homepage: '37signals.com')
+  #   u.color                          # Accessor stored attribute
+  #   u.settings[:country] = 'Denmark' # Any attribute, even if not specified with an accessor
+  #
+  #   # Add additional accessors to an existing store through store_accessor
+  #   class SuperUser < User
+  #     store_accessor :settings, :privileges, :servants
+  #   end
+  module Store
+    extend ActiveSupport::Concern
+  
+    module ClassMethods
+      def store(store_attribute, options = {})
+        serialize store_attribute, Hash
+        store_accessor(store_attribute, options[:accessors]) if options.has_key? :accessors
+      end
+
+      def store_accessor(store_attribute, *keys)
+        Array(keys).flatten.each do |key|
+          define_method("#{key}=") do |value|
+            send("#{store_attribute}=", {}) unless send(store_attribute).is_a?(Hash)
+            send("#{store_attribute}_will_change!")
+            send(store_attribute)[key] = value
+          end
+    
+          define_method(key) do
+            send("#{store_attribute}=", {}) unless send(store_attribute).is_a?(Hash)
+            send(store_attribute)[key]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/test_case.rb

@@ -13,7 +13,7 @@ module ActiveRecord
       ActiveRecord::IdentityMap.clear
     end
 
-    # Backport skip to Ruby 1.8.  test/unit doesn't support it, so just
+    # Backport skip to Ruby 1.8. test/unit doesn't support it, so just
     # make it a noop.
     unless instance_methods.map(&:to_s).include?("skip")
       def skip(message)
@@ -31,26 +31,30 @@ module ActiveRecord
     end
 
     def assert_sql(*patterns_to_match)
-      $queries_executed = []
+      ActiveRecord::SQLCounter.log = []
       yield
-      $queries_executed
+      ActiveRecord::SQLCounter.log
     ensure
       failed_patterns = []
       patterns_to_match.each do |pattern|
-        failed_patterns << pattern unless $queries_executed.any?{ |sql| pattern === sql }
+        failed_patterns << pattern unless ActiveRecord::SQLCounter.log.any?{ |sql| pattern === sql }
       end
-      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map{ |p| p.inspect }.join(', ')} not found.#{$queries_executed.size == 0 ? '' : "\nQueries:\n#{$queries_executed.join("\n")}"}"
+      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map{ |p| p.inspect }.join(', ')} not found.#{ActiveRecord::SQLCounter.log.size == 0 ? '' : "\nQueries:\n#{ActiveRecord::SQLCounter.log.join("\n")}"}"
     end
 
     def assert_queries(num = 1)
-      $queries_executed = []
+      ActiveRecord::SQLCounter.log = []
       yield
     ensure
-      assert_equal num, $queries_executed.size, "#{$queries_executed.size} instead of #{num} queries were executed.#{$queries_executed.size == 0 ? '' : "\nQueries:\n#{$queries_executed.join("\n")}"}"
+      assert_equal num, ActiveRecord::SQLCounter.log.size, "#{ActiveRecord::SQLCounter.log.size} instead of #{num} queries were executed.#{ActiveRecord::SQLCounter.log.size == 0 ? '' : "\nQueries:\n#{ActiveRecord::SQLCounter.log.join("\n")}"}"
     end
 
     def assert_no_queries(&block)
+      prev_ignored_sql = ActiveRecord::SQLCounter.ignored_sql
+      ActiveRecord::SQLCounter.ignored_sql = []
       assert_queries(0, &block)
+    ensure
+      ActiveRecord::SQLCounter.ignored_sql = prev_ignored_sql
     end
 
     def with_kcode(kcode)