activerecord 5.0.7.2 → 6.1.1

data/lib/active_record/errors.rb

@@ -1,11 +1,16 @@
-module ActiveRecord
+# frozen_string_literal: true
 
+module ActiveRecord
   # = Active Record Errors
   #
   # Generic Active Record exception class.
   class ActiveRecordError < StandardError
   end
 
+  # Raised when trying to use a feature in Active Record which requires Active Job but the gem is not present.
+  class ActiveJobRequiredError < ActiveRecordError
+  end
+
   # Raised when the single-table inheritance mechanism fails to locate the subclass
   # (for example due to improper usage of column that
   # {ActiveRecord::Base.inheritance_column}[rdoc-ref:ModelSchema::ClassMethods#inheritance_column]
@@ -37,6 +42,10 @@ module ActiveRecord
   class AdapterNotSpecified < ActiveRecordError
   end
 
+  # Raised when a model makes a query but it has not specified an associated table.
+  class TableNotSpecified < ActiveRecordError
+  end
+
   # Raised when Active Record cannot find database adapter specified in
   # +config/database.yml+ or programmatically.
   class AdapterNotFound < ActiveRecordError
@@ -44,10 +53,27 @@ module ActiveRecord
 
   # Raised when connection to the database could not been established (for example when
   # {ActiveRecord::Base.connection=}[rdoc-ref:ConnectionHandling#connection]
-  # is given a nil object).
+  # is given a +nil+ object).
   class ConnectionNotEstablished < ActiveRecordError
   end
 
+  # Raised when a connection could not be obtained within the connection
+  # acquisition timeout period: because max connections in pool
+  # are in use.
+  class ConnectionTimeoutError < ConnectionNotEstablished
+  end
+
+  # Raised when a pool was unable to get ahold of all its connections
+  # to perform a "group" action such as
+  # {ActiveRecord::Base.connection_pool.disconnect!}[rdoc-ref:ConnectionAdapters::ConnectionPool#disconnect!]
+  # or {ActiveRecord::Base.clear_reloadable_connections!}[rdoc-ref:ConnectionAdapters::ConnectionHandler#clear_reloadable_connections!].
+  class ExclusiveConnectionTimeoutError < ConnectionTimeoutError
+  end
+
+  # Raised when a write to the database is attempted on a read only connection.
+  class ReadOnlyError < ActiveRecordError
+  end
+
   # Raised when Active Record cannot find a record by given id or set of ids.
   class RecordNotFound < ActiveRecordError
     attr_reader :model, :primary_key, :id
@@ -63,7 +89,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
 
@@ -96,20 +122,13 @@ module ActiveRecord
   #
   # Wraps the underlying database error as +cause+.
   class StatementInvalid < ActiveRecordError
-
-    def initialize(message = nil, original_exception = nil)
-      if original_exception
-        ActiveSupport::Deprecation.warn("Passing #original_exception is deprecated and has no effect. " \
-                                        "Exceptions will automatically capture the original exception.", caller)
-      end
-
-      super(message || $!.try(:message))
+    def initialize(message = nil, sql: nil, binds: nil)
+      super(message || $!&.message)
+      @sql = sql
+      @binds = binds
     end
 
-    def original_exception
-      ActiveSupport::Deprecation.warn("#original_exception is deprecated. Use #cause instead.", caller)
-      cause
-    end
+    attr_reader :sql, :binds
   end
 
   # Defunct wrapper class kept for compatibility.
@@ -117,21 +136,63 @@ module ActiveRecord
   class WrappedDatabaseException < StatementInvalid
   end
 
-  # Raised when a record cannot be inserted because it would violate a uniqueness constraint.
+  # Raised when a record cannot be inserted or updated because it would violate a uniqueness constraint.
   class RecordNotUnique < WrappedDatabaseException
   end
 
-  # Raised when a record cannot be inserted or updated because it references a non-existent record.
+  # Raised when a record cannot be inserted or updated because it references a non-existent record,
+  # or when a record cannot be deleted because a parent record references it.
   class InvalidForeignKey < WrappedDatabaseException
   end
 
+  # Raised when a foreign key constraint cannot be added because the column type does not match the referenced column type.
+  class MismatchedForeignKey < StatementInvalid
+    def initialize(
+      message: nil,
+      sql: nil,
+      binds: nil,
+      table: nil,
+      foreign_key: nil,
+      target_table: nil,
+      primary_key: nil,
+      primary_key_column: nil
+    )
+      if table
+        type = primary_key_column.bigint? ? :bigint : primary_key_column.type
+        msg = <<~EOM.squish
+          Column `#{foreign_key}` on table `#{table}` does not match column `#{primary_key}` on `#{target_table}`,
+          which has type `#{primary_key_column.sql_type}`.
+          To resolve this issue, change the type of the `#{foreign_key}` column on `#{table}` to be :#{type}.
+          (For example `t.#{type} :#{foreign_key}`).
+        EOM
+      else
+        msg = <<~EOM.squish
+          There is a mismatch between the foreign key and primary key column types.
+          Verify that the foreign key column type and the primary key of the associated table match types.
+        EOM
+      end
+      if message
+        msg << "\nOriginal message: #{message}"
+      end
+      super(msg, sql: sql, binds: binds)
+    end
+  end
+
+  # Raised when a record cannot be inserted or updated because it would violate a not null constraint.
+  class NotNullViolation < StatementInvalid
+  end
+
   # Raised when a record cannot be inserted or updated because a value too long for a column type.
   class ValueTooLong < StatementInvalid
   end
 
-  # Raised when number of bind variables in statement given to +:condition+ key
-  # (for example, when using {ActiveRecord::Base.find}[rdoc-ref:FinderMethods#find] method)
-  # does not match number of expected values supplied.
+  # Raised when values that executed are out of range.
+  class RangeError < StatementInvalid
+  end
+
+  # Raised when the number of placeholders in an SQL fragment passed to
+  # {ActiveRecord::Base.where}[rdoc-ref:QueryMethods#where]
+  # does not match the number of values supplied.
   #
   # For example, when there are two placeholders with only one value supplied:
   #
@@ -143,7 +204,11 @@ module ActiveRecord
   class NoDatabaseError < StatementInvalid
   end
 
-  # Raised when Postgres returns 'cached plan must not change result type' and
+  # Raised when creating a database if it exists.
+  class DatabaseAlreadyExists < StatementInvalid
+  end
+
+  # Raised when PostgreSQL returns 'cached plan must not change result type' and
   # we cannot retry gracefully (e.g. inside a transaction)
   class PreparedStatementCacheExpired < StatementInvalid
   end
@@ -166,7 +231,6 @@ module ActiveRecord
         super("Stale object error.")
       end
     end
-
   end
 
   # Raised when association is being configured improperly or user tries to use
@@ -181,6 +245,10 @@ module ActiveRecord
   class ReadOnlyRecord < ActiveRecordError
   end
 
+  # Raised on attempt to lazily load records that are marked as strict loading.
+  class StrictLoadingViolationError < ActiveRecordError
+  end
+
   # {ActiveRecord::Base.transaction}[rdoc-ref:Transactions::ClassMethods#transaction]
   # uses this exception to distinguish a deliberate rollback from other exceptional situations.
   # Normally, raising an exception will cause the
@@ -285,8 +353,71 @@ module ActiveRecord
   class TransactionIsolationError < ActiveRecordError
   end
 
+  # TransactionRollbackError will be raised when a transaction is rolled
+  # back by the database due to a serialization failure or a deadlock.
+  #
+  # See the following:
+  #
+  # * https://www.postgresql.org/docs/current/static/transaction-iso.html
+  # * https://dev.mysql.com/doc/mysql-errors/en/server-error-reference.html#error_er_lock_deadlock
+  class TransactionRollbackError < StatementInvalid
+  end
+
+  # SerializationFailure will be raised when a transaction is rolled
+  # back by the database due to a serialization failure.
+  class SerializationFailure < TransactionRollbackError
+  end
+
+  # Deadlocked will be raised when a transaction is rolled
+  # back by the database when a deadlock is encountered.
+  class Deadlocked < TransactionRollbackError
+  end
+
   # IrreversibleOrderError is raised when a relation's order is too complex for
   # +reverse_order+ to automatically reverse.
   class IrreversibleOrderError < ActiveRecordError
   end
+
+  # Superclass for errors that have been aborted (either by client or server).
+  class QueryAborted < StatementInvalid
+  end
+
+  # LockWaitTimeout will be raised when lock wait timeout exceeded.
+  class LockWaitTimeout < StatementInvalid
+  end
+
+  # StatementTimeout will be raised when statement timeout exceeded.
+  class StatementTimeout < QueryAborted
+  end
+
+  # QueryCanceled will be raised when canceling statement due to user request.
+  class QueryCanceled < QueryAborted
+  end
+
+  # AdapterTimeout will be raised when database clients times out while waiting from the server.
+  class AdapterTimeout < QueryAborted
+  end
+
+  # UnknownAttributeReference is raised when an unknown and potentially unsafe
+  # value is passed to a query method. For example, passing a non column name
+  # value to a relation's #order method might cause this exception.
+  #
+  # When working around this exception, caution should be taken to avoid SQL
+  # injection vulnerabilities when passing user-provided values to query
+  # methods. Known-safe values can be passed to query methods by wrapping them
+  # in Arel.sql.
+  #
+  # For example, the following code would raise this exception:
+  #
+  #   Post.order("length(title)").first
+  #
+  # The desired result can be accomplished by wrapping the known-safe string
+  # in Arel.sql:
+  #
+  #   Post.order(Arel.sql("length(title)")).first
+  #
+  # Again, such a workaround should *not* be used when passing user-provided
+  # values, such as request parameters or model attributes to query methods.
+  class UnknownAttributeReference < ActiveRecordError
+  end
 end

data/lib/active_record/explain.rb

@@ -1,5 +1,6 @@
-require 'active_support/lazy_load_hooks'
-require 'active_record/explain_registry'
+# frozen_string_literal: true
+
+require "active_record/explain_registry"
 
 module ActiveRecord
   module Explain
@@ -17,7 +18,7 @@ module ActiveRecord
     # Returns a formatted string ready to be logged.
     def exec_explain(queries) # :nodoc:
       str = queries.map do |sql, binds|
-        msg = "EXPLAIN for: #{sql}"
+        msg = +"EXPLAIN for: #{sql}"
         unless binds.empty?
           msg << " "
           msg << binds.map { |attr| render_bind(attr) }.inspect
@@ -35,15 +36,19 @@ module ActiveRecord
     end
 
     private
-
       def render_bind(attr)
-        value = if attr.type.binary? && attr.value
-          "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+        if ActiveModel::Attribute === attr
+          value = if attr.type.binary? && attr.value
+            "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+          else
+            connection.type_cast(attr.value_for_database)
+          end
         else
-          connection.type_cast(attr.value_for_database)
+          value = connection.type_cast(attr)
+          attr  = nil
         end
 
-        [attr.name, value]
+        [attr&.name, value]
       end
   end
 end

data/lib/active_record/explain_registry.rb

@@ -1,4 +1,6 @@
-require 'active_support/per_thread_registry'
+# frozen_string_literal: true
+
+require "active_support/per_thread_registry"
 
 module ActiveRecord
   # This is a thread locals registry for EXPLAIN. For example

data/lib/active_record/explain_subscriber.rb

@@ -1,5 +1,7 @@
-require 'active_support/notifications'
-require 'active_record/explain_registry'
+# frozen_string_literal: true
+
+require "active_support/notifications"
+require "active_record/explain_registry"
 
 module ActiveRecord
   class ExplainSubscriber # :nodoc:
@@ -18,10 +20,13 @@ module ActiveRecord
     #
     # On the other hand, we want to monitor the performance of our real database
     # queries, not the performance of the access to the query cache.
-    IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN CACHE)
+    IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN)
     EXPLAINED_SQLS = /\A\s*(with|select|update|delete|insert)\b/i
     def ignore_payload?(payload)
-      payload[:exception] || IGNORED_PAYLOADS.include?(payload[:name]) || payload[:sql] !~ EXPLAINED_SQLS
+      payload[:exception] ||
+        payload[:cached] ||
+        IGNORED_PAYLOADS.include?(payload[:name]) ||
+        !payload[:sql].match?(EXPLAINED_SQLS)
     end
 
     ActiveSupport::Notifications.subscribe("sql.active_record", new)

data/lib/active_record/fixture_set/file.rb

@@ -1,5 +1,6 @@
-require 'erb'
-require 'yaml'
+# frozen_string_literal: true
+
+require "active_support/configuration_file"
 
 module ActiveRecord
   class FixtureSet
@@ -24,52 +25,49 @@ module ActiveRecord
       end
 
       def model_class
-        config_row['model_class']
+        config_row["model_class"]
+      end
+
+      def ignored_fixtures
+        config_row["ignore"]
       end
 
       private
         def rows
-          @rows ||= raw_rows.reject { |fixture_name, _| fixture_name == '_fixture' }
+          @rows ||= raw_rows.reject { |fixture_name, _| fixture_name == "_fixture" }
         end
 
         def config_row
           @config_row ||= begin
-            row = raw_rows.find { |fixture_name, _| fixture_name == '_fixture' }
+            row = raw_rows.find { |fixture_name, _| fixture_name == "_fixture" }
             if row
               row.last
             else
-              {'model_class': nil}
+              { 'model_class': nil, 'ignore': nil }
             end
           end
         end
 
         def raw_rows
           @raw_rows ||= begin
-            data = YAML.load(render(IO.read(@file)))
+            data = ActiveSupport::ConfigurationFile.parse(@file, context:
+              ActiveRecord::FixtureSet::RenderContext.create_subclass.new.get_binding)
             data ? validate(data).to_a : []
-          rescue ArgumentError, Psych::SyntaxError => error
-            raise Fixture::FormatError, "a YAML error occurred parsing #{@file}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{error.class}: #{error}", error.backtrace
+          rescue RuntimeError => error
+            raise Fixture::FormatError, error.message
           end
         end
 
-        def prepare_erb(content)
-          erb = ERB.new(content)
-          erb.filename = @file
-          erb
-        end
-
-        def render(content)
-          context = ActiveRecord::FixtureSet::RenderContext.create_subclass.new
-          prepare_erb(content).result(context.get_binding)
-        end
-
         # Validate our unmarshalled data.
         def validate(data)
           unless Hash === data || YAML::Omap === data
-            raise Fixture::FormatError, 'fixture is not a hash'
+            raise Fixture::FormatError, "fixture is not a hash: #{@file}"
           end
 
-          raise Fixture::FormatError unless data.all? { |name, row| Hash === row }
+          invalid = data.reject { |_, row| Hash === row }
+          if invalid.any?
+            raise Fixture::FormatError, "fixture key is not a hash: #{@file}, keys: #{invalid.keys.inspect}"
+          end
           data
         end
     end

data/lib/active_record/fixture_set/model_metadata.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class FixtureSet
+    class ModelMetadata # :nodoc:
+      def initialize(model_class)
+        @model_class = model_class
+      end
+
+      def primary_key_name
+        @primary_key_name ||= @model_class && @model_class.primary_key
+      end
+
+      def primary_key_type
+        @primary_key_type ||= @model_class && @model_class.type_for_attribute(@model_class.primary_key).type
+      end
+
+      def has_primary_key_column?
+        @has_primary_key_column ||= primary_key_name &&
+          @model_class.columns.any? { |col| col.name == primary_key_name }
+      end
+
+      def timestamp_column_names
+        @model_class.all_timestamp_attributes_in_model
+      end
+
+      def inheritance_column_name
+        @inheritance_column_name ||= @model_class && @model_class.inheritance_column
+      end
+    end
+  end
+end