Hash for ActiveRecord's select

Is it possible to pass a Hash as a parameter for the ActiveRecord's select? I mean like this (here I have simple model: LineItem has id's of Product and Order):

Product.select(
    :orders => [{:name => :buyer}, :email], # orders.name as buyer
    :products => {:title => :product}).     # products.title as product
  joins(:line_items => :order)

To get the following SQL:

SELECT "orders"."name" as "buyer", "orders"."email", "products"."title" as "product" 
FROM "products"
INNER JOIN "line_items" ON "line_items"."product_id" = "products"."id" 
INNER JOIN "orders" ON "orders"."id" = "line_items"."order_id"

If it isn't possible, then I suggest some backward-compatible (can be used in old way, with 1 simple string as a peremeter) extension for the select method, but I can't figure out how to make it as transparent (i.e. w/o _h at the end as I did below) application-wide replacement:

class ActiveRecord::Base
  def self.select_h(*fields) # TODO: rid of this ugly _h
    hash_of_fields = fields.last.is_a?(Hash) ? fields.pop : {}
    fields_in_hash = hash_of_fields.map do |table, field_or_fields|
      (field_or_fields.is_a?(Array) ? field_or_fields : [field_开发者_运维技巧or_fields]).map do |field|
        field = "#{field.first[0]}\" as \"#{field.first[1]}" if field.is_a? Hash
        "\"#{table}\".\"#{field}\""
      end
    end
    # calling original select
    select (fields+fields_in_hash).join(', ')
  end
end

I'll appreciate pointing me at some details about internals of ActiveRecord's implementation regarding it's pattern that was used to make this very obscure-to-exam gem :)

The source of the select method--

# File activerecord/lib/active_record/relation/query_methods.rb, line 34
def select(value = Proc.new)
  if block_given?
    to_a.select {|*block_args| value.call(*block_args) }
  else
    relation = clone
    relation.select_values += Array.wrap(value)
    relation
  end
end

-- suggests that it won't do what you're asking it to. However, as it can optionally take a block you might be able to coerce it into the behavior you're looking for...

Whenever I get confused about what I can and can't do with the Arel stuff, I just peruse the source at:

Arel API

I'm not sure this helps but at the very least it might send you in the right direction to explore...

For your final question of how to avoid the _h, see When monkey patching a method, can you call the overridden method from the new implementation?

class Foo
  def bar
    'Hello'
  end
end 

class Foo
  old_bar = instance_method(:bar)

  define_method(:bar) do
    old_bar.bind(self).() + ' World'
  end
end

Foo.new.bar # => 'Hello World'