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
|
module ActiveRecord
module Associations
class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
def initialize(owner, association_name, association_class_name, association_class_primary_key_name, options)
super
@association_foreign_key = options[:association_foreign_key] || Inflector.underscore(Inflector.demodulize(association_class_name)) + "_id"
@association_table_name = options[:table_name] || @association_class.table_name
@join_table = options[:join_table]
@order = options[:order]
construct_sql
end
def build(attributes = {})
load_target
record = @association_class.new(attributes)
@target << record
record
end
# Removes all records from this association. Returns +self+ so method calls may be chained.
def clear
return self if size == 0 # forces load_target if hasn't happened already
if sql = @options[:delete_sql]
each { |record| @owner.connection.execute(sql) }
elsif @options[:conditions]
sql =
"DELETE FROM #{@join_table} WHERE #{@association_class_primary_key_name} = #{@owner.quoted_id} " +
"AND #{@association_foreign_key} IN (#{collect { |record| record.id }.join(", ")})"
@owner.connection.execute(sql)
else
sql = "DELETE FROM #{@join_table} WHERE #{@association_class_primary_key_name} = #{@owner.quoted_id}"
@owner.connection.execute(sql)
end
@target = []
self
end
def find_first
load_target.first
end
def find(*args)
# Return an Array if multiple ids are given.
expects_array = args.first.kind_of?(Array)
ids = args.flatten.compact.uniq
# If no block is given, raise RecordNotFound.
if ids.empty?
raise RecordNotFound, "Couldn't find #{@association_class.name} without an ID"
# If using a custom finder_sql, scan the entire collection.
elsif @options[:finder_sql]
if ids.size == 1
id = ids.first
record = load_target.detect { |record| id == record.id }
expects_array? ? [record] : record
else
load_target.select { |record| ids.include?(record.id) }
end
# Otherwise, construct a query.
else
ids_list = ids.map { |id| @owner.send(:quote, id) }.join(',')
records = find_target(@finder_sql.sub(/(ORDER BY|$)/, " AND j.#{@association_foreign_key} IN (#{ids_list}) \\1"))
if records.size == ids.size
if ids.size == 1 and !expects_array
records.first
else
records
end
else
raise RecordNotFound, "Couldn't find #{@association_class.name} with ID in (#{ids_list})"
end
end
end
def push_with_attributes(record, join_attributes = {})
raise_on_type_mismatch(record)
join_attributes.each { |key, value| record[key.to_s] = value }
insert_record(record) unless @owner.new_record?
@target << record
self
end
alias :concat_with_attributes :push_with_attributes
def size
@options[:uniq] ? count_records : super
end
protected
def find_target(sql = @finder_sql)
records = @association_class.find_by_sql(sql)
@options[:uniq] ? uniq(records) : records
end
def count_records
load_target.size
end
def insert_record(record)
return false unless record.save
if @options[:insert_sql]
@owner.connection.execute(interpolate_sql(@options[:insert_sql], record))
else
columns = @owner.connection.columns(@join_table, "#{@join_table} Columns")
attributes = columns.inject({}) do |attributes, column|
case column.name
when @association_class_primary_key_name
attributes[column.name] = @owner.quoted_id
when @association_foreign_key
attributes[column.name] = record.quoted_id
else
value = record[column.name]
attributes[column.name] = value unless value.nil?
end
attributes
end
sql =
"INSERT INTO #{@join_table} (#{@owner.send(:quoted_column_names, attributes).join(', ')}) " +
"VALUES (#{attributes.values.collect { |value| @owner.send(:quote, value) }.join(', ')})"
@owner.connection.execute(sql)
end
return true
end
def delete_records(records)
if sql = @options[:delete_sql]
records.each { |record| @owner.connection.execute(interpolate_sql(sql, record)) }
else
ids = quoted_record_ids(records)
sql = "DELETE FROM #{@join_table} WHERE #{@association_class_primary_key_name} = #{@owner.quoted_id} AND #{@association_foreign_key} IN (#{ids})"
@owner.connection.execute(sql)
end
end
def construct_sql
interpolate_sql_options!(@options, :finder_sql)
if @options[:finder_sql]
@finder_sql = @options[:finder_sql]
else
@finder_sql =
"SELECT t.*, j.* FROM #{@join_table} j, #{@association_table_name} t " +
"WHERE t.#{@association_class.primary_key} = j.#{@association_foreign_key} AND " +
"j.#{@association_class_primary_key_name} = #{@owner.quoted_id} "
@finder_sql << " AND #{interpolate_sql(@options[:conditions])}" if @options[:conditions]
@finder_sql << " ORDER BY #{@order}" if @order
end
end
end
end
end
|
