1 files changed, 19 insertions, 30 deletions

diff --git a/activerecord/lib/active_record/relation.rb b/activerecord/lib/active_record/relation.rb
index 2d3e1eaa08..806f8a1cbb 100644
--- a/activerecord/lib/active_record/relation.rb
+++ b/activerecord/lib/active_record/relation.rb
@@ -62,7 +62,7 @@ module ActiveRecord
     #   user = users.new { |user| user.name = 'Oscar' }
     #   user.name # => Oscar
     def new(attributes = nil, &block)
-      scoping { klass.new(scope_for_create(attributes), &block) }
+      scoping { klass.new(attributes, &block) }
     end
 
     alias build new
@@ -87,11 +87,7 @@ module ActiveRecord
     #   users.create(name: nil) # validation on name
     #   # => #<User id: nil, name: nil, ...>
     def create(attributes = nil, &block)
-      if attributes.is_a?(Array)
-        attributes.collect { |attr| create(attr, &block) }
-      else
-        scoping { klass.create(scope_for_create(attributes), &block) }
-      end
+      scoping { klass.create(attributes, &block) }
     end
 
     # Similar to #create, but calls
@@ -101,11 +97,7 @@ module ActiveRecord
     # Expects arguments in the same format as
     # {ActiveRecord::Base.create!}[rdoc-ref:Persistence::ClassMethods#create!].
     def create!(attributes = nil, &block)
-      if attributes.is_a?(Array)
-        attributes.collect { |attr| create!(attr, &block) }
-      else
-        scoping { klass.create!(scope_for_create(attributes), &block) }
-      end
+      scoping { klass.create!(attributes, &block) }
     end
 
     def first_or_create(attributes = nil, &block) # :nodoc:
@@ -315,10 +307,7 @@ module ActiveRecord
     # Please check unscoped if you want to remove all previous scopes (including
     # the default_scope) during the execution of a block.
     def scoping
-      previous, klass.current_scope = klass.current_scope(true), self unless @delegate_to_klass
-      yield
-    ensure
-      klass.current_scope = previous unless @delegate_to_klass
+      @delegate_to_klass ? yield : klass._scoping(self) { yield }
     end
 
     def _exec_scope(*args, &block) # :nodoc:
@@ -360,7 +349,7 @@ module ActiveRecord
 
       stmt = Arel::UpdateManager.new
 
-      stmt.set Arel.sql(@klass.sanitize_sql_for_assignment(updates))
+      stmt.set Arel.sql(@klass.sanitize_sql_for_assignment(updates, table.name))
       stmt.table(table)
 
       if has_join_values? || offset_value
@@ -375,8 +364,12 @@ module ActiveRecord
       @klass.connection.update stmt, "#{@klass} Update All"
     end
 
-    def update(attributes) # :nodoc:
-      each { |record| record.update(attributes) }
+    def update(id = :all, attributes) # :nodoc:
+      if id == :all
+        each { |record| record.update(attributes) }
+      else
+        klass.update(id, attributes)
+      end
     end
 
     def update_counters(counters) # :nodoc:
@@ -384,14 +377,14 @@ module ActiveRecord
 
       updates = counters.map do |counter_name, value|
         operator = value < 0 ? "-" : "+"
-        quoted_column = connection.quote_column_name(counter_name)
+        quoted_column = connection.quote_table_name_for_assignment(table.name, counter_name)
         "#{quoted_column} = COALESCE(#{quoted_column}, 0) #{operator} #{value.abs}"
       end
 
       if touch
         names = touch if touch != true
         touch_updates = klass.touch_attributes_with_time(*names)
-        updates << klass.sanitize_sql_for_assignment(touch_updates) unless touch_updates.empty?
+        updates << klass.sanitize_sql_for_assignment(touch_updates, table.name) unless touch_updates.empty?
       end
 
       update_all updates.join(", ")
@@ -421,14 +414,12 @@ module ActiveRecord
     #   Person.where(name: 'David').touch_all
     #   # => "UPDATE \"people\" SET \"updated_at\" = '2018-01-04 22:55:23.132670' WHERE \"people\".\"name\" = 'David'"
     def touch_all(*names, time: nil)
-      updates = touch_attributes_with_time(*names, time: time)
-
       if klass.locking_enabled?
-        quoted_locking_column = connection.quote_column_name(klass.locking_column)
-        updates = sanitize_sql_for_assignment(updates) + ", #{quoted_locking_column} = COALESCE(#{quoted_locking_column}, 0) + 1"
+        names << { time: time }
+        update_counters(klass.locking_column => 1, touch: names)
+      else
+        update_all klass.touch_attributes_with_time(*names, time: time)
       end
-
-      update_all(updates)
     end
 
     # Destroys the records by instantiating each
@@ -550,10 +541,8 @@ module ActiveRecord
       where_clause.to_h(relation_table_name)
     end
 
-    def scope_for_create(attributes = nil)
-      scope = where_values_hash.merge!(create_with_value.stringify_keys)
-      scope.merge!(attributes) if attributes
-      scope
+    def scope_for_create
+      where_values_hash.merge!(create_with_value.stringify_keys)
     end
 
     # Returns true if relation needs eager loading.