composite_primary_keys 1.0.8 → 1.0.10

data/lib/composite_primary_keys/attribute_methods.rb

@@ -5,7 +5,7 @@ module CompositePrimaryKeys
         super
         base.send(:extend, ClassMethods)
       end
-      
+
       module ClassMethods
         # Define an attribute reader method.  Cope with nil column.
         def define_read_method(symbol, attr_name, column)
@@ -16,7 +16,7 @@ module CompositePrimaryKeys
           unless self.primary_keys.include?(attr_name.to_sym)
             access_code = access_code.insert(0, "missing_attribute('#{attr_name}', caller) unless @attributes.has_key?('#{attr_name}'); ")
           end
-          
+
           if cache_attribute?(attr_name)
             access_code = "@attributes_cache['#{attr_name}'] ||= (#{access_code})"
           end
@@ -81,4 +81,4 @@ module CompositePrimaryKeys
       end
     end
   end
-end
+end

data/lib/composite_primary_keys/base.rb

@@ -2,72 +2,70 @@ module CompositePrimaryKeys
   module ActiveRecord #:nodoc:
     class CompositeKeyError < StandardError #:nodoc:
     end
-    
+
     module Base #:nodoc:
-      
+
       INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
-      NOT_IMPLEMENTED_YET = 'Not implemented for composite primary keys yet'
-      
+      NOT_IMPLEMENTED_YET        = 'Not implemented for composite primary keys yet'
+
       def self.append_features(base)
         super
         base.send(:include, InstanceMethods)
         base.extend(ClassMethods)
       end
-      
+
       module ClassMethods
         def set_primary_keys(*keys)
           keys = keys.first if keys.first.is_a?(Array)
-          keys = keys.map {|k| k.to_sym }
-          cattr_accessor :primary_keys 
+          keys = keys.map { |k| k.to_sym }
+          cattr_accessor :primary_keys
           self.primary_keys = keys.to_composite_keys
-          
+
           class_eval <<-EOV
             extend CompositeClassMethods
             include CompositeInstanceMethods
-                     
+
             include CompositePrimaryKeys::ActiveRecord::Associations
             include CompositePrimaryKeys::ActiveRecord::AssociationPreload
             include CompositePrimaryKeys::ActiveRecord::Calculations
             include CompositePrimaryKeys::ActiveRecord::AttributeMethods
           EOV
         end
-        
+
         def composite?
           false
         end
       end
-      
+
       module InstanceMethods
         def composite?; self.class.composite?; end
       end
-      
-      module CompositeInstanceMethods  
-        
+
+      module CompositeInstanceMethods
+
         # A model instance's primary keys is always available as model.ids
         # whether you name it the default 'id' or set it to something else.
         def id
           attr_names = self.class.primary_keys
-          CompositeIds.new(
-             attr_names.map {|attr_name| read_attribute(attr_name)}
-          )
+          CompositeIds.new(attr_names.map { |attr_name| read_attribute(attr_name) })
         end
         alias_method :ids, :id
-        
+
         def to_param
           id.to_s
         end
-        
+
         def id_before_type_cast #:nodoc:
           raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::NOT_IMPLEMENTED_YET
         end
-        
+
         def quoted_id #:nodoc:
           [self.class.primary_keys, ids].
             transpose.
             map {|attr_name,id| quote_value(id, column_for_attribute(attr_name))}.
             to_composite_ids
         end
-        
+
         # Sets the primary ID.
         def id=(ids)
           ids = ids.split(ID_SEP) if ids.is_a?(String)
@@ -78,7 +76,7 @@ module CompositePrimaryKeys
           [primary_keys, ids].transpose.each {|key, an_id| write_attribute(key , an_id)}
           id
         end
-        
+
         # Returns a clone of the record that hasn't been assigned an id yet and
         # is treated as a new record.  Note that this is a "shallow" clone:
         # it copies the object's attributes only, not its associations.
@@ -91,21 +89,22 @@ module CompositePrimaryKeys
             record.send :instance_variable_set, '@attributes', attrs
           end
         end
-        
-        
+
+
         private
         # The xx_without_callbacks methods are overwritten as that is the end of the alias chain
-        
+
         # Creates a new record with values matching those of the instance attributes.
         def create_without_callbacks
           unless self.id
             raise CompositeKeyError, "Composite keys do not generated ids from sequences, you must provide id values"
           end
           attributes_minus_pks = attributes_with_quotes(false)
-          cols = quoted_column_names(attributes_minus_pks) << self.class.primary_key
+          quoted_pk_columns = self.class.primary_key.map { |col| connection.quote_column_name(col) }
+          cols = quoted_column_names(attributes_minus_pks) << quoted_pk_columns
           vals = attributes_minus_pks.values << quoted_id
           connection.insert(
-            "INSERT INTO #{self.class.table_name} " +
+            "INSERT INTO #{self.class.quoted_table_name} " +
             "(#{cols.join(', ')}) " +
             "VALUES (#{vals.join(', ')})",
             "#{self.class.name} Create",
@@ -115,74 +114,93 @@ module CompositePrimaryKeys
           @new_record = false
           return true
         end
-        
-        
+
         # Updates the associated record with values matching those of the instance attributes.
         def update_without_callbacks
-          where_class = [self.class.primary_key, quoted_id].transpose.map {|pair| "(#{pair[0]} = #{pair[1]})"}.join(" AND ")
+          where_clause_terms = [self.class.primary_key, quoted_id].transpose.map do |pair| 
+            "(#{connection.quote_column_name(pair[0])} = #{pair[1]})"
+          end
+          where_clause = where_clause_terms.join(" AND ")
           connection.update(
-            "UPDATE #{self.class.table_name} " +
+            "UPDATE #{self.class.quoted_table_name} " +
             "SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))} " +
-            "WHERE #{where_class}",
+            "WHERE #{where_clause}",
             "#{self.class.name} Update"
           )
           return true
         end
-        
+
         # Deletes the record in the database and freezes this instance to reflect that no changes should
         # be made (since they can't be persisted).
         def destroy_without_callbacks
-          where_class = [self.class.primary_key, quoted_id].transpose.map do |pair| 
-            "(#{pair[0]} = #{pair[1]})"
-          end.join(" AND ")
+          where_clause_terms = [self.class.primary_key, quoted_id].transpose.map do |pair| 
+            "(#{connection.quote_column_name(pair[0])} = #{pair[1]})"
+          end
+          where_clause = where_clause_terms.join(" AND ")
           unless new_record?
             connection.delete(
-              "DELETE FROM #{self.class.table_name} " +
-              "WHERE #{where_class}",
+              "DELETE FROM #{self.class.quoted_table_name} " +
+              "WHERE #{where_clause}",
               "#{self.class.name} Destroy"
             )
           end
           freeze
         end
-          
       end
-      
+
       module CompositeClassMethods
         def primary_key; primary_keys; end
         def primary_key=(keys); primary_keys = keys; end
-        
+
         def composite?
           true
         end
-        
+
         #ids_to_s([[1,2],[7,3]]) -> "(1,2),(7,3)"
         #ids_to_s([[1,2],[7,3]], ',', ';') -> "1,2;7,3"
         def ids_to_s(many_ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
           many_ids.map {|ids| "#{left_bracket}#{ids}#{right_bracket}"}.join(list_sep)
         end
         
+        # Creates WHERE condition from list of composited ids
+        #   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)
+        #   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)
+        def composite_where_clause(ids)
+          if ids.is_a?(String)
+            ids = [[ids]]
+          elsif not ids.first.is_a?(Array) # if single comp key passed, turn into an array of 1
+            ids = [ids.to_composite_ids]
+          end
+          
+          ids.map do |id_set|
+            [primary_keys, id_set].transpose.map do |key, id|
+              "#{table_name}.#{key.to_s}=#{sanitize(id)}"
+            end.join(" AND ")
+          end.join(") OR (")       
+        end
+
         # Returns true if the given +ids+ represents the primary keys of a record in the database, false otherwise.
         # Example:
         #   Person.exists?(5,7)
         def exists?(ids)
           obj = find(ids) rescue false
-        !obj.nil? and obj.is_a?(self)
+          !obj.nil? and obj.is_a?(self)
         end
-        
+
         # Deletes the record with the given +ids+ without instantiating an object first, e.g. delete(1,2)
         # If an array of ids is provided (e.g. delete([1,2], [3,4]), all of them
         # are deleted.
         def delete(*ids)
           unless ids.is_a?(Array); raise "*ids must be an Array"; end
           ids = [ids.to_composite_ids] if not ids.first.is_a?(Array)
-          where_class = ids.map do |id_set|
+          where_clause = ids.map do |id_set|
             [primary_keys, id_set].transpose.map do |key, id|
-              "#{table_name}.#{key.to_s}=#{sanitize(id)}"
+              "#{quoted_table_name}.#{connection.quote_column_name(key.to_s)}=#{sanitize(id)}"
             end.join(" AND ")
           end.join(") OR (")
-          delete_all([ "(#{where_class})" ])
+          delete_all([ "(#{where_clause})" ])
         end
-        
+
         # Destroys the record with the given +ids+ by instantiating the object and calling #destroy (all the callbacks are the triggered).
         # If an array of ids is provided, all of them are destroyed.
         def destroy(*ids)
@@ -194,7 +212,7 @@ module CompositePrimaryKeys
           end
           ids.first.is_a?(CompositeIds) ? ids.each { |id_set| find(id_set).destroy } : find(ids).destroy
         end
-        
+
         # Returns an array of column objects for the table associated with this class.
         # Each column that matches to one of the primary keys has its
         # primary attribute set to true
@@ -205,7 +223,7 @@ module CompositePrimaryKeys
           end
           @columns
         end
-        
+
         ## DEACTIVATED METHODS ##
         public
         # Lazy-set the sequence name to the connection's default.  This method
@@ -213,24 +231,24 @@ module CompositePrimaryKeys
         def sequence_name #:nodoc:
           raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
         end
-        
+
         def reset_sequence_name #:nodoc:
           raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
         end
-        
+
         def set_primary_key(value = nil, &block)
           raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
         end
-        
+
         private
         def find_one(id, options)
           raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
         end
-        
+
         def find_some(ids, options)
           raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
         end
-        
+
         def find_from_ids(ids, options)
           ids = ids.first if ids.last == nil
           conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
@@ -243,7 +261,7 @@ module CompositePrimaryKeys
             # find '2,1;7,3' -> ids = [['2','1'],['7','3']], inner [] are CompositeIds
           end
           ids = [ids.to_composite_ids] if not ids.first.kind_of?(Array)
-          ids.each do |id_set| 
+          ids.each do |id_set|
             unless id_set.is_a?(Array)
               raise "Ids must be in an Array, instead received: #{id_set.inspect}"
             end
@@ -251,69 +269,69 @@ module CompositePrimaryKeys
               raise "#{id_set.inspect}: Incorrect number of primary keys for #{class_name}: #{primary_keys.inspect}"
             end
           end
-          
+
           # Let keys = [:a, :b]
           # If ids = [[10, 50], [11, 51]], then :conditions => 
-          #   "(#{table_name}.a, #{table_name}.b) IN ((10, 50), (11, 51))"
-          
+          #   "(#{quoted_table_name}.a, #{quoted_table_name}.b) IN ((10, 50), (11, 51))"
+
           conditions = ids.map do |id_set|
             [primary_keys, id_set].transpose.map do |key, id|
-			   col = columns_hash[key.to_s]
-			   val = quote_value(id, col)
-			   
-              "#{table_name}.#{key.to_s}=#{val}"
-              end.join(" AND ")
-              end.join(") OR (")
-              options.update :conditions => "(#{conditions})"
-              
-              result = find_every(options)
+			        col = columns_hash[key.to_s]
+			        val = quote_value(id, col)
+              "#{quoted_table_name}.#{connection.quote_column_name(key.to_s)}=#{val}"
+            end.join(" AND ")
+          end.join(") OR (")
               
-              if result.size == ids.size
-                ids.size == 1 ? result[0] : result
-              else
-                raise ::ActiveRecord::RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids.inspect})#{conditions}"
-              end
-            end
-            
+          options.update :conditions => "(#{conditions})"
+
+          result = find_every(options)
+
+          if result.size == ids.size
+            ids.size == 1 ? result[0] : result
+          else
+            raise ::ActiveRecord::RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids.inspect})#{conditions}"
           end
         end
       end
     end
-    
-    module ActiveRecord
-      ID_SEP = ','
-      ID_SET_SEP = ';'
-      
-      class Base
-        # Allows +attr_name+ to be the list of primary_keys, and returns the id
-        # of the object
-        # e.g. @object[@object.class.primary_key] => [1,1]
-        def [](attr_name)
-          if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first
-            attr_name = attr_name.split(ID_SEP)
-          end
-          attr_name.is_a?(Array) ?
-          attr_name.map {|name| read_attribute(name)} :
-          read_attribute(attr_name)
-        end
-        
-        # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
-        # (Alias for the protected write_attribute method).
-        def []=(attr_name, value)
-          if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first
-            attr_name = attr_name.split(ID_SEP)
-          end
-          if attr_name.is_a? Array
-            value = value.split(ID_SEP) if value.is_a? String
-            unless value.length == attr_name.length
-              raise "Number of attr_names and values do not match"
-            end
-            #breakpoint
-            [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}
-          else
-            write_attribute(attr_name, value)
-          end
+  end
+end
+
+
+module ActiveRecord
+  ID_SEP     = ','
+  ID_SET_SEP = ';'
+
+  class Base
+    # Allows +attr_name+ to be the list of primary_keys, and returns the id
+    # of the object
+    # e.g. @object[@object.class.primary_key] => [1,1]
+    def [](attr_name)
+      if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first
+        attr_name = attr_name.split(ID_SEP)
+      end
+      attr_name.is_a?(Array) ?
+        attr_name.map {|name| read_attribute(name)} :
+        read_attribute(attr_name)
+    end
+
+    # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
+    # (Alias for the protected write_attribute method).
+    def []=(attr_name, value)
+      if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first
+        attr_name = attr_name.split(ID_SEP)
+      end
+
+      if attr_name.is_a? Array
+        value = value.split(ID_SEP) if value.is_a? String
+        unless value.length == attr_name.length
+          raise "Number of attr_names and values do not match"
         end
-        
+        #breakpoint
+        [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}
+      else
+        write_attribute(attr_name, value)
       end
     end
+  end
+end

data/lib/composite_primary_keys/calculations.rb

@@ -5,7 +5,7 @@ module CompositePrimaryKeys
         super
         base.send(:extend, ClassMethods)
       end
-      
+
       module ClassMethods
         def construct_calculation_sql(operation, column_name, options) #:nodoc:
           operation = operation.to_s.downcase
@@ -20,7 +20,7 @@ module CompositePrimaryKeys
           if merged_includes.any? && operation.to_s.downcase == 'count'
             options[:distinct] = true
             use_workaround  = !connection.supports_count_distinct?
-            column_name = options[:select] || primary_key.map{ |part| "#{table_name}.#{part}"}.join(',')
+            column_name = options[:select] || primary_key.map{ |part| "#{quoted_table_name}.#{connection.quote_column_name(part)}"}.join(',')
           end
 
           sql  = "SELECT #{operation}(#{'DISTINCT ' if options[:distinct]}#{column_name}) AS #{aggregate_alias}"
@@ -28,9 +28,9 @@ module CompositePrimaryKeys
           # A (slower) workaround if we're using a backend, like sqlite, that doesn't support COUNT DISTINCT.
           sql = "SELECT COUNT(*) AS #{aggregate_alias}" if use_workaround
 
-          sql << ", #{options[:group_field]} AS #{options[:group_alias]}" if options[:group]
+          sql << ", #{connection.quote_column_name(options[:group_field])} AS #{options[:group_alias]}" if options[:group]
           sql << " FROM (SELECT DISTINCT #{column_name}" if use_workaround
-          sql << " FROM #{table_name} "
+          sql << " FROM #{quoted_table_name} "
           if merged_includes.any?
             join_dependency = ::ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, merged_includes, options[:joins])
             sql << join_dependency.join_associations.collect{|join| join.association_join }.join
@@ -38,13 +38,13 @@ module CompositePrimaryKeys
           add_joins!(sql, options, scope)
           add_conditions!(sql, options[:conditions], scope)
           add_limited_ids_condition!(sql, options, join_dependency) if \
-            join_dependency && 
-            !using_limitable_reflections?(join_dependency.reflections) && 
+            join_dependency &&
+            !using_limitable_reflections?(join_dependency.reflections) &&
             ((scope && scope[:limit]) || options[:limit])
 
           if options[:group]
             group_key = connection.adapter_name == 'FrontBase' ?  :group_alias : :group_field
-            sql << " GROUP BY #{options[group_key]} "
+            sql << " GROUP BY #{connection.quote_column_name(options[group_key])} "
           end
 
           if options[:group] && options[:having]
@@ -57,7 +57,7 @@ module CompositePrimaryKeys
             sql << " HAVING #{options[:having]} "
           end
 
-          sql << " ORDER BY #{options[:order]} "       if options[:order]
+          sql << " ORDER BY #{options[:order]} " if options[:order]
           add_limit!(sql, options, scope)
           sql << ') w1' if use_workaround # assign a dummy table name as required for postgresql
           sql