ActiveRecord destroy - no exception - exception

Question

I'm doing a destroy via ActiveRecord using a field. However, a record in the database with that field value does not exist. So, given this bit of debugging using pry:
[1] pry(main)> fieldvalue
=> "17785"
[2] pry(main)> person = Person.where(:fieldname => fieldvalue.to_i)
=> []
[3] pry(main)> person
=> []
[4] pry(main)> person.destroy_all
=> []
...why does it not raise an exception at step 4?
The original bit of code, similarly, silently fails to raise an exception:
begin
Person.where(:fieldname => fieldvalue.to_i).destroy_all
rescue ActiveRecord::RecordNotFound => exception
#logger.info("ActiveRecord::RecordNotFound exception raised. Details: #{exception}")
rescue Exception => exception
#logger.info("Unknown exception raised. Details: #{exception}")
else
#logger.info("Destroying person with field value: #{fieldvalue}")
end
i.e. it just logs the "Destroying..." line each time it's run.

Answer 1

destroy_all does not raise an exception when executed on an empty set ([]) because the method, according to the documentation:
Destroys the records matching conditions by instantiating each record and calling its destroy method.
Because your where query is returning an empty set, there are no records to instantiate – destroy is never actually being executed on anything, hence there are no exceptions thrown.
Contrast this to a hypothetical situation wherein a set is returned that – for some unlikely reason – contained a nil object. The set might look something like this
people = Person.where("created_at < ?", Time.now)
#=> [#<Person id:1>, nil, #<Person id:2>] # for demonstration only; would not actually happen
people.destroy_all
#=> NoMethodError: undefined method `destroy' for nil:NilClass
A NoMethodError would be thrown on the second iteration of destroy_all, since destroy would be executed on nil, which does not have a destroy method.
One other thought: you may be conflating the where ActiveRecord method with the find method. where returns an ActiveRecord::Relation object, which effectively operates as an array of objects which match the passed conditions. find, in contrast, returns the first object itself_ which match the conditions passed. In the real world example from above, if you're seeking to return a single object from your query, it may make more sense to use find rather than where:
people = Person.where(:fieldname => fieldvalue.to_i) # returns a collection of all objects matching the condition
people.class
#=> ActiveRecord::Relation
person = Person.find(:fieldname => fieldvalue.to_i) # returns the FIRST object matching the condition
person.class
#=> Person