blocks|key|2686490|text|听起来你在做这样的事：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2686491|Model.where("attribute+=+?+OR+attribute2+=+?",+[value,+value])|code-block|syntax|javascript|2686492|然而，你需要这样做：|2686493|#+notice+the+lack+of+an+array+as+the+last+argument
Model.where("attribute+=+?+OR+attribute2+=+?",+value,+value)|2686494|有关如何工作的更多细节，请查看http://guides.rubyonrails.org/active_record_querying.html#array-conditions。|offset|length|2686495|entityMap|0|LINK|mutability|MUTABLE|url|http://guides.rubyonrails.org/active_record_querying.html#array-conditions^0|0|0|0|0|F|22|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Sounds like you're doing something like this:

<pre><code>Model.where("attribute = ? OR attribute2 = ?", [value, value])
</code></pre>

Whereas you need to do this:

<pre><code># notice the lack of an array as the last argument
Model.where("attribute = ? OR attribute2 = ?", value, value)
</code></pre>

Have a look at <a href="http://guides.rubyonrails.org/active_record_querying.html#array-conditions" rel="noreferrer">http://guides.rubyonrails.org/active_record_querying.html#array-conditions</a> for more details on how this works.

blocks|key|546333|text|如果您想将一个开放的条件列表(属性名和值)链接在一起，我建议使用attribute。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|546334|由于您的问题非常模糊，所以很难给出具体的说明，因此我将只解释如何对Post模型的简单示例和一些属性(如title、summary和user_id+(即用户has_many帖子))这样做。|offset|length|style|CODE|546335|首先，获取模型的：|546336|table+=+Post.arel_table|code-block|syntax|javascript|546337|然后，开始构建谓词(最终将用于创建SQL查询)：|546338|relation+=+table[:title].eq("Foo")
relation+=+relation.or(table[:summary].eq("A+post+about+foo"))
relation+=+relation.and(table[:user_id].eq(5))|546339|在这里，table[:title]、table[:summary]和table[:user_id]是posts表中列的表示形式。当您调用table[:title].eq("Foo")时，您将创建一个大致相当于查找条件的谓词(获取标题列等于“Foo”的所有行)。这些谓词可以与and和or链接在一起。|546340|当聚合谓词准备就绪时，可以使用以下方法获得结果：|546341|Post.where(relation)|546342|它将生成SQL：|546343|SELECT+"posts".*+FROM+"posts"
WHERE+(("posts"."title"+=+"Foo"+OR+"posts"."summary"+=+"A+post+about+foo")
AND+"posts"."user_id"+=+5)|546344|这将使您获得标题为"Foo“或摘要”关于foo的帖子“的所有帖子，这些帖子属于id为5的用户。|546345|请注意，rel谓词可以无休止地链接在一起，以创建越来越复杂的查询。这意味着，如果您有(比方说)属性/值对的散列，并且有某种方式知道是否对每个属性/值对使用AND或OR，则可以逐一遍历它们并建立条件：|546346|relation+=+table[:title].eq("Foo")
hash.each+do+%7Cattr,+value%7C
++relation+=+relation.and(table[attr].eq(value))
++#+or+relation+=+relation.or(table[attr].eq(value))+for+an+OR+predicate
end
Post.where(relation)|546347|除了易于链接的条件外，database的另一个优点是它们独立于数据库，因此您不必担心您的MySQL查询是否在PostgreSQL中工作，等等。|546348|这是一个更多关于arel：http://railscasts.com/episodes/215-advanced-queries-in-rails-3?view=asciicast的Railscast|546349|希望这能有所帮助。|546350|entityMap|0|LINK|mutability|MUTABLE|url|http://railscasts.com/episodes/215-advanced-queries-in-rails-3?view=asciicast^0|0|X|4|1F|5|1L|7|1T|7|25|8|0|0|0|0|0|4|D|I|F|Y|F|1E|5|1W|N|3T|3|3X|2|0|0|0|0|0|0|25|3|29|2|0|0|0|D|25|0|0|0^^$0|@$1|2|3|4|5|6|7|1M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1N|8|@$D|1O|E|1P|F|G]|$D|1Q|E|1R|F|G]|$D|1S|E|1T|F|G]|$D|1U|E|1V|F|G]|$D|1W|E|1X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1Z|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|20|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|21|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|22|8|@$D|23|E|24|F|G]|$D|25|E|26|F|G]|$D|27|E|28|F|G]|$D|29|E|2A|F|G]|$D|2B|E|2C|F|G]|$D|2D|E|2E|F|G]|$D|2F|E|2G|F|G]]|9|@]|A|$]]|$1|U|3|V|5|6|7|2H|8|@]|9|@]|A|$]]|$1|W|3|X|5|L|7|2I|8|@]|9|@]|A|$M|N]]|$1|Y|3|Z|5|6|7|2J|8|@]|9|@]|A|$]]|$1|10|3|11|5|L|7|2K|8|@]|9|@]|A|$M|N]]|$1|12|3|13|5|6|7|2L|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|2M|8|@$D|2N|E|2O|F|G]|$D|2P|E|2Q|F|G]]|9|@]|A|$]]|$1|16|3|17|5|L|7|2R|8|@]|9|@]|A|$M|N]]|$1|18|3|19|5|6|7|2S|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|2T|8|@]|9|@$D|2U|E|2V|1|2W]]|A|$]]|$1|1C|3|1D|5|6|7|2X|8|@]|9|@]|A|$]]|$1|1E|3|-4|5|6|7|2Y|8|@]|9|@]|A|$]]]|1F|$1G|$5|1H|1I|1J|A|$1K|1L]]]]

If you want to chain together an open-ended list of conditions (attribute names and values), I would suggest using an arel table.

It's a bit hard to give specifics since your question is so vague, so I'll just explain how to do this for a simple case of a <code>Post</code> model and a few attributes, say <code>title</code>, <code>summary</code>, and <code>user_id</code> (i.e. a user <code>has_many</code> posts).

First, get the arel table for the model:

<pre><code>table = Post.arel_table
</code></pre>

Then, start building your predicate (which you will eventually use to create an SQL query):

<pre><code>relation = table[:title].eq("Foo")
relation = relation.or(table[:summary].eq("A post about foo"))
relation = relation.and(table[:user_id].eq(5))
</code></pre>

Here, <code>table[:title]</code>, <code>table[:summary]</code> and <code>table[:user_id]</code> are representations of columns in the <code>posts</code> table. When you call <code>table[:title].eq("Foo")</code>, you are creating a predicate, roughly equivalent to a find condition (get all rows whose title column equals "Foo"). These predicates can be chained together with <code>and</code> and <code>or</code>.

When your aggregate predicate is ready, you can get the result with:

<pre><code>Post.where(relation)
</code></pre>

which will generate the SQL:

<pre><code>SELECT "posts".* FROM "posts"
WHERE (("posts"."title" = "Foo" OR "posts"."summary" = "A post about foo")
AND "posts"."user_id" = 5)
</code></pre>

This will get you all posts that have either the title "Foo" or the summary "A post about foo", and which belong to a user with id 5.

Notice the way arel predicates can be endlessly chained together to create more and more complex queries. This means that if you have (say) a hash of attribute/value pairs, and some way of knowing whether to use <code>AND</code> or <code>OR</code> on each of them, you can loop through them one by one and build up your condition:

<pre><code>relation = table[:title].eq("Foo")
hash.each do |attr, value|
 relation = relation.and(table[attr].eq(value))
 # or relation = relation.or(table[attr].eq(value)) for an OR predicate
end
Post.where(relation)
</code></pre>

Aside from the ease of chaining conditions, another advantage of arel tables is that they are independent of database, so you don't have to worry whether your MySQL query will work in PostgreSQL, etc.

Here's a Railscast with more on arel: <a href="http://railscasts.com/episodes/215-advanced-queries-in-rails-3?view=asciicast" rel="noreferrer">http://railscasts.com/episodes/215-advanced-queries-in-rails-3?view=asciicast</a>

Hope that helps.

blocks|key|546357|text|您可以使用散列而不是字符串。构建一个包含有多少条件和相应值的散列，并将其放入where方法的第一个参数中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|546358|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You can use a hash rather than a string. Build up a hash with however many conditions and corresponding values you are going to have and put it into the first argument of the where method.

blocks|key|2686584|text|而不是像这样多次将相同的参数传递给where()|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2686585|User.where(
++"first_name+like+?+or+last_name+like+?+or+city+like+?",+
++"%25#{search}%25",+"%25#{search}%25",+"%25#{search}%25"
)|code-block|syntax|javascript|2686586|您可以很容易地提供一个散列。|2686587|User.where(
++"first_name+like+:search+or+last_name+like+:search+or+city+like+:search",
++{search:+"%25#{search}%25"}
)|2686588|这使得您的查询对于长参数列表来说更加可读性。|2686589|entityMap^0|H|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|Y|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

Instead of passing the same parameter multiple times to <code>where()</code> like this

<pre><code>User.where(
 "first_name like ? or last_name like ? or city like ?", 
 "%#{search}%", "%#{search}%", "%#{search}%"
)
</code></pre>

you can easily provide a hash

<pre><code>User.where(
 "first_name like :search or last_name like :search or city like :search",
 {search: "%#{search}%"}
)
</code></pre>

that makes your query much more readable for long argument lists.

blocks|key|566947|text|这其实很简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|566948|Model.where(attribute:+[value1,value2])|code-block|syntax|javascript|566949|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is actually pretty simple:

<pre><code>Model.where(attribute: [value1,value2])
</code></pre>

blocks|key|2686628|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2686629|听起来像是在做这样的事情：|blockquote|2686630|2686631|Model.where(“属性=？或attribute2+=+?"，值、值)|2686632|然而，你需要这样做：|2686633|#注意缺少数组，因为最后一个参数Model.where(“attribute2+=？或attribute2=+?"，value，value)有一个|2686634|有关如何工作的更多细节，请查看http://guides.rubyonrails.org/active_record_querying.html#array-conditions。|offset|length|2686635|2686636|真的很接近。可以使用*my_list将数组转换为参数列表。|2686637|Model.where("id+=+?+OR+id+=+?",+*["1",+"2"])|code-block|syntax|javascript|2686638|或|2686639|params+=+["1",+"2"]
Model.where("id+=+?+OR+id+=+?",+*params)|2686640|应起作用|2686641|entityMap|0|LINK|mutability|MUTABLE|url|http://guides.rubyonrails.org/active_record_querying.html#array-conditions^0|0|0|0|0|0|0|F|22|0|0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|1A|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1B|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|1C|7|@]|8|@]|9|$]]|$1|E|3|F|4|5|6|1D|7|@]|8|@]|9|$]]|$1|G|3|H|4|5|6|1E|7|@]|8|@]|9|$]]|$1|I|3|J|4|5|6|1F|7|@]|8|@]|9|$]]|$1|K|3|L|4|5|6|1G|7|@]|8|@$M|1H|N|1I|1|1J]]|9|$]]|$1|O|3|-4|4|5|6|1K|7|@]|8|@]|9|$]]|$1|P|3|Q|4|5|6|1L|7|@]|8|@]|9|$]]|$1|R|3|S|4|T|6|1M|7|@]|8|@]|9|$U|V]]|$1|W|3|X|4|5|6|1N|7|@]|8|@]|9|$]]|$1|Y|3|Z|4|T|6|1O|7|@]|8|@]|9|$U|V]]|$1|10|3|11|4|5|6|1P|7|@]|8|@]|9|$]]|$1|12|3|-4|4|5|6|1Q|7|@]|8|@]|9|$]]]|13|$14|$4|15|16|17|9|$18|19]]]]

<blockquote>
 Sounds like you're doing something like this:

<pre><code>Model.where("attribute = ? OR attribute2 = ?", [value, value])
</code></pre>
 
 Whereas you need to do this:

<pre><code>#notice the lack of an array as the last argument
Model.where("attribute = ? OR attribute2 = ?", value, value) Have a
</code></pre>
 
 look at
 <a href="http://guides.rubyonrails.org/active_record_querying.html#array-conditions" rel="noreferrer">http://guides.rubyonrails.org/active_record_querying.html#array-conditions</a>
 for more details on how this works.
</blockquote>

Was really close. You can turn an array into a list of arguments with *my_list.

<pre><code>Model.where("id = ? OR id = ?", *["1", "2"])
</code></pre>

OR

<pre><code>params = ["1", "2"]
Model.where("id = ? OR id = ?", *params)
</code></pre>

Should work

blocks|key|566974|text|错误，，这是我过去出于某种原因所做的事情。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|566975|keys+=+params[:search].split(',').map!(&:downcase)
#+keys+are+now+['brooklyn',+'queens']

query+=+'lower(city)+LIKE+?'

if+keys.size+>+1
++#+I+need+something+like+this+depending+on+number+of+keys+
++#+'lower(city)+LIKE+?+OR+lower(city)+LIKE+?+OR+lower(city)+LIKE+?'
+query_array+=+[]
+keys.size.times+{+query_array+<<+query+}
+#['lower(city)+LIKE+?','lower(city)+LIKE+?']
+query+=+query_array.join('+OR+')
+#+which+gives+me+'lower(city)+LIKE+?+OR+lower(city)+LIKE+?'
end
#+now+I+can+query+my+model
#+if+keys+size+is+one+then+keys+are+just+'brooklyn',+
#+in+this+case+it+is++'brooklyn',+'queens'
#+@posts+=+Post.where('lower(city)+LIKE+?+OR+lower(city)+LIKE+?','brooklyn',+'queens'+)
@posts+=+Post.where(query,+*keys+)|code-block|syntax|javascript|566976|但现在-是的-这很简单。正如nfriend21所提到的|566977|Model.where(attribute:+[value1,value2])|CODE|566978|做同样的事|566979|entityMap^0|0|3|0|0|0|0|13|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|W|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|X|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|Y|8|@$9|Z|A|10|B|O]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|11|8|@]|D|@]|E|$]]|$1|R|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|S|$]]

WRONG 
This is what I used to do for some reason.

<pre><code>keys = params[:search].split(',').map!(&amp;:downcase)
# keys are now ['brooklyn', 'queens']

query = 'lower(city) LIKE ?'

if keys.size &gt; 1
 # I need something like this depending on number of keys 
 # 'lower(city) LIKE ? OR lower(city) LIKE ? OR lower(city) LIKE ?'
 query_array = []
 keys.size.times { query_array &lt;&lt; query }
 #['lower(city) LIKE ?','lower(city) LIKE ?']
 query = query_array.join(' OR ')
 # which gives me 'lower(city) LIKE ? OR lower(city) LIKE ?'
end
# now I can query my model
# if keys size is one then keys are just 'brooklyn', 
# in this case it is 'brooklyn', 'queens'
# @posts = Post.where('lower(city) LIKE ? OR lower(city) LIKE ?','brooklyn', 'queens' )
@posts = Post.where(query, *keys )
</code></pre>

now however - yes - it's very simple. as nfriend21 mentioned 

<code>Model.where(attribute: [value1,value2])</code> 

does the same thing

Per section 2.2 of rails guide on Active Record query interface <a href="http://guides.rubyonrails.org/active_record_querying.html#conditions">here</a>:

which seems to indicate that I can pass a string specifying the condition(s), then an array of values that should be substituted at some point while the arel is being built. So I've got a statement that generates my conditions string, which can be a varying number of attributes chained together with either AND or OR between them, and I pass in an array as the second arg to the where method, and I get:

<blockquote>
 ActiveRecord::PreparedStatementInvalid: wrong number of bind variables (1 for 5)
</blockquote>

which leads me to believe I'm doing this incorrectly. However, I'm not finding anything on how to do it correctly. To restate the problem another way, I need to pass in a string to the where method such as "table.attribute = ? AND table.attribute1 = ? OR table.attribute1 = ?" with an unknown number of these conditions anded or ored together, and then pass something, what I thought would be an array as the second argument that would be used to substitute the values in the first argument conditions string. Is this the correct approach, or, I'm just missing some other huge concept somewhere and I'm coming at this all wrong? I'd think that somehow, this has to be possible, short of just generating a raw sql string.

How to specify multiple values in where with AR query interface in rails3

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

rails指南中关于活动记录查询接口的2.2节这似乎表明，我可以传递一个字符串，指定条件，然后是一个值数组，在构建arel时，这些值应该在某个时候被替换。因此，我有一个语句来生成我的条件字符串，它可以是与它们之间的和和或链接在一起的不同数量的属性，我把一个数组作为第二个arg传递给where方法，然后我得到： Acti...

问如何在rails3中使用AR查询接口在where中指定多个值
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在rails3中使用AR查询接口在where中指定多个值EN