ruby-on-rails – 当包含预缓存时,Rails忽略关联范围

分类：Ruby作者：编程之家用户
TL; DR：这个问题在 https://github.com/skensell/SO-question-example有自己的示例应用程序,您可以使用它来调试自己.我在这个问题上已经有了一次赏金,但我不相信(或我不明白)最高回答者的推理.我会再给他一个赏金,因为这让我感到很沮丧.

原题

我有一个模型用户具有如下所示的关联：

has_many :avatars,-> { order([:sort_order => :asc,:created_at => :asc])}

我有一个端点执行搜索用户,并设置一个@users变量供视图使用.这是我在调试器中发现的幽灵部分：

@users.first.avatars[0..2].map(&:id)
# => [2546,2547,2548]
# This is the correct order.

@users.to_a.first.avatars[0..2].map(&:id)
# => [2548,2546,2547]
# Wrong order.

这里发生了什么？

唯一的区别是to_a.我甚至试图放弃to_a,但是我认为这是由jbuilder自动调用的,因为我把它设置为一个json数组.

也许我正在搜索的方式用户有什么关系吗？我正在使用几个包含和连接.

UPDATE

在这里,我可以从rails控制台向您显示一个这个奇怪行为的简单例子.看来,包括…是对罪犯的引用,但我不知道为什么或如何.

User.order(id: :desc)
    .includes(:avatars,:industries)
    .where(industries: {id:  [5]})
    .references(:industries)
    .limit(5).to_a.second.avatars.map(&:id)
# => [2751,2748,2749]
# Wrong order.

User.order(id: :desc)
    .includes(:avatars,:industries)
    .where(industries: {id:  [5]})
    .references(:industries)
    .limit(5).second.avatars.map(&:id)
# => [2748,2749,2751]
# Correct order.

我可以验证这些查询是指相同的用户,并且标记为正确的顺序的那个确实是正确的w.r.t sort_order和created_at(这是关联如何指定排序).

更新2

附加的是所请求的SQL日志.我将不相关的字段更改为“OMITTED”,我用“…”替换了34个不相关的用户字段.

>> User.order(id: :desc).includes(:avatars,:industries).where(industries: {id:  [5]}).references(:industries).limit(5).to_a.second.avatars.map(&:id)
SQL (18.5ms)  SELECT  DISTINCT "users"."id","users"."id" AS alias_0 FROM "users" LEFT OUTER JOIN "avatars" ON "avatars"."user_id" = "users"."id" LEFT OUTER JOIN "user_professions" ON "user_professions"."user_id" = "users"."id" LEFT OUTER JOIN "industries" ON "industries"."id" = "user_professions"."industry_id" WHERE "industries"."id" IN (5)  ORDER BY "users"."id" DESC LIMIT 5
SQL (8.3ms)  SELECT "users"."id" AS t0_r0,"users"."OMITTED" AS t0_r1,"users"."OMITTED" AS t0_r2,... AS t0_r36,"avatars"."id" AS t1_r0,"avatars"."user_id" AS t1_r1,"avatars"."avatar" AS t1_r2,"avatars"."created_at" AS t1_r3,"avatars"."updated_at" AS t1_r4,"avatars"."OMITTED" AS t1_r5,"avatars"."OMITTED" AS t1_r6,"avatars"."sort_order" AS t1_r7,"industries"."id" AS t2_r0,"industries"."name" AS t2_r1,"industries"."created_at" AS t2_r2,"industries"."updated_at" AS t2_r3 FROM "users" LEFT OUTER JOIN "avatars" ON "avatars"."user_id" = "users"."id" LEFT OUTER JOIN "user_professions" ON "user_professions"."user_id" = "users"."id" LEFT OUTER JOIN "industries" ON "industries"."id" = "user_professions"."industry_id" WHERE "industries"."id" IN (5) AND "users"."id" IN (1526,945,927,888,884)  ORDER BY "users"."id" DESC
=> [2751,2749]

>> User.order(id: :desc).includes(:avatars,:industries).where(industries: {id:  [5]}).references(:industries).limit(5).second.avatars.map(&:id)
SQL (0.9ms)  SELECT  DISTINCT "users"."id","users"."id" AS alias_0 FROM "users" LEFT OUTER JOIN "avatars" ON "avatars"."user_id" = "users"."id" LEFT OUTER JOIN "user_professions" ON "user_professions"."user_id" = "users"."id" LEFT OUTER JOIN "industries" ON "industries"."id" = "user_professions"."industry_id" WHERE "industries"."id" IN (5)  ORDER BY "users"."id" DESC LIMIT 1 OFFSET 1
SQL (0.8ms)  SELECT "users"."id" AS t0_r0,"industries"."updated_at" AS t2_r3 FROM "users" LEFT OUTER JOIN "avatars" ON "avatars"."user_id" = "users"."id" LEFT OUTER JOIN "user_professions" ON "user_professions"."user_id" = "users"."id" LEFT OUTER JOIN "industries" ON "industries"."id" = "user_professions"."industry_id" WHERE "industries"."id" IN (5) AND "users"."id" IN (945)  ORDER BY "users"."id" DESC
=> [2748,2751]
>>

在这里我将附加一个日志,显示有问题的用户头像(id,sort_order和created_at),以便您可以看到订单应该是确定性的.

>> User.find(945).avatars.pluck(:id,:sort_order,:created_at)
User Load (5.3ms)  SELECT  "users".* FROM "users"  WHERE "users"."id" = $1 LIMIT 1  [["id",945]]
(0.2ms)  SELECT "avatars"."id","avatars"."sort_order","avatars"."created_at" FROM "avatars"  WHERE "avatars"."user_id" = $1  ORDER BY "avatars"."sort_order" ASC,"avatars"."created_at" ASC  [["user_id",945]]
=> [[2748,Fri,13 Nov 2015 00:32:53 UTC +00:00],[2749,13 Nov 2015 00:47:02 UTC +00:00],[2751,13 Nov 2015 00:48:05 UTC +00:00]]

另外,我使用的是Rails 4.1.4和Ruby 2.1.10.

更新3

我在这里创建了一个示例应用程序：https://github.com/skensell/SO-question-example.在这个示例应用程序中甚至更陌生的是,to_a甚至不重要.我得到错误的排序,即使只是包括…参考.

解决方法

Includes考虑父表的顺序,只有当它导致连接查询时,才会检索其记录.即在上述情况下,将要跳过化身顺序,并且当包含查询导致连接时将使用用户顺序.您可以向用户添加默认范围并进行确认.

如果您仍然希望按照定义的头像命令对user.avatars进行排序,则需要将连接替换为连接.请注意,使用join将检索重复的用户记录.

按预期方式检索数据的工作解决方案是使用联接并将其包含在一起.

Loading development environment (Rails 4.1.4)
2.2.0 :001 > User.count
(0.1ms)  SELECT COUNT(*) FROM "users"
=> 2 
2.2.0 :002 > User.pluck :id,:name
(0.2ms)  SELECT "users"."id","users"."name" FROM "users"
=> [[1,"John"],[2,"Jill"]] 
2.2.0 :003 > User.first.industries.pluck :id,:name
User Load (0.2ms)  SELECT  "users".* FROM "users"   ORDER BY "users"."id" ASC LIMIT 1
(0.2ms)  SELECT "industries"."id","industries"."name" FROM "industries" INNER JOIN "user_industries" ON "industries"."id" = "user_industries"."industry_id" WHERE "user_industries"."user_id" = ?  [["user_id",1]]
=> [[1,"Art"],"Music"]] 
2.2.0 :004 > User.last.industries.pluck :id,:name
User Load (1.4ms)  SELECT  "users".* FROM "users"   ORDER BY "users"."id" DESC LIMIT 1
(0.2ms)  SELECT "industries"."id",2]]
=> [[1,"Art"]] 
2.2.0 :005 > User.first.avatars.pluck :id,:sort_order
User Load (0.4ms)  SELECT  "users".* FROM "users"   ORDER BY "users"."id" ASC LIMIT 1
(0.3ms)  SELECT "avatars"."id","avatars"."sort_order" FROM "avatars"  WHERE "avatars"."user_id" = ?  ORDER BY "avatars"."sort_order" ASC,0],[3,1],2]] 
2.2.0 :006 > User.last.avatars.pluck :id,:sort_order
User Load (4.1ms)  SELECT  "users".* FROM "users"   ORDER BY "users"."id" DESC LIMIT 1
(0.2ms)  SELECT "avatars"."id",2]]
=> [[4,5],[6,6],[5,7]] 
2.2.0 :007 > ap User.joins(:avatars,:industries).where(industries: {id: [1]}).references(:industries).count
(0.2ms)  SELECT COUNT(*) FROM "users" INNER JOIN "avatars" ON "avatars"."user_id" = "users"."id" INNER JOIN "user_industries" ON "user_industries"."user_id" = "users"."id" INNER JOIN "industries" ON "industries"."id" = "user_industries"."industry_id" WHERE "industries"."id" IN (1)
6
=> nil 
2.2.0 :008 > ap User.joins(:avatars,:industries).where(industries: {id: [1]}).references(:industries).uniq.count
(0.3ms)  SELECT DISTINCT COUNT(DISTINCT "users"."id") FROM "users" INNER JOIN "avatars" ON "avatars"."user_id" = "users"."id" INNER JOIN "user_industries" ON "user_industries"."user_id" = "users"."id" INNER JOIN "industries" ON "industries"."id" = "user_industries"."industry_id" WHERE "industries"."id" IN (1)
2
=> nil 
2.2.0 :009 > ap User.joins(:industries).where(industries: {id: [1]}).references(:industries).count
(0.3ms)  SELECT COUNT(*) FROM "users" INNER JOIN "user_industries" ON "user_industries"."user_id" = "users"."id" INNER JOIN "industries" ON "industries"."id" = "user_industries"."industry_id" WHERE "industries"."id" IN (1)
2
=> nil 
 2.2.0 :010 > User.joins(:industries).where(industries: {id: [1]}).references(:industries).each{|user| ap user.avatars }
User Load (0.3ms)  SELECT "users".* FROM "users" INNER JOIN "user_industries" ON "user_industries"."user_id" = "users"."id" INNER JOIN "industries" ON "industries"."id" = "user_industries"."industry_id" WHERE "industries"."id" IN (1)
Avatar Load (0.2ms)  SELECT "avatars".* FROM "avatars"  WHERE "avatars"."user_id" = ?  ORDER BY "avatars"."sort_order" ASC,1]]
[
  [0] #<Avatar:0x007ff03f8ab448> {
            :id => 1,:user_id => 1,:sort_order => 0,:created_at => Tue,04 Oct 2016 07:05:36 UTC +00:00,:updated_at => Tue,04 Oct 2016 07:05:44 UTC +00:00
},[1] #<Avatar:0x007ff03ec7e4e0> {
            :id => 3,:sort_order => 1,04 Oct 2016 07:05:40 UTC +00:00,04 Oct 2016 07:05:40 UTC +00:00
},[2] #<Avatar:0x007ff03ec7e2d8> {
            :id => 2,:sort_order => 2,04 Oct 2016 07:05:38 UTC +00:00,04 Oct 2016 07:05:42 UTC +00:00
}
]
Avatar Load (0.2ms)  SELECT "avatars".* FROM "avatars"  WHERE "avatars"."user_id" = ?  ORDER BY "avatars"."sort_order" ASC,2]]
[
  [0] #<Avatar:0x007ff03f9121e8> {
            :id => 4,:user_id => 2,:sort_order => 5,04 Oct 2016 07:05:44 UTC +00:00,04 Oct 2016 07:05:48 UTC +00:00
},[1] #<Avatar:0x007ff03f911fe0> {
            :id => 6,:sort_order => 6,04 Oct 2016 07:05:48 UTC +00:00,[2] #<Avatar:0x007ff03f911dd8> {
            :id => 5,:sort_order => 7,04 Oct 2016 07:05:46 UTC +00:00,04 Oct 2016 07:05:48 UTC +00:00
}
]
=> [#<User id: 1,name: "John",created_at: "2016-10-04 07:05:40",updated_at: "2016-10-04 07:05:40">,#<User id: 2,name: "Jill",created_at: "2016-10-04 07:05:48",updated_at: "2016-10-04 07:05:48">] 
2.2.0 :011 > User.joins(:industries).where(industries: {id: [1]}).references(:industries).includes(:avatars).each{|user| ap user.avatars }

User Load (0.3ms)  SELECT "users".* FROM "users" INNER JOIN "user_industries" ON "user_industries"."user_id" = "users"."id" INNER JOIN "industries" ON "industries"."id" = "user_industries"."industry_id" WHERE "industries"."id" IN (1)
Avatar Load (0.2ms)  SELECT "avatars".* FROM "avatars"  WHERE "avatars"."user_id" IN (1,2)  ORDER BY "avatars"."sort_order" ASC,"avatars"."created_at" ASC
[
  [0] #<Avatar:0x007ff03c7f0df8> {
            :id => 1,[1] #<Avatar:0x007ff03c7f0bf0> {
            :id => 3,[2] #<Avatar:0x007ff03c7f09c0> {
            :id => 2,04 Oct 2016 07:05:42 UTC +00:00
}
]
[
[0] #<Avatar:0x007ff03c7f07b8> {
            :id => 4,[1] #<Avatar:0x007ff03c7f0588> {
            :id => 6,[2] #<Avatar:0x007ff03c7f0380> {
            :id => 5,updated_at: "2016-10-04 07:05:48">]

基本上,我们有2个加载功能：预加载和eager_load.当您使用include时,它可以调用preload或eager_load.预加载导致2个查询(查找用户和检索用户的替身)wheres eager_load仅使用1个查询(连接查询).因此,当包含连接查询中的结果(即,结果为eager_load)时,从单个查询中跳过要检索的关联的顺序.

User.includes(:avatars,:industries).where(industries: {id: [1]}).references(:industries)

导致加入,因为您正在基于本身是“通过”关联的特定行业过滤用户. ‘through’使用连接.另外,请记住,’join’结果是INNER JOIN,而eager_load使用LEFT OUTER JOIN.

2.2.0 :050 > User.joins(:industries).where(industries: {id: [1]}).references(:industries)
User Load (0.2ms)  SELECT "users".* FROM "users" INNER JOIN "user_industries" ON "user_industries"."user_id" = "users"."id" INNER JOIN "industries" ON "industries"."id" = "user_industries"."industry_id" WHERE "industries"."id" IN (1)
=> #<ActiveRecord::Relation [#<User id: 1,updated_at: "2016-10-04 

2.2.0 :054 >   User.includes(:industries).where(industries: {id: [1]}).references(:industries)
SQL (0.3ms)  SELECT "users"."id" AS t0_r0,"users"."name" AS t0_r1,"users"."created_at" AS t0_r2,"users"."updated_at" AS t0_r3,"industries"."id" AS t1_r0,"industries"."name" AS t1_r1,"industries"."created_at" AS t1_r2,"industries"."updated_at" AS t1_r3 FROM "users" LEFT OUTER JOIN "user_industries" ON "user_industries"."user_id" = "users"."id" LEFT OUTER JOIN "industries" ON "industries"."id" = "user_industries"."industry_id" WHERE "industries"."id" IN (1)
=> #<ActiveRecord::Relation [#<User id: 1,updated_at: "2016-10-04 07:05:48">]> 

2.2.0 :057 >   User.eager_load(:industries).where(industries: {id: [1]}).references(:industries)
SQL (0.3ms)  SELECT "users"."id" AS t0_r0,"industries"."updated_at" AS t1_r3 FROM "users" LEFT OUTER JOIN "user_industries" ON "user_industries"."user_id" = "users"."id" LEFT OUTER JOIN "industries" ON "industries"."id" = "user_industries"."industry_id" WHERE "industries"."id" IN (1)

=> #<ActiveRecord::Relation [#<User id: 1,updated_at: "2016-10-04 07:05:48">]>

您可以参考http://blog.arkency.com/2013/12/rails4-preloading/了解更多示例.我没有发现为什么连接的类型是不同的.无论如何,我希望这有帮助.我会尝试为稍后版本的rails重现相同的.

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

ruby on rails validates
validates:conclusion,:presence=>true,:inclusion=>{:in=>[0,1]}validates:email,:presence=>true,:length=>{:minimum=>3,:maximum=>254},:uniqueness=>true,:email=>truevalidates:ending_order,
redis 集群搭建
一、redis集群搭建redis3.0以前，提供了Sentinel工具来监控各Master的状态，如果Master异常，则会做主从切换，将Slave作为master，将master做为slave。其配置也较复杂，且表现一般。redis3.0以后已经支持集群容错功能，并且非常简单1.1素材准备centos7（集群搭建，至少三个master。需
如何让ruby中的ri起作用
分享一下我老师大神的人工智能教程。零基础！通俗易懂！风趣幽默！还带黄段子！希望你也加入到我们人工智能的队伍中来！https://blog.csdn.net/jiangjunshow                 不知道大家是否注意到，全新安装ruby之后，无论是在windows或是linux还是macosX下使用rix
ruby方法名之命名方式
上一篇博文 ruby传参之引用类型 里边定义了一个方法名 modify_my_object!，这个方法名是以!结尾，在ruby的对象里边是用于表达修改本身的意思。比如String#gsub，返回的是一个新的字符串对象；而String#gsub!，返回的是自身已经被修改的对象。不止!这样的特殊字符可以命名，ruby
python入门
一编程与编程语言 什么是编程语言？ 能够被计算机所识别的表达方式即编程语言,语言是沟通的介质，而编程语言是程序员与计算机沟通的介质。 什么是编程？ 编程即程序员根据需求把自己的思想流程按照某种编程语言的语法风格编写下来，产出的结果就是包含一堆字符的文件。二编程语言分
雷林鹏分享：Ruby 类和对象
Ruby类和对象Ruby是一种完美的面向对象编程语言。面向对象编程语言的特性包括：数据封装数据抽象多态性继承这些特性将在面向对象的Ruby中进行讨论。一个面向对象的程序，涉及到的类和对象。类是个别对象创建的蓝图。在面向对象的术语中，您
极客时间
1.ruby的标签<ruby>漢<rp>(<p><rt>han<t><rp>)<p>字<rp>(<p><rt>zi<t><rp>)<p><uby> 
Redis安装及单机集群搭建总结(多节点搭建集群和单机集群大同小异)
1、软件安装1.安装包是个压缩包-->解压到/homeedis_tar下命令如下： tar-zxvf./../-C/homeedis_tar2.安装c++环境yum-yinstallgcc-c++（注：redis底层源码是c++）3.解压后需要源码编译进入到redis-3.0.0后执行make4.编译完后开始安装需要指定一个安装路径
sass(scss的安装
1.sass基于Ruby语言开发而成，因此安装sass前需要安装Ruby。（注:mac下自带Ruby无需在安装Ruby!）window下安装SASS首先需要安装Ruby，先从官网下载Ruby并安装。安装过程中请注意勾选AddRubyexecutablestoyourPATH添加到系统环境变量。ruby官网：https:/ubyinstaller.org/downloa
从0使用Ruby on Rails打造企业级RESTful API项目实战之我的云音乐
本节对我们项目实现的功能和知识点做一个简单的介绍，因为是RESTfulAPI项目，所以对于后端来说基本上没有什么UI界面可展示，那我们就在关键的点，使用客户端（Android）实现的效果图。课程简介这是一门企业级项目实战课程，目的是从0使用Rails开发一个企业级RESTfulAPI项目；他不能让你年薪30
redis 集群搭建
注意点：1.redis集群至少需要6个节点。2.redis集群至少部署在3台服务器上。3.redis的版本需要在3.0以上。4.需要ruby的支持。步骤：1.安装依赖环境：yuminstallgcc-c++2.下载ruby-2.4.6，编译安装https://cache.ruby-lang.org/pububy/2.4uby-2.4.6.tar.gztarzxf ruby-2.4.6.
ruby – sleep 0有特殊意义吗？
在我的客户项目中,我看到很多睡眠用法0.代码看起来像这样.whiletrue......sleep0end通过阅读SO的一些答案,如this,似乎睡眠0具有一定的意义.我现在想知道的是,在时间片0期间调度其他线程运行(如果它们正在等待运行)是像ruby或python这样的langVM的工作,或者它
Day11 - Ruby的block，proc，lamdba方法比较
前情提要：第11天开始，要更深入Ruby的精髓！Ruby经典面试题目#11Ruby的block，proc，lamdba方法比较？What’sdifferencebetweenblocks，procsandlambdas？block代码内存块代码内存块是用do…end围起来，围出特定一个区域、放代码的地方。就好像跑马拉松一样，道路上会进行交通管制，把参赛者
Linux中Redis集群离线版安装步骤
安装环境及工具系统：RedHatEnterpriseLinuxServer工具：XShell5及Xftp5等远程工具安装包：Ruby-2.4.1及以上       Rubygems-2.6.12及以上       Redis-3.2.8及以上(3.x版本才开始支持集群功能)       Redis-3.0.0-gem及以上（该版本不一定要和red
redis requires ruby version 2.2.2的解决方案
 今天在做Redis的Cluster集群的时候，在执行geminstallredis时，提示如下错误：geminstallredisERROR:Errorinstallingredis:redisrequiresRubyversion>=2.2.2.CentOS7yum库中ruby的版本支持到2.0.0，可gem安装redis需要最低是2.2.2，采用rvm来更新ruby：1
Rails 4 jQuery与javascript冲突
我试图在Rails4中制作应用程序.我正在挣扎.我正在尝试合并一个bootstrap主题,我遇到了供应商javascripts和其余代码的问题.我认为问题可能与在我的application.js中使用jQuery然后使用以’$’符号开头的供应商.js文件有关：$.circleProgress={我刚看过这个：https://learn.jqu
sass环境搭建之node-sass，ruby
该内容全部为搬运，感谢作者的分享~，附有原文链接。使用ruby环境SASS学习系列之(一)---------SASS，SCSS环境搭建(Ruby) 使用node-sassSASS学习系列之(二)---------SASS，SCSS环境搭建(node-sass)通过命令编译：npmrunsassinput.scssoutput.csssass-loader在webpack打包里
我如何使用PHP 5.3 Closures,比如我们在Ruby中使用Blocks
我如何使用PHP5.3Closures,比如我们在Ruby中使用Blocks.我从来没有在Ruby中使用’for’循环,因为使用带有’each”read_all”inject’方法的块.我如何使用像Ruby块这样的PHP5.3闭包,并说再见’for’Loops
redis requires Ruby version &gt;= 2.2.2问题
一、说明：搭建Redis集群时，安装geminstallredis报错： redisrequiresRubyversion>=2.2.2的报错，查了资料发现是Centos默认支持ruby到2.0.0，可gem安装redis需要最低是2.2.2二、解决办法：解决办法是先安装rvm，再把ruby版本提升至2.3.31.安装curlsudoyuminstal
Deepin linux Compass.app安装
compass.app是集成了sass的工具，安装完Compass就能够使用sass。首先，上官网 可以看到官网上推荐的两种sass使用方式，application&commandlineapplication里不仅仅只有Compass，不过现在点击Compass.app进行下载。虽然通常我们说sass运行在Ruby环境下，但Compass.app安装使用并不需要
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot