Changeset 8054

Timestamp:

10/29/07 21:39:52 (1 year ago)

Author:

bitsweat

Message:

Introduce finder :joins with associations. Same :include syntax but with inner rather than outer joins. Closes #10012.

Files:

• trunk/activerecord/CHANGELOG (modified) (1 diff)
• trunk/activerecord/lib/active_record/associations.rb (modified) (12 diffs)
• trunk/activerecord/lib/active_record/base.rb (modified) (5 diffs)
• trunk/activerecord/lib/active_record/calculations.rb (modified) (4 diffs)
• trunk/activerecord/test/associations/ar_joins_test.rb (added)

trunk/activerecord/CHANGELOG

@@ -1 +1 @@
-*SVN*
+
+* Introduce finder :joins with associations. Same :include syntax but with inner rather than outer joins.  #10012 [RubyRedRick]
+    # Find users with an avatar
+    User.find(:all, :joins => :avatar)
+
+    # Find posts with a high-rated comment.
+    Post.find(:all, :joins => :comments, :conditions => 'comments.rating > 3')
-
-* Associations: speedup duplicate record check.  #10011 [lifofifo]

trunk/activerecord/lib/active_record/associations.rb

@@ -487 +487 @@
-    # When eager loaded, conditions are interpolated in the context of the model class, not the model instance.  Conditions are lazily interpolated
-    # before the actual model exists.
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    # == Table Aliasing
-    #
@@ -1122 +1178 @@
-        def find_with_associations(options = {})
-          catch :invalid_query do
-
+
+
+
+
+
+
+
-            rows = select_all_rows(options, join_dependency)
-            return join_dependency.instantiate(rows)
@@ -1376 +1438 @@
-          attr_reader :joins, :reflections, :table_aliases
-
-
+, ar_joins = nil
-            @joins                 = [JoinBase.new(base, joins)]
+            @ar_joins              = ar_joins
-            @associations          = associations
-            @reflections           = []
@@ -1401 +1464 @@
-                @base_records_in_order << (@base_records_hash[primary_id] = join_base.instantiate(row))
-              end
-
-
-
+ unless @ar_joins
+
+ unless @ar_joins
-            return @base_records_in_order
-          end
@@ -1445 +1508 @@
-                  raise ConfigurationError, "Association named '#{ associations }' was not found; perhaps you misspelled it?"
-                  @reflections << reflection
-JoinAssociation
+(@ar_joins ? ARJoinAssociation : JoinAssociation)
-                when Array
-                  associations.each do |association|
@@ -1596 +1659 @@
-              join = case reflection.macro
-                when :has_and_belongs_to_many
-LEFT OUTER JOIN
+#{join_type}
-                     table_alias_for(options[:join_table], aliased_join_table_name),
-                     aliased_join_table_name,
-                     options[:foreign_key] || reflection.active_record.to_s.foreign_key,
-                     parent.aliased_table_name, reflection.active_record.primary_key] +
-LEFT OUTER JOIN
+#{join_type}
-                     table_name_and_alias, aliased_table_name, klass.primary_key,
-                     aliased_join_table_name, options[:association_foreign_key] || klass.to_s.foreign_key
@@ -1659 +1722 @@
-                      end
-
-LEFT OUTER JOIN
+#{join_type}
-                        table_alias_for(through_reflection.klass.table_name, aliased_join_table_name),
-                        parent.aliased_table_name, reflection.active_record.connection.quote_column_name(parent.primary_key),
@@ -1665 +1728 @@
-                        jt_as_extra, jt_source_extra, jt_sti_extra
-                      ] +
-LEFT OUTER JOIN
+#{join_type}
-                        table_name_and_alias, 
-                        aliased_table_name, reflection.active_record.connection.quote_column_name(first_key),
@@ -1673 +1736 @@
-
-                    when reflection.options[:as] && [:has_many, :has_one].include?(reflection.macro)
-LEFT OUTER JOIN
+#{join_type}
-                        table_name_and_alias,
-                        aliased_table_name, "#{reflection.options[:as]}_id",
@@ -1682 +1745 @@
-                    else
-                      foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key
-LEFT OUTER JOIN
+#{join_type}
-                        table_name_and_alias,
-                        aliased_table_name, foreign_key,
@@ -1689 +1752 @@
-                  end
-                when :belongs_to
-LEFT OUTER JOIN
+#{join_type}
-                     table_name_and_alias, aliased_table_name, reflection.klass.primary_key,
-                     parent.aliased_table_name, options[:foreign_key] || klass.to_s.foreign_key
@@ -1724 +1787 @@
-              def interpolate_sql(sql)
-                instance_eval("%@#{sql.gsub('@', '\@')}@") 
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-          end
-        end

trunk/activerecord/lib/active_record/base.rb

@@ -381 +381 @@
-      # * <tt>:limit</tt>: An integer determining the limit on the number of rows that should be returned.
-      # * <tt>:offset</tt>: An integer determining the offset from where the rows should be fetched. So at 5, it would skip rows 0 through 4.
-
-
+
+
+
-      #   Pass :readonly => false to override.
+      #   See adding joins for associations under Association.
-      # * <tt>:include</tt>: Names associations that should be loaded alongside using LEFT OUTER JOINs. The symbols named refer
-      #   to already defined associations. See eager loading under Associations.
@@ -429 +431 @@
-      def find(*args)
-        options = args.extract_options!
+        # Note:  we extract any :joins option with a non-string value from the options, and turn it into
+        #  an internal option :ar_joins.  This allows code called from her to find the ar_joins, and
+        #  it bypasses marking the result as read_only.
+        #  A normal string join marks the result as read-only because it contains attributes from joined tables
+        #  which are not in the base table and therefore prevent the result from being saved.
+        #  In the case of an ar_join, the JoinDependency created to instantiate the results eliminates these
+        #  bogus attributes.  See JoinDependency#instantiate, and JoinBase#instantiate in associations.rb.
+        options, ar_joins = *extract_ar_join_from_options(options)
-        validate_find_options(options)
-        set_readonly_option!(options)
+        options[:ar_joins] = ar_joins if ar_joins
-
-        case args.first
@@ -1021 +1032 @@
-        end
-
+        # If options contains :joins, with a non-string value
+        #  remove it from options
+        # return the updated or unchanged options, and the ar_join value or nil
+        def extract_ar_join_from_options(options)
+          new_options = options.dup
+          join_option = new_options.delete(:joins)
+          (join_option && !join_option.kind_of?(String)) ? [new_options, join_option] : [options, nil]
+        end
+
-        def find_every(options)
-
+|| scoped?(:find, :ar_joins) || (options[:ar_joins]) 
-            find_with_associations(options) : 
-            find_by_sql(construct_finder_sql(options))
@@ -1446 +1466 @@
-          if f = method_scoping[:find]
-            f.assert_valid_keys(VALID_FIND_OPTIONS)
+            # see note about :joins and :ar_joins in ActiveRecord::Base#find
+            f, ar_joins = *extract_ar_join_from_options(f)
-            set_readonly_option! f
+            if ar_joins
+              f[:ar_joins] = ar_joins
+              method_scoping[:find] = f
+            end
-          end
-
@@ -1459 +1485 @@
-                      if key == :conditions && merge
-                        hash[method][key] = [params[key], hash[method][key]].collect{ |sql| "( %s )" % sanitize_sql(sql) }.join(" AND ")
-key == :include
+([:include, :ar_joins].include?(key))
-                        hash[method][key] = merge_includes(hash[method][key], params[key]).uniq
-                      else

trunk/activerecord/lib/active_record/calculations.rb

@@ -16 +16 @@
-      #
-      # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro.
-
-
+
+
+
+
+
-      # * <tt>:include</tt>: Named associations that should be loaded alongside using LEFT OUTER JOINs. The symbols named refer
-      #   to already defined associations. When using named associations count returns the number DISTINCT items for the model you're counting.
@@ -110 +113 @@
-      #   Person.minimum(:age, :having => 'min(age) > 17', :group => :last_name) # Selects the minimum age for any family without any minors
-      def calculate(operation, column_name, options = {})
+        options, ar_joins = *extract_ar_join_from_options(options)
-        validate_calculation_options(operation, options)
+        options[:ar_joins] = ar_joins if ar_joins
-        column_name     = options[:select] if options[:select]
-        column_name     = '*' if column_name == :all
@@ -150 +155 @@
-          options = options.symbolize_keys
-
-
+
+
+
+
+
+
-          merged_includes = merge_includes(scope ? scope[:include] : [], options[:include])
+          merged_includes = merge_includes(merged_includes, options[:ar_joins])
-          aggregate_alias = column_alias_for(operation, column_name)
-
@@ -174 +185 @@
-          sql << " FROM #{table_name} "
-          if merged_includes.any?
-
+, options[:ar_joins]
-            sql << join_dependency.join_associations.collect{|join| join.association_join }.join
-          end