2011-06-06 14:17:44 -04:00
|
|
|
require "cases/helper"
|
2010-11-30 17:47:55 -05:00
|
|
|
require 'models/post'
|
|
|
|
require 'models/comment'
|
2013-04-10 08:34:47 -04:00
|
|
|
require 'models/author'
|
|
|
|
require 'models/rating'
|
2010-11-30 17:10:55 -05:00
|
|
|
|
|
|
|
module ActiveRecord
|
|
|
|
class RelationTest < ActiveRecord::TestCase
|
2013-04-10 08:34:47 -04:00
|
|
|
fixtures :posts, :comments, :authors
|
2010-11-30 17:47:55 -05:00
|
|
|
|
Use separate Relation subclasses for each AR class
At present, ActiveRecord::Delegation compiles delegation methods on a
global basis. The compiled methods apply to all subsequent Relation
instances. This creates several problems:
1) After Post.all.recent has been called, User.all.respond_to?(:recent)
will be true, even if User.all.recent will actually raise an error due
to no User.recent method existing. (See #8080.)
2) Depending on the AR class, the delegation should do different things.
For example, if a Post.zip method exists, then Post.all.zip should call
it. But this will then result in User.zip being called by a subsequent
User.all.zip, even if User.zip does not exist, when in fact
User.all.zip should call User.all.to_a.zip. (There are various
variants of this problem.)
We are creating these compiled delegations in order to avoid method
missing and to avoid repeating logic on each invocation.
One way of handling these issues is to add additional checks in various
places to ensure we're doing the "right thing". However, this makes the
compiled methods signficantly slower. In which case, there's almost no
point in avoiding method_missing at all. (See #8127 for a proposed
solution which takes this approach.)
This is an alternative approach which involves creating a subclass of
ActiveRecord::Relation for each AR class represented. So, with this
patch, Post.all.class != User.all.class. This means that the delegations
are compiled for and only apply to a single AR class. A compiled method
for Post.all will not be invoked from User.all.
This solves the above issues without incurring significant performance
penalties. It's designed to be relatively seamless, however the downside
is a bit of complexity and potentially confusion for a user who thinks
that Post.all and User.all should be instances of the same class.
Benchmark
---------
require 'active_record'
require 'benchmark/ips'
class Post < ActiveRecord::Base
establish_connection adapter: 'sqlite3', database: ':memory:'
connection.create_table :posts
def self.omg
:omg
end
end
relation = Post.all
Benchmark.ips do |r|
r.report('delegation') { relation.omg }
r.report('constructing') { Post.all }
end
Before
------
Calculating -------------------------------------
delegation 4392 i/100ms
constructing 4780 i/100ms
-------------------------------------------------
delegation 144235.9 (±27.7%) i/s - 663192 in 5.038075s
constructing 182015.5 (±21.2%) i/s - 850840 in 5.005364s
After
-----
Calculating -------------------------------------
delegation 6677 i/100ms
constructing 6260 i/100ms
-------------------------------------------------
delegation 166828.2 (±34.2%) i/s - 754501 in 5.001430s
constructing 116575.5 (±18.6%) i/s - 563400 in 5.036690s
Comments
--------
Bear in mind that the standard deviations in the above are huge, so we
can't compare the numbers too directly. However, we can conclude that
Relation construction has become a little slower (as we'd expect), but
not by a huge huge amount, and we can still construct a large number of
Relations quite quickly.
2012-11-23 07:36:22 -05:00
|
|
|
class FakeKlass < Struct.new(:table_name, :name)
|
2013-08-30 19:48:20 -04:00
|
|
|
extend ActiveRecord::Delegation::DelegateCache
|
|
|
|
|
|
|
|
inherited self
|
|
|
|
|
2013-07-15 19:29:01 -04:00
|
|
|
def self.connection
|
|
|
|
Post.connection
|
|
|
|
end
|
2013-11-10 00:28:54 -05:00
|
|
|
|
|
|
|
def self.table_name
|
|
|
|
'fake_table'
|
|
|
|
end
|
2015-10-30 21:04:38 -04:00
|
|
|
|
|
|
|
def self.sanitize_sql_for_order(sql)
|
|
|
|
sql
|
|
|
|
end
|
2010-11-30 17:29:35 -05:00
|
|
|
end
|
|
|
|
|
2010-11-30 17:10:55 -05:00
|
|
|
def test_construction
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(FakeKlass, :b, nil)
|
Use separate Relation subclasses for each AR class
At present, ActiveRecord::Delegation compiles delegation methods on a
global basis. The compiled methods apply to all subsequent Relation
instances. This creates several problems:
1) After Post.all.recent has been called, User.all.respond_to?(:recent)
will be true, even if User.all.recent will actually raise an error due
to no User.recent method existing. (See #8080.)
2) Depending on the AR class, the delegation should do different things.
For example, if a Post.zip method exists, then Post.all.zip should call
it. But this will then result in User.zip being called by a subsequent
User.all.zip, even if User.zip does not exist, when in fact
User.all.zip should call User.all.to_a.zip. (There are various
variants of this problem.)
We are creating these compiled delegations in order to avoid method
missing and to avoid repeating logic on each invocation.
One way of handling these issues is to add additional checks in various
places to ensure we're doing the "right thing". However, this makes the
compiled methods signficantly slower. In which case, there's almost no
point in avoiding method_missing at all. (See #8127 for a proposed
solution which takes this approach.)
This is an alternative approach which involves creating a subclass of
ActiveRecord::Relation for each AR class represented. So, with this
patch, Post.all.class != User.all.class. This means that the delegations
are compiled for and only apply to a single AR class. A compiled method
for Post.all will not be invoked from User.all.
This solves the above issues without incurring significant performance
penalties. It's designed to be relatively seamless, however the downside
is a bit of complexity and potentially confusion for a user who thinks
that Post.all and User.all should be instances of the same class.
Benchmark
---------
require 'active_record'
require 'benchmark/ips'
class Post < ActiveRecord::Base
establish_connection adapter: 'sqlite3', database: ':memory:'
connection.create_table :posts
def self.omg
:omg
end
end
relation = Post.all
Benchmark.ips do |r|
r.report('delegation') { relation.omg }
r.report('constructing') { Post.all }
end
Before
------
Calculating -------------------------------------
delegation 4392 i/100ms
constructing 4780 i/100ms
-------------------------------------------------
delegation 144235.9 (±27.7%) i/s - 663192 in 5.038075s
constructing 182015.5 (±21.2%) i/s - 850840 in 5.005364s
After
-----
Calculating -------------------------------------
delegation 6677 i/100ms
constructing 6260 i/100ms
-------------------------------------------------
delegation 166828.2 (±34.2%) i/s - 754501 in 5.001430s
constructing 116575.5 (±18.6%) i/s - 563400 in 5.036690s
Comments
--------
Bear in mind that the standard deviations in the above are huge, so we
can't compare the numbers too directly. However, we can conclude that
Relation construction has become a little slower (as we'd expect), but
not by a huge huge amount, and we can still construct a large number of
Relations quite quickly.
2012-11-23 07:36:22 -05:00
|
|
|
assert_equal FakeKlass, relation.klass
|
2010-11-30 17:10:55 -05:00
|
|
|
assert_equal :b, relation.table
|
|
|
|
assert !relation.loaded, 'relation is not loaded'
|
|
|
|
end
|
|
|
|
|
2012-06-03 01:20:49 -04:00
|
|
|
def test_responds_to_model_and_returns_klass
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(FakeKlass, :b, nil)
|
Use separate Relation subclasses for each AR class
At present, ActiveRecord::Delegation compiles delegation methods on a
global basis. The compiled methods apply to all subsequent Relation
instances. This creates several problems:
1) After Post.all.recent has been called, User.all.respond_to?(:recent)
will be true, even if User.all.recent will actually raise an error due
to no User.recent method existing. (See #8080.)
2) Depending on the AR class, the delegation should do different things.
For example, if a Post.zip method exists, then Post.all.zip should call
it. But this will then result in User.zip being called by a subsequent
User.all.zip, even if User.zip does not exist, when in fact
User.all.zip should call User.all.to_a.zip. (There are various
variants of this problem.)
We are creating these compiled delegations in order to avoid method
missing and to avoid repeating logic on each invocation.
One way of handling these issues is to add additional checks in various
places to ensure we're doing the "right thing". However, this makes the
compiled methods signficantly slower. In which case, there's almost no
point in avoiding method_missing at all. (See #8127 for a proposed
solution which takes this approach.)
This is an alternative approach which involves creating a subclass of
ActiveRecord::Relation for each AR class represented. So, with this
patch, Post.all.class != User.all.class. This means that the delegations
are compiled for and only apply to a single AR class. A compiled method
for Post.all will not be invoked from User.all.
This solves the above issues without incurring significant performance
penalties. It's designed to be relatively seamless, however the downside
is a bit of complexity and potentially confusion for a user who thinks
that Post.all and User.all should be instances of the same class.
Benchmark
---------
require 'active_record'
require 'benchmark/ips'
class Post < ActiveRecord::Base
establish_connection adapter: 'sqlite3', database: ':memory:'
connection.create_table :posts
def self.omg
:omg
end
end
relation = Post.all
Benchmark.ips do |r|
r.report('delegation') { relation.omg }
r.report('constructing') { Post.all }
end
Before
------
Calculating -------------------------------------
delegation 4392 i/100ms
constructing 4780 i/100ms
-------------------------------------------------
delegation 144235.9 (±27.7%) i/s - 663192 in 5.038075s
constructing 182015.5 (±21.2%) i/s - 850840 in 5.005364s
After
-----
Calculating -------------------------------------
delegation 6677 i/100ms
constructing 6260 i/100ms
-------------------------------------------------
delegation 166828.2 (±34.2%) i/s - 754501 in 5.001430s
constructing 116575.5 (±18.6%) i/s - 563400 in 5.036690s
Comments
--------
Bear in mind that the standard deviations in the above are huge, so we
can't compare the numbers too directly. However, we can conclude that
Relation construction has become a little slower (as we'd expect), but
not by a huge huge amount, and we can still construct a large number of
Relations quite quickly.
2012-11-23 07:36:22 -05:00
|
|
|
assert_equal FakeKlass, relation.model
|
2012-06-03 01:20:49 -04:00
|
|
|
end
|
|
|
|
|
2010-11-30 17:10:55 -05:00
|
|
|
def test_initialize_single_values
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(FakeKlass, :b, nil)
|
2012-04-13 07:10:51 -04:00
|
|
|
(Relation::SINGLE_VALUE_METHODS - [:create_with]).each do |method|
|
2010-11-30 17:10:55 -05:00
|
|
|
assert_nil relation.send("#{method}_value"), method.to_s
|
|
|
|
end
|
2015-05-15 09:38:26 -04:00
|
|
|
value = relation.create_with_value
|
|
|
|
assert_equal({}, value)
|
|
|
|
assert_predicate value, :frozen?
|
2010-11-30 17:10:55 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_multi_value_initialize
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(FakeKlass, :b, nil)
|
2010-11-30 17:10:55 -05:00
|
|
|
Relation::MULTI_VALUE_METHODS.each do |method|
|
2015-05-15 09:38:26 -04:00
|
|
|
values = relation.send("#{method}_values")
|
|
|
|
assert_equal [], values, method.to_s
|
|
|
|
assert_predicate values, :frozen?, method.to_s
|
2010-11-30 17:10:55 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_extensions
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(FakeKlass, :b, nil)
|
2010-11-30 17:10:55 -05:00
|
|
|
assert_equal [], relation.extensions
|
|
|
|
end
|
2010-11-30 17:29:35 -05:00
|
|
|
|
2010-11-30 17:47:55 -05:00
|
|
|
def test_empty_where_values_hash
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(FakeKlass, :b, nil)
|
2010-11-30 17:29:35 -05:00
|
|
|
assert_equal({}, relation.where_values_hash)
|
|
|
|
end
|
|
|
|
|
2010-11-30 17:47:55 -05:00
|
|
|
def test_has_values
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
|
2014-12-29 13:21:56 -05:00
|
|
|
relation.where! relation.table[:id].eq(10)
|
2010-11-30 17:47:55 -05:00
|
|
|
assert_equal({:id => 10}, relation.where_values_hash)
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_values_wrong_table
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
|
2014-12-29 13:21:56 -05:00
|
|
|
relation.where! Comment.arel_table[:id].eq(10)
|
2010-11-30 17:47:55 -05:00
|
|
|
assert_equal({}, relation.where_values_hash)
|
|
|
|
end
|
|
|
|
|
2010-11-30 17:56:32 -05:00
|
|
|
def test_tree_is_not_traversed
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
|
2014-12-29 13:21:56 -05:00
|
|
|
left = relation.table[:id].eq(10)
|
|
|
|
right = relation.table[:id].eq(10)
|
2010-11-30 17:56:32 -05:00
|
|
|
combine = left.and right
|
2012-04-13 10:59:47 -04:00
|
|
|
relation.where! combine
|
2010-11-30 17:56:32 -05:00
|
|
|
assert_equal({}, relation.where_values_hash)
|
|
|
|
end
|
|
|
|
|
2010-11-30 17:29:35 -05:00
|
|
|
def test_table_name_delegates_to_klass
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(FakeKlass.new('posts'), :b, Post.predicate_builder)
|
2013-08-30 19:48:20 -04:00
|
|
|
assert_equal 'posts', relation.table_name
|
2010-11-30 17:29:35 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_scope_for_create
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(FakeKlass, :b, nil)
|
2010-11-30 17:29:35 -05:00
|
|
|
assert_equal({}, relation.scope_for_create)
|
|
|
|
end
|
2010-11-30 18:44:30 -05:00
|
|
|
|
|
|
|
def test_create_with_value
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
|
2010-11-30 18:44:30 -05:00
|
|
|
hash = { :hello => 'world' }
|
|
|
|
relation.create_with_value = hash
|
|
|
|
assert_equal hash, relation.scope_for_create
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_create_with_value_with_wheres
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
|
2014-12-29 13:21:56 -05:00
|
|
|
relation.where! relation.table[:id].eq(10)
|
2010-11-30 18:44:30 -05:00
|
|
|
relation.create_with_value = {:hello => 'world'}
|
|
|
|
assert_equal({:hello => 'world', :id => 10}, relation.scope_for_create)
|
|
|
|
end
|
2010-11-30 18:45:32 -05:00
|
|
|
|
|
|
|
# FIXME: is this really wanted or expected behavior?
|
|
|
|
def test_scope_for_create_is_cached
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
|
2010-11-30 18:45:32 -05:00
|
|
|
assert_equal({}, relation.scope_for_create)
|
|
|
|
|
2014-12-29 13:21:56 -05:00
|
|
|
relation.where! relation.table[:id].eq(10)
|
2010-11-30 18:45:32 -05:00
|
|
|
assert_equal({}, relation.scope_for_create)
|
|
|
|
|
|
|
|
relation.create_with_value = {:hello => 'world'}
|
|
|
|
assert_equal({}, relation.scope_for_create)
|
|
|
|
end
|
2010-11-30 19:10:49 -05:00
|
|
|
|
2013-07-23 18:02:43 -04:00
|
|
|
def test_bad_constants_raise_errors
|
|
|
|
assert_raises(NameError) do
|
|
|
|
ActiveRecord::Relation::HelloWorld
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-11-30 19:10:49 -05:00
|
|
|
def test_empty_eager_loading?
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(FakeKlass, :b, nil)
|
2010-11-30 19:10:49 -05:00
|
|
|
assert !relation.eager_loading?
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_eager_load_values
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(FakeKlass, :b, nil)
|
2012-04-13 10:59:47 -04:00
|
|
|
relation.eager_load! :b
|
2010-11-30 19:10:49 -05:00
|
|
|
assert relation.eager_loading?
|
|
|
|
end
|
2012-01-13 18:56:07 -05:00
|
|
|
|
|
|
|
def test_references_values
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(FakeKlass, :b, nil)
|
2012-01-13 18:56:07 -05:00
|
|
|
assert_equal [], relation.references_values
|
|
|
|
relation = relation.references(:foo).references(:omg, :lol)
|
2012-01-14 16:14:21 -05:00
|
|
|
assert_equal ['foo', 'omg', 'lol'], relation.references_values
|
2012-01-13 18:56:07 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_references_values_dont_duplicate
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(FakeKlass, :b, nil)
|
2012-01-13 18:56:07 -05:00
|
|
|
relation = relation.references(:foo).references(:foo)
|
2012-01-14 16:14:21 -05:00
|
|
|
assert_equal ['foo'], relation.references_values
|
2012-01-13 18:56:07 -05:00
|
|
|
end
|
2012-01-16 16:14:34 -05:00
|
|
|
|
2012-04-13 07:10:51 -04:00
|
|
|
test 'merging a hash into a relation' do
|
2015-10-17 21:51:03 -04:00
|
|
|
relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
|
|
|
|
relation = relation.merge where: {name: :lol}, readonly: true
|
2012-04-13 07:10:51 -04:00
|
|
|
|
2015-10-17 21:51:03 -04:00
|
|
|
assert_equal({"name"=>:lol}, relation.where_clause.to_h)
|
2012-04-13 07:10:51 -04:00
|
|
|
assert_equal true, relation.readonly_value
|
|
|
|
end
|
|
|
|
|
|
|
|
test 'merging an empty hash into a relation' do
|
2015-01-25 19:35:46 -05:00
|
|
|
assert_equal Relation::WhereClause.empty, Relation.new(FakeKlass, :b, nil).merge({}).where_clause
|
2012-04-13 07:10:51 -04:00
|
|
|
end
|
2012-04-13 07:15:43 -04:00
|
|
|
|
|
|
|
test 'merging a hash with unknown keys raises' do
|
|
|
|
assert_raises(ArgumentError) { Relation::HashMerger.new(nil, omg: 'lol') }
|
|
|
|
end
|
2012-04-13 11:17:28 -04:00
|
|
|
|
2015-02-06 14:50:45 -05:00
|
|
|
test 'merging nil or false raises' do
|
|
|
|
relation = Relation.new(FakeKlass, :b, nil)
|
|
|
|
|
|
|
|
e = assert_raises(ArgumentError) do
|
|
|
|
relation = relation.merge nil
|
|
|
|
end
|
|
|
|
|
|
|
|
assert_equal 'invalid argument: nil.', e.message
|
|
|
|
|
|
|
|
e = assert_raises(ArgumentError) do
|
|
|
|
relation = relation.merge false
|
|
|
|
end
|
|
|
|
|
|
|
|
assert_equal 'invalid argument: false.', e.message
|
|
|
|
end
|
|
|
|
|
2012-04-13 11:17:28 -04:00
|
|
|
test '#values returns a dup of the values' do
|
2015-10-17 21:51:03 -04:00
|
|
|
relation = Relation.new(Post, Post.arel_table, Post.predicate_builder).where!(name: :foo)
|
2012-04-13 11:17:28 -04:00
|
|
|
values = relation.values
|
|
|
|
|
|
|
|
values[:where] = nil
|
2015-01-25 19:35:46 -05:00
|
|
|
assert_not_nil relation.where_clause
|
2012-04-13 11:17:28 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
test 'relations can be created with a values hash' do
|
Introduce `Relation::WhereClause`
The way that bind values are currently stored on Relation is a mess.
They can come from `having`, `where`, or `join`. I'm almost certain that
`having` is actually broken, and calling `where` followed by `having`
followed by `where` will completely scramble the binds.
Joins don't actually add the bind parameters to the relation itself, but
instead add it onto an accessor on the arel AST which is undocumented,
and unused in Arel itself. This means that the bind values must always
be accessed as `relation.arel.bind_values + relation.bind_values`.
Anything that doesn't is likely broken (and tons of bugs have come up
for exactly that reason)
The result is that everything dealing with `Relation` instances has to
know far too much about the internals. The binds are split, combined,
and re-stored in non-obvious ways that makes it difficult to change
anything about the internal representation of `bind_values`, and is
extremely prone to bugs.
So the goal is to move a lot of logic off of `Relation`, and into
separate objects. This is not the same as what is currently done with
`JoinDependency`, as `Relation` knows far too much about its internals,
and vice versa. Instead these objects need to be black boxes that can
have their implementations swapped easily.
The end result will be two classes, `WhereClause` and `JoinClause`
(`having` will just re-use `WhereClause`), and there will be a single
method to access the bind values of a `Relation` which will be
implemented as
```
join_clause.binds + where_clause.binds + having_clause.binds
```
This is the first step towards that refactoring, with the internal
representation of where changed, and an intermediate representation of
`where_values` and `bind_values` to let the refactoring take small
steps. These will be removed shortly.
2015-01-25 16:54:18 -05:00
|
|
|
relation = Relation.new(FakeKlass, :b, nil, select: [:foo])
|
|
|
|
assert_equal [:foo], relation.select_values
|
2012-04-13 11:17:28 -04:00
|
|
|
end
|
2012-04-22 05:34:55 -04:00
|
|
|
|
|
|
|
test 'merging a hash interpolates conditions' do
|
2013-08-30 19:48:20 -04:00
|
|
|
klass = Class.new(FakeKlass) do
|
|
|
|
def self.sanitize_sql(args)
|
|
|
|
raise unless args == ['foo = ?', 'bar']
|
|
|
|
'foo = bar'
|
|
|
|
end
|
|
|
|
end
|
2012-04-22 05:34:55 -04:00
|
|
|
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(klass, :b, nil)
|
2012-04-22 05:34:55 -04:00
|
|
|
relation.merge!(where: ['foo = ?', 'bar'])
|
2015-01-27 12:30:38 -05:00
|
|
|
assert_equal Relation::WhereClause.new(['foo = bar'], []), relation.where_clause
|
2012-04-22 05:34:55 -04:00
|
|
|
end
|
2013-04-10 08:34:47 -04:00
|
|
|
|
2013-09-11 08:18:31 -04:00
|
|
|
def test_merging_readonly_false
|
2014-12-26 15:53:56 -05:00
|
|
|
relation = Relation.new(FakeKlass, :b, nil)
|
2013-09-11 08:18:31 -04:00
|
|
|
readonly_false_relation = relation.readonly(false)
|
|
|
|
# test merging in both directions
|
|
|
|
assert_equal false, relation.merge(readonly_false_relation).readonly_value
|
|
|
|
assert_equal false, readonly_false_relation.merge(relation).readonly_value
|
|
|
|
end
|
|
|
|
|
2013-05-29 23:36:19 -04:00
|
|
|
def test_relation_merging_with_merged_joins_as_symbols
|
2013-04-10 08:34:47 -04:00
|
|
|
special_comments_with_ratings = SpecialComment.joins(:ratings)
|
|
|
|
posts_with_special_comments_with_ratings = Post.group("posts.id").joins(:special_comments).merge(special_comments_with_ratings)
|
2013-04-11 09:27:07 -04:00
|
|
|
assert_equal 3, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count.length
|
2013-04-10 08:34:47 -04:00
|
|
|
end
|
|
|
|
|
2013-12-28 21:46:21 -05:00
|
|
|
def test_relation_merging_with_joins_as_join_dependency_pick_proper_parent
|
|
|
|
post = Post.create!(title: "haha", body: "huhu")
|
|
|
|
comment = post.comments.create!(body: "hu")
|
|
|
|
3.times { comment.ratings.create! }
|
|
|
|
|
2013-12-31 18:04:11 -05:00
|
|
|
relation = Post.joins(:comments).merge Comment.joins(:ratings)
|
2013-12-28 21:46:21 -05:00
|
|
|
|
2013-12-31 18:04:11 -05:00
|
|
|
assert_equal 3, relation.where(id: post.id).pluck(:id).size
|
2013-12-28 21:46:21 -05:00
|
|
|
end
|
|
|
|
|
2015-11-17 09:57:48 -05:00
|
|
|
def test_merge_raises_with_invalid_argument
|
|
|
|
assert_raises ArgumentError do
|
|
|
|
relation = Relation.new(FakeKlass, :b, nil)
|
|
|
|
relation.merge(true)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-04-13 21:19:17 -04:00
|
|
|
def test_respond_to_for_non_selected_element
|
2013-04-20 03:26:07 -04:00
|
|
|
post = Post.select(:title).first
|
|
|
|
assert_equal false, post.respond_to?(:body), "post should not respond_to?(:body) since invoking it raises exception"
|
|
|
|
|
2013-05-07 05:36:14 -04:00
|
|
|
silence_warnings { post = Post.select("'title' as post_title").first }
|
2013-04-20 03:26:07 -04:00
|
|
|
assert_equal false, post.respond_to?(:title), "post should not respond_to?(:body) since invoking it raises exception"
|
2013-04-13 21:19:17 -04:00
|
|
|
end
|
|
|
|
|
2015-05-30 14:26:41 -04:00
|
|
|
def test_select_quotes_when_using_from_clause
|
2015-09-21 13:36:55 -04:00
|
|
|
skip_if_sqlite3_version_includes_quoting_bug
|
2015-05-30 14:26:41 -04:00
|
|
|
quoted_join = ActiveRecord::Base.connection.quote_table_name("join")
|
|
|
|
selected = Post.select(:join).from(Post.select("id as #{quoted_join}")).map(&:join)
|
|
|
|
assert_equal Post.pluck(:id), selected
|
|
|
|
end
|
|
|
|
|
2015-09-21 13:36:55 -04:00
|
|
|
def test_selecting_aliased_attribute_quotes_column_name_when_from_is_used
|
|
|
|
skip_if_sqlite3_version_includes_quoting_bug
|
|
|
|
klass = Class.new(ActiveRecord::Base) do
|
|
|
|
self.table_name = :test_with_keyword_column_name
|
|
|
|
alias_attribute :description, :desc
|
|
|
|
end
|
|
|
|
klass.create!(description: "foo")
|
|
|
|
|
|
|
|
assert_equal ["foo"], klass.select(:description).from(klass.all).map(&:desc)
|
|
|
|
end
|
|
|
|
|
2013-05-29 23:36:19 -04:00
|
|
|
def test_relation_merging_with_merged_joins_as_strings
|
|
|
|
join_string = "LEFT OUTER JOIN #{Rating.quoted_table_name} ON #{SpecialComment.quoted_table_name}.id = #{Rating.quoted_table_name}.comment_id"
|
|
|
|
special_comments_with_ratings = SpecialComment.joins join_string
|
|
|
|
posts_with_special_comments_with_ratings = Post.group("posts.id").joins(:special_comments).merge(special_comments_with_ratings)
|
|
|
|
assert_equal 3, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count.length
|
|
|
|
end
|
2014-06-25 21:32:14 -04:00
|
|
|
|
|
|
|
class EnsureRoundTripTypeCasting < ActiveRecord::Type::Value
|
|
|
|
def type
|
|
|
|
:string
|
|
|
|
end
|
|
|
|
|
2015-02-17 13:29:51 -05:00
|
|
|
def deserialize(value)
|
2014-06-25 21:32:14 -04:00
|
|
|
raise value unless value == "type cast for database"
|
|
|
|
"type cast from database"
|
|
|
|
end
|
|
|
|
|
2015-02-17 15:35:23 -05:00
|
|
|
def serialize(value)
|
2014-06-25 21:32:14 -04:00
|
|
|
raise value unless value == "value from user"
|
|
|
|
"type cast for database"
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
class UpdateAllTestModel < ActiveRecord::Base
|
|
|
|
self.table_name = 'posts'
|
|
|
|
|
|
|
|
attribute :body, EnsureRoundTripTypeCasting.new
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_update_all_goes_through_normal_type_casting
|
|
|
|
UpdateAllTestModel.update_all(body: "value from user", type: nil) # No STI
|
|
|
|
|
|
|
|
assert_equal "type cast from database", UpdateAllTestModel.first.body
|
|
|
|
end
|
2015-05-30 14:26:41 -04:00
|
|
|
|
|
|
|
private
|
|
|
|
|
2015-09-21 13:36:55 -04:00
|
|
|
def skip_if_sqlite3_version_includes_quoting_bug
|
|
|
|
if sqlite3_version_includes_quoting_bug?
|
|
|
|
skip <<-ERROR.squish
|
|
|
|
You are using an outdated version of SQLite3 which has a bug in
|
|
|
|
quoted column names. Please update SQLite3 and rebuild the sqlite3
|
|
|
|
ruby gem
|
|
|
|
ERROR
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2015-06-02 09:29:44 -04:00
|
|
|
def sqlite3_version_includes_quoting_bug?
|
2015-05-30 14:26:41 -04:00
|
|
|
if current_adapter?(:SQLite3Adapter)
|
|
|
|
selected_quoted_column_names = ActiveRecord::Base.connection.exec_query(
|
|
|
|
'SELECT "join" FROM (SELECT id AS "join" FROM posts) subquery'
|
|
|
|
).columns
|
2015-06-02 09:29:44 -04:00
|
|
|
["join"] != selected_quoted_column_names
|
2015-05-30 14:26:41 -04:00
|
|
|
end
|
|
|
|
end
|
2010-11-30 17:10:55 -05:00
|
|
|
end
|
|
|
|
end
|