activerecord 4.2.6 → 5.0.0

data/lib/active_record/sanitization.rb

@@ -3,28 +3,34 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def quote_value(value, column) #:nodoc:
-        connection.quote(value, column)
-      end
-
-      # Used to sanitize objects before they're used in an SQL SELECT statement. Delegates to <tt>connection.quote</tt>.
-      def sanitize(object) #:nodoc:
+      # Used to sanitize objects before they're used in an SQL SELECT statement.
+      # Delegates to {connection.quote}[rdoc-ref:ConnectionAdapters::Quoting#quote].
+      def sanitize(object) # :nodoc:
         connection.quote(object)
       end
+      alias_method :quote_value, :sanitize
 
       protected
 
-      # Accepts an array, hash, or string of SQL conditions and sanitizes
+      # Accepts an array or string of SQL conditions and sanitizes
       # them into a valid SQL fragment for a WHERE clause.
-      #   ["name='%s' and group_id='%s'", "foo'bar", 4]  returns  "name='foo''bar' and group_id='4'"
-      #   { name: "foo'bar", group_id: 4 }  returns "name='foo''bar' and group_id='4'"
-      #   "name='foo''bar' and group_id='4'" returns "name='foo''bar' and group_id='4'"
-      def sanitize_sql_for_conditions(condition, table_name = self.table_name)
+      #
+      #   sanitize_sql_for_conditions(["name=? and group_id=?", "foo'bar", 4])
+      #   # => "name='foo''bar' and group_id=4"
+      #
+      #   sanitize_sql_for_conditions(["name=:name and group_id=:group_id", name: "foo'bar", group_id: 4])
+      #   # => "name='foo''bar' and group_id='4'"
+      #
+      #   sanitize_sql_for_conditions(["name='%s' and group_id='%s'", "foo'bar", 4])
+      #   # => "name='foo''bar' and group_id='4'"
+      #
+      #   sanitize_sql_for_conditions("name='foo''bar' and group_id='4'")
+      #   # => "name='foo''bar' and group_id='4'"
+      def sanitize_sql_for_conditions(condition)
         return nil if condition.blank?
 
         case condition
         when Array; sanitize_sql_array(condition)
-        when Hash;  sanitize_sql_hash_for_conditions(condition, table_name)
         else        condition
         end
       end
@@ -33,7 +39,18 @@ module ActiveRecord
 
       # Accepts an array, hash, or string of SQL conditions and sanitizes
       # them into a valid SQL fragment for a SET clause.
-      #   { name: nil, group_id: 4 }  returns "name = NULL , group_id='4'"
+      #
+      #   sanitize_sql_for_assignment(["name=? and group_id=?", nil, 4])
+      #   # => "name=NULL and group_id=4"
+      #
+      #   sanitize_sql_for_assignment(["name=:name and group_id=:group_id", name: nil, group_id: 4])
+      #   # => "name=NULL and group_id=4"
+      #
+      #   Post.send(:sanitize_sql_for_assignment, { name: nil, group_id: 4 })
+      #   # => "`posts`.`name` = NULL, `posts`.`group_id` = 4"
+      #
+      #   sanitize_sql_for_assignment("name=NULL and group_id='4'")
+      #   # => "name=NULL and group_id='4'"
       def sanitize_sql_for_assignment(assignments, default_table_name = self.table_name)
         case assignments
         when Array; sanitize_sql_array(assignments)
@@ -42,17 +59,37 @@ module ActiveRecord
         end
       end
 
+      # Accepts an array, or string of SQL conditions and sanitizes
+      # them into a valid SQL fragment for an ORDER clause.
+      #
+      #   sanitize_sql_for_order(["field(id, ?)", [1,3,2]])
+      #   # => "field(id, 1,3,2)"
+      #
+      #   sanitize_sql_for_order("id ASC")
+      #   # => "id ASC"
+      def sanitize_sql_for_order(condition)
+        if condition.is_a?(Array) && condition.first.to_s.include?('?')
+          sanitize_sql_array(condition)
+        else
+          condition
+        end
+      end
+
       # Accepts a hash of SQL conditions and replaces those attributes
-      # that correspond to a +composed_of+ relationship with their expanded
-      # aggregate attribute values.
+      # that correspond to a {#composed_of}[rdoc-ref:Aggregations::ClassMethods#composed_of]
+      # relationship with their expanded aggregate attribute values.
+      #
       # Given:
-      #     class Person < ActiveRecord::Base
-      #       composed_of :address, class_name: "Address",
-      #         mapping: [%w(address_street street), %w(address_city city)]
-      #     end
+      #
+      #   class Person < ActiveRecord::Base
+      #     composed_of :address, class_name: "Address",
+      #       mapping: [%w(address_street street), %w(address_city city)]
+      #   end
+      #
       # Then:
-      #     { address: Address.new("813 abc st.", "chicago") }
-      #       # => { address_street: "813 abc st.", address_city: "chicago" }
+      #
+      #   { address: Address.new("813 abc st.", "chicago") }
+      #   # => { address_street: "813 abc st.", address_city: "chicago" }
       def expand_hash_conditions_for_aggregates(attrs)
         expanded_attrs = {}
         attrs.each do |attr, value|
@@ -72,46 +109,32 @@ module ActiveRecord
         expanded_attrs
       end
 
-      # Sanitizes a hash of attribute/value pairs into SQL conditions for a WHERE clause.
-      #   { name: "foo'bar", group_id: 4 }
-      #     # => "name='foo''bar' and group_id= 4"
-      #   { status: nil, group_id: [1,2,3] }
-      #     # => "status IS NULL and group_id IN (1,2,3)"
-      #   { age: 13..18 }
-      #     # => "age BETWEEN 13 AND 18"
-      #   { 'other_records.id' => 7 }
-      #     # => "`other_records`.`id` = 7"
-      #   { other_records: { id: 7 } }
-      #     # => "`other_records`.`id` = 7"
-      # And for value objects on a composed_of relationship:
-      #   { address: Address.new("123 abc st.", "chicago") }
-      #     # => "address_street='123 abc st.' and address_city='chicago'"
-      def sanitize_sql_hash_for_conditions(attrs, default_table_name = self.table_name)
-        ActiveSupport::Deprecation.warn(<<-EOWARN)
-sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
-        EOWARN
-        attrs = PredicateBuilder.resolve_column_aliases self, attrs
-        attrs = expand_hash_conditions_for_aggregates(attrs)
-
-        table = Arel::Table.new(table_name, arel_engine).alias(default_table_name)
-        PredicateBuilder.build_from_hash(self, attrs, table).map { |b|
-          connection.visitor.compile b
-        }.join(' AND ')
-      end
-      alias_method :sanitize_sql_hash, :sanitize_sql_hash_for_conditions
-
       # Sanitizes a hash of attribute/value pairs into SQL conditions for a SET clause.
-      #   { status: nil, group_id: 1 }
-      #     # => "status = NULL , group_id = 1"
+      #
+      #   sanitize_sql_hash_for_assignment({ status: nil, group_id: 1 }, "posts")
+      #   # => "`posts`.`status` = NULL, `posts`.`group_id` = 1"
       def sanitize_sql_hash_for_assignment(attrs, table)
         c = connection
         attrs.map do |attr, value|
-          "#{c.quote_table_name_for_assignment(table, attr)} = #{quote_bound_value(value, c, columns_hash[attr.to_s])}"
+          value = type_for_attribute(attr.to_s).serialize(value)
+          "#{c.quote_table_name_for_assignment(table, attr)} = #{c.quote(value)}"
         end.join(', ')
       end
 
       # Sanitizes a +string+ so that it is safe to use within an SQL
-      # LIKE statement. This method uses +escape_character+ to escape all occurrences of "\", "_" and "%"
+      # LIKE statement. This method uses +escape_character+ to escape all occurrences of "\", "_" and "%".
+      #
+      #   sanitize_sql_like("100%")
+      #   # => "100\\%"
+      #
+      #   sanitize_sql_like("snake_cased_string")
+      #   # => "snake\\_cased\\_string"
+      #
+      #   sanitize_sql_like("100%", "!")
+      #   # => "100!%"
+      #
+      #   sanitize_sql_like("snake_cased_string", "!")
+      #   # => "snake!_cased!_string"
       def sanitize_sql_like(string, escape_character = "\\")
         pattern = Regexp.union(escape_character, "%", "_")
         string.gsub(pattern) { |x| [escape_character, x].join }
@@ -119,7 +142,15 @@ sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
 
       # Accepts an array of conditions. The array has each value
       # sanitized and interpolated into the SQL statement.
-      #   ["name='%s' and group_id='%s'", "foo'bar", 4]  returns  "name='foo''bar' and group_id='4'"
+      #
+      #   sanitize_sql_array(["name=? and group_id=?", "foo'bar", 4])
+      #   # => "name='foo''bar' and group_id=4"
+      #
+      #   sanitize_sql_array(["name=:name and group_id=:group_id", name: "foo'bar", group_id: 4])
+      #   # => "name='foo''bar' and group_id=4"
+      #
+      #   sanitize_sql_array(["name='%s' and group_id='%s'", "foo'bar", 4])
+      #   # => "name='foo''bar' and group_id='4'"
       def sanitize_sql_array(ary)
         statement, *values = ary
         if values.first.is_a?(Hash) && statement =~ /:\w+/
@@ -133,7 +164,7 @@ sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
         end
       end
 
-      def replace_bind_variables(statement, values) #:nodoc:
+      def replace_bind_variables(statement, values) # :nodoc:
         raise_if_bind_arity_mismatch(statement, statement.count('?'), values.size)
         bound = values.dup
         c = connection
@@ -142,7 +173,7 @@ sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
         end
       end
 
-      def replace_bind_variable(value, c = connection) #:nodoc:
+      def replace_bind_variable(value, c = connection) # :nodoc:
         if ActiveRecord::Relation === value
           value.to_sql
         else
@@ -150,10 +181,10 @@ sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
         end
       end
 
-      def replace_named_bind_variables(statement, bind_vars) #:nodoc:
-        statement.gsub(/(:?):([a-zA-Z]\w*)/) do
+      def replace_named_bind_variables(statement, bind_vars) # :nodoc:
+        statement.gsub(/(:?):([a-zA-Z]\w*)/) do |match|
           if $1 == ':' # skip postgresql casts
-            $& # return the whole match
+            match # return the whole match
           elsif bind_vars.include?(match = $2.to_sym)
             replace_bind_variable(bind_vars[match])
           else
@@ -162,10 +193,8 @@ sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
         end
       end
 
-      def quote_bound_value(value, c = connection, column = nil) #:nodoc:
-        if column
-          c.quote(value, column)
-        elsif value.respond_to?(:map) && !value.acts_like?(:string)
+      def quote_bound_value(value, c = connection) # :nodoc:
+        if value.respond_to?(:map) && !value.acts_like?(:string)
           if value.respond_to?(:empty?) && value.empty?
             c.quote(nil)
           else
@@ -176,7 +205,7 @@ sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
         end
       end
 
-      def raise_if_bind_arity_mismatch(statement, expected, provided) #:nodoc:
+      def raise_if_bind_arity_mismatch(statement, expected, provided) # :nodoc:
         unless expected == provided
           raise PreparedStatementInvalid, "wrong number of bind variables (#{provided} for #{expected}) in: #{statement}"
         end
@@ -184,8 +213,8 @@ sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
     end
 
     # TODO: Deprecate this
-    def quoted_id
-      self.class.quote_value(id, column_for_attribute(self.class.primary_key))
+    def quoted_id # :nodoc:
+      self.class.quote_value(@attributes[self.class.primary_key].value_for_database)
     end
   end
 end

data/lib/active_record/schema.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
-  # = Active Record Schema
+  # = Active Record \Schema
   #
   # Allows programmers to programmatically define a schema in a portable
   # DSL. This means you can define tables, indexes, etc. without using SQL
@@ -27,29 +27,12 @@ module ActiveRecord
   #
   # ActiveRecord::Schema is only supported by database adapters that also
   # support migrations, the two features being very similar.
-  class Schema < Migration
-
-    # Returns the migrations paths.
-    #
-    #   ActiveRecord::Schema.new.migrations_paths
-    #   # => ["db/migrate"] # Rails migration path by default.
-    def migrations_paths
-      ActiveRecord::Migrator.migrations_paths
-    end
-
-    def define(info, &block) # :nodoc:
-      instance_eval(&block)
-
-      unless info[:version].blank?
-        initialize_schema_migrations_table
-        connection.assume_migrated_upto_version(info[:version], migrations_paths)
-      end
-    end
-
+  class Schema < Migration::Current
     # Eval the given block. All methods available to the current connection
     # adapter are available within the block, so you can easily use the
-    # database definition DSL to build up your schema (+create_table+,
-    # +add_index+, etc.).
+    # database definition DSL to build up your schema (
+    # {create_table}[rdoc-ref:ConnectionAdapters::SchemaStatements#create_table],
+    # {add_index}[rdoc-ref:ConnectionAdapters::SchemaStatements#add_index], etc.).
     #
     # The +info+ hash is optional, and if given is used to define metadata
     # about the current schema (currently, only the schema's version):
@@ -60,5 +43,26 @@ module ActiveRecord
     def self.define(info={}, &block)
       new.define(info, &block)
     end
+
+    def define(info, &block) # :nodoc:
+      instance_eval(&block)
+
+      if info[:version].present?
+        initialize_schema_migrations_table
+        connection.assume_migrated_upto_version(info[:version], migrations_paths)
+      end
+
+      ActiveRecord::InternalMetadata.create_table
+      ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
+    end
+
+    private
+      # Returns the migrations paths.
+      #
+      #   ActiveRecord::Schema.new.migrations_paths
+      #   # => ["db/migrate"] # Rails migration path by default.
+      def migrations_paths # :nodoc:
+        ActiveRecord::Migrator.migrations_paths
+      end
   end
 end

data/lib/active_record/schema_dumper.rb

@@ -1,5 +1,4 @@
 require 'stringio'
-require 'active_support/core_ext/big_decimal'
 
 module ActiveRecord
   # = Active Record Schema Dumper
@@ -44,7 +43,6 @@ module ActiveRecord
 
       def initialize(connection, options = {})
         @connection = connection
-        @types = @connection.native_database_types
         @version = Migrator::current_version rescue nil
         @options = options
       end
@@ -52,10 +50,6 @@ module ActiveRecord
       def header(stream)
         define_params = @version ? "version: #{@version}" : ""
 
-        if stream.respond_to?(:external_encoding) && stream.external_encoding
-          stream.puts "# encoding: #{stream.external_encoding.name}"
-        end
-
         stream.puts <<HEADER
 # This file is auto-generated from the current state of the database. Instead
 # of editing this file, please use the migrations feature of Active Record to
@@ -91,7 +85,7 @@ HEADER
       end
 
       def tables(stream)
-        sorted_tables = @connection.tables.sort
+        sorted_tables = @connection.data_sources.sort - @connection.views
 
         sorted_tables.each do |table_name|
           table(table_name, stream) unless ignored?(table_name)
@@ -111,30 +105,46 @@ HEADER
           tbl = StringIO.new
 
           # first dump primary key column
-          pk = @connection.primary_key(table)
+          if @connection.respond_to?(:primary_keys)
+            pk = @connection.primary_keys(table)
+            pk = pk.first unless pk.size > 1
+          else
+            pk = @connection.primary_key(table)
+          end
 
           tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
-          pkcol = columns.detect { |c| c.name == pk }
-          if pkcol
-            if pk != 'id'
-              tbl.print %Q(, primary_key: "#{pk}")
-            elsif pkcol.sql_type == 'bigint'
-              tbl.print ", id: :bigserial"
-            elsif pkcol.sql_type == 'uuid'
-              tbl.print ", id: :uuid"
-              tbl.print %Q(, default: #{pkcol.default_function.inspect})
+
+          case pk
+          when String
+            tbl.print ", primary_key: #{pk.inspect}" unless pk == 'id'
+            pkcol = columns.detect { |c| c.name == pk }
+            pkcolspec = @connection.column_spec_for_primary_key(pkcol)
+            if pkcolspec.present?
+              pkcolspec.each do |key, value|
+                tbl.print ", #{key}: #{value}"
+              end
             end
+          when Array
+            tbl.print ", primary_key: #{pk.inspect}"
           else
             tbl.print ", id: false"
           end
           tbl.print ", force: :cascade"
+
+          table_options = @connection.table_options(table)
+          tbl.print ", options: #{table_options.inspect}" unless table_options.blank?
+
+          if comment = @connection.table_comment(table).presence
+            tbl.print ", comment: #{comment.inspect}"
+          end
+
           tbl.puts " do |t|"
 
           # then dump all non-primary key columns
           column_specs = columns.map do |column|
             raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
             next if column.name == pk
-            @connection.column_spec(column, @types)
+            @connection.column_spec(column)
           end.compact
 
           # find all migration keys used in this table
@@ -165,11 +175,11 @@ HEADER
             tbl.puts
           end
 
+          indexes_in_create(table, tbl)
+
           tbl.puts "  end"
           tbl.puts
 
-          indexes(table, tbl)
-
           tbl.rewind
           stream.print tbl.read
         rescue => e
@@ -181,26 +191,12 @@ HEADER
         stream
       end
 
+      # Keep it for indexing materialized views
       def indexes(table, stream)
         if (indexes = @connection.indexes(table)).any?
           add_index_statements = indexes.map do |index|
-            statement_parts = [
-              "add_index #{remove_prefix_and_suffix(index.table).inspect}",
-              index.columns.inspect,
-              "name: #{index.name.inspect}",
-            ]
-            statement_parts << 'unique: true' if index.unique
-
-            index_lengths = (index.lengths || []).compact
-            statement_parts << "length: #{Hash[index.columns.zip(index.lengths)].inspect}" if index_lengths.any?
-
-            index_orders = index.orders || {}
-            statement_parts << "order: #{index.orders.inspect}" if index_orders.any?
-            statement_parts << "where: #{index.where.inspect}" if index.where
-            statement_parts << "using: #{index.using.inspect}" if index.using
-            statement_parts << "type: #{index.type.inspect}" if index.type
-
-            "  #{statement_parts.join(', ')}"
+            table_name = remove_prefix_and_suffix(index.table).inspect
+            "  add_index #{([table_name]+index_parts(index)).join(', ')}"
           end
 
           stream.puts add_index_statements.sort.join("\n")
@@ -208,6 +204,34 @@ HEADER
         end
       end
 
+      def indexes_in_create(table, stream)
+        if (indexes = @connection.indexes(table)).any?
+          index_statements = indexes.map do |index|
+            "    t.index #{index_parts(index).join(', ')}"
+          end
+          stream.puts index_statements.sort.join("\n")
+        end
+      end
+
+      def index_parts(index)
+        index_parts = [
+          index.columns.inspect,
+          "name: #{index.name.inspect}",
+        ]
+        index_parts << 'unique: true' if index.unique
+
+        index_lengths = (index.lengths || []).compact
+        index_parts << "length: #{Hash[index.columns.zip(index.lengths)].inspect}" if index_lengths.any?
+
+        index_orders = index.orders || {}
+        index_parts << "order: #{index.orders.inspect}" if index_orders.any?
+        index_parts << "where: #{index.where.inspect}" if index.where
+        index_parts << "using: #{index.using.inspect}" if index.using
+        index_parts << "type: #{index.type.inspect}" if index.type
+        index_parts << "comment: #{index.comment.inspect}" if index.comment
+        index_parts
+      end
+
       def foreign_keys(table, stream)
         if (foreign_keys = @connection.foreign_keys(table)).any?
           add_foreign_key_statements = foreign_keys.map do |foreign_key|
@@ -243,7 +267,7 @@ HEADER
       end
 
       def ignored?(table_name)
-        ['schema_migrations', ignore_tables].flatten.any? do |ignored|
+        [ActiveRecord::Base.schema_migrations_table_name, ActiveRecord::Base.internal_metadata_table_name, ignore_tables].flatten.any? do |ignored|
           ignored === remove_prefix_and_suffix(table_name)
         end
       end

data/lib/active_record/schema_migration.rb

@@ -1,43 +1,37 @@
 require 'active_record/scoping/default'
 require 'active_record/scoping/named'
-require 'active_record/base'
 
 module ActiveRecord
-  class SchemaMigration < ActiveRecord::Base
+  # This class is used to create a table that keeps track of which migrations
+  # have been applied to a given database. When a migration is run, its schema
+  # number is inserted in to the `SchemaMigration.table_name` so it doesn't need
+  # to be executed the next time.
+  class SchemaMigration < ActiveRecord::Base # :nodoc:
     class << self
       def primary_key
-        nil
+        "version"
       end
 
       def table_name
         "#{table_name_prefix}#{ActiveRecord::Base.schema_migrations_table_name}#{table_name_suffix}"
       end
 
-      def index_name
-        "#{table_name_prefix}unique_#{ActiveRecord::Base.schema_migrations_table_name}#{table_name_suffix}"
-      end
-
       def table_exists?
-        connection.table_exists?(table_name)
+        ActiveSupport::Deprecation.silence { connection.table_exists?(table_name) }
       end
 
-      def create_table(limit=nil)
+      def create_table
         unless table_exists?
-          version_options = {null: false}
-          version_options[:limit] = limit if limit
+          version_options = connection.internal_string_options_for_primary_key
 
           connection.create_table(table_name, id: false) do |t|
-            t.column :version, :string, version_options
+            t.string :version, version_options
           end
-          connection.add_index table_name, :version, unique: true, name: index_name
         end
       end
 
       def drop_table
-        if table_exists?
-          connection.remove_index table_name, name: index_name
-          connection.drop_table(table_name)
-        end
+        connection.drop_table table_name, if_exists: true
       end
 
       def normalize_migration_number(number)

data/lib/active_record/scoping/default.rb

@@ -6,8 +6,10 @@ module ActiveRecord
       included do
         # Stores the default scope for the class.
         class_attribute :default_scopes, instance_writer: false, instance_predicate: false
+        class_attribute :default_scope_override, instance_writer: false, instance_predicate: false
 
         self.default_scopes = []
+        self.default_scope_override = nil
       end
 
       module ClassMethods
@@ -15,7 +17,7 @@ module ActiveRecord
         #
         #   class Post < ActiveRecord::Base
         #     def self.default_scope
-        #       where published: true
+        #       where(published: true)
         #     end
         #   end
         #
@@ -33,6 +35,11 @@ module ActiveRecord
           block_given? ? relation.scoping { yield } : relation
         end
 
+        # Are there attributes associated with this scope?
+        def scope_attributes? # :nodoc:
+          super || default_scopes.any? || respond_to?(:default_scope)
+        end
+
         def before_remove_const #:nodoc:
           self.current_scope = nil
         end
@@ -48,7 +55,7 @@ module ActiveRecord
         #
         #   Article.all # => SELECT * FROM articles WHERE published = true
         #
-        # The +default_scope+ is also applied while creating/building a record.
+        # The #default_scope is also applied while creating/building a record.
         # It is not applied while updating a record.
         #
         #   Article.new.published    # => true
@@ -58,7 +65,7 @@ module ActiveRecord
         # +default_scope+ macro, and it will be called when building the
         # default scope.)
         #
-        # If you use multiple +default_scope+ declarations in your model then
+        # If you use multiple #default_scope declarations in your model then
         # they will be merged together:
         #
         #   class Article < ActiveRecord::Base
@@ -69,7 +76,7 @@ module ActiveRecord
         #   Article.all # => SELECT * FROM articles WHERE published = true AND rating = 'G'
         #
         # This is also the case with inheritance and module includes where the
-        # parent or module defines a +default_scope+ and the child or including
+        # parent or module defines a #default_scope and the child or including
         # class defines a second one.
         #
         # If you need to do more complex things with a default scope, you can
@@ -94,26 +101,33 @@ module ActiveRecord
           self.default_scopes += [scope]
         end
 
-        def build_default_scope(base_rel = relation) # :nodoc:
+        def build_default_scope(base_rel = nil) # :nodoc:
           return if abstract_class?
-          if !Base.is_a?(method(:default_scope).owner)
+
+          if self.default_scope_override.nil?
+            self.default_scope_override = !Base.is_a?(method(:default_scope).owner)
+          end
+
+          if self.default_scope_override
             # The user has defined their own default scope method, so call that
             evaluate_default_scope { default_scope }
           elsif default_scopes.any?
+            base_rel ||= relation
             evaluate_default_scope do
               default_scopes.inject(base_rel) do |default_scope, scope|
-                default_scope.merge(base_rel.scoping { scope.call })
+                scope = scope.respond_to?(:to_proc) ? scope : scope.method(:call)
+                default_scope.merge(base_rel.instance_exec(&scope))
               end
             end
           end
         end
 
         def ignore_default_scope? # :nodoc:
-          ScopeRegistry.value_for(:ignore_default_scope, self)
+          ScopeRegistry.value_for(:ignore_default_scope, base_class)
         end
 
         def ignore_default_scope=(ignore) # :nodoc:
-          ScopeRegistry.set_value_for(:ignore_default_scope, self, ignore)
+          ScopeRegistry.set_value_for(:ignore_default_scope, base_class, ignore)
         end
 
         # The ignore_default_scope flag is used to prevent an infinite recursion