composite_primary_keys 0.7.5 → 0.8.0

data/lib/composite_primary_keys/base.rb

@@ -25,6 +25,7 @@ module CompositePrimaryKeys
             extend CompositePrimaryKeys::ActiveRecord::Base::CompositeClassMethods
             include CompositePrimaryKeys::ActiveRecord::Base::CompositeInstanceMethods
             include CompositePrimaryKeys::ActiveRecord::Associations
+            extend CompositePrimaryKeys::ActiveRecord::Calculations::ClassMethods
           EOV
         end
         
@@ -44,7 +45,7 @@ module CompositePrimaryKeys
         def id
           attr_names = self.class.primary_keys
           CompositeIds.new(
-                           attr_names.map {|attr_name| read_attribute(attr_name)}
+             attr_names.map {|attr_name| read_attribute(attr_name)}
           )
         end
         alias_method :ids, :id
@@ -59,9 +60,9 @@ module CompositePrimaryKeys
         
         def quoted_id #:nodoc:
           [self.class.primary_keys, ids].
-          transpose.
-          map {|attr_name,id| quote(id, column_for_attribute(attr_name))}.
-          to_composite_ids
+            transpose.
+            map {|attr_name,id| quote_value(id, column_for_attribute(attr_name))}.
+            to_composite_ids
         end
         
         # Sets the primary ID.
@@ -132,15 +133,19 @@ module CompositePrimaryKeys
         
         # 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
+          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
           vals = attributes_minus_pks.values << quoted_id
           connection.insert(
-           "INSERT INTO #{self.class.table_name} " +
-           "(#{cols.join(', ')}) " +
-           "VALUES(#{vals.join(', ')})",
-           "#{self.class.name} Create"
+            "INSERT INTO #{self.class.table_name} " +
+            "(#{cols.join(', ')}) " +
+            "VALUES (#{vals.join(', ')})",
+            "#{self.class.name} Create",
+            self.class.primary_key,
+            self.id
           )
           @new_record = false
           return true
@@ -164,178 +169,183 @@ module CompositePrimaryKeys
         def destroy_without_callbacks
           where_class = [self.class.primary_key, quoted_id].transpose.map do |pair| 
             "(#{pair[0]} = #{pair[1]})"
-            end.join(" AND ")
-            unless new_record?
-              connection.delete(
-                "DELETE FROM #{self.class.table_name} " +
-                "WHERE #{where_class}",
-                "#{self.class.name} Destroy"
-              )
-            end
-            freeze
+          end.join(" AND ")
+          unless new_record?
+            connection.delete(
+              "DELETE FROM #{self.class.table_name} " +
+              "WHERE #{where_class}",
+              "#{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
         
-        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)
+        #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
+        
+        # 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)
+        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|
+            [primary_keys, id_set].transpose.map do |key, id|
+              "#{table_name}.#{key.to_s}=#{sanitize(id)}"
+            end.join(" AND ")
+          end.join(") OR (")
+          delete_all([ "(#{where_class})" ])
+        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)
+          unless ids.is_a?(Array); raise "*ids must be an Array"; end
+          if ids.first.is_a?(Array)
+            ids = ids.map{|compids| compids.to_composite_ids}
+          else
+            ids = ids.to_composite_ids
           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)
+          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
+        def columns
+          unless @columns
+            @columns = connection.columns(table_name, "#{name} Columns")
+            @columns.each {|column| column.primary = primary_keys.include?(column.name.to_sym)}
           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)
-            delete_all([ "(#{primary_keys}) IN (#{ids_to_s(ids)})" ])
+          @columns
+        end
+        
+        ## DEACTIVATED METHODS ##
+        public
+        # Lazy-set the sequence name to the connection's default.  This method
+        # is only ever called once since set_sequence_name overrides it.
+        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]
+          # if ids is just a flat list, then its size must = primary_key.length (one id per primary key, in order)
+          # if ids is list of lists, then each inner list must follow rule above
+          if ids.first.is_a? String
+            # find '2,1' -> ids = ['2,1']
+            # find '2,1;7,3' -> ids = ['2,1;7,3']
+            ids = ids.first.split(ID_SET_SEP).map {|id_set| id_set.split(ID_SEP).to_composite_ids}
+            # find '2,1;7,3' -> ids = [['2','1'],['7','3']], inner [] are CompositeIds
           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)
-            unless ids.is_a?(Array); raise "*ids must be an Array"; end
-            if ids.first.is_a?(Array)
-              ids = ids.map{|compids| compids.to_composite_ids}
-            else
-              ids = ids.to_composite_ids
+          ids = [ids.to_composite_ids] if not ids.first.kind_of?(Array)
+          ids.each do |id_set| 
+            unless id_set.is_a?(Array)
+              raise "Ids must be in an Array, instead received: #{id_set.inspect}"
             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
-          def columns
-            unless @columns
-              @columns = connection.columns(table_name, "#{name} Columns")
-              @columns.each {|column| column.primary = primary_keys.include?(column.name.to_sym)}
+            unless id_set.length == primary_keys.length
+              raise "#{id_set.inspect}: Incorrect number of primary keys for #{class_name}: #{primary_keys.inspect}"
             end
-            @columns
-          end
-          
-          ## DEACTIVATED METHODS ##
-          public
-          # Lazy-set the sequence name to the connection's default.  This method
-          # is only ever called once since set_sequence_name overrides it.
-          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
+          # Let keys = [:a, :b]
+          # If ids = [[10, 50], [11, 51]], then :conditions => 
+          #   "(#{table_name}.a, #{table_name}.b) IN ((10, 50), (11, 51))"
           
-          def find_some(ids, options)
-            raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
-          end
-          
-          def find_from_ids(ids, options)
-            conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
-            # if ids is just a flat list, then its size must = primary_key.length (one id per primary key, in order)
-            # if ids is list of lists, then each inner list must follow rule above
-            
-            if ids.first.is_a? String
-              # find '2,1' -> ids = ['2,1']
-              # find '2,1;7,3' -> ids = ['2,1;7,3']
-              ids = ids.first.split(ID_SET_SEP).map {|id_set| id_set.split(ID_SEP).to_composite_ids}
-              # 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| 
-              unless id_set.is_a?(Array)
-                raise "Ids must be in an Array, instead received: #{id_set.inspect}"
-              end
-              unless id_set.length == primary_keys.length
-                raise "#{id_set.inspect}: Incorrect number of primary keys for #{class_name}: #{primary_keys.inspect}"
+          conditions = 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 (")
+              options.update :conditions => "(#{conditions})"
+              
+              result = find_every(options)
+              
+              if result.size == ids.size
+                ids.size == 1 ? result[0] : result
+              else
+                raise RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids_list})#{conditions}"
               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))"
-            
-            conditions = 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 (")
-                options.update :conditions => "(#{conditions})"
-                
-                result = find_every(options)
-                
-                if result.size == ids.size
-                  ids.size == 1 ? result[0] : result
-                else
-                  raise RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids_list})#{conditions}"
-                end
-              end
-              
-            end
           end
         end
       end
+    end
+    
+    module ActiveRecord
+      ID_SEP = ','
+      ID_SET_SEP = ';'
       
-      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
         
-        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)
+        # 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
-          
-          # 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)
+          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

@@ -0,0 +1,63 @@
+module CompositePrimaryKeys
+  module ActiveRecord
+    module Calculations
+      module ClassMethods
+        def construct_calculation_sql(operation, column_name, options) #:nodoc:
+          operation = operation.to_s.downcase
+          options = options.symbolize_keys
+
+          scope           = scope(:find)
+          merged_includes = merge_includes(scope ? scope[:include] : [], options[:include])
+          aggregate_alias = column_alias_for(operation, column_name)
+          use_workaround  = !connection.supports_count_distinct? && options[:distinct] && operation.to_s.downcase == 'count'
+          join_dependency = nil
+
+          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(',')
+          end
+
+          sql  = "SELECT #{operation}(#{'DISTINCT ' if options[:distinct]}#{column_name}) AS #{aggregate_alias}"
+
+          # 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 << " FROM (SELECT DISTINCT #{column_name}" if use_workaround
+          sql << " FROM #{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
+          end
+          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) && 
+            ((scope && scope[:limit]) || options[:limit])
+
+          if options[:group]
+            group_key = Base.connection.adapter_name == 'FrontBase' ?  :group_alias : :group_field
+            sql << " GROUP BY #{options[group_key]} "
+          end
+
+          if options[:group] && options[:having]
+            # FrontBase requires identifiers in the HAVING clause and chokes on function calls
+            if Base.connection.adapter_name == 'FrontBase'
+              options[:having].downcase!
+              options[:having].gsub!(/#{operation}\s*\(\s*#{column_name}\s*\)/, aggregate_alias)
+            end
+
+            sql << " HAVING #{options[:having]} "
+          end
+
+          sql << " ORDER BY #{options[:order]} "       if options[:order]
+          add_limit!(sql, options, scope)
+          sql << ') as w1' if use_workaround
+          sql
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,11 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      
+      # This mightn't be in Core, but count(distinct x,y) doesn't work for me
+      def supports_count_distinct? #:nodoc:
+        false
+      end
+    end
+  end
+end