2 从数据库中检索对象

要从数据库中检索对象，Active Record提供了几种查找方法。每个查找方法允许您传入参数，以在不编写原始SQL的情况下执行特定的数据库查询。

这些方法包括：

返回集合的查找方法，如where和group，返回ActiveRecord::Relation的实例。查找单个实体的方法，如find和first，返回模型的单个实例。

Model.find(options)的主要操作可以总结如下：

将提供的选项转换为等效的SQL查询。
执行SQL查询，并从数据库中检索相应的结果。
为每一行结果实例化适当模型的等效Ruby对象。
运行after_find，然后是after_initialize回调（如果有）。

2.1 检索单个对象

Active Record提供了几种检索单个对象的方法。

2.1.1 `find`

使用find方法，您可以检索与任何提供的选项匹配的指定主键对应的对象。例如：

# 查找主键（id）为10的客户。
irb> customer = Customer.find(10)
=> #<Customer id: 10, first_name: "Ryan">

以上的SQL等效语句为：

SELECT * FROM customers WHERE (customers.id = 10) LIMIT 1

如果找不到匹配的记录，find方法将引发ActiveRecord::RecordNotFound异常。

您还可以使用此方法查询多个对象。调用find方法并传入一个主键数组。返回的将是一个包含所有匹配的记录的数组，供应用主键。例如： ```irb

查找主键为1和10的客户。

irb> customers = Customer.find([1, 10]) # 或者 Customer.find(1, 10) => [#, #] ```

上述代码的SQL等效语句为：

SELECT * FROM customers WHERE (customers.id IN (1,10))

警告：如果没有找到与所有提供的主键匹配的记录，find方法将引发ActiveRecord::RecordNotFound异常。

2.1.2 `take`

take方法可以检索一条记录，没有隐式排序。例如：

irb> customer = Customer.take
=> #<Customer id: 1, first_name: "Lifo">

上述代码的SQL等效语句为：

SELECT * FROM customers LIMIT 1

如果没有找到记录，take方法将返回nil，不会引发异常。

您可以传入一个数字参数给take方法，以返回指定数量的结果。例如：

irb> customers = Customer.take(2)
=> [#<Customer id: 1, first_name: "Lifo">, #<Customer id: 220, first_name: "Sara">]

上述代码的SQL等效语句为：

SELECT * FROM customers LIMIT 2

take!方法与take方法的行为完全相同，只是如果没有找到匹配的记录，它会引发ActiveRecord::RecordNotFound异常。

提示：检索到的记录可能因数据库引擎而异。

2.1.3 `first`

first方法按照主键（默认）顺序查找第一条记录。例如：

irb> customer = Customer.first
=> #<Customer id: 1, first_name: "Lifo">

上述代码的SQL等效语句为：

SELECT * FROM customers ORDER BY customers.id ASC LIMIT 1

如果没有找到匹配的记录，first方法将返回nil，不会引发异常。

如果您的默认作用域包含一个order方法，first将根据此排序返回第一条记录。

您可以传入一个数字参数给first方法，以返回指定数量的结果。例如：

irb> customers = Customer.first(3)
=> [#<Customer id: 1, first_name: "Lifo">, #<Customer id: 2, first_name: "Fifo">, #<Customer id: 3, first_name: "Filo">]

上述代码的SQL等效语句为：

SELECT * FROM customers ORDER BY customers.id ASC LIMIT 3

在使用order进行排序的集合上，first将返回按指定属性进行排序的第一条记录。

irb> customer = Customer.order(:first_name).first
=> #<Customer id: 2, first_name: "Fifo">

上述代码的SQL等效语句为：

SELECT * FROM customers ORDER BY customers.first_name ASC LIMIT 1

first!方法与first方法的行为完全相同，只是如果没有找到匹配的记录，它会引发ActiveRecord::RecordNotFound异常。

2.1.4 `last`

last方法按照主键（默认）顺序查找最后一条记录。例如：

irb> customer = Customer.last
=> #<Customer id: 221, first_name: "Russel">

上述代码的SQL等效语句为：

SELECT * FROM customers ORDER BY customers.id DESC LIMIT 1

如果没有找到匹配的记录，last方法将返回nil，不会引发异常。

如果您的默认作用域包含一个order方法，last将根据此排序返回最后一条记录。

您可以传入一个数字参数给last方法，以返回指定数量的结果。例如：

irb> customers = Customer.last(3)
=> [#<Customer id: 219, first_name: "James">, #<Customer id: 220, first_name: "Sara">, #<Customer id: 221, first_name: "Russel">]

上述代码的SQL等效语句为：

SELECT * FROM customers ORDER BY customers.id DESC LIMIT 3

在使用order进行排序的集合上，last将返回按指定属性进行排序的最后一条记录。

irb> customer = Customer.order(:first_name).last
=> #<Customer id: 220, first_name: "Sara">

上述代码的SQL等效语句为：

SELECT * FROM customers ORDER BY customers.first_name DESC LIMIT 1

last!方法与last方法的行为完全相同，只是如果没有找到匹配的记录，它会引发ActiveRecord::RecordNotFound异常。

2.1.5 `find_by`

find_by方法查找与某些条件匹配的第一条记录。例如：

irb> Customer.find_by first_name: 'Lifo'
=> #<Customer id: 1, first_name: "Lifo">

irb> Customer.find_by first_name: 'Jon'
=> nil

等效于以下代码：

Customer.where(first_name: 'Lifo').take

上述代码的SQL等效语句为：

SELECT * FROM customers WHERE (customers.first_name = 'Lifo') LIMIT 1

请注意，上述SQL中没有ORDER BY。如果您的find_by条件可以匹配多条记录，您应该应用排序以确保确定性结果。

find_by!方法的行为与find_by完全相同，唯一的区别是如果找不到匹配的记录，它会引发ActiveRecord::RecordNotFound异常。例如：

irb> Customer.find_by! first_name: 'does not exist'
ActiveRecord::RecordNotFound

这等同于编写以下代码：

Customer.where(first_name: 'does not exist').take!

2.2 批量检索多个对象

我们经常需要迭代处理大量的记录，比如向一大批客户发送通讯，或者导出数据。

这种方法可能看起来很简单：

# 如果表很大，这可能会消耗太多的内存。
Customer.all.each do |customer|
  NewsMailer.weekly(customer).deliver_now
end

但是随着表的大小增加，这种方法变得越来越不实用，因为Customer.all.each指示Active Record在一次遍历中获取整个表，为每一行构建一个模型对象，然后将整个模型对象数组保存在内存中。实际上，如果我们有大量的记录，整个集合可能会超过可用的内存量。

Rails提供了两种方法来解决这个问题，将记录分成适合内存的批次进行处理。第一种方法是find_each，它检索一批记录，然后将每个记录作为模型对象逐个传递给块。第二种方法是find_in_batches，它检索一批记录，然后将整个批次作为模型对象数组传递给块。

提示：find_each和find_in_batches方法适用于批量处理大量记录的情况，这些记录无法一次性全部放入内存中。如果您只需要循环遍历一千条记录，常规的查找方法是首选的选项。

2.2.1 `find_each`

find_each方法按批次检索记录，然后将每个记录作为模型对象逐个传递给块。在下面的示例中，find_each以每次1000条的批次检索客户记录，并逐个将它们传递给块：

Customer.find_each do |customer|
  NewsMailer.weekly(customer).deliver_now
end

这个过程会重复进行，根据需要获取更多的批次，直到处理完所有的记录。

find_each可以用于模型类，如上所示，也可以用于关联关系：

Customer.where(weekly_subscriber: true).find_each do |customer|
  NewsMailer.weekly(customer).deliver_now
end

只要它们没有排序，因为该方法需要在内部强制排序以进行迭代。

如果接收者中存在排序，则行为取决于标志config.active_record.error_on_ignored_order。如果为true，则引发ArgumentError异常，否则忽略排序并发出警告，这是默认行为。可以使用选项:error_on_ignore覆盖此行为，下面会解释。

2.2.1.1 `find_each`的选项

:batch_size

:batch_size选项允许您指定每个批次要检索的记录数，在传递给块之前逐个传递。例如，要以每批5000条记录的方式检索记录：

Customer.find_each(batch_size: 5000) do |customer|
  NewsMailer.weekly(customer).deliver_now
end

:start

默认情况下，记录按照主键的升序进行获取。start选项允许您在最低ID不是您所需的ID时配置序列的第一个ID。例如，如果您想要恢复一个中断的批处理过程，只发送给从2000开始的客户：

Customer.find_each(start: 2000) do |customer|
  NewsMailer.weekly(customer).deliver_now
end

:finish

与start选项类似，finish选项允许您在最高ID不是您所需的ID时配置序列的最后一个ID。例如，如果您想要使用基于start和finish的记录子集运行批处理，只发送给从2000开始到10000的客户：

Customer.find_each(start: 2000, finish: 10000) do |customer|
  NewsMailer.weekly(customer).deliver_now
end

另一个例子是如果您想要多个工作进程处理相同的处理队列。您可以通过为每个工作进程设置适当的start和finish选项，使每个工作进程处理10000条记录。

:error_on_ignore

覆盖应用程序配置，指定在关系中存在排序时是否应引发错误。

:order

指定主键的排序顺序（可以是:asc或:desc）。默认为:asc。 ruby Customer.find_each(order: :desc) do |customer| NewsMailer.weekly(customer).deliver_now end

2.2.2 `find_in_batches`

find_in_batches 方法与 find_each 类似，都是检索记录的批处理方法。不同之处在于，find_in_batches 将批次作为模型数组传递给块，而不是逐个传递。以下示例将一次向提供的块传递最多 1000 个客户的数组，最后一个块包含任何剩余的客户：

# 每次给 add_customers 传递一个包含 1000 个客户的数组。
Customer.find_in_batches do |customers|
  export.add_customers(customers)
end

find_in_batches 可以用于模型类，如上所示，也可以用于关系：

# 每次给 add_customers 传递一个包含 1000 个最近活跃客户的数组。
Customer.recently_active.find_in_batches do |customers|
  export.add_customers(customers)
end

只要它们没有排序，因为该方法需要在内部强制排序以进行迭代。

2.2.2.1 `find_in_batches` 的选项

find_in_batches 方法接受与 find_each 相同的选项：

:batch_size

与 find_each 一样，batch_size 确定每个组中将检索多少条记录。例如，可以指定每次检索 2500 条记录的批次：

Customer.find_in_batches(batch_size: 2500) do |customers|
  export.add_customers(customers)
end

:start

start 选项允许指定从哪个 ID 开始选择记录。如前所述，默认情况下，按照主键的升序获取记录。例如，要检索从 ID 5000 开始的客户，每次检索 2500 条记录，可以使用以下代码：

Customer.find_in_batches(batch_size: 2500, start: 5000) do |customers|
  export.add_customers(customers)
end

:finish

finish 选项允许指定要检索的记录的结束 ID。下面的代码显示了按批次检索客户，直到 ID 为 7000 的客户：

Customer.find_in_batches(finish: 7000) do |customers|
  export.add_customers(customers)
end

:error_on_ignore

error_on_ignore 选项覆盖应用程序配置，指定在关系中存在特定顺序时是否应引发错误。

3 条件

where 方法允许您指定条件以限制返回的记录，表示 SQL 语句的 WHERE 部分。条件可以指定为字符串、数组或哈希。

3.1 纯字符串条件

如果您想要在查找中添加条件，可以直接在其中指定它们，就像 Book.where("title = 'Introduction to Algorithms'") 一样。这将找到 title 字段值为 'Introduction to Algorithms' 的所有书籍。

警告：将自己的条件构建为纯字符串可能会使您容易受到 SQL 注入攻击。例如，Book.where("title LIKE '%#{params[:title]}%'") 是不安全的。有关使用数组处理条件的首选方法，请参阅下一节。

3.2 数组条件

现在，如果该标题可能会变化，比如来自某个地方的参数？则查找将采用以下形式：

Book.where("title = ?", params[:title])

Active Record 将第一个参数视为条件字符串，任何其他参数都将替换其中的问号 (?)。

如果要指定多个条件：

Book.where("title = ? AND out_of_print = ?", params[:title], false)

在此示例中，第一个问号将被 params[:title] 中的值替换，第二个问号将被 false 的 SQL 表示形式替换，具体取决于适配器。

以下代码非常可取：

Book.where("title = ?", params[:title])

而不是这段代码：

Book.where("title = #{params[:title]}")

因为它具有参数安全性。直接将变量放入条件字符串中将变量原样传递给数据库。这意味着它将是来自可能具有恶意意图的用户的未转义变量。如果这样做，您将使整个数据库处于风险之中，因为一旦用户发现他们可以利用您的数据库，他们可以对其进行任何操作。永远不要直接将参数放在条件字符串中。

提示：有关 SQL 注入的危险的更多信息，请参阅Ruby on Rails 安全指南。

3.2.2 使用 `LIKE` 的条件

尽管条件参数会自动转义以防止 SQL 注入，但 SQL 的 LIKE 通配符（即 % 和 _）不会被转义。如果在参数中使用未经过处理的值，可能会导致意外行为。例如： ruby Book.order(:created_at).order(:title)