composite_primary_keys 2.3.5.1 → 3.0.0.b2

data/lib/composite_primary_keys/calculations.rb

@@ -1,68 +1,26 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module Calculations
-      def self.append_features(base)
-        super
-        base.send(:extend, ClassMethods)
-      end
-
-      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| "#{quoted_table_name}.#{connection.quote_column_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 << ", #{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 #{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
-          end
-
-          add_joins!(sql, options[:joins], 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 = connection.adapter_name == 'FrontBase' ?  :group_alias : :group_field
-            sql << " GROUP BY #{connection.quote_column_name(options[group_key])} "
-          end
-
-          if options[:group] && options[:having]
-            # FrontBase requires identifiers in the HAVING clause and chokes on function calls
-            if 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 << ') w1' if use_workaround # assign a dummy table name as required for postgresql
-          sql
+module ActiveRecord
+  module Calculations
+    def execute_simple_calculation(operation, column_name, distinct)
+      # CPK changes
+      if column_name.kind_of?(Array)
+        columns = column_name.map do |primary_key_column|
+          table[primary_key_column].to_sql
+        end
+        projection = "DISTINCT #{columns.join(',')}"
+        subquery = "(#{table.project(projection).to_sql}) AS subquery"
+        relation = Arel::Table.new(subquery).project(Arel::SqlLiteral.new('*').count)
+        type_cast_calculated_value(@klass.connection.select_value(relation.to_sql),
+                                   column_for(column_name.first), operation)
+      else
+        column = if @klass.column_names.include?(column_name.to_s)
+          Arel::Attribute.new(@klass.unscoped, column_name)
+        else
+          Arel::SqlLiteral.new(column_name == :all ? "*" : column_name.to_s)
         end
+
+        # Postgresql doesn't like ORDER BY when there are no GROUP BY
+        relation = except(:order).select(operation == 'count' ? column.count(distinct) : column.send(operation))
+        type_cast_calculated_value(@klass.connection.select_value(relation.to_sql), column_for(column_name), operation)
       end
     end
   end

data/lib/composite_primary_keys/composite_arrays.rb

@@ -8,23 +8,16 @@ module CompositePrimaryKeys
     end
 
     def to_composite_ids
-      CompositeIds.new(self)
+      Array.new(self)
     end
   end
 
-  class CompositeArray < Array
+  class CompositeKeys < Array
     def to_s
+      # Doing this makes it easier to parse Base#[](attr_name)
       join(ID_SEP)
     end
   end
-
-  class CompositeKeys < CompositeArray
-
-  end
-
-  class CompositeIds < CompositeArray
-
-  end
 end
 
 Array.send(:include, CompositePrimaryKeys::ArrayExtension)

data/lib/composite_primary_keys/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,9 @@
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    class AbstractAdapter
+      def concat(*columns)
+        "CONCAT(#{columns.join(',')})"
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/connection_adapters/oracle_enhanced_adapter.rb

@@ -0,0 +1,17 @@
+# Added to OracleEnhancedAdapter version 1.1.4
+# 
+# module ActiveRecord
+#   module ConnectionAdapters
+#     class OracleEnhancedAdapter < AbstractAdapter
+#       
+#       # This mightn't be in Core, but count(distinct x,y) doesn't work for me
+#       def supports_count_distinct? #:nodoc:
+#         false
+#       end
+#       
+#       def concat(*columns)
+#         "(#{columns.join('||')})"
+#       end
+#     end
+#   end
+# end

data/lib/composite_primary_keys/connection_adapters/postgresql_adapter.rb

@@ -22,7 +22,7 @@ module ActiveRecord
           pk, sequence_name = *pk_and_sequence_for(table) unless pk
           if pk
             quoted_pk = if pk.is_a?(Array)
-                          pk.map { |col| quote_column_name(col) }.join(ID_SEP)
+                          pk.map { |col| quote_column_name(col) }.join(CompositePrimaryKeys::ID_SEP)
                         else
                           quote_column_name(pk)
                         end

data/lib/composite_primary_keys/finder_methods.rb

@@ -0,0 +1,71 @@
+module CompositePrimaryKeys
+  module ActiveRecord
+    module FinderMethods
+      module InstanceMethods
+        def exists?(id = nil)
+          case id
+          when Array
+            # CPK
+            if id.first.is_a?(String) and id.first.match(/\?/)
+              where(id).exists?
+            else
+              where(ids_predicate(id)).exists?
+            end
+          when Hash
+            where(id).exists?
+          else
+            # CPK
+            #relation = select(primary_key).limit(1)
+            #relation = relation.where(primary_key.eq(id)) if id
+
+            relation = select(primary_keys).limit(1)
+            relation = relation.where(ids_predicate(id)) if id
+            relation.first ? true : false
+          end
+        end
+
+        def find_with_ids(*ids, &block)
+          return to_a.find(&block) if block_given?
+
+          ids = ids.first if ids.last == nil
+
+          # 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']
+            match = ids.first.match(/^\[(.*)\]$/)
+            ids = (match ? match[1] : ids.first).split(ID_SET_SEP).map {|id_set| id_set.split(CompositePrimaryKeys::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 == @klass.primary_keys.length
+              raise "#{id_set.inspect}: Incorrect number of primary keys for #{@klass.name}: #{@klass.primary_keys.inspect}"
+            end
+          end
+
+          new_relation = clone
+          ids.each do |id_set|
+            [@klass.primary_keys, id_set].transpose.map do |key, id|
+              new_relation = new_relation.where(key => id)
+            end
+          end
+
+          result = new_relation.to_a
+
+          if result.size == ids.size
+            ids.size == 1 ? result[0] : result
+          else
+            raise ::ActiveRecord::RecordNotFound, "Couldn't find all #{@klass.name} with IDs (#{ids.inspect})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/fixtures.rb

@@ -1,7 +1,7 @@
 class Fixture #:nodoc:
   def [](key)
     if key.is_a? Array
-      return key.map { |a_key| self[a_key.to_s] }.to_composite_ids.to_s
+      return key.map { |a_key| self[a_key.to_s] }.to_composite_ids
     end
     @fixture[key]
   end

data/lib/composite_primary_keys/read.rb

@@ -0,0 +1,25 @@
+module ActiveRecord
+  module AttributeMethods
+    module Read
+      def read_attribute(attr_name)
+        attr_name = attr_name.to_s
+        # CPK
+        # attr_name = self.class.primary_key if attr_name == 'id'
+        attr_name = self.class.primary_key if (attr_name == 'id' and !self.composite?)
+        if !(value = @attributes[attr_name]).nil?
+          if column = column_for_attribute(attr_name)
+            if unserializable_attribute?(attr_name, column)
+              unserialize_attribute(attr_name)
+            else
+              column.type_cast(value)
+            end
+          else
+            value
+          end
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/reflection.rb

@@ -1,18 +1,38 @@
 module ActiveRecord
   module Reflection
     class AssociationReflection
+      def derive_primary_key
+        result = if options[:foreign_key]
+          options[:foreign_key]
+        elsif belongs_to?
+          #CPK
+          #"#{name}_id"
+          class_name.foreign_key
+        elsif options[:as]
+          options[:as]
+        else
+          active_record.name.foreign_key
+        end
+      end
+
+      def cpk_primary_key
+        # Make sure the returned key(s) are an array
+        @cpk_primary_key ||= [derive_primary_key].flatten
+      end
+
       def primary_key_name
-        return @primary_key_name if @primary_key_name
-        case
-          when macro == :belongs_to
-            @primary_key_name = options[:foreign_key] || class_name.foreign_key
-          when options[:as]
-            @primary_key_name = options[:foreign_key] || "#{options[:as]}_id"
-          else
-            @primary_key_name = options[:foreign_key] || active_record.name.foreign_key
+        @primary_key_name ||= derive_primary_key_name
+      end
+
+      def derive_primary_key_name
+        result = derive_primary_key
+
+        # CPK
+        if result.is_a?(Array)
+          result.to_composite_keys.to_s
+        else
+          result
         end
-        @primary_key_name = @primary_key_name.to_composite_keys.to_s if @primary_key_name.is_a? Array
-        @primary_key_name
       end
     end
   end

data/lib/composite_primary_keys/relation.rb

@@ -0,0 +1,31 @@
+module CompositePrimaryKeys
+  module ActiveRecord
+    module Relation
+      module InstanceMethods
+        def ids_predicate(id)
+          predicate = nil
+          self.primary_keys.zip(id).each do |key, value|
+            eq = table[key].eq(value)
+            predicate = predicate ? predicate.and(eq) : eq
+          end
+          predicate
+        end
+
+        def delete(id_or_array)
+          # CPK
+          # where(@klass.primary_key => id_or_array).delete_all
+          where(ids_predicate(id_or_array)).delete_all
+        end
+
+        def destroy(id)
+          # CPK
+          #if id.is_a?(Array)
+          #  id.map { |one_id| destroy(one_id) }
+          #else
+            find(id).destroy
+          #end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/validations/uniqueness.rb

@@ -1,77 +1,117 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module Validations
-      module Uniqueness
-        module ClassMethods
-          def validates_uniqueness_of(*attr_names)
-            configuration = { :case_sensitive => true }
-            configuration.update(attr_names.extract_options!)
+module ActiveRecord
+  module Validations
+    class UniquenessValidator
+      def validate_each(record, attribute, value)
+        finder_class = find_finder_class_for(record)
+        table = finder_class.unscoped
 
-            validates_each(attr_names,configuration) do |record, attr_name, value|
-              # The check for an existing value should be run from a class that
-              # isn't abstract. This means working down from the current class
-              # (self), to the first non-abstract class. Since classes don't know
-              # their subclasses, we have to build the hierarchy between self and
-              # the record's class.
-              class_hierarchy = [record.class]
-              while class_hierarchy.first != self
-                class_hierarchy.insert(0, class_hierarchy.first.superclass)
-              end
+        table_name   = record.class.quoted_table_name
+        sql, params  = mount_sql_and_params(finder_class, table_name, attribute, value)
 
-              # Now we can work our way down the tree to the first non-abstract
-              # class (which has a database table to query from).
-              finder_class = class_hierarchy.detect { |klass| !klass.abstract_class? }
+        relation = table.where(sql, *params)
 
-              column = finder_class.columns_hash[attr_name.to_s]
-
-              if value.nil?
-                comparison_operator = "IS ?"
-              elsif column.text?
-                comparison_operator = "#{connection.case_sensitive_equality_operator} ?"
-                value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s
-              else
-                comparison_operator = "= ?"
-              end
-
-              sql_attribute = "#{record.class.quoted_table_name}.#{connection.quote_column_name(attr_name)}"
-
-              if value.nil? || (configuration[:case_sensitive] || !column.text?)
-                condition_sql = "#{sql_attribute} #{comparison_operator}"
-                condition_params = [value]
-              else
-                condition_sql = "LOWER(#{sql_attribute}) #{comparison_operator}"
-                condition_params = [value.mb_chars.downcase]
-              end
-
-              if scope = configuration[:scope]
-                Array(scope).map do |scope_item|
-                  scope_value = record.send(scope_item)
-                  condition_sql << " AND " << attribute_condition("#{record.class.quoted_table_name}.#{scope_item}", scope_value)
-                  condition_params << scope_value
-                end
-              end
-
-              unless record.new_record?
-                if record.class.composite?
-                  record.class.primary_keys.each do |key|
-                    condition_sql << " AND #{record.class.quoted_table_name}.#{key} <> ?"
-                    condition_params << record.send(key)
-                  end
-                else
-                  condition_sql << " AND #{record.class.quoted_table_name}.#{record.class.primary_key} <> ?"
-                  condition_params << record.send(:id)
-                end
-              end
+        Array.wrap(options[:scope]).each do |scope_item|
+          scope_value = record.send(scope_item)
+          relation = relation.where(scope_item => scope_value)
+        end
 
-              finder_class.with_exclusive_scope do
-                if finder_class.exists?([condition_sql, *condition_params])
-                  record.errors.add(attr_name, :taken, :default => configuration[:message], :value => value)
-                end
-              end
+        unless record.new_record?
+          # CPK
+          if record.composite?
+            predicate = nil
+            record.ids_hash.each do |key, value|
+              neq = relation.table[key].not_eq(value)
+              predicate = predicate ? predicate.and(neq) : neq
             end
+            relation = relation.where(predicate)
+          else
+            # TODO : This should be in Arel
+            relation = relation.where("#{record.class.quoted_table_name}.#{record.class.primary_key} <> ?", record.send(:id))
           end
         end
+
+        if relation.exists?
+          record.errors.add(attribute, :taken, :default => options[:message], :value => value)
+        end
       end
     end
   end
 end
+
+#module CompositePrimaryKeys
+#  module ActiveRecord
+#    module Validations
+#      module Uniqueness
+#        module ClassMethods
+#          def validates_uniqueness_of(*attr_names)
+#            configuration = { :case_sensitive => true }
+#            configuration.update(attr_names.extract_options!)
+#
+#            validates_each(attr_names,configuration) do |record, attr_name, value|
+#              # The check for an existing value should be run from a class that
+#              # isn't abstract. This means working down from the current class
+#              # (self), to the first non-abstract class. Since classes don't know
+#              # their subclasses, we have to build the hierarchy between self and
+#              # the record's class.
+#              class_hierarchy = [record.class]
+#              while class_hierarchy.first != self
+#                class_hierarchy.insert(0, class_hierarchy.first.superclass)
+#              end
+#
+#              # Now we can work our way down the tree to the first non-abstract
+#              # class (which has a database table to query from).
+#              finder_class = class_hierarchy.detect { |klass| !klass.abstract_class? }
+#
+#              column = finder_class.columns_hash[attr_name.to_s]
+#
+#              if value.nil?
+#                comparison_operator = "IS ?"
+#              elsif column.text?
+#                comparison_operator = "#{connection.case_sensitive_equality_operator} ?"
+#                value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s
+#              else
+#                comparison_operator = "= ?"
+#              end
+#
+#              sql_attribute = "#{record.class.quoted_table_name}.#{connection.quote_column_name(attr_name)}"
+#
+#              if value.nil? || (configuration[:case_sensitive] || !column.text?)
+#                condition_sql = "#{sql_attribute} #{comparison_operator}"
+#                condition_params = [value]
+#              else
+#                condition_sql = "LOWER(#{sql_attribute}) #{comparison_operator}"
+#                condition_params = [value.mb_chars.downcase]
+#              end
+#
+#              if scope = configuration[:scope]
+#                Array(scope).map do |scope_item|
+#                  scope_value = record.send(scope_item)
+#                  condition_sql << " AND " << attribute_condition("#{record.class.quoted_table_name}.#{scope_item}", scope_value)
+#                  condition_params << scope_value
+#                end
+#              end
+#
+#              unless record.new_record?
+#                if record.class.composite?
+#                  record.class.primary_keys.each do |key|
+#                    condition_sql << " AND #{record.class.quoted_table_name}.#{key} <> ?"
+#                    condition_params << record.send(key)
+#                  end
+#                else
+#                  condition_sql << " AND #{record.class.quoted_table_name}.#{record.class.primary_key} <> ?"
+#                  condition_params << record.send(:id)
+#                end
+#              end
+#
+#              finder_class.with_exclusive_scope do
+#                if finder_class.exists?([condition_sql, *condition_params])
+#                  record.errors.add(attr_name, :taken, :default => configuration[:message], :value => value)
+#                end
+#              end
+#            end
+#          end
+#        end
+#      end
+#    end
+#  end
+#end