-
-
Notifications
You must be signed in to change notification settings - Fork 781
/
context.rb
345 lines (308 loc) · 13.3 KB
/
context.rb
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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
require 'ransack/context'
require 'polyamorous/polyamorous'
module Ransack
module Adapters
module ActiveRecord
class Context < ::Ransack::Context
def relation_for(object)
object.all
end
def type_for(attr)
return nil unless attr && attr.valid?
name = attr.arel_attribute.name.to_s
table = attr.arel_attribute.relation.table_name
schema_cache = self.klass.connection.schema_cache
unless schema_cache.send(:data_source_exists?, table)
raise "No table named #{table} exists."
end
attr.klass.columns.find { |column| column.name == name }.type
end
def evaluate(search, opts = {})
viz = Visitor.new
relation = @object.where(viz.accept(search.base))
if search.sorts.any?
relation = relation.except(:order)
# Rather than applying all of the search's sorts in one fell swoop,
# as the original implementation does, we apply one at a time.
#
# If the sort (returned by the Visitor above) is a symbol, we know
# that it represents a scope on the model and we can apply that
# scope.
#
# Otherwise, we fall back to the applying the sort with the "order"
# method as the original implementation did. Actually the original
# implementation used "reorder," which was overkill since we already
# have a clean slate after "relation.except(:order)" above.
viz.accept(search.sorts).each do |scope_or_sort|
if scope_or_sort.is_a?(Symbol)
relation = relation.send(scope_or_sort)
else
case Ransack.options[:postgres_fields_sort_option]
when :nulls_first
scope_or_sort = scope_or_sort.direction == :asc ? Arel.sql("#{scope_or_sort.to_sql} NULLS FIRST") : Arel.sql("#{scope_or_sort.to_sql} NULLS LAST")
when :nulls_last
scope_or_sort = scope_or_sort.direction == :asc ? Arel.sql("#{scope_or_sort.to_sql} NULLS LAST") : Arel.sql("#{scope_or_sort.to_sql} NULLS FIRST")
when :nulls_always_first
scope_or_sort = Arel.sql("#{scope_or_sort.to_sql} NULLS FIRST")
when :nulls_always_last
scope_or_sort = Arel.sql("#{scope_or_sort.to_sql} NULLS LAST")
end
relation = relation.order(scope_or_sort)
end
end
end
opts[:distinct] ? relation.distinct : relation
end
def attribute_method?(str, klass = @klass)
exists = false
if ransackable_attribute?(str, klass)
exists = true
elsif (segments = str.split(Constants::UNDERSCORE)).size > 1
remainder = []
found_assoc = nil
while !found_assoc && remainder.unshift(segments.pop) &&
segments.size > 0 do
assoc, poly_class = unpolymorphize_association(
segments.join(Constants::UNDERSCORE)
)
if found_assoc = get_association(assoc, klass)
exists = attribute_method?(
remainder.join(Constants::UNDERSCORE),
poly_class || found_assoc.klass
)
end
end
end
exists
end
def table_for(parent)
parent.table
end
def klassify(obj)
if Class === obj && ::ActiveRecord::Base > obj
obj
elsif obj.respond_to? :klass
obj.klass
elsif obj.respond_to? :base_klass
obj.base_klass
else
raise ArgumentError, "Don't know how to klassify #{obj}"
end
end
# All dependent Arel::Join nodes used in the search query.
#
# This could otherwise be done as `@object.arel.join_sources`, except
# that ActiveRecord's build_joins sets up its own JoinDependency.
# This extracts what we need to access the joins using our existing
# JoinDependency to track table aliases.
#
def join_sources
base, joins = begin
alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(self.klass.connection, @object.table.name, [])
constraints = @join_dependency.join_constraints(@object.joins_values, alias_tracker, @object.references_values)
[
Arel::SelectManager.new(@object.table),
constraints
]
end
joins.each do |aliased_join|
base.from(aliased_join)
end
base.join_sources
end
def alias_tracker
@join_dependency.send(:alias_tracker)
end
def lock_association(association)
@lock_associations << association
end
def remove_association(association)
return if @lock_associations.include?(association)
@join_dependency.instance_variable_get(:@join_root).children.delete_if { |stashed|
stashed.eql?(association)
}
@object.joins_values.delete_if { |jd|
jd.instance_variables.include?(:@join_root) &&
jd.instance_variable_get(:@join_root).children.map(&:object_id) == [association.object_id]
}
end
# Build an Arel subquery that selects keys for the top query,
# drawn from the first join association's foreign_key.
#
# Example: for an Article that has_and_belongs_to_many Tags
#
# context = Article.search.context
# attribute = Attribute.new(context, "tags_name").tap do |a|
# context.bind(a, a.name)
# end
# context.build_correlated_subquery(attribute.parent).to_sql
#
# # SELECT "articles_tags"."article_id" FROM "articles_tags"
# # INNER JOIN "tags" ON "tags"."id" = "articles_tags"."tag_id"
# # WHERE "articles_tags"."article_id" = "articles"."id"
#
# The WHERE condition on this query makes it invalid by itself,
# because it is correlated to the primary key on the outer query.
#
def build_correlated_subquery(association)
join_constraints = extract_joins(association)
join_root = join_constraints.shift
correlated_key = extract_correlated_key(join_root)
subquery = Arel::SelectManager.new(association.base_klass)
subquery.from(join_root.left)
subquery.project(correlated_key)
join_constraints.each do |j|
subquery.join_sources << Arel::Nodes::InnerJoin.new(j.left, j.right)
end
subquery.where(correlated_key.eq(primary_key))
end
def primary_key
@object.table[@object.primary_key]
end
private
def extract_correlated_key(join_root)
case join_root
when Arel::Nodes::OuterJoin
# one of join_root.right/join_root.left is expected to be Arel::Nodes::On
if join_root.right.is_a?(Arel::Nodes::On)
extract_correlated_key(join_root.right.expr)
elsif join_root.left.is_a?(Arel::Nodes::On)
extract_correlated_key(join_root.left.expr)
else
raise 'Ransack encountered an unexpected arel structure'
end
when Arel::Nodes::Equality
pk = primary_key
if join_root.left == pk
join_root.right
elsif join_root.right == pk
join_root.left
else
nil
end
when Arel::Nodes::And
extract_correlated_key(join_root.left) || extract_correlated_key(join_root.right)
else
# eg parent was Arel::Nodes::And and the evaluated side was one of
# Arel::Nodes::Grouping or MultiTenant::TenantEnforcementClause
nil
end
end
def get_parent_and_attribute_name(str, parent = @base)
attr_name = nil
if ransackable_attribute?(str, klassify(parent))
attr_name = str
elsif (segments = str.split(Constants::UNDERSCORE)).size > 1
remainder = []
found_assoc = nil
while remainder.unshift(segments.pop) && segments.size > 0 &&
!found_assoc do
assoc, klass = unpolymorphize_association(
segments.join(Constants::UNDERSCORE)
)
if found_assoc = get_association(assoc, parent)
join = build_or_find_association(
found_assoc.name, parent, klass
)
parent, attr_name = get_parent_and_attribute_name(
remainder.join(Constants::UNDERSCORE), join
)
end
end
end
[parent, attr_name]
end
def get_association(str, parent = @base)
klass = klassify parent
ransackable_association?(str, klass) &&
klass.reflect_on_all_associations.detect { |a| a.name.to_s == str }
end
def join_dependency(relation)
if relation.respond_to?(:join_dependency) # Polyamorous enables this
relation.join_dependency
else
build_joins(relation)
end
end
# Checkout active_record/relation/query_methods.rb +build_joins+ for
# reference. Lots of duplicated code maybe we can avoid it
def build_joins(relation)
buckets = relation.joins_values + relation.left_outer_joins_values
buckets = buckets.group_by do |join|
case join
when String
:string_join
when Hash, Symbol, Array
:association_join
when Polyamorous::JoinDependency, Polyamorous::JoinAssociation
:stashed_join
when Arel::Nodes::Join
:join_node
else
raise 'unknown class: %s' % join.class.name
end
end
buckets.default = []
association_joins = buckets[:association_join]
stashed_association_joins = buckets[:stashed_join]
join_nodes = buckets[:join_node].uniq
string_joins = buckets[:string_join].map(&:strip)
string_joins.uniq!
join_list = join_nodes + convert_join_strings_to_ast(relation.table, string_joins)
alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(self.klass.connection, relation.table.name, join_list)
join_dependency = Polyamorous::JoinDependency.new(relation.klass, relation.table, association_joins, Arel::Nodes::OuterJoin)
join_dependency.instance_variable_set(:@alias_tracker, alias_tracker)
join_nodes.each do |join|
join_dependency.send(:alias_tracker).aliases[join.left.name.downcase] = 1
end
join_dependency
end
def convert_join_strings_to_ast(table, joins)
joins.map! { |join| table.create_string_join(Arel.sql(join)) unless join.blank? }
joins.compact!
joins
end
def build_or_find_association(name, parent = @base, klass = nil)
find_association(name, parent, klass) or build_association(name, parent, klass)
end
def find_association(name, parent = @base, klass = nil)
@join_dependency.instance_variable_get(:@join_root).children.detect do |assoc|
assoc.reflection.name == name && assoc.table &&
(@associations_pot.empty? || @associations_pot[assoc] == parent || !@associations_pot.key?(assoc)) &&
(!klass || assoc.reflection.klass == klass)
end
end
def build_association(name, parent = @base, klass = nil)
jd = Polyamorous::JoinDependency.new(
parent.base_klass,
parent.table,
Polyamorous::Join.new(name, @join_type, klass),
@join_type
)
found_association = jd.instance_variable_get(:@join_root).children.last
@associations_pot[found_association] = parent
# TODO maybe we dont need to push associations here, we could loop
# through the @associations_pot instead
@join_dependency.instance_variable_get(:@join_root).children.push found_association
# Builds the arel nodes properly for this association
@tables_pot[found_association] = @join_dependency.construct_tables_for_association!(jd.instance_variable_get(:@join_root), found_association)
# Leverage the stashed association functionality in AR
@object = @object.joins(jd)
found_association
end
def extract_joins(association)
parent = @join_dependency.instance_variable_get(:@join_root)
reflection = association.reflection
join_constraints = association.join_constraints_with_tables(
parent.table,
parent.base_klass,
Arel::Nodes::OuterJoin,
@join_dependency.instance_variable_get(:@alias_tracker),
@tables_pot[association]
)
join_constraints.to_a.flatten
end
end
end
end
end