--- /dev/null
+module CompositePrimaryKeys
+ module ActiveRecord
+ module AssociationPreload
+ def self.append_features(base)
+ super
+ base.send(:extend, ClassMethods)
+ end
+
+ # Composite key versions of Association functions
+ module ClassMethods
+ def preload_has_and_belongs_to_many_association(records, reflection, preload_options={})
+ table_name = reflection.klass.quoted_table_name
+ id_to_record_map, ids = construct_id_map_for_composite(records)
+ records.each {|record| record.send(reflection.name).loaded}
+ options = reflection.options
+
+ if composite?
+ primary_key = reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP)
+ where = (primary_key * ids.size).in_groups_of(primary_key.size).map do |keys|
+ "(" + keys.map{|key| "t0.#{connection.quote_column_name(key)} = ?"}.join(" AND ") + ")"
+ end.join(" OR ")
+
+ conditions = [where, ids].flatten
+ joins = "INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{full_composite_join_clause(reflection, reflection.klass.table_name, reflection.klass.primary_key, 't0', reflection.association_foreign_key)}"
+ parent_primary_keys = reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP).map{|k| "t0.#{connection.quote_column_name(k)}"}
+ parent_record_id = connection.concat(*parent_primary_keys.zip(["','"] * (parent_primary_keys.size - 1)).flatten.compact)
+ else
+ conditions = ["t0.#{connection.quote_column_name(reflection.primary_key_name)} IN (?)", ids]
+ joins = "INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{reflection.klass.quoted_table_name}.#{connection.quote_column_name(reflection.klass.primary_key)} = t0.#{connection.quote_column_name(reflection.association_foreign_key)})"
+ parent_record_id = reflection.primary_key_name
+ end
+
+ conditions.first << append_conditions(reflection, preload_options)
+
+ associated_records = reflection.klass.find(:all,
+ :conditions => conditions,
+ :include => options[:include],
+ :joins => joins,
+ :select => "#{options[:select] || table_name+'.*'}, #{parent_record_id} as parent_record_id_",
+ :order => options[:order])
+
+ set_association_collection_records(id_to_record_map, reflection.name, associated_records, 'parent_record_id_')
+ end
+
+ def preload_has_many_association(records, reflection, preload_options={})
+ id_to_record_map, ids = construct_id_map_for_composite(records)
+ records.each {|record| record.send(reflection.name).loaded}
+ options = reflection.options
+
+ if options[:through]
+ through_records = preload_through_records(records, reflection, options[:through])
+ through_reflection = reflections[options[:through]]
+ through_primary_key = through_reflection.primary_key_name
+
+ unless through_records.empty?
+ source = reflection.source_reflection.name
+ #add conditions from reflection!
+ through_records.first.class.preload_associations(through_records, source, reflection.options)
+ through_records.each do |through_record|
+ key = through_primary_key.to_s.split(CompositePrimaryKeys::ID_SEP).map{|k| through_record.send(k)}.join(CompositePrimaryKeys::ID_SEP)
+ add_preloaded_records_to_collection(id_to_record_map[key], reflection.name, through_record.send(source))
+ end
+ end
+ else
+ associated_records = find_associated_records(ids, reflection, preload_options)
+ set_association_collection_records(id_to_record_map, reflection.name, associated_records, reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP))
+ end
+ end
+
+ def preload_through_records(records, reflection, through_association)
+ through_reflection = reflections[through_association]
+ through_primary_key = through_reflection.primary_key_name
+
+ if reflection.options[:source_type]
+ interface = reflection.source_reflection.options[:foreign_type]
+ preload_options = {:conditions => ["#{connection.quote_column_name interface} = ?", reflection.options[:source_type]]}
+
+ records.compact!
+ records.first.class.preload_associations(records, through_association, preload_options)
+
+ # Dont cache the association - we would only be caching a subset
+ through_records = []
+ records.each do |record|
+ proxy = record.send(through_association)
+
+ if proxy.respond_to?(:target)
+ through_records << proxy.target
+ proxy.reset
+ else # this is a has_one :through reflection
+ through_records << proxy if proxy
+ end
+ end
+ through_records.flatten!
+ else
+ records.first.class.preload_associations(records, through_association)
+ through_records = records.map {|record| record.send(through_association)}.flatten
+ end
+
+ through_records.compact!
+ through_records
+ end
+
+ def preload_belongs_to_association(records, reflection, preload_options={})
+ options = reflection.options
+ primary_key_name = reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP)
+
+ if options[:polymorphic]
+ raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
+ else
+ # I need to keep the original ids for each record (as opposed to the stringified) so
+ # that they get properly converted for each db so the id_map ends up looking like:
+ #
+ # { '1,2' => {:id => [1,2], :records => [...records...]}}
+ id_map = {}
+
+ records.each do |record|
+ key = primary_key_name.map{|k| record.send(k)}
+ key_as_string = key.join(CompositePrimaryKeys::ID_SEP)
+
+ if key_as_string
+ mapped_records = (id_map[key_as_string] ||= {:id => key, :records => []})
+ mapped_records[:records] << record
+ end
+ end
+
+
+ klasses_and_ids = [[reflection.klass.name, id_map]]
+ end
+
+ klasses_and_ids.each do |klass_and_id|
+ klass_name, id_map = *klass_and_id
+ klass = klass_name.constantize
+ table_name = klass.quoted_table_name
+ connection = reflection.active_record.connection
+
+ if composite?
+ primary_key = klass.primary_key.to_s.split(CompositePrimaryKeys::ID_SEP)
+ ids = id_map.keys.uniq.map {|id| id_map[id][:id]}
+
+ where = (primary_key * ids.size).in_groups_of(primary_key.size).map do |keys|
+ "(" + keys.map{|key| "#{table_name}.#{connection.quote_column_name(key)} = ?"}.join(" AND ") + ")"
+ end.join(" OR ")
+
+ conditions = [where, ids].flatten
+ else
+ conditions = ["#{table_name}.#{connection.quote_column_name(primary_key)} IN (?)", id_map.keys.uniq]
+ end
+
+ conditions.first << append_conditions(reflection, preload_options)
+
+ associated_records = klass.find(:all,
+ :conditions => conditions,
+ :include => options[:include],
+ :select => options[:select],
+ :joins => options[:joins],
+ :order => options[:order])
+
+ set_association_single_records(id_map, reflection.name, associated_records, primary_key)
+ end
+ end
+
+ def set_association_collection_records(id_to_record_map, reflection_name, associated_records, key)
+ associated_records.each do |associated_record|
+ associated_record_key = associated_record[key]
+ associated_record_key = associated_record_key.is_a?(Array) ? associated_record_key.join(CompositePrimaryKeys::ID_SEP) : associated_record_key.to_s
+ mapped_records = id_to_record_map[associated_record_key]
+ add_preloaded_records_to_collection(mapped_records, reflection_name, associated_record)
+ end
+ end
+
+ def set_association_single_records(id_to_record_map, reflection_name, associated_records, key)
+ seen_keys = {}
+ associated_records.each do |associated_record|
+ associated_record_key = associated_record[key]
+ associated_record_key = associated_record_key.is_a?(Array) ? associated_record_key.join(CompositePrimaryKeys::ID_SEP) : associated_record_key.to_s
+
+ #this is a has_one or belongs_to: there should only be one record.
+ #Unfortunately we can't (in portable way) ask the database for 'all records where foo_id in (x,y,z), but please
+ # only one row per distinct foo_id' so this where we enforce that
+ next if seen_keys[associated_record_key]
+ seen_keys[associated_record_key] = true
+ mapped_records = id_to_record_map[associated_record_key][:records]
+ mapped_records.each do |mapped_record|
+ mapped_record.send("set_#{reflection_name}_target", associated_record)
+ end
+ end
+ end
+
+ def find_associated_records(ids, reflection, preload_options)
+ options = reflection.options
+ table_name = reflection.klass.quoted_table_name
+
+ if interface = reflection.options[:as]
+ raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
+ else
+ connection = reflection.active_record.connection
+ foreign_key = reflection.primary_key_name
+ conditions = ["#{table_name}.#{connection.quote_column_name(foreign_key)} IN (?)", ids]
+
+ if composite?
+ foreign_keys = foreign_key.to_s.split(CompositePrimaryKeys::ID_SEP)
+
+ where = (foreign_keys * ids.size).in_groups_of(foreign_keys.size).map do |keys|
+ "(" + keys.map{|key| "#{table_name}.#{connection.quote_column_name(key)} = ?"}.join(" AND ") + ")"
+ end.join(" OR ")
+
+ conditions = [where, ids].flatten
+ end
+ end
+
+ conditions.first << append_conditions(reflection, preload_options)
+
+ reflection.klass.find(:all,
+ :select => (preload_options[:select] || options[:select] || "#{table_name}.*"),
+ :include => preload_options[:include] || options[:include],
+ :conditions => conditions,
+ :joins => options[:joins],
+ :group => preload_options[:group] || options[:group],
+ :order => preload_options[:order] || options[:order])
+ end
+
+ # Given a collection of ActiveRecord objects, constructs a Hash which maps
+ # the objects' IDs to the relevant objects. Returns a 2-tuple
+ # <tt>(id_to_record_map, ids)</tt> where +id_to_record_map+ is the Hash,
+ # and +ids+ is an Array of record IDs.
+ def construct_id_map_for_composite(records)
+ id_to_record_map = {}
+ ids = []
+ records.each do |record|
+ primary_key ||= record.class.primary_key
+ ids << record.id
+ mapped_records = (id_to_record_map[record.id.to_s] ||= [])
+ mapped_records << record
+ end
+ ids.uniq!
+ return id_to_record_map, ids
+ end
+
+ def full_composite_join_clause(reflection, table1, full_keys1, table2, full_keys2)
+ connection = reflection.active_record.connection
+ full_keys1 = full_keys1.split(CompositePrimaryKeys::ID_SEP) if full_keys1.is_a?(String)
+ full_keys2 = full_keys2.split(CompositePrimaryKeys::ID_SEP) if full_keys2.is_a?(String)
+ where_clause = [full_keys1, full_keys2].transpose.map do |key_pair|
+ quoted1 = connection.quote_table_name(table1)
+ quoted2 = connection.quote_table_name(table2)
+ "#{quoted1}.#{connection.quote_column_name(key_pair.first)}=#{quoted2}.#{connection.quote_column_name(key_pair.last)}"
+ end.join(" AND ")
+ "(#{where_clause})"
+ end
+ end
+ end
+ end
+end
projects / rails.git / blobdiff