activerecord 1.0.0 → 2.0.0

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -0,0 +1,50 @@
+module ActiveRecord
+  module Associations
+    class BelongsToPolymorphicAssociation < AssociationProxy #:nodoc:
+      def replace(record)
+        if record.nil?
+          @target = @owner[@reflection.primary_key_name] = @owner[@reflection.options[:foreign_type]] = nil
+        else
+          @target = (AssociationProxy === record ? record.target : record)
+
+          unless record.new_record?
+            @owner[@reflection.primary_key_name] = record.id
+            @owner[@reflection.options[:foreign_type]] = record.class.base_class.name.to_s
+          end
+
+          @updated = true
+        end
+
+        loaded
+        record
+      end
+
+      def updated?
+        @updated
+      end
+
+      private
+        def find_target
+          return nil if association_class.nil?
+
+          if @reflection.options[:conditions]
+            association_class.find(
+              @owner[@reflection.primary_key_name], 
+              :conditions => conditions,
+              :include    => @reflection.options[:include]
+            )
+          else
+            association_class.find(@owner[@reflection.primary_key_name], :include => @reflection.options[:include])
+          end
+        end
+
+        def foreign_key_present
+          !@owner[@reflection.primary_key_name].nil?
+        end
+
+        def association_class
+          @owner[@reflection.options[:foreign_type]] ? @owner[@reflection.options[:foreign_type]].constantize : nil
+        end
+    end
+  end
+end

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -1,46 +1,164 @@
 module ActiveRecord
   module Associations
-    class HasAndBelongsToManyCollection < AssociationCollection #:nodoc:
-      def initialize(owner, association_name, association_class_name, association_class_primary_key_name, join_table, options)
-        super(owner, association_name, association_class_name, association_class_primary_key_name, options)
-        
-        @association_foreign_key = options[:association_foreign_key] || association_class_name.downcase + "_id"
-        association_table_name = options[:table_name] || @association_class.table_name(association_class_name)
-        @join_table = join_table
-        @order = options[:order] || "t.#{@owner.class.primary_key}"
-
-        @finder_sql = options[:finder_sql] ||
-              "SELECT t.* FROM #{association_table_name} t, #{@join_table} j " +
-              "WHERE t.#{@owner.class.primary_key} = j.#{@association_foreign_key} AND " +
-              "j.#{association_class_primary_key_name} = '#{@owner.id}' ORDER BY #{@order}"
+    class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
+      def initialize(owner, reflection)
+        super
+        construct_sql
       end
-        
-      def <<(record)
-        raise ActiveRecord::AssociationTypeMismatch unless @association_class === record
-        sql = @options[:insert_sql] || 
-            "INSERT INTO #{@join_table} (#{@association_class_primary_key_name}, #{@association_foreign_key}) " +
-            "VALUES ('#{@owner.id}', '#{record.id}')"
-        @owner.connection.execute(sql)
-        @collection_array << record unless @collection_array.nil?
+
+      def build(attributes = {})
+        load_target
+        build_record(attributes)
       end
-        
-      def delete(records)
-        records = duplicated_records_array(records)
-        sql = @options[:delete_sql] || "DELETE FROM #{@join_table} WHERE #{@association_class_primary_key_name} = '#{@owner.id}'"
-        ids = records.map { |record| "'" + record.id.to_s + "'" }.join(',')
-        @owner.connection.delete "#{sql} AND #{@association_foreign_key} in (#{ids})"
-        records.each {|record| @collection_array.delete(record) } unless @collection_array.nil?
+
+      def create(attributes = {})
+        create_record(attributes) { |record| insert_record(record) }
       end
-        
-      protected
-        def find_all_records
-          @association_class.find_by_sql(@finder_sql)
+      
+      def create!(attributes = {})
+        create_record(attributes) { |record| insert_record(record, true) }
+      end
+
+      def find_first
+        load_target.first
+      end
+
+      def find(*args)
+        options = args.extract_options!
+
+        # If using a custom finder_sql, scan the entire collection.
+        if @reflection.options[:finder_sql]
+          expects_array = args.first.kind_of?(Array)
+          ids = args.flatten.compact.uniq
+
+          if ids.size == 1
+            id = ids.first.to_i
+            record = load_target.detect { |record| id == record.id }
+            expects_array ? [record] : record
+          else
+            load_target.select { |record| ids.include?(record.id) }
+          end
+        else
+          conditions = "#{@finder_sql}"
+
+          if sanitized_conditions = sanitize_sql(options[:conditions])
+            conditions << " AND (#{sanitized_conditions})"
+          end
+
+          options[:conditions] = conditions
+          options[:joins]      = @join_sql
+          options[:readonly]   = finding_with_ambiguous_select?(options[:select] || @reflection.options[:select])
+
+          if options[:order] && @reflection.options[:order]
+            options[:order] = "#{options[:order]}, #{@reflection.options[:order]}"
+          elsif @reflection.options[:order]
+            options[:order] = @reflection.options[:order]
+          end
+
+          merge_options_from_reflection!(options)
+
+          options[:select] ||= (@reflection.options[:select] || '*')
+
+          # Pass through args exactly as we received them.
+          args << options
+          @reflection.klass.find(*args)
         end
-            
+      end
+
+      protected
         def count_records
-          load_collection_to_array
-          @collection_array.size
+          load_target.size
         end
-      end
+
+        def insert_record(record, force=true)
+          if record.new_record?
+            if force
+              record.save!
+            else
+              return false unless record.save
+            end
+          end
+
+          if @reflection.options[:insert_sql]
+            @owner.connection.execute(interpolate_sql(@reflection.options[:insert_sql], record))
+          else
+            columns = @owner.connection.columns(@reflection.options[:join_table], "#{@reflection.options[:join_table]} Columns")
+
+            attributes = columns.inject({}) do |attributes, column|
+              case column.name
+                when @reflection.primary_key_name
+                  attributes[column.name] = @owner.quoted_id
+                when @reflection.association_foreign_key
+                  attributes[column.name] = record.quoted_id
+                else
+                  if record.attributes.has_key?(column.name)
+                    value = @owner.send(:quote_value, record[column.name], column)
+                    attributes[column.name] = value unless value.nil?
+                  end
+              end
+              attributes
+            end
+
+            sql =
+              "INSERT INTO #{@reflection.options[:join_table]} (#{@owner.send(:quoted_column_names, attributes).join(', ')}) " +
+              "VALUES (#{attributes.values.join(', ')})"
+
+            @owner.connection.execute(sql)
+          end
+
+          return true
+        end
+
+        def delete_records(records)
+          if sql = @reflection.options[:delete_sql]
+            records.each { |record| @owner.connection.execute(interpolate_sql(sql, record)) }
+          else
+            ids = quoted_record_ids(records)
+            sql = "DELETE FROM #{@reflection.options[:join_table]} WHERE #{@reflection.primary_key_name} = #{@owner.quoted_id} AND #{@reflection.association_foreign_key} IN (#{ids})"
+            @owner.connection.execute(sql)
+          end
+        end
+
+        def construct_sql
+          interpolate_sql_options!(@reflection.options, :finder_sql)
+
+          if @reflection.options[:finder_sql]
+            @finder_sql = @reflection.options[:finder_sql]
+          else
+            @finder_sql = "#{@reflection.options[:join_table]}.#{@reflection.primary_key_name} = #{@owner.quoted_id} "
+            @finder_sql << " AND (#{conditions})" if conditions
+          end
+
+          @join_sql = "INNER JOIN #{@reflection.options[:join_table]} ON #{@reflection.klass.table_name}.#{@reflection.klass.primary_key} = #{@reflection.options[:join_table]}.#{@reflection.association_foreign_key}"
+        end
+
+        def construct_scope
+          { :find => {  :conditions => @finder_sql,
+                        :joins => @join_sql,
+                        :readonly => false,
+                        :order => @reflection.options[:order],
+                        :limit => @reflection.options[:limit] } }
+        end
+
+        # Join tables with additional columns on top of the two foreign keys must be considered ambiguous unless a select
+        # clause has been explicitly defined. Otherwise you can get broken records back, if, for example, the join column also has
+        # an id column. This will then overwrite the id column of the records coming back.
+        def finding_with_ambiguous_select?(select_clause)
+          !select_clause && @owner.connection.columns(@reflection.options[:join_table], "Join Table Columns").size != 2
+        end
+
+      private
+        def create_record(attributes)
+          # Can't use Base.create because the foreign key may be a protected attribute.
+          ensure_owner_is_not_new
+          if attributes.is_a?(Array)
+            attributes.collect { |attr| create(attr) }
+          else
+            record = build(attributes)
+            yield(record)
+            record
+          end
+        end
+    end
   end
-end
+end

data/lib/active_record/associations/has_many_association.rb

@@ -1,104 +1,174 @@
 module ActiveRecord
   module Associations
     class HasManyAssociation < AssociationCollection #:nodoc:
-      def initialize(owner, association_name, association_class_name, association_class_primary_key_name, options)
-        super(owner, association_name, association_class_name, association_class_primary_key_name, options)
-        @conditions = options[:conditions]
-        
-        if options[:finder_sql]
-          @counter_sql = options[:finder_sql].gsub(/SELECT (.*) FROM/, "SELECT COUNT(*) FROM")
-          @finder_sql = options[:finder_sql]
-        else
-          @counter_sql = "#{@association_class_primary_key_name} = '#{@owner.id}'#{@conditions ? " AND " + @conditions : ""}"
-          @finder_sql = "#{@association_class_primary_key_name} = '#{@owner.id}' #{@conditions ? " AND " + @conditions : ""}"   
-        end
-      end
-      
-      def <<(record)
-        raise ActiveRecord::AssociationTypeMismatch unless @association_class === record
-        record.send(@association_class_primary_key_name + "=", @owner.id)
-        record.save(false)
-        @collection_array << record unless @collection_array.nil?
-      end
- 
-      def delete(records)
-        duplicated_records_array(records).each do |record|
-          next if record.send(@association_class_primary_key_name) != @owner.id
-          record.send(@association_class_primary_key_name + "=", nil)
-          record.save(false)
-          @collection_array.delete(record) unless @collection_array.nil?
-        end
-      end
-      
-      def create(attributes = {})
-        # We can't use the regular Base.create method as the foreign key might be a protected attribute, hence the repetion
-        record = @association_class.new(attributes || {})
-        record.send(@association_class_primary_key_name + "=", @owner.id)
-        record.save
-
-        @collection_array << record unless @collection_array.nil?
-        
-        return record
+      def initialize(owner, reflection)
+        super
+        construct_sql
       end
 
       def build(attributes = {})
-        association = @association_class.new
-        association.attributes = attributes.merge({ "#{@association_class_primary_key_name}" => @owner.id})
-        association
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| build(attr) }
+        else
+          build_record(attributes) { |record| set_belongs_to_association_for(record) }
+        end
       end
-      
-      def find_all(runtime_conditions = nil, orderings = nil, limit = nil, joins = nil, &block)
-        if block_given? || @options[:finder_sql]
-          load_collection_to_array
-          @collection_array.send(:find_all, &block)
+
+      # Count the number of associated records. All arguments are optional.
+      def count(*args)
+        if @reflection.options[:counter_sql]
+          @reflection.klass.count_by_sql(@counter_sql)
+        elsif @reflection.options[:finder_sql]
+          @reflection.klass.count_by_sql(@finder_sql)
         else
-          @association_class.find_all(
-              "#{@association_class_primary_key_name} = '#{@owner.id}' " +
-              "#{@conditions ? " AND " + @conditions : ""} #{runtime_conditions ? " AND " + runtime_conditions : ""}",
-              orderings, 
-              limit, 
-              joins
-            )
+          column_name, options = @reflection.klass.send(:construct_count_options_from_args, *args)          
+          options[:conditions] = options[:conditions].nil? ?
+            @finder_sql :
+            @finder_sql + " AND (#{sanitize_sql(options[:conditions])})"
+          options[:include] ||= @reflection.options[:include]
+
+          @reflection.klass.count(column_name, options)
         end
       end
 
-      def find(association_id = nil, &block)
-        if block_given? || @options[:finder_sql]
-          load_collection_to_array
-          return @collection_array.send(:find, &block)
+      def find(*args)
+        options = args.extract_options!
+
+        # If using a custom finder_sql, scan the entire collection.
+        if @reflection.options[:finder_sql]
+          expects_array = args.first.kind_of?(Array)
+          ids           = args.flatten.compact.uniq.map(&:to_i)
+
+          if ids.size == 1
+            id = ids.first
+            record = load_target.detect { |record| id == record.id }
+            expects_array ? [ record ] : record
+          else
+            load_target.select { |record| ids.include?(record.id) }
+          end
         else
-          @association_class.find_on_conditions(
-              association_id, "#{@association_class_primary_key_name} = '#{@owner.id}' #{@conditions ? " AND " + @conditions : ""}"
-            )
+          conditions = "#{@finder_sql}"
+          if sanitized_conditions = sanitize_sql(options[:conditions])
+            conditions << " AND (#{sanitized_conditions})"
+          end
+          options[:conditions] = conditions
+
+          if options[:order] && @reflection.options[:order]
+            options[:order] = "#{options[:order]}, #{@reflection.options[:order]}"
+          elsif @reflection.options[:order]
+            options[:order] = @reflection.options[:order]
+          end
+
+          merge_options_from_reflection!(options)
+
+          # Pass through args exactly as we received them.
+          args << options
+          @reflection.klass.find(*args)
         end
       end
-      
+
       protected
-        def find_all_records
-          if @options[:finder_sql]
-            @association_class.find_by_sql(@finder_sql)
-          else
-            @association_class.find_all(@finder_sql, @options[:order] ? @options[:order] : nil)
+        def load_target
+          if !@owner.new_record? || foreign_key_present
+            begin
+              if !loaded?
+                if @target.is_a?(Array) && @target.any?
+                  @target = (find_target + @target).uniq
+                else
+                  @target = find_target
+                end
+              end
+            rescue ActiveRecord::RecordNotFound
+              reset
+            end
           end
+
+          loaded if target
+          target
         end
-        
+
         def count_records
-          if has_cached_counter?
+          count = if has_cached_counter?
             @owner.send(:read_attribute, cached_counter_attribute_name)
-          elsif @options[:finder_sql]
-            @association_class.count_by_sql(@counter_sql)
+          elsif @reflection.options[:counter_sql]
+            @reflection.klass.count_by_sql(@counter_sql)
           else
-            @association_class.count(@counter_sql)
+            @reflection.klass.count(:conditions => @counter_sql, :include => @reflection.options[:include])
+          end
+          
+          @target = [] and loaded if count == 0
+          
+          if @reflection.options[:limit]
+            count = [ @reflection.options[:limit], count ].min
           end
+          
+          return count
         end
-        
+
         def has_cached_counter?
           @owner.attribute_present?(cached_counter_attribute_name)
         end
-        
+
         def cached_counter_attribute_name
-          @association_name + "_count"
+          "#{@reflection.name}_count"
+        end
+
+        def insert_record(record)
+          set_belongs_to_association_for(record)
+          record.save
+        end
+
+        def delete_records(records)
+          case @reflection.options[:dependent]
+            when :destroy
+              records.each(&:destroy)
+            when :delete_all
+              @reflection.klass.delete(records.map(&:id))
+            else
+              ids = quoted_record_ids(records)
+              @reflection.klass.update_all(
+                "#{@reflection.primary_key_name} = NULL", 
+                "#{@reflection.primary_key_name} = #{@owner.quoted_id} AND #{@reflection.klass.primary_key} IN (#{ids})"
+              )
+          end
+        end
+
+        def target_obsolete?
+          false
+        end
+
+        def construct_sql
+          case
+            when @reflection.options[:finder_sql]
+              @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
+
+            when @reflection.options[:as]
+              @finder_sql = 
+                "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_id = #{@owner.quoted_id} AND " + 
+                "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
+              @finder_sql << " AND (#{conditions})" if conditions
+            
+            else
+              @finder_sql = "#{@reflection.klass.table_name}.#{@reflection.primary_key_name} = #{@owner.quoted_id}"
+              @finder_sql << " AND (#{conditions})" if conditions
+          end
+
+          if @reflection.options[:counter_sql]
+            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
+          elsif @reflection.options[:finder_sql]
+            # replace the SELECT clause with COUNT(*), preserving any hints within /* ... */
+            @reflection.options[:counter_sql] = @reflection.options[:finder_sql].sub(/SELECT (\/\*.*?\*\/ )?(.*)\bFROM\b/im) { "SELECT #{$1}COUNT(*) FROM" }
+            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
+          else
+            @counter_sql = @finder_sql
+          end
+        end
+
+        def construct_scope
+          create_scoping = {}
+          set_belongs_to_association_for(create_scoping)
+          { :find => { :conditions => @finder_sql, :readonly => false, :order => @reflection.options[:order], :limit => @reflection.options[:limit] }, :create => create_scoping }
         end
     end
   end
-end
+end