标签: fetching-strategy

我试图理解LEFT JOIN和LEFT JOIN FETCHHibernate 之间的区别.

有谁能解释一下？

谢谢

我有时玩过graphQL.在graphQL之前,我们通常使用REST API.许多开发人员说graphQL修复了REST的一些问题.(例如过度提取和欠读).我对这些条款感到困惑.

在这种情况下,有人可以解释什么是过度和不足？

谢谢,

我有一个3级实体层次结构:Customer-Order-Line,我想使用ISession.Get(id)为给定客户完整检索.我有以下XML片段:

customer.hbm.xml:

<bag name="Orders" cascade="all-delete-orphan" inverse="false" fetch="join">
  <key column="CustomerID" />
  <one-to-many class="Order" />
</bag>

order.hbm.xml:

<bag name="Lines" cascade="all-delete-orphan" inverse="false" fetch="join">
  <key column="OrderID" />
  <one-to-many class="Line" />
</bag>

我使用了fetch ="join"属性来表示我想为每个父项获取子实体,这构造了正确的SQL:

SELECT 
    customer0_.ID AS ID8_2_, 
    customer0_.Name AS Name8_2_, 
    orders1_.CustomerID AS CustomerID__4_, 
    orders1_.ID AS ID4_, 
    orders1_.ID AS ID9_0_, 
    orders1_.PostalAddress AS PostalAd2_9_0_, 
    orders1_.OrderDate AS OrderDate9_0_, 
    lines2_.OrderID AS OrderID__5_, 
    lines2_.ID AS ID5_, 
    lines2_.ID AS ID10_1_, 
    lines2_.[LineNo] AS column2_10_1_, 
    lines2_.Quantity AS Quantity10_1_, 
    lines2_.ProductID AS ProductID10_1_ 

FROM Customer customer0_ 

LEFT JOIN [Order] orders1_ 
       ON customer0_.ID=orders1_.CustomerID 

LEFT JOIN …

有没有办法在不编辑实体对象的情况下在单个方法上更改JPA fetch类型？

我有一个由JPA实体类组成的共享ORM层.该ORM层由两个DAO层访问.一个DAO需要延迟抓取,因为它适用于我的Web应用程序,另一个需要急切的抓取,因为我需要它是线程安全的.

这是我的线程安全DAO的示例方法,

@PersistenceContext(unitName = "PersistenceUnit", type = PersistenceContextType.TRANSACTION)
private EntityManager em;

public ErrorCode findErrorCodeById(short id) {
    return (ErrorCode) em.createNamedQuery("ErrorCode.findById").
            setParameter("id", id).getSingleResult();
}

我如何使这个方法(或整个类)使用渴望获取？

我有一个Hibernate域对象,由应用程序的不同部分加载.有时延迟加载每个关联和其他关联是有利的,最好在一个连接中加载整个事物.作为一个充满希望的妥协,我发现:

使用批量提取,如果访问一个代理,Hibernate可以加载几个未初始化的代理.批量提取是延迟选择提取策略的优化.

hibernate.default_batch_fetch_size:

使用批量提取,如果访问一个代理,Hibernate可以加载几个未初始化的代理.批量提取是延迟选择提取策略的优化.

我也看到:

hibernate.jdbc.fetch_size:

非零值确定JDBC获取大小(调用Statement.setFetchSize()).

Hibernate是否足够聪明,可以在进行批量提取时查看二级缓存？即,一次获取初始调用关联,然后下一个X调用命中缓存？这样我就可以拥有我想要的延迟加载,但也经常点击缓存以获得更大量的交易.

如果集合的整个内容已经包含在缓存中,它是否仍然会在访问集合时执行获取查询？

谢谢.

我正在尝试使用选择急切地获取集合,但我得到的只是内部联接.到底是怎么回事？

Session.CreateCriteria(typeof(Foo))
    .SetFetchMode("Bars", FetchMode.Select)
    .CreateAlias("Bars", "b")
    .SetFetchMode("b.Bazes", FetchMode.Select)
    .List();

我已经尝试将FetchMode更改为Eager但这不起作用 - 我仍然得到内部联接而不是单独选择.我不知道它从哪里获得内部连接,因为文档中没有任何内容涉及FetchMode导致内部连接.是否有可能获得热切的选择？

更新 确定我发现创建别名会导致内部联接.所以我可以使用.CreateAlias("Bars","b",JoinType.None),但随后b.Bazes的获取将恢复为延迟加载.Urgh.

我正在尝试使用NHibernate 3 alpha 1热切地加载所有集合.我想知道这是否正确使用ThenFetch()？

具有多个名称的属性是集合.其他只是一个对象.

            IQueryable<T> milestoneInstances = Db.Find<T, IQueryable<T>>(db =>
            from mi in db
            where mi.RunDate == runDate
            select mi).Fetch(mi => mi.Milestone)
                .ThenFetch(m => m.PrimaryOwners)
                .Fetch(mi => mi.Milestone)
                .ThenFetch(m => m.SecondaryOwners)
                .Fetch(mi => mi.Milestone)
                .ThenFetch(m => m.Predecessors)
                .Fetch(mi => mi.Milestone)
                .ThenFetch(m => m.Function)
                .Fetch(mi => mi.Milestone)
                .ThenFetchMany(m => m.Jobs)
                .ThenFetch(j => j.Source)
                ;

我想在NHibernate论坛上问这个问题,但不幸的是,我禁止访问google群组.我知道Fabio在这里,所以也许来自NHibernate团队的人可以对此有所了解吗？谢谢

我在"Manning-Java Persistence with Hibernate"中找到了批量获取算法的描述:

什么是真正的批量获取算法？(...)想象一下,批量大小为20,总共有119个未初始化的代理需要批量加载.在启动时,Hibernate读取映射元数据并在内部创建11个批处理加载器.每个加载器知道它可以初始化多少代理:20,10,9,8,7,6,5,4,3,2,1.目标是最小化加载器创建的内存消耗并创建足够的每个加载器可以生成可能的批量提取.另一个目标是显着减少SQL SELECT的数量.要初始化119个代理,Hibernate会执行7个批处理(你可能预计会有6个,因为6 x 20> 119).应用的批处理加载程序是Hibernate自动选择的五倍20倍,一倍10倍和一倍9倍.

但我仍然不明白它是如何工作的.

1. 为什么11批装载机？
2. 为什么批量加载器可以初始化:20,10,9,8,7,6,5,4,3,2,1代理？

如果有人可以提出一步一步的算法...... :)

我有这个对象图:

// Lots of stuff omitted for brevity; these are all virtual properties and there
// are other properties which aren't shown on all classes.
class A {
    B b;
    C c;
    DateTime timestamp;
}
class B {
    X x;
    Y y;
}
class X {
    int id;
}
class C { }
class Y { }

or to put it more simply,
a = {
   b: {
      x { id: int },
      y: { }
   },
   c: { }, …

我想获取iOS设备上固定批量的图片.我正在使用新的Photos Framework,我已经找到了这个解决方法:

PHFetchOptions *allPhotosOptions = [PHFetchOptions new];

allPhotosOptions.sortDescriptors = @[[NSSortDescriptor sortDescriptorWithKey:@"creationDate" ascending:NO]];

// Fetches all photos -> i would like to fetch only some of them
PHFetchResult *allPhotosResult = [PHAsset fetchAssetsWithMediaType:PHAssetMediaTypeImage options:allPhotosOptions];

NSIndexSet *indexSet = [NSIndexSet indexSetWithIndexesInRange:NSMakeRange(currentIndex, batch_size)];

// Iterates over a subset of the previously fetched photos
[allPhotosResult enumerateObjectsAtIndexes:indexSet options:0 usingBlock:^(PHAsset *asset, NSUInteger idx, BOOL *stop)
{
    // Do stuff    
}

它工作正常,但我首先获取所有照片,fetchAssetsWithMediaType然后选择我的应用程序加载的结果的子集,这似乎很重...

我想知道是否有一种方法可以批量直接获取照片,而不是全部获取它们然后迭代.此外,如果我能保留上次获取的批次的索引,知道我将在哪里获取下一批次,那将是完美的.

谢谢你的帮助!