-
Fix
AS::MessagePack
withENV["RAILS_MAX_THREADS"]
.Jonathan Hefner
-
Add a new public API for broadcasting logs
This feature existed for a while but was until now a private API.
Broadcasting log allows to send log message to difference sinks (STDOUT, a file ...) and
is used by default in the development environment to write logs both on STDOUT and in the
"development.log" file.Basic usage:
stdout_logger = Logger.new(STDOUT) file_logger = Logger.new("development.log") broadcast = ActiveSupport::BroadcastLogger.new(stdout_logger, file_logger) broadcast.info("Hello!") # The "Hello!" message is written on STDOUT and in the log file.
Adding other sink(s) to the broadcast:
broadcast = ActiveSupport::BroadcastLogger.new broadcast.broadcast_to(Logger.new(STDERR))
Remove a sink from the broadcast:
stdout_logger = Logger.new(STDOUT) broadcast = ActiveSupport::BroadcastLogger.new(stdout_logger) broadcast.stop_broadcasting_to(stdout_logger)
Edouard Chin
-
Fix Range#overlap? not taking empty ranges into account on Ruby < 3.3
Nobuyoshi Nakada, Shouichi Kamiya, Hartley McGuire
-
Use Ruby 3.3 Range#overlap? if available
Yasuo Honda
-
Add
bigdecimal
as Active Support dependency that is a bundled gem candidate for Ruby 3.4.bigdecimal
3.1.4 or higher version will be installed.
Ruby 2.7 and 3.0 users who wantbigdecimal
version 2.0.0 or 3.0.0 behavior as a default gem,
pin thebigdecimal
version in your application Gemfile.Koichi ITO
-
Add
drb
,mutex_m
andbase64
that are bundled gem candidates for Ruby 3.4Yasuo Honda
-
When using cache format version >= 7.1 or a custom serializer, expired and
version-mismatched cache entries can now be detected without deserializing
their values.Jonathan Hefner
-
Make all cache stores return a boolean for
#delete
Previously the
RedisCacheStore#delete
would return1
if the entry
exists and0
otherwise. Now it returns true if the entry exists and false
otherwise, just like the other stores.The
FileStore
would returnnil
if the entry doesn't exists and returns
false
now as well.Petrik de Heus
-
Active Support cache stores now support replacing the default compressor via
a:compressor
option. The specified compressor must respond todeflate
andinflate
. For example:module MyCompressor def self.deflate(string) # compression logic... end def self.inflate(compressed) # decompression logic... end end config.cache_store = :redis_cache_store, { compressor: MyCompressor }
Jonathan Hefner
-
Active Support cache stores now support a
:serializer
option. Similar to
the:coder
option, serializers must respond todump
andload
. However,
serializers are only responsible for serializing a cached value, whereas
coders are responsible for serializing the entireActiveSupport::Cache::Entry
instance. Additionally, the output from serializers can be automatically
compressed, whereas coders are responsible for their own compression.Specifying a serializer instead of a coder also enables performance
optimizations, including the bare string optimization introduced by cache
format version 7.1.The
:serializer
and:coder
options are mutually exclusive. Specifying
both will raise anArgumentError
.Jonathan Hefner
-
Fix
ActiveSupport::Inflector.humanize(nil)
raisingNoMethodError: undefined method `end_with?' for nil:NilClass
.James Robinson
-
Don't show secrets for
ActiveSupport::KeyGenerator#inspect
.Before:
ActiveSupport::KeyGenerator.new(secret).inspect "#<ActiveSupport::KeyGenerator:0x0000000104888038 ... @secret=\"\\xAF\\bFh]LV}q\\nl\\xB2U\\xB3 ... >"
After:
ActiveSupport::KeyGenerator::Aes256Gcm(secret).inspect "#<ActiveSupport::KeyGenerator:0x0000000104888038>"
Petrik de Heus
-
Improve error message when EventedFileUpdateChecker is used without a
compatible version of the Listen gemHartley McGuire
-
Add
:report
behavior for DeprecationSetting
config.active_support.deprecation = :report
uses the error
reporter to report deprecation warnings toActiveSupport::ErrorReporter
.Deprecations are reported as handled errors, with a severity of
:warning
.Useful to report deprecations happening in production to your bug tracker.
Étienne Barrié
-
Rename
Range#overlaps?
to#overlap?
and add alias for backwards compatibilityChristian Schmidt
-
Fix
EncryptedConfiguration
returning incorrect values for someHash
methodsHartley McGuire
-
Don't show secrets for
MessageEncryptor#inspect
.Before:
ActiveSupport::MessageEncryptor.new(secret, cipher: "aes-256-gcm").inspect "#<ActiveSupport::MessageEncryptor:0x0000000104888038 ... @secret=\"\\xAF\\bFh]LV}q\\nl\\xB2U\\xB3 ... >"
After:
ActiveSupport::MessageEncryptor.new(secret, cipher: "aes-256-gcm").inspect "#<ActiveSupport::MessageEncryptor:0x0000000104888038>"
Petrik de Heus
-
Don't show contents for
EncryptedConfiguration#inspect
.Before:
Rails.application.credentials.inspect "#<ActiveSupport::EncryptedConfiguration:0x000000010d2b38e8 ... @config={:secret=>\"something secret\"} ... @key_file_contents=\"915e4ea054e011022398dc242\" ...>"
After:
Rails.application.credentials.inspect "#<ActiveSupport::EncryptedConfiguration:0x000000010d2b38e8>"
Petrik de Heus
-
ERB::Util.html_escape_once
always returns anhtml_safe
string.This method previously maintained the
html_safe?
property of a string on the return
value. Because this string has been escaped, however, not marking it ashtml_safe
causes
entities to be double-escaped.As an example, take this view snippet:
<p><%= html_escape_once("this & that & the other") %></p>
Before this change, that would be double-escaped and render as:
<p>this &amp; that &amp; the other</p>
After this change, it renders correctly as:
<p>this & that & the other</p>
Fixes #48256
Mike Dalessio
-
Deprecate
SafeBuffer#clone_empty
.This method has not been used internally since Rails 4.2.0.
Mike Dalessio
-
MessageEncryptor
,MessageVerifier
, andconfig.active_support.message_serializer
now accept:message_pack
and:message_pack_allow_marshal
as serializers.
These serializers require themsgpack
gem
(>= 1.7.0).The Message Pack format can provide improved performance and smaller payload
sizes. It also supports round-tripping some Ruby types that are not supported
by JSON. For example:verifier = ActiveSupport::MessageVerifier.new("secret") data = [{ a: 1 }, { b: 2 }.with_indifferent_access, 1.to_d, Time.at(0, 123)] message = verifier.generate(data) # BEFORE with config.active_support.message_serializer = :json verifier.verified(message) # => [{"a"=>1}, {"b"=>2}, "1.0", "1969-12-31T18:00:00.000-06:00"] verifier.verified(message).map(&:class) # => [Hash, Hash, String, String] # AFTER with config.active_support.message_serializer = :message_pack verifier.verified(message) # => [{:a=>1}, {"b"=>2}, 0.1e1, 1969-12-31 18:00:00.000123 -0600] verifier.verified(message).map(&:class) # => [Hash, ActiveSupport::HashWithIndifferentAccess, BigDecimal, Time]
The
:message_pack
serializer can fall back to deserializing with
ActiveSupport::JSON
when necessary, and the:message_pack_allow_marshal
serializer can fall back to deserializing withMarshal
as well as
ActiveSupport::JSON
. Additionally, the:marshal
,:json
, and
:json_allow_marshal
serializers can now fall back to deserializing with
ActiveSupport::MessagePack
when necessary. These behaviors ensure old
messages can still be read so that migration is easier.Jonathan Hefner
-
A new
7.1
cache format is available which includes an optimization for
bare string values such as view fragments.The
7.1
cache format is used by default for new apps, and existing apps
can enable the format by settingconfig.load_defaults 7.1
or by setting
config.active_support.cache_format_version = 7.1
inconfig/application.rb
or aconfig/environments/*.rb
file.Cache entries written using the
6.1
or7.0
cache formats can be read
when using the7.1
format. To perform a rolling deploy of a Rails 7.1
upgrade, wherein servers that have not yet been upgraded must be able to
read caches from upgraded servers, leave the cache format unchanged on the
first deploy, then enable the7.1
cache format on a subsequent deploy.Jonathan Hefner
-
Active Support cache stores can now use a preconfigured serializer based on
ActiveSupport::MessagePack
via the:serializer
option:config.cache_store = :redis_cache_store, { serializer: :message_pack }
The
:message_pack
serializer can reduce cache entry sizes and improve
performance, but requires themsgpack
gem
(>= 1.7.0).The
:message_pack
serializer can read cache entries written by the default
serializer, and the default serializer can now read entries written by the
:message_pack
serializer. These behaviors make it easy to migrate between
serializer without invalidating the entire cache.Jonathan Hefner
-
Object#deep_dup
no longer duplicate named classes and modules.Before:
hash = { class: Object, module: Kernel } hash.deep_dup # => {:class=>#<Class:0x00000001063ffc80>, :module=>#<Module:0x00000001063ffa00>}
After:
hash = { class: Object, module: Kernel } hash.deep_dup # => {:class=>Object, :module=>Kernel}
Jean Boussier
-
Consistently raise an
ArgumentError
if theActiveSupport::Cache
key is blank.Joshua Young
-
Deprecate usage of the singleton
ActiveSupport::Deprecation
.All usage of
ActiveSupport::Deprecation
as a singleton is deprecated, the most common one being
ActiveSupport::Deprecation.warn
. Gem authors should now create their own deprecator (ActiveSupport::Deprecation
object), and use it to emit deprecation warnings.Calling any of the following without specifying a deprecator argument is also deprecated:
- Module.deprecate
- deprecate_constant
- DeprecatedObjectProxy
- DeprecatedInstanceVariableProxy
- DeprecatedConstantProxy
- deprecation-related test assertions
Use of
ActiveSupport::Deprecation.silence
and configuration methods likebehavior=
,disallowed_behavior=
,
disallowed_warnings=
should now be aimed at the application's deprecators.Rails.application.deprecators.silence do # code that emits deprecation warnings end
If your gem has a Railtie or Engine, it's encouraged to add your deprecator to the application's deprecators, that
way the deprecation related configuration options will apply to it as well, e.g.
config.active_support.report_deprecations
set tofalse
in the production environment will also disable your
deprecator.initializer "my_gem.deprecator" do |app| app.deprecators[:my_gem] = MyGem.deprecator end
Étienne Barrié
-
Add
Object#with
to set and restore public attributes around a blockclient.timeout # => 5 client.with(timeout: 1) do client.timeout # => 1 end client.timeout # => 5
Jean Boussier
-
Remove deprecated support to generate incorrect RFC 4122 UUIDs when providing a namespace ID that is not one of the
constants defined onDigest::UUID
.Rafael Mendonça França
-
Deprecate
config.active_support.use_rfc4122_namespaced_uuids
.Rafael Mendonça França
-
Remove implicit conversion of objects into
String
byActiveSupport::SafeBuffer
.Rafael Mendonça França
-
Remove deprecated
active_support/core_ext/range/include_time_with_zone
file.Rafael Mendonça França
-
Deprecate
config.active_support.remove_deprecated_time_with_zone_name
.Rafael Mendonça França
-
Remove deprecated override of
ActiveSupport::TimeWithZone.name
.Rafael Mendonça França
-
Deprecate
config.active_support.disable_to_s_conversion
.Rafael Mendonça França
-
Remove deprecated option to passing a format to
#to_s
inArray
,Range
,Date
,DateTime
,Time
,
BigDecimal
,Float
and,Integer
.Rafael Mendonça França
-
Remove deprecated
ActiveSupport::PerThreadRegistry
.Rafael Mendonça França
-
Remove deprecated override of
Enumerable#sum
.Rafael Mendonça França
-
Deprecated initializing a
ActiveSupport::Cache::MemCacheStore
with an instance ofDalli::Client
.Deprecate the undocumented option of providing an already-initialized instance of
Dalli::Client
toActiveSupport::Cache::MemCacheStore
. Such clients could be configured with unrecognized options, which could lead to unexpected behavior. Instead, provide addresses as documented.aledustet
-
Stub
Time.new()
inTimeHelpers#travel_to
travel_to Time.new(2004, 11, 24) do # Inside the `travel_to` block `Time.new` is stubbed assert_equal 2004, Time.new.year end
fatkodima
-
Raise
ActiveSupport::MessageEncryptor::InvalidMessage
from
ActiveSupport::MessageEncryptor#decrypt_and_verify
regardless of cipher.
Previously, when aMessageEncryptor
was using a non-AEAD cipher such as
AES-256-CBC, a corrupt or tampered message would raise
ActiveSupport::MessageVerifier::InvalidSignature
. Now, all ciphers raise
the same error:encryptor = ActiveSupport::MessageEncryptor.new("x" * 32, cipher: "aes-256-gcm") message = encryptor.encrypt_and_sign("message") encryptor.decrypt_and_verify(message.next) # => raises ActiveSupport::MessageEncryptor::InvalidMessage encryptor = ActiveSupport::MessageEncryptor.new("x" * 32, cipher: "aes-256-cbc") message = encryptor.encrypt_and_sign("message") encryptor.decrypt_and_verify(message.next) # BEFORE: # => raises ActiveSupport::MessageVerifier::InvalidSignature # AFTER: # => raises ActiveSupport::MessageEncryptor::InvalidMessage
Jonathan Hefner
-
Support
nil
original values when usingActiveSupport::MessageVerifier#verify
.
Previously,MessageVerifier#verify
did not work withnil
original
values, though bothMessageVerifier#verified
and
MessageEncryptor#decrypt_and_verify
do:encryptor = ActiveSupport::MessageEncryptor.new(secret) message = encryptor.encrypt_and_sign(nil) encryptor.decrypt_and_verify(message) # => nil verifier = ActiveSupport::MessageVerifier.new(secret) message = verifier.generate(nil) verifier.verified(message) # => nil verifier.verify(message) # BEFORE: # => raises ActiveSupport::MessageVerifier::InvalidSignature # AFTER: # => nil
Jonathan Hefner
-
Maintain
html_safe?
on html_safe strings when sliced withslice
,slice!
, orchr
method.Previously,
html_safe?
was only maintained when the html_safe strings were sliced
with[]
method. Now,slice
,slice!
, andchr
methods will maintainhtml_safe?
like[]
method.string = "<div>test</div>".html_safe string.slice(0, 1).html_safe? # => true string.slice!(0, 1).html_safe? # => true # maintain html_safe? after the slice! string.html_safe? # => true string.chr.html_safe? # => true
Michael Go
-
Add
Object#in?
support for open ranges.assert Date.today.in?(..Date.tomorrow) assert_not Date.today.in?(Date.tomorrow..)
Ignacio Galindo
-
config.i18n.raise_on_missing_translations = true
now raises on any missing translation.Previously it would only raise when called in a view or controller. Now it will raise
anytimeI18n.t
is provided an unrecognised key.If you do not want this behaviour, you can customise the i18n exception handler. See the
upgrading guide or i18n guide for more information.Alex Ghiculescu
-
ActiveSupport::CurrentAttributes
now raises if a restricted attribute name is used.Attributes such as
set
andreset
cannot be used as they clash with the
CurrentAttributes
public API.Alex Ghiculescu
-
HashWithIndifferentAccess#transform_keys
now takes a Hash argument, just
as Ruby'sHash#transform_keys
does.Akira Matsuda
-
delegate
now defines method with proper arity when delegating to a Class.
With this change, it defines faster method (3.5x faster with no argument).
However, in order to gain this benefit, the delegation target method has to
be defined before declaring the delegation.# This defines 3.5 times faster method than before class C def self.x() end delegate :x, to: :class end class C # This works but silently falls back to old behavior because # `delegate` cannot find the definition of `x` delegate :x, to: :class def self.x() end end
Akira Matsuda
-
assert_difference
message now includes what changed.This makes it easier to debug non-obvious failures.
Before:
"User.count" didn't change by 32. Expected: 1611 Actual: 1579
After:
"User.count" didn't change by 32, but by 0. Expected: 1611 Actual: 1579
Alex Ghiculescu
-
Add ability to match exception messages to
assert_raises
assertionInstead of this
error = assert_raises(ArgumentError) do perform_service(param: 'exception') end assert_match(/incorrect param/i, error.message)
you can now write this
assert_raises(ArgumentError, match: /incorrect param/i) do perform_service(param: 'exception') end
fatkodima
-
Add
Rails.env.local?
shorthand forRails.env.development? || Rails.env.test?
.DHH
-
ActiveSupport::Testing::TimeHelpers
now accepts namedwith_usec
argument
tofreeze_time
,travel
, andtravel_to
methods. Passing true prevents
truncating the destination time withchange(usec: 0)
.KevSlashNull, and serprex
-
ActiveSupport::CurrentAttributes.resets
now accepts a method nameThe block API is still the recommended approach, but now both APIs are supported:
class Current < ActiveSupport::CurrentAttributes resets { Time.zone = nil } resets :clear_time_zone end
Alex Ghiculescu
-
Ensure
ActiveSupport::Testing::Isolation::Forking
closes pipesPreviously,
Forking.run_in_isolation
opened two ends of a pipe. The fork
process closed the read end, wrote to it, and then terminated (which
presumably closed the file descriptors on its end). The parent process
closed the write end, read from it, and returned, never closing the read
end.This resulted in an accumulation of open file descriptors, which could
cause errors if the limit is reached.Sam Bostock
-
Fix
Time#change
andTime#advance
for times around the end of Daylight
Saving Time.Previously, when
Time#change
orTime#advance
constructed a time inside
the final stretch of Daylight Saving Time (DST), the non-DST offset would
always be chosen for local times:# DST ended just before 2021-11-07 2:00:00 AM in US/Eastern. ENV["TZ"] = "US/Eastern" time = Time.local(2021, 11, 07, 00, 59, 59) + 1 # => 2021-11-07 01:00:00 -0400 time.change(day: 07) # => 2021-11-07 01:00:00 -0500 time.advance(seconds: 0) # => 2021-11-07 01:00:00 -0500 time = Time.local(2021, 11, 06, 01, 00, 00) # => 2021-11-06 01:00:00 -0400 time.change(day: 07) # => 2021-11-07 01:00:00 -0500 time.advance(days: 1) # => 2021-11-07 01:00:00 -0500
And the DST offset would always be chosen for times with a
TimeZone
object:Time.zone = "US/Eastern" time = Time.new(2021, 11, 07, 02, 00, 00, Time.zone) - 3600 # => 2021-11-07 01:00:00 -0500 time.change(day: 07) # => 2021-11-07 01:00:00 -0400 time.advance(seconds: 0) # => 2021-11-07 01:00:00 -0400 time = Time.new(2021, 11, 8, 01, 00, 00, Time.zone) # => 2021-11-08 01:00:00 -0500 time.change(day: 07) # => 2021-11-07 01:00:00 -0400 time.advance(days: -1) # => 2021-11-07 01:00:00 -0400
Now,
Time#change
andTime#advance
will choose the offset that matches
the original time's offset when possible:ENV["TZ"] = "US/Eastern" time = Time.local(2021, 11, 07, 00, 59, 59) + 1 # => 2021-11-07 01:00:00 -0400 time.change(day: 07) # => 2021-11-07 01:00:00 -0400 time.advance(seconds: 0) # => 2021-11-07 01:00:00 -0400 time = Time.local(2021, 11, 06, 01, 00, 00) # => 2021-11-06 01:00:00 -0400 time.change(day: 07) # => 2021-11-07 01:00:00 -0400 time.advance(days: 1) # => 2021-11-07 01:00:00 -0400 Time.zone = "US/Eastern" time = Time.new(2021, 11, 07, 02, 00, 00, Time.zone) - 3600 # => 2021-11-07 01:00:00 -0500 time.change(day: 07) # => 2021-11-07 01:00:00 -0500 time.advance(seconds: 0) # => 2021-11-07 01:00:00 -0500 time = Time.new(2021, 11, 8, 01, 00, 00, Time.zone) # => 2021-11-08 01:00:00 -0500 time.change(day: 07) # => 2021-11-07 01:00:00 -0500 time.advance(days: -1) # => 2021-11-07 01:00:00 -0500
Kevin Hall, Takayoshi Nishida, and Jonathan Hefner
-
Fix MemoryStore to preserve entries TTL when incrementing or decrementing
This is to be more consistent with how MemCachedStore and RedisCacheStore behaves.
Jean Boussier
-
Rails.error.handle
andRails.error.record
filter now by multiple error classes.Rails.error.handle(IOError, ArgumentError) do 1 + '1' # raises TypeError end 1 + 1 # TypeErrors are not IOErrors or ArgumentError, so this will *not* be handled
Martin Spickermann
-
Class#subclasses
andClass#descendants
now automatically filter reloaded classes.Previously they could return old implementations of reloadable classes that have been
dereferenced but not yet garbage collected.They now automatically filter such classes like
DescendantTracker#subclasses
and
DescendantTracker#descendants
.Jean Boussier
-
Rails.error.report
now marks errors as reported to avoid reporting them twice.In some cases, users might want to report errors explicitly with some extra context
before letting it bubble up.This also allows to safely catch and report errors outside of the execution context.
Jean Boussier
-
Add
assert_error_reported
andassert_no_error_reported
Allows to easily asserts an error happened but was handled
report = assert_error_reported(IOError) do # ... end assert_equal "Oops", report.error.message assert_equal "admin", report.context[:section] assert_equal :warning, report.severity assert_predicate report, :handled?
Jean Boussier
-
ActiveSupport::Deprecation
behavior callbacks can now receive the
deprecator instance as an argument. This makes it easier for such callbacks
to change their behavior based on the deprecator's state. For example,
based on the deprecator'sdebug
flag.3-arity and splat-args callbacks such as the following will now be passed
the deprecator instance as their third argument:->(message, callstack, deprecator) { ... }
->(*args) { ... }
->(message, *other_args) { ... }
2-arity and 4-arity callbacks such as the following will continue to behave
the same as before:->(message, callstack) { ... }
->(message, callstack, deprecation_horizon, gem_name) { ... }
->(message, callstack, *deprecation_details) { ... }
Jonathan Hefner
-
ActiveSupport::Deprecation#disallowed_warnings
now affects the instance on
which it is configured.This means that individual
ActiveSupport::Deprecation
instances can be
configured with their own disallowed warnings, and the global
ActiveSupport::Deprecation.disallowed_warnings
now only affects the global
ActiveSupport::Deprecation.warn
.Before
ActiveSupport::Deprecation.disallowed_warnings = ["foo"] deprecator = ActiveSupport::Deprecation.new("2.0", "MyCoolGem") deprecator.disallowed_warnings = ["bar"] ActiveSupport::Deprecation.warn("foo") # => raise ActiveSupport::DeprecationException ActiveSupport::Deprecation.warn("bar") # => print "DEPRECATION WARNING: bar" deprecator.warn("foo") # => raise ActiveSupport::DeprecationException deprecator.warn("bar") # => print "DEPRECATION WARNING: bar"
After
ActiveSupport::Deprecation.disallowed_warnings = ["foo"] deprecator = ActiveSupport::Deprecation.new("2.0", "MyCoolGem") deprecator.disallowed_warnings = ["bar"] ActiveSupport::Deprecation.warn("foo") # => raise ActiveSupport::DeprecationException ActiveSupport::Deprecation.warn("bar") # => print "DEPRECATION WARNING: bar" deprecator.warn("foo") # => print "DEPRECATION WARNING: foo" deprecator.warn("bar") # => raise ActiveSupport::DeprecationException
Note that global
ActiveSupport::Deprecation
methods such asActiveSupport::Deprecation.warn
andActiveSupport::Deprecation.disallowed_warnings
have been deprecated.Jonathan Hefner
-
Add italic and underline support to
ActiveSupport::LogSubscriber#color
Previously, only bold text was supported via a positional argument.
This allows for bold, italic, and underline options to be specified
for colored logs.info color("Hello world!", :red, bold: true, underline: true)
Gannon McGibbon
-
Add
String#downcase_first
method.This method is the corollary of
String#upcase_first
.Mark Schneider
-
thread_mattr_accessor
will call.dup.freeze
on non-frozen default values.This provides a basic level of protection against different threads trying
to mutate a shared default object.Jonathan Hefner
-
Add
raise_on_invalid_cache_expiration_time
config toActiveSupport::Cache::Store
Specifies if an
ArgumentError
should be raised ifRails.cache
fetch
or
write
are given an invalidexpires_at
orexpires_in
time.Options are
true
, andfalse
. Iffalse
, the exception will be reported
ashandled
and logged instead. Defaults totrue
ifconfig.load_defaults >= 7.1
.Trevor Turk
-
ActiveSupport::Cache:Store#fetch
now passes an options accessor to the block.It makes possible to override cache options:
Rails.cache.fetch("3rd-party-token") do |name, options| token = fetch_token_from_remote # set cache's TTL to match token's TTL options.expires_in = token.expires_in token end
Andrii Gladkyi, Jean Boussier
-
default
option ofthread_mattr_accessor
now applies through inheritance and
also across new threads.Previously, the
default
value provided was set only at the moment of defining
the attribute writer, which would cause the attribute to be uninitialized in
descendants and in other threads.Fixes #43312.
Thierry Deo
-
Redis cache store is now compatible with redis-rb 5.0.
Jean Boussier
-
Add
skip_nil:
support toActiveSupport::Cache::Store#fetch_multi
.Daniel Alfaro
-
Add
quarter
method to date/timeMatt Swanson
-
Fix
NoMethodError
on customActiveSupport::Deprecation
behavior.ActiveSupport::Deprecation.behavior=
was supposed to accept any object
that responds tocall
, but in fact its internal implementation assumed that
this object could respond toarity
, so it was restricted to onlyProc
objects.This change removes this
arity
restriction of custom behaviors.Ryo Nakamura
-
Support
:url_safe
option forMessageEncryptor
.The
MessageEncryptor
constructor now accepts a:url_safe
option, similar
to theMessageVerifier
constructor. When enabled, this option ensures
that messages use a URL-safe encoding.Jonathan Hefner
-
Add
url_safe
option toActiveSupport::MessageVerifier
initializerActiveSupport::MessageVerifier.new
now takes optionalurl_safe
argument.
It can generate URL-safe strings by passingurl_safe: true
.verifier = ActiveSupport::MessageVerifier.new(url_safe: true) message = verifier.generate(data) # => URL-safe string
This option is
false
by default to be backwards compatible.Shouichi Kamiya
-
Enable connection pooling by default for
MemCacheStore
andRedisCacheStore
.If you want to disable connection pooling, set
:pool
option tofalse
when configuring the cache store:config.cache_store = :mem_cache_store, "cache.example.com", pool: false
fatkodima
-
Add
force:
support toActiveSupport::Cache::Store#fetch_multi
.fatkodima
-
Deprecated
:pool_size
and:pool_timeout
options for configuring connection pooling in cache stores.Use
pool: true
to enable pooling with default settings:config.cache_store = :redis_cache_store, pool: true
Or pass individual options via
:pool
option:config.cache_store = :redis_cache_store, pool: { size: 10, timeout: 2 }
fatkodima
-
Allow #increment and #decrement methods of
ActiveSupport::Cache::Store
subclasses to set new values.Previously incrementing or decrementing an unset key would fail and return
nil. A default will now be assumed and the key will be created.Andrej Blagojević, Eugene Kenny
-
Add
skip_nil:
support toRedisCacheStore
Joey Paris
-
ActiveSupport::Cache::MemoryStore#write(name, val, unless_exist:true)
now
correctly writes expired keys.Alan Savage
-
ActiveSupport::ErrorReporter
now accepts and forward asource:
parameter.This allow libraries to signal the origin of the errors, and reporters
to easily ignore some sources.Jean Boussier
-
Fix and add protections for XSS in
ActionView::Helpers
andERB::Util
.Add the method
ERB::Util.xml_name_escape
to escape dangerous characters
in names of tags and names of attributes, following the specification of XML.Álvaro Martín Fraguas
-
Respect
ActiveSupport::Logger.new
's:formatter
keyword argumentThe stdlib
Logger::new
allows passing a:formatter
keyword argument to
set the logger's formatter. PreviouslyActiveSupport::Logger.new
ignored
that argument by always setting the formatter to an instance of
ActiveSupport::Logger::SimpleFormatter
.Steven Harman
-
Deprecate preserving the pre-Ruby 2.4 behavior of
to_time
With Ruby 2.4+ the default for +to_time+ changed from converting to the
local system time to preserving the offset of the receiver. At the time Rails
supported older versions of Ruby so a compatibility layer was added to assist
in the migration process. From Rails 5.0 new applications have defaulted to
the Ruby 2.4+ behavior and since Rails 7.0 now only supports Ruby 2.7+
this compatibility layer can be safely removed.To minimize any noise generated the deprecation warning only appears when the
setting is configured tofalse
as that is the only scenario where the
removal of the compatibility layer has any effect.Andrew White
-
Pathname.blank?
only returns true forPathname.new("")
Previously it would end up calling
Pathname#empty?
which returned true
if the path existed and was an empty directory or file.That behavior was unlikely to be expected.
Jean Boussier
-
Deprecate
Notification::Event
's#children
and#parent_of?
John Hawthorn
-
Change the default serializer of
ActiveSupport::MessageVerifier
from
Marshal
toActiveSupport::JSON
when usingconfig.load_defaults 7.1
.Messages serialized with
Marshal
can still be read, but new messages will
be serialized withActiveSupport::JSON
. For more information, see
https://guides.rubyonrails.org/v7.1/configuring.html#config-active-support-message-serializer.Saba Kiaei, David Buckley, and Jonathan Hefner
-
Change the default serializer of
ActiveSupport::MessageEncryptor
from
Marshal
toActiveSupport::JSON
when usingconfig.load_defaults 7.1
.Messages serialized with
Marshal
can still be read, but new messages will
be serialized withActiveSupport::JSON
. For more information, see
https://guides.rubyonrails.org/v7.1/configuring.html#config-active-support-message-serializer.Zack Deveau, Martin Gingras, and Jonathan Hefner
-
Add
ActiveSupport::TestCase#stub_const
to stub a constant for the duration of a yield.DHH
-
Fix
ActiveSupport::EncryptedConfiguration
to be compatible with Psych 4Stephen Sugden
-
Improve
File.atomic_write
error handlingDaniel Pepper
-
Fix
Class#descendants
andDescendantsTracker#descendants
compatibility with Ruby 3.1.The native
Class#descendants
was reverted prior to Ruby 3.1 release,
butClass#subclasses
was kept, breaking the feature detection.Jean Boussier
-
Remove -shm and -wal SQLite files when
rails db:drop
is run.Niklas Häusele
-
Revert the change to raise an
ArgumentError
when#accepts_nested_attributes_for
is declared more than once for
an association in the same class.The reverted behavior broke the case where the
#accepts_nested_attributes_for
was defined in a concern and
where overridden in the class that included the concern.Rafael Mendonça França
-
Better naming for unique constraints support.
Naming unique keys leads to misunderstanding it's a short-hand of unique indexes.
Just naming it unique constraints is not misleading.In Rails 7.1.0.beta1 or before:
add_unique_key :sections, [:position], deferrable: :deferred, name: "unique_section_position" remove_unique_key :sections, name: "unique_section_position"
Now:
add_unique_constraint :sections, [:position], deferrable: :deferred, name: "unique_section_position" remove_unique_constraint :sections, name: "unique_section_position"
Ryuta Kamizono
-
Fix duplicate quoting for check constraint expressions in schema dump when using MySQL
A check constraint with an expression, that already contains quotes, lead to an invalid schema
dump with the mysql2 adapter.Fixes #42424.
Felix Tscheulin
-
Performance tune the SQLite3 adapter connection configuration
For Rails applications, the Write-Ahead-Log in normal syncing mode with a capped journal size, a healthy shared memory buffer and a shared cache will perform, on average, 2× better.
Stephen Margheim
-
Allow SQLite3
busy_handler
to be configured with simple max number ofretries
Retrying busy connections without delay is a preferred practice for performance-sensitive applications. Add support for a
database.yml
retries
integer, which is used in a simplebusy_handler
function to retry busy connections without exponential backoff up to the max number ofretries
.Stephen Margheim
-
The SQLite3 adapter now supports
supports_insert_returning?
Implementing the full
supports_insert_returning?
contract means the SQLite3 adapter supports auto-populated columns (#48241) as well as custom primary keys.Stephen Margheim
-
Ensure the SQLite3 adapter handles default functions with the
||
concatenation operatorPreviously, this default function would produce the static string
"'Ruby ' || 'on ' || 'Rails'"
.
Now, the adapter will appropriately receive and use"Ruby on Rails"
.change_column_default "test_models", "ruby_on_rails", -> { "('Ruby ' || 'on ' || 'Rails')" }
Stephen Margheim
-
Dump PostgreSQL schemas as part of the schema dump.
Lachlan Sylvester
-
Encryption now supports
support_unencrypted_data
being set per-attribute.You can now opt out of
support_unencrypted_data
on a specific encrypted attribute.
This only has an effect ifActiveRecord::Encryption.config.support_unencrypted_data == true
.class User < ActiveRecord::Base encrypts :name, deterministic: true, support_unencrypted_data: false encrypts :email, deterministic: true end
Alex Ghiculescu
-
Add instrumentation for Active Record transactions
Allows subscribing to transaction events for tracking/instrumentation. The event payload contains the connection and the outcome (commit, rollback, restart, incomplete), as well as timing details.
ActiveSupport::Notifications.subscribe("transaction.active_record") do |event| puts "Transaction event occurred!" connection = event.payload[:connection] puts "Connection: #{connection.inspect}" end
Daniel Colson, Ian Candy
-
Support composite foreign keys via migration helpers.
# Assuming "carts" table has "(shop_id, user_id)" as a primary key. add_foreign_key(:orders, :carts, primary_key: [:shop_id, :user_id]) remove_foreign_key(:orders, :carts, primary_key: [:shop_id, :user_id]) foreign_key_exists?(:orders, :carts, primary_key: [:shop_id, :user_id])
fatkodima
-
Adds support for
if_not_exists
when adding a check constraint.add_check_constraint :posts, "post_type IN ('blog', 'comment', 'share')", if_not_exists: true
Cody Cutrer
-
Raise an
ArgumentError
when#accepts_nested_attributes_for
is declared more than once for an association in
the same class. Previously, the last declaration would silently override the previous one. Overriding in a subclass
is still allowed.Joshua Young
-
Deprecate
rewhere
argument on#merge
.The
rewhere
argument on#merge
is deprecated without replacement and
will be removed in Rails 7.2.Adam Hess
-
Fix unscope is not working in specific case
Before:
Post.where(id: 1...3).unscope(where: :id).to_sql # "SELECT `posts`.* FROM `posts` WHERE `posts`.`id` >= 1 AND `posts`.`id` < 3"
After:
Post.where(id: 1...3).unscope(where: :id).to_sql # "SELECT `posts`.* FROM `posts`"
Fixes #48094.
Kazuya Hatanaka
-
Change
has_secure_token
default toon: :initialize
Change the new default value from
on: :create
toon: :initialize
Can be controlled by the
config.active_record.generate_secure_token_on
configuration:config.active_record.generate_secure_token_on = :create
Sean Doyle
-
Fix
change_column
not settingprecision: 6
ondatetime
columns when
using 7.0+ Migrations and SQLite.Hartley McGuire
-
Support composite identifiers in
to_key
to_key
avoids wrapping#id
value into anArray
if#id
already an arrayNikita Vasilevsky
-
Add validation option for
enum
class Contract < ApplicationRecord enum :status, %w[in_progress completed], validate: true end Contract.new(status: "unknown").valid? # => false Contract.new(status: nil).valid? # => false Contract.new(status: "completed").valid? # => true class Contract < ApplicationRecord enum :status, %w[in_progress completed], validate: { allow_nil: true } end Contract.new(status: "unknown").valid? # => false Contract.new(status: nil).valid? # => true Contract.new(status: "completed").valid? # => true
Edem Topuzov, Ryuta Kamizono
-
Allow batching methods to use already loaded relation if available
Calling batch methods on already loaded relations will use the records previously loaded instead of retrieving
them from the database again.Adam Hess
-
Deprecate
read_attribute(:id)
returning the primary key if the primary key is not:id
.Starting in Rails 7.2,
read_attribute(:id)
will return the value of the id column, regardless of the model's
primary key. To retrieve the value of the primary key, use#id
instead.read_attribute(:id)
for composite
primary key models will now return the value of the id column.Adrianna Chang
-
Fix
change_table
setting datetime precision for 6.1 MigrationsHartley McGuire
-
Fix change_column setting datetime precision for 6.1 Migrations
Hartley McGuire
-
Add
ActiveRecord::Base#id_value
alias to access the raw value of a record's id column.This alias is only provided for models that declare an
:id
column.Adrianna Chang
-
Fix previous change tracking for
ActiveRecord::Store
when using a column with JSON structured database typeBefore, the methods to access the changes made during the last save
#saved_change_to_key?
,#saved_change_to_key
, and#key_before_last_save
did not work if the store was defined as astore_accessor
on a column with a JSON structured database typeRobert DiMartino
-
Fully support
NULLS [NOT] DISTINCT
for PostgreSQL 15+ indexes.Previous work was done to allow the index to be created in a migration, but it was not
supported in schema.rb. Additionally, the matching forNULLS [NOT] DISTINCT
was not
in the correct order, which could have resulted in inconsistent schema detection.Gregory Jones
-
Allow escaping of literal colon characters in
sanitize_sql_*
methods when named bind variables are usedJustin Bull
-
Fix
#previously_new_record?
to return true for destroyed records.Before, if a record was created and then destroyed,
#previously_new_record?
would return true.
Now, any UPDATE or DELETE to a record is considered a change, and will result in#previously_new_record?
returning false.Adrianna Chang
-
Specify callback in
has_secure_token
class User < ApplicationRecord has_secure_token on: :initialize end User.new.token # => "abc123...."
Sean Doyle
-
Fix incrementation of in memory counter caches when associations overlap
When two associations had a similarly named counter cache column, Active Record
could sometime increment the wrong one.Jacopo Beschi, Jean Boussier
-
Don't show secrets for Active Record's
Cipher::Aes256Gcm#inspect
.Before:
ActiveRecord::Encryption::Cipher::Aes256Gcm.new(secret).inspect "#<ActiveRecord::Encryption::Cipher::Aes256Gcm:0x0000000104888038 ... @secret=\"\\xAF\\bFh]LV}q\\nl\\xB2U\\xB3 ... >"
After:
ActiveRecord::Encryption::Cipher::Aes256Gcm(secret).inspect "#<ActiveRecord::Encryption::Cipher::Aes256Gcm:0x0000000104888038>"
Petrik de Heus
-
Bring back the historical behavior of committing transaction on non-local return.
Model.transaction do model.save return other_model.save # not executed end
Historically only raised errors would trigger a rollback, but in Ruby
2.3
, thetimeout
library
started usingthrow
to interrupt execution which had the adverse effect of committing open transactions.To solve this, in Active Record 6.1 the behavior was changed to instead rollback the transaction as it was safer
than to potentially commit an incomplete transaction.Using
return
,break
orthrow
inside atransaction
block was essentially deprecated from Rails 6.1 onwards.However with the release of
timeout 0.4.0
,Timeout.timeout
now raises an error again, and Active Record is able
to return to its original, less surprising, behavior.This historical behavior can now be opt-ed in via:
Rails.application.config.active_record.commit_transaction_on_non_local_return = true
And is the default for new applications created in Rails 7.1.
Jean Boussier
-
Deprecate
name
argument on#remove_connection
.The
name
argument is deprecated on#remove_connection
without replacement.#remove_connection
should be called directly on the class that established the connection.Eileen M. Uchitelle
-
Fix has_one through singular building with inverse.
Allows building of records from an association with a has_one through a
singular association with inverse. For belongs_to through associations,
linking the foreign key to the primary key model isn't needed.
For has_one, we cannot build records due to the association not being mutable.Gannon McGibbon
-
Disable database prepared statements when query logs are enabled
Prepared Statements and Query Logs are incompatible features due to query logs making every query unique.
zzak, Jean Boussier
-
Support decrypting data encrypted non-deterministically with a SHA1 hash digest.
This adds a new Active Record encryption option to support decrypting data encrypted
non-deterministically with a SHA1 hash digest:Rails.application.config.active_record.encryption.support_sha1_for_non_deterministic_encryption = true
The new option addresses a problem when upgrading from 7.0 to 7.1. Due to a bug in how Active Record
Encryption was getting initialized, the key provider used for non-deterministic encryption were using
SHA-1 as its digest class, instead of the one configured globally by Rails via
Rails.application.config.active_support.key_generator_hash_digest_class
.Cadu Ribeiro and Jorge Manrubia
-
Added PostgreSQL migration commands for enum rename, add value, and rename value.
rename_enum
andrename_enum_value
are reversible. Due to Postgres
limitation,add_enum_value
is not reversible since you cannot delete enum
values. As an alternative you should drop and recreate the enum entirely.rename_enum :article_status, to: :article_state
add_enum_value :article_state, "archived" # will be at the end of existing values add_enum_value :article_state, "in review", before: "published" add_enum_value :article_state, "approved", after: "in review"
rename_enum_value :article_state, from: "archived", to: "deleted"
Ray Faddis
-
Allow composite primary key to be derived from schema
Booting an application with a schema that contains composite primary keys
will not issue warning and won'tnil
ify theActiveRecord::Base#primary_key
value anymore.Given a
travel_routes
table definition and aTravelRoute
model like:create_table :travel_routes, primary_key: [:origin, :destination], force: true do |t| t.string :origin t.string :destination end class TravelRoute < ActiveRecord::Base; end
The
TravelRoute.primary_key
value will be automatically derived to["origin", "destination"]
Nikita Vasilevsky
-
Include the
connection_pool
with exceptions raised from an adapter.The
connection_pool
provides added context such as the connection used
that led to the exception as well as which role and shard.Luan Vieira
-
Support multiple column ordering for
find_each
,find_in_batches
andin_batches
.When find_each/find_in_batches/in_batches are performed on a table with composite primary keys, ascending or descending order can be selected for each key.
Person.find_each(order: [:desc, :asc]) do |person| person.party_all_night! end
Takuya Kurimoto
-
Fix where on association with has_one/has_many polymorphic relations.
Before:
Treasure.where(price_estimates: PriceEstimate.all) #=> SELECT (...) WHERE "treasures"."id" IN (SELECT "price_estimates"."estimate_of_id" FROM "price_estimates")
Later:
Treasure.where(price_estimates: PriceEstimate.all) #=> SELECT (...) WHERE "treasures"."id" IN (SELECT "price_estimates"."estimate_of_id" FROM "price_estimates" WHERE "price_estimates"."estimate_of_type" = 'Treasure')
Lázaro Nixon
-
Assign auto populated columns on Active Record record creation.
Changes record creation logic to allow for the
auto_increment
column to be assigned
immediately after creation regardless of it's relation to the model's primary key.The PostgreSQL adapter benefits the most from the change allowing for any number of auto-populated
columns to be assigned on the object immediately after row insertion utilizing theRETURNING
statement.Nikita Vasilevsky
-
Use the first key in the
shards
hash fromconnected_to
for thedefault_shard
.Some applications may not want to use
:default
as a shard name in their connection model. Unfortunately Active Record expects there to be a:default
shard because it must assume a shard to get the right connection from the pool manager. Rather than force applications to manually set this,connects_to
can infer the default shard name from the hash of shards and will now assume that the first shard is your default.For example if your model looked like this:
class ShardRecord < ApplicationRecord self.abstract_class = true connects_to shards: { shard_one: { writing: :shard_one }, shard_two: { writing: :shard_two } }
Then the
default_shard
for this class would be set toshard_one
.Fixes: #45390
Eileen M. Uchitelle
-
Fix mutation detection for serialized attributes backed by binary columns.
Jean Boussier
-
Add
ActiveRecord.disconnect_all!
method to immediately close all connections from all pools.Jean Boussier
-
Discard connections which may have been left in a transaction.
There are cases where, due to an error,
within_new_transaction
may unexpectedly leave a connection in an open transaction. In these cases the connection may be reused, and the following may occur:- Writes appear to fail when they actually succeed.
- Writes appear to succeed when they actually fail.
- Reads return stale or uncommitted data.
Previously, the following case was detected:
- An error is encountered during the transaction, then another error is encountered while attempting to roll it back.
Now, the following additional cases are detected:
- An error is encountered just after successfully beginning a transaction.
- An error is encountered while committing a transaction, then another error is encountered while attempting to roll it back.
- An error is encountered while rolling back a transaction.
Nick Dower
-
Active Record query cache now evicts least recently used entries
By default it only keeps the
100
most recently used queries.The cache size can be configured via
database.yml
development: adapter: mysql2 query_cache: 200
It can also be entirely disabled:
development: adapter: mysql2 query_cache: false
Jean Boussier
-
Deprecate
check_pending!
in favor ofcheck_all_pending!
.check_pending!
will only check for pending migrations on the current database connection or the one passed in. This has been deprecated in favor ofcheck_all_pending!
which will find all pending migrations for the database configurations in a given environment.Eileen M. Uchitelle
-
Make
increment_counter
/decrement_counter
accept an amount argumentPost.increment_counter(:comments_count, 5, by: 3)
fatkodima
-
Add support for
Array#intersect?
toActiveRecord::Relation
.Array#intersect?
is only available on Ruby 3.1 or later.This allows the Rubocop
Style/ArrayIntersect
cop to work withActiveRecord::Relation
objects.John Harry Kelly
-
The deferrable foreign key can be passed to
t.references
.Hiroyuki Ishii
-
Deprecate
deferrable: true
option ofadd_foreign_key
.deferrable: true
is deprecated in favor ofdeferrable: :immediate
, and
will be removed in Rails 7.2.Because
deferrable: true
anddeferrable: :deferred
are hard to understand.
Both true and :deferred are truthy values.
This behavior is the same as the deferrable option of the add_unique_key method, added in #46192.Hiroyuki Ishii
-
AbstractAdapter#execute
and#exec_query
now clear the query cacheIf you need to perform a read only SQL query without clearing the query
cache, useAbstractAdapter#select_all
.Jean Boussier
-
Make
.joins
/.left_outer_joins
work with CTEs.For example:
Post .with(commented_posts: Comment.select(:post_id).distinct) .joins(:commented_posts) #=> WITH (...) SELECT ... INNER JOIN commented_posts on posts.id = commented_posts.post_id
Vladimir Dementyev
-
Add a load hook for
ActiveRecord::ConnectionAdapters::Mysql2Adapter
(namedactive_record_mysql2adapter
) to allow for overriding aspects of the
ActiveRecord::ConnectionAdapters::Mysql2Adapter
class. This makesMysql2Adapter
consistent withPostgreSQLAdapter
andSQLite3Adapter
that already have load hooks.fatkodima
-
Introduce adapter for Trilogy database client
Trilogy is a MySQL-compatible database client. Rails applications can use Trilogy
by configuring theirconfig/database.yml
:development: adapter: trilogy database: blog_development pool: 5
Or by using the
DATABASE_URL
environment variable:ENV['DATABASE_URL'] # => "trilogy://localhost/blog_development?pool=5"
Adrianna Chang
-
after_commit
callbacks defined on models now execute in the correct order.class User < ActiveRecord::Base after_commit { puts("this gets called first") } after_commit { puts("this gets called second") } end
Previously, the callbacks executed in the reverse order. To opt in to the new behaviour:
config.active_record.run_after_transaction_callbacks_in_order_defined = true
This is the default for new apps.
Alex Ghiculescu
-
Infer
foreign_key
wheninverse_of
is present onhas_one
andhas_many
associations.has_many :citations, foreign_key: "book1_id", inverse_of: :book
can be simplified to
has_many :citations, inverse_of: :book
and the foreign_key will be read from the corresponding
belongs_to
association.Daniel Whitney
-
Limit max length of auto generated index names
Auto generated index names are now limited to 62 bytes, which fits within
the default index name length limits for MySQL, Postgres and SQLite.Any index name over the limit will fallback to the new short format.
Before (too long):
index_testings_on_foo_and_bar_and_first_name_and_last_name_and_administrator
After (short format):
idx_on_foo_bar_first_name_last_name_administrator_5939248142
The short format includes a hash to ensure the name is unique database-wide.
Mike Coutermarsh
-
Introduce a more stable and optimized Marshal serializer for Active Record models.
Can be enabled with
config.active_record.marshalling_format_version = 7.1
.Jean Boussier
-
Allow specifying where clauses with column-tuple syntax.
Querying through
#where
now accepts a new tuple-syntax which accepts, as
a key, an array of columns and, as a value, an array of corresponding tuples.
The key specifies a list of columns, while the value is an array of
ordered-tuples that conform to the column list.For instance:
# Cpk::Book => Cpk::Book(author_id: integer, number: integer, title: string, revision: integer) # Cpk::Book.primary_key => ["author_id", "number"] book = Cpk::Book.create!(author_id: 1, number: 1) Cpk::Book.where(Cpk::Book.primary_key => [[1, 2]]) # => [book] # Topic => Topic(id: integer, title: string, author_name: string...) Topic.where([:title, :author_name] => [["The Alchemist", "Paulo Coelho"], ["Harry Potter", "J.K Rowling"]])
Paarth Madan
-
Allow warning codes to be ignore when reporting SQL warnings.
Active Record config that can ignore warning codes
# Configure allowlist of warnings that should always be ignored config.active_record.db_warnings_ignore = [ "1062", # MySQL Error 1062: Duplicate entry ]
This is supported for the MySQL and PostgreSQL adapters.
Nick Borromeo
-
Introduce
:active_record_fixtures
lazy load hook.Hooks defined with this name will be run whenever
TestFixtures
is included
in a class.ActiveSupport.on_load(:active_record_fixtures) do self.fixture_paths << "test/fixtures" end klass = Class.new klass.include(ActiveRecord::TestFixtures) klass.fixture_paths # => ["test/fixtures"]
Andrew Novoselac
-
Introduce
TestFixtures#fixture_paths
.Multiple fixture paths can now be specified using the
#fixture_paths
accessor.
Apps will continue to havetest/fixtures
as their one fixture path by default,
but additional fixture paths can be specified.ActiveSupport::TestCase.fixture_paths << "component1/test/fixtures" ActiveSupport::TestCase.fixture_paths << "component2/test/fixtures"
TestFixtures#fixture_path
is now deprecated.Andrew Novoselac
-
Adds support for deferrable exclude constraints in PostgreSQL.
By default, exclude constraints in PostgreSQL are checked after each statement.
This works for most use cases, but becomes a major limitation when replacing
records with overlapping ranges by using multiple statements.exclusion_constraint :users, "daterange(valid_from, valid_to) WITH &&", deferrable: :immediate
Passing
deferrable: :immediate
checks constraint after each statement,
but allows manually deferring the check usingSET CONSTRAINTS ALL DEFERRED
within a transaction. This will cause the excludes to be checked after the transaction.It's also possible to change the default behavior from an immediate check
(after the statement), to a deferred check (after the transaction):exclusion_constraint :users, "daterange(valid_from, valid_to) WITH &&", deferrable: :deferred
Hiroyuki Ishii
-
Respect
foreign_type
option todelegated_type
for{role}_class
method.Usage of
delegated_type
with non-conventional{role}_type
column names can now be specified withforeign_type
option.
This option is the same asforeign_type
as forwarded to the underlyingbelongs_to
association thatdelegated_type
wraps.Jason Karns
-
Add support for unique constraints (PostgreSQL-only).
add_unique_key :sections, [:position], deferrable: :deferred, name: "unique_section_position" remove_unique_key :sections, name: "unique_section_position"
See PostgreSQL's Unique Constraints documentation for more on unique constraints.
By default, unique constraints in PostgreSQL are checked after each statement.
This works for most use cases, but becomes a major limitation when replacing
records with unique column by using multiple statements.An example of swapping unique columns between records.
# position is unique column old_item = Item.create!(position: 1) new_item = Item.create!(position: 2) Item.transaction do old_item.update!(position: 2) new_item.update!(position: 1) end
Using the default behavior, the transaction would fail when executing the
firstUPDATE
statement.By passing the
:deferrable
option to theadd_unique_key
statement in
migrations, it's possible to defer this check.add_unique_key :items, [:position], deferrable: :immediate
Passing
deferrable: :immediate
does not change the behaviour of the previous example,
but allows manually deferring the check usingSET CONSTRAINTS ALL DEFERRED
within a transaction.
This will cause the unique constraints to be checked after the transaction.It's also possible to adjust the default behavior from an immediate
check (after the statement), to a deferred check (after the transaction):add_unique_key :items, [:position], deferrable: :deferred
If you want to change an existing unique index to deferrable, you can use :using_index
to create deferrable unique constraints.add_unique_key :items, deferrable: :deferred, using_index: "index_items_on_position"
Hiroyuki Ishii
-
Remove deprecated
Tasks::DatabaseTasks.schema_file_type
.Rafael Mendonça França
-
Remove deprecated
config.active_record.partial_writes
.Rafael Mendonça França
-
Remove deprecated
ActiveRecord::Base
config accessors.Rafael Mendonça França
-
Remove the
:include_replicas
argument fromconfigs_for
. Use:include_hidden
argument instead.Eileen M. Uchitelle
-
Allow applications to lookup a config via a custom hash key.
If you have registered a custom config or want to find configs where the hash matches a specific key, now you can pass
config_key
toconfigs_for
. For example if you have adb_config
with the keyvitess
you can look up a database configuration hash by matching that key.ActiveRecord::Base.configurations.configs_for(env_name: "development", name: "primary", config_key: :vitess) ActiveRecord::Base.configurations.configs_for(env_name: "development", config_key: :vitess)
Eileen M. Uchitelle
-
Allow applications to register a custom database configuration handler.
Adds a mechanism for registering a custom handler for cases where you want database configurations to respond to custom methods. This is useful for non-Rails database adapters or tools like Vitess that you may want to configure differently from a standard
HashConfig
orUrlConfig
.Given the following database YAML we want the
animals
db to create aCustomConfig
object instead while theprimary
database will be aUrlConfig
:development: primary: url: postgres://localhost/primary animals: url: postgres://localhost/animals custom_config: sharded: 1
To register a custom handler first make a class that has your custom methods:
class CustomConfig < ActiveRecord::DatabaseConfigurations::UrlConfig def sharded? custom_config.fetch("sharded", false) end private def custom_config configuration_hash.fetch(:custom_config) end end
Then register the config in an initializer:
ActiveRecord::DatabaseConfigurations.register_db_config_handler do |env_name, name, url, config| next unless config.key?(:custom_config) CustomConfig.new(env_name, name, url, config) end
When the application is booted, configuration hashes with the
:custom_config
key will beCustomConfig
objects and respond tosharded?
. Applications must handle the condition in which Active Record should use their custom handler.Eileen M. Uchitelle and John Crepezzi
-
ActiveRecord::Base.serialize
no longer uses YAML by default.YAML isn't particularly performant and can lead to security issues
if not used carefully.Unfortunately there isn't really any good serializers in Ruby's stdlib
to replace it.The obvious choice would be JSON, which is a fine format for this use case,
however the JSON serializer in Ruby's stdlib isn't strict enough, as it fallback
to casting unknown types to strings, which could lead to corrupted data.Some third party JSON libraries like
Oj
have a suitable strict mode.So it's preferable that users choose a serializer based on their own constraints.
The original default can be restored by setting
config.active_record.default_column_serializer = YAML
.Jean Boussier
-
ActiveRecord::Base.serialize
signature changed.Rather than a single positional argument that accepts two possible
types of values,serialize
now accepts two distinct keyword arguments.Before:
serialize :content, JSON serialize :backtrace, Array
After:
serialize :content, coder: JSON serialize :backtrace, type: Array
Jean Boussier
-
YAML columns use
YAML.safe_dump
if available.As of
psych 5.1.0
,YAML.safe_dump
can now apply the same permitted
types restrictions thanYAML.safe_load
.It's preferable to ensure the payload only use allowed types when we first
try to serialize it, otherwise you may end up with invalid records in the
database.Jean Boussier
-
ActiveRecord::QueryLogs
better handle broken encoding.It's not uncommon when building queries with BLOB fields to contain
binary data. Unless the call carefully encode the string in ASCII-8BIT
it generally end up being encoded inUTF-8
, andQueryLogs
would
end up failing on it.ActiveRecord::QueryLogs
no longer depend on the query to be properly encoded.Jean Boussier
-
Fix a bug where
ActiveRecord::Generators::ModelGenerator
would not respect create_table_migration template overrides.rails g model create_books title:string content:text
will now read from the create_table_migration.rb.tt template in the following locations in order:
lib/templates/active_record/model/create_table_migration.rb lib/templates/active_record/migration/create_table_migration.rb
Spencer Neste
-
ActiveRecord::Relation#explain
now accepts options.For databases and adapters which support them (currently PostgreSQL
and MySQL), options can be passed toexplain
to provide more
detailed query plan analysis:Customer.where(id: 1).joins(:orders).explain(:analyze, :verbose)
Reid Lynch
-
Multiple
Arel::Nodes::SqlLiteral
nodes can now be added together to
formArel::Nodes::Fragments
nodes. This allows joining several pieces
of SQL.Matthew Draper, Ole Friis
-
ActiveRecord::Base#signed_id
raises if called on a new record.Previously it would return an ID that was not usable, since it was based on
id = nil
.Alex Ghiculescu
-
Allow SQL warnings to be reported.
Active Record configs can be set to enable SQL warning reporting.
# Configure action to take when SQL query produces warning config.active_record.db_warnings_action = :raise # Configure allowlist of warnings that should always be ignored config.active_record.db_warnings_ignore = [ /Invalid utf8mb4 character string/, "An exact warning message", ]
This is supported for the MySQL and PostgreSQL adapters.
Adrianna Chang, Paarth Madan
-
Add
#regroup
query method as a short-hand for.unscope(:group).group(fields)
Example:
Post.group(:title).regroup(:author) # SELECT `posts`.`*` FROM `posts` GROUP BY `posts`.`author`
Danielius Visockas
-
PostgreSQL adapter method
enable_extension
now allows parameter to be[schema_name.]<extension_name>
if the extension must be installed on another schema.Example:
enable_extension('heroku_ext.hstore')
Leonardo Luarte
-
Add
:include
option toadd_index
.Add support for including non-key columns in indexes for PostgreSQL
with theINCLUDE
parameter.add_index(:users, :email, include: [:id, :created_at])
will result in:
CREATE INDEX index_users_on_email USING btree (email) INCLUDE (id, created_at)
Steve Abrams
-
ActiveRecord::Relation
’s#any?
,#none?
, and#one?
methods take an optional pattern
argument, more closely matching theirEnumerable
equivalents.George Claghorn
-
Add
ActiveRecord::Base.normalizes
for declaring attribute normalizations.An attribute normalization is applied when the attribute is assigned or
updated, and the normalized value will be persisted to the database. The
normalization is also applied to the corresponding keyword argument of query
methods, allowing records to be queried using unnormalized values.For example:
class User < ActiveRecord::Base normalizes :email, with: -> email { email.strip.downcase } normalizes :phone, with: -> phone { phone.delete("^0-9").delete_prefix("1") } end user = User.create(email: " CRUISE-CONTROL@EXAMPLE.COM\n") user.email # => "cruise-control@example.com" user = User.find_by(email: "\tCRUISE-CONTROL@EXAMPLE.COM ") user.email # => "cruise-control@example.com" user.email_before_type_cast # => "cruise-control@example.com" User.where(email: "\tCRUISE-CONTROL@EXAMPLE.COM ").count # => 1 User.where(["email = ?", "\tCRUISE-CONTROL@EXAMPLE.COM "]).count # => 0 User.exists?(email: "\tCRUISE-CONTROL@EXAMPLE.COM ") # => true User.exists?(["email = ?", "\tCRUISE-CONTROL@EXAMPLE.COM "]) # => false User.normalize_value_for(:phone, "+1 (555) 867-5309") # => "5558675309"
Jonathan Hefner
-
Hide changes to before_committed! callback behaviour behind flag.
In #46525, behavior around before_committed! callbacks was changed so that callbacks
would run on every enrolled record in a transaction, not just the first copy of a record.
This change in behavior is now controlled by a configuration option,
config.active_record.before_committed_on_all_records
. It will be enabled by default on Rails 7.1.Adrianna Chang
-
The
namespaced_controller
Query Log tag now matches thecontroller
formatFor example, a request processed by
NameSpaced::UsersController
will now log as::controller # "users" :namespaced_controller # "name_spaced/users"
Alex Ghiculescu
-
Return only unique ids from ActiveRecord::Calculations#ids
Updated ActiveRecord::Calculations#ids to only return the unique ids of the base model
when using eager_load, preload and includes.Post.find_by(id: 1).comments.count # => 5 Post.includes(:comments).where(id: 1).pluck(:id) # => [1, 1, 1, 1, 1] Post.includes(:comments).where(id: 1).ids # => [1]
Joshua Young
-
Stop using
LOWER()
for case-insensitive queries oncitext
columnsPreviously,
LOWER()
was added for e.g. uniqueness validations with
case_sensitive: false
.
It wasn't mentioned in the documentation that the index withoutLOWER()
wouldn't be used in this case.Phil Pirozhkov
-
Extract
#sync_timezone_changes
method in AbstractMysqlAdapter to enable subclasses
to sync database timezone changes without overriding#raw_execute
.Adrianna Chang, Paarth Madan
-
Do not write additional new lines when dumping sql migration versions
This change updates the
insert_versions_sql
function so that the database insert string containing the current database migration versions does not end with two additional new lines.Misha Schwartz
-
Fix
composed_of
value freezing and duplication.Previously composite values exhibited two confusing behaviors:
- When reading a compositve value it'd NOT be frozen, allowing it to get out of sync with its underlying database
columns. - When writing a compositve value the argument would be frozen, potentially confusing the caller.
Currently, composite values instantiated based on database columns are frozen (addressing the first issue) and
assigned compositve values are duplicated and the duplicate is frozen (addressing the second issue).Greg Navis
- When reading a compositve value it'd NOT be frozen, allowing it to get out of sync with its underlying database
-
Fix redundant updates to the column insensitivity cache
Fixed redundant queries checking column capability for insensitive
comparison.Phil Pirozhkov
-
Allow disabling methods generated by
ActiveRecord.enum
.Alfred Dominic
-
Avoid validating
belongs_to
association if it has not changed.Previously, when updating a record, Active Record will perform an extra query to check for the presence of
belongs_to
associations (if the presence is configured to be mandatory), even if that attribute hasn't changed.Currently, only
belongs_to
-related columns are checked for presence. It is possible to have orphaned records with
this approach. To avoid this problem, you need to use a foreign key.This behavior can be controlled by configuration:
config.active_record.belongs_to_required_validates_foreign_key = false
and will be disabled by default with
config.load_defaults 7.1
.fatkodima
-
has_one
andbelongs_to
associations now define areset_association
method
on the owner model (whereassociation
is the name of the association). This
method unloads the cached associate record, if any, and causes the next access
to query it from the database.George Claghorn
-
Allow per attribute setting of YAML permitted classes (safe load) and unsafe load.
Carlos Palhares
-
Add a build persistence method
Provides a wrapper for
new
, to provide feature parity withcreate
s
ability to create multiple records from an array of hashes, using the
same notation as thebuild
method on associations.Sean Denny
-
Raise on assignment to readonly attributes
class Post < ActiveRecord::Base attr_readonly :content end Post.create!(content: "cannot be updated") post.content # "cannot be updated" post.content = "something else" # => ActiveRecord::ReadonlyAttributeError
Previously, assignment would succeed but silently not write to the database.
This behavior can be controlled by configuration:
config.active_record.raise_on_assign_to_attr_readonly = true
and will be enabled by default with
config.load_defaults 7.1
.Alex Ghiculescu, Hartley McGuire
-
Allow unscoping of preload and eager_load associations
Added the ability to unscope preload and eager_load associations just like
includes, joins, etc. See ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES
for the full list of supported unscopable scopes.query.unscope(:eager_load, :preload).group(:id).select(:id)
David Morehouse
-
Add automatic filtering of encrypted attributes on inspect
This feature is enabled by default but can be disabled with
config.active_record.encryption.add_to_filter_parameters = false
Hartley McGuire
-
Clear locking column on #dup
This change fixes not to duplicate locking_column like id and timestamps.
car = Car.create! car.touch car.lock_version #=> 1 car.dup.lock_version #=> 0
Shouichi Kamiya, Seonggi Yang, Ryohei UEDA
-
Invalidate transaction as early as possible
After rescuing a
TransactionRollbackError
exception Rails invalidates transactions earlier in the flow
allowing the framework to skip issuing theROLLBACK
statement in more cases.
Only affects adapters that havesavepoint_errors_invalidate_transactions?
configured astrue
,
which at this point is only applicable to themysql2
adapter.Nikita Vasilevsky
-
Allow configuring columns list to be used in SQL queries issued by an
ActiveRecord::Base
objectIt is now possible to configure columns list that will be used to build an SQL query clauses when
updating, deleting or reloading anActiveRecord::Base
objectclass Developer < ActiveRecord::Base query_constraints :company_id, :id end developer = Developer.first.update(name: "Bob") # => UPDATE "developers" SET "name" = 'Bob' WHERE "developers"."company_id" = 1 AND "developers"."id" = 1
Nikita Vasilevsky
-
Adds
validate
to foreign keys and check constraints in schema.rbPreviously,
schema.rb
would not record ifvalidate: false
had been used when adding a foreign key or check
constraint, so restoring a database from the schema could result in foreign keys or check constraints being
incorrectly validated.Tommy Graves
-
Adapter
#execute
methods now accept anallow_retry
option. When set totrue
, the SQL statement will be
retried, up to the database's configuredconnection_retries
value, upon encountering connection-related errors.Adrianna Chang
-
Only trigger
after_commit :destroy
callbacks when a database row is deleted.This prevents
after_commit :destroy
callbacks from being triggered again
whendestroy
is called multiple times on the same record.Ben Sheldon
-
Fix
ciphertext_for
for yet-to-be-encrypted values.Previously,
ciphertext_for
returned the cleartext of values that had not
yet been encrypted, such as with an unpersisted record:Post.encrypts :body post = Post.create!(body: "Hello") post.ciphertext_for(:body) # => "{\"p\":\"abc..." post.body = "World" post.ciphertext_for(:body) # => "World"
Now,
ciphertext_for
will always return the ciphertext of encrypted
attributes:Post.encrypts :body post = Post.create!(body: "Hello") post.ciphertext_for(:body) # => "{\"p\":\"abc..." post.body = "World" post.ciphertext_for(:body) # => "{\"p\":\"xyz..."
Jonathan Hefner
-
Fix a bug where using groups and counts with long table names would return incorrect results.
Shota Toguchi, Yusaku Ono
-
Fix encryption of column default values.
Previously, encrypted attributes that used column default values appeared to
be encrypted on create, but were not:Book.encrypts :name book = Book.create! book.name # => "<untitled>" book.name_before_type_cast # => "{\"p\":\"abc..." book.reload.name_before_type_cast # => "<untitled>"
Now, attributes with column default values are encrypted:
Book.encrypts :name book = Book.create! book.name # => "<untitled>" book.name_before_type_cast # => "{\"p\":\"abc..." book.reload.name_before_type_cast # => "{\"p\":\"abc..."
Jonathan Hefner
-
Deprecate delegation from
Base
toconnection_handler
.Calling
Base.clear_all_connections!
,Base.clear_active_connections!
,Base.clear_reloadable_connections!
andBase.flush_idle_connections!
is deprecated. Please call these methods on the connection handler directly. In future Rails versions, the delegation fromBase
to theconnection_handler
will be removed.Eileen M. Uchitelle
-
Allow ActiveRecord::QueryMethods#reselect to receive hash values, similar to ActiveRecord::QueryMethods#select
Sampat Badhe
-
Validate options when managing columns and tables in migrations.
If an invalid option is passed to a migration method like
create_table
andadd_column
, an error will be raised
instead of the option being silently ignored. Validation of the options will only be applied for new migrations
that are created.Guo Xiang Tan, George Wambold
-
Update query log tags to use the SQLCommenter format by default. See #46179
To opt out of SQLCommenter-formatted query log tags, set
config.active_record.query_log_tags_format = :legacy
. By default, this is set to:sqlcommenter
.Modulitos and Iheanyi
-
Allow any ERB in the database.yml when creating rake tasks.
Any ERB can be used in
database.yml
even if it accesses environment
configurations.Deprecates
config.active_record.suppress_multiple_database_warning
.Eike Send
-
Add table to error for duplicate column definitions.
If a migration defines duplicate columns for a table, the error message
shows which table it concerns.Petrik de Heus
-
Fix erroneous nil default precision on virtual datetime columns.
Prior to this change, virtual datetime columns did not have the same
default precision as regular datetime columns, resulting in the following
being erroneously equivalent:t.virtual :name, type: datetime, as: "expression" t.virtual :name, type: datetime, precision: nil, as: "expression"
This change fixes the default precision lookup, so virtual and regular
datetime column default precisions match.Sam Bostock
-
Use connection from
#with_raw_connection
in#quote_string
.This ensures that the string quoting is wrapped in the reconnect and retry logic
that#with_raw_connection
offers.Adrianna Chang
-
Add
expires_at
option tosigned_id
.Shouichi Kamiya
-
Allow applications to set retry deadline for query retries.
Building on the work done in #44576 and #44591, we extend the logic that automatically
reconnects database connections to take into account a timeout limit. We won't retry
a query if a given amount of time has elapsed since the query was first attempted. This
value defaults to nil, meaning that all retryable queries are retried regardless of time elapsed,
but this can be changed via theretry_deadline
option in the database config.Adrianna Chang
-
Fix a case where the query cache can return wrong values. See #46044
Aaron Patterson
-
Support MySQL's ssl-mode option for MySQLDatabaseTasks.
Verifying the identity of the database server requires setting the ssl-mode
option to VERIFY_CA or VERIFY_IDENTITY. This option was previously ignored
for MySQL database tasks like creating a database and dumping the structure.Petrik de Heus
-
Move
ActiveRecord::InternalMetadata
to an independent object.ActiveRecord::InternalMetadata
no longer inherits fromActiveRecord::Base
and is now an independent object that should be instantiated with aconnection
. This class is private and should not be used by applications directly. If you want to interact with the schema migrations table, please access it on the connection directly, for example:ActiveRecord::Base.connection.schema_migration
.Eileen M. Uchitelle
-
Deprecate quoting
ActiveSupport::Duration
as an integerUsing ActiveSupport::Duration as an interpolated bind parameter in a SQL
string template is deprecated. To avoid this warning, you should explicitly
convert the duration to a more specific database type. For example, if you
want to use a duration as an integer number of seconds:Record.where("duration = ?", 1.hour.to_i)
If you want to use a duration as an ISO 8601 string:
Record.where("duration = ?", 1.hour.iso8601)
Aram Greenman
-
Allow
QueryMethods#in_order_of
to order by a string column name.Post.in_order_of("id", [4,2,3,1]).to_a Post.joins(:author).in_order_of("authors.name", ["Bob", "Anna", "John"]).to_a
Igor Kasyanchuk
-
Move
ActiveRecord::SchemaMigration
to an independent object.ActiveRecord::SchemaMigration
no longer inherits fromActiveRecord::Base
and is now an independent object that should be instantiated with aconnection
. This class is private and should not be used by applications directly. If you want to interact with the schema migrations table, please access it on the connection directly, for example:ActiveRecord::Base.connection.schema_migration
.Eileen M. Uchitelle
-
Deprecate
all_connection_pools
and makeconnection_pool_list
more explicit.Following on #45924
all_connection_pools
is now deprecated.connection_pool_list
will either take an explicit role or applications can opt into the new behavior by passing:all
.Eileen M. Uchitelle
-
Fix connection handler methods to operate on all pools.
active_connections?
,clear_active_connections!
,clear_reloadable_connections!
,clear_all_connections!
, andflush_idle_connections!
now operate on all pools by default. Previously they would default to using thecurrent_role
or:writing
role unless specified.Eileen M. Uchitelle
-
Allow ActiveRecord::QueryMethods#select to receive hash values.
Currently,
select
might receive only raw sql and symbols to define columns and aliases to select.With this change we can provide
hash
as argument, for example:Post.joins(:comments).select(posts: [:id, :title, :created_at], comments: [:id, :body, :author_id]) #=> "SELECT \"posts\".\"id\", \"posts\".\"title\", \"posts\".\"created_at\", \"comments\".\"id\", \"comments\".\"body\", \"comments\".\"author_id\" # FROM \"posts\" INNER JOIN \"comments\" ON \"comments\".\"post_id\" = \"posts\".\"id\"" Post.joins(:comments).select(posts: { id: :post_id, title: :post_title }, comments: { id: :comment_id, body: :comment_body }) #=> "SELECT posts.id as post_id, posts.title as post_title, comments.id as comment_id, comments.body as comment_body # FROM \"posts\" INNER JOIN \"comments\" ON \"comments\".\"post_id\" = \"posts\".\"id\""
Oleksandr Holubenko, Josef Šimánek, Jean Boussier
-
Adapts virtual attributes on
ActiveRecord::Persistence#becomes
.When source and target classes have a different set of attributes adapts
attributes such that the extra attributes from target are added.class Person < ApplicationRecord end class WebUser < Person attribute :is_admin, :boolean after_initialize :set_admin def set_admin write_attribute(:is_admin, email =~ /@ourcompany\.com$/) end end person = Person.find_by(email: "email@ourcompany.com") person.respond_to? :is_admin # => false person.becomes(WebUser).is_admin? # => true
Jacopo Beschi, Sampson Crowley
-
Fix
ActiveRecord::QueryMethods#in_order_of
to includenil
s, to match the
behavior ofEnumerable#in_order_of
.For example,
Post.in_order_of(:title, [nil, "foo"])
will now include posts
withnil
titles, the same asPost.all.to_a.in_order_of(:title, [nil, "foo"])
.fatkodima
-
Optimize
add_timestamps
to use a single SQL statement.Now results in the following SQL:
ALTER TABLE "my_table" ADD COLUMN "created_at" datetime(6) NOT NULL, ADD COLUMN "updated_at" datetime(6) NOT NULL
Iliana Hadzhiatanasova
-
Add
drop_enum
migration command for PostgreSQLThis does the inverse of
create_enum
. Before dropping an enum, ensure you have
dropped columns that depend on it.Alex Ghiculescu
-
Adds support for
if_exists
option when removing a check constraint.The
remove_check_constraint
method now accepts anif_exists
option. If set
to true an error won't be raised if the check constraint doesn't exist.Margaret Parsa and Aditya Bhutani
-
find_or_create_by
now try to find a second time if it hits a unicity constraint.find_or_create_by
always has been inherently racy, either creating multiple
duplicate records or failing withActiveRecord::RecordNotUnique
depending on
whether a proper unicity constraint was set.create_or_find_by
was introduced for this use case, however it's quite wasteful
when the record is expected to exist most of the time, as INSERT require to send
more data than SELECT and require more work from the database. Also on some
databases it can actually consume a primary key increment which is undesirable.So for case where most of the time the record is expected to exist,
find_or_create_by
can be made race-condition free by re-trying thefind
if thecreate
failed
withActiveRecord::RecordNotUnique
. This assumes that the table has the proper
unicity constraints, if not,find_or_create_by
will still lead to duplicated records.Jean Boussier, Alex Kitchens
-
Introduce a simpler constructor API for ActiveRecord database adapters.
Previously the adapter had to know how to build a new raw connection to
support reconnect, but also expected to be passed an initial already-
established connection.When manually creating an adapter instance, it will now accept a single
config hash, and only establish the real connection on demand.Matthew Draper
-
Avoid redundant
SELECT 1
connection-validation query during DB pool
checkout when possible.If the first query run during a request is known to be idempotent, it can be
used directly to validate the connection, saving a network round-trip.Matthew Draper
-
Automatically reconnect broken database connections when safe, even
mid-request.When an error occurs while attempting to run a known-idempotent query, and
not inside a transaction, it is safe to immediately reconnect to the
database server and try again, so this is now the default behavior.This new default should always be safe -- to support that, it's consciously
conservative about which queries are considered idempotent -- but if
necessary it can be disabled by setting theconnection_retries
connection
option to0
.Matthew Draper
-
Avoid removing a PostgreSQL extension when there are dependent objects.
Previously, removing an extension also implicitly removed dependent objects. Now, this will raise an error.
You can force removing the extension:
disable_extension :citext, force: :cascade
Fixes #29091.
fatkodima
-
Allow nested functions as safe SQL string
Michael Siegfried
-
Allow
destroy_association_async_job=
to be configured with a class string instead of a constant.Defers an autoloading dependency between
ActiveRecord::Base
andActiveJob::Base
and moves the configuration ofActiveRecord::DestroyAssociationAsyncJob
from ActiveJob to ActiveRecord.Deprecates
ActiveRecord::ActiveJobRequiredError
and now raises aNameError
if the job class is unloadable or anActiveRecord::ConfigurationError
if
dependent: :destroy_async
is declared on an association but there is no job
class configured.Ben Sheldon
-
Fix
ActiveRecord::Store
to serialize as a regular HashPreviously it would serialize as an
ActiveSupport::HashWithIndifferentAccess
which is wasteful and cause problem with YAML safe_load.Jean Boussier
-
Add
timestamptz
as a time zone aware type for PostgreSQLThis is required for correctly parsing
timestamp with time zone
values in your database.If you don't want this, you can opt out by adding this initializer:
ActiveRecord::Base.time_zone_aware_types -= [:timestamptz]
Alex Ghiculescu
-
Add new
ActiveRecord::Base.generates_token_for
API.Currently,
signed_id
fulfills the role of generating tokens for e.g.
resetting a password. However, signed IDs cannot reflect record state, so
if a token is intended to be single-use, it must be tracked in a database at
least until it expires.With
generates_token_for
, a token can embed data from a record. When
using the token to fetch the record, the data from the token and the current
data from the record will be compared. If the two do not match, the token
will be treated as invalid, the same as if it had expired. For example:class User < ActiveRecord::Base has_secure_password generates_token_for :password_reset, expires_in: 15.minutes do # A password's BCrypt salt changes when the password is updated. # By embedding (part of) the salt in a token, the token will # expire when the password is updated. BCrypt::Password.new(password_digest).salt[-10..] end end user = User.first token = user.generate_token_for(:password_reset) User.find_by_token_for(:password_reset, token) # => user user.update!(password: "new password") User.find_by_token_for(:password_reset, token) # => nil
Jonathan Hefner
-
Optimize Active Record batching for whole table iterations.
Previously,
in_batches
got all the ids and constructed anIN
-based query for each batch.
When iterating over the whole tables, this approach is not optimal as it loads unneeded ids and
IN
queries with lots of items are slow.Now, whole table iterations use range iteration (
id >= x AND id <= y
) by default which can make iteration
several times faster. E.g., tested on a PostgreSQL table with 10 million records: querying (253s
vs30s
),
updating (288s
vs124s
), deleting (268s
vs83s
).Only whole table iterations use this style of iteration by default. You can disable this behavior by passing
use_ranges: false
.
If you iterate over the table and the only condition is, e.g.,archived_at: nil
(and only a tiny fraction
of the records are archived), it makes sense to opt in to this approach:Project.where(archived_at: nil).in_batches(use_ranges: true) do |relation| # do something end
See #45414 for more details.
fatkodima
-
.with
query method added. Construct common table expressions with ease and getActiveRecord::Relation
back.Post.with(posts_with_comments: Post.where("comments_count > ?", 0)) # => ActiveRecord::Relation # WITH posts_with_comments AS (SELECT * FROM posts WHERE (comments_count > 0)) SELECT * FROM posts
Vlado Cingel
-
Don't establish a new connection if an identical pool exists already.
Previously, if
establish_connection
was called on a class that already had an established connection, the existing connection would be removed regardless of whether it was the same config. Now if a pool is found with the same values as the new connection, the existing connection will be returned instead of creating a new one.This has a slight change in behavior if application code is depending on a new connection being established regardless of whether it's identical to an existing connection. If the old behavior is desirable, applications should call
ActiveRecord::Base#remove_connection
before establishing a new one. Callingestablish_connection
with a different config works the same way as it did previously.Eileen M. Uchitelle
-
Update
db:prepare
task to load schema when an uninitialized database exists, and dump schema after migrations.Ben Sheldon
-
Fix supporting timezone awareness for
tsrange
andtstzrange
array columns.# In database migrations add_column :shops, :open_hours, :tsrange, array: true # In app config ActiveRecord::Base.time_zone_aware_types += [:tsrange] # In the code times are properly converted to app time zone Shop.create!(open_hours: [Time.current..8.hour.from_now])
Wojciech Wnętrzak
-
Introduce strategy pattern for executing migrations.
By default, migrations will use a strategy object that delegates the method
to the connection adapter. Consumers can implement custom strategy objects
to change how their migrations run.Adrianna Chang
-
Add adapter option disallowing foreign keys
This adds a new option to be added to
database.yml
which enables skipping
foreign key constraints usage even if the underlying database supports them.Usage:
development: <<: *default database: storage/development.sqlite3 foreign_keys: false
Paulo Barros
-
Add configurable deprecation warning for singular associations
This adds a deprecation warning when using the plural name of a singular associations in
where
.
It is possible to opt into the new more performant behavior withconfig.active_record.allow_deprecated_singular_associations_name = false
Adam Hess
-
Run transactional callbacks on the freshest instance to save a given
record within a transaction.When multiple Active Record instances change the same record within a
transaction, Rails runsafter_commit
orafter_rollback
callbacks for
only one of them.config.active_record.run_commit_callbacks_on_first_saved_instances_in_transaction
was added to specify how Rails chooses which instance receives the
callbacks. The framework defaults were changed to use the new logic.When
config.active_record.run_commit_callbacks_on_first_saved_instances_in_transaction
istrue
, transactional callbacks are run on the first instance to save,
even though its instance state may be stale.When it is
false
, which is the new framework default starting with version
7.1, transactional callbacks are run on the instances with the freshest
instance state. Those instances are chosen as follows:- In general, run transactional callbacks on the last instance to save a
given record within the transaction. - There are two exceptions:
- If the record is created within the transaction, then updated by
another instance,after_create_commit
callbacks will be run on the
second instance. This is instead of theafter_update_commit
callbacks that would naively be run based on that instance’s state. - If the record is destroyed within the transaction, then
after_destroy_commit
callbacks will be fired on the last destroyed
instance, even if a stale instance subsequently performed an update
(which will have affected 0 rows).
- If the record is created within the transaction, then updated by
Cameron Bothner and Mitch Vollebregt
- In general, run transactional callbacks on the last instance to save a
-
Enable strict strings mode for
SQLite3Adapter
.Configures SQLite with a strict strings mode, which disables double-quoted string literals.
SQLite has some quirks around double-quoted string literals.
It first tries to consider double-quoted strings as identifier names, but if they don't exist
it then considers them as string literals. Because of this, typos can silently go unnoticed.
For example, it is possible to create an index for a non existing column.
See SQLite documentation for more details.If you don't want this behavior, you can disable it via:
# config/application.rb config.active_record.sqlite3_adapter_strict_strings_by_default = false
Fixes #27782.
fatkodima, Jean Boussier
-
Resolve issue where a relation cache_version could be left stale.
Previously, when
reset
was called on a relation object it did not reset the cache_versions
ivar. This led to a confusing situation where despite having the correct data the relation
still reported a stale cache_version.Usage:
developers = Developer.all developers.cache_version Developer.update_all(updated_at: Time.now.utc + 1.second) developers.cache_version # Stale cache_version developers.reset developers.cache_version # Returns the current correct cache_version
Fixes #45341.
Austen Madden
-
Add support for exclusion constraints (PostgreSQL-only).
add_exclusion_constraint :invoices, "daterange(start_date, end_date) WITH &&", using: :gist, name: "invoices_date_overlap" remove_exclusion_constraint :invoices, name: "invoices_date_overlap"
See PostgreSQL's
CREATE TABLE ... EXCLUDE ...
documentation for more on exclusion constraints.Alex Robbin
-
change_column_null
raises if a non-boolean argument is providedPreviously if you provided a non-boolean argument,
change_column_null
would
treat it as truthy and make your column nullable. This could be surprising, so now
the input must be eithertrue
orfalse
.change_column_null :table, :column, true # good change_column_null :table, :column, false # good change_column_null :table, :column, from: true, to: false # raises (previously this made the column nullable)
Alex Ghiculescu
-
Enforce limit on table names length.
Fixes #45130.
fatkodima
-
Adjust the minimum MariaDB version for check constraints support.
Eddie Lebow
-
Fix Hstore deserialize regression.
edsharp
-
Add validity for PostgreSQL indexes.
connection.index_exists?(:users, :email, valid: true) connection.indexes(:users).select(&:valid?)
fatkodima
-
Fix eager loading for models without primary keys.
Anmol Chopra, Matt Lawrence, and Jonathan Hefner
-
Avoid validating a unique field if it has not changed and is backed by a unique index.
Previously, when saving a record, Active Record will perform an extra query to check for the
uniqueness of each attribute having auniqueness
validation, even if that attribute hasn't changed.
If the database has the corresponding unique index, then this validation can never fail for persisted
records, and we could safely skip it.fatkodima
-
Stop setting
sql_auto_is_null
Since version 5.5 the default has been off, we no longer have to manually turn it off.
Adam Hess
-
Fix
touch
to raise an error for readonly columns.fatkodima
-
Add ability to ignore tables by regexp for SQL schema dumps.
ActiveRecord::SchemaDumper.ignore_tables = [/^_/]
fatkodima
-
Avoid queries when performing calculations on contradictory relations.
Previously calculations would make a query even when passed a
contradiction, such asUser.where(id: []).count
. We no longer perform a
query in that scenario.This applies to the following calculations:
count
,sum
,average
,
minimum
andmaximum
Luan Vieira, John Hawthorn and Daniel Colson
-
Allow using aliased attributes with
insert_all
/upsert_all
.class Book < ApplicationRecord alias_attribute :title, :name end Book.insert_all [{ title: "Remote", author_id: 1 }], returning: :title
fatkodima
-
Support encrypted attributes on columns with default db values.
This adds support for encrypted attributes defined on columns with default values.
It will encrypt those values at creation time. Before, it would raise an
error unlessconfig.active_record.encryption.support_unencrypted_data
was true.Jorge Manrubia and Dima Fatko
-
Allow overriding
reading_request?
inDatabaseSelector::Resolver
The default implementation checks if a request is a
get?
orhead?
,
but you can now change it to anything you like. If the method returns true,
Resolver#read
gets called meaning the request could be served by the
replica database.Alex Ghiculescu
-
Remove
ActiveRecord.legacy_connection_handling
.Eileen M. Uchitelle
-
rails db:schema:{dump,load}
now checksENV["SCHEMA_FORMAT"]
before configSince
rails db:structure:{dump,load}
was deprecated there wasn't a simple
way to dump a schema to both SQL and Ruby formats. You can now do this with
an environment variable. For example:SCHEMA_FORMAT=sql rake db:schema:dump
Alex Ghiculescu
-
Fixed MariaDB default function support.
Defaults would be written wrong in "db/schema.rb" and not work correctly
if usingdb:schema:load
. Further more the function name would be
added as string content when saving new records.kaspernj
-
Add
active_record.destroy_association_async_batch_size
configurationThis allows applications to specify the maximum number of records that will
be destroyed in a single background job by thedependent: :destroy_async
association option. By default, the current behavior will remain the same:
when a parent record is destroyed, all dependent records will be destroyed
in a single background job. If the number of dependent records is greater
than this configuration, the records will be destroyed in multiple
background jobs.Nick Holden
-
Fix
remove_foreign_key
with:if_exists
option when foreign key actually exists.fatkodima
-
Remove
--no-comments
flag in structure dumps for PostgreSQLThis broke some apps that used custom schema comments. If you don't want
comments in your structure dump, you can use:ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = ['--no-comments']
Alex Ghiculescu
-
Reduce the memory footprint of fixtures accessors.
Until now fixtures accessors were eagerly defined using
define_method
.
So the memory usage was directly dependent of the number of fixtures and
test suites.Instead fixtures accessors are now implemented with
method_missing
,
so they incur much less memory and CPU overhead.Jean Boussier
-
Fix
config.active_record.destroy_association_async_job
configurationconfig.active_record.destroy_association_async_job
should allow
applications to specify the job that will be used to destroy associated
records in the background forhas_many
associations with the
dependent: :destroy_async
option. Previously, that was ignored, which
meant the defaultActiveRecord::DestroyAssociationAsyncJob
always
destroyed records in the background.Nick Holden
-
Fix
change_column_comment
to preserve column's AUTO_INCREMENT in the MySQL adapterfatkodima
-
Fix quoting of
ActiveSupport::Duration
andRational
numbers in the MySQL adapter.Kevin McPhillips
-
Allow column name with COLLATE (e.g., title COLLATE "C") as safe SQL string
Shugo Maeda
-
Permit underscores in the VERSION argument to database rake tasks.
Eddie Lebow
-
Reversed the order of
INSERT
statements instructure.sql
dumpsThis should decrease the likelihood of merge conflicts. New migrations
will now be added at the top of the list.For existing apps, there will be a large diff the next time
structure.sql
is generated.Alex Ghiculescu, Matt Larraz
-
Fix PG.connect keyword arguments deprecation warning on ruby 2.7
Fixes #44307.
Nikita Vasilevsky
-
Fix dropping DB connections after serialization failures and deadlocks.
Prior to 6.1.4, serialization failures and deadlocks caused rollbacks to be
issued for both real transactions and savepoints. This breaks MySQL which
disallows rollbacks of savepoints following a deadlock.6.1.4 removed these rollbacks, for both transactions and savepoints, causing
the DB connection to be left in an unknown state and thus discarded.These rollbacks are now restored, except for savepoints on MySQL.
Thomas Morgan
-
Make
ActiveRecord::ConnectionPool
Fiber-safeWhen
ActiveSupport::IsolatedExecutionState.isolation_level
is set to:fiber
,
the connection pool now supports multiple Fibers from the same Thread checking
out connections from the pool.Alex Matchneer
-
Add
update_attribute!
toActiveRecord::Persistence
Similar to
update_attribute
, but raisesActiveRecord::RecordNotSaved
when abefore_*
callback throws:abort
.class Topic < ActiveRecord::Base before_save :check_title def check_title throw(:abort) if title == "abort" end end topic = Topic.create(title: "Test Title") # #=> #<Topic title: "Test Title"> topic.update_attribute!(:title, "Another Title") # #=> #<Topic title: "Another Title"> topic.update_attribute!(:title, "abort") # raises ActiveRecord::RecordNotSaved
Drew Tempelmeyer
-
Avoid loading every record in
ActiveRecord::Relation#pretty_print
# Before pp Foo.all # Loads the whole table. # After pp Foo.all # Shows 10 items and an ellipsis.
Ulysse Buonomo
-
Change
QueryMethods#in_order_of
to drop records not listed in values.in_order_of
now filters down to the values provided, to match the behavior of theEnumerable
version.Kevin Newton
-
Allow named expression indexes to be revertible.
Previously, the following code would raise an error in a reversible migration executed while rolling back, due to the index name not being used in the index removal.
add_index(:settings, "(data->'property')", using: :gin, name: :index_settings_data_property)
Fixes #43331.
Oliver Günther
-
Fix incorrect argument in PostgreSQL structure dump tasks.
Updating the
--no-comment
argument added in Rails 7 to the correct--no-comments
argument.Alex Dent
-
Fix migration compatibility to create SQLite references/belongs_to column as integer when migration version is 6.0.
Reference/belongs_to in migrations with version 6.0 were creating columns as
bigint instead of integer for the SQLite Adapter.Marcelo Lauxen
-
Fix
QueryMethods#in_order_of
to handle empty order list.Post.in_order_of(:id, []).to_a
Also more explicitly set the column as secondary order, so that any other
value is still ordered.Jean Boussier
-
Fix quoting of column aliases generated by calculation methods.
Since the alias is derived from the table name, we can't assume the result
is a valid identifier.class Test < ActiveRecord::Base self.table_name = '1abc' end Test.group(:id).count # syntax error at or near "1" (ActiveRecord::StatementInvalid) # LINE 1: SELECT COUNT(*) AS count_all, "1abc"."id" AS 1abc_id FROM "1...
Jean Boussier
-
Add
authenticate_by
when usinghas_secure_password
.authenticate_by
is intended to replace code like the following, which
returns early when a user with a matching email is not found:User.find_by(email: "...")&.authenticate("...")
Such code is vulnerable to timing-based enumeration attacks, wherein an
attacker can determine if a user account with a given email exists. After
confirming that an account exists, the attacker can try passwords associated
with that email address from other leaked databases, in case the user
re-used a password across multiple sites (a common practice). Additionally,
knowing an account email address allows the attacker to attempt a targeted
phishing ("spear phishing") attack.authenticate_by
addresses the vulnerability by taking the same amount of
time regardless of whether a user with a matching email is found:User.authenticate_by(email: "...", password: "...")
Jonathan Hefner
from Hacker News https://ift.tt/TPXKlt9
No comments:
Post a Comment
Note: Only a member of this blog may post a comment.