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
|
module ActiveRecord
module Associations
class Preloader
module ThroughAssociation #:nodoc:
def through_reflection
reflection.through_reflection
end
def source_reflection
reflection.source_reflection
end
def associated_records_by_owner(preloader)
preloader.preload(owners,
through_reflection.name,
through_scope)
through_records = owners.map do |owner|
association = owner.association through_reflection.name
[owner, Array(association.reader)]
end
reset_association owners, through_reflection.name
middle_records = through_records.flat_map { |(_,rec)| rec }
preloaders = preloader.preload(middle_records,
source_reflection.name,
reflection_scope)
@preloaded_records = preloaders.flat_map(&:preloaded_records)
middle_to_pl = preloaders.each_with_object({}) do |pl,h|
pl.owners.each { |middle|
h[middle] = pl
}
end
record_offset = {}
@preloaded_records.each_with_index do |record,i|
record_offset[record] = i
end
through_records.each_with_object({}) { |(lhs,center),records_by_owner|
pl_to_middle = center.group_by { |record| middle_to_pl[record] }
records_by_owner[lhs] = pl_to_middle.flat_map do |pl, middles|
rhs_records = middles.flat_map { |r|
association = r.association source_reflection.name
association.reader
}.compact
rhs_records.sort_by { |rhs| record_offset[rhs] }
end
}
end
private
def reset_association(owners, association_name)
should_reset = (through_scope != through_reflection.klass.unscoped) ||
(reflection.options[:source_type] && through_reflection.collection?)
# Dont cache the association - we would only be caching a subset
if should_reset
owners.each { |owner|
owner.association(association_name).reset
}
end
end
def through_scope
scope = through_reflection.klass.unscoped
if options[:source_type]
scope.where! reflection.foreign_type => options[:source_type]
else
unless reflection_scope.where_values.empty?
scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
scope.where_values = reflection_scope.values[:where]
end
scope.references! reflection_scope.values[:references]
scope = scope.order reflection_scope.values[:order] if scope.eager_loading?
end
scope
end
end
end
end
end
|
