1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
module ActiveRecord
module Associations
class AssociationScope #:nodoc:
attr_reader :association, :alias_tracker
delegate :klass, :owner, :reflection, :to => :association
delegate :chain, :scope_chain, :options, :to => :reflection
def initialize(association)
@association = association
@alias_tracker = AliasTracker.new klass.connection
end
def scope
scope = klass.unscoped
scope.extending! Array(options[:extend])
add_constraints(scope)
end
def join_type
Arel::Nodes::InnerJoin
end
private
def construct_tables
chain.map do |reflection|
alias_tracker.aliased_table_for(
table_name_for(reflection),
table_alias_for(reflection, reflection != self.reflection)
)
end
end
def table_alias_for(reflection, join = false)
name = "#{reflection.plural_name}_#{alias_suffix}"
name << "_join" if join
name
end
def join(table, constraint)
table.create_join(table, table.create_on(constraint), join_type)
end
def column_for(table_name, column_name)
columns = alias_tracker.connection.schema_cache.columns_hash(table_name)
columns[column_name]
end
def bind_value(scope, column, value)
substitute = alias_tracker.connection.substitute_at(
column, scope.bind_values.length)
scope.bind_values += [[column, value]]
substitute
end
def bind(scope, table_name, column_name, value)
column = column_for table_name, column_name
bind_value scope, column, value
end
def add_constraints(scope)
tables = construct_tables
chain.each_with_index do |reflection, i|
table, foreign_table = tables.shift, tables.first
if reflection.source_macro == :belongs_to
if reflection.options[:polymorphic]
key = reflection.association_primary_key(self.klass)
else
key = reflection.association_primary_key
end
foreign_key = reflection.foreign_key
else
key = reflection.foreign_key
foreign_key = reflection.active_record_primary_key
end
if reflection == chain.last
bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key]
scope = scope.where(table[key].eq(bind_val))
if reflection.type
value = owner.class.base_class.name
bind_val = bind scope, table.table_name, reflection.type.to_s, value
scope = scope.where(table[reflection.type].eq(bind_val))
end
else
constraint = table[key].eq(foreign_table[foreign_key])
if reflection.type
value = chain[i + 1].klass.base_class.name
bind_val = bind scope, table.table_name, reflection.type.to_s, value
scope = scope.where(table[reflection.type].eq(bind_val))
end
scope = scope.joins(join(foreign_table, constraint))
end
is_first_chain = i == 0
klass = is_first_chain ? self.klass : reflection.klass
# Exclude the scope of the association itself, because that
# was already merged in the #scope method.
scope_chain[i].each do |scope_chain_item|
item = eval_scope(klass, scope_chain_item)
if scope_chain_item == self.reflection.scope
scope.merge! item.except(:where, :includes, :bind)
end
if is_first_chain
scope.includes! item.includes_values
end
scope.where_values += item.where_values
scope.order_values |= item.order_values
end
end
scope
end
def alias_suffix
reflection.name
end
def table_name_for(reflection)
if reflection == self.reflection
# If this is a polymorphic belongs_to, we want to get the klass from the
# association because it depends on the polymorphic_type attribute of
# the owner
klass.table_name
else
reflection.table_name
end
end
def eval_scope(klass, scope)
if scope.is_a?(Relation)
scope
else
klass.unscoped.instance_exec(owner, &scope)
end
end
end
end
end
|
