activerecord 6.0.0.beta2 → 6.0.2.rc1

data/lib/active_record/database_configurations/url_config.rb

@@ -17,17 +17,17 @@ module ActiveRecord
     #     @config={"adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost"},
     #     @url="postgres://localhost/foo">
     #
-    # Options are:
+    # ==== Options
     #
-    # <tt>:env_name</tt> - The Rails environment, ie "development"
-    # <tt>:spec_name</tt> - The specification name. In a standard two-tier
-    # database configuration this will default to "primary". In a multiple
-    # database three-tier database configuration this corresponds to the name
-    # used in the second tier, for example "primary_readonly".
-    # <tt>:url</tt> - The database URL.
-    # <tt>:config</tt> - The config hash. This is the hash that contains the
-    # database adapter, name, and other important information for database
-    # connections.
+    # * <tt>:env_name</tt> - The Rails environment, ie "development".
+    # * <tt>:spec_name</tt> - The specification name. In a standard two-tier
+    #   database configuration this will default to "primary". In a multiple
+    #   database three-tier database configuration this corresponds to the name
+    #   used in the second tier, for example "primary_readonly".
+    # * <tt>:url</tt> - The database URL.
+    # * <tt>:config</tt> - The config hash. This is the hash that contains the
+    #   database adapter, name, and other important information for database
+    #   connections.
     class UrlConfig < DatabaseConfig
       attr_reader :url, :config
 
@@ -42,14 +42,14 @@ module ActiveRecord
       end
 
       # Determines whether a database configuration is for a replica / readonly
-      # connection. If the `replica` key is present in the config, `replica?` will
+      # connection. If the +replica+ key is present in the config, +replica?+ will
       # return +true+.
       def replica?
         config["replica"]
       end
 
       # The migrations paths for a database configuration. If the
-      # `migrations_paths` key is present in the config, `migrations_paths`
+      # +migrations_paths+ key is present in the config, +migrations_paths+
       # will return its value.
       def migrations_paths
         config["migrations_paths"]

data/lib/active_record/dynamic_matchers.rb

@@ -53,7 +53,7 @@ module ActiveRecord
           @model           = model
           @name            = name.to_s
           @attribute_names = @name.match(self.class.pattern)[1].split("_and_")
-          @attribute_names.map! { |n| @model.attribute_aliases[n] || n }
+          @attribute_names.map! { |name| @model.attribute_aliases[name] || name }
         end
 
         def valid?

data/lib/active_record/enum.rb

@@ -31,7 +31,9 @@ module ActiveRecord
   # as well. With the above example:
   #
   #   Conversation.active
+  #   Conversation.not_active
   #   Conversation.archived
+  #   Conversation.not_archived
   #
   # Of course, you can also query them directly if the scopes don't fit your
   # needs:
@@ -196,9 +198,15 @@ module ActiveRecord
             define_method("#{value_method_name}!") { update!(attr => value) }
 
             # scope :active, -> { where(status: 0) }
+            # scope :not_active, -> { where.not(status: 0) }
             if enum_scopes != false
+              klass.send(:detect_negative_condition!, value_method_name)
+
               klass.send(:detect_enum_conflict!, name, value_method_name, true)
               klass.scope value_method_name, -> { where(attr => value) }
+
+              klass.send(:detect_enum_conflict!, name, "not_#{value_method_name}", true)
+              klass.scope "not_#{value_method_name}", -> { where.not(attr => value) }
             end
           end
         end
@@ -255,5 +263,12 @@ module ActiveRecord
           source: source
         }
       end
+
+      def detect_negative_condition!(method_name)
+        if method_name.start_with?("not_") && logger
+          logger.warn "An enum element in #{self.name} uses the prefix 'not_'." \
+            " This will cause a conflict with auto generated negative scopes."
+        end
+      end
   end
 end

data/lib/active_record/errors.rb

@@ -68,7 +68,7 @@ module ActiveRecord
 
   # Raised by {ActiveRecord::Base#save!}[rdoc-ref:Persistence#save!] and
   # {ActiveRecord::Base.create!}[rdoc-ref:Persistence::ClassMethods#create!]
-  # methods when a record is invalid and can not be saved.
+  # methods when a record is invalid and cannot be saved.
   class RecordNotSaved < ActiveRecordError
     attr_reader :record
 

data/lib/active_record/fixtures.rb

@@ -531,15 +531,15 @@ module ActiveRecord
         end
       end
 
-      def create_fixtures(fixtures_directory, fixture_set_names, class_names = {}, config = ActiveRecord::Base)
+      def create_fixtures(fixtures_directory, fixture_set_names, class_names = {}, config = ActiveRecord::Base, &block)
         fixture_set_names = Array(fixture_set_names).map(&:to_s)
         class_names = ClassCache.new class_names, config
 
         # FIXME: Apparently JK uses this.
-        connection = block_given? ? yield : ActiveRecord::Base.connection
+        connection = block_given? ? block : lambda { ActiveRecord::Base.connection }
 
         fixture_files_to_read = fixture_set_names.reject do |fs_name|
-          fixture_is_cached?(connection, fs_name)
+          fixture_is_cached?(connection.call, fs_name)
         end
 
         if fixture_files_to_read.any?
@@ -549,9 +549,9 @@ module ActiveRecord
             class_names,
             connection,
           )
-          cache_fixtures(connection, fixtures_map)
+          cache_fixtures(connection.call, fixtures_map)
         end
-        cached_fixtures(connection, fixture_set_names)
+        cached_fixtures(connection.call, fixture_set_names)
       end
 
       # Returns a consistent, platform-independent identifier for +label+.
@@ -591,7 +591,11 @@ module ActiveRecord
 
         def insert(fixture_sets, connection) # :nodoc:
           fixture_sets_by_connection = fixture_sets.group_by do |fixture_set|
-            fixture_set.model_class&.connection || connection
+            if fixture_set.model_class
+              fixture_set.model_class.connection
+            else
+              connection.call
+            end
           end
 
           fixture_sets_by_connection.each do |conn, set|
@@ -602,6 +606,7 @@ module ActiveRecord
                 table_rows_for_connection[table].unshift(*rows)
               end
             end
+
             conn.insert_fixtures_set(table_rows_for_connection, table_rows_for_connection.keys)
 
             # Cap primary key sequences to max(pk).

data/lib/active_record/gem_version.rb

@@ -9,8 +9,8 @@ module ActiveRecord
   module VERSION
     MAJOR = 6
     MINOR = 0
-    TINY  = 0
-    PRE   = "beta2"
+    TINY  = 2
+    PRE   = "rc1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/insert_all.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class InsertAll # :nodoc:
+    attr_reader :model, :connection, :inserts, :keys
+    attr_reader :on_duplicate, :returning, :unique_by
+
+    def initialize(model, inserts, on_duplicate:, returning: nil, unique_by: nil)
+      raise ArgumentError, "Empty list of attributes passed" if inserts.blank?
+
+      @model, @connection, @inserts, @keys = model, model.connection, inserts, inserts.first.keys.map(&:to_s).to_set
+      @on_duplicate, @returning, @unique_by = on_duplicate, returning, unique_by
+
+      @returning = (connection.supports_insert_returning? ? primary_keys : false) if @returning.nil?
+      @returning = false if @returning == []
+
+      @unique_by = find_unique_index_for(unique_by) if unique_by
+      @on_duplicate = :skip if @on_duplicate == :update && updatable_columns.empty?
+
+      ensure_valid_options_for_connection!
+    end
+
+    def execute
+      message = +"#{model} "
+      message << "Bulk " if inserts.many?
+      message << (on_duplicate == :update ? "Upsert" : "Insert")
+      connection.exec_insert_all to_sql, message
+    end
+
+    def updatable_columns
+      keys - readonly_columns - unique_by_columns
+    end
+
+    def primary_keys
+      Array(model.primary_key)
+    end
+
+
+    def skip_duplicates?
+      on_duplicate == :skip
+    end
+
+    def update_duplicates?
+      on_duplicate == :update
+    end
+
+    def map_key_with_value
+      inserts.map do |attributes|
+        attributes = attributes.stringify_keys
+        verify_attributes(attributes)
+
+        keys.map do |key|
+          yield key, attributes[key]
+        end
+      end
+    end
+
+    private
+      def find_unique_index_for(unique_by)
+        match = Array(unique_by).map(&:to_s)
+
+        if index = unique_indexes.find { |i| match.include?(i.name) || i.columns == match }
+          index
+        else
+          raise ArgumentError, "No unique index found for #{unique_by}"
+        end
+      end
+
+      def unique_indexes
+        connection.schema_cache.indexes(model.table_name).select(&:unique)
+      end
+
+
+      def ensure_valid_options_for_connection!
+        if returning && !connection.supports_insert_returning?
+          raise ArgumentError, "#{connection.class} does not support :returning"
+        end
+
+        if skip_duplicates? && !connection.supports_insert_on_duplicate_skip?
+          raise ArgumentError, "#{connection.class} does not support skipping duplicates"
+        end
+
+        if update_duplicates? && !connection.supports_insert_on_duplicate_update?
+          raise ArgumentError, "#{connection.class} does not support upsert"
+        end
+
+        if unique_by && !connection.supports_insert_conflict_target?
+          raise ArgumentError, "#{connection.class} does not support :unique_by"
+        end
+      end
+
+
+      def to_sql
+        connection.build_insert_sql(ActiveRecord::InsertAll::Builder.new(self))
+      end
+
+
+      def readonly_columns
+        primary_keys + model.readonly_attributes.to_a
+      end
+
+      def unique_by_columns
+        Array(unique_by&.columns)
+      end
+
+
+      def verify_attributes(attributes)
+        if keys != attributes.keys.to_set
+          raise ArgumentError, "All objects being inserted must have the same keys"
+        end
+      end
+
+      class Builder # :nodoc:
+        attr_reader :model
+
+        delegate :skip_duplicates?, :update_duplicates?, :keys, to: :insert_all
+
+        def initialize(insert_all)
+          @insert_all, @model, @connection = insert_all, insert_all.model, insert_all.connection
+        end
+
+        def into
+          "INTO #{model.quoted_table_name}(#{columns_list})"
+        end
+
+        def values_list
+          types = extract_types_from_columns_on(model.table_name, keys: keys)
+
+          values_list = insert_all.map_key_with_value do |key, value|
+            connection.with_yaml_fallback(types[key].serialize(value))
+          end
+
+          Arel::InsertManager.new.create_values_list(values_list).to_sql
+        end
+
+        def returning
+          format_columns(insert_all.returning) if insert_all.returning
+        end
+
+        def conflict_target
+          if index = insert_all.unique_by
+            sql = +"(#{format_columns(index.columns)})"
+            sql << " WHERE #{index.where}" if index.where
+            sql
+          elsif update_duplicates?
+            "(#{format_columns(insert_all.primary_keys)})"
+          end
+        end
+
+        def updatable_columns
+          quote_columns(insert_all.updatable_columns)
+        end
+
+        private
+          attr_reader :connection, :insert_all
+
+          def columns_list
+            format_columns(insert_all.keys)
+          end
+
+          def extract_types_from_columns_on(table_name, keys:)
+            columns = connection.schema_cache.columns_hash(table_name)
+
+            unknown_column = (keys - columns.keys).first
+            raise UnknownAttributeError.new(model.new, unknown_column) if unknown_column
+
+            keys.map { |key| [ key, connection.lookup_cast_type_from_column(columns[key]) ] }.to_h
+          end
+
+          def format_columns(columns)
+            quote_columns(columns).join(",")
+          end
+
+          def quote_columns(columns)
+            columns.map(&connection.method(:quote_column_name))
+          end
+      end
+  end
+end

data/lib/active_record/integration.rb

@@ -22,6 +22,14 @@ module ActiveRecord
       #
       # This is +true+, by default on Rails 5.2 and above.
       class_attribute :cache_versioning, instance_writer: false, default: false
+
+      ##
+      # :singleton-method:
+      # Indicates whether to use a stable #cache_key method that is accompanied
+      # by a changing version in the #cache_version method on collections.
+      #
+      # This is +false+, by default until Rails 6.1.
+      class_attribute :collection_cache_versioning, instance_writer: false, default: false
     end
 
     # Returns a +String+, which Action Pack uses for constructing a URL to this
@@ -152,6 +160,10 @@ module ActiveRecord
           end
         end
       end
+
+      def collection_cache_key(collection = all, timestamp_column = :updated_at) # :nodoc:
+        collection.send(:compute_cache_key, timestamp_column)
+      end
     end
 
     private
@@ -180,7 +192,7 @@ module ActiveRecord
       #   raw_timestamp_to_cache_version(timestamp)
       #   # => "20181015200215266505"
       #
-      # Postgres truncates trailing zeros,
+      # PostgreSQL truncates trailing zeros,
       # https://github.com/postgres/postgres/commit/3e1beda2cde3495f41290e1ece5d544525810214
       # to account for this we pad the output with zeros
       def raw_timestamp_to_cache_version(timestamp)

data/lib/active_record/internal_metadata.rb

@@ -17,7 +17,7 @@ module ActiveRecord
       end
 
       def table_name
-        "#{table_name_prefix}#{ActiveRecord::Base.internal_metadata_table_name}#{table_name_suffix}"
+        "#{table_name_prefix}#{internal_metadata_table_name}#{table_name_suffix}"
       end
 
       def []=(key, value)
@@ -44,6 +44,10 @@ module ActiveRecord
           end
         end
       end
+
+      def drop_table
+        connection.drop_table table_name, if_exists: true
+      end
     end
   end
 end

data/lib/active_record/locking/optimistic.rb

@@ -71,9 +71,8 @@ module ActiveRecord
         end
 
         def _touch_row(attribute_names, time)
+          @_touch_attr_names << self.class.locking_column if locking_enabled?
           super
-        ensure
-          clear_attribute_change(self.class.locking_column) if locking_enabled?
         end
 
         def _update_row(attribute_names, attempted_action = "update")
@@ -88,7 +87,7 @@ module ActiveRecord
 
             affected_rows = self.class._update_record(
               attributes_with_values(attribute_names),
-              self.class.primary_key => id_in_database,
+              @primary_key => id_in_database,
               locking_column => previous_lock_value
             )
 
@@ -111,7 +110,7 @@ module ActiveRecord
           locking_column = self.class.locking_column
 
           affected_rows = self.class._delete_record(
-            self.class.primary_key => id_in_database,
+            @primary_key => id_in_database,
             locking_column => read_attribute_before_type_cast(locking_column)
           )
 

data/lib/active_record/log_subscriber.rb

@@ -110,7 +110,7 @@ module ActiveRecord
       end
 
       def extract_query_source_location(locations)
-        backtrace_cleaner.clean(locations).first
+        backtrace_cleaner.clean(locations.lazy).first
       end
   end
 end

data/lib/active_record/middleware/database_selector.rb

@@ -35,10 +35,10 @@ module ActiveRecord
     #   config.active_record.database_resolver = MyResolver
     #   config.active_record.database_resolver_context = MyResolver::MySession
     class DatabaseSelector
-      def initialize(app, resolver_klass = Resolver, context_klass = Resolver::Session, options = {})
+      def initialize(app, resolver_klass = nil, context_klass = nil, options = {})
         @app = app
-        @resolver_klass = resolver_klass
-        @context_klass = context_klass
+        @resolver_klass = resolver_klass || Resolver
+        @context_klass = context_klass || Resolver::Session
         @options = options
       end