| Commit message (Collapse) | Author | Age | Files | Lines |
|---|
| | |
|
| | |
|
| | |
|
| |
|
|
|
| |
The current code base is not uniform. After some discussion,
we have chosen to go with double quotes by default.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Previously we had primarily tested the behavior of these attributes by
calling `.new`, allowing this to slip through the cracks. There were a
few ways in which they were behaving incorrectly.
The biggest issue was that attempting to read the attribute would
through a `MissingAttribute` error. We've corrected this by returning
the default value when the attribute isn't backed by a database column.
This is super special cased, but I don't see a way to avoid this
conditional. I had considered handling this higher up in
`define_default_attribute`, but we don't have the relevant information
there as users can provide new defaults for database columns as well.
Once I corrected this, I had noticed that the attributes were always
being marked as changed. This is because the behavior of
`define_default_attribute` was treating them as assigned from
`Attribute::Null`.
Finally, with our new implementation, `LazyAttributeHash` could no
longer be marshalled, as it holds onto a proc. This has been corrected
as well. I've not handled YAML in that class, as we do additional work
higher up to avoid YAML dumping it at all.
Fixes #25787
Close #25841
|
| |
|
|
|
|
|
|
|
| |
As mentioned in 7b86ea6715ee987e61a7f3bd8e72b1bbfcfbbbe7, this is an
internal class.
[ci skip]
r? @sgrif
|
| |
|
|
|
|
|
|
| |
ActiveRecord::AttributeSet::YAMLEncoder#decode"
This reverts commit 7ea502ae141fc26b736c7a73bdf7a676b1f9fc87, per
internal discussion with @sgrif -- this is documenting the
implementation of a class that isn't intended to be public API.
|
| | |
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
This reduces the size of a YAML encoded Active Record object by ~80%
depending on the number of columns. There were a number of wasteful
things that occurred when we encoded the objects before that have
resulted in numerous wins
- We were emitting the result of `attributes_before_type_cast` as a hack
to work around some laziness issues
- The name of an attribute was emitted multiple times, since the
attribute objects were in a hash keyed by the name. We now store them
in an array instead, and reconstruct the hash using the name
- The types were included for every attribute. This would use backrefs
if multiple objects were encoded, but really we don't need to include
it at all unless it differs from the type at the class level. (The
only time that will occur is if the field is the result of a custom
select clause)
- `original_attribute:` was included over and over and over again since
the ivar is almost always `nil`. We've added a custom implementation
of `encode_with` on the attribute objects to ensure we don't write the
key when the field is `nil`.
This isn't without a cost though. Since we're no longer including the
types, an object can find itself in an invalid state if the type changes
on the class after serialization. This is the same as 4.1 and earlier,
but I think it's worth noting.
I was worried that I'd introduce some new state bugs as a result of
doing this, so I've added an additional test that asserts mutation not
being lost as the result of YAML round tripping.
Fixes #25145
|
| |
|
|
|
|
|
| |
Any gems or libraries which do work with serialization or YAML will
ultimately need to compare these objects (albeit indirectly) to ensure
correctness. These will likely never get used internally (as they're
slow), but we should still expose them for others.
|
| |
|
|
|
|
|
|
|
|
|
| |
I'm looking to move towards a tree-like structure for dirty checking
that involves an attribute holding onto the attribute that it was
created from. This means that `changed?` can be fully encapsulated on
that object. Since the objects are immutable, in `changes_applied`, we
can simply perform a shallow dup, instead of a deep one.
I'm not sure if that will actually end up in a performance boost, but
I'd like to semantically separate these concepts regardless
|
| |
|
|
|
| |
autoloading this could possibly cause some weird race condition
when calling an AR::Attribute's singleton method on a threaded server.
|
| |
|
|
| |
Fixes #18871
|
| |
|
|
|
|
|
|
|
| |
This method doesn't need to be lazy, as it is never called from reads.
The only time it is called are in write cases, where we're about to loop
through the results of it, and build the attribute objects anyway. So we
don't gain anything by dodging the instantiation here. This is the only
method that coupled `AttributeSet` to `LazyAttributeHash`, so removing
it puts us back in a place where we can use a normal hash instead.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
`freeze` will ultimately end up freezing the `AttributeSet`, which in
turn freezes its `@attributes` hash. However, we actually insert a
special object to lazily instantiate the values of the hash on demand.
When it does need to actually instantiate all of them for iteration (the
only case is `ActiveRecord::Base#attributes`, which calls
`AttributeSet#to_h`), it will set an instance variable as a performance
optimization
Since it's just an optimization for subsequent calls, and that method
being called at all is a very uncommon case, we can just leave the ivar
alone if we're frozen, as opposed to coming up with some overly
complicated mechanism for freezing which allows us to continue to modify
ourselves.
Fixes #17960
|
| |
|
|
| |
This appears to be a performance hotspot, see #17655.
|
| | |
|
| |
|
|
| |
Performance improvement, as well as improved code clarity
|
| |
|
|
| |
This class no longer has any private methods
|
| | |
|
| |
|
|
|
|
|
|
| |
`default_proc` makes a hash unmarshallable, and adds unneccessary
overhead. Since we control all access to the hash, let's just handle it
in that method. This has the side effect of improving performance on
initialization (but not neccessarily on access). We'll need to profile
further once the tests are passing.
|
| |
|
|
|
|
|
| |
In real usage, we give the builder a types hash with a default value of
`Type::Value.new`. This means we need to explicitly check for the key,
rather than the truthiness of the type to determine if it's a known but
uninitialized attribute
|
| |
|
|
|
|
|
|
|
|
| |
We don't know which attributes will or won't be used, and we don't want
to create massive bottlenecks at instantiation. Rather than doing *any*
iteration over types and values, we can lazily instantiate the object.
The lazy attribute hash should not fully implement hash, or subclass
hash at any point in the future. It is not meant to be a replacement,
but instead implement its own interface which happens to overlap.
|
| |
|
|
|
|
|
|
|
|
| |
This reverts commit 8fee923888192a658d8823b31e77ed0683dfd665.
Conflicts:
activerecord/lib/active_record/attribute_set/builder.rb
This solution sucks, and is hard to actually apply across the board.
Going to try other solutions
|
| | |
|
| |
|
|
|
|
|
| |
We introduced a performance hit by adding an additional iteration
through a model's attributes on creation. We don't actually need the
values from `Result` to be a hash, we can separate the columns and
values and zip them up ourself during the iteration that we have to do.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Benchmark:
```ruby
require 'objspace'
require 'active_record'
ActiveRecord::Base.establish_connection adapter: "sqlite3",
database: ":memory:"
ActiveRecord::Base.connection.instance_eval do
create_table(:articles) { |t| t.string :name }
end
class Article < ActiveRecord::Base; end
a = Article.create name: "foo"
a = Article.find a.id
N = 10
ObjectSpace::AllocationTracer.trace do
N.times { Article.find a.id }
end
ObjectSpace::AllocationTracer.allocated_count_table
table.sort_by { |_,x| x }.each do |k,v|
p k => (v / N)
end
```
|
| |
|
|
|
| |
This allows using polymorphism for the uninitialized attributes raising
an exception behavior.
|
| |
|
|
|
|
|
|
| |
This will make it less painful to add additional properties, which
should persist across writes, such as `name`.
Conflicts:
activerecord/lib/active_record/attribute_set.rb
|
|
|
Moved `Builder` to its own file, as it started looking very weird once I
added private methods to the `AttributeSet` class and the `Builder`
class started to grow.
Would like to refactor `fetch_value` to change to
```ruby
self[name].value(&block)
```
But that requires the attributes to know about their name, which they
currently do not.
|
