Merge branch 'master' into copyright
[rails.git] / vendor / gems / composite_primary_keys-2.2.2 / lib / composite_primary_keys / base.rb
1 module CompositePrimaryKeys
2   module ActiveRecord #:nodoc:
3     class CompositeKeyError < StandardError #:nodoc:
4     end
5
6     module Base #:nodoc:
7
8       INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
9       NOT_IMPLEMENTED_YET        = 'Not implemented for composite primary keys yet'
10
11       def self.append_features(base)
12         super
13         base.send(:include, InstanceMethods)
14         base.extend(ClassMethods)
15       end
16
17       module ClassMethods
18         def set_primary_keys(*keys)
19           keys = keys.first if keys.first.is_a?(Array)
20           keys = keys.map { |k| k.to_sym }
21           cattr_accessor :primary_keys
22           self.primary_keys = keys.to_composite_keys
23
24           class_eval <<-EOV
25             extend CompositeClassMethods
26             include CompositeInstanceMethods
27
28             include CompositePrimaryKeys::ActiveRecord::Associations
29             include CompositePrimaryKeys::ActiveRecord::AssociationPreload
30             include CompositePrimaryKeys::ActiveRecord::Calculations
31             include CompositePrimaryKeys::ActiveRecord::AttributeMethods
32           EOV
33         end
34
35         def composite?
36           false
37         end
38       end
39
40       module InstanceMethods
41         def composite?; self.class.composite?; end
42       end
43
44       module CompositeInstanceMethods
45
46         # A model instance's primary keys is always available as model.ids
47         # whether you name it the default 'id' or set it to something else.
48         def id
49           attr_names = self.class.primary_keys
50           CompositeIds.new(attr_names.map { |attr_name| read_attribute(attr_name) })
51         end
52         alias_method :ids, :id
53
54         def to_param
55           id.to_s
56         end
57
58         def id_before_type_cast #:nodoc:
59           raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::NOT_IMPLEMENTED_YET
60         end
61
62         def quoted_id #:nodoc:
63           [self.class.primary_keys, ids].
64             transpose.
65             map {|attr_name,id| quote_value(id, column_for_attribute(attr_name))}.
66             to_composite_ids
67         end
68
69         # Sets the primary ID.
70         def id=(ids)
71           ids = ids.split(ID_SEP) if ids.is_a?(String)
72           ids.flatten!
73           unless ids.is_a?(Array) and ids.length == self.class.primary_keys.length
74             raise "#{self.class}.id= requires #{self.class.primary_keys.length} ids"
75           end
76           [primary_keys, ids].transpose.each {|key, an_id| write_attribute(key , an_id)}
77           id
78         end
79
80         # Returns a clone of the record that hasn't been assigned an id yet and
81         # is treated as a new record.  Note that this is a "shallow" clone:
82         # it copies the object's attributes only, not its associations.
83         # The extent of a "deep" clone is application-specific and is therefore
84         # left to the application to implement according to its need.
85         def clone
86           attrs = self.attributes_before_type_cast
87           self.class.primary_keys.each {|key| attrs.delete(key.to_s)}
88           self.class.new do |record|
89             record.send :instance_variable_set, '@attributes', attrs
90           end
91         end
92
93
94         private
95         # The xx_without_callbacks methods are overwritten as that is the end of the alias chain
96
97         # Creates a new record with values matching those of the instance attributes.
98         def create_without_callbacks
99           unless self.id
100             raise CompositeKeyError, "Composite keys do not generated ids from sequences, you must provide id values"
101           end
102           attributes_minus_pks = attributes_with_quotes(false)
103           quoted_pk_columns = self.class.primary_key.map { |col| connection.quote_column_name(col) }
104           cols = quoted_column_names(attributes_minus_pks) << quoted_pk_columns
105           vals = attributes_minus_pks.values << quoted_id
106           connection.insert(
107             "INSERT INTO #{self.class.quoted_table_name} " +
108             "(#{cols.join(', ')}) " +
109             "VALUES (#{vals.join(', ')})",
110             "#{self.class.name} Create",
111             self.class.primary_key,
112             self.id
113           )
114           @new_record = false
115           return true
116         end
117
118         # Updates the associated record with values matching those of the instance attributes.
119         def update_without_callbacks
120           where_clause_terms = [self.class.primary_key, quoted_id].transpose.map do |pair| 
121             "(#{connection.quote_column_name(pair[0])} = #{pair[1]})"
122           end
123           where_clause = where_clause_terms.join(" AND ")
124           connection.update(
125             "UPDATE #{self.class.quoted_table_name} " +
126             "SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))} " +
127             "WHERE #{where_clause}",
128             "#{self.class.name} Update"
129           )
130           return true
131         end
132
133         # Deletes the record in the database and freezes this instance to reflect that no changes should
134         # be made (since they can't be persisted).
135         def destroy_without_callbacks
136           where_clause_terms = [self.class.primary_key, quoted_id].transpose.map do |pair| 
137             "(#{connection.quote_column_name(pair[0])} = #{pair[1]})"
138           end
139           where_clause = where_clause_terms.join(" AND ")
140           unless new_record?
141             connection.delete(
142               "DELETE FROM #{self.class.quoted_table_name} " +
143               "WHERE #{where_clause}",
144               "#{self.class.name} Destroy"
145             )
146           end
147           freeze
148         end
149       end
150
151       module CompositeClassMethods
152         def primary_key; primary_keys; end
153         def primary_key=(keys); primary_keys = keys; end
154
155         def composite?
156           true
157         end
158
159         #ids_to_s([[1,2],[7,3]]) -> "(1,2),(7,3)"
160         #ids_to_s([[1,2],[7,3]], ',', ';') -> "1,2;7,3"
161         def ids_to_s(many_ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
162           many_ids.map {|ids| "#{left_bracket}#{ids}#{right_bracket}"}.join(list_sep)
163         end
164         
165         # Creates WHERE condition from list of composited ids
166         #   User.update_all({:role => 'admin'}, :conditions => composite_where_clause([[1, 2], [2, 2]])) #=> UPDATE admins SET admin.role='admin' WHERE (admin.type=1 AND admin.type2=2) OR (admin.type=2 AND admin.type2=2)
167         #   User.find(:all, :conditions => composite_where_clause([[1, 2], [2, 2]])) #=> SELECT * FROM admins WHERE (admin.type=1 AND admin.type2=2) OR (admin.type=2 AND admin.type2=2)
168         def composite_where_clause(ids)
169           if ids.is_a?(String)
170             ids = [[ids]]
171           elsif not ids.first.is_a?(Array) # if single comp key passed, turn into an array of 1
172             ids = [ids.to_composite_ids]
173           end
174           
175           ids.map do |id_set|
176             [primary_keys, id_set].transpose.map do |key, id|
177               "#{table_name}.#{key.to_s}=#{sanitize(id)}"
178             end.join(" AND ")
179           end.join(") OR (")       
180         end
181
182         # Returns true if the given +ids+ represents the primary keys of a record in the database, false otherwise.
183         # Example:
184         #   Person.exists?(5,7)
185         def exists?(ids)
186           if ids.is_a?(Array) && ids.first.is_a?(String)
187             count(:conditions => ids) > 0
188           else
189             obj = find(ids) rescue false
190             !obj.nil? and obj.is_a?(self)            
191           end
192         end
193
194         # Deletes the record with the given +ids+ without instantiating an object first, e.g. delete(1,2)
195         # If an array of ids is provided (e.g. delete([1,2], [3,4]), all of them
196         # are deleted.
197         def delete(*ids)
198           unless ids.is_a?(Array); raise "*ids must be an Array"; end
199           ids = [ids.to_composite_ids] if not ids.first.is_a?(Array)
200           where_clause = ids.map do |id_set|
201             [primary_keys, id_set].transpose.map do |key, id|
202               "#{quoted_table_name}.#{connection.quote_column_name(key.to_s)}=#{sanitize(id)}"
203             end.join(" AND ")
204           end.join(") OR (")
205           delete_all([ "(#{where_clause})" ])
206         end
207
208         # Destroys the record with the given +ids+ by instantiating the object and calling #destroy (all the callbacks are the triggered).
209         # If an array of ids is provided, all of them are destroyed.
210         def destroy(*ids)
211           unless ids.is_a?(Array); raise "*ids must be an Array"; end
212           if ids.first.is_a?(Array)
213             ids = ids.map{|compids| compids.to_composite_ids}
214           else
215             ids = ids.to_composite_ids
216           end
217           ids.first.is_a?(CompositeIds) ? ids.each { |id_set| find(id_set).destroy } : find(ids).destroy
218         end
219
220         # Returns an array of column objects for the table associated with this class.
221         # Each column that matches to one of the primary keys has its
222         # primary attribute set to true
223         def columns
224           unless @columns
225             @columns = connection.columns(table_name, "#{name} Columns")
226             @columns.each {|column| column.primary = primary_keys.include?(column.name.to_sym)}
227           end
228           @columns
229         end
230
231         ## DEACTIVATED METHODS ##
232         public
233         # Lazy-set the sequence name to the connection's default.  This method
234         # is only ever called once since set_sequence_name overrides it.
235         def sequence_name #:nodoc:
236           raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
237         end
238
239         def reset_sequence_name #:nodoc:
240           raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
241         end
242
243         def set_primary_key(value = nil, &block)
244           raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
245         end
246
247         private
248         def find_one(id, options)
249           raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
250         end
251
252         def find_some(ids, options)
253           raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
254         end
255
256         def find_from_ids(ids, options)
257           ids = ids.first if ids.last == nil
258           conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
259           # if ids is just a flat list, then its size must = primary_key.length (one id per primary key, in order)
260           # if ids is list of lists, then each inner list must follow rule above
261           if ids.first.is_a? String
262             # find '2,1' -> ids = ['2,1']
263             # find '2,1;7,3' -> ids = ['2,1;7,3']
264             ids = ids.first.split(ID_SET_SEP).map {|id_set| id_set.split(ID_SEP).to_composite_ids}
265             # find '2,1;7,3' -> ids = [['2','1'],['7','3']], inner [] are CompositeIds
266           end
267           ids = [ids.to_composite_ids] if not ids.first.kind_of?(Array)
268           ids.each do |id_set|
269             unless id_set.is_a?(Array)
270               raise "Ids must be in an Array, instead received: #{id_set.inspect}"
271             end
272             unless id_set.length == primary_keys.length
273               raise "#{id_set.inspect}: Incorrect number of primary keys for #{class_name}: #{primary_keys.inspect}"
274             end
275           end
276
277           # Let keys = [:a, :b]
278           # If ids = [[10, 50], [11, 51]], then :conditions => 
279           #   "(#{quoted_table_name}.a, #{quoted_table_name}.b) IN ((10, 50), (11, 51))"
280
281           conditions = ids.map do |id_set|
282             [primary_keys, id_set].transpose.map do |key, id|
283                                 col = columns_hash[key.to_s]
284                                 val = quote_value(id, col)
285               "#{quoted_table_name}.#{connection.quote_column_name(key.to_s)}=#{val}"
286             end.join(" AND ")
287           end.join(") OR (")
288               
289           options.update :conditions => "(#{conditions})"
290
291           result = find_every(options)
292
293           if result.size == ids.size
294             ids.size == 1 ? result[0] : result
295           else
296             raise ::ActiveRecord::RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids.inspect})#{conditions}"
297           end
298         end
299       end
300     end
301   end
302 end
303
304
305 module ActiveRecord
306   ID_SEP     = ','
307   ID_SET_SEP = ';'
308
309   class Base
310     # Allows +attr_name+ to be the list of primary_keys, and returns the id
311     # of the object
312     # e.g. @object[@object.class.primary_key] => [1,1]
313     def [](attr_name)
314       if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first
315         attr_name = attr_name.split(ID_SEP)
316       end
317       attr_name.is_a?(Array) ?
318         attr_name.map {|name| read_attribute(name)} :
319         read_attribute(attr_name)
320     end
321
322     # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
323     # (Alias for the protected write_attribute method).
324     def []=(attr_name, value)
325       if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first
326         attr_name = attr_name.split(ID_SEP)
327       end
328
329       if attr_name.is_a? Array
330         value = value.split(ID_SEP) if value.is_a? String
331         unless value.length == attr_name.length
332           raise "Number of attr_names and values do not match"
333         end
334         #breakpoint
335         [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}
336       else
337         write_attribute(attr_name, value)
338       end
339     end
340   end
341 end