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
|
require 'active_record/associations/join_dependency/join_part'
module ActiveRecord
module Associations
class JoinDependency # :nodoc:
class JoinAssociation < JoinPart # :nodoc:
include JoinHelper
# The reflection of the association represented
attr_reader :reflection
# What type of join will be generated, either Arel::InnerJoin (default) or Arel::OuterJoin
attr_accessor :join_type
# These implement abstract methods from the superclass
attr_reader :aliased_prefix
attr_reader :tables
attr_reader :alias_tracker
delegate :options, :through_reflection, :source_reflection, :chain, :to => :reflection
def initialize(reflection, index, parent, join_type, alias_tracker)
super(reflection.klass, parent)
@reflection = reflection
@alias_tracker = alias_tracker
@join_type = join_type
@aliased_prefix = "t#{ index }"
@tables = construct_tables.reverse
end
def parent_table_name; parent.table_name; end
alias :alias_suffix :parent_table_name
def match?(other)
return true if self == other
super && reflection == other.reflection
end
def join_constraints
joins = []
tables = @tables.dup
foreign_table = parent.table
foreign_klass = parent.base_klass
scope_chain_iter = reflection.scope_chain.reverse_each
# The chain starts with the target table, but we want to end with it here (makes
# more sense in this context), so we reverse
chain.reverse_each do |reflection|
table = tables.shift
klass = reflection.klass
case reflection.source_macro
when :belongs_to
key = reflection.association_primary_key
foreign_key = reflection.foreign_key
else
key = reflection.foreign_key
foreign_key = reflection.active_record_primary_key
end
constraint = build_constraint(klass, table, key, foreign_table, foreign_key)
scope_chain_items = scope_chain_iter.next.map do |item|
if item.is_a?(Relation)
item
else
ActiveRecord::Relation.create(klass, table).instance_exec(self, &item)
end
end
if reflection.type
scope_chain_items <<
ActiveRecord::Relation.create(klass, table)
.where(reflection.type => foreign_klass.base_class.name)
end
scope_chain_items.concat [klass.send(:build_default_scope)].compact
rel = scope_chain_items.inject(scope_chain_items.shift) do |left, right|
left.merge right
end
if rel && !rel.arel.constraints.empty?
constraint = constraint.and rel.arel.constraints
end
joins << join(table, constraint)
# The current table in this iteration becomes the foreign table in the next
foreign_table, foreign_klass = table, klass
end
joins
end
# Builds equality condition.
#
# Example:
#
# class Physician < ActiveRecord::Base
# has_many :appointments
# end
#
# If I execute `Physician.joins(:appointments).to_a` then
# reflection #=> #<ActiveRecord::Reflection::AssociationReflection @macro=:has_many ...>
# table #=> #<Arel::Table @name="appointments" ...>
# key #=> physician_id
# foreign_table #=> #<Arel::Table @name="physicians" ...>
# foreign_key #=> id
#
def build_constraint(klass, table, key, foreign_table, foreign_key)
constraint = table[key].eq(foreign_table[foreign_key])
if klass.finder_needs_type_condition?
constraint = table.create_and([
constraint,
klass.send(:type_condition, table)
])
end
constraint
end
def table
tables.last
end
def aliased_table_name
table.table_alias || table.name
end
end
end
end
end
|