resync from rails_port 11795:12304
[rails.git] / vendor / gems / composite_primary_keys-1.1.0 / lib / composite_primary_keys / associations.rb
1 module CompositePrimaryKeys
2   module ActiveRecord
3     module Associations
4       def self.append_features(base)
5         super
6         base.send(:extend, ClassMethods)
7       end
8
9       # Composite key versions of Association functions
10       module ClassMethods
11
12         def construct_counter_sql_with_included_associations(options, join_dependency)
13           scope = scope(:find)
14           sql = "SELECT COUNT(DISTINCT #{quoted_table_columns(primary_key)})"
15
16           # A (slower) workaround if we're using a backend, like sqlite, that doesn't support COUNT DISTINCT.
17           if !self.connection.supports_count_distinct?
18             sql = "SELECT COUNT(*) FROM (SELECT DISTINCT #{quoted_table_columns(primary_key)}"
19           end
20           
21           sql << " FROM #{quoted_table_name} "
22           sql << join_dependency.join_associations.collect{|join| join.association_join }.join
23
24           add_joins!(sql, options, scope)
25           add_conditions!(sql, options[:conditions], scope)
26           add_limited_ids_condition!(sql, options, join_dependency) if !using_limitable_reflections?(join_dependency.reflections) && ((scope && scope[:limit]) || options[:limit])
27
28           add_limit!(sql, options, scope) if using_limitable_reflections?(join_dependency.reflections)
29
30           if !self.connection.supports_count_distinct?
31             sql << ")"
32           end
33
34           return sanitize_sql(sql)
35         end
36
37         def construct_finder_sql_with_included_associations(options, join_dependency)
38           scope = scope(:find)
39           sql = "SELECT #{column_aliases(join_dependency)} FROM #{(scope && scope[:from]) || options[:from] || quoted_table_name} "
40           sql << join_dependency.join_associations.collect{|join| join.association_join }.join
41
42           add_joins!(sql, options, scope)
43           add_conditions!(sql, options[:conditions], scope)
44           add_limited_ids_condition!(sql, options, join_dependency) if !using_limitable_reflections?(join_dependency.reflections) && options[:limit]
45
46           sql << "ORDER BY #{options[:order]} " if options[:order]
47
48           add_limit!(sql, options, scope) if using_limitable_reflections?(join_dependency.reflections)
49
50           return sanitize_sql(sql)
51         end
52
53         def table_columns(columns)
54           columns.collect {|column| "#{self.quoted_table_name}.#{connection.quote_column_name(column)}"}
55         end
56
57         def quoted_table_columns(columns)
58           table_columns(columns).join(ID_SEP)
59         end
60
61       end
62
63     end
64   end
65 end
66
67 module ActiveRecord::Associations::ClassMethods
68   class JoinDependency
69     def construct_association(record, join, row)
70       case join.reflection.macro
71         when :has_many, :has_and_belongs_to_many
72           collection = record.send(join.reflection.name)
73           collection.loaded
74
75           join_aliased_primary_keys = join.active_record.composite? ?
76             join.aliased_primary_key : [join.aliased_primary_key]
77           return nil if
78             record.id.to_s != join.parent.record_id(row).to_s or not
79             join_aliased_primary_keys.select {|key| row[key].nil?}.blank?
80           association = join.instantiate(row)
81           collection.target.push(association) unless collection.target.include?(association)
82         when :has_one, :belongs_to
83           return if record.id.to_s != join.parent.record_id(row).to_s or
84                     [*join.aliased_primary_key].any? { |key| row[key].nil? }
85           association = join.instantiate(row)
86           record.send("set_#{join.reflection.name}_target", association)
87         else
88           raise ConfigurationError, "unknown macro: #{join.reflection.macro}"
89       end
90       return association
91     end
92
93     class JoinBase
94       def aliased_primary_key
95         active_record.composite? ?
96           primary_key.inject([]) {|aliased_keys, key| aliased_keys << "#{ aliased_prefix }_r#{aliased_keys.length}"} :
97           "#{ aliased_prefix }_r0"
98       end
99
100       def record_id(row)
101         active_record.composite? ?
102           aliased_primary_key.map {|key| row[key]}.to_composite_ids :
103           row[aliased_primary_key]
104       end
105
106       def column_names_with_alias
107         unless @column_names_with_alias
108           @column_names_with_alias = []
109           keys = active_record.composite? ? primary_key.map(&:to_s) : [primary_key]
110           (keys + (column_names - keys)).each_with_index do |column_name, i|
111             @column_names_with_alias << [column_name, "#{ aliased_prefix }_r#{ i }"]
112           end
113         end
114         return @column_names_with_alias
115       end
116     end
117
118     class JoinAssociation < JoinBase
119       alias single_association_join association_join
120       def association_join
121         reflection.active_record.composite? ? composite_association_join : single_association_join
122       end
123
124       def composite_association_join
125         join = case reflection.macro
126           when :has_and_belongs_to_many
127             " LEFT OUTER JOIN %s ON %s " % [
128               table_alias_for(options[:join_table], aliased_join_table_name),
129                 composite_join_clause(
130                   full_keys(aliased_join_table_name, options[:foreign_key] || reflection.active_record.to_s.classify.foreign_key),
131                   full_keys(reflection.active_record.table_name, reflection.active_record.primary_key)
132                 )
133               ] +
134              " LEFT OUTER JOIN %s ON %s " % [
135                 table_name_and_alias,
136                 composite_join_clause(
137                   full_keys(aliased_table_name, klass.primary_key),
138                   full_keys(aliased_join_table_name, options[:association_foreign_key] || klass.table_name.classify.foreign_key)
139                 )
140               ]
141           when :has_many, :has_one
142             case
143               when reflection.macro == :has_many && reflection.options[:through]
144                 through_conditions = through_reflection.options[:conditions] ? "AND #{interpolate_sql(sanitize_sql(through_reflection.options[:conditions]))}" : ''
145                 if through_reflection.options[:as] # has_many :through against a polymorphic join
146                   raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
147                 else
148                   if source_reflection.macro == :has_many && source_reflection.options[:as]
149                     raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
150                   else
151                     case source_reflection.macro
152                       when :belongs_to
153                         first_key  = primary_key
154                         second_key = options[:foreign_key] || klass.to_s.classify.foreign_key
155                       when :has_many
156                         first_key  = through_reflection.klass.to_s.classify.foreign_key
157                         second_key = options[:foreign_key] || primary_key
158                     end
159
160                     " LEFT OUTER JOIN %s ON %s "  % [
161                       table_alias_for(through_reflection.klass.table_name, aliased_join_table_name),
162                        composite_join_clause(
163                          full_keys(aliased_join_table_name, through_reflection.primary_key_name),
164                          full_keys(parent.aliased_table_name, parent.primary_key)
165                        )
166                      ] +
167                      " LEFT OUTER JOIN %s ON %s " % [
168                        table_name_and_alias,
169                        composite_join_clause(
170                          full_keys(aliased_table_name, first_key),
171                          full_keys(aliased_join_table_name, second_key)
172                        )
173                     ]
174                   end
175                 end
176
177               when reflection.macro == :has_many && reflection.options[:as]
178                 raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
179               when reflection.macro == :has_one && reflection.options[:as]
180                 raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
181               else
182                 foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key
183                 " LEFT OUTER JOIN %s ON %s " % [
184                   table_name_and_alias,
185                   composite_join_clause(
186                     full_keys(aliased_table_name, foreign_key),
187                     full_keys(parent.aliased_table_name, parent.primary_key)),
188                 ]
189             end
190           when :belongs_to
191             " LEFT OUTER JOIN %s ON %s " % [
192                table_name_and_alias,
193                composite_join_clause(
194                  full_keys(aliased_table_name, reflection.klass.primary_key),
195                  full_keys(parent.aliased_table_name, options[:foreign_key] || klass.to_s.foreign_key)),
196               ]
197           else
198             ""
199         end || ''
200         join << %(AND %s.%s = %s ) % [
201           aliased_table_name,
202           reflection.active_record.connection.quote_column_name(reflection.active_record.inheritance_column),
203           klass.connection.quote(klass.name)] unless klass.descends_from_active_record?
204         join << "AND #{interpolate_sql(sanitize_sql(reflection.options[:conditions]))} " if reflection.options[:conditions]
205         join
206       end
207
208       def full_keys(table_name, keys)
209         connection = reflection.active_record.connection
210         quoted_table_name = connection.quote_table_name(table_name)
211         if keys.is_a?(Array) 
212           keys.collect {|key| "#{quoted_table_name}.#{connection.quote_column_name(key)}"}.join(CompositePrimaryKeys::ID_SEP) 
213         else
214           "#{quoted_table_name}.#{connection.quote_column_name(keys)}"
215         end
216       end
217
218       def composite_join_clause(full_keys1, full_keys2)
219         full_keys1 = full_keys1.split(CompositePrimaryKeys::ID_SEP) if full_keys1.is_a?(String)
220         full_keys2 = full_keys2.split(CompositePrimaryKeys::ID_SEP) if full_keys2.is_a?(String)
221         where_clause = [full_keys1, full_keys2].transpose.map do |key1, key2|
222           "#{key1}=#{key2}"
223         end.join(" AND ")
224         "(#{where_clause})"
225       end
226     end
227   end
228 end
229
230 module ActiveRecord::Associations
231   class AssociationProxy #:nodoc:
232
233     def composite_where_clause(full_keys, ids)
234       full_keys = full_keys.split(CompositePrimaryKeys::ID_SEP) if full_keys.is_a?(String)
235
236       if ids.is_a?(String)
237         ids = [[ids]]
238       elsif not ids.first.is_a?(Array) # if single comp key passed, turn into an array of 1
239         ids = [ids.to_composite_ids]
240       end
241
242       where_clause = ids.map do |id_set|
243         transposed = id_set.size == 1 ? [[full_keys, id_set.first]] : [full_keys, id_set].transpose
244         transposed.map do |full_key, id|
245           "#{full_key.to_s}=#{@reflection.klass.sanitize(id)}"
246         end.join(" AND ")
247       end.join(") OR (")
248
249       "(#{where_clause})"
250     end
251
252     def composite_join_clause(full_keys1, full_keys2)
253       full_keys1 = full_keys1.split(CompositePrimaryKeys::ID_SEP) if full_keys1.is_a?(String)
254       full_keys2 = full_keys2.split(CompositePrimaryKeys::ID_SEP) if full_keys2.is_a?(String)
255
256       where_clause = [full_keys1, full_keys2].transpose.map do |key1, key2|
257         "#{key1}=#{key2}"
258       end.join(" AND ")
259
260       "(#{where_clause})"
261     end
262
263     def full_composite_join_clause(table1, full_keys1, table2, full_keys2)
264       connection = @reflection.active_record.connection
265       full_keys1 = full_keys1.split(CompositePrimaryKeys::ID_SEP) if full_keys1.is_a?(String)
266       full_keys2 = full_keys2.split(CompositePrimaryKeys::ID_SEP) if full_keys2.is_a?(String)
267
268       quoted1 = connection.quote_table_name(table1)
269       quoted2 = connection.quote_table_name(table2)
270       
271       where_clause = [full_keys1, full_keys2].transpose.map do |key_pair|
272         "#{quoted1}.#{connection.quote_column_name(key_pair.first)}=#{quoted2}.#{connection.quote_column_name(key_pair.last)}"
273       end.join(" AND ")
274
275       "(#{where_clause})"
276     end
277
278     def full_keys(table_name, keys)
279       connection = @reflection.active_record.connection
280       quoted_table_name = connection.quote_table_name(table_name)
281       keys = keys.split(CompositePrimaryKeys::ID_SEP) if keys.is_a?(String)
282       if keys.is_a?(Array) 
283         keys.collect {|key| "#{quoted_table_name}.#{connection.quote_column_name(key)}"}.join(CompositePrimaryKeys::ID_SEP) 
284       else
285         "#{quoted_table_name}.#{connection.quote_column_name(keys)}"
286       end
287     end
288
289     def full_columns_equals(table_name, keys, quoted_ids)
290       connection = @reflection.active_record.connection
291       quoted_table_name = connection.quote_table_name(table_name)
292       if keys.is_a?(Symbol) or (keys.is_a?(String) and keys == keys.to_s.split(CompositePrimaryKeys::ID_SEP))
293         return "#{quoted_table_name}.#{connection.quote_column_name(keys)} = #{quoted_ids}"
294       end
295       keys = keys.split(CompositePrimaryKeys::ID_SEP) if keys.is_a?(String)
296       quoted_ids = quoted_ids.split(CompositePrimaryKeys::ID_SEP) if quoted_ids.is_a?(String)
297       keys_ids = [keys, quoted_ids].transpose
298       keys_ids.collect {|key, id| "(#{quoted_table_name}.#{connection.quote_column_name(key)} = #{id})"}.join(' AND ')
299     end 
300
301     def set_belongs_to_association_for(record)
302       if @reflection.options[:as]
303         record["#{@reflection.options[:as]}_id"]   = @owner.id unless @owner.new_record?
304         record["#{@reflection.options[:as]}_type"] = @owner.class.base_class.name.to_s
305       else
306         key_values = @reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP).zip([@owner.id].flatten)
307         key_values.each{|key, value| record[key] = value} unless @owner.new_record?
308       end
309     end
310   end
311
312   class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
313     def construct_sql
314       @reflection.options[:finder_sql] &&= interpolate_sql(@reflection.options[:finder_sql])
315
316       if @reflection.options[:finder_sql]
317         @finder_sql = @reflection.options[:finder_sql]
318       else
319         @finder_sql = full_columns_equals(@reflection.options[:join_table], @reflection.primary_key_name, @owner.quoted_id)
320         @finder_sql << " AND (#{conditions})" if conditions
321       end
322
323       @join_sql = "INNER JOIN #{@reflection.active_record.connection.quote_table_name(@reflection.options[:join_table])} ON " +
324       full_composite_join_clause(@reflection.klass.table_name, @reflection.klass.primary_key, @reflection.options[:join_table], @reflection.association_foreign_key)
325     end
326   end
327
328   class HasManyAssociation < AssociationCollection #:nodoc:
329     def construct_sql
330       case
331         when @reflection.options[:finder_sql]
332           @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
333
334         when @reflection.options[:as]
335           @finder_sql = 
336             "#{@reflection.klass.quoted_table_name}.#{@reflection.options[:as]}_id = #{@owner.quoted_id} AND " + 
337             "#{@reflection.klass.quoted_table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
338           @finder_sql << " AND (#{conditions})" if conditions
339
340         else
341           @finder_sql = full_columns_equals(@reflection.klass.table_name, @reflection.primary_key_name, @owner.quoted_id)
342           @finder_sql << " AND (#{conditions})" if conditions
343       end
344
345       if @reflection.options[:counter_sql]
346         @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
347       elsif @reflection.options[:finder_sql]
348         # replace the SELECT clause with COUNT(*), preserving any hints within /* ... */
349         @reflection.options[:counter_sql] = @reflection.options[:finder_sql].sub(/SELECT (\/\*.*?\*\/ )?(.*)\bFROM\b/im) { "SELECT #{$1}COUNT(*) FROM" }
350         @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
351       else
352         @counter_sql = @finder_sql
353       end
354     end
355
356     def delete_records(records)
357       if @reflection.options[:dependent]
358         records.each { |r| r.destroy }
359       else
360         connection = @reflection.active_record.connection
361         field_names = @reflection.primary_key_name.split(',')
362         field_names.collect! {|n| connection.quote_column_name(n) + " = NULL"}
363         records.each do |r|
364           where_clause = nil
365           
366           if r.quoted_id.to_s.include?(CompositePrimaryKeys::ID_SEP)
367             where_clause_terms = [@reflection.klass.primary_key, r.quoted_id].transpose.map do |pair|
368               "(#{connection.quote_column_name(pair[0])} = #{pair[1]})"
369             end
370             where_clause = where_clause_terms.join(" AND ")
371           else
372             where_clause = connection.quote_column_name(@reflection.klass.primary_key) + ' = ' +  r.quoted_id
373           end
374           
375           @reflection.klass.update_all(  field_names.join(',') , where_clause)
376         end
377       end
378     end
379   end
380
381   class HasOneAssociation < BelongsToAssociation #:nodoc:
382     def construct_sql
383       case
384         when @reflection.options[:as]
385           @finder_sql = 
386             "#{@reflection.klass.quoted_table_name}.#{@reflection.options[:as]}_id = #{@owner.quoted_id} AND " + 
387             "#{@reflection.klass.quoted_table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
388         else
389           @finder_sql = full_columns_equals(@reflection.klass.table_name, @reflection.primary_key_name, @owner.quoted_id)
390       end
391
392       @finder_sql << " AND (#{conditions})" if conditions
393     end
394   end
395
396   class HasManyThroughAssociation < HasManyAssociation #:nodoc:
397     def construct_conditions_with_composite_keys
398       if @reflection.through_reflection.options[:as]
399         construct_conditions_without_composite_keys
400       else
401         conditions = full_columns_equals(@reflection.through_reflection.table_name, @reflection.through_reflection.primary_key_name, @owner.quoted_id)
402         conditions << " AND (#{sql_conditions})" if sql_conditions
403         conditions
404       end
405     end
406     alias_method_chain :construct_conditions, :composite_keys
407
408     def construct_joins_with_composite_keys(custom_joins = nil)
409       if @reflection.through_reflection.options[:as] || @reflection.source_reflection.options[:as]
410         construct_joins_without_composite_keys(custom_joins)
411       else
412         if @reflection.source_reflection.macro == :belongs_to
413           reflection_primary_key = @reflection.klass.primary_key
414           source_primary_key     = @reflection.source_reflection.primary_key_name
415         else
416           reflection_primary_key = @reflection.source_reflection.primary_key_name
417           source_primary_key     = @reflection.klass.primary_key
418         end
419
420         "INNER JOIN %s ON %s #{@reflection.options[:joins]} #{custom_joins}" % [
421           @reflection.through_reflection.quoted_table_name,
422           composite_join_clause(full_keys(@reflection.table_name, reflection_primary_key), full_keys(@reflection.through_reflection.table_name, source_primary_key))
423         ]
424       end
425     end
426     alias_method_chain :construct_joins, :composite_keys
427   end
428 end