:include loads all columns, overriding :select

with_scope is not even required to verifiy this bug, this is enough

class DocumentCategory < ActiveRecord::Base

has_many :documents, :select => "id, title, filename, tag, size"

validates_presence_of :name, :project validates_uniqueness_of :name, :scope => 'project_id' validates_length_of :name, :maximum => 255

end

@categories = DocumentCategory.find(:all, :conditions => ['project_id = ?', @project.id], :include => 'documents')

this will perform the following query:

DocumentCategory Load Including Associations (7.225554) SELECT document_categories."id" AS t0_r0, document_categories."name" AS t0_r1, document_categories."project_id" AS t0_r2, documents."id" AS t1_r0, documents."created_at" AS t1_r1, documents."updated_at" AS t1_r2, documents."creator_id" AS t1_r3, documents."modifier_id" AS t1_r4, documents."data" AS t1_r5, documents."tag" AS t1_r6, documents."title" AS t1_r7, documents."filename" AS t1_r8, documents."content_type" AS t1_r9, documents."size" AS t1_r10, documents."document_category_id" AS t1_r11 FROM document_categories LEFT OUTER JOIN documents ON documents.document_category_id = document_categories.id WHERE (project_id = 8)

which is obviously a problem, particularly in this case where one of the columns is binary

It looks like changing the second line of construct_finder_sql_with_included_associations from this:

sql = "SELECT #{column_aliases(join_dependency)} FROM #{(scope && scope[:from]) || options[:from] || table_name} "

to this:

sql = "SELECT #{options[:select] || column_aliases(join_dependency)} FROM #{(scope && scope[:from]) || options[:from] || table_name} "

will fix the problem. I apologize, but I don't have the time to come up with a decent unit test--perhaps someone more directly affected by this bug could do that.

Wait, no, that last bit kills a bunch of unit tests. I'm not sure if this is possible.

It appears that this :include bug has several effects. Also overridden is :finder_sql.

In case it helps anyone else, here is a workaround that works for me. I don't understand this code well enough to know what other features this might have broken.

module ActiveRecord
  module Associations
  	module ClassMethods
  	
  	    def find_with_associations(options = {})
          catch :invalid_query do
            join_dependency = JoinDependency.new(self, merge_includes(scope(:find, :include), options[:include]), options[:joins])
            rows = select_all_rows(options, join_dependency)
            
            if options[:select]
            	return rows.collect! { |record| instantiate(record) }
            else
            	return join_dependency.instantiate(rows)
            end
          end
          []
        end
  	
        def construct_finder_sql_with_included_associations(options, join_dependency)
          scope = scope(:find)
          sql = "SELECT #{options[:select] || column_aliases(join_dependency)} FROM #{(scope && scope[:from]) || options[:from] || table_name} "
          sql << join_dependency.join_associations.collect{|join| join.association_join }.join
 
          add_joins!(sql, options, scope)
          add_conditions!(sql, options[:conditions], scope)
          add_limited_ids_condition!(sql, options, join_dependency) if !using_limitable_reflections?(join_dependency.reflections) && options[:limit]

          sql << "GROUP BY #{options[:group]} " if options[:group]
          sql << "ORDER BY #{options[:order]} " if options[:order]
 
          add_limit!(sql, options, scope) if using_limitable_reflections?(join_dependency.reflections)
 
          return sanitize_sql(sql)
        end
    end
  end
end

I've attached a patch proposal options_select_working_with_eager_loading.diff

It works with :select => 'table_x.col_a, table_y.col_n' don't work with * wildcard, in this case it will fall back on the current behaviour (:select ignored) id (primary keys) will be always extracted from the db for any model included. This patch passes all the tests + the new one introduced with this patch itself. I can put some more work on this if necessary please let me know if this approach seems reasonable enough to be included in the actual framework.

thanks

I've submitted the same patch

options_select_working_with_eager_loading.diff

as patch #7147

-Any reactions on the patch? On our database, we are otherwise faced with (a) hitting the database with hundreds of queries every time we look at an index, (b) load the returning data with 120 megs of text data which we don't need when we just want to show an index or (c) writing our own sql [which is what the current program does]

I've been using this patch with good results.

I had an issue which stopped me from using it:

It only allows you to :select existing columns, you can't use any functions on them.

tmacedo, I doubt that is related to the patch, but rather to how you were using the functions.

Replying to tmacedo:

I had an issue which stopped me from using it: It only allows you to :select existing columns, you can't use any functions on them.

Yes, you're right, the patch only allows to select on existing columns and you can not apply any database function to them. The reason is, in theory is possible to include more than once the same table and things get really tricky in this case if you want to correctly handle functions.

The patch doesn't even allow to use the * but this could be easily fixed.

Allowing table.* would be most useful.

Hi I posted in #7147 a new version of the patch that allow the use of the * symbol. Now the code is a bit less clunky. All activerecord tests are successfull.

If someone is interested I released patch #7147 as a gem to make more easy to test the patch in real word applications.

the gem is select_with_include available from rubyforge

more details at

http://assertbuggy.blogspot.com/2007/05/activerecord-select-with-include.html

I closed this because it's being tracked in #7147, and it doesn't look like this is getting fixed (it would require a full select parser). You can get the desired behavior (including full select parsing) by installing the rparsec gem and the parsing plugin from http://cfis.savagexi.com/files/select_parser.zip