composite_primary_keys 3.1.11 → 4.0.0.beta1

data/lib/composite_primary_keys/composite_predicates.rb

@@ -0,0 +1,53 @@
+module CompositePrimaryKeys
+  module Predicates
+    def cpk_and_predicate(predicates)
+      if predicates.length == 1
+        predicates.first
+      else
+        Arel::Nodes::And.new(predicates)
+      end
+    end
+    
+    def cpk_or_predicate(predicates)
+      result = predicates.shift
+      predicates.each do |predicate|
+        result = result.or(predicate)
+      end
+      result
+    end
+
+    def cpk_id_predicate(table, keys, values)
+      eq_predicates = keys.zip(values).map do |key, value|
+        table[key].eq(value)
+      end
+      cpk_and_predicate(eq_predicates)
+    end
+
+    def cpk_join_predicate(table1, key1, table2, key2)
+      key1_fields = Array(key1).map {|key| table1[key]}
+      key2_fields = Array(key2).map {|key| table2[key]}
+
+      eq_predicates = key1_fields.zip(key2_fields).map do |key_field1, key_field2|
+        key_field1.eq(key_field2)
+      end
+      cpk_and_predicate(eq_predicates)
+    end
+
+    def cpk_in_predicate(table, primary_keys, ids)
+      and_predicates = ids.map do |id_set|
+        eq_predicates = Array(primary_keys).zip(Array(id_set)).map do |primary_key, value|
+          table[primary_key].eq(value)
+        end
+        cpk_and_predicate(eq_predicates)
+      end
+
+      cpk_or_predicate(and_predicates)
+    end
+  end
+end
+
+ActiveRecord::Associations::AssociationScope.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::HasAndBelongsToManyAssociation.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::JoinDependency::JoinAssociation.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::Preloader::Association.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Relation.send(:include, CompositePrimaryKeys::Predicates)

data/lib/composite_primary_keys/connection_adapters/abstract_adapter.rb

@@ -1,9 +1,11 @@
 module ActiveRecord
-  module ConnectionAdapters # :nodoc:
+  module ConnectionAdapters
     class AbstractAdapter
-      def concat(*columns)
-        "CONCAT(#{columns.join(',')})"
+      def quote_column_names(name)
+        Array(name).map do |col|
+          quote_column_name(col.to_s)
+        end.join(CompositePrimaryKeys::ID_SEP)
       end
     end
   end
-end
+end

data/lib/composite_primary_keys/connection_adapters/postgresql_adapter.rb

@@ -1,52 +1,30 @@
 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
-
-      def concat(*columns)
-        columns = columns.map { |c| "CAST(#{c} AS varchar)" }
-        "(#{columns.join('||')})"
-      end
-      
-      # Executes an INSERT query and returns the new record's ID
-      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+    class PostgreSQLAdapter
+      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
         # Extract the table from the insert sql. Yuck.
-        table = sql.split(" ", 4)[2].gsub('"', '')
+        _, table = extract_schema_and_table(sql.split(" ", 4)[2])
 
-        # Try an insert with 'returning id' if available (PG >= 8.2)
-        if supports_insert_with_returning?
-          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(CompositePrimaryKeys::ID_SEP)
-                        else
-                          quote_column_name(pk)
-                        end
-            id = select_value("#{sql} RETURNING #{quoted_pk}")
-            clear_query_cache
-            return id
-          end
-        end
+        pk ||= primary_key(table)
 
-        # Otherwise, insert then grab last_insert_id.
-        if insert_id = super
-          insert_id
+        if pk
+          select_value("#{sql} RETURNING #{quote_column_names(pk)}")
         else
-          # If neither pk nor sequence name is given, look them up.
-          unless pk || sequence_name
-            pk, sequence_name = *pk_and_sequence_for(table)
-          end
+          super
+        end
+      end
+      alias :create :insert
+
+      def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+        unless pk
+          _, table = extract_schema_and_table(sql.split(" ", 4)[2])
 
-          # If a pk is given, fallback to default sequence name.
-          # Don't fetch last insert id for a table without a pk.
-          if pk && sequence_name ||= default_sequence_name(table, pk)
-            last_insert_id(table, sequence_name)
-          end
+          pk = primary_key(table)
         end
+
+        sql = "#{sql} RETURNING #{quote_column_names(pk)}" if pk
+
+        [sql, binds]
       end
     end
   end

data/lib/composite_primary_keys/fixtures.rb

@@ -1,9 +1,22 @@
-class Fixture
-  def [](key)
-    if key.is_a? Array
-      key.map { |a_key| self[a_key.to_s] }
-    else
-      @fixture[key]
+module ActiveRecord
+  class Fixture
+    def find
+      if model_class
+        # CPK
+        # model_class.find(fixture[model_class.primary_key])
+        ids = self.ids(model_class.primary_key)
+        model_class.find(ids)
+      else
+        raise FixtureClassNotFound, "No class attached to find."
+      end
+    end
+
+    def ids(key)
+      if key.is_a? Array
+        key.map {|a_key| fixture[a_key.to_s] }
+      else
+        fixture[key]
+      end
     end
   end
 end

data/lib/composite_primary_keys/persistence.rb

@@ -1,17 +1,30 @@
 module ActiveRecord
   module Persistence
-    def cpk_conditions
-      if self.composite?
-        ids_hash
-      else
-        self.class.arel_table[self.class.primary_key].eq(id)
-      end
-    end
-
     def destroy
       if persisted?
-        # self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).delete_all
-        self.class.unscoped.where(cpk_conditions).delete_all
+        ::ActiveRecord::IdentityMap.remove(self) if ::ActiveRecord::IdentityMap.enabled?
+
+        # CPK
+        #pk         = self.class.primary_key
+        #column     = self.class.columns_hash[pk]
+        #substitute = connection.substitute_at(column, 0)
+        primary_keys = Array(self.class.primary_key)
+        bind_values = Array.new
+        eq_predicates = Array.new
+        primary_keys.each_with_index do |key, i|
+          column = self.class.columns_hash[key.to_s]
+          bind_values << [column, self[key]]
+          substitute = connection.substitute_at(column, i)
+          eq_predicates << self.class.arel_table[key].eq(substitute)
+        end
+        predicate = Arel::Nodes::And.new(eq_predicates)
+        relation = self.class.unscoped.where(predicate)
+
+        # CPK
+        #relation.bind_values = [[column, id]]
+        relation.bind_values = bind_values
+
+        relation.delete_all
       end
 
       @destroyed = true
@@ -21,9 +34,15 @@ module ActiveRecord
     def update(attribute_names = @attributes.keys)
       attributes_with_values = arel_attributes_values(false, false, attribute_names)
       return 0 if attributes_with_values.empty?
+      klass = self.class
       # CPK
-      # self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).arel.update(attributes_with_values)
-      self.class.unscoped.where(cpk_conditions).arel.update(attributes_with_values)
+      if !self.composite?
+        stmt = klass.unscoped.where(klass.arel_table[klass.primary_key].eq(id)).arel.compile_update(attributes_with_values)
+      else
+        # CPK
+        stmt =  klass.unscoped.where(ids_hash).arel.compile_update(attributes_with_values)
+      end
+      klass.connection.update stmt.to_sql
     end
   end
-end
+end

data/lib/composite_primary_keys/relation.rb

@@ -1,20 +1,15 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module Relation
-      module InstanceMethods
-        def where_cpk_id(id)
-          relation = clone
-
-          predicates = self.primary_keys.zip(Array(id)).map do |key, value|
-            table[key].eq(value)
-          end
-          relation.where_values += predicates
-          relation
-        end
+module ActiveRecord
+  class Relation
+    def add_cpk_support
+      class << self
+        include CompositePrimaryKeys::ActiveRecord::Calculations
+        include CompositePrimaryKeys::ActiveRecord::FinderMethods
+        include CompositePrimaryKeys::ActiveRecord::QueryMethods
 
         def delete(id_or_array)
+          ::ActiveRecord::IdentityMap.remove_by_id(self.symbolized_base_class, id_or_array) if ::ActiveRecord::IdentityMap.enabled?
           # CPK
-          # where(@klass.primary_key => id_or_array).delete_all
+          # where(primary_key => id_or_array).delete_all
 
           id_or_array = if id_or_array.kind_of?(CompositePrimaryKeys::CompositeKeys)
             [id_or_array]
@@ -23,7 +18,7 @@ module CompositePrimaryKeys
           end
 
           id_or_array.each do |id|
-            where_cpk_id(id).delete_all
+            where(cpk_id_predicate(table, self.primary_key, id)).delete_all
           end
         end
 
@@ -41,12 +36,24 @@ module CompositePrimaryKeys
           end
 
           id_or_array.each do |id|
-            where_cpk_id(id).each do |record|
+            where(cpk_id_predicate(table, self.primary_key, id)).each do |record|
               record.destroy
             end
           end
         end
       end
     end
+
+    alias :initialize_cpk :initialize
+    def initialize(klass, table)
+      initialize_cpk(klass, table)
+      add_cpk_support if klass.composite?
+    end
+
+    alias :initialize_copy_cpk :initialize_copy
+    def initialize_copy(other)
+      initialize_copy_cpk(other)
+      add_cpk_support if klass.composite?
+    end
   end
 end

data/lib/composite_primary_keys/relation/calculations.rb

@@ -0,0 +1,48 @@
+module CompositePrimaryKeys
+  module ActiveRecord
+    module Calculations
+      def execute_simple_calculation(operation, column_name, distinct)
+        # Postgresql doesn't like ORDER BY when there are no GROUP BY
+        relation = reorder(nil)
+
+        # CPK
+        #if operation == "count" && (relation.limit_value || relation.offset_value)
+        if operation == "count"
+          # Shortcut when limit is zero.
+          return 0 if relation.limit_value == 0
+
+          query_builder = build_count_subquery(relation, column_name, distinct)
+        else
+          column = aggregate_column(column_name)
+
+          select_value = operation_over_aggregate_column(column, operation, distinct)
+
+          relation.select_values = [select_value]
+
+          query_builder = relation.arel
+        end
+
+        type_cast_calculated_value(@klass.connection.select_value(query_builder.to_sql), column_for(column_name), operation)
+      end
+
+      def build_count_subquery(relation, column_name, distinct)
+        # CPK
+        # column_alias = Arel.sql('count_column')
+        subquery_alias = Arel.sql('subquery_for_count')
+
+        # CPK
+        # aliased_column = aggregate_column(column_name == :all ? 1 : column_name).as(column_alias)
+        # relation.select_values = [aliased_column]
+        column = aggregate_column(column_name)
+        relation.select_values = ["DISTINCT #{column.to_s}"]
+        subquery = relation.arel.as(subquery_alias)
+
+        sm = Arel::SelectManager.new relation.engine
+        # CPK
+        # select_value = operation_over_aggregate_column(column_alias, 'count', distinct)
+        select_value = operation_over_aggregate_column(Arel.sql("*"), 'count', false)
+        sm.project(select_value).from(subquery)
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/relation/finder_methods.rb

@@ -0,0 +1,117 @@
+module CompositePrimaryKeys
+  module ActiveRecord
+    module FinderMethods
+      def construct_limited_ids_condition(relation)
+        orders = relation.order_values
+        # CPK
+        # values = @klass.connection.distinct("#{@klass.connection.quote_table_name table_name}.#{primary_key}", orders)
+        keys = @klass.primary_keys.map do |key|
+          "#{@klass.connection.quote_table_name @klass.table_name}.#{key}"
+        end
+        values = @klass.connection.distinct(keys.join(', '), orders)
+
+        relation = relation.dup
+
+        ids_array = relation.select(values).collect {|row| row[primary_key]}
+        # CPK
+        # ids_array.empty? ? raise(ThrowResult) : table[primary_key].in(ids_array)
+
+        # OR together each and expression (key=value and key=value) that matches an id set
+        # since we only need to match 0 or more records
+        or_expressions = ids_array.map do |id_set|
+          # AND together "key=value" exprssios to match each id set
+          and_expressions = [self.primary_keys, id_set].transpose.map do |key, id|
+            table[key].eq(id)
+          end
+          Arel::Nodes::And.new(and_expressions)
+        end
+
+        first = or_expressions.shift
+        Arel::Nodes::Grouping.new(or_expressions.inject(first) do |memo, expr|
+            Arel::Nodes::Or.new(memo, expr)
+        end)
+      end
+
+      def exists?(id = nil)
+        # ID can be:
+        #   Array - ['department_id = ? and location_id = ?', 1, 1]
+        #   Array -> [1,2]
+        #   CompositeKeys -> [1,2]
+
+        id = id.id if ::ActiveRecord::Base === id
+
+        join_dependency = construct_join_dependency_for_association_find
+        relation = construct_relation_for_association_find(join_dependency)
+        relation = relation.except(:select).select("1").limit(1)
+
+        # CPK
+        #case id
+        #when Array, Hash
+        #  relation = relation.where(id)
+        #else
+        #  relation = relation.where(table[primary_key].eq(id)) if id
+        #end
+
+        case id
+        when CompositePrimaryKeys::CompositeKeys
+          relation = relation.where(cpk_id_predicate(table, primary_key, id))
+        when Array
+          if !id.first.kind_of?(String)
+            return self.exists?(id.to_composite_keys)
+          else
+            relation = relation.where(id)
+          end
+        when Hash
+          relation = relation.where(id)
+        end
+        connection.select_value(relation.to_sql) ? true : false
+      end
+
+      def find_with_ids(*ids, &block)
+        return to_a.find { |*block_args| yield(*block_args) } if block_given?
+
+        # Supports:
+        #   find('1,2')             ->  ['1,2']
+        #   find(1,2)               ->  [1,2]
+        #   find([1,2])             -> [['1,2']]
+        #   find([1,2], [3,4])      -> [[1,2],[3,4]]
+        #
+        # Does *not* support:
+        #   find('1,2', '3,4')      ->  ['1,2','3,4']
+
+        # Normalize incoming data.  Note the last arg can be nil.  Happens
+        # when find is called with nil options like the reload method does.
+        ids.compact!
+        ids = [ids] unless ids.first.kind_of?(Array)
+
+        results = ids.map do |cpk_ids|
+          cpk_ids = if cpk_ids.length == 1
+            cpk_ids.first.split(CompositePrimaryKeys::ID_SEP).to_composite_keys
+          else
+            cpk_ids.to_composite_keys
+          end
+
+          unless cpk_ids.length == @klass.primary_keys.length
+            raise "#{cpk_ids.inspect}: Incorrect number of primary keys for #{@klass.name}: #{@klass.primary_keys.inspect}"
+          end
+
+          new_relation = clone
+          [@klass.primary_keys, cpk_ids].transpose.map do |key, id|
+            new_relation = new_relation.where(key => id)
+          end
+
+          records = new_relation.to_a
+
+          if records.empty?
+            conditions = new_relation.arel.where_sql
+            raise(::ActiveRecord::RecordNotFound,
+                  "Couldn't find #{@klass.name} with ID=#{cpk_ids} #{conditions}")
+          end
+          records
+        end.flatten
+
+        ids.length == 1 ? results.first : results
+      end
+    end
+  end
+end