Skip to content
Browse files

Merge branch 'master' of git://github.com/rails/rails

Conflicts:
	actionmailer/lib/action_mailer/base.rb
  • Loading branch information...
2 parents c04baed + 8a1be22 commit 8b37fee201bb3f41d3bc4557422c5f8b344f456c @mikel mikel committed Jan 20, 2010
Showing with 738 additions and 810 deletions.
  1. +9 −8 actionmailer/lib/action_mailer/base.rb
  2. +4 −4 actionmailer/lib/action_mailer/railties/subscriber.rb
  3. +1 −1 actionmailer/lib/action_mailer/test_case.rb
  4. +1 −1 actionpack/lib/action_controller/base.rb
  5. +0 −5 actionpack/lib/action_controller/metal/filter_parameter_logging.rb
  6. +1 −1 actionpack/lib/action_controller/metal/helpers.rb
  7. +13 −7 actionpack/lib/action_controller/metal/instrumentation.rb
  8. +6 −2 actionpack/lib/action_controller/railties/subscriber.rb
  9. +13 −6 actionpack/lib/action_dispatch/middleware/notifications.rb
  10. +3 −3 actionpack/lib/action_dispatch/middleware/params_parser.rb
  11. +1 −3 actionpack/lib/action_dispatch/middleware/stack.rb
  12. +2 −2 actionpack/lib/action_dispatch/railties/subscriber.rb
  13. +32 −4 actionpack/lib/action_dispatch/routing/mapper.rb
  14. +3 −1 actionpack/lib/action_dispatch/testing/integration.rb
  15. +2 −2 actionpack/test/activerecord/controller_runtime_test.rb
  16. +3 −3 actionpack/test/controller/new_base/base_test.rb
  17. +30 −24 actionpack/test/controller/subscriber_test.rb
  18. +1 −1 actionpack/test/dispatch/request/json_params_parsing_test.rb
  19. +1 −1 actionpack/test/dispatch/request/xml_params_parsing_test.rb
  20. +11 −11 actionpack/test/dispatch/show_exceptions_test.rb
  21. +2 −3 actionpack/test/dispatch/subscriber_test.rb
  22. +2 −0 activemodel/lib/active_model/lint.rb
  23. +1 −2 activerecord/lib/active_record.rb
  24. +13 −14 activerecord/lib/active_record/association_preload.rb
  25. +0 −67 activerecord/lib/active_record/associations.rb
  26. +4 −3 activerecord/lib/active_record/associations/association_collection.rb
  27. +5 −161 activerecord/lib/active_record/base.rb
  28. +0 −122 activerecord/lib/active_record/calculations.rb
  29. +2 −2 activerecord/lib/active_record/locking/optimistic.rb
  30. +0 −17 activerecord/lib/active_record/named_scope.rb
  31. +5 −10 activerecord/lib/active_record/relation.rb
  32. +0 −200 activerecord/lib/active_record/relation/calculation_methods.rb
  33. +259 −0 activerecord/lib/active_record/relation/calculations.rb
  34. +155 −32 activerecord/lib/active_record/relation/finder_methods.rb
  35. +6 −2 activerecord/lib/active_record/relation/query_methods.rb
  36. +6 −13 activerecord/lib/active_record/relation/spawn_methods.rb
  37. +0 −15 activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
  38. +4 −4 activerecord/test/cases/method_scoping_test.rb
  39. +6 −0 activerecord/test/cases/named_scope_test.rb
  40. +16 −30 activesupport/lib/active_support/core_ext/load_error.rb
  41. +1 −1 activesupport/lib/active_support/dependencies.rb
  42. +4 −3 activesupport/lib/active_support/values/time_zone.rb
  43. +15 −0 activesupport/test/core_ext/load_error_test.rb
  44. +6 −0 activesupport/test/time_zone_test.rb
  45. +1 −1 railties/builtin/rails_info/rails/info.rb
  46. +5 −1 railties/lib/rails/application.rb
  47. +24 −14 railties/lib/rails/generators.rb
  48. +1 −1 railties/lib/rails/plugin.rb
  49. +15 −0 railties/lib/rails/railtie.rb
  50. +5 −1 railties/lib/rails/subscriber.rb
  51. +1 −1 railties/lib/rails/tasks/middleware.rake
  52. +7 −0 railties/test/generators_test.rb
  53. +16 −0 railties/test/plugins/framework_extension_test.rb
  54. +14 −0 railties/test/subscriber_test.rb
View
17 actionmailer/lib/action_mailer/base.rb
@@ -410,21 +410,22 @@ def receive(raw_mail)
def deliver(mail)
raise "no mail object available for delivery!" unless mail
- begin
- ActiveSupport::Notifications.instrument("action_mailer.deliver", :mailer => self.name) do |payload|
- set_payload_for_mail(payload, mail)
+ ActiveSupport::Notifications.instrument("action_mailer.deliver", :mailer => self.name) do |payload|
- # TODO Move me to the instance
- mail.delivery_method delivery_methods[delivery_method],
- delivery_settings[delivery_method]
+ self.set_payload_for_mail(payload, mail)
+
+ mail.delivery_method delivery_methods[delivery_method],
+ delivery_settings[delivery_method]
+ begin
+ # TODO Move me to the instance
if @@perform_deliveries
mail.deliver!
self.deliveries << mail
end
+ rescue Exception => e # Net::SMTP errors or sendmail pipe errors
+ raise e if raise_delivery_errors
end
- rescue Exception => e # Net::SMTP errors or sendmail pipe errors
- raise e if raise_delivery_errors
end
mail
View
8 actionmailer/lib/action_mailer/railties/subscriber.rb
@@ -3,13 +3,13 @@ module Railties
class Subscriber < Rails::Subscriber
def deliver(event)
recipients = Array(event.payload[:to]).join(', ')
- info("Sent mail to #{recipients} (%1.fms)" % event.duration)
- debug("\n#{event.payload[:mail]}")
+ info("\nSent mail to #{recipients} (%1.fms)" % event.duration)
+ debug(event.payload[:mail])
end
def receive(event)
- info("Received mail (%.1fms)" % event.duration)
- debug("\n#{event.payload[:mail]}")
+ info("\nReceived mail (%.1fms)" % event.duration)
+ debug(event.payload[:mail])
end
def logger
View
2 actionmailer/lib/action_mailer/test_case.rb
@@ -56,7 +56,7 @@ def encode(subject)
end
def read_fixture(action)
- IO.readlines(File.join(RAILS_ROOT, 'test', 'fixtures', self.class.mailer_class.name.underscore, action))
+ IO.readlines(File.join(Rails.root, 'test', 'fixtures', self.class.mailer_class.name.underscore, action))
end
end
end
View
2 actionpack/lib/action_controller/base.rb
@@ -26,6 +26,7 @@ class Base < Metal
include ActionController::Compatibility
include ActionController::Cookies
+ include ActionController::FilterParameterLogging
include ActionController::Flash
include ActionController::Verification
include ActionController::RequestForgeryProtection
@@ -37,7 +38,6 @@ class Base < Metal
# Add instrumentations hooks at the bottom, to ensure they instrument
# all the methods properly.
include ActionController::Instrumentation
- include ActionController::FilterParameterLogging
# TODO: Extract into its own module
# This should be moved together with other normalizing behavior
View
5 actionpack/lib/action_controller/metal/filter_parameter_logging.rb
@@ -58,11 +58,6 @@ def filter_parameter_logging(*filter_words, &block)
protected
- def append_info_to_payload(payload)
- super
- payload[:params] = filter_parameters(request.params)
- end
-
def filter_parameters(params)
params.dup.except!(*INTERNAL_PARAMS)
end
View
2 actionpack/lib/action_controller/metal/helpers.rb
@@ -100,7 +100,7 @@ def default_helper_module!
module_path = module_name.underscore
helper module_path
rescue MissingSourceFile => e
- raise e unless e.is_missing? "#{module_path}_helper"
+ raise e unless e.is_missing? "helpers/#{module_path}_helper"
rescue NameError => e
raise e unless e.missing_name? "#{module_name}Helper"
end
View
20 actionpack/lib/action_controller/metal/instrumentation.rb
@@ -9,18 +9,24 @@ module ActionController
module Instrumentation
extend ActiveSupport::Concern
- included do
- include AbstractController::Logger
- end
+ include AbstractController::Logger
+ include ActionController::FilterParameterLogging
attr_internal :view_runtime
def process_action(action, *args)
- ActiveSupport::Notifications.instrument("action_controller.process_action") do |payload|
+ raw_payload = {
+ :controller => self.class.name,
+ :action => self.action_name,
+ :params => filter_parameters(params),
+ :formats => request.formats.map(&:to_sym)
+ }
+
+ ActiveSupport::Notifications.instrument("action_controller.start_processing", raw_payload.dup)
+
+ ActiveSupport::Notifications.instrument("action_controller.process_action", raw_payload) do |payload|
result = super
- payload[:controller] = self.class.name
- payload[:action] = self.action_name
- payload[:status] = response.status
+ payload[:status] = response.status
append_info_to_payload(payload)
result
end
View
8 actionpack/lib/action_controller/railties/subscriber.rb
@@ -1,15 +1,19 @@
module ActionController
module Railties
class Subscriber < Rails::Subscriber
- def process_action(event)
+ def start_processing(event)
payload = event.payload
+ info " Processing by #{payload[:controller]}##{payload[:action]} as #{payload[:formats].first.to_s.upcase}"
info " Parameters: #{payload[:params].inspect}" unless payload[:params].blank?
+ end
+ def process_action(event)
+ payload = event.payload
additions = ActionController::Base.log_process_action(payload)
message = "Completed in %.0fms" % event.duration
message << " (#{additions.join(" | ")})" unless additions.blank?
- message << " by #{payload[:controller]}##{payload[:action]} [#{payload[:status]}]"
+ message << " with #{payload[:status]}"
info(message)
end
View
19 actionpack/lib/action_dispatch/middleware/notifications.rb
@@ -8,17 +8,24 @@ def initialize(app)
@app = app
end
- def call(stack_env)
- env = stack_env.dup
- ActiveSupport::Notifications.instrument("action_dispatch.before_dispatch", :env => env)
+ def call(env)
+ payload = retrieve_payload_from_env(env)
+ ActiveSupport::Notifications.instrument("action_dispatch.before_dispatch", payload)
- ActiveSupport::Notifications.instrument!("action_dispatch.after_dispatch", :env => env) do
- @app.call(stack_env)
+ ActiveSupport::Notifications.instrument!("action_dispatch.after_dispatch", payload) do
+ @app.call(env)
end
rescue Exception => exception
ActiveSupport::Notifications.instrument('action_dispatch.exception',
- :env => stack_env, :exception => exception)
+ :env => env, :exception => exception)
raise exception
end
+
+ protected
+
+ # Remove any rack related constants from the env, like rack.input.
+ def retrieve_payload_from_env(env)
+ Hash[:env => env.except(*env.keys.select { |k| k.to_s.index("rack.") == 0 })]
+ end
end
end
View
6 actionpack/lib/action_dispatch/middleware/params_parser.rb
@@ -35,14 +35,14 @@ def parse_formatted_parameters(env)
when Proc
strategy.call(request.raw_post)
when :xml_simple, :xml_node
- request.body.size == 0 ? {} : Hash.from_xml(request.body).with_indifferent_access
+ request.body.size == 0 ? {} : Hash.from_xml(request.raw_post).with_indifferent_access
when :yaml
- YAML.load(request.body)
+ YAML.load(request.raw_post)
when :json
if request.body.size == 0
{}
else
- data = ActiveSupport::JSON.decode(request.body)
+ data = ActiveSupport::JSON.decode(request.raw_post)
data = {:_json => data} unless data.is_a?(Hash)
data.with_indifferent_access
end
View
4 actionpack/lib/action_dispatch/middleware/stack.rb
@@ -60,9 +60,7 @@ def ==(middleware)
end
def inspect
- str = klass.to_s
- args.each { |arg| str += ", #{build_args.inspect}" }
- str
+ klass.to_s
end
def build(app)
View
4 actionpack/lib/action_dispatch/railties/subscriber.rb
@@ -5,8 +5,8 @@ def before_dispatch(event)
request = Request.new(event.payload[:env])
path = request.request_uri.inspect rescue "unknown"
- info "\n\nProcessing #{path} to #{request.formats.join(', ')} " <<
- "(for #{request.remote_ip} at #{event.time.to_s(:db)}) [#{request.method.to_s.upcase}]"
+ info "\n\nStarted #{request.method.to_s.upcase} #{path} " <<
+ "for #{request.remote_ip} at #{event.time.to_s(:db)}"
end
def logger
View
36 actionpack/lib/action_dispatch/routing/mapper.rb
@@ -375,6 +375,15 @@ def actions
end
end
+ def action_type(action)
+ case action
+ when :index, :create
+ :collection
+ when :show, :update, :destroy
+ :member
+ end
+ end
+
def name
options[:as] || plural
end
@@ -391,6 +400,15 @@ def collection_name
plural
end
+ def name_for_action(action)
+ case action_type(action)
+ when :collection
+ collection_name
+ when :member
+ member_name
+ end
+ end
+
def id_segment
":#{singular}_id"
end
@@ -405,6 +423,13 @@ def initialize(entity, options = {})
super
end
+ def action_type(action)
+ case action
+ when :show, :create, :update, :destroy
+ :member
+ end
+ end
+
def name
options[:as] || singular
end
@@ -428,7 +453,7 @@ def resource(*resources, &block)
with_scope_level(:resource, resource) do
yield if block_given?
- get :show, :as => resource.member_name if resource.actions.include?(:show)
+ get :show if resource.actions.include?(:show)
post :create if resource.actions.include?(:create)
put :update if resource.actions.include?(:update)
delete :destroy if resource.actions.include?(:destroy)
@@ -454,14 +479,14 @@ def resources(*resources, &block)
yield if block_given?
with_scope_level(:collection) do
- get :index, :as => resource.collection_name if resource.actions.include?(:index)
+ get :index if resource.actions.include?(:index)
post :create if resource.actions.include?(:create)
get :new, :as => resource.singular if resource.actions.include?(:new)
end
with_scope_level(:member) do
scope(':id') do
- get :show, :as => resource.member_name if resource.actions.include?(:show)
+ get :show if resource.actions.include?(:show)
put :update if resource.actions.include?(:update)
delete :destroy if resource.actions.include?(:destroy)
get :edit, :as => resource.singular if resource.actions.include?(:edit)
@@ -525,7 +550,10 @@ def match(*args)
begin
old_path = @scope[:path]
@scope[:path] = "#{@scope[:path]}(.:format)"
- return match(options.reverse_merge(:to => action))
+ return match(options.reverse_merge(
+ :to => action,
+ :as => parent_resource.name_for_action(action)
+ ))
ensure
@scope[:path] = old_path
end
View
4 actionpack/lib/action_dispatch/testing/integration.rb
@@ -259,7 +259,9 @@ def process(method, path, parameters = nil, rack_environment = nil)
"HTTP_HOST" => host,
"REMOTE_ADDR" => remote_addr,
"CONTENT_TYPE" => "application/x-www-form-urlencoded",
- "HTTP_ACCEPT" => accept
+ "HTTP_ACCEPT" => accept,
+
+ "action_dispatch.show_exceptions" => false
}
(rack_environment || {}).each do |key, value|
View
4 actionpack/test/activerecord/controller_runtime_test.rb
@@ -37,8 +37,8 @@ def test_log_with_active_record
get :show
wait
- assert_equal 1, @logger.logged(:info).size
- assert_match /\(Views: [\d\.]+ms | ActiveRecord: [\d\.]+ms\)/, @logger.logged(:info)[0]
+ assert_equal 2, @logger.logged(:info).size
+ assert_match /\(Views: [\d\.]+ms | ActiveRecord: [\d\.]+ms\)/, @logger.logged(:info)[1]
end
class SyncSubscriberTest < ActionController::TestCase
View
6 actionpack/test/controller/new_base/base_test.rb
@@ -22,7 +22,7 @@ def modify_response_headers
end
def show_actions
- render :text => "actions: #{action_methods.to_a.join(', ')}"
+ render :text => "actions: #{action_methods.to_a.sort.join(', ')}"
end
protected
@@ -77,9 +77,9 @@ class BaseTest < Rack::TestCase
test "action methods" do
assert_equal Set.new(%w(
+ index
modify_response_headers
modify_response_body_twice
- index
modify_response_body
show_actions
)), SimpleController.action_methods
@@ -88,7 +88,7 @@ class BaseTest < Rack::TestCase
assert_equal Set.new, Submodule::ContainedEmptyController.action_methods
get "/dispatching/simple/show_actions"
- assert_body "actions: modify_response_headers, modify_response_body_twice, index, modify_response_body, show_actions"
+ assert_body "actions: index, modify_response_body, modify_response_body_twice, modify_response_headers, show_actions"
end
end
end
View
54 actionpack/test/controller/subscriber_test.rb
@@ -63,13 +63,19 @@ def set_logger(logger)
ActionController::Base.logger = logger
end
+ def test_start_processing
+ get :show
+ wait
+ assert_equal 2, logs.size
+ assert_equal "Processing by Another::SubscribersController#show as HTML", logs.first
+ end
+
def test_process_action
get :show
wait
- assert_equal 1, logs.size
- assert_match /Completed/, logs.first
- assert_match /\[200\]/, logs.first
- assert_match /Another::SubscribersController#show/, logs.first
+ assert_equal 2, logs.size
+ assert_match /Completed/, logs.last
+ assert_match /with 200/, logs.last
end
def test_process_action_without_parameters
@@ -82,14 +88,14 @@ def test_process_action_with_parameters
get :show, :id => '10'
wait
- assert_equal 2, logs.size
- assert_equal 'Parameters: {"id"=>"10"}', logs[0]
+ assert_equal 3, logs.size
+ assert_equal 'Parameters: {"id"=>"10"}', logs[1]
end
def test_process_action_with_view_runtime
get :show
wait
- assert_match /\(Views: [\d\.]+ms\)/, logs[0]
+ assert_match /\(Views: [\d\.]+ms\)/, logs[1]
end
def test_process_action_with_filter_parameters
@@ -98,7 +104,7 @@ def test_process_action_with_filter_parameters
get :show, :lifo => 'Pratik', :amount => '420', :step => '1'
wait
- params = logs[0]
+ params = logs[1]
assert_match /"amount"=>"\[FILTERED\]"/, params
assert_match /"lifo"=>"\[FILTERED\]"/, params
assert_match /"step"=>"1"/, params
@@ -108,44 +114,44 @@ def test_redirect_to
get :redirector
wait
- assert_equal 2, logs.size
- assert_equal "Redirected to http://foo.bar/", logs[0]
+ assert_equal 3, logs.size
+ assert_equal "Redirected to http://foo.bar/", logs[1]
end
def test_send_data
get :data_sender
wait
- assert_equal 2, logs.size
- assert_match /Sent data omg\.txt/, logs[0]
+ assert_equal 3, logs.size
+ assert_match /Sent data omg\.txt/, logs[1]
end
def test_send_file
get :file_sender
wait
- assert_equal 2, logs.size
- assert_match /Sent file/, logs[0]
- assert_match /test\/fixtures\/company\.rb/, logs[0]
+ assert_equal 3, logs.size
+ assert_match /Sent file/, logs[1]
+ assert_match /test\/fixtures\/company\.rb/, logs[1]
end
def test_send_xfile
get :xfile_sender
wait
- assert_equal 2, logs.size
- assert_match /Sent X\-Sendfile header/, logs[0]
- assert_match /test\/fixtures\/company\.rb/, logs[0]
+ assert_equal 3, logs.size
+ assert_match /Sent X\-Sendfile header/, logs[1]
+ assert_match /test\/fixtures\/company\.rb/, logs[1]
end
def test_with_fragment_cache
ActionController::Base.perform_caching = true
get :with_fragment_cache
wait
- assert_equal 3, logs.size
- assert_match /Exist fragment\? views\/foo/, logs[0]
- assert_match /Write fragment views\/foo/, logs[1]
+ assert_equal 4, logs.size
+ assert_match /Exist fragment\? views\/foo/, logs[1]
+ assert_match /Write fragment views\/foo/, logs[2]
ensure
ActionController::Base.perform_caching = true
end
@@ -155,9 +161,9 @@ def test_with_page_cache
get :with_page_cache
wait
- assert_equal 2, logs.size
- assert_match /Write page/, logs[0]
- assert_match /\/index\.html/, logs[0]
+ assert_equal 3, logs.size
+ assert_match /Write page/, logs[1]
+ assert_match /\/index\.html/, logs[1]
ensure
ActionController::Base.perform_caching = true
end
View
2 actionpack/test/dispatch/request/json_params_parsing_test.rb
@@ -35,7 +35,7 @@ def teardown
begin
$stderr = StringIO.new
json = "[\"person]\": {\"name\": \"David\"}}"
- post "/parse", json, {'CONTENT_TYPE' => 'application/json'}
+ post "/parse", json, {'CONTENT_TYPE' => 'application/json', 'action_dispatch.show_exceptions' => true}
assert_response :error
$stderr.rewind && err = $stderr.read
assert err =~ /Error occurred while parsing request parameters/
View
2 actionpack/test/dispatch/request/xml_params_parsing_test.rb
@@ -43,7 +43,7 @@ def teardown
begin
$stderr = StringIO.new
xml = "<person><name>David</name><avatar type='file' name='me.jpg' content_type='image/jpg'>#{ActiveSupport::Base64.encode64('ABC')}</avatar></pineapple>"
- post "/parse", xml, default_headers
+ post "/parse", xml, default_headers.merge('action_dispatch.show_exceptions' => true)
assert_response :error
$stderr.rewind && err = $stderr.read
assert err =~ /Error occurred while parsing request parameters/
View
22 actionpack/test/dispatch/show_exceptions_test.rb
@@ -38,15 +38,15 @@ class ShowExceptionsTest < ActionController::IntegrationTest
@app = ProductionApp
self.remote_addr = '208.77.188.166'
- get "/"
+ get "/", {}, {'action_dispatch.show_exceptions' => true}
assert_response 500
assert_equal "500 error fixture\n", body
- get "/not_found"
+ get "/not_found", {}, {'action_dispatch.show_exceptions' => true}
assert_response 404
assert_equal "404 error fixture\n", body
- get "/method_not_allowed"
+ get "/method_not_allowed", {}, {'action_dispatch.show_exceptions' => true}
assert_response 405
assert_equal "", body
end
@@ -56,15 +56,15 @@ class ShowExceptionsTest < ActionController::IntegrationTest
['127.0.0.1', '::1'].each do |ip_address|
self.remote_addr = ip_address
- get "/"
+ get "/", {}, {'action_dispatch.show_exceptions' => true}
assert_response 500
assert_match /puke/, body
- get "/not_found"
+ get "/not_found", {}, {'action_dispatch.show_exceptions' => true}
assert_response 404
assert_match /#{ActionController::UnknownAction.name}/, body
- get "/method_not_allowed"
+ get "/method_not_allowed", {}, {'action_dispatch.show_exceptions' => true}
assert_response 405
assert_match /ActionController::MethodNotAllowed/, body
end
@@ -78,11 +78,11 @@ class ShowExceptionsTest < ActionController::IntegrationTest
@app = ProductionApp
self.remote_addr = '208.77.188.166'
- get "/"
+ get "/", {}, {'action_dispatch.show_exceptions' => true}
assert_response 500
assert_equal "500 localized error fixture\n", body
- get "/not_found"
+ get "/not_found", {}, {'action_dispatch.show_exceptions' => true}
assert_response 404
assert_equal "404 error fixture\n", body
ensure
@@ -94,15 +94,15 @@ class ShowExceptionsTest < ActionController::IntegrationTest
@app = DevelopmentApp
self.remote_addr = '208.77.188.166'
- get "/"
+ get "/", {}, {'action_dispatch.show_exceptions' => true}
assert_response 500
assert_match /puke/, body
- get "/not_found"
+ get "/not_found", {}, {'action_dispatch.show_exceptions' => true}
assert_response 404
assert_match /#{ActionController::UnknownAction.name}/, body
- get "/method_not_allowed"
+ get "/method_not_allowed", {}, {'action_dispatch.show_exceptions' => true}
assert_response 405
assert_match /ActionController::MethodNotAllowed/, body
end
View
5 actionpack/test/dispatch/subscriber_test.rb
@@ -78,9 +78,8 @@ def test_subscriber_logs_notifications
log = @logger.logged(:info).first
assert_equal 1, @logger.logged(:info).size
- assert_match %r{^Processing "/" to text/html}, log
- assert_match %r{\(for 127\.0\.0\.1}, log
- assert_match %r{\[GET\]}, log
+ assert_match %r{^Started GET "/"}, log
+ assert_match %r{for 127\.0\.0\.1}, log
end
def test_subscriber_has_its_logged_flushed_after_request
View
2 activemodel/lib/active_model/lint.rb
@@ -53,6 +53,8 @@ def test_model_naming
assert_kind_of String, model_name
assert_kind_of String, model_name.human
assert_kind_of String, model_name.partial_path
+ assert_kind_of String, model_name.singular
+ assert_kind_of String, model_name.plural
end
# errors
View
3 activerecord/lib/active_record.rb
@@ -53,14 +53,13 @@ module ActiveRecord
autoload_under 'relation' do
autoload :QueryMethods
autoload :FinderMethods
- autoload :CalculationMethods
+ autoload :Calculations
autoload :PredicateBuilder
autoload :SpawnMethods
end
autoload :Base
autoload :Batches
- autoload :Calculations
autoload :Callbacks
autoload :DynamicFinderMatch
autoload :DynamicScopeMatch
View
27 activerecord/lib/active_record/association_preload.rb
@@ -187,13 +187,12 @@ def preload_has_and_belongs_to_many_association(records, reflection, preload_opt
conditions = "t0.#{reflection.primary_key_name} #{in_or_equals_for_ids(ids)}"
conditions << append_conditions(reflection, preload_options)
- associated_records = reflection.klass.with_exclusive_scope do
- reflection.klass.where([conditions, ids]).
+ associated_records = reflection.klass.unscoped.where([conditions, ids]).
includes(options[:include]).
joins("INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{reflection.klass.quoted_table_name}.#{reflection.klass.primary_key} = t0.#{reflection.association_foreign_key}").
select("#{options[:select] || table_name+'.*'}, t0.#{reflection.primary_key_name} as the_parent_record_id").
order(options[:order]).to_a
- end
+
set_association_collection_records(id_to_record_map, reflection.name, associated_records, 'the_parent_record_id')
end
@@ -341,9 +340,7 @@ def preload_belongs_to_association(records, reflection, preload_options={})
conditions = "#{table_name}.#{connection.quote_column_name(primary_key)} #{in_or_equals_for_ids(ids)}"
conditions << append_conditions(reflection, preload_options)
- associated_records = klass.with_exclusive_scope do
- klass.where([conditions, ids]).apply_finder_options(options.slice(:include, :select, :joins, :order)).to_a
- end
+ associated_records = klass.unscoped.where([conditions, ids]).apply_finder_options(options.slice(:include, :select, :joins, :order)).to_a
set_association_single_records(id_map, reflection.name, associated_records, primary_key)
end
@@ -362,14 +359,16 @@ def find_associated_records(ids, reflection, preload_options)
conditions << append_conditions(reflection, preload_options)
- reflection.klass.with_exclusive_scope do
- reflection.klass.select(preload_options[:select] || options[:select] || "#{table_name}.*").
- includes(preload_options[:include] || options[:include]).
- where([conditions, ids]).
- joins(options[:joins]).
- group(preload_options[:group] || options[:group]).
- order(preload_options[:order] || options[:order])
- end
+ find_options = {
+ :select => preload_options[:select] || options[:select] || "#{table_name}.*",
+ :include => preload_options[:include] || options[:include],
+ :conditions => [conditions, ids],
+ :joins => options[:joins],
+ :group => preload_options[:group] || options[:group],
+ :order => preload_options[:order] || options[:order]
+ }
+
+ reflection.klass.unscoped.apply_finder_options(find_options).to_a
end
View
67 activerecord/lib/active_record/associations.rb
@@ -1463,13 +1463,6 @@ def add_touch_callbacks(reflection, touch_attribute)
after_destroy(method_name)
end
- def find_with_associations(options, join_dependency)
- rows = select_all_rows(options, join_dependency)
- join_dependency.instantiate(rows)
- rescue ThrowResult
- []
- end
-
# Creates before_destroy callback methods that nullify, delete or destroy
# has_many associated objects, according to the defined :dependent rule.
#
@@ -1693,66 +1686,6 @@ def create_has_and_belongs_to_many_reflection(association_id, options, &extensio
reflection
end
- def select_all_rows(options, join_dependency)
- connection.select_all(
- construct_finder_sql_with_included_associations(options, join_dependency),
- "#{name} Load Including Associations"
- )
- end
-
- def construct_finder_arel_with_included_associations(options, join_dependency)
- relation = scoped
-
- for association in join_dependency.join_associations
- relation = association.join_relation(relation)
- end
-
- relation = relation.apply_finder_options(options).select(column_aliases(join_dependency))
-
- if !using_limitable_reflections?(join_dependency.reflections) && relation.limit_value
- relation = relation.where(construct_arel_limited_ids_condition(options, join_dependency))
- end
-
- relation = relation.except(:limit, :offset) unless using_limitable_reflections?(join_dependency.reflections)
-
- relation
- end
-
- def construct_finder_sql_with_included_associations(options, join_dependency)
- construct_finder_arel_with_included_associations(options, join_dependency).to_sql
- end
-
- def construct_arel_limited_ids_condition(options, join_dependency)
- if (ids_array = select_limited_ids_array(options, join_dependency)).empty?
- raise ThrowResult
- else
- Arel::Predicates::In.new(
- Arel::SqlLiteral.new("#{connection.quote_table_name table_name}.#{primary_key}"),
- ids_array
- )
- end
- end
-
- def select_limited_ids_array(options, join_dependency)
- connection.select_all(
- construct_finder_sql_for_association_limiting(options, join_dependency),
- "#{name} Load IDs For Limited Eager Loading"
- ).collect { |row| row[primary_key] }
- end
-
- def construct_finder_sql_for_association_limiting(options, join_dependency)
- relation = scoped
-
- for association in join_dependency.join_associations
- relation = association.join_relation(relation)
- end
-
- relation = relation.apply_finder_options(options).except(:select)
- relation = relation.select(connection.distinct("#{connection.quote_table_name table_name}.#{primary_key}", relation.order_values.join(", ")))
-
- relation.to_sql
- end
-
def using_limitable_reflections?(reflections)
reflections.collect(&:collection?).length.zero?
end
View
7 activerecord/lib/active_record/associations/association_collection.rb
@@ -176,14 +176,15 @@ def sum(*args)
# be used for the query. If no +:counter_sql+ was supplied, but +:finder_sql+ was set, the
# descendant's +construct_sql+ method will have set :counter_sql automatically.
# Otherwise, construct options and pass them with scope to the target class's +count+.
- def count(*args)
+ def count(column_name = nil, options = {})
if @reflection.options[:counter_sql]
@reflection.klass.count_by_sql(@counter_sql)
else
- column_name, options = @reflection.klass.scoped.send(:construct_count_options_from_args, *args)
+ column_name, options = nil, column_name if column_name.is_a?(Hash)
+
if @reflection.options[:uniq]
# This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL.
- column_name = "#{@reflection.quoted_table_name}.#{@reflection.klass.primary_key}" if column_name == :all
+ column_name = "#{@reflection.quoted_table_name}.#{@reflection.klass.primary_key}" unless column_name
options.merge!(:distinct => true)
end
View
166 activerecord/lib/active_record/base.rb
@@ -556,122 +556,9 @@ def colorize_logging(*args)
end
alias :colorize_logging= :colorize_logging
- # Find operates with four different retrieval approaches:
- #
- # * Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
- # If no record can be found for all of the listed ids, then RecordNotFound will be raised.
- # * Find first - This will return the first record matched by the options used. These options can either be specific
- # conditions or merely an order. If no record can be matched, +nil+ is returned. Use
- # <tt>Model.find(:first, *args)</tt> or its shortcut <tt>Model.first(*args)</tt>.
- # * Find last - This will return the last record matched by the options used. These options can either be specific
- # conditions or merely an order. If no record can be matched, +nil+ is returned. Use
- # <tt>Model.find(:last, *args)</tt> or its shortcut <tt>Model.last(*args)</tt>.
- # * Find all - This will return all the records matched by the options used.
- # If no records are found, an empty array is returned. Use
- # <tt>Model.find(:all, *args)</tt> or its shortcut <tt>Model.all(*args)</tt>.
- #
- # All approaches accept an options hash as their last parameter.
- #
- # ==== Parameters
- #
- # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1", <tt>[ "user_name = ?", username ]</tt>, or <tt>["user_name = :user_name", { :user_name => user_name }]</tt>. See conditions in the intro.
- # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name".
- # * <tt>:group</tt> - An attribute name by which the result should be grouped. Uses the <tt>GROUP BY</tt> SQL-clause.
- # * <tt>:having</tt> - Combined with +:group+ this can be used to filter the records that a <tt>GROUP BY</tt> returns. Uses the <tt>HAVING</tt> SQL-clause.
- # * <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.
- # * <tt>:joins</tt> - Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" (rarely needed),
- # named associations in the same form used for the <tt>:include</tt> option, which will perform an <tt>INNER JOIN</tt> on the associated table(s),
- # or an array containing a mixture of both strings and named associations.
- # If the value is a string, then the records will be returned read-only since they will have attributes that do not correspond to the table's columns.
- # Pass <tt>:readonly => false</tt> to override.
- # * <tt>:include</tt> - Names associations that should be loaded alongside. The symbols named refer
- # to already defined associations. See eager loading under Associations.
- # * <tt>:select</tt> - By default, this is "*" as in "SELECT * FROM", but can be changed if you, for example, want to do a join but not
- # include the joined columns. Takes a string with the SELECT SQL fragment (e.g. "id, name").
- # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed to an alternate table name (or even the name
- # of a database view).
- # * <tt>:readonly</tt> - Mark the returned records read-only so they cannot be saved or updated.
- # * <tt>:lock</tt> - An SQL fragment like "FOR UPDATE" or "LOCK IN SHARE MODE".
- # <tt>:lock => true</tt> gives connection's default exclusive lock, usually "FOR UPDATE".
- #
- # ==== Examples
- #
- # # find by id
- # Person.find(1) # returns the object for ID = 1
- # Person.find(1, 2, 6) # returns an array for objects with IDs in (1, 2, 6)
- # Person.find([7, 17]) # returns an array for objects with IDs in (7, 17)
- # Person.find([1]) # returns an array for the object with ID = 1
- # Person.find(1, :conditions => "administrator = 1", :order => "created_on DESC")
- #
- # Note that returned records may not be in the same order as the ids you
- # provide since database rows are unordered. Give an explicit <tt>:order</tt>
- # to ensure the results are sorted.
- #
- # ==== Examples
- #
- # # find first
- # Person.find(:first) # returns the first object fetched by SELECT * FROM people
- # Person.find(:first, :conditions => [ "user_name = ?", user_name])
- # Person.find(:first, :conditions => [ "user_name = :u", { :u => user_name }])
- # Person.find(:first, :order => "created_on DESC", :offset => 5)
- #
- # # find last
- # Person.find(:last) # returns the last object fetched by SELECT * FROM people
- # Person.find(:last, :conditions => [ "user_name = ?", user_name])
- # Person.find(:last, :order => "created_on DESC", :offset => 5)
- #
- # # find all
- # Person.find(:all) # returns an array of objects for all the rows fetched by SELECT * FROM people
- # Person.find(:all, :conditions => [ "category IN (?)", categories], :limit => 50)
- # Person.find(:all, :conditions => { :friends => ["Bob", "Steve", "Fred"] }
- # Person.find(:all, :offset => 10, :limit => 10)
- # Person.find(:all, :include => [ :account, :friends ])
- # Person.find(:all, :group => "category")
- #
- # Example for find with a lock: Imagine two concurrent transactions:
- # each will read <tt>person.visits == 2</tt>, add 1 to it, and save, resulting
- # in two saves of <tt>person.visits = 3</tt>. By locking the row, the second
- # transaction has to wait until the first is finished; we get the
- # expected <tt>person.visits == 4</tt>.
- #
- # Person.transaction do
- # person = Person.find(1, :lock => true)
- # person.visits += 1
- # person.save!
- # end
- def find(*args)
- options = args.extract_options!
-
- relation = construct_finder_arel(options, current_scoped_methods)
-
- case args.first
- when :first, :last, :all
- relation.send(args.first)
- else
- relation.find(*args)
- end
- end
-
+ delegate :find, :first, :last, :all, :to => :scoped
delegate :select, :group, :order, :limit, :joins, :where, :preload, :eager_load, :includes, :from, :lock, :readonly, :having, :to => :scoped
-
- # A convenience wrapper for <tt>find(:first, *args)</tt>. You can pass in all the
- # same arguments to this method as you can to <tt>find(:first)</tt>.
- def first(*args)
- find(:first, *args)
- end
-
- # A convenience wrapper for <tt>find(:last, *args)</tt>. You can pass in all the
- # same arguments to this method as you can to <tt>find(:last)</tt>.
- def last(*args)
- find(:last, *args)
- end
-
- # A convenience wrapper for <tt>find(:all, *args)</tt>. You can pass in all the
- # same arguments to this method as you can to <tt>find(:all)</tt>.
- def all(*args)
- find(:all, *args)
- end
+ delegate :count, :average, :minimum, :maximum, :sum, :calculate, :to => :scoped
# Executes a custom SQL query against your database and returns all the results. The results will
# be returned as an array with columns requested encapsulated as attributes of the model you call
@@ -1568,38 +1455,6 @@ def construct_finder_arel(options = {}, scope = nil)
relation
end
- def construct_join(joins)
- case joins
- when Symbol, Hash, Array
- if array_of_strings?(joins)
- joins.join(' ') + " "
- else
- build_association_joins(joins)
- end
- when String
- " #{joins} "
- else
- ""
- end
- end
-
- def build_association_joins(joins)
- join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, joins, nil)
- relation = unscoped.table
- join_dependency.join_associations.map { |association|
- if (association_relation = association.relation).is_a?(Array)
- [Arel::InnerJoin.new(relation, association_relation.first, *association.association_join.first).joins(relation),
- Arel::InnerJoin.new(relation, association_relation.last, *association.association_join.last).joins(relation)].join()
- else
- Arel::InnerJoin.new(relation, association_relation, *association.association_join).joins(relation)
- end
- }.join(" ")
- end
-
- def array_of_strings?(o)
- o.is_a?(Array) && o.all?{|obj| obj.is_a?(String)}
- end
-
def type_condition
sti_column = arel_table[inheritance_column]
condition = sti_column.eq(sti_name)
@@ -1762,11 +1617,8 @@ def with_scope(method_scoping = {}, action = :merge, &block)
relation = construct_finder_arel(method_scoping[:find] || {})
if current_scoped_methods && current_scoped_methods.create_with_value && method_scoping[:create]
- scope_for_create = case action
- when :merge
+ scope_for_create = if action == :merge
current_scoped_methods.create_with_value.merge(method_scoping[:create])
- when :reverse_merge
- method_scoping[:create].merge(current_scoped_methods.create_with_value)
else
method_scoping[:create]
end
@@ -1781,15 +1633,7 @@ def with_scope(method_scoping = {}, action = :merge, &block)
method_scoping = relation
end
- if current_scoped_methods
- case action
- when :merge
- method_scoping = current_scoped_methods.merge(method_scoping)
- when :reverse_merge
- method_scoping = current_scoped_methods.except(:where).merge(method_scoping)
- method_scoping = method_scoping.merge(current_scoped_methods.only(:where))
- end
- end
+ method_scoping = current_scoped_methods.merge(method_scoping) if current_scoped_methods && action == :merge
self.scoped_methods << method_scoping
begin
@@ -2742,7 +2586,7 @@ def quoted_comma_pair_list(quoter, hash)
# #save_with_autosave_associations to be wrapped inside a transaction.
include AutosaveAssociation, NestedAttributes
- include Aggregations, Transactions, Reflection, Batches, Calculations, Serialization
+ include Aggregations, Transactions, Reflection, Batches, Serialization
end
end
View
122 activerecord/lib/active_record/calculations.rb
@@ -1,122 +0,0 @@
-module ActiveRecord
- module Calculations #:nodoc:
- extend ActiveSupport::Concern
-
- module ClassMethods
- # Count operates using three different approaches.
- #
- # * Count all: By not passing any parameters to count, it will return a count of all the rows for the model.
- # * Count using column: By passing a column name to count, it will return a count of all the rows for the model with supplied column present
- # * Count using options will find the row count matched by the options used.
- #
- # The third approach, count using options, accepts an option hash as the only parameter. The options are:
- #
- # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro to ActiveRecord::Base.
- # * <tt>:joins</tt>: Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" (rarely needed)
- # or named associations in the same form used for the <tt>:include</tt> option, which will perform an INNER JOIN on the associated table(s).
- # If the value is a string, then the records will be returned read-only since they will have attributes that do not correspond to the table's columns.
- # Pass <tt>:readonly => false</tt> to override.
- # * <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 of DISTINCT items for the model you're counting.
- # See eager loading under Associations.
- # * <tt>:order</tt>: An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
- # * <tt>:group</tt>: An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
- # * <tt>:select</tt>: By default, this is * as in SELECT * FROM, but can be changed if you, for example, want to do a join but not
- # include the joined columns.
- # * <tt>:distinct</tt>: Set this to true to make this a distinct calculation, such as SELECT COUNT(DISTINCT posts.id) ...
- # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed to an alternate table name (or even the name
- # of a database view).
- #
- # Examples for counting all:
- # Person.count # returns the total count of all people
- #
- # Examples for counting by column:
- # Person.count(:age) # returns the total count of all people whose age is present in database
- #
- # Examples for count with options:
- # Person.count(:conditions => "age > 26")
- # Person.count(:conditions => "age > 26 AND job.salary > 60000", :include => :job) # because of the named association, it finds the DISTINCT count using LEFT OUTER JOIN.
- # Person.count(:conditions => "age > 26 AND job.salary > 60000", :joins => "LEFT JOIN jobs on jobs.person_id = person.id") # finds the number of rows matching the conditions and joins.
- # Person.count('id', :conditions => "age > 26") # Performs a COUNT(id)
- # Person.count(:all, :conditions => "age > 26") # Performs a COUNT(*) (:all is an alias for '*')
- #
- # Note: <tt>Person.count(:all)</tt> will not work because it will use <tt>:all</tt> as the condition. Use Person.count instead.
- def count(*args)
- case args.size
- when 0
- construct_calculation_arel.count
- when 1
- if args[0].is_a?(Hash)
- options = args[0]
- distinct = options.has_key?(:distinct) ? options.delete(:distinct) : false
- construct_calculation_arel(options).count(options[:select], :distinct => distinct)
- else
- construct_calculation_arel.count(args[0])
- end
- when 2
- column_name, options = args
- distinct = options.has_key?(:distinct) ? options.delete(:distinct) : false
- construct_calculation_arel(options).count(column_name, :distinct => distinct)
- else
- raise ArgumentError, "Unexpected parameters passed to count(): #{args.inspect}"
- end
- rescue ThrowResult
- 0
- end
-
- delegate :average, :minimum, :maximum, :sum, :to => :scoped
-
- # This calculates aggregate values in the given column. Methods for count, sum, average, minimum, and maximum have been added as shortcuts.
- # Options such as <tt>:conditions</tt>, <tt>:order</tt>, <tt>:group</tt>, <tt>:having</tt>, and <tt>:joins</tt> can be passed to customize the query.
- #
- # There are two basic forms of output:
- # * Single aggregate value: The single value is type cast to Fixnum for COUNT, Float for AVG, and the given column's type for everything else.
- # * Grouped values: This returns an ordered hash of the values and groups them by the <tt>:group</tt> option. It takes either a column name, or the name
- # of a belongs_to association.
- #
- # values = Person.maximum(:age, :group => 'last_name')
- # puts values["Drake"]
- # => 43
- #
- # drake = Family.find_by_last_name('Drake')
- # values = Person.maximum(:age, :group => :family) # Person belongs_to :family
- # puts values[drake]
- # => 43
- #
- # values.each do |family, max_age|
- # ...
- # end
- #
- # Options:
- # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro to ActiveRecord::Base.
- # * <tt>:include</tt>: Eager loading, see Associations for details. Since calculations don't load anything, the purpose of this is to access fields on joined tables in your conditions, order, or group clauses.
- # * <tt>:joins</tt> - An SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id". (Rarely needed).
- # The records will be returned read-only since they will have attributes that do not correspond to the table's columns.
- # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
- # * <tt>:group</tt> - An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
- # * <tt>:select</tt> - By default, this is * as in SELECT * FROM, but can be changed if you for example want to do a join, but not
- # include the joined columns.
- # * <tt>:distinct</tt> - Set this to true to make this a distinct calculation, such as SELECT COUNT(DISTINCT posts.id) ...
- #
- # Examples:
- # Person.calculate(:count, :all) # The same as Person.count
- # Person.average(:age) # SELECT AVG(age) FROM people...
- # Person.minimum(:age, :conditions => ['last_name != ?', 'Drake']) # Selects the minimum age for everyone with a last name other than 'Drake'
- # Person.minimum(:age, :having => 'min(age) > 17', :group => :last_name) # Selects the minimum age for any family without any minors
- # Person.sum("2 * age")
- def calculate(operation, column_name, options = {})
- construct_calculation_arel(options).calculate(operation, column_name, options.slice(:distinct))
- rescue ThrowResult
- 0
- end
-
- private
-
- def construct_calculation_arel(options = {})
- relation = scoped.apply_finder_options(options.except(:distinct))
- (relation.eager_loading? || relation.includes_values.present?) ? relation.send(:construct_relation_for_association_calculations) : relation
- end
-
- end
- end
-end
View
4 activerecord/lib/active_record/locking/optimistic.rb
@@ -81,8 +81,8 @@ def update_with_lock(attribute_names = @attributes.keys) #:nodoc:
relation = self.class.unscoped
affected_rows = relation.where(
- relation[self.class.primary_key].eq(quoted_id).and(
- relation[self.class.locking_column].eq(quote_value(previous_value))
+ relation.table[self.class.primary_key].eq(quoted_id).and(
+ relation.table[self.class.locking_column].eq(quote_value(previous_value))
)
).update(arel_attributes_values(false, false, attribute_names))
View
17 activerecord/lib/active_record/named_scope.rb
@@ -148,18 +148,6 @@ def self.init(klass, options, &block)
relation
end
- def find(*args)
- options = args.extract_options!
- relation = options.present? ? apply_finder_options(options) : self
-
- case args.first
- when :first, :last, :all
- relation.send(args.first)
- else
- options.present? ? relation.find(*args) : super
- end
- end
-
def first(*args)
if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
to_a.first(*args)
@@ -176,11 +164,6 @@ def last(*args)
end
end
- def count(*args)
- options = args.extract_options!
- options.present? ? apply_finder_options(options).count(*args) : super
- end
-
def ==(other)
other.respond_to?(:to_a) ? to_a == other.to_a : false
end
View
15 activerecord/lib/active_record/relation.rb
@@ -5,9 +5,10 @@ class Relation
MULTI_VALUE_METHODS = [:select, :group, :order, :joins, :where, :having]
SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :create_with, :from]
- include FinderMethods, CalculationMethods, SpawnMethods, QueryMethods
+ include FinderMethods, Calculations, SpawnMethods, QueryMethods
delegate :length, :collect, :map, :each, :all?, :include?, :to => :to_a
+ delegate :insert, :update, :to => :arel
attr_reader :table, :klass
@@ -59,8 +60,6 @@ def to_a
@records
end
- alias all to_a
-
def size
loaded? ? @records.length : count
end
@@ -139,10 +138,10 @@ def eager_loading?
protected
def method_missing(method, *args, &block)
- if arel.respond_to?(method)
- arel.send(method, *args, &block)
- elsif Array.method_defined?(method)
+ if Array.method_defined?(method)
to_a.send(method, *args, &block)
+ elsif arel.respond_to?(method)
+ arel.send(method, *args, &block)
elsif match = DynamicFinderMatch.match(method)
attributes = match.attribute_names
super unless @klass.send(:all_attributes_exists?, attributes)
@@ -163,10 +162,6 @@ def with_create_scope
@klass.send(:with_scope, :create => scope_for_create, :find => {}) { yield }
end
- def where_clause(join_string = " AND ")
- arel.send(:where_clauses).join(join_string)
- end
-
def references_eager_loaded_tables?
joined_tables = (tables_in_string(arel.joins(arel)) + [table.name, table.table_alias]).compact.uniq
(tables_in_string(to_sql) - joined_tables).any?
View
200 activerecord/lib/active_record/relation/calculation_methods.rb
@@ -1,200 +0,0 @@
-module ActiveRecord
- module CalculationMethods
-
- def count(*args)
- calculate(:count, *construct_count_options_from_args(*args))
- end
-
- # Calculates the average value on a given column. The value is returned as
- # a float, or +nil+ if there's no row. See +calculate+ for examples with
- # options.
- #
- # Person.average('age') # => 35.8
- def average(column_name, options = {})
- calculation_relation(options).calculate(:average, column_name)
- end
-
- # Calculates the minimum value on a given column. The value is returned
- # with the same data type of the column, or +nil+ if there's no row. See
- # +calculate+ for examples with options.
- #
- # Person.minimum('age') # => 7
- def minimum(column_name, options = {})
- calculation_relation(options).calculate(:minimum, column_name)
- end
-
- # Calculates the maximum value on a given column. The value is returned
- # with the same data type of the column, or +nil+ if there's no row. See
- # +calculate+ for examples with options.
- #
- # Person.maximum('age') # => 93
- def maximum(column_name, options = {})
- calculation_relation(options).calculate(:maximum, column_name)
- end
-
- # Calculates the sum of values on a given column. The value is returned
- # with the same data type of the column, 0 if there's no row. See
- # +calculate+ for examples with options.
- #
- # Person.sum('age') # => 4562
- def sum(column_name, options = {})
- calculation_relation(options).calculate(:sum, column_name)
- end
-
- def calculate(operation, column_name, options = {})
- operation = operation.to_s.downcase
-
- if operation == "count"
- joins = arel.joins(arel)
- if joins.present? && joins =~ /LEFT OUTER/i
- distinct = true
- column_name = @klass.primary_key if column_name == :all
- end
-
- distinct = nil if column_name.to_s =~ /\s*DISTINCT\s+/i
- distinct ||= options[:distinct]
- else
- distinct = nil
- end
-
- distinct = options[:distinct] || distinct
- column_name = :all if column_name.blank? && operation == "count"
-
- if @group_values.any?
- return execute_grouped_calculation(operation, column_name)
- else
- return execute_simple_calculation(operation, column_name, distinct)
- end
- rescue ThrowResult
- 0
- end
-
- def calculation_relation(options = {})
- if options.present?
- apply_finder_options(options.except(:distinct)).calculation_relation
- else
- (eager_loading? || includes_values.present?) ? construct_relation_for_association_calculations : self
- end
- end
-
- private
-
- def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
- column = if @klass.column_names.include?(column_name.to_s)
- Arel::Attribute.new(@klass.unscoped, column_name)
- else
- Arel::SqlLiteral.new(column_name == :all ? "*" : column_name.to_s)
- end
-
- relation = select(operation == 'count' ? column.count(distinct) : column.send(operation))
- type_cast_calculated_value(@klass.connection.select_value(relation.to_sql), column_for(column_name), operation)
- end
-
- def execute_grouped_calculation(operation, column_name) #:nodoc:
- group_attr = @group_values.first
- association = @klass.reflect_on_association(group_attr.to_sym)
- associated = association && association.macro == :belongs_to # only count belongs_to associations
- group_field = associated ? association.primary_key_name : group_attr
- group_alias = column_alias_for(group_field)
- group_column = column_for(group_field)
-
- group = @klass.connection.adapter_name == 'FrontBase' ? group_alias : group_field
-
- aggregate_alias = column_alias_for(operation, column_name)
-
- select_statement = if operation == 'count' && column_name == :all
- "COUNT(*) AS count_all"
- else
- Arel::Attribute.new(@klass.unscoped, column_name).send(operation).as(aggregate_alias).to_sql
- end
-
- select_statement << ", #{group_field} AS #{group_alias}"
-
- relation = select(select_statement).group(group)
-
- calculated_data = @klass.connection.select_all(relation.to_sql)
-
- if association
- key_ids = calculated_data.collect { |row| row[group_alias] }
- key_records = association.klass.base_class.find(key_ids)
- key_records = key_records.inject({}) { |hsh, r| hsh.merge(r.id => r) }
- end
-
- calculated_data.inject(ActiveSupport::OrderedHash.new) do |all, row|
- key = type_cast_calculated_value(row[group_alias], group_column)
- key = key_records[key] if associated
- value = row[aggregate_alias]
- all[key] = type_cast_calculated_value(value, column_for(column_name), operation)
- all
- end
- end
-
- def construct_count_options_from_args(*args)
- options = {}
- column_name = :all
-
- # Handles count(), count(:column), count(:distinct => true), count(:column, :distinct => true)
- case args.size
- when 0
- select = get_projection_name_from_chained_relations
- column_name = select if select !~ /(,|\*)/
- when 1
- if args[0].is_a?(Hash)
- select = get_projection_name_from_chained_relations
- column_name = select if select !~ /(,|\*)/
- options = args[0]
- else
- column_name = args[0]
- end
- when 2
- column_name, options = args
- else
- raise ArgumentError, "Unexpected parameters passed to count(): #{args.inspect}"
- end
-
- [column_name || :all, options]
- end
-
- # Converts the given keys to the value that the database adapter returns as
- # a usable column name:
- #
- # column_alias_for("users.id") # => "users_id"
- # column_alias_for("sum(id)") # => "sum_id"
- # column_alias_for("count(distinct users.id)") # => "count_distinct_users_id"
- # column_alias_for("count(*)") # => "count_all"
- # column_alias_for("count", "id") # => "count_id"
- def column_alias_for(*keys)
- table_name = keys.join(' ')
- table_name.downcase!
- table_name.gsub!(/\*/, 'all')
- table_name.gsub!(/\W+/, ' ')
- table_name.strip!
- table_name.gsub!(/ +/, '_')
-
- @klass.connection.table_alias_for(table_name)
- end
-
- def column_for(field)
- field_name = field.to_s.split('.').last
- @klass.columns.detect { |c| c.name.to_s == field_name }
- end
-
- def type_cast_calculated_value(value, column, operation = nil)
- case operation
- when 'count' then value.to_i
- when 'sum' then type_cast_using_column(value || '0', column)
- when 'average' then value && (value.is_a?(Fixnum) ? value.to_f : value).to_d
- else type_cast_using_column(value, column)
- end
- end
-
- def type_cast_using_column(value, column)
- column ? column.type_cast(value) : value
- end
-
- def get_projection_name_from_chained_relations
- @select_values.join(", ") if @select_values.present?
- end
-
- end
-end
View
259 activerecord/lib/active_record/relation/calculations.rb
@@ -0,0 +1,259 @@
+module ActiveRecord
+ module Calculations
+ # Count operates using three different approaches.
+ #
+ # * Count all: By not passing any parameters to count, it will return a count of all the rows for the model.
+ # * Count using column: By passing a column name to count, it will return a count of all the rows for the model with supplied column present
+ # * Count using options will find the row count matched by the options used.
+ #
+ # The third approach, count using options, accepts an option hash as the only parameter. The options are:
+ #
+ # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro to ActiveRecord::Base.
+ # * <tt>:joins</tt>: Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" (rarely needed)
+ # or named associations in the same form used for the <tt>:include</tt> option, which will perform an INNER JOIN on the associated table(s).
+ # If the value is a string, then the records will be returned read-only since they will have attributes that do not correspond to the table's columns.
+ # Pass <tt>:readonly => false</tt> to override.
+ # * <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 of DISTINCT items for the model you're counting.
+ # See eager loading under Associations.
+ # * <tt>:order</tt>: An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
+ # * <tt>:group</tt>: An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
+ # * <tt>:select</tt>: By default, this is * as in SELECT * FROM, but can be changed if you, for example, want to do a join but not
+ # include the joined columns.
+ # * <tt>:distinct</tt>: Set this to true to make this a distinct calculation, such as SELECT COUNT(DISTINCT posts.id) ...
+ # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed to an alternate table name (or even the name
+ # of a database view).
+ #
+ # Examples for counting all:
+ # Person.count # returns the total count of all people
+ #
+ # Examples for counting by column:
+ # Person.count(:age) # returns the total count of all people whose age is present in database
+ #
+ # Examples for count with options:
+ # Person.count(:conditions => "age > 26")
+ # Person.count(:conditions => "age > 26 AND job.salary > 60000", :include => :job) # because of the named association, it finds the DISTINCT count using LEFT OUTER JOIN.
+ # Person.count(:conditions => "age > 26 AND job.salary > 60000", :joins => "LEFT JOIN jobs on jobs.person_id = person.id") # finds the number of rows matching the conditions and joins.
+ # Person.count('id', :conditions => "age > 26") # Performs a COUNT(id)
+ # Person.count(:all, :conditions => "age > 26") # Performs a COUNT(*) (:all is an alias for '*')
+ #
+ # Note: <tt>Person.count(:all)</tt> will not work because it will use <tt>:all</tt> as the condition. Use Person.count instead.
+ def count(column_name = nil, options = {})
+ column_name, options = nil, column_name if column_name.is_a?(Hash)
+ calculate(:count, column_name, options)
+ end
+
+ # Calculates the average value on a given column. The value is returned as
+ # a float, or +nil+ if there's no row. See +calculate+ for examples with
+ # options.
+ #
+ # Person.average('age') # => 35.8
+ def average(column_name, options = {})
+ calculate(:average, column_name, options)
+ end
+
+ # Calculates the minimum value on a given column. The value is returned
+ # with the same data type of the column, or +nil+ if there's no row. See
+ # +calculate+ for examples with options.
+ #
+ # Person.minimum('age') # => 7
+ def minimum(column_name, options = {})
+ calculate(:minimum, column_name, options)
+ end
+
+ # Calculates the maximum value on a given column. The value is returned
+ # with the same data type of the column, or +nil+ if there's no row. See
+ # +calculate+ for examples with options.
+ #
+ # Person.maximum('age') # => 93
+ def maximum(column_name, options = {})
+ calculate(:maximum, column_name, options)
+ end
+
+ # Calculates the sum of values on a given column. The value is returned
+ # with the same data type of the column, 0 if there's no row. See
+ # +calculate+ for examples with options.
+ #
+ # Person.sum('age') # => 4562
+ def sum(column_name, options = {})
+ calculate(:sum, column_name, options)
+ end
+
+ # This calculates aggregate values in the given column. Methods for count, sum, average, minimum, and maximum have been added as shortcuts.
+ # Options such as <tt>:conditions</tt>, <tt>:order</tt>, <tt>:group</tt>, <tt>:having</tt>, and <tt>:joins</tt> can be passed to customize the query.
+ #
+ # There are two basic forms of output:
+ # * Single aggregate value: The single value is type cast to Fixnum for COUNT, Float for AVG, and the given column's type for everything else.
+ # * Grouped values: This returns an ordered hash of the values and groups them by the <tt>:group</tt> option. It takes either a column name, or the name
+ # of a belongs_to association.
+ #
+ # values = Person.maximum(:age, :group => 'last_name')
+ # puts values["Drake"]
+ # => 43
+ #
+ # drake = Family.find_by_last_name('Drake')
+ # values = Person.maximum(:age, :group => :family) # Person belongs_to :family
+ # puts values[drake]
+ # => 43
+ #
+ # values.each do |family, max_age|
+ # ...
+ # end
+ #
+ # Options:
+ # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro to ActiveRecord::Base.
+ # * <tt>:include</tt>: Eager loading, see Associations for details. Since calculations don't load anything, the purpose of this is to access fields on joined tables in your conditions, order, or group clauses.
+ # * <tt>:joins</tt> - An SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id". (Rarely needed).
+ # The records will be returned read-only since they will have attributes that do not correspond to the table's columns.
+ # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
+ # * <tt>:group</tt> - An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
+ # * <tt>:select</tt> - By default, this is * as in SELECT * FROM, but can be changed if you for example want to do a join, but not
+ # include the joined columns.
+ # * <tt>:distinct</tt> - Set this to true to make this a distinct calculation, such as SELECT COUNT(DISTINCT posts.id) ...
+ #
+ # Examples:
+ # Person.calculate(:count, :all) # The same as Person.count
+ # Person.average(:age) # SELECT AVG(age) FROM people...
+ # Person.minimum(:age, :conditions => ['last_name != ?', 'Drake']) # Selects the minimum age for everyone with a last name other than 'Drake'
+ # Person.minimum(:age, :having => 'min(age) > 17', :group => :last_name) # Selects the minimum age for any family without any minors
+ # Person.sum("2 * age")
+ def calculate(operation, column_name, options = {})
+ if options.except(:distinct).present?
+ apply_finder_options(options.except(:distinct)).calculate(operation, column_name, :distinct => options[:distinct])
+ else
+ if eager_loading? || includes_values.present?
+ construct_relation_for_association_calculations.calculate(operation, column_name, options)
+ else
+ perform_calculation(operation, column_name, options)
+ end
+ end
+ rescue ThrowResult
+ 0
+ end
+
+ private
+
+ def perform_calculation(operation, column_name, options = {})
+ operation = operation.to_s.downcase
+
+ if operation == "count"
+ column_name ||= (select_for_count || :all)
+
+ joins = arel.joins(arel)
+ if joins.present? && joins =~ /LEFT OUTER/i
+ distinct = true
+ column_name = @klass.primary_key if column_name == :all
+ end
+
+ distinct = nil if column_name.to_s =~ /\s*DISTINCT\s+/i
+ distinct ||= options[:distinct]
+ else
+ distinct = nil
+ end
+
+ distinct = options[:distinct] || distinct
+ column_name = :all if column_name.blank? && operation == "count"
+
+ if @group_values.any?
+ return execute_grouped_calculation(operation, column_name)
+ else
+ return execute_simple_calculation(operation, column_name, distinct)
+ end
+ end
+
+ def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
+ column = if @klass.column_names.include?(column_name.to_s)
+ Arel::Attribute.new(@klass.unscoped, column_name)
+ else
+ Arel::SqlLiteral.new(column_name == :all ? "*" : column_name.to_s)
+ end
+
+ # Postgresql doesn't like ORDER BY when there are no GROUP BY
+ relation = except(:order).select(operation == 'count' ? column.count(distinct) : column.send(operation))
+ type_cast_calculated_value(@klass.connection.select_value(relation.to_sql), column_for(column_name), operation)
+ end
+
+ def execute_grouped_calculation(operation, column_name) #:nodoc:
+ group_attr = @group_values.first
+ association = @klass.reflect_on_association(group_attr.to_sym)
+ associated = association && association.macro == :belongs_to # only count belongs_to associations
+ group_field = associated ? association.primary_key_name : group_attr
+ group_alias = column_alias_for(group_field)
+ group_column = column_for(group_field)
+
+ group = @klass.connection.adapter_name == 'FrontBase' ? group_alias : group_field
+
+ aggregate_alias = column_alias_for(operation, column_name)
+
+ select_statement = if operation == 'count' && column_name == :all
+ "COUNT(*) AS count_all"
+ else
+ Arel::Attribute.new(@klass.unscoped, column_name).send(operation).as(aggregate_alias).to_sql
+ end
+
+ select_statement << ", #{group_field} AS #{group_alias}"
+
+ relation = select(select_statement).group(group)
+
+ calculated_data = @klass.connection.select_all(relation.to_sql)
+
+ if association
+ key_ids = calculated_data.collect { |row| row[group_alias] }
+ key_records = association.klass.base_class.find(key_ids)
+ key_records = key_records.inject({}) { |hsh, r| hsh.merge(r.id => r) }
+ end
+
+ calculated_data.inject(ActiveSupport::OrderedHash.new) do |all, row|
+ key = type_cast_calculated_value(row[group_alias], group_column)
+ key = key_records[key] if associated
+ value = row[aggregate_alias]
+ all[key] = type_cast_calculated_value(value, column_for(column_name), operation)
+ all
+ end
+ end
+
+ # Converts the given keys to the value that the database adapter returns as
+ # a usable column name:
+ #
+ # column_alias_for("users.id") # => "users_id"
+ # column_alias_for("sum(id)") # => "sum_id"
+ # column_alias_for("count(distinct users.id)") # => "count_distinct_users_id"
+ # column_alias_for("count(*)") # => "count_all"
+ # column_alias_for("count", "id") # => "count_id"
+ def column_alias_for(*keys)
+ table_name = keys.join(' ')
+ table_name.downcase!
+ table_name.gsub!(/\*/, 'all')
+ table_name.gsub!(/\W+/, ' ')
+ table_name.strip!
+ table_name.gsub!(/ +/, '_')
+
+ @klass.connection.table_alias_for(table_name)
+ end
+
+ def column_for(field)
+ field_name = field.to_s.split('.').last
+ @klass.columns.detect { |c| c.name.to_s == field_name }
+ end
+
+ def type_cast_calculated_value(value, column, operation = nil)
+ case operation
+ when 'count' then value.to_i
+ when 'sum' then type_cast_using_column(value || '0', column)
+ when 'average' then value && (value.is_a?(Fixnum) ? value.to_f : value).to_d
+ else type_cast_using_column(value, column)
+ end
+ end
+
+ def type_cast_using_column(value, column)
+ column ? column.type_cast(value) : value
+ end
+
+ def select_for_count
+ if @select_values.present?
+ select = @select_values.join(", ")
+ select if select !~ /(,|\*)/
+ end
+ end
+ end
+end
View
187 activerecord/lib/active_record/relation/finder_methods.rb
@@ -1,45 +1,128 @@
module ActiveRecord
module FinderMethods
-
- def find(*ids, &block)
+ # Find operates with four different retrieval approaches:
+ #
+ # * Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
+ # If no record can be found for all of the listed ids, then RecordNotFound will be raised.
+ # * Find first - This will return the first record matched by the options used. These options can either be specific
+ # conditions or merely an order. If no record can be matched, +nil+ is returned. Use
+ # <tt>Model.find(:first, *args)</tt> or its shortcut <tt>Model.first(*args)</tt>.
+ # * Find last - This will return the last record matched by the options used. These options can either be specific
+ # conditions or merely an order. If no record can be matched, +nil+ is returned. Use
+ # <tt>Model.find(:last, *args)</tt> or its shortcut <tt>Model.last(*args)</tt>.
+ # * Find all - This will return all the records matched by the options used.
+ # If no records are found, an empty array is returned. Use
+ # <tt>Model.find(:all, *args)</tt> or its shortcut <tt>Model.all(*args)</tt>.
+ #
+ # All approaches accept an options hash as their last parameter.
+ #
+ # ==== Parameters
+ #
+ # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1", <tt>[ "user_name = ?", username ]</tt>, or <tt>["user_name = :user_name", { :user_name => user_name }]</tt>. See conditions in the intro.
+ # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name".
+ # * <tt>:group</tt> - An attribute name by which the result should be grouped. Uses the <tt>GROUP BY</tt> SQL-clause.
+ # * <tt>:having</tt> - Combined with +:group+ this can be used to filter the records that a <tt>GROUP BY</tt> returns. Uses the <tt>HAVING</tt> SQL-clause.
+ # * <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.
+ # * <tt>:joins</tt> - Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" (rarely needed),
+ # named associations in the same form used for the <tt>:include</tt> option, which will perform an <tt>INNER JOIN</tt> on the associated table(s),
+ # or an array containing a mixture of both strings and named associations.
+ # If the value is a string, then the records will be returned read-only since they will have attributes that do not correspond to the table's columns.
+ # Pass <tt>:readonly => false</tt> to override.
+ # * <tt>:include</tt> - Names associations that should be loaded alongside. The symbols named refer
+ # to already defined associations. See eager loading under Associations.
+ # * <tt>:select</tt> - By default, this is "*" as in "SELECT * FROM", but can be changed if you, for example, want to do a join but not
+ # include the joined columns. Takes a string with the SELECT SQL fragment (e.g. "id, name").
+ # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed to an alternate table name (or even the name
+ # of a database view).
+ # * <tt>:readonly</tt> - Mark the returned records read-only so they cannot be saved or updated.
+ # * <tt>:lock</tt> - An SQL fragment like "FOR UPDATE" or "LOCK IN SHARE MODE".
+ # <tt>:lock => true</tt> gives connection's default exclusive lock, usually "FOR UPDATE".
+ #
+ # ==== Examples
+ #
+ # # find by id
+ # Person.find(1) # returns the object for ID = 1
+ # Person.find(1, 2, 6) # returns an array for objects with IDs in (1, 2, 6)
+ # Person.find([7, 17]) # returns an array for objects with IDs in (7, 17)
+ # Person.find([1]) # returns an array for the object with ID = 1
+ # Person.find(1, :conditions => "administrator = 1", :order => "created_on DESC")
+ #
+ # Note that returned records may not be in the same order as the ids you
+ # provide since database rows are unordered. Give an explicit <tt>:order</tt>
+ # to ensure the results are sorted.
+ #
+ # ==== Examples
+ #
+ # # find first
+ # Person.find(:first) # returns the first object fetched by SELECT * FROM people
+ # Person.find(:first, :conditions => [ "user_name = ?", user_name])
+ # Person.find(:first, :conditions => [ "user_name = :u", { :u => user_name }])
+ # Person.find(:first, :order => "created_on DESC", :offset => 5)
+ #
+ # # find last
+ # Person.find(:last) # returns the last object fetched by SELECT * FROM people
+ # Person.find(:last, :conditions => [ "user_name = ?", user_name])
+ # Person.find(:last, :order => "created_on DESC", :offset => 5)
+ #
+ # # find all
+ # Person.find(:all) # returns an array of objects for all the rows fetched by SELECT * FROM people
+ # Person.find(:all, :conditions => [ "category IN (?)", categories], :limit => 50)
+ # Person.find(:all, :conditions => { :friends => ["Bob", "Steve", "Fred"] }
+ # Person.find(:all, :offset => 10, :limit => 10)
+ # Person.find(:all, :include => [ :account, :friends ])
+ # Person.find(:all, :group => "category")
+ #
+ # Example for find with a lock: Imagine two concurrent transactions:
+ # each will read <tt>person.visits == 2</tt>, add 1 to it, and save, resulting
+ # in two saves of <tt>person.visits = 3</tt>. By locking the row, the second
+ # transaction has to wait until the first is finished; we get the
+ # expected <tt>person.visits == 4</tt>.
+ #
+ # Person.transaction do
+ # person = Person.find(1, :lock => true)
+ # person.visits += 1
+ # person.save!
+ # end
+ def find(*args, &block)
return to_a.find(&block) if block_given?
- expects_array = ids.first.kind_of?(Array)
- return ids.first if expects_array && ids.first.empty?
-
- ids = ids.flatten.compact.uniq
+ options = args.extract_options!
- case ids.size
- when 0
- raise RecordNotFound, "Couldn't find #{@klass.name} without an ID"
- when 1
- result = find_one(ids.first)
- expects_array ? [ result ] : result
+ if options.present?
+ apply_finder_options(options).find(*args)
else
- find_some(ids)
+ case args.first
+ when :first, :last, :all
+ send(args.first)
+ else
+ find_with_ids(*args)
+ end
end
end
- def exists?(id = nil)
- relation = select(primary_key).limit(1)
- relation = relation.where(primary_key.eq(id)) if id
- relation.first ? true : false
+ # A convenience wrapper for <tt>find(:first, *args)</tt>. You can pass in all the
+ # same arguments to this method as you can to <tt>find(:first)</tt>.
+ def first(*args)
+ args.any? ? apply_finder_options(args.first).first : find_first
end
- def first
- if loaded?
- @records.first
- else
- @first ||= limit(1).to_a[0]
- end
+ # A convenience wrapper for <tt>find(:last, *args)</tt>. You can pass in all the
+ # same arguments to this method as you can to <tt>find(:last)</tt>.
+ def last(*args)
+ args.any? ? apply_finder_options(args.first).last : find_last
end
- def last
- if loaded?
- @records.last
- else
- @last ||= reverse_order.limit(1).to_a[0]
- end
+ # A convenience wrapper for <tt>find(:all, *args)</tt>. You can pass in all the
+ # same arguments to this method as you can to <tt>find(:all)</tt>.
+ def all(*args)
+ args.any? ? apply_finder_options(args.first).to_a : to_a
+ end
+
+ def exists?(id = nil)
+ relation = select(primary_key).limit(1)
+ relation = relation.where(primary_key.eq(id)) if id
+ relation.first ? true : false
end
protected
@@ -56,12 +139,17 @@ def find_with_associations
def construct_relation_for_association_calculations
including = (@eager_load_values + @includes_values).uniq
join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, including, arel.joins(arel))
- construct_relation_for_association_find(join_dependency)
+
+ relation = except(:includes, :eager_load, :preload)
+ apply_join_dependency(relation, join_dependency)
end
def construct_relation_for_association_find(join_dependency)
relation = except(:includes, :eager_load, :preload, :select).select(@klass.send(:column_aliases, join_dependency))
+ apply_join_dependency(relation, join_dependency)
+ end
+ def apply_join_dependency(relation, join_dependency)
for association in join_dependency.join_associations
relation = association.join_relation(relation)
end
@@ -119,11 +207,30 @@ def find_or_instantiator_by_attributes(match, attributes, *args)
record
end
+ def find_with_ids(*ids, &block)
+ return to_a.find(&block) if block_given?
+
+ expects_array = ids.first.kind_of?(Array)
+ return ids.first if expects_array && ids.first.empty?
+
+ ids = ids.flatten.compact.uniq
+
+ case ids.size
+ when 0
+ raise RecordNotFound, "Couldn't find #{@klass.name} without an ID"
+ when 1
+ result = find_one(ids.first)
+ expects_array ? [ result ] : result
+ else
+ find_some(ids)
+ end
+ end
+
def find_one(id)
record = where(primary_key.eq(id)).first
unless record
- conditions = where_clause(', ')
+ conditions = arel.send(:where_clauses).join(', ')
conditions = " [WHERE #{conditions}]" if conditions.present?
raise RecordNotFound, "Couldn't find #{@klass.name} with ID=#{id}#{conditions}"
end
@@ -149,7 +256,7 @@ def find_some(ids)
if result.size == expected_size
result
else
- conditions = where_clause(', ')
+ conditions = arel.send(:where_clauses).join(', ')
conditions = " [WHERE #{conditions}]" if conditions.present?
error = "Couldn't find all #{@klass.name.pluralize} with IDs "
@@ -158,5 +265,21 @@ def find_some(ids)
end
end
+ def find_first
+ if loaded?
+ @records.first
+ else
+ @first ||= limit(1).to_a[0]
+ end
+ end
+
+ def find_last
+ if loaded?
+ @records.last
+ else
+ @last ||= reverse_order.limit(1).to_a[0]
+ end
+ end
+
end
end
View
8 activerecord/lib/active_record/relation/query_methods.rb