例如,我有一个博客对象,该博客有很多帖子.我想做第一个博客对象的热切加载,并包括说出它的前10个帖子.目前我会做@blogs = Blog.limit(4),然后在视图中使用@blogs.posts.limit(10).我很确定有一种更好的方法可以通过包括诸如此类的包含来实现Blog.include(:posts).limit(:posts=>10).是不是可以限制包含的对象的数量,还是我错过了一些基本的东西？

我的rails 4.1 app通过SSH连接到第二台非主服务器,用于后端作业.因此,当rails应用程序每天重新启动时,SSH连接需要处于活动状态(而非第二个非主服务器需要生存/启动),否则应用程序崩溃.这是由于默认情况下急切加载在production.rb(config.eager_load = true)中设置为true .

我很想通过禁用急切负载来打破这种依赖关系,但我无法找到有关性能影响的大量信息.所以,我的问题是......

1)如果eager_load设置为false,那么这会简化应用程序的启动时间,还是应用程序会在第一次启动时急切地加载资源？

3)如果eager_load只是关闭,这将在多大程度上影响应用程序的性能(更主观的问题)？

2)执行SSH连接的模型位于文件夹下app\models\legacy.而不是更改eager_load为false,该文件夹是否可以从急切加载的资源中排除？如果是这样,怎么样？我相信我需要编辑config.autoload_paths += Dir[Rails.root.join('app', 'models', '{**/}')]但不完全确定.

production.rb:

  # Eager load code on boot. This eager loads most of Rails and
  # your application in memory, allowing both thread web servers
  # and those relying on copy on write to perform better.
  # Rake tasks automatically ignore this option for performance.
  config.eager_load = true

我有一个案例,大多数情况下,对象之间的关系是这样的,即预先配置对关系的热切(加入)负载是有意义的.但是现在我遇到了一种我真的不希望完成负载的情况.

我应该从关系中删除已加入的加载并更改所有相关查询以在查询位置(ick)加入,还是有某种方法可以在查询设置后抑制查询中的急切加载？

下面是一个示例,其中已在User-> Address关系上设置了预先加载.程序末尾的查询是否可以配置为不急于加载？

import sqlalchemy as sa
from sqlalchemy.ext.declarative import declarative_base
import sqlalchemy.orm as orm

##Set up SQLAlchemy for declarative use with Sqlite...
engine = sa.create_engine("sqlite://", echo = True)
DeclarativeBase = declarative_base()
Session = orm.sessionmaker(bind = engine)

class User(DeclarativeBase):
    __tablename__ = "users"
    id = sa.Column(sa.Integer, primary_key = True, autoincrement = True)
    name = sa.Column(sa.String, unique = True)
    addresses = orm.relationship("Address",
                                 lazy = "joined", #EAGER LOAD CONFIG IS HERE
                                 )
    def __init__(self, Name):
        self.name = Name

class Address(DeclarativeBase):
    __tablename__ = …

我正在使用一个暴露IQueryable<T>这样的通用存储库:

public IQueryable<T> AllEntities
{
    get
    {
        return session.Query<T>();
    }
}

我可以像这样查询:

var results =
    (from e in repository.AllEntities
     where e.SomeProperty == "some value"
     select e).ToList();

但是,如果T有父母和祖父母实体并且我想急切地加载它们,我必须这样做:

var results =
    (from e in repository.AllEntities
     where e.SomeProperty == "some value"
     select e)
    .Fetch(x => x.Parent)
    .ThenFetch(x => x.Grandparent)
    .ToList();

这工作,但.Fetch并.ThenFetch都Linq2Nhibernate特定扩展方法,这是造成两个问题:

1. 我必须using NHibernate.Linq;在我的文件顶部包含一个声明.但是,在我正在进行此查询时,它应该是与实现无关的.

2. 当我尝试对此进行单元测试时,.Fetch和我的模拟存储库提供的.ThenFetch方法相比,和方法失败IQueryable<T>了.

如何将这些内容包装在我的IRepository<T>界面内或某些通用扩展方法中？

更新:

到目前为止,我所提出的是将其添加到我的存储库界面:

IQueryable<T> EagerLoadParent<U>(IQueryable<T> query, 
    Expression<Func<T, U>> parentExpression);
IQueryable<T> …

这与一年前的一个问题有关.

我提出了一个开箱即用的问题示例,只要你有sqlite3可用:https://github.com/cairo140/rails-eager-loading-counts-demo

安装说明(主分支)

git clone git://github.com/cairo140/rails-eager-loading-counts-demo.git
cd rails-eager-loading-counts-demo
rails s

我在存储库中有更全面的文章,但我的一般问题是这个.

如何以最小化数据库查询的方式使Rails急切加载计数？

尽管在ActiveRelation 中包含了该关联,但n+1只要您#count在关联上使用该问题就会出现问题#includes(:associated).一种解决方法是使用#length,但只有当它被调用的对象已被加载时才能正常工作,更不用说我怀疑它复制了Rails内部已经完成的东西.此外,使用的一个问题#length是,当开始时没有加载关联时,它会导致不幸的过载,并且只需要计数.

从自述文件:

我们可以通过在posts数组上运行#length来解决这个问题(参见附录),这已经加载了,但是也可以随时使用.它不仅更加一致; 它提供了一个访问路径,不一定需要加载帖子.例如,如果你有一个部分显示计数,无论什么,但一半的时间,部分是在加载帖子和一半时间没有调用,你面临以下情况:

• 运用 #count
  • n COUNT已经加载帖子时的样式查询
  • n COUNT尚未加载帖子时的样式查询
• 运用 #length
  • 在已加载帖子时将其他查询归零
  • n *尚未加载帖子时的样式查询

在这两种选择之间,没有主导选择.但是修改#count来推迟#length或访问存储在幕后的其他方式的长度会很好,这样我们就可以得到以下场景:

• 使用修改 #count
  • 在已加载帖子时将其他查询归零
  • n COUNT尚未加载帖子时的样式查询

那么这里的正确方法是什么？有没有我忽略的东西(非常非常可能)？

领域模型

我有一个Customer很多的规范领域Orders,每个Order都有很多OrderItems:

顾客

public class Customer
{
  public Customer()
  {
    Orders = new HashSet<Order>();
  }
  public virtual int Id {get;set;}
  public virtual ICollection<Order> Orders {get;set;}
}

订购

public class Order
{
  public Order()
  {
    Items = new HashSet<OrderItem>();
  }
  public virtual int Id {get;set;}
  public virtual Customer Customer {get;set;}
}

的OrderItems

public class OrderItem
{
  public virtual int Id {get;set;}
  public virtual Order Order {get;set;}
}

问题

无论是使用FluentNHibernate还是hbm文件映射,我都运行两个单独的查询,它们的Fetch()语法相同,但包含.First()扩展方法的查询除外.

返回预期结果:

var customer = …

我在我的Rails应用程序中使用Devise进行身份验证.我想在我的一些控制器中加载一些用户相关模型.像这样的东西:

class TeamsController < ApplicationController

  def show
    @team = Team.includes(:members).find params[:id]
    current_user.includes(:saved_listings)

    # normal controller stuff
  end
end

我怎样才能做到这一点？

我有一个文档生成器,目前包含大约200个项目的查询,但完成后可能会超过500个.我最近注意到一些映射表示延迟加载.这给文档生成器带来了问题,因为它需要根据生成的文档访问所有这些属性.

虽然我知道DataLoadOptions可以在上下文中指定,但这会导致我必须明确指定可能加载的每一列.这是1000的北方,因为所有数据提取都发生在一个上下文中.

有没有办法让我为上下文禁用延迟加载或显式启用急切加载以忽略延迟加载属性？也许扩展DB上下文类并覆盖一些东西？

背景

我有一个带有深层嵌套关联的rails应用程序.

                          .-< WorkPeriod
Timecard -< Week -< Day -<--< Subtotal
                          `-< Adjustment

-<  (has many)

我正在使用Active Model Serializer来构建API.

在客户端,我想一次性加载时间卡和所有关联.

目前我的序列化器看起来像这样,

class TimecardSerializer < ActiveModel::Serializer
  embed :ids, include: true
  has_many :weeks
end
class WeekSerializer < ActiveModel::Serializer
  embed :ids, include: true
  has_many :days
end
# ... etc ...

问题

这一切都找到了,除了没有什么急于加载.因此,它最终会针对每个请求对数据库进行大量调用.对于每周,它会单独请求该周的日期.并且对于每一天,它单独请求它的work_periods,小计和调整.

尽管FetchType.EAGER和JOIN FETCH,我得到一个LazyInitalizationException,同时增加一些对象,以一个@ManyToMany通过收集JSF UISelectMany组件,如我的情况<p:selectManyMenu>.

的@Entity IdentUser,有FetchType.EAGER:

@Column(name = "EMPLOYERS")
@ManyToMany(fetch = FetchType.EAGER, cascade= CascadeType.ALL)
@JoinTable(name = "USER_COMPANY", joinColumns = { @JoinColumn(name = "USER_ID") }, inverseJoinColumns = { @JoinColumn(name = "COMPANY_ID") })
private Set<Company> employers = new HashSet<Company>();

的@Entity Company,有FetchType.EAGER:

@ManyToMany(mappedBy="employers", fetch=FetchType.EAGER)
private List<IdentUser> employee;

JPQL,包含JOIN FETCH:

public List<IdentUser> getAllUsers() {
    return this.em.createQuery("from IdentUser u LEFT JOIN FETCH u.employers WHERE u.enabled …